From a06e3b95d63848287065dbc97d3b9a17e44dce3d Mon Sep 17 00:00:00 2001 From: Klaus2m5 Date: Wed, 18 Dec 2013 11:19:08 +0100 Subject: [PATCH] added binaries Added pre-configured binaries with listing. Loadable from $0000 for full 64k --- bin_files/6502_functional_test.bin | Bin 0 -> 65536 bytes bin_files/6502_functional_test.lst | 13999 ++++++++++++++++++++ bin_files/65C02_extended_opcodes_test.bin | Bin 0 -> 65536 bytes bin_files/65C02_extended_opcodes_test.lst | 11308 ++++++++++++++++ 4 files changed, 25307 insertions(+) create mode 100644 bin_files/6502_functional_test.bin create mode 100644 bin_files/6502_functional_test.lst create mode 100644 bin_files/65C02_extended_opcodes_test.bin create mode 100644 bin_files/65C02_extended_opcodes_test.lst diff --git a/bin_files/6502_functional_test.bin b/bin_files/6502_functional_test.bin new file mode 100644 index 0000000000000000000000000000000000000000..8a20227a6decf69bcdf87155cace7278caa2996a GIT binary patch literal 65536 zcmeI3ZERcTb;rp|k-m~Bijv>tw^(VNln&fLnN!VM+9YxlS900Zb(YTiur0-~LLIun z`LH1aqDXcvO)#P~0g}KDP?ROYR9A=sWvGkTs~dH)1&gx-W4!Irlp~&Ti-P&I8Va&K~C;=d;e|oO>OzXox4{%lzjzfPkL9 z82Zpq%o%Ao9Q&K(x8h&x>5N_eNnz+ve8|Cnv3M-*92z<_gq6VY(2x_eS0wh~*4PrY zyR_6A!`e7Qv7z69?zzN^#pM^h*jUV&j5%|$O3jPoxKJBCHjzzqe8cG*92;-&V)^ek zlz**%mhSzvrZ1P568Srl(=q&5-$1D1K;;0{bi9(tKalid1n-$zS8Xo7RGX@0YZFx^ zs4Btuv=U4!0fli8CV?n%cayC7Z}6Q~MJ6rqnZud~2%GnqQO3uTSMSrt(`-`OcKvKi5Uw_U0YRZA(u2h$kP2}%O9d!03@_SNVyf?SxR1*2Gq@Ho668QsC|Ho4Q^^`ZH^p8pZ z$5UCSE0G_R`jM1(ztTS|^~a?DcT@YEgNgjhDetDzzb50qF8$w-`q`9MQ}w+i{Vz)W zyHdZ9@&=XuL+O7*#$T5D)GF@{rEgm$>hD-3>f5?X^mqFzBHsWENt)Ipg$dC2;<;Xz zHle?lz~%tei;)O}h6vDdWVK8p=q)SDQCnG#I+o>Vton53FXoP$Va{4JHSMj~0) zfM1vIIOW&nI}R!<%aJlxv3t{4Lh3z<-cz)7X!5hUz8PJHhz8k=keNEjCk3BX#A{n& zH~DqsK5*wcd^pu@2*0~hD_$y`CQ$E_`h6c%^%B&lW%gBw79TF`?;Pn4x>e!!dvMEJZcT7&)^59t z`wL%;iDYw&Fn$=u52Als9shK1hDVw_aJqN6SR$Orxm|QXdvbsdKE}c0T5^#N{u`1T zTJky_ya5TF^>j?L-9-m?;h;lH9;bu5AvvHWH|Ss&Bp0=W&Qdx)2;u8mIEhiGQDqCN zEY_&bMVBsCu%ji#3%M4wWq4s0vutbd!uXV_R6h#sm>-3f+>b(?_)$pXM0YA(;GEAh6jsu%w>|{EooL@+vOgO5Z zqo{2(`yQ3viqf-G`pqA1IC{J>K05usQy&#>{x}nVp`DJet0aO^vc@p2W77jOP36MwFqj;|LJ6oYb$ z2$ugZ$iE%_tKm-*e_2d?BKNfDdZIcb>b*c+3-uZ~$)_7=BPObcr8=Y4Yn3`F)jd+( zs@3b1IwjR|5iVp&4GxjH2V`ziN97*4AaavBD)+zzk(<;}xd&u!^!=*d(GeQcSve-Z z?N=Ms29LCmc1^JBSDUmpL)x{$reAH=+E&u8lUm(#Fz>__k=XPcOgwQ#WHvnqGf!L* zsZGzp)Du@kZqsvd#=WN2+V8Y@*uB<>dEf+uw4>np}eSbCbnNP3c%{sL8stt_?30gSXvHjtQ##Wt2QlKe$8%4KtskEbZT(AY;f25V$)vjMN@i_;O>`tdWNwSNU`FRooj zXzj<(g!cXw?7dXe-jAONE&eN5e5t0zA3qb?{7`Or%9*}Hx#c-$`VQrmC!Og#lv|#4 zrtiXxdp^ARg~RUo@a7kK-1FhhFT~vQ;mtSkOamsKsoKOdrJ8uMzJkB`N36}qX6ns9 zVr@P)Qg8kdYxAEnn}5XG{HNsRV~pNfx?hOf+=ehd~c=L27{`@b!^%p)a*1osncyk;Xrf*FBm&##16n$9u_+&Qz>@HHv zr>BGyR2OTn-Fax24DeAz04i}kO6)+1v?wL9Y-8dwI~Tgjme$Z*$HX;uE_8`4tra?P zft?FoUrXzRPF!8Z`xWcrTA$CHp!NC8iCUk}oUrxz%!OrAuF!DQL&PMmrf6_D>JefR zmr~M2JwQz2I!d~z$A|iSroZ}proZ}proZ}pray1S6*ppfJkZaC-eFhVh3!WMug4X) zV3O%a1~2A{`!C7#&CkR$b(?smUK7vMY2wNHe)W$G_yo$^AU7Ew&TU(#-!9YJLTooa z*4wsLzau_qWNWnSZ;foVmMxJ?eAs8=-KS)BJiPG}c98k;-Y_yh9=)rkT9$J=us7=C zLsQ@mESh@HZYtb?%~V2D;ts5`5}F#Vn5IZ8rm513Y09)>Qk`^l*Z`&*CDYahAGuE)J|Q`8+kN6?m(PgxEIE&q=!V`Or1*3=9iZV`Qha4e z@hwYLGc3;=8l&o1M5W`pu*yKhRmUQ*Wo#l(`!q)7p@@say0B6$qRK-N)L3d7n?Pf; zq~Q(a&aQXohQt=oe$b8&3K^WS8I+7V zayJ!N?xq6E-Sq#HZS~1X7S2twaBAagG858`*=lB+!Q8Zs;=ZP!LT9xOvU>^8L%@gxRBl7%NRBa-Uud!4hd{okK!()1OHxzCQ121mL8O+qt=6?$-nXxio0>*&TW#m2 z&V6+dvz1$V2U%OWzrI4{Dz~k+D_6OtI*8uNZL2kZ@yYWo;J?-I$J?7+25)ijxm9Qc z@(uNg)%6ydgnUCSEgn)af`hPQ1TAz&c8oh$tb>qH9YG7b4x(aP1czeRp<@K+V%PB( zEB2!62wK>^=sL7Ta6on)K?^;jDxD)+F{4g1qvzAPb!qp+O6N#Ot*PiugZit&J2)D> zDQ1zv<=SaJMj<73t(Qk&| z^$t}oQOz(!A$CAnMnpi^*#Whk6_BdMr=Z?#s#>f$(W|K~wF^F-a7@KNL&eJWooHK` z8C6ZjC?^pqKteul&2oRLQ zvd}T)6EZ13vpMX&ARg_4I_*a~nf7z{)up}aJ6cNZc~yLReG(ae2cB;$W^WUc(JU#K zdqc_rtyG_Ulls=*4Z70j*;mwu-a)aS`lsa7JI7wT zlbZjslk1C|dgs_b-bqsn80h|KEjs1Yp?@%P>ZF(cMz8&8>YZxp2=JxosS67k!m`jY z)YRerNaqSu59qX?nmTlU`1zHl9#m>iHFYTe0G`oP4=OeNt9t5C_v{Y32Bsd+*G(PT zuY|n)sRwjAubBF$F!h|AddJxJyJ+fPaB_{2Q|}l%*F{qc80h|K>K$_G&?h6OPI~EY z^xB`M-l3+B04>o|7Zx&vWuarJsl$D3#|l#q=(L}jI&@p^S!wD)rS?=)hjIfvqo*EJ zYWn`vp^onjx(22m(AP~J+P09lKlOl4=Uq5JCwmTK-;S|gEN1W>w%BlbxMes4`opcm zS#No`9luWUoZ+^P&dS{j>4jF;?caVFUq@cZCbPqByC9uSFSJyu@XX>)zmOsQaNBJA zoAis-;nvD5CE1Q7cOc0Pk>t3a!iytc7QU2bSLb(k&ZbMP6?Zo49fxcC_SQ;zw$=XI z0h@(%sby)c(6!83fAeiS;nq^hEOkNIF`F@e7uwC=*~~(FiSm_Xn+w^>@I@-}4iveB zBJ;<0=3@P`S3tM z@@T1T`?q>aEe~e8n(%LHwxPfA{@(uKHXG#3S$x$h0MeHjkiN)()S}GTJ)f~aYH|D6 zeu#aLT5Lf25+9^5F(7@B0qKhjNMB??`XV2sFY!V85+9^5@j*(-qv|`*Q?-NmpBk2G zbNZ{(_#Slc(cV+ln^;Nu5`3G(>EgVjqAx;eC|s)K`8A6C4MwN-JPH5&d;hKbGzZYAL)84wc)0b z=2NE~@y*PB`eO5`Dn6~WA{~*DUT$72HT6y0pKtzc{{MlP025#WOn?b60Vco%m;e)C z0!)AjFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@GCcp%k025#WOn?b60Vco%m;e)C z0!)AjFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@GCcp%k025#WOn?b60Vco%m;e)C z0!)AjFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@GCcp%k025#WOn?b60Vco%m;e)C z0!)AjFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@GCcp%k025#WOn?b60Vco%m;e)C z0!)AjFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@GCcp%k025#WOn?b60Vco%m;e)C z0!)AjFaajO1egF5U;<2l2`~XBzyz286JP>NfC(@GCcp%k025#WOn?b6fnP0wneN%{ Hf9U>yF)>V1 literal 0 HcmV?d00001 diff --git a/bin_files/6502_functional_test.lst b/bin_files/6502_functional_test.lst new file mode 100644 index 0000000..9051910 --- /dev/null +++ b/bin_files/6502_functional_test.lst @@ -0,0 +1,13999 @@ +AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 1 +---------------------------------------------------- 6502_functional_test.a65 ---------------------------------------------------- + +5803 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-2013 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 16-aug-2013 + ; edited to provide a pre-configured bin file loadable at $0000 for full 64k + ; 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 + + + ; 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, $5B (91) 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 + ;parts of the code are self modifying and must reside in RAM +0400 = code_segment = $400 + + ;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 + + noopt ;do not take shortcuts + + ;macros for error & success traps to allow user modification + ;example: + ;trap macro + ; jsr my_error_handler + ; endm + ;trap_eq macro + ; bne skip\? + ; trap ;failed equal (zero) + ;skip\? + ; endm + ; + ; my_error_handler should pop the calling address from the stack and report it. + ; putting larger portions of code (more than 3 bytes) inside the trap macro + ; may lead to branch range problems for some tests. + if report = 0 + trap macro + jmp * ;failed anyway + endm + trap_eq macro + beq * ;failed equal (zero) + endm + trap_ne macro + bne * ;failed not equal (non zero) + endm + trap_cs macro + bcs * ;failed carry set + endm + trap_cc macro + bcc * ;failed carry clear + endm + trap_mi macro + bmi * ;failed minus (bit 7 set) + endm + trap_pl macro + bpl * ;failed plus (bit 7 clear) + endm + trap_vs macro + bvs * ;failed overflow set + endm + trap_vc macro + bvc * ;failed overflow clear + endm + ; please observe that during the test the stack gets invalidated + ; therefore a RTS inside the success macro is not possible + success macro + jmp * ;test passed, no errors + endm + endif + if report = 1 + trap macro + jsr report_error + endm + trap_eq macro + bne skip\? + trap ;failed equal (zero) + skip\? + endm + trap_ne macro + beq skip\? + trap ;failed not equal (non zero) + skip\? + endm + trap_cs macro + bcc skip\? + trap ;failed carry set + skip\? + endm + trap_cc macro + bcs skip\? + trap ;failed carry clear + skip\? + endm + trap_mi macro + bpl skip\? + trap ;failed minus (bit 7 set) + skip\? + endm + trap_pl macro + bmi skip\? + trap ;failed plus (bit 7 clear) + skip\? + endm + trap_vs macro + bvc skip\? + trap ;failed overflow set + skip\? + endm + trap_vc macro + bvs skip\? + trap ;failed overflow clear + skip\? + endm + ; please observe that during the test the stack gets invalidated + ; therefore a RTS inside the success macro is not possible + success macro + jsr report_success + endm + endif + + +0001 = carry equ %00000001 ;flag bits in status +0002 = zero equ %00000010 +0004 = intdis equ %00000100 +0008 = decmode equ %00001000 +0010 = break equ %00010000 +0020 = reserv equ %00100000 +0040 = overfl equ %01000000 +0080 = minus equ %10000000 + +0001 = fc equ carry +0002 = fz equ zero +0003 = fzc equ carry+zero +0040 = fv equ overfl +0042 = fvz equ overfl+zero +0080 = fn equ minus +0081 = fnc equ minus+carry +0082 = fnz equ minus+zero +0083 = fnzc equ minus+zero+carry +00c0 = fnv equ minus+overfl + +0030 = fao equ break+reserv ;bits always on after PHP, BRK +0034 = fai equ fao+intdis ;+ forced interrupt disable +00ff = m8 equ $ff ;8 bit mask +00fb = m8i equ $ff&~intdis ;8 bit mask - interrupt disable + + ;macros to allow masking of status bits. + ;masking of interrupt enable/disable on load and compare + ;masking of always on bits after PHP or BRK (unused & break) on compare + if I_flag = 0 + load_flag macro + lda #\1&m8i ;force enable interrupts (mask I) + endm + cmp_flag macro + cmp #(\1|fao)&m8i ;I_flag is always enabled + always on bits + endm + eor_flag macro + eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits + endm + endif + if I_flag = 1 + load_flag macro + lda #\1|intdis ;force disable interrupts + endm + cmp_flag macro + cmp #(\1|fai)&m8 ;I_flag is always disabled + always on bits + endm + eor_flag macro + eor #(\1|fai) ;invert expected flags + always on bits + I + endm + endif + if I_flag = 2 + load_flag macro + lda #\1 + ora flag_I_on ;restore I-flag + and flag_I_off + endm + cmp_flag macro + eor flag_I_on ;I_flag is never changed + cmp #(\1|fao)&m8i ;expected flags + always on bits, mask I + endm + eor_flag macro + eor flag_I_on ;I_flag is never changed + eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits + endm + endif + if I_flag = 3 + load_flag macro + lda #\1 ;allow test to change I-flag (no mask) + endm + cmp_flag macro + cmp #(\1|fao)&m8 ;expected flags + always on bits + endm + eor_flag macro + eor #\1|fao ;invert expected flags + always on bits + endm + endif + + ;macros to set (register|memory|zeropage) & status + set_stat macro ;setting flags in the processor status register + load_flag \1 + pha ;use stack to load status + plp + endm + + set_a macro ;precharging accu & status + load_flag \2 + pha ;use stack to load status + lda #\1 ;precharge accu + plp + endm + + set_x macro ;precharging index & status + load_flag \2 + pha ;use stack to load status + ldx #\1 ;precharge index x + plp + endm + + set_y macro ;precharging index & status + load_flag \2 + pha ;use stack to load status + ldy #\1 ;precharge index y + plp + endm + + set_ax macro ;precharging indexed accu & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,x ;precharge accu + plp + endm + + set_ay macro ;precharging indexed accu & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,y ;precharge accu + plp + endm + + set_z macro ;precharging indexed zp & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,x ;load to zeropage + sta zpt + plp + endm + + set_zx macro ;precharging zp,x & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,x ;load to indexed zeropage + sta zpt,x + plp + endm + + set_abs macro ;precharging indexed memory & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,x ;load to memory + sta abst + plp + endm + + set_absx macro ;precharging abs,x & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,x ;load to indexed memory + sta abst,x + plp + endm + + ;macros to test (register|memory|zeropage) & status & (mask) + tst_stat macro ;testing flags in the processor status register + php ;save status + pla ;use stack to retrieve status + pha + cmp_flag \1 + trap_ne + plp ;restore status + endm + + tst_a macro ;testing result in accu & flags + php ;save flags + cmp #\1 ;test result + trap_ne + pla ;load status + pha + cmp_flag \2 + trap_ne + plp ;restore status + endm + + tst_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 + sta range_adr ;reset self modifying code + sta tandi1 + sta tandi2 + sta teori1 + sta teori2 + sta torai1 + sta torai2 + sta chkdadi + sta chkdsbi + sta chkadi + sta chksbi + 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(data_segment) ;set high byte of indirect pointer + stx zpt+1 + ldy #lo(data_bss) ;data after write test area + ccs5\? adc (zpt),y + bcc ccs4\? + inc zpt+3 ;carry to high byte + clc + ccs4\? iny + bne ccs5\? + inx ;advance RAM high address + stx zpt+1 + cpx #ram_top + bne ccs5\? + sta zpt+2 ;checksum low is + cmp ram_chksm ;checksum low expected + trap_ne ;checksum mismatch + lda zpt+3 ;checksum high is + cmp ram_chksm+1 ;checksum high expected + trap_ne ;checksum mismatch + endm + else + check_ram macro + ;RAM check disabled - RAM size not set + endm + endif + + next_test macro ;make sure, tests don't jump the fence + lda test_case ;previous test + cmp #test_num + trap_ne ;test is out of sequence + test_num = test_num + 1 + lda #test_num ;*** next tests' number + sta test_case + ;check_ram ;uncomment to find altered RAM after each test + endm + + if load_data_direct = 1 + data + else + bss ;uninitialized segment, copy of data at end of code! + endif + ; org zero_page +0000 = org 0 ;edited to provide binaries loading from 0 +0000 : 00000000000000.. ds zero_page + ;break test interrupt save +000a : 00 irq_a ds 1 ;a register +000b : 00 irq_x ds 1 ;x register + if I_flag = 2 + ;masking for I bit in status + flag_I_on ds 1 ;or mask to load flags + flag_I_off ds 1 ;and mask to load flags + endif +000c : zpt ;5 bytes store/modify test area + ;add/subtract operand generation and result/flag prediction +000c : 00 adfc ds 1 ;carry flag before op +000d : 00 ad1 ds 1 ;operand 1 - accumulator +000e : 00 ad2 ds 1 ;operand 2 - memory / immediate +000f : 00 adrl ds 1 ;expected result bits 0-7 +0010 : 00 adrh ds 1 ;expected result bit 8 (carry) +0011 : 00 adrf ds 1 ;expected flags NV0000ZC (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 : 0802 ind1 dw abs1 ;indirect pointer to pattern in absolute memory +0026 : 0902 dw abs1+1 +0028 : 0a02 dw abs1+2 +002a : 0b02 dw abs1+3 +002c : 0c02 dw abs7f +002e : 1001 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 : 3f02 indAN dw absAN ;indirect pointer to AND pattern in absolute memory +003c : 4002 dw absAN+1 +003e : 4102 dw absAN+2 +0040 : 4202 dw absAN+3 +0042 : 4302 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory +0044 : 4402 dw absEO+1 +0046 : 4502 dw absEO+2 +0048 : 4602 dw absEO+3 +004a : 3b02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory +004c : 3c02 dw absOR+1 +004e : 3d02 dw absOR+2 +0050 : 3e02 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 +0208 : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR +020c : 7f abs7f db $7f ;test pattern for compare + ;loads +020d : 80800002 fLDx db fn,fn,0,fz ;expected flags for load + ;shifts +0211 : rASL ;expected result ASL & ROL -carry +0211 : 86048200 rROL db $86,$04,$82,0 ; " +0215 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry +0219 : rLSR ;expected result LSR & ROR -carry +0219 : 61412000 rROR db $61,$41,$20,0 ; " +021d : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carry +0221 : fASL ;expected flags for shifts +0221 : 81018002 fROL db fnc,fc,fn,fz ;no carry in +0225 : 81018000 fROLc db fnc,fc,fn,0 ;carry in +0229 : fLSR +0229 : 01000102 fROR db fc,0,fc,fz ;no carry in +022d : 81808180 fRORc db fnc,fn,fnc,fn ;carry in + ;increments (decrements) +0231 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC +0236 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC + ;logical memory operand +023b : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR +023f : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND +0243 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR + ;logical accu operand +0247 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR +024b : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND +024f : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR + ;logical results +0253 : 00ff7f80 absrlo db 0,$ff,$7f,$80 +0257 : 02800080 absflo db fz,fn,0,fn +025b : 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 + + ;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 + sta range_adr ;reset self modifying code + sta tandi1 + sta tandi2 + sta teori1 + sta teori2 + sta torai1 + sta torai2 + sta chkdadi + sta chkdsbi + sta chkadi + sta chksbi + 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(data_segment) ;set high byte of indirect pointer + stx zpt+1 + ldy #lo(data_bss) ;data after write test area + gcs5 adc (zpt),y + bcc gcs4 + inc ram_chksm+1 ;carry to high byte + clc + gcs4 iny + bne gcs5 + inx ;advance RAM high address + stx zpt+1 + cpx #ram_top + bne gcs5 + sta ram_chksm ;checksum complete + endif + next_test +0409 : ad0002 > lda test_case ;previous test +040c : c900 > cmp #test_num + > trap_ne ;test is out of sequence +040e : d0fe > bne * ;failed not equal (non zero) + > +0001 = >test_num = test_num + 1 +0410 : a901 > lda #test_num ;*** next tests' number +0412 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ;testing relative addressing with BEQ +0415 : a0fe ldy #$fe ;testing maximum range, not -1/-2 (invalid/self adr) +0417 : range_loop +0417 : 88 dey ;next relative address +0418 : 98 tya +0419 : aa tax ;precharge count to end of loop +041a : 1003 bpl range_fw ;calculate relative address +041c : 18 clc ;avoid branch self or to relative address of branch +041d : 6902 adc #2 +041f : range_fw +041f : 497f eor #$7f ;complement except sign +0421 : 8da804 sta range_adr ;load into test target +0424 : a900 lda #0 ;should set zero flag in status register +0426 : 4ca704 jmp range_op + + ;relative address target field with branch under test in the middle +0429 : ca dex ;-128 - max backward +042a : ca dex +042b : ca dex +042c : ca dex +042d : ca dex +042e : ca dex +042f : ca dex +0430 : ca dex +0431 : ca dex ;-120 +0432 : ca dex +0433 : ca dex +0434 : ca dex +0435 : ca dex +0436 : ca dex +0437 : ca dex +0438 : ca dex +0439 : ca dex +043a : ca dex +043b : ca dex ;-110 +043c : ca dex +043d : ca dex +043e : ca dex +043f : ca dex +0440 : ca dex +0441 : ca dex +0442 : ca dex +0443 : ca dex +0444 : ca dex +0445 : ca dex ;-100 +0446 : ca dex +0447 : ca dex +0448 : ca dex +0449 : ca dex +044a : ca dex +044b : ca dex +044c : ca dex +044d : ca dex +044e : ca dex +044f : ca dex ;-90 +0450 : ca dex +0451 : ca dex +0452 : ca dex +0453 : ca dex +0454 : ca dex +0455 : ca dex +0456 : ca dex +0457 : ca dex +0458 : ca dex +0459 : ca dex ;-80 +045a : ca dex +045b : ca dex +045c : ca dex +045d : ca dex +045e : ca dex +045f : ca dex +0460 : ca dex +0461 : ca dex +0462 : ca dex +0463 : ca dex ;-70 +0464 : ca dex +0465 : ca dex +0466 : ca dex +0467 : ca dex +0468 : ca dex +0469 : ca dex +046a : ca dex +046b : ca dex +046c : ca dex +046d : ca dex ;-60 +046e : ca dex +046f : ca dex +0470 : ca dex +0471 : ca dex +0472 : ca dex +0473 : ca dex +0474 : ca dex +0475 : ca dex +0476 : ca dex +0477 : ca dex ;-50 +0478 : ca dex +0479 : ca dex +047a : ca dex +047b : ca dex +047c : ca dex +047d : ca dex +047e : ca dex +047f : ca dex +0480 : ca dex +0481 : ca dex ;-40 +0482 : ca dex +0483 : ca dex +0484 : ca dex +0485 : ca dex +0486 : ca dex +0487 : ca dex +0488 : ca dex +0489 : ca dex +048a : ca dex +048b : ca dex ;-30 +048c : ca dex +048d : ca dex +048e : ca dex +048f : ca dex +0490 : ca dex +0491 : ca dex +0492 : ca dex +0493 : ca dex +0494 : ca dex +0495 : ca dex ;-20 +0496 : ca dex +0497 : ca dex +0498 : ca dex +0499 : ca dex +049a : ca dex +049b : ca dex +049c : ca dex +049d : ca dex +049e : ca dex +049f : ca dex ;-10 +04a0 : ca dex +04a1 : ca dex +04a2 : ca dex +04a3 : ca dex +04a4 : ca dex +04a5 : ca dex +04a6 : ca dex ;-3 +04a7 : range_op ;test target with zero flag=0, z=1 if previous dex +04a8 = range_adr = *+1 ;modifiable relative address +04a7 : f03e beq *+64 ;if called without modification +04a9 : ca dex ;+0 +04aa : ca dex +04ab : ca dex +04ac : ca dex +04ad : ca dex +04ae : ca dex +04af : ca dex +04b0 : ca dex +04b1 : ca dex +04b2 : ca dex +04b3 : ca dex ;+10 +04b4 : ca dex +04b5 : ca dex +04b6 : ca dex +04b7 : ca dex +04b8 : ca dex +04b9 : ca dex +04ba : ca dex +04bb : ca dex +04bc : ca dex +04bd : ca dex ;+20 +04be : ca dex +04bf : ca dex +04c0 : ca dex +04c1 : ca dex +04c2 : ca dex +04c3 : ca dex +04c4 : ca dex +04c5 : ca dex +04c6 : ca dex +04c7 : ca dex ;+30 +04c8 : ca dex +04c9 : ca dex +04ca : ca dex +04cb : ca dex +04cc : ca dex +04cd : ca dex +04ce : ca dex +04cf : ca dex +04d0 : ca dex +04d1 : ca dex ;+40 +04d2 : ca dex +04d3 : ca dex +04d4 : ca dex +04d5 : ca dex +04d6 : ca dex +04d7 : ca dex +04d8 : ca dex +04d9 : ca dex +04da : ca dex +04db : ca dex ;+50 +04dc : ca dex +04dd : ca dex +04de : ca dex +04df : ca dex +04e0 : ca dex +04e1 : ca dex +04e2 : ca dex +04e3 : ca dex +04e4 : ca dex +04e5 : ca dex ;+60 +04e6 : ca dex +04e7 : ca dex +04e8 : ca dex +04e9 : ca dex +04ea : ca dex +04eb : ca dex +04ec : ca dex +04ed : ca dex +04ee : ca dex +04ef : ca dex ;+70 +04f0 : ca dex +04f1 : ca dex +04f2 : ca dex +04f3 : ca dex +04f4 : ca dex +04f5 : ca dex +04f6 : ca dex +04f7 : ca dex +04f8 : ca dex +04f9 : ca dex ;+80 +04fa : ca dex +04fb : ca dex +04fc : ca dex +04fd : ca dex +04fe : ca dex +04ff : ca dex +0500 : ca dex +0501 : ca dex +0502 : ca dex +0503 : ca dex ;+90 +0504 : ca dex +0505 : ca dex +0506 : ca dex +0507 : ca dex +0508 : ca dex +0509 : ca dex +050a : ca dex +050b : ca dex +050c : ca dex +050d : ca dex ;+100 +050e : ca dex +050f : ca dex +0510 : ca dex +0511 : ca dex +0512 : ca dex +0513 : ca dex +0514 : ca dex +0515 : ca dex +0516 : ca dex +0517 : ca dex ;+110 +0518 : ca dex +0519 : ca dex +051a : ca dex +051b : ca dex +051c : ca dex +051d : ca dex +051e : ca dex +051f : ca dex +0520 : ca dex +0521 : ca dex ;+120 +0522 : ca dex +0523 : ca dex +0524 : ca dex +0525 : ca dex +0526 : ca dex +0527 : ca dex +0528 : f003 beq range_ok ;+127 - max forward + trap ; bad range +052a : 4c2a05 > jmp * ;failed anyway + +052d : range_ok +052d : c000 cpy #0 +052f : f003 beq range_end +0531 : 4c1704 jmp range_loop +0534 : range_end ;range test successful + next_test +0534 : ad0002 > lda test_case ;previous test +0537 : c901 > cmp #test_num + > trap_ne ;test is out of sequence +0539 : d0fe > bne * ;failed not equal (non zero) + > +0002 = >test_num = test_num + 1 +053b : a902 > lda #test_num ;*** next tests' number +053d : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ;partial test BNE & CMP, CPX, CPY immediate +0540 : c001 cpy #1 ;testing BNE true +0542 : d003 bne test_bne + trap +0544 : 4c4405 > jmp * ;failed anyway + +0547 : test_bne +0547 : a900 lda #0 +0549 : c900 cmp #0 ;test compare immediate + trap_ne +054b : d0fe > bne * ;failed not equal (non zero) + + trap_cc +054d : 90fe > bcc * ;failed carry clear + + trap_mi +054f : 30fe > bmi * ;failed minus (bit 7 set) + +0551 : c901 cmp #1 + trap_eq +0553 : f0fe > beq * ;failed equal (zero) + + trap_cs +0555 : b0fe > bcs * ;failed carry set + + trap_pl +0557 : 10fe > bpl * ;failed plus (bit 7 clear) + +0559 : aa tax +055a : e000 cpx #0 ;test compare x immediate + trap_ne +055c : d0fe > bne * ;failed not equal (non zero) + + trap_cc +055e : 90fe > bcc * ;failed carry clear + + trap_mi +0560 : 30fe > bmi * ;failed minus (bit 7 set) + +0562 : e001 cpx #1 + trap_eq +0564 : f0fe > beq * ;failed equal (zero) + + trap_cs +0566 : b0fe > bcs * ;failed carry set + + trap_pl +0568 : 10fe > bpl * ;failed plus (bit 7 clear) + +056a : a8 tay +056b : c000 cpy #0 ;test compare y immediate + trap_ne +056d : d0fe > bne * ;failed not equal (non zero) + + trap_cc +056f : 90fe > bcc * ;failed carry clear + + trap_mi +0571 : 30fe > bmi * ;failed minus (bit 7 set) + +0573 : c001 cpy #1 + trap_eq +0575 : f0fe > beq * ;failed equal (zero) + + trap_cs +0577 : b0fe > bcs * ;failed carry set + + trap_pl +0579 : 10fe > bpl * ;failed plus (bit 7 clear) + + next_test +057b : ad0002 > lda test_case ;previous test +057e : c902 > cmp #test_num + > trap_ne ;test is out of sequence +0580 : d0fe > bne * ;failed not equal (non zero) + > +0003 = >test_num = test_num + 1 +0582 : a903 > lda #test_num ;*** next tests' number +0584 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + ;testing stack operations PHA PHP PLA PLP + +0587 : a2ff ldx #$ff ;initialize stack +0589 : 9a txs +058a : a955 lda #$55 +058c : 48 pha +058d : a9aa lda #$aa +058f : 48 pha +0590 : cdfe01 cmp $1fe ;on stack ? + trap_ne +0593 : d0fe > bne * ;failed not equal (non zero) + +0595 : ba tsx +0596 : 8a txa ;overwrite accu +0597 : c9fd cmp #$fd ;sp decremented? + trap_ne +0599 : d0fe > bne * ;failed not equal (non zero) + +059b : 68 pla +059c : c9aa cmp #$aa ;successful retreived from stack? + trap_ne +059e : d0fe > bne * ;failed not equal (non zero) + +05a0 : 68 pla +05a1 : c955 cmp #$55 + trap_ne +05a3 : d0fe > bne * ;failed not equal (non zero) + +05a5 : cdff01 cmp $1ff ;remains on stack? + trap_ne +05a8 : d0fe > bne * ;failed not equal (non zero) + +05aa : ba tsx +05ab : e0ff cpx #$ff ;sp incremented? + trap_ne +05ad : d0fe > bne * ;failed not equal (non zero) + + next_test +05af : ad0002 > lda test_case ;previous test +05b2 : c903 > cmp #test_num + > trap_ne ;test is out of sequence +05b4 : d0fe > bne * ;failed not equal (non zero) + > +0004 = >test_num = test_num + 1 +05b6 : a904 > lda #test_num ;*** next tests' number +05b8 : 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 +05bb : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +05bd : 48 > pha ;use stack to load status +05be : 28 > plp + +05bf : 101a bpl nbr1 ;branches should not be taken +05c1 : 501b bvc nbr2 +05c3 : 901c bcc nbr3 +05c5 : d01d bne nbr4 +05c7 : 3003 bmi br1 ;branches should be taken + trap +05c9 : 4cc905 > jmp * ;failed anyway + +05cc : 7003 br1 bvs br2 + trap +05ce : 4cce05 > jmp * ;failed anyway + +05d1 : b003 br2 bcs br3 + trap +05d3 : 4cd305 > jmp * ;failed anyway + +05d6 : f00f br3 beq br4 + trap +05d8 : 4cd805 > jmp * ;failed anyway + +05db : nbr1 + trap ;previous bpl taken +05db : 4cdb05 > jmp * ;failed anyway + +05de : nbr2 + trap ;previous bvc taken +05de : 4cde05 > jmp * ;failed anyway + +05e1 : nbr3 + trap ;previous bcc taken +05e1 : 4ce105 > jmp * ;failed anyway + +05e4 : nbr4 + trap ;previous bne taken +05e4 : 4ce405 > jmp * ;failed anyway + +05e7 : 08 br4 php +05e8 : ba tsx +05e9 : e0fe cpx #$fe ;sp after php? + trap_ne +05eb : d0fe > bne * ;failed not equal (non zero) + +05ed : 68 pla + cmp_flag $ff ;returned all flags on? +05ee : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits + + trap_ne +05f0 : d0fe > bne * ;failed not equal (non zero) + +05f2 : ba tsx +05f3 : e0ff cpx #$ff ;sp after php? + trap_ne +05f5 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 ;all off + > load_flag 0 +05f7 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +05f9 : 48 > pha ;use stack to load status +05fa : 28 > plp + +05fb : 301a bmi nbr11 ;branches should not be taken +05fd : 701b bvs nbr12 +05ff : b01c bcs nbr13 +0601 : f01d beq nbr14 +0603 : 1003 bpl br11 ;branches should be taken + trap +0605 : 4c0506 > jmp * ;failed anyway + +0608 : 5003 br11 bvc br12 + trap +060a : 4c0a06 > jmp * ;failed anyway + +060d : 9003 br12 bcc br13 + trap +060f : 4c0f06 > jmp * ;failed anyway + +0612 : d00f br13 bne br14 + trap +0614 : 4c1406 > jmp * ;failed anyway + +0617 : nbr11 + trap ;previous bmi taken +0617 : 4c1706 > jmp * ;failed anyway + +061a : nbr12 + trap ;previous bvs taken +061a : 4c1a06 > jmp * ;failed anyway + +061d : nbr13 + trap ;previous bcs taken +061d : 4c1d06 > jmp * ;failed anyway + +0620 : nbr14 + trap ;previous beq taken +0620 : 4c2006 > jmp * ;failed anyway + +0623 : 08 br14 php +0624 : 68 pla + cmp_flag 0 ;flags off except break (pushed by sw) + reserved? +0625 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits + + trap_ne +0627 : d0fe > bne * ;failed not equal (non zero) + + ;crosscheck flags + set_stat zero + > load_flag zero +0629 : a902 > lda #zero ;allow test to change I-flag (no mask) + > +062b : 48 > pha ;use stack to load status +062c : 28 > plp + +062d : d002 bne brzs1 +062f : f003 beq brzs2 +0631 : brzs1 + trap ;branch zero/non zero +0631 : 4c3106 > jmp * ;failed anyway + +0634 : b002 brzs2 bcs brzs3 +0636 : 9003 bcc brzs4 +0638 : brzs3 + trap ;branch carry/no carry +0638 : 4c3806 > jmp * ;failed anyway + +063b : 3002 brzs4 bmi brzs5 +063d : 1003 bpl brzs6 +063f : brzs5 + trap ;branch minus/plus +063f : 4c3f06 > jmp * ;failed anyway + +0642 : 7002 brzs6 bvs brzs7 +0644 : 5003 bvc brzs8 +0646 : brzs7 + trap ;branch overflow/no overflow +0646 : 4c4606 > jmp * ;failed anyway + +0649 : brzs8 + set_stat carry + > load_flag carry +0649 : a901 > lda #carry ;allow test to change I-flag (no mask) + > +064b : 48 > pha ;use stack to load status +064c : 28 > plp + +064d : f002 beq brcs1 +064f : d003 bne brcs2 +0651 : brcs1 + trap ;branch zero/non zero +0651 : 4c5106 > jmp * ;failed anyway + +0654 : 9002 brcs2 bcc brcs3 +0656 : b003 bcs brcs4 +0658 : brcs3 + trap ;branch carry/no carry +0658 : 4c5806 > jmp * ;failed anyway + +065b : 3002 brcs4 bmi brcs5 +065d : 1003 bpl brcs6 +065f : brcs5 + trap ;branch minus/plus +065f : 4c5f06 > jmp * ;failed anyway + +0662 : 7002 brcs6 bvs brcs7 +0664 : 5003 bvc brcs8 +0666 : brcs7 + trap ;branch overflow/no overflow +0666 : 4c6606 > jmp * ;failed anyway + + +0669 : brcs8 + set_stat minus + > load_flag minus +0669 : a980 > lda #minus ;allow test to change I-flag (no mask) + > +066b : 48 > pha ;use stack to load status +066c : 28 > plp + +066d : f002 beq brmi1 +066f : d003 bne brmi2 +0671 : brmi1 + trap ;branch zero/non zero +0671 : 4c7106 > jmp * ;failed anyway + +0674 : b002 brmi2 bcs brmi3 +0676 : 9003 bcc brmi4 +0678 : brmi3 + trap ;branch carry/no carry +0678 : 4c7806 > jmp * ;failed anyway + +067b : 1002 brmi4 bpl brmi5 +067d : 3003 bmi brmi6 +067f : brmi5 + trap ;branch minus/plus +067f : 4c7f06 > jmp * ;failed anyway + +0682 : 7002 brmi6 bvs brmi7 +0684 : 5003 bvc brmi8 +0686 : brmi7 + trap ;branch overflow/no overflow +0686 : 4c8606 > jmp * ;failed anyway + +0689 : brmi8 + set_stat overfl + > load_flag overfl +0689 : a940 > lda #overfl ;allow test to change I-flag (no mask) + > +068b : 48 > pha ;use stack to load status +068c : 28 > plp + +068d : f002 beq brvs1 +068f : d003 bne brvs2 +0691 : brvs1 + trap ;branch zero/non zero +0691 : 4c9106 > jmp * ;failed anyway + +0694 : b002 brvs2 bcs brvs3 +0696 : 9003 bcc brvs4 +0698 : brvs3 + trap ;branch carry/no carry +0698 : 4c9806 > jmp * ;failed anyway + +069b : 3002 brvs4 bmi brvs5 +069d : 1003 bpl brvs6 +069f : brvs5 + trap ;branch minus/plus +069f : 4c9f06 > jmp * ;failed anyway + +06a2 : 5002 brvs6 bvc brvs7 +06a4 : 7003 bvs brvs8 +06a6 : brvs7 + trap ;branch overflow/no overflow +06a6 : 4ca606 > jmp * ;failed anyway + +06a9 : brvs8 + set_stat $ff-zero + > load_flag $ff-zero +06a9 : a9fd > lda #$ff-zero ;allow test to change I-flag (no mask) + > +06ab : 48 > pha ;use stack to load status +06ac : 28 > plp + +06ad : f002 beq brzc1 +06af : d003 bne brzc2 +06b1 : brzc1 + trap ;branch zero/non zero +06b1 : 4cb106 > jmp * ;failed anyway + +06b4 : 9002 brzc2 bcc brzc3 +06b6 : b003 bcs brzc4 +06b8 : brzc3 + trap ;branch carry/no carry +06b8 : 4cb806 > jmp * ;failed anyway + +06bb : 1002 brzc4 bpl brzc5 +06bd : 3003 bmi brzc6 +06bf : brzc5 + trap ;branch minus/plus +06bf : 4cbf06 > jmp * ;failed anyway + +06c2 : 5002 brzc6 bvc brzc7 +06c4 : 7003 bvs brzc8 +06c6 : brzc7 + trap ;branch overflow/no overflow +06c6 : 4cc606 > jmp * ;failed anyway + +06c9 : brzc8 + set_stat $ff-carry + > load_flag $ff-carry +06c9 : a9fe > lda #$ff-carry ;allow test to change I-flag (no mask) + > +06cb : 48 > pha ;use stack to load status +06cc : 28 > plp + +06cd : d002 bne brcc1 +06cf : f003 beq brcc2 +06d1 : brcc1 + trap ;branch zero/non zero +06d1 : 4cd106 > jmp * ;failed anyway + +06d4 : b002 brcc2 bcs brcc3 +06d6 : 9003 bcc brcc4 +06d8 : brcc3 + trap ;branch carry/no carry +06d8 : 4cd806 > jmp * ;failed anyway + +06db : 1002 brcc4 bpl brcc5 +06dd : 3003 bmi brcc6 +06df : brcc5 + trap ;branch minus/plus +06df : 4cdf06 > jmp * ;failed anyway + +06e2 : 5002 brcc6 bvc brcc7 +06e4 : 7003 bvs brcc8 +06e6 : brcc7 + trap ;branch overflow/no overflow +06e6 : 4ce606 > jmp * ;failed anyway + +06e9 : brcc8 + set_stat $ff-minus + > load_flag $ff-minus +06e9 : a97f > lda #$ff-minus ;allow test to change I-flag (no mask) + > +06eb : 48 > pha ;use stack to load status +06ec : 28 > plp + +06ed : d002 bne brpl1 +06ef : f003 beq brpl2 +06f1 : brpl1 + trap ;branch zero/non zero +06f1 : 4cf106 > jmp * ;failed anyway + +06f4 : 9002 brpl2 bcc brpl3 +06f6 : b003 bcs brpl4 +06f8 : brpl3 + trap ;branch carry/no carry +06f8 : 4cf806 > jmp * ;failed anyway + +06fb : 3002 brpl4 bmi brpl5 +06fd : 1003 bpl brpl6 +06ff : brpl5 + trap ;branch minus/plus +06ff : 4cff06 > jmp * ;failed anyway + +0702 : 5002 brpl6 bvc brpl7 +0704 : 7003 bvs brpl8 +0706 : brpl7 + trap ;branch overflow/no overflow +0706 : 4c0607 > jmp * ;failed anyway + +0709 : brpl8 + set_stat $ff-overfl + > load_flag $ff-overfl +0709 : a9bf > lda #$ff-overfl ;allow test to change I-flag (no mask) + > +070b : 48 > pha ;use stack to load status +070c : 28 > plp + +070d : d002 bne brvc1 +070f : f003 beq brvc2 +0711 : brvc1 + trap ;branch zero/non zero +0711 : 4c1107 > jmp * ;failed anyway + +0714 : 9002 brvc2 bcc brvc3 +0716 : b003 bcs brvc4 +0718 : brvc3 + trap ;branch carry/no carry +0718 : 4c1807 > jmp * ;failed anyway + +071b : 1002 brvc4 bpl brvc5 +071d : 3003 bmi brvc6 +071f : brvc5 + trap ;branch minus/plus +071f : 4c1f07 > jmp * ;failed anyway + +0722 : 7002 brvc6 bvs brvc7 +0724 : 5003 bvc brvc8 +0726 : brvc7 + trap ;branch overflow/no overflow +0726 : 4c2607 > jmp * ;failed anyway + +0729 : brvc8 + next_test +0729 : ad0002 > lda test_case ;previous test +072c : c904 > cmp #test_num + > trap_ne ;test is out of sequence +072e : d0fe > bne * ;failed not equal (non zero) + > +0005 = >test_num = test_num + 1 +0730 : a905 > lda #test_num ;*** next tests' number +0732 : 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 +0735 : a255 ldx #$55 ;x & y protected +0737 : a0aa ldy #$aa + set_a 1,$ff ;push + > load_flag $ff +0739 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +073b : 48 > pha ;use stack to load status +073c : a901 > lda #1 ;precharge accu +073e : 28 > plp + +073f : 48 pha + tst_a 1,$ff +0740 : 08 > php ;save flags +0741 : c901 > cmp #1 ;test result + > trap_ne +0743 : d0fe > bne * ;failed not equal (non zero) + > +0745 : 68 > pla ;load status +0746 : 48 > pha + > cmp_flag $ff +0747 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0749 : d0fe > bne * ;failed not equal (non zero) + > +074b : 28 > plp ;restore status + + set_a 0,0 + > load_flag 0 +074c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +074e : 48 > pha ;use stack to load status +074f : a900 > lda #0 ;precharge accu +0751 : 28 > plp + +0752 : 48 pha + tst_a 0,0 +0753 : 08 > php ;save flags +0754 : c900 > cmp #0 ;test result + > trap_ne +0756 : d0fe > bne * ;failed not equal (non zero) + > +0758 : 68 > pla ;load status +0759 : 48 > pha + > cmp_flag 0 +075a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +075c : d0fe > bne * ;failed not equal (non zero) + > +075e : 28 > plp ;restore status + + set_a $ff,$ff + > load_flag $ff +075f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0761 : 48 > pha ;use stack to load status +0762 : a9ff > lda #$ff ;precharge accu +0764 : 28 > plp + +0765 : 48 pha + tst_a $ff,$ff +0766 : 08 > php ;save flags +0767 : c9ff > cmp #$ff ;test result + > trap_ne +0769 : d0fe > bne * ;failed not equal (non zero) + > +076b : 68 > pla ;load status +076c : 48 > pha + > cmp_flag $ff +076d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +076f : d0fe > bne * ;failed not equal (non zero) + > +0771 : 28 > plp ;restore status + + set_a 1,0 + > load_flag 0 +0772 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0774 : 48 > pha ;use stack to load status +0775 : a901 > lda #1 ;precharge accu +0777 : 28 > plp + +0778 : 48 pha + tst_a 1,0 +0779 : 08 > php ;save flags +077a : c901 > cmp #1 ;test result + > trap_ne +077c : d0fe > bne * ;failed not equal (non zero) + > +077e : 68 > pla ;load status +077f : 48 > pha + > cmp_flag 0 +0780 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0782 : d0fe > bne * ;failed not equal (non zero) + > +0784 : 28 > plp ;restore status + + set_a 0,$ff + > load_flag $ff +0785 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0787 : 48 > pha ;use stack to load status +0788 : a900 > lda #0 ;precharge accu +078a : 28 > plp + +078b : 48 pha + tst_a 0,$ff +078c : 08 > php ;save flags +078d : c900 > cmp #0 ;test result + > trap_ne +078f : d0fe > bne * ;failed not equal (non zero) + > +0791 : 68 > pla ;load status +0792 : 48 > pha + > cmp_flag $ff +0793 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0795 : d0fe > bne * ;failed not equal (non zero) + > +0797 : 28 > plp ;restore status + + set_a $ff,0 + > load_flag 0 +0798 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +079a : 48 > pha ;use stack to load status +079b : a9ff > lda #$ff ;precharge accu +079d : 28 > plp + +079e : 48 pha + tst_a $ff,0 +079f : 08 > php ;save flags +07a0 : c9ff > cmp #$ff ;test result + > trap_ne +07a2 : d0fe > bne * ;failed not equal (non zero) + > +07a4 : 68 > pla ;load status +07a5 : 48 > pha + > cmp_flag 0 +07a6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +07a8 : d0fe > bne * ;failed not equal (non zero) + > +07aa : 28 > plp ;restore status + + set_a 0,$ff ;pull + > load_flag $ff +07ab : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +07ad : 48 > pha ;use stack to load status +07ae : a900 > lda #0 ;precharge accu +07b0 : 28 > plp + +07b1 : 68 pla + tst_a $ff,$ff-zero +07b2 : 08 > php ;save flags +07b3 : c9ff > cmp #$ff ;test result + > trap_ne +07b5 : d0fe > bne * ;failed not equal (non zero) + > +07b7 : 68 > pla ;load status +07b8 : 48 > pha + > cmp_flag $ff-zero +07b9 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +07bb : d0fe > bne * ;failed not equal (non zero) + > +07bd : 28 > plp ;restore status + + set_a $ff,0 + > load_flag 0 +07be : a900 > lda #0 ;allow test to change I-flag (no mask) + > +07c0 : 48 > pha ;use stack to load status +07c1 : a9ff > lda #$ff ;precharge accu +07c3 : 28 > plp + +07c4 : 68 pla + tst_a 0,zero +07c5 : 08 > php ;save flags +07c6 : c900 > cmp #0 ;test result + > trap_ne +07c8 : d0fe > bne * ;failed not equal (non zero) + > +07ca : 68 > pla ;load status +07cb : 48 > pha + > cmp_flag zero +07cc : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +07ce : d0fe > bne * ;failed not equal (non zero) + > +07d0 : 28 > plp ;restore status + + set_a $fe,$ff + > load_flag $ff +07d1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +07d3 : 48 > pha ;use stack to load status +07d4 : a9fe > lda #$fe ;precharge accu +07d6 : 28 > plp + +07d7 : 68 pla + tst_a 1,$ff-zero-minus +07d8 : 08 > php ;save flags +07d9 : c901 > cmp #1 ;test result + > trap_ne +07db : d0fe > bne * ;failed not equal (non zero) + > +07dd : 68 > pla ;load status +07de : 48 > pha + > cmp_flag $ff-zero-minus +07df : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +07e1 : d0fe > bne * ;failed not equal (non zero) + > +07e3 : 28 > plp ;restore status + + set_a 0,0 + > load_flag 0 +07e4 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +07e6 : 48 > pha ;use stack to load status +07e7 : a900 > lda #0 ;precharge accu +07e9 : 28 > plp + +07ea : 68 pla + tst_a $ff,minus +07eb : 08 > php ;save flags +07ec : c9ff > cmp #$ff ;test result + > trap_ne +07ee : d0fe > bne * ;failed not equal (non zero) + > +07f0 : 68 > pla ;load status +07f1 : 48 > pha + > cmp_flag minus +07f2 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +07f4 : d0fe > bne * ;failed not equal (non zero) + > +07f6 : 28 > plp ;restore status + + set_a $ff,$ff + > load_flag $ff +07f7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +07f9 : 48 > pha ;use stack to load status +07fa : a9ff > lda #$ff ;precharge accu +07fc : 28 > plp + +07fd : 68 pla + tst_a 0,$ff-minus +07fe : 08 > php ;save flags +07ff : c900 > cmp #0 ;test result + > trap_ne +0801 : d0fe > bne * ;failed not equal (non zero) + > +0803 : 68 > pla ;load status +0804 : 48 > pha + > cmp_flag $ff-minus +0805 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0807 : d0fe > bne * ;failed not equal (non zero) + > +0809 : 28 > plp ;restore status + + set_a $fe,0 + > load_flag 0 +080a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +080c : 48 > pha ;use stack to load status +080d : a9fe > lda #$fe ;precharge accu +080f : 28 > plp + +0810 : 68 pla + tst_a 1,0 +0811 : 08 > php ;save flags +0812 : c901 > cmp #1 ;test result + > trap_ne +0814 : d0fe > bne * ;failed not equal (non zero) + > +0816 : 68 > pla ;load status +0817 : 48 > pha + > cmp_flag 0 +0818 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +081a : d0fe > bne * ;failed not equal (non zero) + > +081c : 28 > plp ;restore status + +081d : e055 cpx #$55 ;x & y unchanged? + trap_ne +081f : d0fe > bne * ;failed not equal (non zero) + +0821 : c0aa cpy #$aa + trap_ne +0823 : d0fe > bne * ;failed not equal (non zero) + + next_test +0825 : ad0002 > lda test_case ;previous test +0828 : c905 > cmp #test_num + > trap_ne ;test is out of sequence +082a : d0fe > bne * ;failed not equal (non zero) + > +0006 = >test_num = test_num + 1 +082c : a906 > lda #test_num ;*** next tests' number +082e : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; partial pretest EOR # + set_a $3c,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 : a93c > lda #$3c ;precharge accu +0836 : 28 > plp + +0837 : 49c3 eor #$c3 + tst_a $ff,fn +0839 : 08 > php ;save flags +083a : c9ff > cmp #$ff ;test result + > trap_ne +083c : d0fe > bne * ;failed not equal (non zero) + > +083e : 68 > pla ;load status +083f : 48 > pha + > cmp_flag fn +0840 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0842 : d0fe > bne * ;failed not equal (non zero) + > +0844 : 28 > plp ;restore status + + set_a $c3,0 + > load_flag 0 +0845 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0847 : 48 > pha ;use stack to load status +0848 : a9c3 > lda #$c3 ;precharge accu +084a : 28 > plp + +084b : 49c3 eor #$c3 + tst_a 0,fz +084d : 08 > php ;save flags +084e : c900 > cmp #0 ;test result + > trap_ne +0850 : d0fe > bne * ;failed not equal (non zero) + > +0852 : 68 > pla ;load status +0853 : 48 > pha + > cmp_flag fz +0854 : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0856 : d0fe > bne * ;failed not equal (non zero) + > +0858 : 28 > plp ;restore status + + next_test +0859 : ad0002 > lda test_case ;previous test +085c : c906 > cmp #test_num + > trap_ne ;test is out of sequence +085e : d0fe > bne * ;failed not equal (non zero) + > +0007 = >test_num = test_num + 1 +0860 : a907 > lda #test_num ;*** next tests' number +0862 : 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 +0865 : a224 ldx #$24 +0867 : a042 ldy #$42 + set_a $18,0 + > load_flag 0 +0869 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +086b : 48 > pha ;use stack to load status +086c : a918 > lda #$18 ;precharge accu +086e : 28 > plp + +086f : ea nop + tst_a $18,0 +0870 : 08 > php ;save flags +0871 : c918 > cmp #$18 ;test result + > trap_ne +0873 : d0fe > bne * ;failed not equal (non zero) + > +0875 : 68 > pla ;load status +0876 : 48 > pha + > cmp_flag 0 +0877 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0879 : d0fe > bne * ;failed not equal (non zero) + > +087b : 28 > plp ;restore status + +087c : e024 cpx #$24 + trap_ne +087e : d0fe > bne * ;failed not equal (non zero) + +0880 : c042 cpy #$42 + trap_ne +0882 : d0fe > bne * ;failed not equal (non zero) + +0884 : a2db ldx #$db +0886 : a0bd ldy #$bd + set_a $e7,$ff + > load_flag $ff +0888 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +088a : 48 > pha ;use stack to load status +088b : a9e7 > lda #$e7 ;precharge accu +088d : 28 > plp + +088e : ea nop + tst_a $e7,$ff +088f : 08 > php ;save flags +0890 : c9e7 > cmp #$e7 ;test result + > trap_ne +0892 : d0fe > bne * ;failed not equal (non zero) + > +0894 : 68 > pla ;load status +0895 : 48 > pha + > cmp_flag $ff +0896 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0898 : d0fe > bne * ;failed not equal (non zero) + > +089a : 28 > plp ;restore status + +089b : e0db cpx #$db + trap_ne +089d : d0fe > bne * ;failed not equal (non zero) + +089f : c0bd cpy #$bd + trap_ne +08a1 : d0fe > bne * ;failed not equal (non zero) + + next_test +08a3 : ad0002 > lda test_case ;previous test +08a6 : c907 > cmp #test_num + > trap_ne ;test is out of sequence +08a8 : d0fe > bne * ;failed not equal (non zero) + > +0008 = >test_num = test_num + 1 +08aa : a908 > lda #test_num ;*** next tests' number +08ac : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; jump absolute + set_stat $0 + > load_flag $0 +08af : a900 > lda #$0 ;allow test to change I-flag (no mask) + > +08b1 : 48 > pha ;use stack to load status +08b2 : 28 > plp + +08b3 : a946 lda #'F' +08b5 : a241 ldx #'A' +08b7 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0 +08b9 : 4c1b36 jmp test_far +08bc : ea nop +08bd : ea nop + trap_ne ;runover protection +08be : d0fe > bne * ;failed not equal (non zero) + +08c0 : e8 inx +08c1 : e8 inx +08c2 : far_ret + trap_eq ;returned flags OK? +08c2 : f0fe > beq * ;failed equal (zero) + + trap_pl +08c4 : 10fe > bpl * ;failed plus (bit 7 clear) + + trap_cc +08c6 : 90fe > bcc * ;failed carry clear + + trap_vc +08c8 : 50fe > bvc * ;failed overflow clear + +08ca : c9ec cmp #('F'^$aa) ;returned registers OK? + trap_ne +08cc : d0fe > bne * ;failed not equal (non zero) + +08ce : e042 cpx #('A'+1) + trap_ne +08d0 : d0fe > bne * ;failed not equal (non zero) + +08d2 : c04f cpy #('R'-3) + trap_ne +08d4 : d0fe > bne * ;failed not equal (non zero) + +08d6 : ca dex +08d7 : c8 iny +08d8 : c8 iny +08d9 : c8 iny +08da : 49aa eor #$aa ;N=0, V=1, Z=0, C=1 +08dc : 4ce508 jmp test_near +08df : ea nop +08e0 : ea nop + trap_ne ;runover protection +08e1 : d0fe > bne * ;failed not equal (non zero) + +08e3 : e8 inx +08e4 : e8 inx +08e5 : test_near + trap_eq ;passed flags OK? +08e5 : f0fe > beq * ;failed equal (zero) + + trap_mi +08e7 : 30fe > bmi * ;failed minus (bit 7 set) + + trap_cc +08e9 : 90fe > bcc * ;failed carry clear + + trap_vc +08eb : 50fe > bvc * ;failed overflow clear + +08ed : c946 cmp #'F' ;passed registers OK? + trap_ne +08ef : d0fe > bne * ;failed not equal (non zero) + +08f1 : e041 cpx #'A' + trap_ne +08f3 : d0fe > bne * ;failed not equal (non zero) + +08f5 : c052 cpy #'R' + trap_ne +08f7 : d0fe > bne * ;failed not equal (non zero) + + next_test +08f9 : ad0002 > lda test_case ;previous test +08fc : c908 > cmp #test_num + > trap_ne ;test is out of sequence +08fe : d0fe > bne * ;failed not equal (non zero) + > +0009 = >test_num = test_num + 1 +0900 : a909 > lda #test_num ;*** next tests' number +0902 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; jump indirect + set_stat 0 + > load_flag 0 +0905 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0907 : 48 > pha ;use stack to load status +0908 : 28 > plp + +0909 : a949 lda #'I' +090b : a24e ldx #'N' +090d : a044 ldy #'D' ;N=0, V=0, Z=0, C=0 +090f : 6c4a36 jmp (ptr_tst_ind) +0912 : ea nop + trap_ne ;runover protection +0913 : d0fe > bne * ;failed not equal (non zero) + +0915 : 88 dey +0916 : 88 dey +0917 : ind_ret +0917 : 08 php ;either SP or Y count will fail, if we do not hit +0918 : 88 dey +0919 : 88 dey +091a : 88 dey +091b : 28 plp + trap_eq ;returned flags OK? +091c : f0fe > beq * ;failed equal (zero) + + trap_pl +091e : 10fe > bpl * ;failed plus (bit 7 clear) + + trap_cc +0920 : 90fe > bcc * ;failed carry clear + + trap_vc +0922 : 50fe > bvc * ;failed overflow clear + +0924 : c9e3 cmp #('I'^$aa) ;returned registers OK? + trap_ne +0926 : d0fe > bne * ;failed not equal (non zero) + +0928 : e04f cpx #('N'+1) + trap_ne +092a : d0fe > bne * ;failed not equal (non zero) + +092c : c03e cpy #('D'-6) + trap_ne +092e : d0fe > bne * ;failed not equal (non zero) + +0930 : ba tsx ;SP check +0931 : e0ff cpx #$ff + trap_ne +0933 : d0fe > bne * ;failed not equal (non zero) + + next_test +0935 : ad0002 > lda test_case ;previous test +0938 : c909 > cmp #test_num + > trap_ne ;test is out of sequence +093a : d0fe > bne * ;failed not equal (non zero) + > +000a = >test_num = test_num + 1 +093c : a90a > lda #test_num ;*** next tests' number +093e : 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 +0941 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0943 : 48 > pha ;use stack to load status +0944 : 28 > plp + +0945 : a94a lda #'J' +0947 : a253 ldx #'S' +0949 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0 +094b : 208636 jsr test_jsr +094d = jsr_ret = *-1 ;last address of jsr = return address +094e : 08 php ;either SP or Y count will fail, if we do not hit +094f : 88 dey +0950 : 88 dey +0951 : 88 dey +0952 : 28 plp + trap_eq ;returned flags OK? +0953 : f0fe > beq * ;failed equal (zero) + + trap_pl +0955 : 10fe > bpl * ;failed plus (bit 7 clear) + + trap_cc +0957 : 90fe > bcc * ;failed carry clear + + trap_vc +0959 : 50fe > bvc * ;failed overflow clear + +095b : c9e0 cmp #('J'^$aa) ;returned registers OK? + trap_ne +095d : d0fe > bne * ;failed not equal (non zero) + +095f : e054 cpx #('S'+1) + trap_ne +0961 : d0fe > bne * ;failed not equal (non zero) + +0963 : c04c cpy #('R'-6) + trap_ne +0965 : d0fe > bne * ;failed not equal (non zero) + +0967 : ba tsx ;sp? +0968 : e0ff cpx #$ff + trap_ne +096a : d0fe > bne * ;failed not equal (non zero) + + next_test +096c : ad0002 > lda test_case ;previous test +096f : c90a > cmp #test_num + > trap_ne ;test is out of sequence +0971 : d0fe > bne * ;failed not equal (non zero) + > +000b = >test_num = test_num + 1 +0973 : a90b > lda #test_num ;*** next tests' number +0975 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; break & return from interrupt + if ROM_vectors = 1 + set_stat 0 + > load_flag 0 +0978 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +097a : 48 > pha ;use stack to load status +097b : 28 > plp + +097c : a942 lda #'B' +097e : a252 ldx #'R' +0980 : a04b ldy #'K' ;N=0, V=0, Z=0, C=0 +0982 : 00 brk + else + lda #hi brk_ret ;emulated break + pha + lda #lo brk_ret + pha + lda #fao ;set break & unused on stack + pha + set_stat intdis + lda #'B' + ldx #'R' + ldy #'K' ;N=0, V=0, Z=0, C=0 + jmp irq_trap + endif +0983 : 88 dey ;should not be executed +0984 : brk_ret ;address of break return +0984 : 08 php ;either SP or Y count will fail, if we do not hit +0985 : 88 dey +0986 : 88 dey +0987 : 88 dey +0988 : c9e8 cmp #('B'^$aa) ;returned registers OK? + trap_ne +098a : d0fe > bne * ;failed not equal (non zero) + +098c : e053 cpx #('R'+1) + trap_ne +098e : d0fe > bne * ;failed not equal (non zero) + +0990 : c045 cpy #('K'-6) + trap_ne +0992 : d0fe > bne * ;failed not equal (non zero) + +0994 : 68 pla ;returned flags OK (unchanged)? + cmp_flag 0 +0995 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + + trap_ne +0997 : d0fe > bne * ;failed not equal (non zero) + +0999 : ba tsx ;sp? +099a : e0ff cpx #$ff + trap_ne +099c : d0fe > bne * ;failed not equal (non zero) + + next_test +099e : ad0002 > lda test_case ;previous test +09a1 : c90b > cmp #test_num + > trap_ne ;test is out of sequence +09a3 : d0fe > bne * ;failed not equal (non zero) + > +000c = >test_num = test_num + 1 +09a5 : a90c > lda #test_num ;*** next tests' number +09a7 : 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 +09aa : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +09ac : 48 > pha ;use stack to load status +09ad : 28 > plp + +09ae : 18 clc + tst_stat $ff-carry +09af : 08 > php ;save status +09b0 : 68 > pla ;use stack to retrieve status +09b1 : 48 > pha + > cmp_flag $ff-carry +09b2 : c9fe > cmp #($ff-carry|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09b4 : d0fe > bne * ;failed not equal (non zero) + > +09b6 : 28 > plp ;restore status + +09b7 : 38 sec + tst_stat $ff +09b8 : 08 > php ;save status +09b9 : 68 > pla ;use stack to retrieve status +09ba : 48 > pha + > cmp_flag $ff +09bb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09bd : d0fe > bne * ;failed not equal (non zero) + > +09bf : 28 > plp ;restore status + + if I_flag = 3 +09c0 : 58 cli + tst_stat $ff-intdis +09c1 : 08 > php ;save status +09c2 : 68 > pla ;use stack to retrieve status +09c3 : 48 > pha + > cmp_flag $ff-intdis +09c4 : c9fb > cmp #($ff-intdis|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09c6 : d0fe > bne * ;failed not equal (non zero) + > +09c8 : 28 > plp ;restore status + +09c9 : 78 sei + tst_stat $ff +09ca : 08 > php ;save status +09cb : 68 > pla ;use stack to retrieve status +09cc : 48 > pha + > cmp_flag $ff +09cd : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09cf : d0fe > bne * ;failed not equal (non zero) + > +09d1 : 28 > plp ;restore status + + endif +09d2 : d8 cld + tst_stat $ff-decmode +09d3 : 08 > php ;save status +09d4 : 68 > pla ;use stack to retrieve status +09d5 : 48 > pha + > cmp_flag $ff-decmode +09d6 : c9f7 > cmp #($ff-decmode|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09d8 : d0fe > bne * ;failed not equal (non zero) + > +09da : 28 > plp ;restore status + +09db : f8 sed + tst_stat $ff +09dc : 08 > php ;save status +09dd : 68 > pla ;use stack to retrieve status +09de : 48 > pha + > cmp_flag $ff +09df : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09e1 : d0fe > bne * ;failed not equal (non zero) + > +09e3 : 28 > plp ;restore status + +09e4 : b8 clv + tst_stat $ff-overfl +09e5 : 08 > php ;save status +09e6 : 68 > pla ;use stack to retrieve status +09e7 : 48 > pha + > cmp_flag $ff-overfl +09e8 : c9bf > cmp #($ff-overfl|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09ea : d0fe > bne * ;failed not equal (non zero) + > +09ec : 28 > plp ;restore status + + set_stat 0 + > load_flag 0 +09ed : a900 > lda #0 ;allow test to change I-flag (no mask) + > +09ef : 48 > pha ;use stack to load status +09f0 : 28 > plp + + tst_stat 0 +09f1 : 08 > php ;save status +09f2 : 68 > pla ;use stack to retrieve status +09f3 : 48 > pha + > cmp_flag 0 +09f4 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09f6 : d0fe > bne * ;failed not equal (non zero) + > +09f8 : 28 > plp ;restore status + +09f9 : 38 sec + tst_stat carry +09fa : 08 > php ;save status +09fb : 68 > pla ;use stack to retrieve status +09fc : 48 > pha + > cmp_flag carry +09fd : c931 > cmp #(carry|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09ff : d0fe > bne * ;failed not equal (non zero) + > +0a01 : 28 > plp ;restore status + +0a02 : 18 clc + tst_stat 0 +0a03 : 08 > php ;save status +0a04 : 68 > pla ;use stack to retrieve status +0a05 : 48 > pha + > cmp_flag 0 +0a06 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a08 : d0fe > bne * ;failed not equal (non zero) + > +0a0a : 28 > plp ;restore status + + if I_flag = 3 +0a0b : 78 sei + tst_stat intdis +0a0c : 08 > php ;save status +0a0d : 68 > pla ;use stack to retrieve status +0a0e : 48 > pha + > cmp_flag intdis +0a0f : c934 > cmp #(intdis|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a11 : d0fe > bne * ;failed not equal (non zero) + > +0a13 : 28 > plp ;restore status + +0a14 : 58 cli + tst_stat 0 +0a15 : 08 > php ;save status +0a16 : 68 > pla ;use stack to retrieve status +0a17 : 48 > pha + > cmp_flag 0 +0a18 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a1a : d0fe > bne * ;failed not equal (non zero) + > +0a1c : 28 > plp ;restore status + + endif +0a1d : f8 sed + tst_stat decmode +0a1e : 08 > php ;save status +0a1f : 68 > pla ;use stack to retrieve status +0a20 : 48 > pha + > cmp_flag decmode +0a21 : c938 > cmp #(decmode|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a23 : d0fe > bne * ;failed not equal (non zero) + > +0a25 : 28 > plp ;restore status + +0a26 : d8 cld + tst_stat 0 +0a27 : 08 > php ;save status +0a28 : 68 > pla ;use stack to retrieve status +0a29 : 48 > pha + > cmp_flag 0 +0a2a : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a2c : d0fe > bne * ;failed not equal (non zero) + > +0a2e : 28 > plp ;restore status + + set_stat overfl + > load_flag overfl +0a2f : a940 > lda #overfl ;allow test to change I-flag (no mask) + > +0a31 : 48 > pha ;use stack to load status +0a32 : 28 > plp + + tst_stat overfl +0a33 : 08 > php ;save status +0a34 : 68 > pla ;use stack to retrieve status +0a35 : 48 > pha + > cmp_flag overfl +0a36 : c970 > cmp #(overfl|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a38 : d0fe > bne * ;failed not equal (non zero) + > +0a3a : 28 > plp ;restore status + +0a3b : b8 clv + tst_stat 0 +0a3c : 08 > php ;save status +0a3d : 68 > pla ;use stack to retrieve status +0a3e : 48 > pha + > cmp_flag 0 +0a3f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a41 : d0fe > bne * ;failed not equal (non zero) + > +0a43 : 28 > plp ;restore status + + next_test +0a44 : ad0002 > lda test_case ;previous test +0a47 : c90c > cmp #test_num + > trap_ne ;test is out of sequence +0a49 : d0fe > bne * ;failed not equal (non zero) + > +000d = >test_num = test_num + 1 +0a4b : a90d > lda #test_num ;*** next tests' number +0a4d : 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 +0a50 : a2fe ldx #$fe + set_stat $ff + > load_flag $ff +0a52 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0a54 : 48 > pha ;use stack to load status +0a55 : 28 > plp + +0a56 : e8 inx ;ff + tst_x $ff,$ff-zero +0a57 : 08 > php ;save flags +0a58 : e0ff > cpx #$ff ;test result + > trap_ne +0a5a : d0fe > bne * ;failed not equal (non zero) + > +0a5c : 68 > pla ;load status +0a5d : 48 > pha + > cmp_flag $ff-zero +0a5e : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a60 : d0fe > bne * ;failed not equal (non zero) + > +0a62 : 28 > plp ;restore status + +0a63 : e8 inx ;00 + tst_x 0,$ff-minus +0a64 : 08 > php ;save flags +0a65 : e000 > cpx #0 ;test result + > trap_ne +0a67 : d0fe > bne * ;failed not equal (non zero) + > +0a69 : 68 > pla ;load status +0a6a : 48 > pha + > cmp_flag $ff-minus +0a6b : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a6d : d0fe > bne * ;failed not equal (non zero) + > +0a6f : 28 > plp ;restore status + +0a70 : e8 inx ;01 + tst_x 1,$ff-minus-zero +0a71 : 08 > php ;save flags +0a72 : e001 > cpx #1 ;test result + > trap_ne +0a74 : d0fe > bne * ;failed not equal (non zero) + > +0a76 : 68 > pla ;load status +0a77 : 48 > pha + > cmp_flag $ff-minus-zero +0a78 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a7a : d0fe > bne * ;failed not equal (non zero) + > +0a7c : 28 > plp ;restore status + +0a7d : ca dex ;00 + tst_x 0,$ff-minus +0a7e : 08 > php ;save flags +0a7f : e000 > cpx #0 ;test result + > trap_ne +0a81 : d0fe > bne * ;failed not equal (non zero) + > +0a83 : 68 > pla ;load status +0a84 : 48 > pha + > cmp_flag $ff-minus +0a85 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a87 : d0fe > bne * ;failed not equal (non zero) + > +0a89 : 28 > plp ;restore status + +0a8a : ca dex ;ff + tst_x $ff,$ff-zero +0a8b : 08 > php ;save flags +0a8c : e0ff > cpx #$ff ;test result + > trap_ne +0a8e : d0fe > bne * ;failed not equal (non zero) + > +0a90 : 68 > pla ;load status +0a91 : 48 > pha + > cmp_flag $ff-zero +0a92 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a94 : d0fe > bne * ;failed not equal (non zero) + > +0a96 : 28 > plp ;restore status + +0a97 : ca dex ;fe + set_stat 0 + > load_flag 0 +0a98 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0a9a : 48 > pha ;use stack to load status +0a9b : 28 > plp + +0a9c : e8 inx ;ff + tst_x $ff,minus +0a9d : 08 > php ;save flags +0a9e : e0ff > cpx #$ff ;test result + > trap_ne +0aa0 : d0fe > bne * ;failed not equal (non zero) + > +0aa2 : 68 > pla ;load status +0aa3 : 48 > pha + > cmp_flag minus +0aa4 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0aa6 : d0fe > bne * ;failed not equal (non zero) + > +0aa8 : 28 > plp ;restore status + +0aa9 : e8 inx ;00 + tst_x 0,zero +0aaa : 08 > php ;save flags +0aab : e000 > cpx #0 ;test result + > trap_ne +0aad : d0fe > bne * ;failed not equal (non zero) + > +0aaf : 68 > pla ;load status +0ab0 : 48 > pha + > cmp_flag zero +0ab1 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0ab3 : d0fe > bne * ;failed not equal (non zero) + > +0ab5 : 28 > plp ;restore status + +0ab6 : e8 inx ;01 + tst_x 1,0 +0ab7 : 08 > php ;save flags +0ab8 : e001 > cpx #1 ;test result + > trap_ne +0aba : d0fe > bne * ;failed not equal (non zero) + > +0abc : 68 > pla ;load status +0abd : 48 > pha + > cmp_flag 0 +0abe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0ac0 : d0fe > bne * ;failed not equal (non zero) + > +0ac2 : 28 > plp ;restore status + +0ac3 : ca dex ;00 + tst_x 0,zero +0ac4 : 08 > php ;save flags +0ac5 : e000 > cpx #0 ;test result + > trap_ne +0ac7 : d0fe > bne * ;failed not equal (non zero) + > +0ac9 : 68 > pla ;load status +0aca : 48 > pha + > cmp_flag zero +0acb : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0acd : d0fe > bne * ;failed not equal (non zero) + > +0acf : 28 > plp ;restore status + +0ad0 : ca dex ;ff + tst_x $ff,minus +0ad1 : 08 > php ;save flags +0ad2 : e0ff > cpx #$ff ;test result + > trap_ne +0ad4 : d0fe > bne * ;failed not equal (non zero) + > +0ad6 : 68 > pla ;load status +0ad7 : 48 > pha + > cmp_flag minus +0ad8 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0ada : d0fe > bne * ;failed not equal (non zero) + > +0adc : 28 > plp ;restore status + + +0add : a0fe ldy #$fe + set_stat $ff + > load_flag $ff +0adf : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0ae1 : 48 > pha ;use stack to load status +0ae2 : 28 > plp + +0ae3 : c8 iny ;ff + tst_y $ff,$ff-zero +0ae4 : 08 > php ;save flags +0ae5 : c0ff > cpy #$ff ;test result + > trap_ne +0ae7 : d0fe > bne * ;failed not equal (non zero) + > +0ae9 : 68 > pla ;load status +0aea : 48 > pha + > cmp_flag $ff-zero +0aeb : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0aed : d0fe > bne * ;failed not equal (non zero) + > +0aef : 28 > plp ;restore status + +0af0 : c8 iny ;00 + tst_y 0,$ff-minus +0af1 : 08 > php ;save flags +0af2 : c000 > cpy #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 : c8 iny ;01 + tst_y 1,$ff-minus-zero +0afe : 08 > php ;save flags +0aff : c001 > cpy #1 ;test result + > trap_ne +0b01 : d0fe > bne * ;failed not equal (non zero) + > +0b03 : 68 > pla ;load status +0b04 : 48 > pha + > cmp_flag $ff-minus-zero +0b05 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b07 : d0fe > bne * ;failed not equal (non zero) + > +0b09 : 28 > plp ;restore status + +0b0a : 88 dey ;00 + tst_y 0,$ff-minus +0b0b : 08 > php ;save flags +0b0c : c000 > cpy #0 ;test result + > trap_ne +0b0e : d0fe > bne * ;failed not equal (non zero) + > +0b10 : 68 > pla ;load status +0b11 : 48 > pha + > cmp_flag $ff-minus +0b12 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b14 : d0fe > bne * ;failed not equal (non zero) + > +0b16 : 28 > plp ;restore status + +0b17 : 88 dey ;ff + tst_y $ff,$ff-zero +0b18 : 08 > php ;save flags +0b19 : c0ff > cpy #$ff ;test result + > trap_ne +0b1b : d0fe > bne * ;failed not equal (non zero) + > +0b1d : 68 > pla ;load status +0b1e : 48 > pha + > cmp_flag $ff-zero +0b1f : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b21 : d0fe > bne * ;failed not equal (non zero) + > +0b23 : 28 > plp ;restore status + +0b24 : 88 dey ;fe + set_stat 0 + > load_flag 0 +0b25 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0b27 : 48 > pha ;use stack to load status +0b28 : 28 > plp + +0b29 : c8 iny ;ff + tst_y $ff,0+minus +0b2a : 08 > php ;save flags +0b2b : c0ff > cpy #$ff ;test result + > trap_ne +0b2d : d0fe > bne * ;failed not equal (non zero) + > +0b2f : 68 > pla ;load status +0b30 : 48 > pha + > cmp_flag 0+minus +0b31 : c9b0 > cmp #(0+minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b33 : d0fe > bne * ;failed not equal (non zero) + > +0b35 : 28 > plp ;restore status + +0b36 : c8 iny ;00 + tst_y 0,zero +0b37 : 08 > php ;save flags +0b38 : c000 > cpy #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 : c8 iny ;01 + tst_y 1,0 +0b44 : 08 > php ;save flags +0b45 : c001 > cpy #1 ;test result + > trap_ne +0b47 : d0fe > bne * ;failed not equal (non zero) + > +0b49 : 68 > pla ;load status +0b4a : 48 > pha + > cmp_flag 0 +0b4b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b4d : d0fe > bne * ;failed not equal (non zero) + > +0b4f : 28 > plp ;restore status + +0b50 : 88 dey ;00 + tst_y 0,zero +0b51 : 08 > php ;save flags +0b52 : c000 > cpy #0 ;test result + > trap_ne +0b54 : d0fe > bne * ;failed not equal (non zero) + > +0b56 : 68 > pla ;load status +0b57 : 48 > pha + > cmp_flag zero +0b58 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b5a : d0fe > bne * ;failed not equal (non zero) + > +0b5c : 28 > plp ;restore status + +0b5d : 88 dey ;ff + tst_y $ff,minus +0b5e : 08 > php ;save flags +0b5f : c0ff > cpy #$ff ;test result + > trap_ne +0b61 : d0fe > bne * ;failed not equal (non zero) + > +0b63 : 68 > pla ;load status +0b64 : 48 > pha + > cmp_flag minus +0b65 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b67 : d0fe > bne * ;failed not equal (non zero) + > +0b69 : 28 > plp ;restore status + + +0b6a : a2ff ldx #$ff + set_stat $ff + > load_flag $ff +0b6c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0b6e : 48 > pha ;use stack to load status +0b6f : 28 > plp + +0b70 : 8a txa + tst_a $ff,$ff-zero +0b71 : 08 > php ;save flags +0b72 : c9ff > cmp #$ff ;test result + > trap_ne +0b74 : d0fe > bne * ;failed not equal (non zero) + > +0b76 : 68 > pla ;load status +0b77 : 48 > pha + > cmp_flag $ff-zero +0b78 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b7a : d0fe > bne * ;failed not equal (non zero) + > +0b7c : 28 > plp ;restore status + +0b7d : 08 php +0b7e : e8 inx ;00 +0b7f : 28 plp +0b80 : 8a txa + tst_a 0,$ff-minus +0b81 : 08 > php ;save flags +0b82 : c900 > cmp #0 ;test result + > trap_ne +0b84 : d0fe > bne * ;failed not equal (non zero) + > +0b86 : 68 > pla ;load status +0b87 : 48 > pha + > cmp_flag $ff-minus +0b88 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b8a : d0fe > bne * ;failed not equal (non zero) + > +0b8c : 28 > plp ;restore status + +0b8d : 08 php +0b8e : e8 inx ;01 +0b8f : 28 plp +0b90 : 8a txa + tst_a 1,$ff-minus-zero +0b91 : 08 > php ;save flags +0b92 : c901 > cmp #1 ;test result + > trap_ne +0b94 : d0fe > bne * ;failed not equal (non zero) + > +0b96 : 68 > pla ;load status +0b97 : 48 > pha + > cmp_flag $ff-minus-zero +0b98 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b9a : d0fe > bne * ;failed not equal (non zero) + > +0b9c : 28 > plp ;restore status + + set_stat 0 + > load_flag 0 +0b9d : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0b9f : 48 > pha ;use stack to load status +0ba0 : 28 > plp + +0ba1 : 8a txa + tst_a 1,0 +0ba2 : 08 > php ;save flags +0ba3 : c901 > cmp #1 ;test result + > trap_ne +0ba5 : d0fe > bne * ;failed not equal (non zero) + > +0ba7 : 68 > pla ;load status +0ba8 : 48 > pha + > cmp_flag 0 +0ba9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0bab : d0fe > bne * ;failed not equal (non zero) + > +0bad : 28 > plp ;restore status + +0bae : 08 php +0baf : ca dex ;00 +0bb0 : 28 plp +0bb1 : 8a txa + tst_a 0,zero +0bb2 : 08 > php ;save flags +0bb3 : c900 > cmp #0 ;test result + > trap_ne +0bb5 : d0fe > bne * ;failed not equal (non zero) + > +0bb7 : 68 > pla ;load status +0bb8 : 48 > pha + > cmp_flag zero +0bb9 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0bbb : d0fe > bne * ;failed not equal (non zero) + > +0bbd : 28 > plp ;restore status + +0bbe : 08 php +0bbf : ca dex ;ff +0bc0 : 28 plp +0bc1 : 8a txa + tst_a $ff,minus +0bc2 : 08 > php ;save flags +0bc3 : c9ff > cmp #$ff ;test result + > trap_ne +0bc5 : d0fe > bne * ;failed not equal (non zero) + > +0bc7 : 68 > pla ;load status +0bc8 : 48 > pha + > cmp_flag minus +0bc9 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0bcb : d0fe > bne * ;failed not equal (non zero) + > +0bcd : 28 > plp ;restore status + + +0bce : a0ff ldy #$ff + set_stat $ff + > load_flag $ff +0bd0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0bd2 : 48 > pha ;use stack to load status +0bd3 : 28 > plp + +0bd4 : 98 tya + tst_a $ff,$ff-zero +0bd5 : 08 > php ;save flags +0bd6 : c9ff > cmp #$ff ;test result + > trap_ne +0bd8 : d0fe > bne * ;failed not equal (non zero) + > +0bda : 68 > pla ;load status +0bdb : 48 > pha + > cmp_flag $ff-zero +0bdc : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0bde : d0fe > bne * ;failed not equal (non zero) + > +0be0 : 28 > plp ;restore status + +0be1 : 08 php +0be2 : c8 iny ;00 +0be3 : 28 plp +0be4 : 98 tya + tst_a 0,$ff-minus +0be5 : 08 > php ;save flags +0be6 : c900 > cmp #0 ;test result + > trap_ne +0be8 : d0fe > bne * ;failed not equal (non zero) + > +0bea : 68 > pla ;load status +0beb : 48 > pha + > cmp_flag $ff-minus +0bec : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0bee : d0fe > bne * ;failed not equal (non zero) + > +0bf0 : 28 > plp ;restore status + +0bf1 : 08 php +0bf2 : c8 iny ;01 +0bf3 : 28 plp +0bf4 : 98 tya + tst_a 1,$ff-minus-zero +0bf5 : 08 > php ;save flags +0bf6 : c901 > cmp #1 ;test result + > trap_ne +0bf8 : d0fe > bne * ;failed not equal (non zero) + > +0bfa : 68 > pla ;load status +0bfb : 48 > pha + > cmp_flag $ff-minus-zero +0bfc : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0bfe : d0fe > bne * ;failed not equal (non zero) + > +0c00 : 28 > plp ;restore status + + set_stat 0 + > load_flag 0 +0c01 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0c03 : 48 > pha ;use stack to load status +0c04 : 28 > plp + +0c05 : 98 tya + tst_a 1,0 +0c06 : 08 > php ;save flags +0c07 : c901 > cmp #1 ;test result + > trap_ne +0c09 : d0fe > bne * ;failed not equal (non zero) + > +0c0b : 68 > pla ;load status +0c0c : 48 > pha + > cmp_flag 0 +0c0d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c0f : d0fe > bne * ;failed not equal (non zero) + > +0c11 : 28 > plp ;restore status + +0c12 : 08 php +0c13 : 88 dey ;00 +0c14 : 28 plp +0c15 : 98 tya + tst_a 0,zero +0c16 : 08 > php ;save flags +0c17 : c900 > cmp #0 ;test result + > trap_ne +0c19 : d0fe > bne * ;failed not equal (non zero) + > +0c1b : 68 > pla ;load status +0c1c : 48 > pha + > cmp_flag zero +0c1d : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c1f : d0fe > bne * ;failed not equal (non zero) + > +0c21 : 28 > plp ;restore status + +0c22 : 08 php +0c23 : 88 dey ;ff +0c24 : 28 plp +0c25 : 98 tya + tst_a $ff,minus +0c26 : 08 > php ;save flags +0c27 : c9ff > cmp #$ff ;test result + > trap_ne +0c29 : d0fe > bne * ;failed not equal (non zero) + > +0c2b : 68 > pla ;load status +0c2c : 48 > pha + > cmp_flag minus +0c2d : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c2f : d0fe > bne * ;failed not equal (non zero) + > +0c31 : 28 > plp ;restore status + + + load_flag $ff +0c32 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + +0c34 : 48 pha +0c35 : a2ff ldx #$ff ;ff +0c37 : 8a txa +0c38 : 28 plp +0c39 : a8 tay + tst_y $ff,$ff-zero +0c3a : 08 > php ;save flags +0c3b : c0ff > cpy #$ff ;test result + > trap_ne +0c3d : d0fe > bne * ;failed not equal (non zero) + > +0c3f : 68 > pla ;load status +0c40 : 48 > pha + > cmp_flag $ff-zero +0c41 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c43 : d0fe > bne * ;failed not equal (non zero) + > +0c45 : 28 > plp ;restore status + +0c46 : 08 php +0c47 : e8 inx ;00 +0c48 : 8a txa +0c49 : 28 plp +0c4a : a8 tay + tst_y 0,$ff-minus +0c4b : 08 > php ;save flags +0c4c : c000 > cpy #0 ;test result + > trap_ne +0c4e : d0fe > bne * ;failed not equal (non zero) + > +0c50 : 68 > pla ;load status +0c51 : 48 > pha + > cmp_flag $ff-minus +0c52 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c54 : d0fe > bne * ;failed not equal (non zero) + > +0c56 : 28 > plp ;restore status + +0c57 : 08 php +0c58 : e8 inx ;01 +0c59 : 8a txa +0c5a : 28 plp +0c5b : a8 tay + tst_y 1,$ff-minus-zero +0c5c : 08 > php ;save flags +0c5d : c001 > cpy #1 ;test result + > trap_ne +0c5f : d0fe > bne * ;failed not equal (non zero) + > +0c61 : 68 > pla ;load status +0c62 : 48 > pha + > cmp_flag $ff-minus-zero +0c63 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c65 : d0fe > bne * ;failed not equal (non zero) + > +0c67 : 28 > plp ;restore status + + load_flag 0 +0c68 : a900 > lda #0 ;allow test to change I-flag (no mask) + +0c6a : 48 pha +0c6b : a900 lda #0 +0c6d : 8a txa +0c6e : 28 plp +0c6f : a8 tay + tst_y 1,0 +0c70 : 08 > php ;save flags +0c71 : c001 > cpy #1 ;test result + > trap_ne +0c73 : d0fe > bne * ;failed not equal (non zero) + > +0c75 : 68 > pla ;load status +0c76 : 48 > pha + > cmp_flag 0 +0c77 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c79 : d0fe > bne * ;failed not equal (non zero) + > +0c7b : 28 > plp ;restore status + +0c7c : 08 php +0c7d : ca dex ;00 +0c7e : 8a txa +0c7f : 28 plp +0c80 : a8 tay + tst_y 0,zero +0c81 : 08 > php ;save flags +0c82 : c000 > cpy #0 ;test result + > trap_ne +0c84 : d0fe > bne * ;failed not equal (non zero) + > +0c86 : 68 > pla ;load status +0c87 : 48 > pha + > cmp_flag zero +0c88 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c8a : d0fe > bne * ;failed not equal (non zero) + > +0c8c : 28 > plp ;restore status + +0c8d : 08 php +0c8e : ca dex ;ff +0c8f : 8a txa +0c90 : 28 plp +0c91 : a8 tay + tst_y $ff,minus +0c92 : 08 > php ;save flags +0c93 : c0ff > cpy #$ff ;test result + > trap_ne +0c95 : d0fe > bne * ;failed not equal (non zero) + > +0c97 : 68 > pla ;load status +0c98 : 48 > pha + > cmp_flag minus +0c99 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c9b : d0fe > bne * ;failed not equal (non zero) + > +0c9d : 28 > plp ;restore status + + + + load_flag $ff +0c9e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + +0ca0 : 48 pha +0ca1 : a0ff ldy #$ff ;ff +0ca3 : 98 tya +0ca4 : 28 plp +0ca5 : aa tax + tst_x $ff,$ff-zero +0ca6 : 08 > php ;save flags +0ca7 : e0ff > cpx #$ff ;test result + > trap_ne +0ca9 : d0fe > bne * ;failed not equal (non zero) + > +0cab : 68 > pla ;load status +0cac : 48 > pha + > cmp_flag $ff-zero +0cad : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0caf : d0fe > bne * ;failed not equal (non zero) + > +0cb1 : 28 > plp ;restore status + +0cb2 : 08 php +0cb3 : c8 iny ;00 +0cb4 : 98 tya +0cb5 : 28 plp +0cb6 : aa tax + tst_x 0,$ff-minus +0cb7 : 08 > php ;save flags +0cb8 : e000 > cpx #0 ;test result + > trap_ne +0cba : d0fe > bne * ;failed not equal (non zero) + > +0cbc : 68 > pla ;load status +0cbd : 48 > pha + > cmp_flag $ff-minus +0cbe : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0cc0 : d0fe > bne * ;failed not equal (non zero) + > +0cc2 : 28 > plp ;restore status + +0cc3 : 08 php +0cc4 : c8 iny ;01 +0cc5 : 98 tya +0cc6 : 28 plp +0cc7 : aa tax + tst_x 1,$ff-minus-zero +0cc8 : 08 > php ;save flags +0cc9 : e001 > cpx #1 ;test result + > trap_ne +0ccb : d0fe > bne * ;failed not equal (non zero) + > +0ccd : 68 > pla ;load status +0cce : 48 > pha + > cmp_flag $ff-minus-zero +0ccf : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0cd1 : d0fe > bne * ;failed not equal (non zero) + > +0cd3 : 28 > plp ;restore status + + load_flag 0 +0cd4 : a900 > lda #0 ;allow test to change I-flag (no mask) + +0cd6 : 48 pha +0cd7 : a900 lda #0 ;preset status +0cd9 : 98 tya +0cda : 28 plp +0cdb : aa tax + tst_x 1,0 +0cdc : 08 > php ;save flags +0cdd : e001 > cpx #1 ;test result + > trap_ne +0cdf : d0fe > bne * ;failed not equal (non zero) + > +0ce1 : 68 > pla ;load status +0ce2 : 48 > pha + > cmp_flag 0 +0ce3 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0ce5 : d0fe > bne * ;failed not equal (non zero) + > +0ce7 : 28 > plp ;restore status + +0ce8 : 08 php +0ce9 : 88 dey ;00 +0cea : 98 tya +0ceb : 28 plp +0cec : aa tax + tst_x 0,zero +0ced : 08 > php ;save flags +0cee : e000 > cpx #0 ;test result + > trap_ne +0cf0 : d0fe > bne * ;failed not equal (non zero) + > +0cf2 : 68 > pla ;load status +0cf3 : 48 > pha + > cmp_flag zero +0cf4 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0cf6 : d0fe > bne * ;failed not equal (non zero) + > +0cf8 : 28 > plp ;restore status + +0cf9 : 08 php +0cfa : 88 dey ;ff +0cfb : 98 tya +0cfc : 28 plp +0cfd : aa tax + tst_x $ff,minus +0cfe : 08 > php ;save flags +0cff : e0ff > cpx #$ff ;test result + > trap_ne +0d01 : d0fe > bne * ;failed not equal (non zero) + > +0d03 : 68 > pla ;load status +0d04 : 48 > pha + > cmp_flag minus +0d05 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0d07 : d0fe > bne * ;failed not equal (non zero) + > +0d09 : 28 > plp ;restore status + + next_test +0d0a : ad0002 > lda test_case ;previous test +0d0d : c90d > cmp #test_num + > trap_ne ;test is out of sequence +0d0f : d0fe > bne * ;failed not equal (non zero) + > +000e = >test_num = test_num + 1 +0d11 : a90e > lda #test_num ;*** next tests' number +0d13 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ;TSX sets NZ - TXS does not +0d16 : a201 ldx #1 ;01 + set_stat $ff + > load_flag $ff +0d18 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0d1a : 48 > pha ;use stack to load status +0d1b : 28 > plp + +0d1c : 9a txs +0d1d : 08 php +0d1e : ad0101 lda $101 + cmp_flag $ff +0d21 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + + trap_ne +0d23 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +0d25 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0d27 : 48 > pha ;use stack to load status +0d28 : 28 > plp + +0d29 : 9a txs +0d2a : 08 php +0d2b : ad0101 lda $101 + cmp_flag 0 +0d2e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + + trap_ne +0d30 : d0fe > bne * ;failed not equal (non zero) + +0d32 : ca dex ;00 + set_stat $ff + > load_flag $ff +0d33 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0d35 : 48 > pha ;use stack to load status +0d36 : 28 > plp + +0d37 : 9a txs +0d38 : 08 php +0d39 : ad0001 lda $100 + cmp_flag $ff +0d3c : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + + trap_ne +0d3e : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +0d40 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0d42 : 48 > pha ;use stack to load status +0d43 : 28 > plp + +0d44 : 9a txs +0d45 : 08 php +0d46 : ad0001 lda $100 + cmp_flag 0 +0d49 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + + trap_ne +0d4b : d0fe > bne * ;failed not equal (non zero) + +0d4d : ca dex ;ff + set_stat $ff + > load_flag $ff +0d4e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0d50 : 48 > pha ;use stack to load status +0d51 : 28 > plp + +0d52 : 9a txs +0d53 : 08 php +0d54 : adff01 lda $1ff + cmp_flag $ff +0d57 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + + trap_ne +0d59 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +0d5b : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0d5d : 48 > pha ;use stack to load status +0d5e : 28 > plp + +0d5f : 9a txs +0d60 : 08 php +0d61 : adff01 lda $1ff + cmp_flag 0 +0d64 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + + +0d66 : a201 ldx #1 +0d68 : 9a txs ;sp=01 + set_stat $ff + > load_flag $ff +0d69 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0d6b : 48 > pha ;use stack to load status +0d6c : 28 > plp + +0d6d : ba tsx ;clears Z, N +0d6e : 08 php ;sp=00 +0d6f : e001 cpx #1 + trap_ne +0d71 : d0fe > bne * ;failed not equal (non zero) + +0d73 : ad0101 lda $101 + cmp_flag $ff-minus-zero +0d76 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits + + trap_ne +0d78 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +0d7a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0d7c : 48 > pha ;use stack to load status +0d7d : 28 > plp + +0d7e : ba tsx ;clears N, sets Z +0d7f : 08 php ;sp=ff +0d80 : e000 cpx #0 + trap_ne +0d82 : d0fe > bne * ;failed not equal (non zero) + +0d84 : ad0001 lda $100 + cmp_flag $ff-minus +0d87 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + + trap_ne +0d89 : d0fe > bne * ;failed not equal (non zero) + + 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 : ba tsx ;clears N, sets Z +0d90 : 08 php ;sp=fe +0d91 : e0ff cpx #$ff + trap_ne +0d93 : d0fe > bne * ;failed not equal (non zero) + +0d95 : adff01 lda $1ff + cmp_flag $ff-zero +0d98 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + + trap_ne +0d9a : d0fe > bne * ;failed not equal (non zero) + + +0d9c : a201 ldx #1 +0d9e : 9a txs ;sp=01 + set_stat 0 + > load_flag 0 +0d9f : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0da1 : 48 > pha ;use stack to load status +0da2 : 28 > plp + +0da3 : ba tsx ;clears Z, N +0da4 : 08 php ;sp=00 +0da5 : e001 cpx #1 + trap_ne +0da7 : d0fe > bne * ;failed not equal (non zero) + +0da9 : ad0101 lda $101 + cmp_flag 0 +0dac : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + + trap_ne +0dae : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +0db0 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0db2 : 48 > pha ;use stack to load status +0db3 : 28 > plp + +0db4 : ba tsx ;clears N, sets Z +0db5 : 08 php ;sp=ff +0db6 : e000 cpx #0 + trap_ne +0db8 : d0fe > bne * ;failed not equal (non zero) + +0dba : ad0001 lda $100 + cmp_flag zero +0dbd : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + + trap_ne +0dbf : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +0dc1 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0dc3 : 48 > pha ;use stack to load status +0dc4 : 28 > plp + +0dc5 : ba tsx ;clears N, sets Z +0dc6 : 08 php ;sp=fe +0dc7 : e0ff cpx #$ff + trap_ne +0dc9 : d0fe > bne * ;failed not equal (non zero) + +0dcb : adff01 lda $1ff + cmp_flag minus +0dce : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + + trap_ne +0dd0 : d0fe > bne * ;failed not equal (non zero) + +0dd2 : 68 pla ;sp=ff + next_test +0dd3 : ad0002 > lda test_case ;previous test +0dd6 : c90e > cmp #test_num + > trap_ne ;test is out of sequence +0dd8 : d0fe > bne * ;failed not equal (non zero) + > +000f = >test_num = test_num + 1 +0dda : a90f > lda #test_num ;*** next tests' number +0ddc : 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 +0ddf : a003 ldy #3 +0de1 : tldx + set_stat 0 + > load_flag 0 +0de1 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0de3 : 48 > pha ;use stack to load status +0de4 : 28 > plp + +0de5 : b613 ldx zp1,y +0de7 : 08 php ;test stores do not alter flags +0de8 : 8a txa +0de9 : 49c3 eor #$c3 +0deb : 28 plp +0dec : 990302 sta abst,y +0def : 08 php ;flags after load/store sequence +0df0 : 49c3 eor #$c3 +0df2 : d90802 cmp abs1,y ;test result + trap_ne +0df5 : d0fe > bne * ;failed not equal (non zero) + +0df7 : 68 pla ;load status + eor_flag 0 +0df8 : 4930 > eor #0|fao ;invert expected flags + always on bits + +0dfa : d90d02 cmp fLDx,y ;test flags + trap_ne +0dfd : d0fe > bne * ;failed not equal (non zero) + +0dff : 88 dey +0e00 : 10df bpl tldx + +0e02 : a003 ldy #3 +0e04 : tldx1 + set_stat $ff + > load_flag $ff +0e04 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0e06 : 48 > pha ;use stack to load status +0e07 : 28 > plp + +0e08 : b613 ldx zp1,y +0e0a : 08 php ;test stores do not alter flags +0e0b : 8a txa +0e0c : 49c3 eor #$c3 +0e0e : 28 plp +0e0f : 990302 sta abst,y +0e12 : 08 php ;flags after load/store sequence +0e13 : 49c3 eor #$c3 +0e15 : d90802 cmp abs1,y ;test result + trap_ne +0e18 : d0fe > bne * ;failed not equal (non zero) + +0e1a : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +0e1b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +0e1d : d90d02 cmp fLDx,y ;test flags + trap_ne +0e20 : d0fe > bne * ;failed not equal (non zero) + +0e22 : 88 dey +0e23 : 10df bpl tldx1 + +0e25 : a003 ldy #3 +0e27 : tldx2 + set_stat 0 + > load_flag 0 +0e27 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0e29 : 48 > pha ;use stack to load status +0e2a : 28 > plp + +0e2b : be0802 ldx abs1,y +0e2e : 08 php ;test stores do not alter flags +0e2f : 8a txa +0e30 : 49c3 eor #$c3 +0e32 : aa tax +0e33 : 28 plp +0e34 : 960c stx zpt,y +0e36 : 08 php ;flags after load/store sequence +0e37 : 49c3 eor #$c3 +0e39 : d91300 cmp zp1,y ;test result + trap_ne +0e3c : d0fe > bne * ;failed not equal (non zero) + +0e3e : 68 pla ;load status + eor_flag 0 +0e3f : 4930 > eor #0|fao ;invert expected flags + always on bits + +0e41 : d90d02 cmp fLDx,y ;test flags + trap_ne +0e44 : d0fe > bne * ;failed not equal (non zero) + +0e46 : 88 dey +0e47 : 10de bpl tldx2 + +0e49 : a003 ldy #3 +0e4b : tldx3 + set_stat $ff + > load_flag $ff +0e4b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0e4d : 48 > pha ;use stack to load status +0e4e : 28 > plp + +0e4f : be0802 ldx abs1,y +0e52 : 08 php ;test stores do not alter flags +0e53 : 8a txa +0e54 : 49c3 eor #$c3 +0e56 : aa tax +0e57 : 28 plp +0e58 : 960c stx zpt,y +0e5a : 08 php ;flags after load/store sequence +0e5b : 49c3 eor #$c3 +0e5d : d91300 cmp zp1,y ;test result + trap_ne +0e60 : d0fe > bne * ;failed not equal (non zero) + +0e62 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +0e63 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +0e65 : d90d02 cmp fLDx,y ;test flags + trap_ne +0e68 : d0fe > bne * ;failed not equal (non zero) + +0e6a : 88 dey +0e6b : 10de bpl tldx3 + +0e6d : a003 ldy #3 ;testing store result +0e6f : a200 ldx #0 +0e71 : b90c00 tstx lda zpt,y +0e74 : 49c3 eor #$c3 +0e76 : d91300 cmp zp1,y + trap_ne ;store to zp data +0e79 : d0fe > bne * ;failed not equal (non zero) + +0e7b : 960c stx zpt,y ;clear +0e7d : b90302 lda abst,y +0e80 : 49c3 eor #$c3 +0e82 : d90802 cmp abs1,y + trap_ne ;store to abs data +0e85 : d0fe > bne * ;failed not equal (non zero) + +0e87 : 8a txa +0e88 : 990302 sta abst,y ;clear +0e8b : 88 dey +0e8c : 10e3 bpl tstx + next_test +0e8e : ad0002 > lda test_case ;previous test +0e91 : c90f > cmp #test_num + > trap_ne ;test is out of sequence +0e93 : d0fe > bne * ;failed not equal (non zero) + > +0010 = >test_num = test_num + 1 +0e95 : a910 > lda #test_num ;*** next tests' number +0e97 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; indexed wraparound test (only zp should wrap) +0e9a : a0fd ldy #3+$fa +0e9c : b619 tldx4 ldx zp1-$fa&$ff,y ;wrap on indexed zp +0e9e : 8a txa +0e9f : 990901 sta abst-$fa,y ;no STX abs,y! +0ea2 : 88 dey +0ea3 : c0fa cpy #$fa +0ea5 : b0f5 bcs tldx4 +0ea7 : a0fd ldy #3+$fa +0ea9 : be0e01 tldx5 ldx abs1-$fa,y ;no wrap on indexed abs +0eac : 9612 stx zpt-$fa&$ff,y +0eae : 88 dey +0eaf : c0fa cpy #$fa +0eb1 : b0f6 bcs tldx5 +0eb3 : a003 ldy #3 ;testing wraparound result +0eb5 : a200 ldx #0 +0eb7 : b90c00 tstx1 lda zpt,y +0eba : d91300 cmp zp1,y + trap_ne ;store to zp data +0ebd : d0fe > bne * ;failed not equal (non zero) + +0ebf : 960c stx zpt,y ;clear +0ec1 : b90302 lda abst,y +0ec4 : d90802 cmp abs1,y + trap_ne ;store to abs data +0ec7 : d0fe > bne * ;failed not equal (non zero) + +0ec9 : 8a txa +0eca : 990302 sta abst,y ;clear +0ecd : 88 dey +0ece : 10e7 bpl tstx1 + next_test +0ed0 : ad0002 > lda test_case ;previous test +0ed3 : c910 > cmp #test_num + > trap_ne ;test is out of sequence +0ed5 : d0fe > bne * ;failed not equal (non zero) + > +0011 = >test_num = test_num + 1 +0ed7 : a911 > lda #test_num ;*** next tests' number +0ed9 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; LDY / STY - zp,x / abs,x +0edc : a203 ldx #3 +0ede : tldy + set_stat 0 + > load_flag 0 +0ede : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0ee0 : 48 > pha ;use stack to load status +0ee1 : 28 > plp + +0ee2 : b413 ldy zp1,x +0ee4 : 08 php ;test stores do not alter flags +0ee5 : 98 tya +0ee6 : 49c3 eor #$c3 +0ee8 : 28 plp +0ee9 : 9d0302 sta abst,x +0eec : 08 php ;flags after load/store sequence +0eed : 49c3 eor #$c3 +0eef : dd0802 cmp abs1,x ;test result + trap_ne +0ef2 : d0fe > bne * ;failed not equal (non zero) + +0ef4 : 68 pla ;load status + eor_flag 0 +0ef5 : 4930 > eor #0|fao ;invert expected flags + always on bits + +0ef7 : dd0d02 cmp fLDx,x ;test flags + trap_ne +0efa : d0fe > bne * ;failed not equal (non zero) + +0efc : ca dex +0efd : 10df bpl tldy + +0eff : a203 ldx #3 +0f01 : tldy1 + set_stat $ff + > load_flag $ff +0f01 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0f03 : 48 > pha ;use stack to load status +0f04 : 28 > plp + +0f05 : b413 ldy zp1,x +0f07 : 08 php ;test stores do not alter flags +0f08 : 98 tya +0f09 : 49c3 eor #$c3 +0f0b : 28 plp +0f0c : 9d0302 sta abst,x +0f0f : 08 php ;flags after load/store sequence +0f10 : 49c3 eor #$c3 +0f12 : dd0802 cmp abs1,x ;test result + trap_ne +0f15 : d0fe > bne * ;failed not equal (non zero) + +0f17 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +0f18 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +0f1a : dd0d02 cmp fLDx,x ;test flags + trap_ne +0f1d : d0fe > bne * ;failed not equal (non zero) + +0f1f : ca dex +0f20 : 10df bpl tldy1 + +0f22 : a203 ldx #3 +0f24 : tldy2 + set_stat 0 + > load_flag 0 +0f24 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0f26 : 48 > pha ;use stack to load status +0f27 : 28 > plp + +0f28 : bc0802 ldy abs1,x +0f2b : 08 php ;test stores do not alter flags +0f2c : 98 tya +0f2d : 49c3 eor #$c3 +0f2f : a8 tay +0f30 : 28 plp +0f31 : 940c sty zpt,x +0f33 : 08 php ;flags after load/store sequence +0f34 : 49c3 eor #$c3 +0f36 : d513 cmp zp1,x ;test result + trap_ne +0f38 : d0fe > bne * ;failed not equal (non zero) + +0f3a : 68 pla ;load status + eor_flag 0 +0f3b : 4930 > eor #0|fao ;invert expected flags + always on bits + +0f3d : dd0d02 cmp fLDx,x ;test flags + trap_ne +0f40 : d0fe > bne * ;failed not equal (non zero) + +0f42 : ca dex +0f43 : 10df bpl tldy2 + +0f45 : a203 ldx #3 +0f47 : tldy3 + set_stat $ff + > load_flag $ff +0f47 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0f49 : 48 > pha ;use stack to load status +0f4a : 28 > plp + +0f4b : bc0802 ldy abs1,x +0f4e : 08 php ;test stores do not alter flags +0f4f : 98 tya +0f50 : 49c3 eor #$c3 +0f52 : a8 tay +0f53 : 28 plp +0f54 : 940c sty zpt,x +0f56 : 08 php ;flags after load/store sequence +0f57 : 49c3 eor #$c3 +0f59 : d513 cmp zp1,x ;test result + trap_ne +0f5b : d0fe > bne * ;failed not equal (non zero) + +0f5d : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +0f5e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +0f60 : dd0d02 cmp fLDx,x ;test flags + trap_ne +0f63 : d0fe > bne * ;failed not equal (non zero) + +0f65 : ca dex +0f66 : 10df bpl tldy3 + +0f68 : a203 ldx #3 ;testing store result +0f6a : a000 ldy #0 +0f6c : b50c tsty lda zpt,x +0f6e : 49c3 eor #$c3 +0f70 : d513 cmp zp1,x + trap_ne ;store to zp,x data +0f72 : d0fe > bne * ;failed not equal (non zero) + +0f74 : 940c sty zpt,x ;clear +0f76 : bd0302 lda abst,x +0f79 : 49c3 eor #$c3 +0f7b : dd0802 cmp abs1,x + trap_ne ;store to abs,x data +0f7e : d0fe > bne * ;failed not equal (non zero) + +0f80 : 8a txa +0f81 : 9d0302 sta abst,x ;clear +0f84 : ca dex +0f85 : 10e5 bpl tsty + next_test +0f87 : ad0002 > lda test_case ;previous test +0f8a : c911 > cmp #test_num + > trap_ne ;test is out of sequence +0f8c : d0fe > bne * ;failed not equal (non zero) + > +0012 = >test_num = test_num + 1 +0f8e : a912 > lda #test_num ;*** next tests' number +0f90 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; indexed wraparound test (only zp should wrap) +0f93 : a2fd ldx #3+$fa +0f95 : b419 tldy4 ldy zp1-$fa&$ff,x ;wrap on indexed zp +0f97 : 98 tya +0f98 : 9d0901 sta abst-$fa,x ;no STX abs,x! +0f9b : ca dex +0f9c : e0fa cpx #$fa +0f9e : b0f5 bcs tldy4 +0fa0 : a2fd ldx #3+$fa +0fa2 : bc0e01 tldy5 ldy abs1-$fa,x ;no wrap on indexed abs +0fa5 : 9412 sty zpt-$fa&$ff,x +0fa7 : ca dex +0fa8 : e0fa cpx #$fa +0faa : b0f6 bcs tldy5 +0fac : a203 ldx #3 ;testing wraparound result +0fae : a000 ldy #0 +0fb0 : b50c tsty1 lda zpt,x +0fb2 : d513 cmp zp1,x + trap_ne ;store to zp,x data +0fb4 : d0fe > bne * ;failed not equal (non zero) + +0fb6 : 940c sty zpt,x ;clear +0fb8 : bd0302 lda abst,x +0fbb : dd0802 cmp abs1,x + trap_ne ;store to abs,x data +0fbe : d0fe > bne * ;failed not equal (non zero) + +0fc0 : 8a txa +0fc1 : 9d0302 sta abst,x ;clear +0fc4 : ca dex +0fc5 : 10e9 bpl tsty1 + next_test +0fc7 : ad0002 > lda test_case ;previous test +0fca : c912 > cmp #test_num + > trap_ne ;test is out of sequence +0fcc : d0fe > bne * ;failed not equal (non zero) + > +0013 = >test_num = test_num + 1 +0fce : a913 > lda #test_num ;*** next tests' number +0fd0 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; LDX / STX - zp / abs / # + set_stat 0 + > load_flag 0 +0fd3 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0fd5 : 48 > pha ;use stack to load status +0fd6 : 28 > plp + +0fd7 : a613 ldx zp1 +0fd9 : 08 php ;test stores do not alter flags +0fda : 8a txa +0fdb : 49c3 eor #$c3 +0fdd : aa tax +0fde : 28 plp +0fdf : 8e0302 stx abst +0fe2 : 08 php ;flags after load/store sequence +0fe3 : 49c3 eor #$c3 +0fe5 : aa tax +0fe6 : e0c3 cpx #$c3 ;test result + trap_ne +0fe8 : d0fe > bne * ;failed not equal (non zero) + +0fea : 68 pla ;load status + eor_flag 0 +0feb : 4930 > eor #0|fao ;invert expected flags + always on bits + +0fed : cd0d02 cmp fLDx ;test flags + trap_ne +0ff0 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +0ff2 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0ff4 : 48 > pha ;use stack to load status +0ff5 : 28 > plp + +0ff6 : a614 ldx zp1+1 +0ff8 : 08 php ;test stores do not alter flags +0ff9 : 8a txa +0ffa : 49c3 eor #$c3 +0ffc : aa tax +0ffd : 28 plp +0ffe : 8e0402 stx abst+1 +1001 : 08 php ;flags after load/store sequence +1002 : 49c3 eor #$c3 +1004 : aa tax +1005 : e082 cpx #$82 ;test result + trap_ne +1007 : d0fe > bne * ;failed not equal (non zero) + +1009 : 68 pla ;load status + eor_flag 0 +100a : 4930 > eor #0|fao ;invert expected flags + always on bits + +100c : cd0e02 cmp fLDx+1 ;test flags + trap_ne +100f : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1011 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1013 : 48 > pha ;use stack to load status +1014 : 28 > plp + +1015 : a615 ldx zp1+2 +1017 : 08 php ;test stores do not alter flags +1018 : 8a txa +1019 : 49c3 eor #$c3 +101b : aa tax +101c : 28 plp +101d : 8e0502 stx abst+2 +1020 : 08 php ;flags after load/store sequence +1021 : 49c3 eor #$c3 +1023 : aa tax +1024 : e041 cpx #$41 ;test result + trap_ne +1026 : d0fe > bne * ;failed not equal (non zero) + +1028 : 68 pla ;load status + eor_flag 0 +1029 : 4930 > eor #0|fao ;invert expected flags + always on bits + +102b : cd0f02 cmp fLDx+2 ;test flags + trap_ne +102e : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1030 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1032 : 48 > pha ;use stack to load status +1033 : 28 > plp + +1034 : a616 ldx zp1+3 +1036 : 08 php ;test stores do not alter flags +1037 : 8a txa +1038 : 49c3 eor #$c3 +103a : aa tax +103b : 28 plp +103c : 8e0602 stx abst+3 +103f : 08 php ;flags after load/store sequence +1040 : 49c3 eor #$c3 +1042 : aa tax +1043 : e000 cpx #0 ;test result + trap_ne +1045 : d0fe > bne * ;failed not equal (non zero) + +1047 : 68 pla ;load status + eor_flag 0 +1048 : 4930 > eor #0|fao ;invert expected flags + always on bits + +104a : cd1002 cmp fLDx+3 ;test flags + trap_ne +104d : d0fe > bne * ;failed not equal (non zero) + + + set_stat $ff + > load_flag $ff +104f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1051 : 48 > pha ;use stack to load status +1052 : 28 > plp + +1053 : a613 ldx zp1 +1055 : 08 php ;test stores do not alter flags +1056 : 8a txa +1057 : 49c3 eor #$c3 +1059 : aa tax +105a : 28 plp +105b : 8e0302 stx abst +105e : 08 php ;flags after load/store sequence +105f : 49c3 eor #$c3 +1061 : aa tax +1062 : e0c3 cpx #$c3 ;test result + trap_ne ; +1064 : d0fe > bne * ;failed not equal (non zero) + +1066 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1067 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1069 : cd0d02 cmp fLDx ;test flags + trap_ne +106c : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +106e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1070 : 48 > pha ;use stack to load status +1071 : 28 > plp + +1072 : a614 ldx zp1+1 +1074 : 08 php ;test stores do not alter flags +1075 : 8a txa +1076 : 49c3 eor #$c3 +1078 : aa tax +1079 : 28 plp +107a : 8e0402 stx abst+1 +107d : 08 php ;flags after load/store sequence +107e : 49c3 eor #$c3 +1080 : aa tax +1081 : e082 cpx #$82 ;test result + trap_ne +1083 : d0fe > bne * ;failed not equal (non zero) + +1085 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1086 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1088 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +108b : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +108d : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +108f : 48 > pha ;use stack to load status +1090 : 28 > plp + +1091 : a615 ldx zp1+2 +1093 : 08 php ;test stores do not alter flags +1094 : 8a txa +1095 : 49c3 eor #$c3 +1097 : aa tax +1098 : 28 plp +1099 : 8e0502 stx abst+2 +109c : 08 php ;flags after load/store sequence +109d : 49c3 eor #$c3 +109f : aa tax +10a0 : e041 cpx #$41 ;test result + trap_ne ; +10a2 : d0fe > bne * ;failed not equal (non zero) + +10a4 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +10a5 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +10a7 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +10aa : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +10ac : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +10ae : 48 > pha ;use stack to load status +10af : 28 > plp + +10b0 : a616 ldx zp1+3 +10b2 : 08 php ;test stores do not alter flags +10b3 : 8a txa +10b4 : 49c3 eor #$c3 +10b6 : aa tax +10b7 : 28 plp +10b8 : 8e0602 stx abst+3 +10bb : 08 php ;flags after load/store sequence +10bc : 49c3 eor #$c3 +10be : aa tax +10bf : e000 cpx #0 ;test result + trap_ne +10c1 : d0fe > bne * ;failed not equal (non zero) + +10c3 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +10c4 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +10c6 : cd1002 cmp fLDx+3 ;test flags + trap_ne +10c9 : d0fe > bne * ;failed not equal (non zero) + + + set_stat 0 + > load_flag 0 +10cb : a900 > lda #0 ;allow test to change I-flag (no mask) + > +10cd : 48 > pha ;use stack to load status +10ce : 28 > plp + +10cf : ae0802 ldx abs1 +10d2 : 08 php ;test stores do not alter flags +10d3 : 8a txa +10d4 : 49c3 eor #$c3 +10d6 : aa tax +10d7 : 28 plp +10d8 : 860c stx zpt +10da : 08 php ;flags after load/store sequence +10db : 49c3 eor #$c3 +10dd : c513 cmp zp1 ;test result + trap_ne +10df : d0fe > bne * ;failed not equal (non zero) + +10e1 : 68 pla ;load status + eor_flag 0 +10e2 : 4930 > eor #0|fao ;invert expected flags + always on bits + +10e4 : cd0d02 cmp fLDx ;test flags + trap_ne +10e7 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +10e9 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +10eb : 48 > pha ;use stack to load status +10ec : 28 > plp + +10ed : ae0902 ldx abs1+1 +10f0 : 08 php ;test stores do not alter flags +10f1 : 8a txa +10f2 : 49c3 eor #$c3 +10f4 : aa tax +10f5 : 28 plp +10f6 : 860d stx zpt+1 +10f8 : 08 php ;flags after load/store sequence +10f9 : 49c3 eor #$c3 +10fb : c514 cmp zp1+1 ;test result + trap_ne +10fd : d0fe > bne * ;failed not equal (non zero) + +10ff : 68 pla ;load status + eor_flag 0 +1100 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1102 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +1105 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1107 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1109 : 48 > pha ;use stack to load status +110a : 28 > plp + +110b : ae0a02 ldx abs1+2 +110e : 08 php ;test stores do not alter flags +110f : 8a txa +1110 : 49c3 eor #$c3 +1112 : aa tax +1113 : 28 plp +1114 : 860e stx zpt+2 +1116 : 08 php ;flags after load/store sequence +1117 : 49c3 eor #$c3 +1119 : c515 cmp zp1+2 ;test result + trap_ne +111b : d0fe > bne * ;failed not equal (non zero) + +111d : 68 pla ;load status + eor_flag 0 +111e : 4930 > eor #0|fao ;invert expected flags + always on bits + +1120 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +1123 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1125 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1127 : 48 > pha ;use stack to load status +1128 : 28 > plp + +1129 : ae0b02 ldx abs1+3 +112c : 08 php ;test stores do not alter flags +112d : 8a txa +112e : 49c3 eor #$c3 +1130 : aa tax +1131 : 28 plp +1132 : 860f stx zpt+3 +1134 : 08 php ;flags after load/store sequence +1135 : 49c3 eor #$c3 +1137 : c516 cmp zp1+3 ;test result + trap_ne +1139 : d0fe > bne * ;failed not equal (non zero) + +113b : 68 pla ;load status + eor_flag 0 +113c : 4930 > eor #0|fao ;invert expected flags + always on bits + +113e : cd1002 cmp fLDx+3 ;test flags + trap_ne +1141 : d0fe > bne * ;failed not equal (non zero) + + + set_stat $ff + > load_flag $ff +1143 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1145 : 48 > pha ;use stack to load status +1146 : 28 > plp + +1147 : ae0802 ldx abs1 +114a : 08 php ;test stores do not alter flags +114b : 8a txa +114c : 49c3 eor #$c3 +114e : aa tax +114f : 28 plp +1150 : 860c stx zpt +1152 : 08 php ;flags after load/store sequence +1153 : 49c3 eor #$c3 +1155 : aa tax +1156 : e413 cpx zp1 ;test result + trap_ne +1158 : d0fe > bne * ;failed not equal (non zero) + +115a : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +115b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +115d : cd0d02 cmp fLDx ;test flags + trap_ne +1160 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1162 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1164 : 48 > pha ;use stack to load status +1165 : 28 > plp + +1166 : ae0902 ldx abs1+1 +1169 : 08 php ;test stores do not alter flags +116a : 8a txa +116b : 49c3 eor #$c3 +116d : aa tax +116e : 28 plp +116f : 860d stx zpt+1 +1171 : 08 php ;flags after load/store sequence +1172 : 49c3 eor #$c3 +1174 : aa tax +1175 : e414 cpx zp1+1 ;test result + trap_ne +1177 : d0fe > bne * ;failed not equal (non zero) + +1179 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +117a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +117c : cd0e02 cmp fLDx+1 ;test flags + trap_ne +117f : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1181 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1183 : 48 > pha ;use stack to load status +1184 : 28 > plp + +1185 : ae0a02 ldx abs1+2 +1188 : 08 php ;test stores do not alter flags +1189 : 8a txa +118a : 49c3 eor #$c3 +118c : aa tax +118d : 28 plp +118e : 860e stx zpt+2 +1190 : 08 php ;flags after load/store sequence +1191 : 49c3 eor #$c3 +1193 : aa tax +1194 : e415 cpx zp1+2 ;test result + trap_ne +1196 : d0fe > bne * ;failed not equal (non zero) + +1198 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1199 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +119b : cd0f02 cmp fLDx+2 ;test flags + trap_ne +119e : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +11a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +11a2 : 48 > pha ;use stack to load status +11a3 : 28 > plp + +11a4 : ae0b02 ldx abs1+3 +11a7 : 08 php ;test stores do not alter flags +11a8 : 8a txa +11a9 : 49c3 eor #$c3 +11ab : aa tax +11ac : 28 plp +11ad : 860f stx zpt+3 +11af : 08 php ;flags after load/store sequence +11b0 : 49c3 eor #$c3 +11b2 : aa tax +11b3 : e416 cpx zp1+3 ;test result + trap_ne +11b5 : d0fe > bne * ;failed not equal (non zero) + +11b7 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +11b8 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +11ba : cd1002 cmp fLDx+3 ;test flags + trap_ne +11bd : d0fe > bne * ;failed not equal (non zero) + + + set_stat 0 + > load_flag 0 +11bf : a900 > lda #0 ;allow test to change I-flag (no mask) + > +11c1 : 48 > pha ;use stack to load status +11c2 : 28 > plp + +11c3 : a2c3 ldx #$c3 +11c5 : 08 php +11c6 : ec0802 cpx abs1 ;test result + trap_ne +11c9 : d0fe > bne * ;failed not equal (non zero) + +11cb : 68 pla ;load status + eor_flag 0 +11cc : 4930 > eor #0|fao ;invert expected flags + always on bits + +11ce : cd0d02 cmp fLDx ;test flags + trap_ne +11d1 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +11d3 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +11d5 : 48 > pha ;use stack to load status +11d6 : 28 > plp + +11d7 : a282 ldx #$82 +11d9 : 08 php +11da : ec0902 cpx abs1+1 ;test result + trap_ne +11dd : d0fe > bne * ;failed not equal (non zero) + +11df : 68 pla ;load status + eor_flag 0 +11e0 : 4930 > eor #0|fao ;invert expected flags + always on bits + +11e2 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +11e5 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +11e7 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +11e9 : 48 > pha ;use stack to load status +11ea : 28 > plp + +11eb : a241 ldx #$41 +11ed : 08 php +11ee : ec0a02 cpx abs1+2 ;test result + trap_ne +11f1 : d0fe > bne * ;failed not equal (non zero) + +11f3 : 68 pla ;load status + eor_flag 0 +11f4 : 4930 > eor #0|fao ;invert expected flags + always on bits + +11f6 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +11f9 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +11fb : a900 > lda #0 ;allow test to change I-flag (no mask) + > +11fd : 48 > pha ;use stack to load status +11fe : 28 > plp + +11ff : a200 ldx #0 +1201 : 08 php +1202 : ec0b02 cpx abs1+3 ;test result + trap_ne +1205 : d0fe > bne * ;failed not equal (non zero) + +1207 : 68 pla ;load status + eor_flag 0 +1208 : 4930 > eor #0|fao ;invert expected flags + always on bits + +120a : cd1002 cmp fLDx+3 ;test flags + trap_ne +120d : d0fe > bne * ;failed not equal (non zero) + + + set_stat $ff + > load_flag $ff +120f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1211 : 48 > pha ;use stack to load status +1212 : 28 > plp + +1213 : a2c3 ldx #$c3 +1215 : 08 php +1216 : ec0802 cpx abs1 ;test result + trap_ne +1219 : d0fe > bne * ;failed not equal (non zero) + +121b : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +121c : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +121e : cd0d02 cmp fLDx ;test flags + trap_ne +1221 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1223 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1225 : 48 > pha ;use stack to load status +1226 : 28 > plp + +1227 : a282 ldx #$82 +1229 : 08 php +122a : ec0902 cpx abs1+1 ;test result + trap_ne +122d : d0fe > bne * ;failed not equal (non zero) + +122f : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1230 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1232 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +1235 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1237 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1239 : 48 > pha ;use stack to load status +123a : 28 > plp + +123b : a241 ldx #$41 +123d : 08 php +123e : ec0a02 cpx abs1+2 ;test result + trap_ne +1241 : d0fe > bne * ;failed not equal (non zero) + +1243 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1244 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1246 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +1249 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +124b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +124d : 48 > pha ;use stack to load status +124e : 28 > plp + +124f : a200 ldx #0 +1251 : 08 php +1252 : ec0b02 cpx abs1+3 ;test result + trap_ne +1255 : d0fe > bne * ;failed not equal (non zero) + +1257 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1258 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +125a : cd1002 cmp fLDx+3 ;test flags + trap_ne +125d : d0fe > bne * ;failed not equal (non zero) + + +125f : a200 ldx #0 +1261 : a50c lda zpt +1263 : 49c3 eor #$c3 +1265 : c513 cmp zp1 + trap_ne ;store to zp data +1267 : d0fe > bne * ;failed not equal (non zero) + +1269 : 860c stx zpt ;clear +126b : ad0302 lda abst +126e : 49c3 eor #$c3 +1270 : cd0802 cmp abs1 + trap_ne ;store to abs data +1273 : d0fe > bne * ;failed not equal (non zero) + +1275 : 8e0302 stx abst ;clear +1278 : a50d lda zpt+1 +127a : 49c3 eor #$c3 +127c : c514 cmp zp1+1 + trap_ne ;store to zp data +127e : d0fe > bne * ;failed not equal (non zero) + +1280 : 860d stx zpt+1 ;clear +1282 : ad0402 lda abst+1 +1285 : 49c3 eor #$c3 +1287 : cd0902 cmp abs1+1 + trap_ne ;store to abs data +128a : d0fe > bne * ;failed not equal (non zero) + +128c : 8e0402 stx abst+1 ;clear +128f : a50e lda zpt+2 +1291 : 49c3 eor #$c3 +1293 : c515 cmp zp1+2 + trap_ne ;store to zp data +1295 : d0fe > bne * ;failed not equal (non zero) + +1297 : 860e stx zpt+2 ;clear +1299 : ad0502 lda abst+2 +129c : 49c3 eor #$c3 +129e : cd0a02 cmp abs1+2 + trap_ne ;store to abs data +12a1 : d0fe > bne * ;failed not equal (non zero) + +12a3 : 8e0502 stx abst+2 ;clear +12a6 : a50f lda zpt+3 +12a8 : 49c3 eor #$c3 +12aa : c516 cmp zp1+3 + trap_ne ;store to zp data +12ac : d0fe > bne * ;failed not equal (non zero) + +12ae : 860f stx zpt+3 ;clear +12b0 : ad0602 lda abst+3 +12b3 : 49c3 eor #$c3 +12b5 : cd0b02 cmp abs1+3 + trap_ne ;store to abs data +12b8 : d0fe > bne * ;failed not equal (non zero) + +12ba : 8e0602 stx abst+3 ;clear + next_test +12bd : ad0002 > lda test_case ;previous test +12c0 : c913 > cmp #test_num + > trap_ne ;test is out of sequence +12c2 : d0fe > bne * ;failed not equal (non zero) + > +0014 = >test_num = test_num + 1 +12c4 : a914 > lda #test_num ;*** next tests' number +12c6 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; LDY / STY - zp / abs / # + set_stat 0 + > load_flag 0 +12c9 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +12cb : 48 > pha ;use stack to load status +12cc : 28 > plp + +12cd : a413 ldy zp1 +12cf : 08 php ;test stores do not alter flags +12d0 : 98 tya +12d1 : 49c3 eor #$c3 +12d3 : a8 tay +12d4 : 28 plp +12d5 : 8c0302 sty abst +12d8 : 08 php ;flags after load/store sequence +12d9 : 49c3 eor #$c3 +12db : a8 tay +12dc : c0c3 cpy #$c3 ;test result + trap_ne +12de : d0fe > bne * ;failed not equal (non zero) + +12e0 : 68 pla ;load status + eor_flag 0 +12e1 : 4930 > eor #0|fao ;invert expected flags + always on bits + +12e3 : cd0d02 cmp fLDx ;test flags + trap_ne +12e6 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +12e8 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +12ea : 48 > pha ;use stack to load status +12eb : 28 > plp + +12ec : a414 ldy zp1+1 +12ee : 08 php ;test stores do not alter flags +12ef : 98 tya +12f0 : 49c3 eor #$c3 +12f2 : a8 tay +12f3 : 28 plp +12f4 : 8c0402 sty abst+1 +12f7 : 08 php ;flags after load/store sequence +12f8 : 49c3 eor #$c3 +12fa : a8 tay +12fb : c082 cpy #$82 ;test result + trap_ne +12fd : d0fe > bne * ;failed not equal (non zero) + +12ff : 68 pla ;load status + eor_flag 0 +1300 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1302 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +1305 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1307 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1309 : 48 > pha ;use stack to load status +130a : 28 > plp + +130b : a415 ldy zp1+2 +130d : 08 php ;test stores do not alter flags +130e : 98 tya +130f : 49c3 eor #$c3 +1311 : a8 tay +1312 : 28 plp +1313 : 8c0502 sty abst+2 +1316 : 08 php ;flags after load/store sequence +1317 : 49c3 eor #$c3 +1319 : a8 tay +131a : c041 cpy #$41 ;test result + trap_ne +131c : d0fe > bne * ;failed not equal (non zero) + +131e : 68 pla ;load status + eor_flag 0 +131f : 4930 > eor #0|fao ;invert expected flags + always on bits + +1321 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +1324 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1326 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1328 : 48 > pha ;use stack to load status +1329 : 28 > plp + +132a : a416 ldy zp1+3 +132c : 08 php ;test stores do not alter flags +132d : 98 tya +132e : 49c3 eor #$c3 +1330 : a8 tay +1331 : 28 plp +1332 : 8c0602 sty abst+3 +1335 : 08 php ;flags after load/store sequence +1336 : 49c3 eor #$c3 +1338 : a8 tay +1339 : c000 cpy #0 ;test result + trap_ne +133b : d0fe > bne * ;failed not equal (non zero) + +133d : 68 pla ;load status + eor_flag 0 +133e : 4930 > eor #0|fao ;invert expected flags + always on bits + +1340 : cd1002 cmp fLDx+3 ;test flags + trap_ne +1343 : d0fe > bne * ;failed not equal (non zero) + + + set_stat $ff + > load_flag $ff +1345 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1347 : 48 > pha ;use stack to load status +1348 : 28 > plp + +1349 : a413 ldy zp1 +134b : 08 php ;test stores do not alter flags +134c : 98 tya +134d : 49c3 eor #$c3 +134f : a8 tay +1350 : 28 plp +1351 : 8c0302 sty abst +1354 : 08 php ;flags after load/store sequence +1355 : 49c3 eor #$c3 +1357 : a8 tay +1358 : c0c3 cpy #$c3 ;test result + trap_ne +135a : d0fe > bne * ;failed not equal (non zero) + +135c : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +135d : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +135f : cd0d02 cmp fLDx ;test flags + trap_ne +1362 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1364 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1366 : 48 > pha ;use stack to load status +1367 : 28 > plp + +1368 : a414 ldy zp1+1 +136a : 08 php ;test stores do not alter flags +136b : 98 tya +136c : 49c3 eor #$c3 +136e : a8 tay +136f : 28 plp +1370 : 8c0402 sty abst+1 +1373 : 08 php ;flags after load/store sequence +1374 : 49c3 eor #$c3 +1376 : a8 tay +1377 : c082 cpy #$82 ;test result + trap_ne +1379 : d0fe > bne * ;failed not equal (non zero) + +137b : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +137c : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +137e : cd0e02 cmp fLDx+1 ;test flags + trap_ne +1381 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1383 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1385 : 48 > pha ;use stack to load status +1386 : 28 > plp + +1387 : a415 ldy zp1+2 +1389 : 08 php ;test stores do not alter flags +138a : 98 tya +138b : 49c3 eor #$c3 +138d : a8 tay +138e : 28 plp +138f : 8c0502 sty abst+2 +1392 : 08 php ;flags after load/store sequence +1393 : 49c3 eor #$c3 +1395 : a8 tay +1396 : c041 cpy #$41 ;test result + trap_ne +1398 : d0fe > bne * ;failed not equal (non zero) + +139a : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +139b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +139d : cd0f02 cmp fLDx+2 ;test flags + trap_ne +13a0 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +13a2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +13a4 : 48 > pha ;use stack to load status +13a5 : 28 > plp + +13a6 : a416 ldy zp1+3 +13a8 : 08 php ;test stores do not alter flags +13a9 : 98 tya +13aa : 49c3 eor #$c3 +13ac : a8 tay +13ad : 28 plp +13ae : 8c0602 sty abst+3 +13b1 : 08 php ;flags after load/store sequence +13b2 : 49c3 eor #$c3 +13b4 : a8 tay +13b5 : c000 cpy #0 ;test result + trap_ne +13b7 : d0fe > bne * ;failed not equal (non zero) + +13b9 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +13ba : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +13bc : cd1002 cmp fLDx+3 ;test flags + trap_ne +13bf : d0fe > bne * ;failed not equal (non zero) + + + set_stat 0 + > load_flag 0 +13c1 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +13c3 : 48 > pha ;use stack to load status +13c4 : 28 > plp + +13c5 : ac0802 ldy abs1 +13c8 : 08 php ;test stores do not alter flags +13c9 : 98 tya +13ca : 49c3 eor #$c3 +13cc : a8 tay +13cd : 28 plp +13ce : 840c sty zpt +13d0 : 08 php ;flags after load/store sequence +13d1 : 49c3 eor #$c3 +13d3 : a8 tay +13d4 : c413 cpy zp1 ;test result + trap_ne +13d6 : d0fe > bne * ;failed not equal (non zero) + +13d8 : 68 pla ;load status + eor_flag 0 +13d9 : 4930 > eor #0|fao ;invert expected flags + always on bits + +13db : cd0d02 cmp fLDx ;test flags + trap_ne +13de : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +13e0 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +13e2 : 48 > pha ;use stack to load status +13e3 : 28 > plp + +13e4 : ac0902 ldy abs1+1 +13e7 : 08 php ;test stores do not alter flags +13e8 : 98 tya +13e9 : 49c3 eor #$c3 +13eb : a8 tay +13ec : 28 plp +13ed : 840d sty zpt+1 +13ef : 08 php ;flags after load/store sequence +13f0 : 49c3 eor #$c3 +13f2 : a8 tay +13f3 : c414 cpy zp1+1 ;test result + trap_ne +13f5 : d0fe > bne * ;failed not equal (non zero) + +13f7 : 68 pla ;load status + eor_flag 0 +13f8 : 4930 > eor #0|fao ;invert expected flags + always on bits + +13fa : cd0e02 cmp fLDx+1 ;test flags + trap_ne +13fd : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +13ff : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1401 : 48 > pha ;use stack to load status +1402 : 28 > plp + +1403 : ac0a02 ldy abs1+2 +1406 : 08 php ;test stores do not alter flags +1407 : 98 tya +1408 : 49c3 eor #$c3 +140a : a8 tay +140b : 28 plp +140c : 840e sty zpt+2 +140e : 08 php ;flags after load/store sequence +140f : 49c3 eor #$c3 +1411 : a8 tay +1412 : c415 cpy zp1+2 ;test result + trap_ne +1414 : d0fe > bne * ;failed not equal (non zero) + +1416 : 68 pla ;load status + eor_flag 0 +1417 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1419 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +141c : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +141e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1420 : 48 > pha ;use stack to load status +1421 : 28 > plp + +1422 : ac0b02 ldy abs1+3 +1425 : 08 php ;test stores do not alter flags +1426 : 98 tya +1427 : 49c3 eor #$c3 +1429 : a8 tay +142a : 28 plp +142b : 840f sty zpt+3 +142d : 08 php ;flags after load/store sequence +142e : 49c3 eor #$c3 +1430 : a8 tay +1431 : c416 cpy zp1+3 ;test result + trap_ne +1433 : d0fe > bne * ;failed not equal (non zero) + +1435 : 68 pla ;load status + eor_flag 0 +1436 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1438 : cd1002 cmp fLDx+3 ;test flags + trap_ne +143b : d0fe > bne * ;failed not equal (non zero) + + + set_stat $ff + > load_flag $ff +143d : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +143f : 48 > pha ;use stack to load status +1440 : 28 > plp + +1441 : ac0802 ldy abs1 +1444 : 08 php ;test stores do not alter flags +1445 : 98 tya +1446 : 49c3 eor #$c3 +1448 : a8 tay +1449 : 28 plp +144a : 840c sty zpt +144c : 08 php ;flags after load/store sequence +144d : 49c3 eor #$c3 +144f : a8 tay +1450 : c513 cmp zp1 ;test result + trap_ne +1452 : d0fe > bne * ;failed not equal (non zero) + +1454 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1455 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1457 : cd0d02 cmp fLDx ;test flags + trap_ne +145a : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +145c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +145e : 48 > pha ;use stack to load status +145f : 28 > plp + +1460 : ac0902 ldy abs1+1 +1463 : 08 php ;test stores do not alter flags +1464 : 98 tya +1465 : 49c3 eor #$c3 +1467 : a8 tay +1468 : 28 plp +1469 : 840d sty zpt+1 +146b : 08 php ;flags after load/store sequence +146c : 49c3 eor #$c3 +146e : a8 tay +146f : c514 cmp zp1+1 ;test result + trap_ne +1471 : d0fe > bne * ;failed not equal (non zero) + +1473 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1474 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1476 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +1479 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +147b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +147d : 48 > pha ;use stack to load status +147e : 28 > plp + +147f : ac0a02 ldy abs1+2 +1482 : 08 php ;test stores do not alter flags +1483 : 98 tya +1484 : 49c3 eor #$c3 +1486 : a8 tay +1487 : 28 plp +1488 : 840e sty zpt+2 +148a : 08 php ;flags after load/store sequence +148b : 49c3 eor #$c3 +148d : a8 tay +148e : c515 cmp zp1+2 ;test result + trap_ne +1490 : d0fe > bne * ;failed not equal (non zero) + +1492 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1493 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1495 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +1498 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +149a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +149c : 48 > pha ;use stack to load status +149d : 28 > plp + +149e : ac0b02 ldy abs1+3 +14a1 : 08 php ;test stores do not alter flags +14a2 : 98 tya +14a3 : 49c3 eor #$c3 +14a5 : a8 tay +14a6 : 28 plp +14a7 : 840f sty zpt+3 +14a9 : 08 php ;flags after load/store sequence +14aa : 49c3 eor #$c3 +14ac : a8 tay +14ad : c516 cmp zp1+3 ;test result + trap_ne +14af : d0fe > bne * ;failed not equal (non zero) + +14b1 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +14b2 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +14b4 : cd1002 cmp fLDx+3 ;test flags + trap_ne +14b7 : d0fe > bne * ;failed not equal (non zero) + + + + set_stat 0 + > load_flag 0 +14b9 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +14bb : 48 > pha ;use stack to load status +14bc : 28 > plp + +14bd : a0c3 ldy #$c3 +14bf : 08 php +14c0 : cc0802 cpy abs1 ;test result + trap_ne +14c3 : d0fe > bne * ;failed not equal (non zero) + +14c5 : 68 pla ;load status + eor_flag 0 +14c6 : 4930 > eor #0|fao ;invert expected flags + always on bits + +14c8 : cd0d02 cmp fLDx ;test flags + trap_ne +14cb : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +14cd : a900 > lda #0 ;allow test to change I-flag (no mask) + > +14cf : 48 > pha ;use stack to load status +14d0 : 28 > plp + +14d1 : a082 ldy #$82 +14d3 : 08 php +14d4 : cc0902 cpy abs1+1 ;test result + trap_ne +14d7 : d0fe > bne * ;failed not equal (non zero) + +14d9 : 68 pla ;load status + eor_flag 0 +14da : 4930 > eor #0|fao ;invert expected flags + always on bits + +14dc : cd0e02 cmp fLDx+1 ;test flags + trap_ne +14df : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +14e1 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +14e3 : 48 > pha ;use stack to load status +14e4 : 28 > plp + +14e5 : a041 ldy #$41 +14e7 : 08 php +14e8 : cc0a02 cpy abs1+2 ;test result + trap_ne +14eb : d0fe > bne * ;failed not equal (non zero) + +14ed : 68 pla ;load status + eor_flag 0 +14ee : 4930 > eor #0|fao ;invert expected flags + always on bits + +14f0 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +14f3 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +14f5 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +14f7 : 48 > pha ;use stack to load status +14f8 : 28 > plp + +14f9 : a000 ldy #0 +14fb : 08 php +14fc : cc0b02 cpy abs1+3 ;test result + trap_ne +14ff : d0fe > bne * ;failed not equal (non zero) + +1501 : 68 pla ;load status + eor_flag 0 +1502 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1504 : cd1002 cmp fLDx+3 ;test flags + trap_ne +1507 : d0fe > bne * ;failed not equal (non zero) + + + set_stat $ff + > load_flag $ff +1509 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +150b : 48 > pha ;use stack to load status +150c : 28 > plp + +150d : a0c3 ldy #$c3 +150f : 08 php +1510 : cc0802 cpy abs1 ;test result + trap_ne +1513 : d0fe > bne * ;failed not equal (non zero) + +1515 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1516 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1518 : cd0d02 cmp fLDx ;test flags + trap_ne +151b : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +151d : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +151f : 48 > pha ;use stack to load status +1520 : 28 > plp + +1521 : a082 ldy #$82 +1523 : 08 php +1524 : cc0902 cpy abs1+1 ;test result + trap_ne +1527 : d0fe > bne * ;failed not equal (non zero) + +1529 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +152a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +152c : cd0e02 cmp fLDx+1 ;test flags + trap_ne +152f : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1531 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1533 : 48 > pha ;use stack to load status +1534 : 28 > plp + +1535 : a041 ldy #$41 +1537 : 08 php +1538 : cc0a02 cpy abs1+2 ;test result + trap_ne +153b : d0fe > bne * ;failed not equal (non zero) + +153d : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +153e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1540 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +1543 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1545 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1547 : 48 > pha ;use stack to load status +1548 : 28 > plp + +1549 : a000 ldy #0 +154b : 08 php +154c : cc0b02 cpy abs1+3 ;test result + trap_ne +154f : d0fe > bne * ;failed not equal (non zero) + +1551 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1552 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1554 : cd1002 cmp fLDx+3 ;test flags + trap_ne +1557 : d0fe > bne * ;failed not equal (non zero) + + +1559 : a000 ldy #0 +155b : a50c lda zpt +155d : 49c3 eor #$c3 +155f : c513 cmp zp1 + trap_ne ;store to zp data +1561 : d0fe > bne * ;failed not equal (non zero) + +1563 : 840c sty zpt ;clear +1565 : ad0302 lda abst +1568 : 49c3 eor #$c3 +156a : cd0802 cmp abs1 + trap_ne ;store to abs data +156d : d0fe > bne * ;failed not equal (non zero) + +156f : 8c0302 sty abst ;clear +1572 : a50d lda zpt+1 +1574 : 49c3 eor #$c3 +1576 : c514 cmp zp1+1 + trap_ne ;store to zp+1 data +1578 : d0fe > bne * ;failed not equal (non zero) + +157a : 840d sty zpt+1 ;clear +157c : ad0402 lda abst+1 +157f : 49c3 eor #$c3 +1581 : cd0902 cmp abs1+1 + trap_ne ;store to abs+1 data +1584 : d0fe > bne * ;failed not equal (non zero) + +1586 : 8c0402 sty abst+1 ;clear +1589 : a50e lda zpt+2 +158b : 49c3 eor #$c3 +158d : c515 cmp zp1+2 + trap_ne ;store to zp+2 data +158f : d0fe > bne * ;failed not equal (non zero) + +1591 : 840e sty zpt+2 ;clear +1593 : ad0502 lda abst+2 +1596 : 49c3 eor #$c3 +1598 : cd0a02 cmp abs1+2 + trap_ne ;store to abs+2 data +159b : d0fe > bne * ;failed not equal (non zero) + +159d : 8c0502 sty abst+2 ;clear +15a0 : a50f lda zpt+3 +15a2 : 49c3 eor #$c3 +15a4 : c516 cmp zp1+3 + trap_ne ;store to zp+3 data +15a6 : d0fe > bne * ;failed not equal (non zero) + +15a8 : 840f sty zpt+3 ;clear +15aa : ad0602 lda abst+3 +15ad : 49c3 eor #$c3 +15af : cd0b02 cmp abs1+3 + trap_ne ;store to abs+3 data +15b2 : d0fe > bne * ;failed not equal (non zero) + +15b4 : 8c0602 sty abst+3 ;clear + next_test +15b7 : ad0002 > lda test_case ;previous test +15ba : c914 > cmp #test_num + > trap_ne ;test is out of sequence +15bc : d0fe > bne * ;failed not equal (non zero) + > +0015 = >test_num = test_num + 1 +15be : a915 > lda #test_num ;*** next tests' number +15c0 : 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 +15c3 : a203 ldx #3 +15c5 : tldax + set_stat 0 + > load_flag 0 +15c5 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +15c7 : 48 > pha ;use stack to load status +15c8 : 28 > plp + +15c9 : b513 lda zp1,x +15cb : 08 php ;test stores do not alter flags +15cc : 49c3 eor #$c3 +15ce : 28 plp +15cf : 9d0302 sta abst,x +15d2 : 08 php ;flags after load/store sequence +15d3 : 49c3 eor #$c3 +15d5 : dd0802 cmp abs1,x ;test result + trap_ne +15d8 : d0fe > bne * ;failed not equal (non zero) + +15da : 68 pla ;load status + eor_flag 0 +15db : 4930 > eor #0|fao ;invert expected flags + always on bits + +15dd : dd0d02 cmp fLDx,x ;test flags + trap_ne +15e0 : d0fe > bne * ;failed not equal (non zero) + +15e2 : ca dex +15e3 : 10e0 bpl tldax + +15e5 : a203 ldx #3 +15e7 : tldax1 + set_stat $ff + > load_flag $ff +15e7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +15e9 : 48 > pha ;use stack to load status +15ea : 28 > plp + +15eb : b513 lda zp1,x +15ed : 08 php ;test stores do not alter flags +15ee : 49c3 eor #$c3 +15f0 : 28 plp +15f1 : 9d0302 sta abst,x +15f4 : 08 php ;flags after load/store sequence +15f5 : 49c3 eor #$c3 +15f7 : dd0802 cmp abs1,x ;test result + trap_ne +15fa : d0fe > bne * ;failed not equal (non zero) + +15fc : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +15fd : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +15ff : dd0d02 cmp fLDx,x ;test flags + trap_ne +1602 : d0fe > bne * ;failed not equal (non zero) + +1604 : ca dex +1605 : 10e0 bpl tldax1 + +1607 : a203 ldx #3 +1609 : tldax2 + set_stat 0 + > load_flag 0 +1609 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +160b : 48 > pha ;use stack to load status +160c : 28 > plp + +160d : bd0802 lda abs1,x +1610 : 08 php ;test stores do not alter flags +1611 : 49c3 eor #$c3 +1613 : 28 plp +1614 : 950c sta zpt,x +1616 : 08 php ;flags after load/store sequence +1617 : 49c3 eor #$c3 +1619 : d513 cmp zp1,x ;test result + trap_ne +161b : d0fe > bne * ;failed not equal (non zero) + +161d : 68 pla ;load status + eor_flag 0 +161e : 4930 > eor #0|fao ;invert expected flags + always on bits + +1620 : dd0d02 cmp fLDx,x ;test flags + trap_ne +1623 : d0fe > bne * ;failed not equal (non zero) + +1625 : ca dex +1626 : 10e1 bpl tldax2 + +1628 : a203 ldx #3 +162a : tldax3 + set_stat $ff + > load_flag $ff +162a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +162c : 48 > pha ;use stack to load status +162d : 28 > plp + +162e : bd0802 lda abs1,x +1631 : 08 php ;test stores do not alter flags +1632 : 49c3 eor #$c3 +1634 : 28 plp +1635 : 950c sta zpt,x +1637 : 08 php ;flags after load/store sequence +1638 : 49c3 eor #$c3 +163a : d513 cmp zp1,x ;test result + trap_ne +163c : d0fe > bne * ;failed not equal (non zero) + +163e : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +163f : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1641 : dd0d02 cmp fLDx,x ;test flags + trap_ne +1644 : d0fe > bne * ;failed not equal (non zero) + +1646 : ca dex +1647 : 10e1 bpl tldax3 + +1649 : a203 ldx #3 ;testing store result +164b : a000 ldy #0 +164d : b50c tstax lda zpt,x +164f : 49c3 eor #$c3 +1651 : d513 cmp zp1,x + trap_ne ;store to zp,x data +1653 : d0fe > bne * ;failed not equal (non zero) + +1655 : 940c sty zpt,x ;clear +1657 : bd0302 lda abst,x +165a : 49c3 eor #$c3 +165c : dd0802 cmp abs1,x + trap_ne ;store to abs,x data +165f : d0fe > bne * ;failed not equal (non zero) + +1661 : 8a txa +1662 : 9d0302 sta abst,x ;clear +1665 : ca dex +1666 : 10e5 bpl tstax + next_test +1668 : ad0002 > lda test_case ;previous test +166b : c915 > cmp #test_num + > trap_ne ;test is out of sequence +166d : d0fe > bne * ;failed not equal (non zero) + > +0016 = >test_num = test_num + 1 +166f : a916 > lda #test_num ;*** next tests' number +1671 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; LDA / STA - (zp),y / abs,y / (zp,x) +1674 : a003 ldy #3 +1676 : tlday + set_stat 0 + > load_flag 0 +1676 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1678 : 48 > pha ;use stack to load status +1679 : 28 > plp + +167a : b124 lda (ind1),y +167c : 08 php ;test stores do not alter flags +167d : 49c3 eor #$c3 +167f : 28 plp +1680 : 990302 sta abst,y +1683 : 08 php ;flags after load/store sequence +1684 : 49c3 eor #$c3 +1686 : d90802 cmp abs1,y ;test result + trap_ne +1689 : d0fe > bne * ;failed not equal (non zero) + +168b : 68 pla ;load status + eor_flag 0 +168c : 4930 > eor #0|fao ;invert expected flags + always on bits + +168e : d90d02 cmp fLDx,y ;test flags + trap_ne +1691 : d0fe > bne * ;failed not equal (non zero) + +1693 : 88 dey +1694 : 10e0 bpl tlday + +1696 : a003 ldy #3 +1698 : tlday1 + set_stat $ff + > load_flag $ff +1698 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +169a : 48 > pha ;use stack to load status +169b : 28 > plp + +169c : b124 lda (ind1),y +169e : 08 php ;test stores do not alter flags +169f : 49c3 eor #$c3 +16a1 : 28 plp +16a2 : 990302 sta abst,y +16a5 : 08 php ;flags after load/store sequence +16a6 : 49c3 eor #$c3 +16a8 : d90802 cmp abs1,y ;test result + trap_ne +16ab : d0fe > bne * ;failed not equal (non zero) + +16ad : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +16ae : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +16b0 : d90d02 cmp fLDx,y ;test flags + trap_ne +16b3 : d0fe > bne * ;failed not equal (non zero) + +16b5 : 88 dey +16b6 : 10e0 bpl tlday1 + +16b8 : a003 ldy #3 ;testing store result +16ba : a200 ldx #0 +16bc : b90302 tstay lda abst,y +16bf : 49c3 eor #$c3 +16c1 : d90802 cmp abs1,y + trap_ne ;store to abs data +16c4 : d0fe > bne * ;failed not equal (non zero) + +16c6 : 8a txa +16c7 : 990302 sta abst,y ;clear +16ca : 88 dey +16cb : 10ef bpl tstay + +16cd : a003 ldy #3 +16cf : tlday2 + set_stat 0 + > load_flag 0 +16cf : a900 > lda #0 ;allow test to change I-flag (no mask) + > +16d1 : 48 > pha ;use stack to load status +16d2 : 28 > plp + +16d3 : b90802 lda abs1,y +16d6 : 08 php ;test stores do not alter flags +16d7 : 49c3 eor #$c3 +16d9 : 28 plp +16da : 9130 sta (indt),y +16dc : 08 php ;flags after load/store sequence +16dd : 49c3 eor #$c3 +16df : d124 cmp (ind1),y ;test result + trap_ne +16e1 : d0fe > bne * ;failed not equal (non zero) + +16e3 : 68 pla ;load status + eor_flag 0 +16e4 : 4930 > eor #0|fao ;invert expected flags + always on bits + +16e6 : d90d02 cmp fLDx,y ;test flags + trap_ne +16e9 : d0fe > bne * ;failed not equal (non zero) + +16eb : 88 dey +16ec : 10e1 bpl tlday2 + +16ee : a003 ldy #3 +16f0 : tlday3 + set_stat $ff + > load_flag $ff +16f0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +16f2 : 48 > pha ;use stack to load status +16f3 : 28 > plp + +16f4 : b90802 lda abs1,y +16f7 : 08 php ;test stores do not alter flags +16f8 : 49c3 eor #$c3 +16fa : 28 plp +16fb : 9130 sta (indt),y +16fd : 08 php ;flags after load/store sequence +16fe : 49c3 eor #$c3 +1700 : d124 cmp (ind1),y ;test result + trap_ne +1702 : d0fe > bne * ;failed not equal (non zero) + +1704 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1705 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1707 : d90d02 cmp fLDx,y ;test flags + trap_ne +170a : d0fe > bne * ;failed not equal (non zero) + +170c : 88 dey +170d : 10e1 bpl tlday3 + +170f : a003 ldy #3 ;testing store result +1711 : a200 ldx #0 +1713 : b90302 tstay1 lda abst,y +1716 : 49c3 eor #$c3 +1718 : d90802 cmp abs1,y + trap_ne ;store to abs data +171b : d0fe > bne * ;failed not equal (non zero) + +171d : 8a txa +171e : 990302 sta abst,y ;clear +1721 : 88 dey +1722 : 10ef bpl tstay1 + +1724 : a206 ldx #6 +1726 : a003 ldy #3 +1728 : tldax4 + set_stat 0 + > load_flag 0 +1728 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +172a : 48 > pha ;use stack to load status +172b : 28 > plp + +172c : a124 lda (ind1,x) +172e : 08 php ;test stores do not alter flags +172f : 49c3 eor #$c3 +1731 : 28 plp +1732 : 8130 sta (indt,x) +1734 : 08 php ;flags after load/store sequence +1735 : 49c3 eor #$c3 +1737 : d90802 cmp abs1,y ;test result + trap_ne +173a : d0fe > bne * ;failed not equal (non zero) + +173c : 68 pla ;load status + eor_flag 0 +173d : 4930 > eor #0|fao ;invert expected flags + always on bits + +173f : d90d02 cmp fLDx,y ;test flags + trap_ne +1742 : d0fe > bne * ;failed not equal (non zero) + +1744 : ca dex +1745 : ca dex +1746 : 88 dey +1747 : 10df bpl tldax4 + +1749 : a206 ldx #6 +174b : a003 ldy #3 +174d : tldax5 + set_stat $ff + > load_flag $ff +174d : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +174f : 48 > pha ;use stack to load status +1750 : 28 > plp + +1751 : a124 lda (ind1,x) +1753 : 08 php ;test stores do not alter flags +1754 : 49c3 eor #$c3 +1756 : 28 plp +1757 : 8130 sta (indt,x) +1759 : 08 php ;flags after load/store sequence +175a : 49c3 eor #$c3 +175c : d90802 cmp abs1,y ;test result + trap_ne +175f : d0fe > bne * ;failed not equal (non zero) + +1761 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1762 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1764 : d90d02 cmp fLDx,y ;test flags + trap_ne +1767 : d0fe > bne * ;failed not equal (non zero) + +1769 : ca dex +176a : ca dex +176b : 88 dey +176c : 10df bpl tldax5 + +176e : a003 ldy #3 ;testing store result +1770 : a200 ldx #0 +1772 : b90302 tstay2 lda abst,y +1775 : 49c3 eor #$c3 +1777 : d90802 cmp abs1,y + trap_ne ;store to abs data +177a : d0fe > bne * ;failed not equal (non zero) + +177c : 8a txa +177d : 990302 sta abst,y ;clear +1780 : 88 dey +1781 : 10ef bpl tstay2 + next_test +1783 : ad0002 > lda test_case ;previous test +1786 : c916 > cmp #test_num + > trap_ne ;test is out of sequence +1788 : d0fe > bne * ;failed not equal (non zero) + > +0017 = >test_num = test_num + 1 +178a : a917 > lda #test_num ;*** next tests' number +178c : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; indexed wraparound test (only zp should wrap) +178f : a2fd ldx #3+$fa +1791 : b519 tldax6 lda zp1-$fa&$ff,x ;wrap on indexed zp +1793 : 9d0901 sta abst-$fa,x ;no STX abs,x! +1796 : ca dex +1797 : e0fa cpx #$fa +1799 : b0f6 bcs tldax6 +179b : a2fd ldx #3+$fa +179d : bd0e01 tldax7 lda abs1-$fa,x ;no wrap on indexed abs +17a0 : 9512 sta zpt-$fa&$ff,x +17a2 : ca dex +17a3 : e0fa cpx #$fa +17a5 : b0f6 bcs tldax7 + +17a7 : a203 ldx #3 ;testing wraparound result +17a9 : a000 ldy #0 +17ab : b50c tstax1 lda zpt,x +17ad : d513 cmp zp1,x + trap_ne ;store to zp,x data +17af : d0fe > bne * ;failed not equal (non zero) + +17b1 : 940c sty zpt,x ;clear +17b3 : bd0302 lda abst,x +17b6 : dd0802 cmp abs1,x + trap_ne ;store to abs,x data +17b9 : d0fe > bne * ;failed not equal (non zero) + +17bb : 8a txa +17bc : 9d0302 sta abst,x ;clear +17bf : ca dex +17c0 : 10e9 bpl tstax1 + +17c2 : a0fb ldy #3+$f8 +17c4 : a2fe ldx #6+$f8 +17c6 : a12c tlday4 lda (ind1-$f8&$ff,x) ;wrap on indexed zp indirect +17c8 : 990b01 sta abst-$f8,y +17cb : ca dex +17cc : ca dex +17cd : 88 dey +17ce : c0f8 cpy #$f8 +17d0 : b0f4 bcs tlday4 +17d2 : a003 ldy #3 ;testing wraparound result +17d4 : a200 ldx #0 +17d6 : b90302 tstay4 lda abst,y +17d9 : d90802 cmp abs1,y + trap_ne ;store to abs data +17dc : d0fe > bne * ;failed not equal (non zero) + +17de : 8a txa +17df : 990302 sta abst,y ;clear +17e2 : 88 dey +17e3 : 10f1 bpl tstay4 + +17e5 : a0fb ldy #3+$f8 +17e7 : b91001 tlday5 lda abs1-$f8,y ;no wrap on indexed abs +17ea : 9138 sta (inwt),y +17ec : 88 dey +17ed : c0f8 cpy #$f8 +17ef : b0f6 bcs tlday5 +17f1 : a003 ldy #3 ;testing wraparound result +17f3 : a200 ldx #0 +17f5 : b90302 tstay5 lda abst,y +17f8 : d90802 cmp abs1,y + trap_ne ;store to abs data +17fb : d0fe > bne * ;failed not equal (non zero) + +17fd : 8a txa +17fe : 990302 sta abst,y ;clear +1801 : 88 dey +1802 : 10f1 bpl tstay5 + +1804 : a0fb ldy #3+$f8 +1806 : a2fe ldx #6+$f8 +1808 : b12e tlday6 lda (inw1),y ;no wrap on zp indirect indexed +180a : 8138 sta (indt-$f8&$ff,x) +180c : ca dex +180d : ca dex +180e : 88 dey +180f : c0f8 cpy #$f8 +1811 : b0f5 bcs tlday6 +1813 : a003 ldy #3 ;testing wraparound result +1815 : a200 ldx #0 +1817 : b90302 tstay6 lda abst,y +181a : d90802 cmp abs1,y + trap_ne ;store to abs data +181d : d0fe > bne * ;failed not equal (non zero) + +181f : 8a txa +1820 : 990302 sta abst,y ;clear +1823 : 88 dey +1824 : 10f1 bpl tstay6 + next_test +1826 : ad0002 > lda test_case ;previous test +1829 : c917 > cmp #test_num + > trap_ne ;test is out of sequence +182b : d0fe > bne * ;failed not equal (non zero) + > +0018 = >test_num = test_num + 1 +182d : a918 > lda #test_num ;*** next tests' number +182f : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; LDA / STA - zp / abs / # + set_stat 0 + > load_flag 0 +1832 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1834 : 48 > pha ;use stack to load status +1835 : 28 > plp + +1836 : a513 lda zp1 +1838 : 08 php ;test stores do not alter flags +1839 : 49c3 eor #$c3 +183b : 28 plp +183c : 8d0302 sta abst +183f : 08 php ;flags after load/store sequence +1840 : 49c3 eor #$c3 +1842 : c9c3 cmp #$c3 ;test result + trap_ne +1844 : d0fe > bne * ;failed not equal (non zero) + +1846 : 68 pla ;load status + eor_flag 0 +1847 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1849 : cd0d02 cmp fLDx ;test flags + trap_ne +184c : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +184e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1850 : 48 > pha ;use stack to load status +1851 : 28 > plp + +1852 : a514 lda zp1+1 +1854 : 08 php ;test stores do not alter flags +1855 : 49c3 eor #$c3 +1857 : 28 plp +1858 : 8d0402 sta abst+1 +185b : 08 php ;flags after load/store sequence +185c : 49c3 eor #$c3 +185e : c982 cmp #$82 ;test result + trap_ne +1860 : d0fe > bne * ;failed not equal (non zero) + +1862 : 68 pla ;load status + eor_flag 0 +1863 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1865 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +1868 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +186a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +186c : 48 > pha ;use stack to load status +186d : 28 > plp + +186e : a515 lda zp1+2 +1870 : 08 php ;test stores do not alter flags +1871 : 49c3 eor #$c3 +1873 : 28 plp +1874 : 8d0502 sta abst+2 +1877 : 08 php ;flags after load/store sequence +1878 : 49c3 eor #$c3 +187a : c941 cmp #$41 ;test result + trap_ne +187c : d0fe > bne * ;failed not equal (non zero) + +187e : 68 pla ;load status + eor_flag 0 +187f : 4930 > eor #0|fao ;invert expected flags + always on bits + +1881 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +1884 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1886 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1888 : 48 > pha ;use stack to load status +1889 : 28 > plp + +188a : a516 lda zp1+3 +188c : 08 php ;test stores do not alter flags +188d : 49c3 eor #$c3 +188f : 28 plp +1890 : 8d0602 sta abst+3 +1893 : 08 php ;flags after load/store sequence +1894 : 49c3 eor #$c3 +1896 : c900 cmp #0 ;test result + trap_ne +1898 : d0fe > bne * ;failed not equal (non zero) + +189a : 68 pla ;load status + eor_flag 0 +189b : 4930 > eor #0|fao ;invert expected flags + always on bits + +189d : cd1002 cmp fLDx+3 ;test flags + trap_ne +18a0 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +18a2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +18a4 : 48 > pha ;use stack to load status +18a5 : 28 > plp + +18a6 : a513 lda zp1 +18a8 : 08 php ;test stores do not alter flags +18a9 : 49c3 eor #$c3 +18ab : 28 plp +18ac : 8d0302 sta abst +18af : 08 php ;flags after load/store sequence +18b0 : 49c3 eor #$c3 +18b2 : c9c3 cmp #$c3 ;test result + trap_ne +18b4 : d0fe > bne * ;failed not equal (non zero) + +18b6 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +18b7 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +18b9 : cd0d02 cmp fLDx ;test flags + trap_ne +18bc : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +18be : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +18c0 : 48 > pha ;use stack to load status +18c1 : 28 > plp + +18c2 : a514 lda zp1+1 +18c4 : 08 php ;test stores do not alter flags +18c5 : 49c3 eor #$c3 +18c7 : 28 plp +18c8 : 8d0402 sta abst+1 +18cb : 08 php ;flags after load/store sequence +18cc : 49c3 eor #$c3 +18ce : c982 cmp #$82 ;test result + trap_ne +18d0 : d0fe > bne * ;failed not equal (non zero) + +18d2 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +18d3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +18d5 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +18d8 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +18da : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +18dc : 48 > pha ;use stack to load status +18dd : 28 > plp + +18de : a515 lda zp1+2 +18e0 : 08 php ;test stores do not alter flags +18e1 : 49c3 eor #$c3 +18e3 : 28 plp +18e4 : 8d0502 sta abst+2 +18e7 : 08 php ;flags after load/store sequence +18e8 : 49c3 eor #$c3 +18ea : c941 cmp #$41 ;test result + trap_ne +18ec : d0fe > bne * ;failed not equal (non zero) + +18ee : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +18ef : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +18f1 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +18f4 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +18f6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +18f8 : 48 > pha ;use stack to load status +18f9 : 28 > plp + +18fa : a516 lda zp1+3 +18fc : 08 php ;test stores do not alter flags +18fd : 49c3 eor #$c3 +18ff : 28 plp +1900 : 8d0602 sta abst+3 +1903 : 08 php ;flags after load/store sequence +1904 : 49c3 eor #$c3 +1906 : c900 cmp #0 ;test result + trap_ne +1908 : d0fe > bne * ;failed not equal (non zero) + +190a : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +190b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +190d : cd1002 cmp fLDx+3 ;test flags + trap_ne +1910 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1912 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1914 : 48 > pha ;use stack to load status +1915 : 28 > plp + +1916 : ad0802 lda abs1 +1919 : 08 php ;test stores do not alter flags +191a : 49c3 eor #$c3 +191c : 28 plp +191d : 850c sta zpt +191f : 08 php ;flags after load/store sequence +1920 : 49c3 eor #$c3 +1922 : c513 cmp zp1 ;test result + trap_ne +1924 : d0fe > bne * ;failed not equal (non zero) + +1926 : 68 pla ;load status + eor_flag 0 +1927 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1929 : cd0d02 cmp fLDx ;test flags + trap_ne +192c : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +192e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1930 : 48 > pha ;use stack to load status +1931 : 28 > plp + +1932 : ad0902 lda abs1+1 +1935 : 08 php ;test stores do not alter flags +1936 : 49c3 eor #$c3 +1938 : 28 plp +1939 : 850d sta zpt+1 +193b : 08 php ;flags after load/store sequence +193c : 49c3 eor #$c3 +193e : c514 cmp zp1+1 ;test result + trap_ne +1940 : d0fe > bne * ;failed not equal (non zero) + +1942 : 68 pla ;load status + eor_flag 0 +1943 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1945 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +1948 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +194a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +194c : 48 > pha ;use stack to load status +194d : 28 > plp + +194e : ad0a02 lda abs1+2 +1951 : 08 php ;test stores do not alter flags +1952 : 49c3 eor #$c3 +1954 : 28 plp +1955 : 850e sta zpt+2 +1957 : 08 php ;flags after load/store sequence +1958 : 49c3 eor #$c3 +195a : c515 cmp zp1+2 ;test result + trap_ne +195c : d0fe > bne * ;failed not equal (non zero) + +195e : 68 pla ;load status + eor_flag 0 +195f : 4930 > eor #0|fao ;invert expected flags + always on bits + +1961 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +1964 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1966 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1968 : 48 > pha ;use stack to load status +1969 : 28 > plp + +196a : ad0b02 lda abs1+3 +196d : 08 php ;test stores do not alter flags +196e : 49c3 eor #$c3 +1970 : 28 plp +1971 : 850f sta zpt+3 +1973 : 08 php ;flags after load/store sequence +1974 : 49c3 eor #$c3 +1976 : c516 cmp zp1+3 ;test result + trap_ne +1978 : d0fe > bne * ;failed not equal (non zero) + +197a : 68 pla ;load status + eor_flag 0 +197b : 4930 > eor #0|fao ;invert expected flags + always on bits + +197d : cd1002 cmp fLDx+3 ;test flags + trap_ne +1980 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1982 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1984 : 48 > pha ;use stack to load status +1985 : 28 > plp + +1986 : ad0802 lda abs1 +1989 : 08 php ;test stores do not alter flags +198a : 49c3 eor #$c3 +198c : 28 plp +198d : 850c sta zpt +198f : 08 php ;flags after load/store sequence +1990 : 49c3 eor #$c3 +1992 : c513 cmp zp1 ;test result + trap_ne +1994 : d0fe > bne * ;failed not equal (non zero) + +1996 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1997 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1999 : cd0d02 cmp fLDx ;test flags + trap_ne +199c : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +199e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +19a0 : 48 > pha ;use stack to load status +19a1 : 28 > plp + +19a2 : ad0902 lda abs1+1 +19a5 : 08 php ;test stores do not alter flags +19a6 : 49c3 eor #$c3 +19a8 : 28 plp +19a9 : 850d sta zpt+1 +19ab : 08 php ;flags after load/store sequence +19ac : 49c3 eor #$c3 +19ae : c514 cmp zp1+1 ;test result + trap_ne +19b0 : d0fe > bne * ;failed not equal (non zero) + +19b2 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +19b3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +19b5 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +19b8 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +19ba : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +19bc : 48 > pha ;use stack to load status +19bd : 28 > plp + +19be : ad0a02 lda abs1+2 +19c1 : 08 php ;test stores do not alter flags +19c2 : 49c3 eor #$c3 +19c4 : 28 plp +19c5 : 850e sta zpt+2 +19c7 : 08 php ;flags after load/store sequence +19c8 : 49c3 eor #$c3 +19ca : c515 cmp zp1+2 ;test result + trap_ne +19cc : d0fe > bne * ;failed not equal (non zero) + +19ce : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +19cf : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +19d1 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +19d4 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +19d6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +19d8 : 48 > pha ;use stack to load status +19d9 : 28 > plp + +19da : ad0b02 lda abs1+3 +19dd : 08 php ;test stores do not alter flags +19de : 49c3 eor #$c3 +19e0 : 28 plp +19e1 : 850f sta zpt+3 +19e3 : 08 php ;flags after load/store sequence +19e4 : 49c3 eor #$c3 +19e6 : c516 cmp zp1+3 ;test result + trap_ne +19e8 : d0fe > bne * ;failed not equal (non zero) + +19ea : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +19eb : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +19ed : cd1002 cmp fLDx+3 ;test flags + trap_ne +19f0 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +19f2 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +19f4 : 48 > pha ;use stack to load status +19f5 : 28 > plp + +19f6 : a9c3 lda #$c3 +19f8 : 08 php +19f9 : cd0802 cmp abs1 ;test result + trap_ne +19fc : d0fe > bne * ;failed not equal (non zero) + +19fe : 68 pla ;load status + eor_flag 0 +19ff : 4930 > eor #0|fao ;invert expected flags + always on bits + +1a01 : cd0d02 cmp fLDx ;test flags + trap_ne +1a04 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1a06 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1a08 : 48 > pha ;use stack to load status +1a09 : 28 > plp + +1a0a : a982 lda #$82 +1a0c : 08 php +1a0d : cd0902 cmp abs1+1 ;test result + trap_ne +1a10 : d0fe > bne * ;failed not equal (non zero) + +1a12 : 68 pla ;load status + eor_flag 0 +1a13 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1a15 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +1a18 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1a1a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1a1c : 48 > pha ;use stack to load status +1a1d : 28 > plp + +1a1e : a941 lda #$41 +1a20 : 08 php +1a21 : cd0a02 cmp abs1+2 ;test result + trap_ne +1a24 : d0fe > bne * ;failed not equal (non zero) + +1a26 : 68 pla ;load status + eor_flag 0 +1a27 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1a29 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +1a2c : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1a2e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1a30 : 48 > pha ;use stack to load status +1a31 : 28 > plp + +1a32 : a900 lda #0 +1a34 : 08 php +1a35 : cd0b02 cmp abs1+3 ;test result + trap_ne +1a38 : d0fe > bne * ;failed not equal (non zero) + +1a3a : 68 pla ;load status + eor_flag 0 +1a3b : 4930 > eor #0|fao ;invert expected flags + always on bits + +1a3d : cd1002 cmp fLDx+3 ;test flags + trap_ne +1a40 : d0fe > bne * ;failed not equal (non zero) + + + set_stat $ff + > load_flag $ff +1a42 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1a44 : 48 > pha ;use stack to load status +1a45 : 28 > plp + +1a46 : a9c3 lda #$c3 +1a48 : 08 php +1a49 : cd0802 cmp abs1 ;test result + trap_ne +1a4c : d0fe > bne * ;failed not equal (non zero) + +1a4e : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1a4f : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1a51 : cd0d02 cmp fLDx ;test flags + trap_ne +1a54 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1a56 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1a58 : 48 > pha ;use stack to load status +1a59 : 28 > plp + +1a5a : a982 lda #$82 +1a5c : 08 php +1a5d : cd0902 cmp abs1+1 ;test result + trap_ne +1a60 : d0fe > bne * ;failed not equal (non zero) + +1a62 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1a63 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1a65 : cd0e02 cmp fLDx+1 ;test flags + trap_ne +1a68 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1a6a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1a6c : 48 > pha ;use stack to load status +1a6d : 28 > plp + +1a6e : a941 lda #$41 +1a70 : 08 php +1a71 : cd0a02 cmp abs1+2 ;test result + trap_ne +1a74 : d0fe > bne * ;failed not equal (non zero) + +1a76 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1a77 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1a79 : cd0f02 cmp fLDx+2 ;test flags + trap_ne +1a7c : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +1a7e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1a80 : 48 > pha ;use stack to load status +1a81 : 28 > plp + +1a82 : a900 lda #0 +1a84 : 08 php +1a85 : cd0b02 cmp abs1+3 ;test result + trap_ne +1a88 : d0fe > bne * ;failed not equal (non zero) + +1a8a : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1a8b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +1a8d : cd1002 cmp fLDx+3 ;test flags + trap_ne +1a90 : d0fe > bne * ;failed not equal (non zero) + + +1a92 : a200 ldx #0 +1a94 : a50c lda zpt +1a96 : 49c3 eor #$c3 +1a98 : c513 cmp zp1 + trap_ne ;store to zp data +1a9a : d0fe > bne * ;failed not equal (non zero) + +1a9c : 860c stx zpt ;clear +1a9e : ad0302 lda abst +1aa1 : 49c3 eor #$c3 +1aa3 : cd0802 cmp abs1 + trap_ne ;store to abs data +1aa6 : d0fe > bne * ;failed not equal (non zero) + +1aa8 : 8e0302 stx abst ;clear +1aab : a50d lda zpt+1 +1aad : 49c3 eor #$c3 +1aaf : c514 cmp zp1+1 + trap_ne ;store to zp data +1ab1 : d0fe > bne * ;failed not equal (non zero) + +1ab3 : 860d stx zpt+1 ;clear +1ab5 : ad0402 lda abst+1 +1ab8 : 49c3 eor #$c3 +1aba : cd0902 cmp abs1+1 + trap_ne ;store to abs data +1abd : d0fe > bne * ;failed not equal (non zero) + +1abf : 8e0402 stx abst+1 ;clear +1ac2 : a50e lda zpt+2 +1ac4 : 49c3 eor #$c3 +1ac6 : c515 cmp zp1+2 + trap_ne ;store to zp data +1ac8 : d0fe > bne * ;failed not equal (non zero) + +1aca : 860e stx zpt+2 ;clear +1acc : ad0502 lda abst+2 +1acf : 49c3 eor #$c3 +1ad1 : cd0a02 cmp abs1+2 + trap_ne ;store to abs data +1ad4 : d0fe > bne * ;failed not equal (non zero) + +1ad6 : 8e0502 stx abst+2 ;clear +1ad9 : a50f lda zpt+3 +1adb : 49c3 eor #$c3 +1add : c516 cmp zp1+3 + trap_ne ;store to zp data +1adf : d0fe > bne * ;failed not equal (non zero) + +1ae1 : 860f stx zpt+3 ;clear +1ae3 : ad0602 lda abst+3 +1ae6 : 49c3 eor #$c3 +1ae8 : cd0b02 cmp abs1+3 + trap_ne ;store to abs data +1aeb : d0fe > bne * ;failed not equal (non zero) + +1aed : 8e0602 stx abst+3 ;clear + next_test +1af0 : ad0002 > lda test_case ;previous test +1af3 : c918 > cmp #test_num + > trap_ne ;test is out of sequence +1af5 : d0fe > bne * ;failed not equal (non zero) + > +0019 = >test_num = test_num + 1 +1af7 : a919 > lda #test_num ;*** next tests' number +1af9 : 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 +1afc : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1afe : 48 > pha ;use stack to load status +1aff : a9ff > lda #$ff ;precharge accu +1b01 : 28 > plp + +1b02 : 2416 bit zp1+3 ;00 - should set Z / clear NV + tst_a $ff,fz +1b04 : 08 > php ;save flags +1b05 : c9ff > cmp #$ff ;test result + > trap_ne +1b07 : d0fe > bne * ;failed not equal (non zero) + > +1b09 : 68 > pla ;load status +1b0a : 48 > pha + > cmp_flag fz +1b0b : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b0d : d0fe > bne * ;failed not equal (non zero) + > +1b0f : 28 > plp ;restore status + + set_a 1,0 + > load_flag 0 +1b10 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1b12 : 48 > pha ;use stack to load status +1b13 : a901 > lda #1 ;precharge accu +1b15 : 28 > plp + +1b16 : 2415 bit zp1+2 ;41 - should set V (M6) / clear NZ + tst_a 1,fv +1b18 : 08 > php ;save flags +1b19 : c901 > cmp #1 ;test result + > trap_ne +1b1b : d0fe > bne * ;failed not equal (non zero) + > +1b1d : 68 > pla ;load status +1b1e : 48 > pha + > cmp_flag fv +1b1f : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b21 : d0fe > bne * ;failed not equal (non zero) + > +1b23 : 28 > plp ;restore status + + set_a 1,0 + > load_flag 0 +1b24 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1b26 : 48 > pha ;use stack to load status +1b27 : a901 > lda #1 ;precharge accu +1b29 : 28 > plp + +1b2a : 2414 bit zp1+1 ;82 - should set N (M7) & Z / clear V + tst_a 1,fnz +1b2c : 08 > php ;save flags +1b2d : c901 > cmp #1 ;test result + > trap_ne +1b2f : d0fe > bne * ;failed not equal (non zero) + > +1b31 : 68 > pla ;load status +1b32 : 48 > pha + > cmp_flag fnz +1b33 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b35 : d0fe > bne * ;failed not equal (non zero) + > +1b37 : 28 > plp ;restore status + + set_a 1,0 + > load_flag 0 +1b38 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1b3a : 48 > pha ;use stack to load status +1b3b : a901 > lda #1 ;precharge accu +1b3d : 28 > plp + +1b3e : 2413 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z + tst_a 1,fnv +1b40 : 08 > php ;save flags +1b41 : c901 > cmp #1 ;test result + > trap_ne +1b43 : d0fe > bne * ;failed not equal (non zero) + > +1b45 : 68 > pla ;load status +1b46 : 48 > pha + > cmp_flag fnv +1b47 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b49 : d0fe > bne * ;failed not equal (non zero) + > +1b4b : 28 > plp ;restore status + + + set_a $ff,$ff + > load_flag $ff +1b4c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1b4e : 48 > pha ;use stack to load status +1b4f : a9ff > lda #$ff ;precharge accu +1b51 : 28 > plp + +1b52 : 2416 bit zp1+3 ;00 - should set Z / clear NV + tst_a $ff,~fnv +1b54 : 08 > php ;save flags +1b55 : c9ff > cmp #$ff ;test result + > trap_ne +1b57 : d0fe > bne * ;failed not equal (non zero) + > +1b59 : 68 > pla ;load status +1b5a : 48 > pha + > cmp_flag ~fnv +1b5b : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b5d : d0fe > bne * ;failed not equal (non zero) + > +1b5f : 28 > plp ;restore status + + set_a 1,$ff + > load_flag $ff +1b60 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1b62 : 48 > pha ;use stack to load status +1b63 : a901 > lda #1 ;precharge accu +1b65 : 28 > plp + +1b66 : 2415 bit zp1+2 ;41 - should set V (M6) / clear NZ + tst_a 1,~fnz +1b68 : 08 > php ;save flags +1b69 : c901 > cmp #1 ;test result + > trap_ne +1b6b : d0fe > bne * ;failed not equal (non zero) + > +1b6d : 68 > pla ;load status +1b6e : 48 > pha + > cmp_flag ~fnz +1b6f : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b71 : d0fe > bne * ;failed not equal (non zero) + > +1b73 : 28 > plp ;restore status + + set_a 1,$ff + > load_flag $ff +1b74 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1b76 : 48 > pha ;use stack to load status +1b77 : a901 > lda #1 ;precharge accu +1b79 : 28 > plp + +1b7a : 2414 bit zp1+1 ;82 - should set N (M7) & Z / clear V + tst_a 1,~fv +1b7c : 08 > php ;save flags +1b7d : c901 > cmp #1 ;test result + > trap_ne +1b7f : d0fe > bne * ;failed not equal (non zero) + > +1b81 : 68 > pla ;load status +1b82 : 48 > pha + > cmp_flag ~fv +1b83 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b85 : d0fe > bne * ;failed not equal (non zero) + > +1b87 : 28 > plp ;restore status + + set_a 1,$ff + > load_flag $ff +1b88 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1b8a : 48 > pha ;use stack to load status +1b8b : a901 > lda #1 ;precharge accu +1b8d : 28 > plp + +1b8e : 2413 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z + tst_a 1,~fz +1b90 : 08 > php ;save flags +1b91 : c901 > cmp #1 ;test result + > trap_ne +1b93 : d0fe > bne * ;failed not equal (non zero) + > +1b95 : 68 > pla ;load status +1b96 : 48 > pha + > cmp_flag ~fz +1b97 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b99 : d0fe > bne * ;failed not equal (non zero) + > +1b9b : 28 > plp ;restore status + + + set_a $ff,0 + > load_flag 0 +1b9c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1b9e : 48 > pha ;use stack to load status +1b9f : a9ff > lda #$ff ;precharge accu +1ba1 : 28 > plp + +1ba2 : 2c0b02 bit abs1+3 ;00 - should set Z / clear NV + tst_a $ff,fz +1ba5 : 08 > php ;save flags +1ba6 : c9ff > cmp #$ff ;test result + > trap_ne +1ba8 : d0fe > bne * ;failed not equal (non zero) + > +1baa : 68 > pla ;load status +1bab : 48 > pha + > cmp_flag fz +1bac : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits + > + > trap_ne +1bae : d0fe > bne * ;failed not equal (non zero) + > +1bb0 : 28 > plp ;restore status + + set_a 1,0 + > load_flag 0 +1bb1 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1bb3 : 48 > pha ;use stack to load status +1bb4 : a901 > lda #1 ;precharge accu +1bb6 : 28 > plp + +1bb7 : 2c0a02 bit abs1+2 ;41 - should set V (M6) / clear NZ + tst_a 1,fv +1bba : 08 > php ;save flags +1bbb : c901 > cmp #1 ;test result + > trap_ne +1bbd : d0fe > bne * ;failed not equal (non zero) + > +1bbf : 68 > pla ;load status +1bc0 : 48 > pha + > cmp_flag fv +1bc1 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1bc3 : d0fe > bne * ;failed not equal (non zero) + > +1bc5 : 28 > plp ;restore status + + set_a 1,0 + > load_flag 0 +1bc6 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1bc8 : 48 > pha ;use stack to load status +1bc9 : a901 > lda #1 ;precharge accu +1bcb : 28 > plp + +1bcc : 2c0902 bit abs1+1 ;82 - should set N (M7) & Z / clear V + tst_a 1,fnz +1bcf : 08 > php ;save flags +1bd0 : c901 > cmp #1 ;test result + > trap_ne +1bd2 : d0fe > bne * ;failed not equal (non zero) + > +1bd4 : 68 > pla ;load status +1bd5 : 48 > pha + > cmp_flag fnz +1bd6 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1bd8 : d0fe > bne * ;failed not equal (non zero) + > +1bda : 28 > plp ;restore status + + set_a 1,0 + > load_flag 0 +1bdb : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1bdd : 48 > pha ;use stack to load status +1bde : a901 > lda #1 ;precharge accu +1be0 : 28 > plp + +1be1 : 2c0802 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z + tst_a 1,fnv +1be4 : 08 > php ;save flags +1be5 : c901 > cmp #1 ;test result + > trap_ne +1be7 : d0fe > bne * ;failed not equal (non zero) + > +1be9 : 68 > pla ;load status +1bea : 48 > pha + > cmp_flag fnv +1beb : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1bed : d0fe > bne * ;failed not equal (non zero) + > +1bef : 28 > plp ;restore status + + + set_a $ff,$ff + > load_flag $ff +1bf0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1bf2 : 48 > pha ;use stack to load status +1bf3 : a9ff > lda #$ff ;precharge accu +1bf5 : 28 > plp + +1bf6 : 2c0b02 bit abs1+3 ;00 - should set Z / clear NV + tst_a $ff,~fnv +1bf9 : 08 > php ;save flags +1bfa : c9ff > cmp #$ff ;test result + > trap_ne +1bfc : d0fe > bne * ;failed not equal (non zero) + > +1bfe : 68 > pla ;load status +1bff : 48 > pha + > cmp_flag ~fnv +1c00 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c02 : d0fe > bne * ;failed not equal (non zero) + > +1c04 : 28 > plp ;restore status + + set_a 1,$ff + > load_flag $ff +1c05 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1c07 : 48 > pha ;use stack to load status +1c08 : a901 > lda #1 ;precharge accu +1c0a : 28 > plp + +1c0b : 2c0a02 bit abs1+2 ;41 - should set V (M6) / clear NZ + tst_a 1,~fnz +1c0e : 08 > php ;save flags +1c0f : c901 > cmp #1 ;test result + > trap_ne +1c11 : d0fe > bne * ;failed not equal (non zero) + > +1c13 : 68 > pla ;load status +1c14 : 48 > pha + > cmp_flag ~fnz +1c15 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c17 : d0fe > bne * ;failed not equal (non zero) + > +1c19 : 28 > plp ;restore status + + set_a 1,$ff + > load_flag $ff +1c1a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1c1c : 48 > pha ;use stack to load status +1c1d : a901 > lda #1 ;precharge accu +1c1f : 28 > plp + +1c20 : 2c0902 bit abs1+1 ;82 - should set N (M7) & Z / clear V + tst_a 1,~fv +1c23 : 08 > php ;save flags +1c24 : c901 > cmp #1 ;test result + > trap_ne +1c26 : d0fe > bne * ;failed not equal (non zero) + > +1c28 : 68 > pla ;load status +1c29 : 48 > pha + > cmp_flag ~fv +1c2a : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c2c : d0fe > bne * ;failed not equal (non zero) + > +1c2e : 28 > plp ;restore status + + set_a 1,$ff + > load_flag $ff +1c2f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1c31 : 48 > pha ;use stack to load status +1c32 : a901 > lda #1 ;precharge accu +1c34 : 28 > plp + +1c35 : 2c0802 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z + tst_a 1,~fz +1c38 : 08 > php ;save flags +1c39 : c901 > cmp #1 ;test result + > trap_ne +1c3b : d0fe > bne * ;failed not equal (non zero) + > +1c3d : 68 > pla ;load status +1c3e : 48 > pha + > cmp_flag ~fz +1c3f : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c41 : d0fe > bne * ;failed not equal (non zero) + > +1c43 : 28 > plp ;restore status + + next_test +1c44 : ad0002 > lda test_case ;previous test +1c47 : c919 > cmp #test_num + > trap_ne ;test is out of sequence +1c49 : d0fe > bne * ;failed not equal (non zero) + > +001a = >test_num = test_num + 1 +1c4b : a91a > lda #test_num ;*** next tests' number +1c4d : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; CPX - zp / abs / # + set_x $80,0 + > load_flag 0 +1c50 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1c52 : 48 > pha ;use stack to load status +1c53 : a280 > ldx #$80 ;precharge index x +1c55 : 28 > plp + +1c56 : e417 cpx zp7f + tst_stat fc +1c58 : 08 > php ;save status +1c59 : 68 > pla ;use stack to retrieve status +1c5a : 48 > pha + > cmp_flag fc +1c5b : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c5d : d0fe > bne * ;failed not equal (non zero) + > +1c5f : 28 > plp ;restore status + +1c60 : ca dex +1c61 : e417 cpx zp7f + tst_stat fzc +1c63 : 08 > php ;save status +1c64 : 68 > pla ;use stack to retrieve status +1c65 : 48 > pha + > cmp_flag fzc +1c66 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c68 : d0fe > bne * ;failed not equal (non zero) + > +1c6a : 28 > plp ;restore status + +1c6b : ca dex +1c6c : e417 cpx zp7f + tst_x $7e,fn +1c6e : 08 > php ;save flags +1c6f : e07e > cpx #$7e ;test result + > trap_ne +1c71 : d0fe > bne * ;failed not equal (non zero) + > +1c73 : 68 > pla ;load status +1c74 : 48 > pha + > cmp_flag fn +1c75 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c77 : d0fe > bne * ;failed not equal (non zero) + > +1c79 : 28 > plp ;restore status + + set_x $80,$ff + > load_flag $ff +1c7a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1c7c : 48 > pha ;use stack to load status +1c7d : a280 > ldx #$80 ;precharge index x +1c7f : 28 > plp + +1c80 : e417 cpx zp7f + tst_stat ~fnz +1c82 : 08 > php ;save status +1c83 : 68 > pla ;use stack to retrieve status +1c84 : 48 > pha + > cmp_flag ~fnz +1c85 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c87 : d0fe > bne * ;failed not equal (non zero) + > +1c89 : 28 > plp ;restore status + +1c8a : ca dex +1c8b : e417 cpx zp7f + tst_stat ~fn +1c8d : 08 > php ;save status +1c8e : 68 > pla ;use stack to retrieve status +1c8f : 48 > pha + > cmp_flag ~fn +1c90 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c92 : d0fe > bne * ;failed not equal (non zero) + > +1c94 : 28 > plp ;restore status + +1c95 : ca dex +1c96 : e417 cpx zp7f + tst_x $7e,~fzc +1c98 : 08 > php ;save flags +1c99 : e07e > cpx #$7e ;test result + > trap_ne +1c9b : d0fe > bne * ;failed not equal (non zero) + > +1c9d : 68 > pla ;load status +1c9e : 48 > pha + > cmp_flag ~fzc +1c9f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ca1 : d0fe > bne * ;failed not equal (non zero) + > +1ca3 : 28 > plp ;restore status + + + set_x $80,0 + > load_flag 0 +1ca4 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1ca6 : 48 > pha ;use stack to load status +1ca7 : a280 > ldx #$80 ;precharge index x +1ca9 : 28 > plp + +1caa : ec0c02 cpx abs7f + tst_stat fc +1cad : 08 > php ;save status +1cae : 68 > pla ;use stack to retrieve status +1caf : 48 > pha + > cmp_flag fc +1cb0 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1cb2 : d0fe > bne * ;failed not equal (non zero) + > +1cb4 : 28 > plp ;restore status + +1cb5 : ca dex +1cb6 : ec0c02 cpx abs7f + tst_stat fzc +1cb9 : 08 > php ;save status +1cba : 68 > pla ;use stack to retrieve status +1cbb : 48 > pha + > cmp_flag fzc +1cbc : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1cbe : d0fe > bne * ;failed not equal (non zero) + > +1cc0 : 28 > plp ;restore status + +1cc1 : ca dex +1cc2 : ec0c02 cpx abs7f + tst_x $7e,fn +1cc5 : 08 > php ;save flags +1cc6 : e07e > cpx #$7e ;test result + > trap_ne +1cc8 : d0fe > bne * ;failed not equal (non zero) + > +1cca : 68 > pla ;load status +1ccb : 48 > pha + > cmp_flag fn +1ccc : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1cce : d0fe > bne * ;failed not equal (non zero) + > +1cd0 : 28 > plp ;restore status + + set_x $80,$ff + > load_flag $ff +1cd1 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1cd3 : 48 > pha ;use stack to load status +1cd4 : a280 > ldx #$80 ;precharge index x +1cd6 : 28 > plp + +1cd7 : ec0c02 cpx abs7f + tst_stat ~fnz +1cda : 08 > php ;save status +1cdb : 68 > pla ;use stack to retrieve status +1cdc : 48 > pha + > cmp_flag ~fnz +1cdd : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1cdf : d0fe > bne * ;failed not equal (non zero) + > +1ce1 : 28 > plp ;restore status + +1ce2 : ca dex +1ce3 : ec0c02 cpx abs7f + tst_stat ~fn +1ce6 : 08 > php ;save status +1ce7 : 68 > pla ;use stack to retrieve status +1ce8 : 48 > pha + > cmp_flag ~fn +1ce9 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ceb : d0fe > bne * ;failed not equal (non zero) + > +1ced : 28 > plp ;restore status + +1cee : ca dex +1cef : ec0c02 cpx abs7f + tst_x $7e,~fzc +1cf2 : 08 > php ;save flags +1cf3 : e07e > cpx #$7e ;test result + > trap_ne +1cf5 : d0fe > bne * ;failed not equal (non zero) + > +1cf7 : 68 > pla ;load status +1cf8 : 48 > pha + > cmp_flag ~fzc +1cf9 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1cfb : d0fe > bne * ;failed not equal (non zero) + > +1cfd : 28 > plp ;restore status + + + set_x $80,0 + > load_flag 0 +1cfe : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1d00 : 48 > pha ;use stack to load status +1d01 : a280 > ldx #$80 ;precharge index x +1d03 : 28 > plp + +1d04 : e07f cpx #$7f + tst_stat fc +1d06 : 08 > php ;save status +1d07 : 68 > pla ;use stack to retrieve status +1d08 : 48 > pha + > cmp_flag fc +1d09 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1d0b : d0fe > bne * ;failed not equal (non zero) + > +1d0d : 28 > plp ;restore status + +1d0e : ca dex +1d0f : e07f cpx #$7f + tst_stat fzc +1d11 : 08 > php ;save status +1d12 : 68 > pla ;use stack to retrieve status +1d13 : 48 > pha + > cmp_flag fzc +1d14 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1d16 : d0fe > bne * ;failed not equal (non zero) + > +1d18 : 28 > plp ;restore status + +1d19 : ca dex +1d1a : e07f cpx #$7f + tst_x $7e,fn +1d1c : 08 > php ;save flags +1d1d : e07e > cpx #$7e ;test result + > trap_ne +1d1f : d0fe > bne * ;failed not equal (non zero) + > +1d21 : 68 > pla ;load status +1d22 : 48 > pha + > cmp_flag fn +1d23 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1d25 : d0fe > bne * ;failed not equal (non zero) + > +1d27 : 28 > plp ;restore status + + set_x $80,$ff + > load_flag $ff +1d28 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1d2a : 48 > pha ;use stack to load status +1d2b : a280 > ldx #$80 ;precharge index x +1d2d : 28 > plp + +1d2e : e07f cpx #$7f + tst_stat ~fnz +1d30 : 08 > php ;save status +1d31 : 68 > pla ;use stack to retrieve status +1d32 : 48 > pha + > cmp_flag ~fnz +1d33 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1d35 : d0fe > bne * ;failed not equal (non zero) + > +1d37 : 28 > plp ;restore status + +1d38 : ca dex +1d39 : e07f cpx #$7f + tst_stat ~fn +1d3b : 08 > php ;save status +1d3c : 68 > pla ;use stack to retrieve status +1d3d : 48 > pha + > cmp_flag ~fn +1d3e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1d40 : d0fe > bne * ;failed not equal (non zero) + > +1d42 : 28 > plp ;restore status + +1d43 : ca dex +1d44 : e07f cpx #$7f + tst_x $7e,~fzc +1d46 : 08 > php ;save flags +1d47 : e07e > cpx #$7e ;test result + > trap_ne +1d49 : d0fe > bne * ;failed not equal (non zero) + > +1d4b : 68 > pla ;load status +1d4c : 48 > pha + > cmp_flag ~fzc +1d4d : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1d4f : d0fe > bne * ;failed not equal (non zero) + > +1d51 : 28 > plp ;restore status + + next_test +1d52 : ad0002 > lda test_case ;previous test +1d55 : c91a > cmp #test_num + > trap_ne ;test is out of sequence +1d57 : d0fe > bne * ;failed not equal (non zero) + > +001b = >test_num = test_num + 1 +1d59 : a91b > lda #test_num ;*** next tests' number +1d5b : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; CPY - zp / abs / # + set_y $80,0 + > load_flag 0 +1d5e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1d60 : 48 > pha ;use stack to load status +1d61 : a080 > ldy #$80 ;precharge index y +1d63 : 28 > plp + +1d64 : c417 cpy zp7f + tst_stat fc +1d66 : 08 > php ;save status +1d67 : 68 > pla ;use stack to retrieve status +1d68 : 48 > pha + > cmp_flag fc +1d69 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1d6b : d0fe > bne * ;failed not equal (non zero) + > +1d6d : 28 > plp ;restore status + +1d6e : 88 dey +1d6f : c417 cpy zp7f + tst_stat fzc +1d71 : 08 > php ;save status +1d72 : 68 > pla ;use stack to retrieve status +1d73 : 48 > pha + > cmp_flag fzc +1d74 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1d76 : d0fe > bne * ;failed not equal (non zero) + > +1d78 : 28 > plp ;restore status + +1d79 : 88 dey +1d7a : c417 cpy zp7f + tst_y $7e,fn +1d7c : 08 > php ;save flags +1d7d : c07e > cpy #$7e ;test result + > trap_ne +1d7f : d0fe > bne * ;failed not equal (non zero) + > +1d81 : 68 > pla ;load status +1d82 : 48 > pha + > cmp_flag fn +1d83 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1d85 : d0fe > bne * ;failed not equal (non zero) + > +1d87 : 28 > plp ;restore status + + set_y $80,$ff + > load_flag $ff +1d88 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1d8a : 48 > pha ;use stack to load status +1d8b : a080 > ldy #$80 ;precharge index y +1d8d : 28 > plp + +1d8e : c417 cpy zp7f + tst_stat ~fnz +1d90 : 08 > php ;save status +1d91 : 68 > pla ;use stack to retrieve status +1d92 : 48 > pha + > cmp_flag ~fnz +1d93 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1d95 : d0fe > bne * ;failed not equal (non zero) + > +1d97 : 28 > plp ;restore status + +1d98 : 88 dey +1d99 : c417 cpy zp7f + tst_stat ~fn +1d9b : 08 > php ;save status +1d9c : 68 > pla ;use stack to retrieve status +1d9d : 48 > pha + > cmp_flag ~fn +1d9e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1da0 : d0fe > bne * ;failed not equal (non zero) + > +1da2 : 28 > plp ;restore status + +1da3 : 88 dey +1da4 : c417 cpy zp7f + tst_y $7e,~fzc +1da6 : 08 > php ;save flags +1da7 : c07e > cpy #$7e ;test result + > trap_ne +1da9 : d0fe > bne * ;failed not equal (non zero) + > +1dab : 68 > pla ;load status +1dac : 48 > pha + > cmp_flag ~fzc +1dad : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1daf : d0fe > bne * ;failed not equal (non zero) + > +1db1 : 28 > plp ;restore status + + + set_y $80,0 + > load_flag 0 +1db2 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1db4 : 48 > pha ;use stack to load status +1db5 : a080 > ldy #$80 ;precharge index y +1db7 : 28 > plp + +1db8 : cc0c02 cpy abs7f + tst_stat fc +1dbb : 08 > php ;save status +1dbc : 68 > pla ;use stack to retrieve status +1dbd : 48 > pha + > cmp_flag fc +1dbe : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1dc0 : d0fe > bne * ;failed not equal (non zero) + > +1dc2 : 28 > plp ;restore status + +1dc3 : 88 dey +1dc4 : cc0c02 cpy abs7f + tst_stat fzc +1dc7 : 08 > php ;save status +1dc8 : 68 > pla ;use stack to retrieve status +1dc9 : 48 > pha + > cmp_flag fzc +1dca : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1dcc : d0fe > bne * ;failed not equal (non zero) + > +1dce : 28 > plp ;restore status + +1dcf : 88 dey +1dd0 : cc0c02 cpy abs7f + tst_y $7e,fn +1dd3 : 08 > php ;save flags +1dd4 : c07e > cpy #$7e ;test result + > trap_ne +1dd6 : d0fe > bne * ;failed not equal (non zero) + > +1dd8 : 68 > pla ;load status +1dd9 : 48 > pha + > cmp_flag fn +1dda : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ddc : d0fe > bne * ;failed not equal (non zero) + > +1dde : 28 > plp ;restore status + + set_y $80,$ff + > load_flag $ff +1ddf : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1de1 : 48 > pha ;use stack to load status +1de2 : a080 > ldy #$80 ;precharge index y +1de4 : 28 > plp + +1de5 : cc0c02 cpy abs7f + tst_stat ~fnz +1de8 : 08 > php ;save status +1de9 : 68 > pla ;use stack to retrieve status +1dea : 48 > pha + > cmp_flag ~fnz +1deb : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ded : d0fe > bne * ;failed not equal (non zero) + > +1def : 28 > plp ;restore status + +1df0 : 88 dey +1df1 : cc0c02 cpy abs7f + tst_stat ~fn +1df4 : 08 > php ;save status +1df5 : 68 > pla ;use stack to retrieve status +1df6 : 48 > pha + > cmp_flag ~fn +1df7 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1df9 : d0fe > bne * ;failed not equal (non zero) + > +1dfb : 28 > plp ;restore status + +1dfc : 88 dey +1dfd : cc0c02 cpy abs7f + tst_y $7e,~fzc +1e00 : 08 > php ;save flags +1e01 : c07e > cpy #$7e ;test result + > trap_ne +1e03 : d0fe > bne * ;failed not equal (non zero) + > +1e05 : 68 > pla ;load status +1e06 : 48 > pha + > cmp_flag ~fzc +1e07 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e09 : d0fe > bne * ;failed not equal (non zero) + > +1e0b : 28 > plp ;restore status + + + set_y $80,0 + > load_flag 0 +1e0c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1e0e : 48 > pha ;use stack to load status +1e0f : a080 > ldy #$80 ;precharge index y +1e11 : 28 > plp + +1e12 : c07f cpy #$7f + tst_stat fc +1e14 : 08 > php ;save status +1e15 : 68 > pla ;use stack to retrieve status +1e16 : 48 > pha + > cmp_flag fc +1e17 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e19 : d0fe > bne * ;failed not equal (non zero) + > +1e1b : 28 > plp ;restore status + +1e1c : 88 dey +1e1d : c07f cpy #$7f + tst_stat fzc +1e1f : 08 > php ;save status +1e20 : 68 > pla ;use stack to retrieve status +1e21 : 48 > pha + > cmp_flag fzc +1e22 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e24 : d0fe > bne * ;failed not equal (non zero) + > +1e26 : 28 > plp ;restore status + +1e27 : 88 dey +1e28 : c07f cpy #$7f + tst_y $7e,fn +1e2a : 08 > php ;save flags +1e2b : c07e > cpy #$7e ;test result + > trap_ne +1e2d : d0fe > bne * ;failed not equal (non zero) + > +1e2f : 68 > pla ;load status +1e30 : 48 > pha + > cmp_flag fn +1e31 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e33 : d0fe > bne * ;failed not equal (non zero) + > +1e35 : 28 > plp ;restore status + + set_y $80,$ff + > load_flag $ff +1e36 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1e38 : 48 > pha ;use stack to load status +1e39 : a080 > ldy #$80 ;precharge index y +1e3b : 28 > plp + +1e3c : c07f cpy #$7f + tst_stat ~fnz +1e3e : 08 > php ;save status +1e3f : 68 > pla ;use stack to retrieve status +1e40 : 48 > pha + > cmp_flag ~fnz +1e41 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e43 : d0fe > bne * ;failed not equal (non zero) + > +1e45 : 28 > plp ;restore status + +1e46 : 88 dey +1e47 : c07f cpy #$7f + tst_stat ~fn +1e49 : 08 > php ;save status +1e4a : 68 > pla ;use stack to retrieve status +1e4b : 48 > pha + > cmp_flag ~fn +1e4c : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e4e : d0fe > bne * ;failed not equal (non zero) + > +1e50 : 28 > plp ;restore status + +1e51 : 88 dey +1e52 : c07f cpy #$7f + tst_y $7e,~fzc +1e54 : 08 > php ;save flags +1e55 : c07e > cpy #$7e ;test result + > trap_ne +1e57 : d0fe > bne * ;failed not equal (non zero) + > +1e59 : 68 > pla ;load status +1e5a : 48 > pha + > cmp_flag ~fzc +1e5b : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e5d : d0fe > bne * ;failed not equal (non zero) + > +1e5f : 28 > plp ;restore status + + next_test +1e60 : ad0002 > lda test_case ;previous test +1e63 : c91b > cmp #test_num + > trap_ne ;test is out of sequence +1e65 : d0fe > bne * ;failed not equal (non zero) + > +001c = >test_num = test_num + 1 +1e67 : a91c > lda #test_num ;*** next tests' number +1e69 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; CMP - zp / abs / # + set_a $80,0 + > load_flag 0 +1e6c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1e6e : 48 > pha ;use stack to load status +1e6f : a980 > lda #$80 ;precharge accu +1e71 : 28 > plp + +1e72 : c517 cmp zp7f + tst_a $80,fc +1e74 : 08 > php ;save flags +1e75 : c980 > cmp #$80 ;test result + > trap_ne +1e77 : d0fe > bne * ;failed not equal (non zero) + > +1e79 : 68 > pla ;load status +1e7a : 48 > pha + > cmp_flag fc +1e7b : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e7d : d0fe > bne * ;failed not equal (non zero) + > +1e7f : 28 > plp ;restore status + + set_a $7f,0 + > load_flag 0 +1e80 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1e82 : 48 > pha ;use stack to load status +1e83 : a97f > lda #$7f ;precharge accu +1e85 : 28 > plp + +1e86 : c517 cmp zp7f + tst_a $7f,fzc +1e88 : 08 > php ;save flags +1e89 : c97f > cmp #$7f ;test result + > trap_ne +1e8b : d0fe > bne * ;failed not equal (non zero) + > +1e8d : 68 > pla ;load status +1e8e : 48 > pha + > cmp_flag fzc +1e8f : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e91 : d0fe > bne * ;failed not equal (non zero) + > +1e93 : 28 > plp ;restore status + + set_a $7e,0 + > load_flag 0 +1e94 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1e96 : 48 > pha ;use stack to load status +1e97 : a97e > lda #$7e ;precharge accu +1e99 : 28 > plp + +1e9a : c517 cmp zp7f + tst_a $7e,fn +1e9c : 08 > php ;save flags +1e9d : c97e > cmp #$7e ;test result + > trap_ne +1e9f : d0fe > bne * ;failed not equal (non zero) + > +1ea1 : 68 > pla ;load status +1ea2 : 48 > pha + > cmp_flag fn +1ea3 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ea5 : d0fe > bne * ;failed not equal (non zero) + > +1ea7 : 28 > plp ;restore status + + set_a $80,$ff + > load_flag $ff +1ea8 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1eaa : 48 > pha ;use stack to load status +1eab : a980 > lda #$80 ;precharge accu +1ead : 28 > plp + +1eae : c517 cmp zp7f + tst_a $80,~fnz +1eb0 : 08 > php ;save flags +1eb1 : c980 > cmp #$80 ;test result + > trap_ne +1eb3 : d0fe > bne * ;failed not equal (non zero) + > +1eb5 : 68 > pla ;load status +1eb6 : 48 > pha + > cmp_flag ~fnz +1eb7 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1eb9 : d0fe > bne * ;failed not equal (non zero) + > +1ebb : 28 > plp ;restore status + + set_a $7f,$ff + > load_flag $ff +1ebc : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1ebe : 48 > pha ;use stack to load status +1ebf : a97f > lda #$7f ;precharge accu +1ec1 : 28 > plp + +1ec2 : c517 cmp zp7f + tst_a $7f,~fn +1ec4 : 08 > php ;save flags +1ec5 : c97f > cmp #$7f ;test result + > trap_ne +1ec7 : d0fe > bne * ;failed not equal (non zero) + > +1ec9 : 68 > pla ;load status +1eca : 48 > pha + > cmp_flag ~fn +1ecb : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ecd : d0fe > bne * ;failed not equal (non zero) + > +1ecf : 28 > plp ;restore status + + set_a $7e,$ff + > load_flag $ff +1ed0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1ed2 : 48 > pha ;use stack to load status +1ed3 : a97e > lda #$7e ;precharge accu +1ed5 : 28 > plp + +1ed6 : c517 cmp zp7f + tst_a $7e,~fzc +1ed8 : 08 > php ;save flags +1ed9 : c97e > cmp #$7e ;test result + > trap_ne +1edb : d0fe > bne * ;failed not equal (non zero) + > +1edd : 68 > pla ;load status +1ede : 48 > pha + > cmp_flag ~fzc +1edf : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ee1 : d0fe > bne * ;failed not equal (non zero) + > +1ee3 : 28 > plp ;restore status + + + set_a $80,0 + > load_flag 0 +1ee4 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1ee6 : 48 > pha ;use stack to load status +1ee7 : a980 > lda #$80 ;precharge accu +1ee9 : 28 > plp + +1eea : cd0c02 cmp abs7f + tst_a $80,fc +1eed : 08 > php ;save flags +1eee : c980 > cmp #$80 ;test result + > trap_ne +1ef0 : d0fe > bne * ;failed not equal (non zero) + > +1ef2 : 68 > pla ;load status +1ef3 : 48 > pha + > cmp_flag fc +1ef4 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ef6 : d0fe > bne * ;failed not equal (non zero) + > +1ef8 : 28 > plp ;restore status + + set_a $7f,0 + > load_flag 0 +1ef9 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1efb : 48 > pha ;use stack to load status +1efc : a97f > lda #$7f ;precharge accu +1efe : 28 > plp + +1eff : cd0c02 cmp abs7f + tst_a $7f,fzc +1f02 : 08 > php ;save flags +1f03 : c97f > cmp #$7f ;test result + > trap_ne +1f05 : d0fe > bne * ;failed not equal (non zero) + > +1f07 : 68 > pla ;load status +1f08 : 48 > pha + > cmp_flag fzc +1f09 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f0b : d0fe > bne * ;failed not equal (non zero) + > +1f0d : 28 > plp ;restore status + + set_a $7e,0 + > load_flag 0 +1f0e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1f10 : 48 > pha ;use stack to load status +1f11 : a97e > lda #$7e ;precharge accu +1f13 : 28 > plp + +1f14 : cd0c02 cmp abs7f + tst_a $7e,fn +1f17 : 08 > php ;save flags +1f18 : c97e > cmp #$7e ;test result + > trap_ne +1f1a : d0fe > bne * ;failed not equal (non zero) + > +1f1c : 68 > pla ;load status +1f1d : 48 > pha + > cmp_flag fn +1f1e : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f20 : d0fe > bne * ;failed not equal (non zero) + > +1f22 : 28 > plp ;restore status + + set_a $80,$ff + > load_flag $ff +1f23 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1f25 : 48 > pha ;use stack to load status +1f26 : a980 > lda #$80 ;precharge accu +1f28 : 28 > plp + +1f29 : cd0c02 cmp abs7f + tst_a $80,~fnz +1f2c : 08 > php ;save flags +1f2d : c980 > cmp #$80 ;test result + > trap_ne +1f2f : d0fe > bne * ;failed not equal (non zero) + > +1f31 : 68 > pla ;load status +1f32 : 48 > pha + > cmp_flag ~fnz +1f33 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f35 : d0fe > bne * ;failed not equal (non zero) + > +1f37 : 28 > plp ;restore status + + set_a $7f,$ff + > load_flag $ff +1f38 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1f3a : 48 > pha ;use stack to load status +1f3b : a97f > lda #$7f ;precharge accu +1f3d : 28 > plp + +1f3e : cd0c02 cmp abs7f + tst_a $7f,~fn +1f41 : 08 > php ;save flags +1f42 : c97f > cmp #$7f ;test result + > trap_ne +1f44 : d0fe > bne * ;failed not equal (non zero) + > +1f46 : 68 > pla ;load status +1f47 : 48 > pha + > cmp_flag ~fn +1f48 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f4a : d0fe > bne * ;failed not equal (non zero) + > +1f4c : 28 > plp ;restore status + + set_a $7e,$ff + > load_flag $ff +1f4d : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1f4f : 48 > pha ;use stack to load status +1f50 : a97e > lda #$7e ;precharge accu +1f52 : 28 > plp + +1f53 : cd0c02 cmp abs7f + tst_a $7e,~fzc +1f56 : 08 > php ;save flags +1f57 : c97e > cmp #$7e ;test result + > trap_ne +1f59 : d0fe > bne * ;failed not equal (non zero) + > +1f5b : 68 > pla ;load status +1f5c : 48 > pha + > cmp_flag ~fzc +1f5d : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f5f : d0fe > bne * ;failed not equal (non zero) + > +1f61 : 28 > plp ;restore status + + + set_a $80,0 + > load_flag 0 +1f62 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1f64 : 48 > pha ;use stack to load status +1f65 : a980 > lda #$80 ;precharge accu +1f67 : 28 > plp + +1f68 : c97f cmp #$7f + tst_a $80,fc +1f6a : 08 > php ;save flags +1f6b : c980 > cmp #$80 ;test result + > trap_ne +1f6d : d0fe > bne * ;failed not equal (non zero) + > +1f6f : 68 > pla ;load status +1f70 : 48 > pha + > cmp_flag fc +1f71 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f73 : d0fe > bne * ;failed not equal (non zero) + > +1f75 : 28 > plp ;restore status + + set_a $7f,0 + > load_flag 0 +1f76 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1f78 : 48 > pha ;use stack to load status +1f79 : a97f > lda #$7f ;precharge accu +1f7b : 28 > plp + +1f7c : c97f cmp #$7f + tst_a $7f,fzc +1f7e : 08 > php ;save flags +1f7f : c97f > cmp #$7f ;test result + > trap_ne +1f81 : d0fe > bne * ;failed not equal (non zero) + > +1f83 : 68 > pla ;load status +1f84 : 48 > pha + > cmp_flag fzc +1f85 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f87 : d0fe > bne * ;failed not equal (non zero) + > +1f89 : 28 > plp ;restore status + + set_a $7e,0 + > load_flag 0 +1f8a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1f8c : 48 > pha ;use stack to load status +1f8d : a97e > lda #$7e ;precharge accu +1f8f : 28 > plp + +1f90 : c97f cmp #$7f + tst_a $7e,fn +1f92 : 08 > php ;save flags +1f93 : c97e > cmp #$7e ;test result + > trap_ne +1f95 : d0fe > bne * ;failed not equal (non zero) + > +1f97 : 68 > pla ;load status +1f98 : 48 > pha + > cmp_flag fn +1f99 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f9b : d0fe > bne * ;failed not equal (non zero) + > +1f9d : 28 > plp ;restore status + + set_a $80,$ff + > load_flag $ff +1f9e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1fa0 : 48 > pha ;use stack to load status +1fa1 : a980 > lda #$80 ;precharge accu +1fa3 : 28 > plp + +1fa4 : c97f cmp #$7f + tst_a $80,~fnz +1fa6 : 08 > php ;save flags +1fa7 : c980 > cmp #$80 ;test result + > trap_ne +1fa9 : d0fe > bne * ;failed not equal (non zero) + > +1fab : 68 > pla ;load status +1fac : 48 > pha + > cmp_flag ~fnz +1fad : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1faf : d0fe > bne * ;failed not equal (non zero) + > +1fb1 : 28 > plp ;restore status + + set_a $7f,$ff + > load_flag $ff +1fb2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1fb4 : 48 > pha ;use stack to load status +1fb5 : a97f > lda #$7f ;precharge accu +1fb7 : 28 > plp + +1fb8 : c97f cmp #$7f + tst_a $7f,~fn +1fba : 08 > php ;save flags +1fbb : c97f > cmp #$7f ;test result + > trap_ne +1fbd : d0fe > bne * ;failed not equal (non zero) + > +1fbf : 68 > pla ;load status +1fc0 : 48 > pha + > cmp_flag ~fn +1fc1 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1fc3 : d0fe > bne * ;failed not equal (non zero) + > +1fc5 : 28 > plp ;restore status + + set_a $7e,$ff + > load_flag $ff +1fc6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1fc8 : 48 > pha ;use stack to load status +1fc9 : a97e > lda #$7e ;precharge accu +1fcb : 28 > plp + +1fcc : c97f cmp #$7f + tst_a $7e,~fzc +1fce : 08 > php ;save flags +1fcf : c97e > cmp #$7e ;test result + > trap_ne +1fd1 : d0fe > bne * ;failed not equal (non zero) + > +1fd3 : 68 > pla ;load status +1fd4 : 48 > pha + > cmp_flag ~fzc +1fd5 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1fd7 : d0fe > bne * ;failed not equal (non zero) + > +1fd9 : 28 > plp ;restore status + + +1fda : a204 ldx #4 ;with indexing by X + set_a $80,0 + > load_flag 0 +1fdc : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1fde : 48 > pha ;use stack to load status +1fdf : a980 > lda #$80 ;precharge accu +1fe1 : 28 > plp + +1fe2 : d513 cmp zp1,x + tst_a $80,fc +1fe4 : 08 > php ;save flags +1fe5 : c980 > cmp #$80 ;test result + > trap_ne +1fe7 : d0fe > bne * ;failed not equal (non zero) + > +1fe9 : 68 > pla ;load status +1fea : 48 > pha + > cmp_flag fc +1feb : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1fed : d0fe > bne * ;failed not equal (non zero) + > +1fef : 28 > plp ;restore status + + set_a $7f,0 + > load_flag 0 +1ff0 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1ff2 : 48 > pha ;use stack to load status +1ff3 : a97f > lda #$7f ;precharge accu +1ff5 : 28 > plp + +1ff6 : d513 cmp zp1,x + tst_a $7f,fzc +1ff8 : 08 > php ;save flags +1ff9 : c97f > cmp #$7f ;test result + > trap_ne +1ffb : d0fe > bne * ;failed not equal (non zero) + > +1ffd : 68 > pla ;load status +1ffe : 48 > pha + > cmp_flag fzc +1fff : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2001 : d0fe > bne * ;failed not equal (non zero) + > +2003 : 28 > plp ;restore status + + set_a $7e,0 + > load_flag 0 +2004 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2006 : 48 > pha ;use stack to load status +2007 : a97e > lda #$7e ;precharge accu +2009 : 28 > plp + +200a : d513 cmp zp1,x + tst_a $7e,fn +200c : 08 > php ;save flags +200d : c97e > cmp #$7e ;test result + > trap_ne +200f : d0fe > bne * ;failed not equal (non zero) + > +2011 : 68 > pla ;load status +2012 : 48 > pha + > cmp_flag fn +2013 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2015 : d0fe > bne * ;failed not equal (non zero) + > +2017 : 28 > plp ;restore status + + set_a $80,$ff + > load_flag $ff +2018 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +201a : 48 > pha ;use stack to load status +201b : a980 > lda #$80 ;precharge accu +201d : 28 > plp + +201e : d513 cmp zp1,x + tst_a $80,~fnz +2020 : 08 > php ;save flags +2021 : c980 > cmp #$80 ;test result + > trap_ne +2023 : d0fe > bne * ;failed not equal (non zero) + > +2025 : 68 > pla ;load status +2026 : 48 > pha + > cmp_flag ~fnz +2027 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2029 : d0fe > bne * ;failed not equal (non zero) + > +202b : 28 > plp ;restore status + + set_a $7f,$ff + > load_flag $ff +202c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +202e : 48 > pha ;use stack to load status +202f : a97f > lda #$7f ;precharge accu +2031 : 28 > plp + +2032 : d513 cmp zp1,x + tst_a $7f,~fn +2034 : 08 > php ;save flags +2035 : c97f > cmp #$7f ;test result + > trap_ne +2037 : d0fe > bne * ;failed not equal (non zero) + > +2039 : 68 > pla ;load status +203a : 48 > pha + > cmp_flag ~fn +203b : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +203d : d0fe > bne * ;failed not equal (non zero) + > +203f : 28 > plp ;restore status + + set_a $7e,$ff + > load_flag $ff +2040 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2042 : 48 > pha ;use stack to load status +2043 : a97e > lda #$7e ;precharge accu +2045 : 28 > plp + +2046 : d513 cmp zp1,x + tst_a $7e,~fzc +2048 : 08 > php ;save flags +2049 : c97e > cmp #$7e ;test result + > trap_ne +204b : d0fe > bne * ;failed not equal (non zero) + > +204d : 68 > pla ;load status +204e : 48 > pha + > cmp_flag ~fzc +204f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2051 : d0fe > bne * ;failed not equal (non zero) + > +2053 : 28 > plp ;restore status + + + set_a $80,0 + > load_flag 0 +2054 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2056 : 48 > pha ;use stack to load status +2057 : a980 > lda #$80 ;precharge accu +2059 : 28 > plp + +205a : dd0802 cmp abs1,x + tst_a $80,fc +205d : 08 > php ;save flags +205e : c980 > cmp #$80 ;test result + > trap_ne +2060 : d0fe > bne * ;failed not equal (non zero) + > +2062 : 68 > pla ;load status +2063 : 48 > pha + > cmp_flag fc +2064 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2066 : d0fe > bne * ;failed not equal (non zero) + > +2068 : 28 > plp ;restore status + + set_a $7f,0 + > load_flag 0 +2069 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +206b : 48 > pha ;use stack to load status +206c : a97f > lda #$7f ;precharge accu +206e : 28 > plp + +206f : dd0802 cmp abs1,x + tst_a $7f,fzc +2072 : 08 > php ;save flags +2073 : c97f > cmp #$7f ;test result + > trap_ne +2075 : d0fe > bne * ;failed not equal (non zero) + > +2077 : 68 > pla ;load status +2078 : 48 > pha + > cmp_flag fzc +2079 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +207b : d0fe > bne * ;failed not equal (non zero) + > +207d : 28 > plp ;restore status + + set_a $7e,0 + > load_flag 0 +207e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2080 : 48 > pha ;use stack to load status +2081 : a97e > lda #$7e ;precharge accu +2083 : 28 > plp + +2084 : dd0802 cmp abs1,x + tst_a $7e,fn +2087 : 08 > php ;save flags +2088 : c97e > cmp #$7e ;test result + > trap_ne +208a : d0fe > bne * ;failed not equal (non zero) + > +208c : 68 > pla ;load status +208d : 48 > pha + > cmp_flag fn +208e : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2090 : d0fe > bne * ;failed not equal (non zero) + > +2092 : 28 > plp ;restore status + + set_a $80,$ff + > load_flag $ff +2093 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2095 : 48 > pha ;use stack to load status +2096 : a980 > lda #$80 ;precharge accu +2098 : 28 > plp + +2099 : dd0802 cmp abs1,x + tst_a $80,~fnz +209c : 08 > php ;save flags +209d : c980 > cmp #$80 ;test result + > trap_ne +209f : d0fe > bne * ;failed not equal (non zero) + > +20a1 : 68 > pla ;load status +20a2 : 48 > pha + > cmp_flag ~fnz +20a3 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +20a5 : d0fe > bne * ;failed not equal (non zero) + > +20a7 : 28 > plp ;restore status + + set_a $7f,$ff + > load_flag $ff +20a8 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +20aa : 48 > pha ;use stack to load status +20ab : a97f > lda #$7f ;precharge accu +20ad : 28 > plp + +20ae : dd0802 cmp abs1,x + tst_a $7f,~fn +20b1 : 08 > php ;save flags +20b2 : c97f > cmp #$7f ;test result + > trap_ne +20b4 : d0fe > bne * ;failed not equal (non zero) + > +20b6 : 68 > pla ;load status +20b7 : 48 > pha + > cmp_flag ~fn +20b8 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +20ba : d0fe > bne * ;failed not equal (non zero) + > +20bc : 28 > plp ;restore status + + set_a $7e,$ff + > load_flag $ff +20bd : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +20bf : 48 > pha ;use stack to load status +20c0 : a97e > lda #$7e ;precharge accu +20c2 : 28 > plp + +20c3 : dd0802 cmp abs1,x + tst_a $7e,~fzc +20c6 : 08 > php ;save flags +20c7 : c97e > cmp #$7e ;test result + > trap_ne +20c9 : d0fe > bne * ;failed not equal (non zero) + > +20cb : 68 > pla ;load status +20cc : 48 > pha + > cmp_flag ~fzc +20cd : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +20cf : d0fe > bne * ;failed not equal (non zero) + > +20d1 : 28 > plp ;restore status + + +20d2 : a004 ldy #4 ;with indexing by Y +20d4 : a208 ldx #8 ;with indexed indirect + set_a $80,0 + > load_flag 0 +20d6 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +20d8 : 48 > pha ;use stack to load status +20d9 : a980 > lda #$80 ;precharge accu +20db : 28 > plp + +20dc : d90802 cmp abs1,y + tst_a $80,fc +20df : 08 > php ;save flags +20e0 : c980 > cmp #$80 ;test result + > trap_ne +20e2 : d0fe > bne * ;failed not equal (non zero) + > +20e4 : 68 > pla ;load status +20e5 : 48 > pha + > cmp_flag fc +20e6 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +20e8 : d0fe > bne * ;failed not equal (non zero) + > +20ea : 28 > plp ;restore status + + set_a $7f,0 + > load_flag 0 +20eb : a900 > lda #0 ;allow test to change I-flag (no mask) + > +20ed : 48 > pha ;use stack to load status +20ee : a97f > lda #$7f ;precharge accu +20f0 : 28 > plp + +20f1 : d90802 cmp abs1,y + tst_a $7f,fzc +20f4 : 08 > php ;save flags +20f5 : c97f > cmp #$7f ;test result + > trap_ne +20f7 : d0fe > bne * ;failed not equal (non zero) + > +20f9 : 68 > pla ;load status +20fa : 48 > pha + > cmp_flag fzc +20fb : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +20fd : d0fe > bne * ;failed not equal (non zero) + > +20ff : 28 > plp ;restore status + + set_a $7e,0 + > load_flag 0 +2100 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2102 : 48 > pha ;use stack to load status +2103 : a97e > lda #$7e ;precharge accu +2105 : 28 > plp + +2106 : d90802 cmp abs1,y + tst_a $7e,fn +2109 : 08 > php ;save flags +210a : c97e > cmp #$7e ;test result + > trap_ne +210c : d0fe > bne * ;failed not equal (non zero) + > +210e : 68 > pla ;load status +210f : 48 > pha + > cmp_flag fn +2110 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2112 : d0fe > bne * ;failed not equal (non zero) + > +2114 : 28 > plp ;restore status + + set_a $80,$ff + > load_flag $ff +2115 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2117 : 48 > pha ;use stack to load status +2118 : a980 > lda #$80 ;precharge accu +211a : 28 > plp + +211b : d90802 cmp abs1,y + tst_a $80,~fnz +211e : 08 > php ;save flags +211f : c980 > cmp #$80 ;test result + > trap_ne +2121 : d0fe > bne * ;failed not equal (non zero) + > +2123 : 68 > pla ;load status +2124 : 48 > pha + > cmp_flag ~fnz +2125 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2127 : d0fe > bne * ;failed not equal (non zero) + > +2129 : 28 > plp ;restore status + + set_a $7f,$ff + > load_flag $ff +212a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +212c : 48 > pha ;use stack to load status +212d : a97f > lda #$7f ;precharge accu +212f : 28 > plp + +2130 : d90802 cmp abs1,y + tst_a $7f,~fn +2133 : 08 > php ;save flags +2134 : c97f > cmp #$7f ;test result + > trap_ne +2136 : d0fe > bne * ;failed not equal (non zero) + > +2138 : 68 > pla ;load status +2139 : 48 > pha + > cmp_flag ~fn +213a : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +213c : d0fe > bne * ;failed not equal (non zero) + > +213e : 28 > plp ;restore status + + set_a $7e,$ff + > load_flag $ff +213f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2141 : 48 > pha ;use stack to load status +2142 : a97e > lda #$7e ;precharge accu +2144 : 28 > plp + +2145 : d90802 cmp abs1,y + tst_a $7e,~fzc +2148 : 08 > php ;save flags +2149 : c97e > cmp #$7e ;test result + > trap_ne +214b : d0fe > bne * ;failed not equal (non zero) + > +214d : 68 > pla ;load status +214e : 48 > pha + > cmp_flag ~fzc +214f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2151 : d0fe > bne * ;failed not equal (non zero) + > +2153 : 28 > plp ;restore status + + + set_a $80,0 + > load_flag 0 +2154 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2156 : 48 > pha ;use stack to load status +2157 : a980 > lda #$80 ;precharge accu +2159 : 28 > plp + +215a : c124 cmp (ind1,x) + tst_a $80,fc +215c : 08 > php ;save flags +215d : c980 > cmp #$80 ;test result + > trap_ne +215f : d0fe > bne * ;failed not equal (non zero) + > +2161 : 68 > pla ;load status +2162 : 48 > pha + > cmp_flag fc +2163 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2165 : d0fe > bne * ;failed not equal (non zero) + > +2167 : 28 > plp ;restore status + + set_a $7f,0 + > load_flag 0 +2168 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +216a : 48 > pha ;use stack to load status +216b : a97f > lda #$7f ;precharge accu +216d : 28 > plp + +216e : c124 cmp (ind1,x) + tst_a $7f,fzc +2170 : 08 > php ;save flags +2171 : c97f > cmp #$7f ;test result + > trap_ne +2173 : d0fe > bne * ;failed not equal (non zero) + > +2175 : 68 > pla ;load status +2176 : 48 > pha + > cmp_flag fzc +2177 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2179 : d0fe > bne * ;failed not equal (non zero) + > +217b : 28 > plp ;restore status + + set_a $7e,0 + > load_flag 0 +217c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +217e : 48 > pha ;use stack to load status +217f : a97e > lda #$7e ;precharge accu +2181 : 28 > plp + +2182 : c124 cmp (ind1,x) + tst_a $7e,fn +2184 : 08 > php ;save flags +2185 : c97e > cmp #$7e ;test result + > trap_ne +2187 : d0fe > bne * ;failed not equal (non zero) + > +2189 : 68 > pla ;load status +218a : 48 > pha + > cmp_flag fn +218b : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +218d : d0fe > bne * ;failed not equal (non zero) + > +218f : 28 > plp ;restore status + + set_a $80,$ff + > load_flag $ff +2190 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2192 : 48 > pha ;use stack to load status +2193 : a980 > lda #$80 ;precharge accu +2195 : 28 > plp + +2196 : c124 cmp (ind1,x) + tst_a $80,~fnz +2198 : 08 > php ;save flags +2199 : c980 > cmp #$80 ;test result + > trap_ne +219b : d0fe > bne * ;failed not equal (non zero) + > +219d : 68 > pla ;load status +219e : 48 > pha + > cmp_flag ~fnz +219f : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +21a1 : d0fe > bne * ;failed not equal (non zero) + > +21a3 : 28 > plp ;restore status + + set_a $7f,$ff + > load_flag $ff +21a4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +21a6 : 48 > pha ;use stack to load status +21a7 : a97f > lda #$7f ;precharge accu +21a9 : 28 > plp + +21aa : c124 cmp (ind1,x) + tst_a $7f,~fn +21ac : 08 > php ;save flags +21ad : c97f > cmp #$7f ;test result + > trap_ne +21af : d0fe > bne * ;failed not equal (non zero) + > +21b1 : 68 > pla ;load status +21b2 : 48 > pha + > cmp_flag ~fn +21b3 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +21b5 : d0fe > bne * ;failed not equal (non zero) + > +21b7 : 28 > plp ;restore status + + set_a $7e,$ff + > load_flag $ff +21b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +21ba : 48 > pha ;use stack to load status +21bb : a97e > lda #$7e ;precharge accu +21bd : 28 > plp + +21be : c124 cmp (ind1,x) + tst_a $7e,~fzc +21c0 : 08 > php ;save flags +21c1 : c97e > cmp #$7e ;test result + > trap_ne +21c3 : d0fe > bne * ;failed not equal (non zero) + > +21c5 : 68 > pla ;load status +21c6 : 48 > pha + > cmp_flag ~fzc +21c7 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +21c9 : d0fe > bne * ;failed not equal (non zero) + > +21cb : 28 > plp ;restore status + + + set_a $80,0 + > load_flag 0 +21cc : a900 > lda #0 ;allow test to change I-flag (no mask) + > +21ce : 48 > pha ;use stack to load status +21cf : a980 > lda #$80 ;precharge accu +21d1 : 28 > plp + +21d2 : d124 cmp (ind1),y + tst_a $80,fc +21d4 : 08 > php ;save flags +21d5 : c980 > cmp #$80 ;test result + > trap_ne +21d7 : d0fe > bne * ;failed not equal (non zero) + > +21d9 : 68 > pla ;load status +21da : 48 > pha + > cmp_flag fc +21db : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +21dd : d0fe > bne * ;failed not equal (non zero) + > +21df : 28 > plp ;restore status + + set_a $7f,0 + > load_flag 0 +21e0 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +21e2 : 48 > pha ;use stack to load status +21e3 : a97f > lda #$7f ;precharge accu +21e5 : 28 > plp + +21e6 : d124 cmp (ind1),y + tst_a $7f,fzc +21e8 : 08 > php ;save flags +21e9 : c97f > cmp #$7f ;test result + > trap_ne +21eb : d0fe > bne * ;failed not equal (non zero) + > +21ed : 68 > pla ;load status +21ee : 48 > pha + > cmp_flag fzc +21ef : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +21f1 : d0fe > bne * ;failed not equal (non zero) + > +21f3 : 28 > plp ;restore status + + set_a $7e,0 + > load_flag 0 +21f4 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +21f6 : 48 > pha ;use stack to load status +21f7 : a97e > lda #$7e ;precharge accu +21f9 : 28 > plp + +21fa : d124 cmp (ind1),y + tst_a $7e,fn +21fc : 08 > php ;save flags +21fd : c97e > cmp #$7e ;test result + > trap_ne +21ff : d0fe > bne * ;failed not equal (non zero) + > +2201 : 68 > pla ;load status +2202 : 48 > pha + > cmp_flag fn +2203 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2205 : d0fe > bne * ;failed not equal (non zero) + > +2207 : 28 > plp ;restore status + + set_a $80,$ff + > load_flag $ff +2208 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +220a : 48 > pha ;use stack to load status +220b : a980 > lda #$80 ;precharge accu +220d : 28 > plp + +220e : d124 cmp (ind1),y + tst_a $80,~fnz +2210 : 08 > php ;save flags +2211 : c980 > cmp #$80 ;test result + > trap_ne +2213 : d0fe > bne * ;failed not equal (non zero) + > +2215 : 68 > pla ;load status +2216 : 48 > pha + > cmp_flag ~fnz +2217 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2219 : d0fe > bne * ;failed not equal (non zero) + > +221b : 28 > plp ;restore status + + set_a $7f,$ff + > load_flag $ff +221c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +221e : 48 > pha ;use stack to load status +221f : a97f > lda #$7f ;precharge accu +2221 : 28 > plp + +2222 : d124 cmp (ind1),y + tst_a $7f,~fn +2224 : 08 > php ;save flags +2225 : c97f > cmp #$7f ;test result + > trap_ne +2227 : d0fe > bne * ;failed not equal (non zero) + > +2229 : 68 > pla ;load status +222a : 48 > pha + > cmp_flag ~fn +222b : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +222d : d0fe > bne * ;failed not equal (non zero) + > +222f : 28 > plp ;restore status + + set_a $7e,$ff + > load_flag $ff +2230 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2232 : 48 > pha ;use stack to load status +2233 : a97e > lda #$7e ;precharge accu +2235 : 28 > plp + +2236 : d124 cmp (ind1),y + tst_a $7e,~fzc +2238 : 08 > php ;save flags +2239 : c97e > cmp #$7e ;test result + > trap_ne +223b : d0fe > bne * ;failed not equal (non zero) + > +223d : 68 > pla ;load status +223e : 48 > pha + > cmp_flag ~fzc +223f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2241 : d0fe > bne * ;failed not equal (non zero) + > +2243 : 28 > plp ;restore status + + next_test +2244 : ad0002 > lda test_case ;previous test +2247 : c91c > cmp #test_num + > trap_ne ;test is out of sequence +2249 : d0fe > bne * ;failed not equal (non zero) + > +001d = >test_num = test_num + 1 +224b : a91d > lda #test_num ;*** next tests' number +224d : 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 +2250 : a203 ldx #3 +2252 : tasl + set_ax zp1,0 + > load_flag 0 +2252 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2254 : 48 > pha ;use stack to load status +2255 : b513 > lda zp1,x ;precharge accu +2257 : 28 > plp + +2258 : 0a asl a + tst_ax rASL,fASL,0 +2259 : 08 > php ;save flags +225a : dd1102 > cmp rASL,x ;test result + > trap_ne +225d : d0fe > bne * ;failed not equal (non zero) + > +225f : 68 > pla ;load status + > eor_flag 0 +2260 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2262 : dd2102 > cmp fASL,x ;test flags + > trap_ne ; +2265 : d0fe > bne * ;failed not equal (non zero) + > + +2267 : ca dex +2268 : 10e8 bpl tasl +226a : a203 ldx #3 +226c : tasl1 + set_ax zp1,$ff + > load_flag $ff +226c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +226e : 48 > pha ;use stack to load status +226f : b513 > lda zp1,x ;precharge accu +2271 : 28 > plp + +2272 : 0a asl a + tst_ax rASL,fASL,$ff-fnzc +2273 : 08 > php ;save flags +2274 : dd1102 > cmp rASL,x ;test result + > trap_ne +2277 : d0fe > bne * ;failed not equal (non zero) + > +2279 : 68 > pla ;load status + > eor_flag $ff-fnzc +227a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +227c : dd2102 > cmp fASL,x ;test flags + > trap_ne ; +227f : d0fe > bne * ;failed not equal (non zero) + > + +2281 : ca dex +2282 : 10e8 bpl tasl1 + +2284 : a203 ldx #3 +2286 : tlsr + set_ax zp1,0 + > load_flag 0 +2286 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2288 : 48 > pha ;use stack to load status +2289 : b513 > lda zp1,x ;precharge accu +228b : 28 > plp + +228c : 4a lsr a + tst_ax rLSR,fLSR,0 +228d : 08 > php ;save flags +228e : dd1902 > cmp rLSR,x ;test result + > trap_ne +2291 : d0fe > bne * ;failed not equal (non zero) + > +2293 : 68 > pla ;load status + > eor_flag 0 +2294 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2296 : dd2902 > cmp fLSR,x ;test flags + > trap_ne ; +2299 : d0fe > bne * ;failed not equal (non zero) + > + +229b : ca dex +229c : 10e8 bpl tlsr +229e : a203 ldx #3 +22a0 : tlsr1 + set_ax zp1,$ff + > load_flag $ff +22a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +22a2 : 48 > pha ;use stack to load status +22a3 : b513 > lda zp1,x ;precharge accu +22a5 : 28 > plp + +22a6 : 4a lsr a + tst_ax rLSR,fLSR,$ff-fnzc +22a7 : 08 > php ;save flags +22a8 : dd1902 > cmp rLSR,x ;test result + > trap_ne +22ab : d0fe > bne * ;failed not equal (non zero) + > +22ad : 68 > pla ;load status + > eor_flag $ff-fnzc +22ae : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +22b0 : dd2902 > cmp fLSR,x ;test flags + > trap_ne ; +22b3 : d0fe > bne * ;failed not equal (non zero) + > + +22b5 : ca dex +22b6 : 10e8 bpl tlsr1 + +22b8 : a203 ldx #3 +22ba : trol + set_ax zp1,0 + > load_flag 0 +22ba : a900 > lda #0 ;allow test to change I-flag (no mask) + > +22bc : 48 > pha ;use stack to load status +22bd : b513 > lda zp1,x ;precharge accu +22bf : 28 > plp + +22c0 : 2a rol a + tst_ax rROL,fROL,0 +22c1 : 08 > php ;save flags +22c2 : dd1102 > cmp rROL,x ;test result + > trap_ne +22c5 : d0fe > bne * ;failed not equal (non zero) + > +22c7 : 68 > pla ;load status + > eor_flag 0 +22c8 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +22ca : dd2102 > cmp fROL,x ;test flags + > trap_ne ; +22cd : d0fe > bne * ;failed not equal (non zero) + > + +22cf : ca dex +22d0 : 10e8 bpl trol +22d2 : a203 ldx #3 +22d4 : trol1 + set_ax zp1,$ff-fc + > load_flag $ff-fc +22d4 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) + > +22d6 : 48 > pha ;use stack to load status +22d7 : b513 > lda zp1,x ;precharge accu +22d9 : 28 > plp + +22da : 2a rol a + tst_ax rROL,fROL,$ff-fnzc +22db : 08 > php ;save flags +22dc : dd1102 > cmp rROL,x ;test result + > trap_ne +22df : d0fe > bne * ;failed not equal (non zero) + > +22e1 : 68 > pla ;load status + > eor_flag $ff-fnzc +22e2 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +22e4 : dd2102 > cmp fROL,x ;test flags + > trap_ne ; +22e7 : d0fe > bne * ;failed not equal (non zero) + > + +22e9 : ca dex +22ea : 10e8 bpl trol1 + +22ec : a203 ldx #3 +22ee : trolc + set_ax zp1,fc + > load_flag fc +22ee : a901 > lda #fc ;allow test to change I-flag (no mask) + > +22f0 : 48 > pha ;use stack to load status +22f1 : b513 > lda zp1,x ;precharge accu +22f3 : 28 > plp + +22f4 : 2a rol a + tst_ax rROLc,fROLc,0 +22f5 : 08 > php ;save flags +22f6 : dd1502 > cmp rROLc,x ;test result + > trap_ne +22f9 : d0fe > bne * ;failed not equal (non zero) + > +22fb : 68 > pla ;load status + > eor_flag 0 +22fc : 4930 > eor #0|fao ;invert expected flags + always on bits + > +22fe : dd2502 > cmp fROLc,x ;test flags + > trap_ne ; +2301 : d0fe > bne * ;failed not equal (non zero) + > + +2303 : ca dex +2304 : 10e8 bpl trolc +2306 : a203 ldx #3 +2308 : trolc1 + set_ax zp1,$ff + > load_flag $ff +2308 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +230a : 48 > pha ;use stack to load status +230b : b513 > lda zp1,x ;precharge accu +230d : 28 > plp + +230e : 2a rol a + tst_ax rROLc,fROLc,$ff-fnzc +230f : 08 > php ;save flags +2310 : dd1502 > cmp rROLc,x ;test result + > trap_ne +2313 : d0fe > bne * ;failed not equal (non zero) + > +2315 : 68 > pla ;load status + > eor_flag $ff-fnzc +2316 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2318 : dd2502 > cmp fROLc,x ;test flags + > trap_ne ; +231b : d0fe > bne * ;failed not equal (non zero) + > + +231d : ca dex +231e : 10e8 bpl trolc1 + +2320 : a203 ldx #3 +2322 : tror + set_ax zp1,0 + > load_flag 0 +2322 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2324 : 48 > pha ;use stack to load status +2325 : b513 > lda zp1,x ;precharge accu +2327 : 28 > plp + +2328 : 6a ror a + tst_ax rROR,fROR,0 +2329 : 08 > php ;save flags +232a : dd1902 > cmp rROR,x ;test result + > trap_ne +232d : d0fe > bne * ;failed not equal (non zero) + > +232f : 68 > pla ;load status + > eor_flag 0 +2330 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2332 : dd2902 > cmp fROR,x ;test flags + > trap_ne ; +2335 : d0fe > bne * ;failed not equal (non zero) + > + +2337 : ca dex +2338 : 10e8 bpl tror +233a : a203 ldx #3 +233c : tror1 + set_ax zp1,$ff-fc + > load_flag $ff-fc +233c : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) + > +233e : 48 > pha ;use stack to load status +233f : b513 > lda zp1,x ;precharge accu +2341 : 28 > plp + +2342 : 6a ror a + tst_ax rROR,fROR,$ff-fnzc +2343 : 08 > php ;save flags +2344 : dd1902 > cmp rROR,x ;test result + > trap_ne +2347 : d0fe > bne * ;failed not equal (non zero) + > +2349 : 68 > pla ;load status + > eor_flag $ff-fnzc +234a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +234c : dd2902 > cmp fROR,x ;test flags + > trap_ne ; +234f : d0fe > bne * ;failed not equal (non zero) + > + +2351 : ca dex +2352 : 10e8 bpl tror1 + +2354 : a203 ldx #3 +2356 : trorc + set_ax zp1,fc + > load_flag fc +2356 : a901 > lda #fc ;allow test to change I-flag (no mask) + > +2358 : 48 > pha ;use stack to load status +2359 : b513 > lda zp1,x ;precharge accu +235b : 28 > plp + +235c : 6a ror a + tst_ax rRORc,fRORc,0 +235d : 08 > php ;save flags +235e : dd1d02 > cmp rRORc,x ;test result + > trap_ne +2361 : d0fe > bne * ;failed not equal (non zero) + > +2363 : 68 > pla ;load status + > eor_flag 0 +2364 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2366 : dd2d02 > cmp fRORc,x ;test flags + > trap_ne ; +2369 : d0fe > bne * ;failed not equal (non zero) + > + +236b : ca dex +236c : 10e8 bpl trorc +236e : a203 ldx #3 +2370 : trorc1 + set_ax zp1,$ff + > load_flag $ff +2370 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2372 : 48 > pha ;use stack to load status +2373 : b513 > lda zp1,x ;precharge accu +2375 : 28 > plp + +2376 : 6a ror a + tst_ax rRORc,fRORc,$ff-fnzc +2377 : 08 > php ;save flags +2378 : dd1d02 > cmp rRORc,x ;test result + > trap_ne +237b : d0fe > bne * ;failed not equal (non zero) + > +237d : 68 > pla ;load status + > eor_flag $ff-fnzc +237e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2380 : dd2d02 > cmp fRORc,x ;test flags + > trap_ne ; +2383 : d0fe > bne * ;failed not equal (non zero) + > + +2385 : ca dex +2386 : 10e8 bpl trorc1 + next_test +2388 : ad0002 > lda test_case ;previous test +238b : c91d > cmp #test_num + > trap_ne ;test is out of sequence +238d : d0fe > bne * ;failed not equal (non zero) + > +001e = >test_num = test_num + 1 +238f : a91e > lda #test_num ;*** next tests' number +2391 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; shifts - zeropage +2394 : a203 ldx #3 +2396 : tasl2 + set_z zp1,0 + > load_flag 0 +2396 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2398 : 48 > pha ;use stack to load status +2399 : b513 > lda zp1,x ;load to zeropage +239b : 850c > sta zpt +239d : 28 > plp + +239e : 060c asl zpt + tst_z rASL,fASL,0 +23a0 : 08 > php ;save flags +23a1 : a50c > lda zpt +23a3 : dd1102 > cmp rASL,x ;test result + > trap_ne +23a6 : d0fe > bne * ;failed not equal (non zero) + > +23a8 : 68 > pla ;load status + > eor_flag 0 +23a9 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +23ab : dd2102 > cmp fASL,x ;test flags + > trap_ne +23ae : d0fe > bne * ;failed not equal (non zero) + > + +23b0 : ca dex +23b1 : 10e3 bpl tasl2 +23b3 : a203 ldx #3 +23b5 : tasl3 + set_z zp1,$ff + > load_flag $ff +23b5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +23b7 : 48 > pha ;use stack to load status +23b8 : b513 > lda zp1,x ;load to zeropage +23ba : 850c > sta zpt +23bc : 28 > plp + +23bd : 060c asl zpt + tst_z rASL,fASL,$ff-fnzc +23bf : 08 > php ;save flags +23c0 : a50c > lda zpt +23c2 : dd1102 > cmp rASL,x ;test result + > trap_ne +23c5 : d0fe > bne * ;failed not equal (non zero) + > +23c7 : 68 > pla ;load status + > eor_flag $ff-fnzc +23c8 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +23ca : dd2102 > cmp fASL,x ;test flags + > trap_ne +23cd : d0fe > bne * ;failed not equal (non zero) + > + +23cf : ca dex +23d0 : 10e3 bpl tasl3 + +23d2 : a203 ldx #3 +23d4 : tlsr2 + set_z zp1,0 + > load_flag 0 +23d4 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +23d6 : 48 > pha ;use stack to load status +23d7 : b513 > lda zp1,x ;load to zeropage +23d9 : 850c > sta zpt +23db : 28 > plp + +23dc : 460c lsr zpt + tst_z rLSR,fLSR,0 +23de : 08 > php ;save flags +23df : a50c > lda zpt +23e1 : dd1902 > cmp rLSR,x ;test result + > trap_ne +23e4 : d0fe > bne * ;failed not equal (non zero) + > +23e6 : 68 > pla ;load status + > eor_flag 0 +23e7 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +23e9 : dd2902 > cmp fLSR,x ;test flags + > trap_ne +23ec : d0fe > bne * ;failed not equal (non zero) + > + +23ee : ca dex +23ef : 10e3 bpl tlsr2 +23f1 : a203 ldx #3 +23f3 : tlsr3 + set_z zp1,$ff + > load_flag $ff +23f3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +23f5 : 48 > pha ;use stack to load status +23f6 : b513 > lda zp1,x ;load to zeropage +23f8 : 850c > sta zpt +23fa : 28 > plp + +23fb : 460c lsr zpt + tst_z rLSR,fLSR,$ff-fnzc +23fd : 08 > php ;save flags +23fe : a50c > lda zpt +2400 : dd1902 > cmp rLSR,x ;test result + > trap_ne +2403 : d0fe > bne * ;failed not equal (non zero) + > +2405 : 68 > pla ;load status + > eor_flag $ff-fnzc +2406 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2408 : dd2902 > cmp fLSR,x ;test flags + > trap_ne +240b : d0fe > bne * ;failed not equal (non zero) + > + +240d : ca dex +240e : 10e3 bpl tlsr3 + +2410 : a203 ldx #3 +2412 : trol2 + set_z zp1,0 + > load_flag 0 +2412 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2414 : 48 > pha ;use stack to load status +2415 : b513 > lda zp1,x ;load to zeropage +2417 : 850c > sta zpt +2419 : 28 > plp + +241a : 260c rol zpt + tst_z rROL,fROL,0 +241c : 08 > php ;save flags +241d : a50c > lda zpt +241f : dd1102 > cmp rROL,x ;test result + > trap_ne +2422 : d0fe > bne * ;failed not equal (non zero) + > +2424 : 68 > pla ;load status + > eor_flag 0 +2425 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2427 : dd2102 > cmp fROL,x ;test flags + > trap_ne +242a : d0fe > bne * ;failed not equal (non zero) + > + +242c : ca dex +242d : 10e3 bpl trol2 +242f : a203 ldx #3 +2431 : trol3 + set_z zp1,$ff-fc + > load_flag $ff-fc +2431 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) + > +2433 : 48 > pha ;use stack to load status +2434 : b513 > lda zp1,x ;load to zeropage +2436 : 850c > sta zpt +2438 : 28 > plp + +2439 : 260c rol zpt + tst_z rROL,fROL,$ff-fnzc +243b : 08 > php ;save flags +243c : a50c > lda zpt +243e : dd1102 > cmp rROL,x ;test result + > trap_ne +2441 : d0fe > bne * ;failed not equal (non zero) + > +2443 : 68 > pla ;load status + > eor_flag $ff-fnzc +2444 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2446 : dd2102 > cmp fROL,x ;test flags + > trap_ne +2449 : d0fe > bne * ;failed not equal (non zero) + > + +244b : ca dex +244c : 10e3 bpl trol3 + +244e : a203 ldx #3 +2450 : trolc2 + set_z zp1,fc + > load_flag fc +2450 : a901 > lda #fc ;allow test to change I-flag (no mask) + > +2452 : 48 > pha ;use stack to load status +2453 : b513 > lda zp1,x ;load to zeropage +2455 : 850c > sta zpt +2457 : 28 > plp + +2458 : 260c rol zpt + tst_z rROLc,fROLc,0 +245a : 08 > php ;save flags +245b : a50c > lda zpt +245d : dd1502 > cmp rROLc,x ;test result + > trap_ne +2460 : d0fe > bne * ;failed not equal (non zero) + > +2462 : 68 > pla ;load status + > eor_flag 0 +2463 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2465 : dd2502 > cmp fROLc,x ;test flags + > trap_ne +2468 : d0fe > bne * ;failed not equal (non zero) + > + +246a : ca dex +246b : 10e3 bpl trolc2 +246d : a203 ldx #3 +246f : trolc3 + set_z zp1,$ff + > load_flag $ff +246f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2471 : 48 > pha ;use stack to load status +2472 : b513 > lda zp1,x ;load to zeropage +2474 : 850c > sta zpt +2476 : 28 > plp + +2477 : 260c rol zpt + tst_z rROLc,fROLc,$ff-fnzc +2479 : 08 > php ;save flags +247a : a50c > lda zpt +247c : dd1502 > cmp rROLc,x ;test result + > trap_ne +247f : d0fe > bne * ;failed not equal (non zero) + > +2481 : 68 > pla ;load status + > eor_flag $ff-fnzc +2482 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2484 : dd2502 > cmp fROLc,x ;test flags + > trap_ne +2487 : d0fe > bne * ;failed not equal (non zero) + > + +2489 : ca dex +248a : 10e3 bpl trolc3 + +248c : a203 ldx #3 +248e : tror2 + set_z zp1,0 + > load_flag 0 +248e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2490 : 48 > pha ;use stack to load status +2491 : b513 > lda zp1,x ;load to zeropage +2493 : 850c > sta zpt +2495 : 28 > plp + +2496 : 660c ror zpt + tst_z rROR,fROR,0 +2498 : 08 > php ;save flags +2499 : a50c > lda zpt +249b : dd1902 > cmp rROR,x ;test result + > trap_ne +249e : d0fe > bne * ;failed not equal (non zero) + > +24a0 : 68 > pla ;load status + > eor_flag 0 +24a1 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +24a3 : dd2902 > cmp fROR,x ;test flags + > trap_ne +24a6 : d0fe > bne * ;failed not equal (non zero) + > + +24a8 : ca dex +24a9 : 10e3 bpl tror2 +24ab : a203 ldx #3 +24ad : tror3 + set_z zp1,$ff-fc + > load_flag $ff-fc +24ad : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) + > +24af : 48 > pha ;use stack to load status +24b0 : b513 > lda zp1,x ;load to zeropage +24b2 : 850c > sta zpt +24b4 : 28 > plp + +24b5 : 660c ror zpt + tst_z rROR,fROR,$ff-fnzc +24b7 : 08 > php ;save flags +24b8 : a50c > lda zpt +24ba : dd1902 > cmp rROR,x ;test result + > trap_ne +24bd : d0fe > bne * ;failed not equal (non zero) + > +24bf : 68 > pla ;load status + > eor_flag $ff-fnzc +24c0 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +24c2 : dd2902 > cmp fROR,x ;test flags + > trap_ne +24c5 : d0fe > bne * ;failed not equal (non zero) + > + +24c7 : ca dex +24c8 : 10e3 bpl tror3 + +24ca : a203 ldx #3 +24cc : trorc2 + set_z zp1,fc + > load_flag fc +24cc : a901 > lda #fc ;allow test to change I-flag (no mask) + > +24ce : 48 > pha ;use stack to load status +24cf : b513 > lda zp1,x ;load to zeropage +24d1 : 850c > sta zpt +24d3 : 28 > plp + +24d4 : 660c ror zpt + tst_z rRORc,fRORc,0 +24d6 : 08 > php ;save flags +24d7 : a50c > lda zpt +24d9 : dd1d02 > cmp rRORc,x ;test result + > trap_ne +24dc : d0fe > bne * ;failed not equal (non zero) + > +24de : 68 > pla ;load status + > eor_flag 0 +24df : 4930 > eor #0|fao ;invert expected flags + always on bits + > +24e1 : dd2d02 > cmp fRORc,x ;test flags + > trap_ne +24e4 : d0fe > bne * ;failed not equal (non zero) + > + +24e6 : ca dex +24e7 : 10e3 bpl trorc2 +24e9 : a203 ldx #3 +24eb : trorc3 + set_z zp1,$ff + > load_flag $ff +24eb : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +24ed : 48 > pha ;use stack to load status +24ee : b513 > lda zp1,x ;load to zeropage +24f0 : 850c > sta zpt +24f2 : 28 > plp + +24f3 : 660c ror zpt + tst_z rRORc,fRORc,$ff-fnzc +24f5 : 08 > php ;save flags +24f6 : a50c > lda zpt +24f8 : dd1d02 > cmp rRORc,x ;test result + > trap_ne +24fb : d0fe > bne * ;failed not equal (non zero) + > +24fd : 68 > pla ;load status + > eor_flag $ff-fnzc +24fe : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2500 : dd2d02 > cmp fRORc,x ;test flags + > trap_ne +2503 : d0fe > bne * ;failed not equal (non zero) + > + +2505 : ca dex +2506 : 10e3 bpl trorc3 + next_test +2508 : ad0002 > lda test_case ;previous test +250b : c91e > cmp #test_num + > trap_ne ;test is out of sequence +250d : d0fe > bne * ;failed not equal (non zero) + > +001f = >test_num = test_num + 1 +250f : a91f > lda #test_num ;*** next tests' number +2511 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; shifts - absolute +2514 : a203 ldx #3 +2516 : tasl4 + set_abs zp1,0 + > load_flag 0 +2516 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2518 : 48 > pha ;use stack to load status +2519 : b513 > lda zp1,x ;load to memory +251b : 8d0302 > sta abst +251e : 28 > plp + +251f : 0e0302 asl abst + tst_abs rASL,fASL,0 +2522 : 08 > php ;save flags +2523 : ad0302 > lda abst +2526 : dd1102 > cmp rASL,x ;test result + > trap_ne +2529 : d0fe > bne * ;failed not equal (non zero) + > +252b : 68 > pla ;load status + > eor_flag 0 +252c : 4930 > eor #0|fao ;invert expected flags + always on bits + > +252e : dd2102 > cmp fASL,x ;test flags + > trap_ne +2531 : d0fe > bne * ;failed not equal (non zero) + > + +2533 : ca dex +2534 : 10e0 bpl tasl4 +2536 : a203 ldx #3 +2538 : tasl5 + set_abs zp1,$ff + > load_flag $ff +2538 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +253a : 48 > pha ;use stack to load status +253b : b513 > lda zp1,x ;load to memory +253d : 8d0302 > sta abst +2540 : 28 > plp + +2541 : 0e0302 asl abst + tst_abs rASL,fASL,$ff-fnzc +2544 : 08 > php ;save flags +2545 : ad0302 > lda abst +2548 : dd1102 > cmp rASL,x ;test result + > trap_ne +254b : d0fe > bne * ;failed not equal (non zero) + > +254d : 68 > pla ;load status + > eor_flag $ff-fnzc +254e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2550 : dd2102 > cmp fASL,x ;test flags + > trap_ne +2553 : d0fe > bne * ;failed not equal (non zero) + > + +2555 : ca dex +2556 : 10e0 bpl tasl5 + +2558 : a203 ldx #3 +255a : tlsr4 + set_abs zp1,0 + > load_flag 0 +255a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +255c : 48 > pha ;use stack to load status +255d : b513 > lda zp1,x ;load to memory +255f : 8d0302 > sta abst +2562 : 28 > plp + +2563 : 4e0302 lsr abst + tst_abs rLSR,fLSR,0 +2566 : 08 > php ;save flags +2567 : ad0302 > lda abst +256a : dd1902 > cmp rLSR,x ;test result + > trap_ne +256d : d0fe > bne * ;failed not equal (non zero) + > +256f : 68 > pla ;load status + > eor_flag 0 +2570 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2572 : dd2902 > cmp fLSR,x ;test flags + > trap_ne +2575 : d0fe > bne * ;failed not equal (non zero) + > + +2577 : ca dex +2578 : 10e0 bpl tlsr4 +257a : a203 ldx #3 +257c : tlsr5 + set_abs zp1,$ff + > load_flag $ff +257c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +257e : 48 > pha ;use stack to load status +257f : b513 > lda zp1,x ;load to memory +2581 : 8d0302 > sta abst +2584 : 28 > plp + +2585 : 4e0302 lsr abst + tst_abs rLSR,fLSR,$ff-fnzc +2588 : 08 > php ;save flags +2589 : ad0302 > lda abst +258c : dd1902 > cmp rLSR,x ;test result + > trap_ne +258f : d0fe > bne * ;failed not equal (non zero) + > +2591 : 68 > pla ;load status + > eor_flag $ff-fnzc +2592 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2594 : dd2902 > cmp fLSR,x ;test flags + > trap_ne +2597 : d0fe > bne * ;failed not equal (non zero) + > + +2599 : ca dex +259a : 10e0 bpl tlsr5 + +259c : a203 ldx #3 +259e : trol4 + set_abs zp1,0 + > load_flag 0 +259e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +25a0 : 48 > pha ;use stack to load status +25a1 : b513 > lda zp1,x ;load to memory +25a3 : 8d0302 > sta abst +25a6 : 28 > plp + +25a7 : 2e0302 rol abst + tst_abs rROL,fROL,0 +25aa : 08 > php ;save flags +25ab : ad0302 > lda abst +25ae : dd1102 > cmp rROL,x ;test result + > trap_ne +25b1 : d0fe > bne * ;failed not equal (non zero) + > +25b3 : 68 > pla ;load status + > eor_flag 0 +25b4 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +25b6 : dd2102 > cmp fROL,x ;test flags + > trap_ne +25b9 : d0fe > bne * ;failed not equal (non zero) + > + +25bb : ca dex +25bc : 10e0 bpl trol4 +25be : a203 ldx #3 +25c0 : trol5 + set_abs zp1,$ff-fc + > load_flag $ff-fc +25c0 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) + > +25c2 : 48 > pha ;use stack to load status +25c3 : b513 > lda zp1,x ;load to memory +25c5 : 8d0302 > sta abst +25c8 : 28 > plp + +25c9 : 2e0302 rol abst + tst_abs rROL,fROL,$ff-fnzc +25cc : 08 > php ;save flags +25cd : ad0302 > lda abst +25d0 : dd1102 > cmp rROL,x ;test result + > trap_ne +25d3 : d0fe > bne * ;failed not equal (non zero) + > +25d5 : 68 > pla ;load status + > eor_flag $ff-fnzc +25d6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +25d8 : dd2102 > cmp fROL,x ;test flags + > trap_ne +25db : d0fe > bne * ;failed not equal (non zero) + > + +25dd : ca dex +25de : 10e0 bpl trol5 + +25e0 : a203 ldx #3 +25e2 : trolc4 + set_abs zp1,fc + > load_flag fc +25e2 : a901 > lda #fc ;allow test to change I-flag (no mask) + > +25e4 : 48 > pha ;use stack to load status +25e5 : b513 > lda zp1,x ;load to memory +25e7 : 8d0302 > sta abst +25ea : 28 > plp + +25eb : 2e0302 rol abst + tst_abs rROLc,fROLc,0 +25ee : 08 > php ;save flags +25ef : ad0302 > lda abst +25f2 : dd1502 > cmp rROLc,x ;test result + > trap_ne +25f5 : d0fe > bne * ;failed not equal (non zero) + > +25f7 : 68 > pla ;load status + > eor_flag 0 +25f8 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +25fa : dd2502 > cmp fROLc,x ;test flags + > trap_ne +25fd : d0fe > bne * ;failed not equal (non zero) + > + +25ff : ca dex +2600 : 10e0 bpl trolc4 +2602 : a203 ldx #3 +2604 : trolc5 + set_abs zp1,$ff + > load_flag $ff +2604 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2606 : 48 > pha ;use stack to load status +2607 : b513 > lda zp1,x ;load to memory +2609 : 8d0302 > sta abst +260c : 28 > plp + +260d : 2e0302 rol abst + tst_abs rROLc,fROLc,$ff-fnzc +2610 : 08 > php ;save flags +2611 : ad0302 > lda abst +2614 : dd1502 > cmp rROLc,x ;test result + > trap_ne +2617 : d0fe > bne * ;failed not equal (non zero) + > +2619 : 68 > pla ;load status + > eor_flag $ff-fnzc +261a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +261c : dd2502 > cmp fROLc,x ;test flags + > trap_ne +261f : d0fe > bne * ;failed not equal (non zero) + > + +2621 : ca dex +2622 : 10e0 bpl trolc5 + +2624 : a203 ldx #3 +2626 : tror4 + set_abs zp1,0 + > load_flag 0 +2626 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2628 : 48 > pha ;use stack to load status +2629 : b513 > lda zp1,x ;load to memory +262b : 8d0302 > sta abst +262e : 28 > plp + +262f : 6e0302 ror abst + tst_abs rROR,fROR,0 +2632 : 08 > php ;save flags +2633 : ad0302 > lda abst +2636 : dd1902 > cmp rROR,x ;test result + > trap_ne +2639 : d0fe > bne * ;failed not equal (non zero) + > +263b : 68 > pla ;load status + > eor_flag 0 +263c : 4930 > eor #0|fao ;invert expected flags + always on bits + > +263e : dd2902 > cmp fROR,x ;test flags + > trap_ne +2641 : d0fe > bne * ;failed not equal (non zero) + > + +2643 : ca dex +2644 : 10e0 bpl tror4 +2646 : a203 ldx #3 +2648 : tror5 + set_abs zp1,$ff-fc + > load_flag $ff-fc +2648 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) + > +264a : 48 > pha ;use stack to load status +264b : b513 > lda zp1,x ;load to memory +264d : 8d0302 > sta abst +2650 : 28 > plp + +2651 : 6e0302 ror abst + tst_abs rROR,fROR,$ff-fnzc +2654 : 08 > php ;save flags +2655 : ad0302 > lda abst +2658 : dd1902 > cmp rROR,x ;test result + > trap_ne +265b : d0fe > bne * ;failed not equal (non zero) + > +265d : 68 > pla ;load status + > eor_flag $ff-fnzc +265e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2660 : dd2902 > cmp fROR,x ;test flags + > trap_ne +2663 : d0fe > bne * ;failed not equal (non zero) + > + +2665 : ca dex +2666 : 10e0 bpl tror5 + +2668 : a203 ldx #3 +266a : trorc4 + set_abs zp1,fc + > load_flag fc +266a : a901 > lda #fc ;allow test to change I-flag (no mask) + > +266c : 48 > pha ;use stack to load status +266d : b513 > lda zp1,x ;load to memory +266f : 8d0302 > sta abst +2672 : 28 > plp + +2673 : 6e0302 ror abst + tst_abs rRORc,fRORc,0 +2676 : 08 > php ;save flags +2677 : ad0302 > lda abst +267a : dd1d02 > cmp rRORc,x ;test result + > trap_ne +267d : d0fe > bne * ;failed not equal (non zero) + > +267f : 68 > pla ;load status + > eor_flag 0 +2680 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2682 : dd2d02 > cmp fRORc,x ;test flags + > trap_ne +2685 : d0fe > bne * ;failed not equal (non zero) + > + +2687 : ca dex +2688 : 10e0 bpl trorc4 +268a : a203 ldx #3 +268c : trorc5 + set_abs zp1,$ff + > load_flag $ff +268c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +268e : 48 > pha ;use stack to load status +268f : b513 > lda zp1,x ;load to memory +2691 : 8d0302 > sta abst +2694 : 28 > plp + +2695 : 6e0302 ror abst + tst_abs rRORc,fRORc,$ff-fnzc +2698 : 08 > php ;save flags +2699 : ad0302 > lda abst +269c : dd1d02 > cmp rRORc,x ;test result + > trap_ne +269f : d0fe > bne * ;failed not equal (non zero) + > +26a1 : 68 > pla ;load status + > eor_flag $ff-fnzc +26a2 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +26a4 : dd2d02 > cmp fRORc,x ;test flags + > trap_ne +26a7 : d0fe > bne * ;failed not equal (non zero) + > + +26a9 : ca dex +26aa : 10e0 bpl trorc5 + next_test +26ac : ad0002 > lda test_case ;previous test +26af : c91f > cmp #test_num + > trap_ne ;test is out of sequence +26b1 : d0fe > bne * ;failed not equal (non zero) + > +0020 = >test_num = test_num + 1 +26b3 : a920 > lda #test_num ;*** next tests' number +26b5 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; shifts - zp indexed +26b8 : a203 ldx #3 +26ba : tasl6 + set_zx zp1,0 + > load_flag 0 +26ba : a900 > lda #0 ;allow test to change I-flag (no mask) + > +26bc : 48 > pha ;use stack to load status +26bd : b513 > lda zp1,x ;load to indexed zeropage +26bf : 950c > sta zpt,x +26c1 : 28 > plp + +26c2 : 160c asl zpt,x + tst_zx rASL,fASL,0 +26c4 : 08 > php ;save flags +26c5 : b50c > lda zpt,x +26c7 : dd1102 > cmp rASL,x ;test result + > trap_ne +26ca : d0fe > bne * ;failed not equal (non zero) + > +26cc : 68 > pla ;load status + > eor_flag 0 +26cd : 4930 > eor #0|fao ;invert expected flags + always on bits + > +26cf : dd2102 > cmp fASL,x ;test flags + > trap_ne +26d2 : d0fe > bne * ;failed not equal (non zero) + > + +26d4 : ca dex +26d5 : 10e3 bpl tasl6 +26d7 : a203 ldx #3 +26d9 : tasl7 + set_zx zp1,$ff + > load_flag $ff +26d9 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +26db : 48 > pha ;use stack to load status +26dc : b513 > lda zp1,x ;load to indexed zeropage +26de : 950c > sta zpt,x +26e0 : 28 > plp + +26e1 : 160c asl zpt,x + tst_zx rASL,fASL,$ff-fnzc +26e3 : 08 > php ;save flags +26e4 : b50c > lda zpt,x +26e6 : dd1102 > cmp rASL,x ;test result + > trap_ne +26e9 : d0fe > bne * ;failed not equal (non zero) + > +26eb : 68 > pla ;load status + > eor_flag $ff-fnzc +26ec : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +26ee : dd2102 > cmp fASL,x ;test flags + > trap_ne +26f1 : d0fe > bne * ;failed not equal (non zero) + > + +26f3 : ca dex +26f4 : 10e3 bpl tasl7 + +26f6 : a203 ldx #3 +26f8 : tlsr6 + set_zx zp1,0 + > load_flag 0 +26f8 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +26fa : 48 > pha ;use stack to load status +26fb : b513 > lda zp1,x ;load to indexed zeropage +26fd : 950c > sta zpt,x +26ff : 28 > plp + +2700 : 560c lsr zpt,x + tst_zx rLSR,fLSR,0 +2702 : 08 > php ;save flags +2703 : b50c > lda zpt,x +2705 : dd1902 > cmp rLSR,x ;test result + > trap_ne +2708 : d0fe > bne * ;failed not equal (non zero) + > +270a : 68 > pla ;load status + > eor_flag 0 +270b : 4930 > eor #0|fao ;invert expected flags + always on bits + > +270d : dd2902 > cmp fLSR,x ;test flags + > trap_ne +2710 : d0fe > bne * ;failed not equal (non zero) + > + +2712 : ca dex +2713 : 10e3 bpl tlsr6 +2715 : a203 ldx #3 +2717 : tlsr7 + set_zx zp1,$ff + > load_flag $ff +2717 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2719 : 48 > pha ;use stack to load status +271a : b513 > lda zp1,x ;load to indexed zeropage +271c : 950c > sta zpt,x +271e : 28 > plp + +271f : 560c lsr zpt,x + tst_zx rLSR,fLSR,$ff-fnzc +2721 : 08 > php ;save flags +2722 : b50c > lda zpt,x +2724 : dd1902 > cmp rLSR,x ;test result + > trap_ne +2727 : d0fe > bne * ;failed not equal (non zero) + > +2729 : 68 > pla ;load status + > eor_flag $ff-fnzc +272a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +272c : dd2902 > cmp fLSR,x ;test flags + > trap_ne +272f : d0fe > bne * ;failed not equal (non zero) + > + +2731 : ca dex +2732 : 10e3 bpl tlsr7 + +2734 : a203 ldx #3 +2736 : trol6 + set_zx zp1,0 + > load_flag 0 +2736 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2738 : 48 > pha ;use stack to load status +2739 : b513 > lda zp1,x ;load to indexed zeropage +273b : 950c > sta zpt,x +273d : 28 > plp + +273e : 360c rol zpt,x + tst_zx rROL,fROL,0 +2740 : 08 > php ;save flags +2741 : b50c > lda zpt,x +2743 : dd1102 > cmp rROL,x ;test result + > trap_ne +2746 : d0fe > bne * ;failed not equal (non zero) + > +2748 : 68 > pla ;load status + > eor_flag 0 +2749 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +274b : dd2102 > cmp fROL,x ;test flags + > trap_ne +274e : d0fe > bne * ;failed not equal (non zero) + > + +2750 : ca dex +2751 : 10e3 bpl trol6 +2753 : a203 ldx #3 +2755 : trol7 + set_zx zp1,$ff-fc + > load_flag $ff-fc +2755 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) + > +2757 : 48 > pha ;use stack to load status +2758 : b513 > lda zp1,x ;load to indexed zeropage +275a : 950c > sta zpt,x +275c : 28 > plp + +275d : 360c rol zpt,x + tst_zx rROL,fROL,$ff-fnzc +275f : 08 > php ;save flags +2760 : b50c > lda zpt,x +2762 : dd1102 > cmp rROL,x ;test result + > trap_ne +2765 : d0fe > bne * ;failed not equal (non zero) + > +2767 : 68 > pla ;load status + > eor_flag $ff-fnzc +2768 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +276a : dd2102 > cmp fROL,x ;test flags + > trap_ne +276d : d0fe > bne * ;failed not equal (non zero) + > + +276f : ca dex +2770 : 10e3 bpl trol7 + +2772 : a203 ldx #3 +2774 : trolc6 + set_zx zp1,fc + > load_flag fc +2774 : a901 > lda #fc ;allow test to change I-flag (no mask) + > +2776 : 48 > pha ;use stack to load status +2777 : b513 > lda zp1,x ;load to indexed zeropage +2779 : 950c > sta zpt,x +277b : 28 > plp + +277c : 360c rol zpt,x + tst_zx rROLc,fROLc,0 +277e : 08 > php ;save flags +277f : b50c > lda zpt,x +2781 : dd1502 > cmp rROLc,x ;test result + > trap_ne +2784 : d0fe > bne * ;failed not equal (non zero) + > +2786 : 68 > pla ;load status + > eor_flag 0 +2787 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2789 : dd2502 > cmp fROLc,x ;test flags + > trap_ne +278c : d0fe > bne * ;failed not equal (non zero) + > + +278e : ca dex +278f : 10e3 bpl trolc6 +2791 : a203 ldx #3 +2793 : trolc7 + set_zx zp1,$ff + > load_flag $ff +2793 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2795 : 48 > pha ;use stack to load status +2796 : b513 > lda zp1,x ;load to indexed zeropage +2798 : 950c > sta zpt,x +279a : 28 > plp + +279b : 360c rol zpt,x + tst_zx rROLc,fROLc,$ff-fnzc +279d : 08 > php ;save flags +279e : b50c > lda zpt,x +27a0 : dd1502 > cmp rROLc,x ;test result + > trap_ne +27a3 : d0fe > bne * ;failed not equal (non zero) + > +27a5 : 68 > pla ;load status + > eor_flag $ff-fnzc +27a6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +27a8 : dd2502 > cmp fROLc,x ;test flags + > trap_ne +27ab : d0fe > bne * ;failed not equal (non zero) + > + +27ad : ca dex +27ae : 10e3 bpl trolc7 + +27b0 : a203 ldx #3 +27b2 : tror6 + set_zx zp1,0 + > load_flag 0 +27b2 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +27b4 : 48 > pha ;use stack to load status +27b5 : b513 > lda zp1,x ;load to indexed zeropage +27b7 : 950c > sta zpt,x +27b9 : 28 > plp + +27ba : 760c ror zpt,x + tst_zx rROR,fROR,0 +27bc : 08 > php ;save flags +27bd : b50c > lda zpt,x +27bf : dd1902 > cmp rROR,x ;test result + > trap_ne +27c2 : d0fe > bne * ;failed not equal (non zero) + > +27c4 : 68 > pla ;load status + > eor_flag 0 +27c5 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +27c7 : dd2902 > cmp fROR,x ;test flags + > trap_ne +27ca : d0fe > bne * ;failed not equal (non zero) + > + +27cc : ca dex +27cd : 10e3 bpl tror6 +27cf : a203 ldx #3 +27d1 : tror7 + set_zx zp1,$ff-fc + > load_flag $ff-fc +27d1 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) + > +27d3 : 48 > pha ;use stack to load status +27d4 : b513 > lda zp1,x ;load to indexed zeropage +27d6 : 950c > sta zpt,x +27d8 : 28 > plp + +27d9 : 760c ror zpt,x + tst_zx rROR,fROR,$ff-fnzc +27db : 08 > php ;save flags +27dc : b50c > lda zpt,x +27de : dd1902 > cmp rROR,x ;test result + > trap_ne +27e1 : d0fe > bne * ;failed not equal (non zero) + > +27e3 : 68 > pla ;load status + > eor_flag $ff-fnzc +27e4 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +27e6 : dd2902 > cmp fROR,x ;test flags + > trap_ne +27e9 : d0fe > bne * ;failed not equal (non zero) + > + +27eb : ca dex +27ec : 10e3 bpl tror7 + +27ee : a203 ldx #3 +27f0 : trorc6 + set_zx zp1,fc + > load_flag fc +27f0 : a901 > lda #fc ;allow test to change I-flag (no mask) + > +27f2 : 48 > pha ;use stack to load status +27f3 : b513 > lda zp1,x ;load to indexed zeropage +27f5 : 950c > sta zpt,x +27f7 : 28 > plp + +27f8 : 760c ror zpt,x + tst_zx rRORc,fRORc,0 +27fa : 08 > php ;save flags +27fb : b50c > lda zpt,x +27fd : dd1d02 > cmp rRORc,x ;test result + > trap_ne +2800 : d0fe > bne * ;failed not equal (non zero) + > +2802 : 68 > pla ;load status + > eor_flag 0 +2803 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2805 : dd2d02 > cmp fRORc,x ;test flags + > trap_ne +2808 : d0fe > bne * ;failed not equal (non zero) + > + +280a : ca dex +280b : 10e3 bpl trorc6 +280d : a203 ldx #3 +280f : trorc7 + set_zx zp1,$ff + > load_flag $ff +280f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2811 : 48 > pha ;use stack to load status +2812 : b513 > lda zp1,x ;load to indexed zeropage +2814 : 950c > sta zpt,x +2816 : 28 > plp + +2817 : 760c ror zpt,x + tst_zx rRORc,fRORc,$ff-fnzc +2819 : 08 > php ;save flags +281a : b50c > lda zpt,x +281c : dd1d02 > cmp rRORc,x ;test result + > trap_ne +281f : d0fe > bne * ;failed not equal (non zero) + > +2821 : 68 > pla ;load status + > eor_flag $ff-fnzc +2822 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2824 : dd2d02 > cmp fRORc,x ;test flags + > trap_ne +2827 : d0fe > bne * ;failed not equal (non zero) + > + +2829 : ca dex +282a : 10e3 bpl trorc7 + next_test +282c : ad0002 > lda test_case ;previous test +282f : c920 > cmp #test_num + > trap_ne ;test is out of sequence +2831 : d0fe > bne * ;failed not equal (non zero) + > +0021 = >test_num = test_num + 1 +2833 : a921 > lda #test_num ;*** next tests' number +2835 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; shifts - abs indexed +2838 : a203 ldx #3 +283a : tasl8 + set_absx zp1,0 + > load_flag 0 +283a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +283c : 48 > pha ;use stack to load status +283d : b513 > lda zp1,x ;load to indexed memory +283f : 9d0302 > sta abst,x +2842 : 28 > plp + +2843 : 1e0302 asl abst,x + tst_absx rASL,fASL,0 +2846 : 08 > php ;save flags +2847 : bd0302 > lda abst,x +284a : dd1102 > cmp rASL,x ;test result + > trap_ne +284d : d0fe > bne * ;failed not equal (non zero) + > +284f : 68 > pla ;load status + > eor_flag 0 +2850 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2852 : dd2102 > cmp fASL,x ;test flags + > trap_ne +2855 : d0fe > bne * ;failed not equal (non zero) + > + +2857 : ca dex +2858 : 10e0 bpl tasl8 +285a : a203 ldx #3 +285c : tasl9 + set_absx zp1,$ff + > load_flag $ff +285c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +285e : 48 > pha ;use stack to load status +285f : b513 > lda zp1,x ;load to indexed memory +2861 : 9d0302 > sta abst,x +2864 : 28 > plp + +2865 : 1e0302 asl abst,x + tst_absx rASL,fASL,$ff-fnzc +2868 : 08 > php ;save flags +2869 : bd0302 > lda abst,x +286c : dd1102 > cmp rASL,x ;test result + > trap_ne +286f : d0fe > bne * ;failed not equal (non zero) + > +2871 : 68 > pla ;load status + > eor_flag $ff-fnzc +2872 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2874 : dd2102 > cmp fASL,x ;test flags + > trap_ne +2877 : d0fe > bne * ;failed not equal (non zero) + > + +2879 : ca dex +287a : 10e0 bpl tasl9 + +287c : a203 ldx #3 +287e : tlsr8 + set_absx zp1,0 + > load_flag 0 +287e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2880 : 48 > pha ;use stack to load status +2881 : b513 > lda zp1,x ;load to indexed memory +2883 : 9d0302 > sta abst,x +2886 : 28 > plp + +2887 : 5e0302 lsr abst,x + tst_absx rLSR,fLSR,0 +288a : 08 > php ;save flags +288b : bd0302 > lda abst,x +288e : dd1902 > cmp rLSR,x ;test result + > trap_ne +2891 : d0fe > bne * ;failed not equal (non zero) + > +2893 : 68 > pla ;load status + > eor_flag 0 +2894 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2896 : dd2902 > cmp fLSR,x ;test flags + > trap_ne +2899 : d0fe > bne * ;failed not equal (non zero) + > + +289b : ca dex +289c : 10e0 bpl tlsr8 +289e : a203 ldx #3 +28a0 : tlsr9 + set_absx zp1,$ff + > load_flag $ff +28a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +28a2 : 48 > pha ;use stack to load status +28a3 : b513 > lda zp1,x ;load to indexed memory +28a5 : 9d0302 > sta abst,x +28a8 : 28 > plp + +28a9 : 5e0302 lsr abst,x + tst_absx rLSR,fLSR,$ff-fnzc +28ac : 08 > php ;save flags +28ad : bd0302 > lda abst,x +28b0 : dd1902 > cmp rLSR,x ;test result + > trap_ne +28b3 : d0fe > bne * ;failed not equal (non zero) + > +28b5 : 68 > pla ;load status + > eor_flag $ff-fnzc +28b6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +28b8 : dd2902 > cmp fLSR,x ;test flags + > trap_ne +28bb : d0fe > bne * ;failed not equal (non zero) + > + +28bd : ca dex +28be : 10e0 bpl tlsr9 + +28c0 : a203 ldx #3 +28c2 : trol8 + set_absx zp1,0 + > load_flag 0 +28c2 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +28c4 : 48 > pha ;use stack to load status +28c5 : b513 > lda zp1,x ;load to indexed memory +28c7 : 9d0302 > sta abst,x +28ca : 28 > plp + +28cb : 3e0302 rol abst,x + tst_absx rROL,fROL,0 +28ce : 08 > php ;save flags +28cf : bd0302 > lda abst,x +28d2 : dd1102 > cmp rROL,x ;test result + > trap_ne +28d5 : d0fe > bne * ;failed not equal (non zero) + > +28d7 : 68 > pla ;load status + > eor_flag 0 +28d8 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +28da : dd2102 > cmp fROL,x ;test flags + > trap_ne +28dd : d0fe > bne * ;failed not equal (non zero) + > + +28df : ca dex +28e0 : 10e0 bpl trol8 +28e2 : a203 ldx #3 +28e4 : trol9 + set_absx zp1,$ff-fc + > load_flag $ff-fc +28e4 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) + > +28e6 : 48 > pha ;use stack to load status +28e7 : b513 > lda zp1,x ;load to indexed memory +28e9 : 9d0302 > sta abst,x +28ec : 28 > plp + +28ed : 3e0302 rol abst,x + tst_absx rROL,fROL,$ff-fnzc +28f0 : 08 > php ;save flags +28f1 : bd0302 > lda abst,x +28f4 : dd1102 > cmp rROL,x ;test result + > trap_ne +28f7 : d0fe > bne * ;failed not equal (non zero) + > +28f9 : 68 > pla ;load status + > eor_flag $ff-fnzc +28fa : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +28fc : dd2102 > cmp fROL,x ;test flags + > trap_ne +28ff : d0fe > bne * ;failed not equal (non zero) + > + +2901 : ca dex +2902 : 10e0 bpl trol9 + +2904 : a203 ldx #3 +2906 : trolc8 + set_absx zp1,fc + > load_flag fc +2906 : a901 > lda #fc ;allow test to change I-flag (no mask) + > +2908 : 48 > pha ;use stack to load status +2909 : b513 > lda zp1,x ;load to indexed memory +290b : 9d0302 > sta abst,x +290e : 28 > plp + +290f : 3e0302 rol abst,x + tst_absx rROLc,fROLc,0 +2912 : 08 > php ;save flags +2913 : bd0302 > lda abst,x +2916 : dd1502 > cmp rROLc,x ;test result + > trap_ne +2919 : d0fe > bne * ;failed not equal (non zero) + > +291b : 68 > pla ;load status + > eor_flag 0 +291c : 4930 > eor #0|fao ;invert expected flags + always on bits + > +291e : dd2502 > cmp fROLc,x ;test flags + > trap_ne +2921 : d0fe > bne * ;failed not equal (non zero) + > + +2923 : ca dex +2924 : 10e0 bpl trolc8 +2926 : a203 ldx #3 +2928 : trolc9 + set_absx zp1,$ff + > load_flag $ff +2928 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +292a : 48 > pha ;use stack to load status +292b : b513 > lda zp1,x ;load to indexed memory +292d : 9d0302 > sta abst,x +2930 : 28 > plp + +2931 : 3e0302 rol abst,x + tst_absx rROLc,fROLc,$ff-fnzc +2934 : 08 > php ;save flags +2935 : bd0302 > lda abst,x +2938 : dd1502 > cmp rROLc,x ;test result + > trap_ne +293b : d0fe > bne * ;failed not equal (non zero) + > +293d : 68 > pla ;load status + > eor_flag $ff-fnzc +293e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2940 : dd2502 > cmp fROLc,x ;test flags + > trap_ne +2943 : d0fe > bne * ;failed not equal (non zero) + > + +2945 : ca dex +2946 : 10e0 bpl trolc9 + +2948 : a203 ldx #3 +294a : tror8 + set_absx zp1,0 + > load_flag 0 +294a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +294c : 48 > pha ;use stack to load status +294d : b513 > lda zp1,x ;load to indexed memory +294f : 9d0302 > sta abst,x +2952 : 28 > plp + +2953 : 7e0302 ror abst,x + tst_absx rROR,fROR,0 +2956 : 08 > php ;save flags +2957 : bd0302 > lda abst,x +295a : dd1902 > cmp rROR,x ;test result + > trap_ne +295d : d0fe > bne * ;failed not equal (non zero) + > +295f : 68 > pla ;load status + > eor_flag 0 +2960 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2962 : dd2902 > cmp fROR,x ;test flags + > trap_ne +2965 : d0fe > bne * ;failed not equal (non zero) + > + +2967 : ca dex +2968 : 10e0 bpl tror8 +296a : a203 ldx #3 +296c : tror9 + set_absx zp1,$ff-fc + > load_flag $ff-fc +296c : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask) + > +296e : 48 > pha ;use stack to load status +296f : b513 > lda zp1,x ;load to indexed memory +2971 : 9d0302 > sta abst,x +2974 : 28 > plp + +2975 : 7e0302 ror abst,x + tst_absx rROR,fROR,$ff-fnzc +2978 : 08 > php ;save flags +2979 : bd0302 > lda abst,x +297c : dd1902 > cmp rROR,x ;test result + > trap_ne +297f : d0fe > bne * ;failed not equal (non zero) + > +2981 : 68 > pla ;load status + > eor_flag $ff-fnzc +2982 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +2984 : dd2902 > cmp fROR,x ;test flags + > trap_ne +2987 : d0fe > bne * ;failed not equal (non zero) + > + +2989 : ca dex +298a : 10e0 bpl tror9 + +298c : a203 ldx #3 +298e : trorc8 + set_absx zp1,fc + > load_flag fc +298e : a901 > lda #fc ;allow test to change I-flag (no mask) + > +2990 : 48 > pha ;use stack to load status +2991 : b513 > lda zp1,x ;load to indexed memory +2993 : 9d0302 > sta abst,x +2996 : 28 > plp + +2997 : 7e0302 ror abst,x + tst_absx rRORc,fRORc,0 +299a : 08 > php ;save flags +299b : bd0302 > lda abst,x +299e : dd1d02 > cmp rRORc,x ;test result + > trap_ne +29a1 : d0fe > bne * ;failed not equal (non zero) + > +29a3 : 68 > pla ;load status + > eor_flag 0 +29a4 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +29a6 : dd2d02 > cmp fRORc,x ;test flags + > trap_ne +29a9 : d0fe > bne * ;failed not equal (non zero) + > + +29ab : ca dex +29ac : 10e0 bpl trorc8 +29ae : a203 ldx #3 +29b0 : trorc9 + set_absx zp1,$ff + > load_flag $ff +29b0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +29b2 : 48 > pha ;use stack to load status +29b3 : b513 > lda zp1,x ;load to indexed memory +29b5 : 9d0302 > sta abst,x +29b8 : 28 > plp + +29b9 : 7e0302 ror abst,x + tst_absx rRORc,fRORc,$ff-fnzc +29bc : 08 > php ;save flags +29bd : bd0302 > lda abst,x +29c0 : dd1d02 > cmp rRORc,x ;test result + > trap_ne +29c3 : d0fe > bne * ;failed not equal (non zero) + > +29c5 : 68 > pla ;load status + > eor_flag $ff-fnzc +29c6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits + > +29c8 : dd2d02 > cmp fRORc,x ;test flags + > trap_ne +29cb : d0fe > bne * ;failed not equal (non zero) + > + +29cd : ca dex +29ce : 10e0 bpl trorc9 + next_test +29d0 : ad0002 > lda test_case ;previous test +29d3 : c921 > cmp #test_num + > trap_ne ;test is out of sequence +29d5 : d0fe > bne * ;failed not equal (non zero) + > +0022 = >test_num = test_num + 1 +29d7 : a922 > lda #test_num ;*** next tests' number +29d9 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; testing memory increment/decrement - INC DEC all addressing modes + ; zeropage +29dc : a200 ldx #0 +29de : a97e lda #$7e +29e0 : 850c sta zpt +29e2 : tinc + set_stat 0 + > load_flag 0 +29e2 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +29e4 : 48 > pha ;use stack to load status +29e5 : 28 > plp + +29e6 : e60c inc zpt + tst_z rINC,fINC,0 +29e8 : 08 > php ;save flags +29e9 : a50c > lda zpt +29eb : dd3102 > cmp rINC,x ;test result + > trap_ne +29ee : d0fe > bne * ;failed not equal (non zero) + > +29f0 : 68 > pla ;load status + > eor_flag 0 +29f1 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +29f3 : dd3602 > cmp fINC,x ;test flags + > trap_ne +29f6 : d0fe > bne * ;failed not equal (non zero) + > + +29f8 : e8 inx +29f9 : e002 cpx #2 +29fb : d004 bne tinc1 +29fd : a9fe lda #$fe +29ff : 850c sta zpt +2a01 : e005 tinc1 cpx #5 +2a03 : d0dd bne tinc +2a05 : ca dex +2a06 : e60c inc zpt +2a08 : tdec + set_stat 0 + > load_flag 0 +2a08 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2a0a : 48 > pha ;use stack to load status +2a0b : 28 > plp + +2a0c : c60c dec zpt + tst_z rINC,fINC,0 +2a0e : 08 > php ;save flags +2a0f : a50c > lda zpt +2a11 : dd3102 > cmp rINC,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 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2a1c : d0fe > bne * ;failed not equal (non zero) + > + +2a1e : ca dex +2a1f : 300a bmi tdec1 +2a21 : e001 cpx #1 +2a23 : d0e3 bne tdec +2a25 : a981 lda #$81 +2a27 : 850c sta zpt +2a29 : d0dd bne tdec +2a2b : tdec1 +2a2b : a200 ldx #0 +2a2d : a97e lda #$7e +2a2f : 850c sta zpt +2a31 : tinc10 + set_stat $ff + > load_flag $ff +2a31 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2a33 : 48 > pha ;use stack to load status +2a34 : 28 > plp + +2a35 : e60c inc zpt + tst_z rINC,fINC,$ff-fnz +2a37 : 08 > php ;save flags +2a38 : a50c > lda zpt +2a3a : dd3102 > cmp rINC,x ;test result + > trap_ne +2a3d : d0fe > bne * ;failed not equal (non zero) + > +2a3f : 68 > pla ;load status + > eor_flag $ff-fnz +2a40 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2a42 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2a45 : d0fe > bne * ;failed not equal (non zero) + > + +2a47 : e8 inx +2a48 : e002 cpx #2 +2a4a : d004 bne tinc11 +2a4c : a9fe lda #$fe +2a4e : 850c sta zpt +2a50 : e005 tinc11 cpx #5 +2a52 : d0dd bne tinc10 +2a54 : ca dex +2a55 : e60c inc zpt +2a57 : tdec10 + set_stat $ff + > load_flag $ff +2a57 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2a59 : 48 > pha ;use stack to load status +2a5a : 28 > plp + +2a5b : c60c dec zpt + tst_z rINC,fINC,$ff-fnz +2a5d : 08 > php ;save flags +2a5e : a50c > lda zpt +2a60 : dd3102 > cmp rINC,x ;test result + > trap_ne +2a63 : d0fe > bne * ;failed not equal (non zero) + > +2a65 : 68 > pla ;load status + > eor_flag $ff-fnz +2a66 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2a68 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2a6b : d0fe > bne * ;failed not equal (non zero) + > + +2a6d : ca dex +2a6e : 300a bmi tdec11 +2a70 : e001 cpx #1 +2a72 : d0e3 bne tdec10 +2a74 : a981 lda #$81 +2a76 : 850c sta zpt +2a78 : d0dd bne tdec10 +2a7a : tdec11 + next_test +2a7a : ad0002 > lda test_case ;previous test +2a7d : c922 > cmp #test_num + > trap_ne ;test is out of sequence +2a7f : d0fe > bne * ;failed not equal (non zero) + > +0023 = >test_num = test_num + 1 +2a81 : a923 > lda #test_num ;*** next tests' number +2a83 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; absolute memory +2a86 : a200 ldx #0 +2a88 : a97e lda #$7e +2a8a : 8d0302 sta abst +2a8d : tinc2 + set_stat 0 + > load_flag 0 +2a8d : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2a8f : 48 > pha ;use stack to load status +2a90 : 28 > plp + +2a91 : ee0302 inc abst + tst_abs rINC,fINC,0 +2a94 : 08 > php ;save flags +2a95 : ad0302 > lda abst +2a98 : dd3102 > cmp rINC,x ;test result + > trap_ne +2a9b : d0fe > bne * ;failed not equal (non zero) + > +2a9d : 68 > pla ;load status + > eor_flag 0 +2a9e : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2aa0 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2aa3 : d0fe > bne * ;failed not equal (non zero) + > + +2aa5 : e8 inx +2aa6 : e002 cpx #2 +2aa8 : d005 bne tinc3 +2aaa : a9fe lda #$fe +2aac : 8d0302 sta abst +2aaf : e005 tinc3 cpx #5 +2ab1 : d0da bne tinc2 +2ab3 : ca dex +2ab4 : ee0302 inc abst +2ab7 : tdec2 + set_stat 0 + > load_flag 0 +2ab7 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2ab9 : 48 > pha ;use stack to load status +2aba : 28 > plp + +2abb : ce0302 dec abst + tst_abs rINC,fINC,0 +2abe : 08 > php ;save flags +2abf : ad0302 > lda abst +2ac2 : dd3102 > cmp rINC,x ;test result + > trap_ne +2ac5 : d0fe > bne * ;failed not equal (non zero) + > +2ac7 : 68 > pla ;load status + > eor_flag 0 +2ac8 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2aca : dd3602 > cmp fINC,x ;test flags + > trap_ne +2acd : d0fe > bne * ;failed not equal (non zero) + > + +2acf : ca dex +2ad0 : 300b bmi tdec3 +2ad2 : e001 cpx #1 +2ad4 : d0e1 bne tdec2 +2ad6 : a981 lda #$81 +2ad8 : 8d0302 sta abst +2adb : d0da bne tdec2 +2add : tdec3 +2add : a200 ldx #0 +2adf : a97e lda #$7e +2ae1 : 8d0302 sta abst +2ae4 : tinc12 + set_stat $ff + > load_flag $ff +2ae4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2ae6 : 48 > pha ;use stack to load status +2ae7 : 28 > plp + +2ae8 : ee0302 inc abst + tst_abs rINC,fINC,$ff-fnz +2aeb : 08 > php ;save flags +2aec : ad0302 > lda abst +2aef : dd3102 > cmp rINC,x ;test result + > trap_ne +2af2 : d0fe > bne * ;failed not equal (non zero) + > +2af4 : 68 > pla ;load status + > eor_flag $ff-fnz +2af5 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2af7 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2afa : d0fe > bne * ;failed not equal (non zero) + > + +2afc : e8 inx +2afd : e002 cpx #2 +2aff : d005 bne tinc13 +2b01 : a9fe lda #$fe +2b03 : 8d0302 sta abst +2b06 : e005 tinc13 cpx #5 +2b08 : d0da bne tinc12 +2b0a : ca dex +2b0b : ee0302 inc abst +2b0e : tdec12 + set_stat $ff + > load_flag $ff +2b0e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2b10 : 48 > pha ;use stack to load status +2b11 : 28 > plp + +2b12 : ce0302 dec abst + tst_abs rINC,fINC,$ff-fnz +2b15 : 08 > php ;save flags +2b16 : ad0302 > lda abst +2b19 : dd3102 > cmp rINC,x ;test result + > trap_ne +2b1c : d0fe > bne * ;failed not equal (non zero) + > +2b1e : 68 > pla ;load status + > eor_flag $ff-fnz +2b1f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2b21 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2b24 : d0fe > bne * ;failed not equal (non zero) + > + +2b26 : ca dex +2b27 : 300b bmi tdec13 +2b29 : e001 cpx #1 +2b2b : d0e1 bne tdec12 +2b2d : a981 lda #$81 +2b2f : 8d0302 sta abst +2b32 : d0da bne tdec12 +2b34 : tdec13 + next_test +2b34 : ad0002 > lda test_case ;previous test +2b37 : c923 > cmp #test_num + > trap_ne ;test is out of sequence +2b39 : d0fe > bne * ;failed not equal (non zero) + > +0024 = >test_num = test_num + 1 +2b3b : a924 > lda #test_num ;*** next tests' number +2b3d : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; zeropage indexed +2b40 : a200 ldx #0 +2b42 : a97e lda #$7e +2b44 : 950c tinc4 sta zpt,x + set_stat 0 + > load_flag 0 +2b46 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2b48 : 48 > pha ;use stack to load status +2b49 : 28 > plp + +2b4a : f60c inc zpt,x + tst_zx rINC,fINC,0 +2b4c : 08 > php ;save flags +2b4d : b50c > lda zpt,x +2b4f : dd3102 > cmp rINC,x ;test result + > trap_ne +2b52 : d0fe > bne * ;failed not equal (non zero) + > +2b54 : 68 > pla ;load status + > eor_flag 0 +2b55 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2b57 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2b5a : d0fe > bne * ;failed not equal (non zero) + > + +2b5c : b50c lda zpt,x +2b5e : e8 inx +2b5f : e002 cpx #2 +2b61 : d002 bne tinc5 +2b63 : a9fe lda #$fe +2b65 : e005 tinc5 cpx #5 +2b67 : d0db bne tinc4 +2b69 : ca dex +2b6a : a902 lda #2 +2b6c : 950c tdec4 sta zpt,x + set_stat 0 + > load_flag 0 +2b6e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2b70 : 48 > pha ;use stack to load status +2b71 : 28 > plp + +2b72 : d60c dec zpt,x + tst_zx rINC,fINC,0 +2b74 : 08 > php ;save flags +2b75 : b50c > lda zpt,x +2b77 : dd3102 > cmp rINC,x ;test result + > trap_ne +2b7a : d0fe > bne * ;failed not equal (non zero) + > +2b7c : 68 > pla ;load status + > eor_flag 0 +2b7d : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2b7f : dd3602 > cmp fINC,x ;test flags + > trap_ne +2b82 : d0fe > bne * ;failed not equal (non zero) + > + +2b84 : b50c lda zpt,x +2b86 : ca dex +2b87 : 3008 bmi tdec5 +2b89 : e001 cpx #1 +2b8b : d0df bne tdec4 +2b8d : a981 lda #$81 +2b8f : d0db bne tdec4 +2b91 : tdec5 +2b91 : a200 ldx #0 +2b93 : a97e lda #$7e +2b95 : 950c tinc14 sta zpt,x + set_stat $ff + > load_flag $ff +2b97 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2b99 : 48 > pha ;use stack to load status +2b9a : 28 > plp + +2b9b : f60c inc zpt,x + tst_zx rINC,fINC,$ff-fnz +2b9d : 08 > php ;save flags +2b9e : b50c > lda zpt,x +2ba0 : dd3102 > cmp rINC,x ;test result + > trap_ne +2ba3 : d0fe > bne * ;failed not equal (non zero) + > +2ba5 : 68 > pla ;load status + > eor_flag $ff-fnz +2ba6 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2ba8 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2bab : d0fe > bne * ;failed not equal (non zero) + > + +2bad : b50c lda zpt,x +2baf : e8 inx +2bb0 : e002 cpx #2 +2bb2 : d002 bne tinc15 +2bb4 : a9fe lda #$fe +2bb6 : e005 tinc15 cpx #5 +2bb8 : d0db bne tinc14 +2bba : ca dex +2bbb : a902 lda #2 +2bbd : 950c tdec14 sta zpt,x + set_stat $ff + > load_flag $ff +2bbf : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2bc1 : 48 > pha ;use stack to load status +2bc2 : 28 > plp + +2bc3 : d60c dec zpt,x + tst_zx rINC,fINC,$ff-fnz +2bc5 : 08 > php ;save flags +2bc6 : b50c > lda zpt,x +2bc8 : dd3102 > cmp rINC,x ;test result + > trap_ne +2bcb : d0fe > bne * ;failed not equal (non zero) + > +2bcd : 68 > pla ;load status + > eor_flag $ff-fnz +2bce : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2bd0 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2bd3 : d0fe > bne * ;failed not equal (non zero) + > + +2bd5 : b50c lda zpt,x +2bd7 : ca dex +2bd8 : 3008 bmi tdec15 +2bda : e001 cpx #1 +2bdc : d0df bne tdec14 +2bde : a981 lda #$81 +2be0 : d0db bne tdec14 +2be2 : tdec15 + next_test +2be2 : ad0002 > lda test_case ;previous test +2be5 : c924 > cmp #test_num + > trap_ne ;test is out of sequence +2be7 : d0fe > bne * ;failed not equal (non zero) + > +0025 = >test_num = test_num + 1 +2be9 : a925 > lda #test_num ;*** next tests' number +2beb : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; memory indexed +2bee : a200 ldx #0 +2bf0 : a97e lda #$7e +2bf2 : 9d0302 tinc6 sta abst,x + set_stat 0 + > load_flag 0 +2bf5 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2bf7 : 48 > pha ;use stack to load status +2bf8 : 28 > plp + +2bf9 : fe0302 inc abst,x + tst_absx rINC,fINC,0 +2bfc : 08 > php ;save flags +2bfd : bd0302 > lda abst,x +2c00 : dd3102 > cmp rINC,x ;test result + > trap_ne +2c03 : d0fe > bne * ;failed not equal (non zero) + > +2c05 : 68 > pla ;load status + > eor_flag 0 +2c06 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2c08 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2c0b : d0fe > bne * ;failed not equal (non zero) + > + +2c0d : bd0302 lda abst,x +2c10 : e8 inx +2c11 : e002 cpx #2 +2c13 : d002 bne tinc7 +2c15 : a9fe lda #$fe +2c17 : e005 tinc7 cpx #5 +2c19 : d0d7 bne tinc6 +2c1b : ca dex +2c1c : a902 lda #2 +2c1e : 9d0302 tdec6 sta abst,x + set_stat 0 + > load_flag 0 +2c21 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2c23 : 48 > pha ;use stack to load status +2c24 : 28 > plp + +2c25 : de0302 dec abst,x + tst_absx rINC,fINC,0 +2c28 : 08 > php ;save flags +2c29 : bd0302 > lda abst,x +2c2c : dd3102 > cmp rINC,x ;test result + > trap_ne +2c2f : d0fe > bne * ;failed not equal (non zero) + > +2c31 : 68 > pla ;load status + > eor_flag 0 +2c32 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2c34 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2c37 : d0fe > bne * ;failed not equal (non zero) + > + +2c39 : bd0302 lda abst,x +2c3c : ca dex +2c3d : 3008 bmi tdec7 +2c3f : e001 cpx #1 +2c41 : d0db bne tdec6 +2c43 : a981 lda #$81 +2c45 : d0d7 bne tdec6 +2c47 : tdec7 +2c47 : a200 ldx #0 +2c49 : a97e lda #$7e +2c4b : 9d0302 tinc16 sta abst,x + set_stat $ff + > load_flag $ff +2c4e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2c50 : 48 > pha ;use stack to load status +2c51 : 28 > plp + +2c52 : fe0302 inc abst,x + tst_absx rINC,fINC,$ff-fnz +2c55 : 08 > php ;save flags +2c56 : bd0302 > lda abst,x +2c59 : dd3102 > cmp rINC,x ;test result + > trap_ne +2c5c : d0fe > bne * ;failed not equal (non zero) + > +2c5e : 68 > pla ;load status + > eor_flag $ff-fnz +2c5f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2c61 : dd3602 > cmp fINC,x ;test flags + > trap_ne +2c64 : d0fe > bne * ;failed not equal (non zero) + > + +2c66 : bd0302 lda abst,x +2c69 : e8 inx +2c6a : e002 cpx #2 +2c6c : d002 bne tinc17 +2c6e : a9fe lda #$fe +2c70 : e005 tinc17 cpx #5 +2c72 : d0d7 bne tinc16 +2c74 : ca dex +2c75 : a902 lda #2 +2c77 : 9d0302 tdec16 sta abst,x + set_stat $ff + > load_flag $ff +2c7a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2c7c : 48 > pha ;use stack to load status +2c7d : 28 > plp + +2c7e : de0302 dec abst,x + tst_absx rINC,fINC,$ff-fnz +2c81 : 08 > php ;save flags +2c82 : bd0302 > lda abst,x +2c85 : dd3102 > cmp rINC,x ;test result + > trap_ne +2c88 : d0fe > bne * ;failed not equal (non zero) + > +2c8a : 68 > pla ;load status + > eor_flag $ff-fnz +2c8b : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2c8d : dd3602 > cmp fINC,x ;test flags + > trap_ne +2c90 : d0fe > bne * ;failed not equal (non zero) + > + +2c92 : bd0302 lda abst,x +2c95 : ca dex +2c96 : 3008 bmi tdec17 +2c98 : e001 cpx #1 +2c9a : d0db bne tdec16 +2c9c : a981 lda #$81 +2c9e : d0d7 bne tdec16 +2ca0 : tdec17 + next_test +2ca0 : ad0002 > lda test_case ;previous test +2ca3 : c925 > cmp #test_num + > trap_ne ;test is out of sequence +2ca5 : d0fe > bne * ;failed not equal (non zero) + > +0026 = >test_num = test_num + 1 +2ca7 : a926 > lda #test_num ;*** next tests' number +2ca9 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; testing logical instructions - AND EOR ORA all addressing modes + ; AND +2cac : a203 ldx #3 ;immediate - self modifying code +2cae : b51c tand lda zpAN,x +2cb0 : 8dbb2c sta tandi1 + set_ax absANa,0 + > load_flag 0 +2cb3 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2cb5 : 48 > pha ;use stack to load status +2cb6 : bd4b02 > lda absANa,x ;precharge accu +2cb9 : 28 > plp + +2cbb = tandi1 equ *+1 ;target for immediate operand +2cba : 2963 and #99 + tst_ax absrlo,absflo,0 +2cbc : 08 > php ;save flags +2cbd : dd5302 > cmp absrlo,x ;test result + > trap_ne +2cc0 : d0fe > bne * ;failed not equal (non zero) + > +2cc2 : 68 > pla ;load status + > eor_flag 0 +2cc3 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2cc5 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2cc8 : d0fe > bne * ;failed not equal (non zero) + > + +2cca : ca dex +2ccb : 10e1 bpl tand +2ccd : a203 ldx #3 +2ccf : b51c tand1 lda zpAN,x +2cd1 : 8ddc2c sta tandi2 + set_ax absANa,$ff + > load_flag $ff +2cd4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2cd6 : 48 > pha ;use stack to load status +2cd7 : bd4b02 > lda absANa,x ;precharge accu +2cda : 28 > plp + +2cdc = tandi2 equ *+1 ;target for immediate operand +2cdb : 2963 and #99 + tst_ax absrlo,absflo,$ff-fnz +2cdd : 08 > php ;save flags +2cde : dd5302 > cmp absrlo,x ;test result + > trap_ne +2ce1 : d0fe > bne * ;failed not equal (non zero) + > +2ce3 : 68 > pla ;load status + > eor_flag $ff-fnz +2ce4 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2ce6 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2ce9 : d0fe > bne * ;failed not equal (non zero) + > + +2ceb : ca dex +2cec : 10e1 bpl tand1 + +2cee : a203 ldx #3 ;zp +2cf0 : b51c tand2 lda zpAN,x +2cf2 : 850c sta zpt + set_ax absANa,0 + > load_flag 0 +2cf4 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2cf6 : 48 > pha ;use stack to load status +2cf7 : bd4b02 > lda absANa,x ;precharge accu +2cfa : 28 > plp + +2cfb : 250c and zpt + tst_ax absrlo,absflo,0 +2cfd : 08 > php ;save flags +2cfe : dd5302 > cmp absrlo,x ;test result + > trap_ne +2d01 : d0fe > bne * ;failed not equal (non zero) + > +2d03 : 68 > pla ;load status + > eor_flag 0 +2d04 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2d06 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2d09 : d0fe > bne * ;failed not equal (non zero) + > + +2d0b : ca dex +2d0c : 10e2 bpl tand2 +2d0e : a203 ldx #3 +2d10 : b51c tand3 lda zpAN,x +2d12 : 850c sta zpt + set_ax absANa,$ff + > load_flag $ff +2d14 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2d16 : 48 > pha ;use stack to load status +2d17 : bd4b02 > lda absANa,x ;precharge accu +2d1a : 28 > plp + +2d1b : 250c and zpt + tst_ax absrlo,absflo,$ff-fnz +2d1d : 08 > php ;save flags +2d1e : dd5302 > cmp absrlo,x ;test result + > trap_ne +2d21 : d0fe > bne * ;failed not equal (non zero) + > +2d23 : 68 > pla ;load status + > eor_flag $ff-fnz +2d24 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2d26 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2d29 : d0fe > bne * ;failed not equal (non zero) + > + +2d2b : ca dex +2d2c : 10e2 bpl tand3 + +2d2e : a203 ldx #3 ;abs +2d30 : b51c tand4 lda zpAN,x +2d32 : 8d0302 sta abst + set_ax absANa,0 + > load_flag 0 +2d35 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2d37 : 48 > pha ;use stack to load status +2d38 : bd4b02 > lda absANa,x ;precharge accu +2d3b : 28 > plp + +2d3c : 2d0302 and abst + tst_ax absrlo,absflo,0 +2d3f : 08 > php ;save flags +2d40 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2d43 : d0fe > bne * ;failed not equal (non zero) + > +2d45 : 68 > pla ;load status + > eor_flag 0 +2d46 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2d48 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2d4b : d0fe > bne * ;failed not equal (non zero) + > + +2d4d : ca dex +2d4e : 10e0 bpl tand4 +2d50 : a203 ldx #3 +2d52 : b51c tand5 lda zpAN,x +2d54 : 8d0302 sta abst + set_ax absANa,$ff + > load_flag $ff +2d57 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2d59 : 48 > pha ;use stack to load status +2d5a : bd4b02 > lda absANa,x ;precharge accu +2d5d : 28 > plp + +2d5e : 2d0302 and abst + tst_ax absrlo,absflo,$ff-fnz +2d61 : 08 > php ;save flags +2d62 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2d65 : d0fe > bne * ;failed not equal (non zero) + > +2d67 : 68 > pla ;load status + > eor_flag $ff-fnz +2d68 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2d6a : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2d6d : d0fe > bne * ;failed not equal (non zero) + > + +2d6f : ca dex +2d70 : 1002 bpl tand6 + +2d72 : a203 ldx #3 ;zp,x +2d74 : tand6 + set_ax absANa,0 + > load_flag 0 +2d74 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2d76 : 48 > pha ;use stack to load status +2d77 : bd4b02 > lda absANa,x ;precharge accu +2d7a : 28 > plp + +2d7b : 351c and zpAN,x + tst_ax absrlo,absflo,0 +2d7d : 08 > php ;save flags +2d7e : dd5302 > cmp absrlo,x ;test result + > trap_ne +2d81 : d0fe > bne * ;failed not equal (non zero) + > +2d83 : 68 > pla ;load status + > eor_flag 0 +2d84 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2d86 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2d89 : d0fe > bne * ;failed not equal (non zero) + > + +2d8b : ca dex +2d8c : 10e6 bpl tand6 +2d8e : a203 ldx #3 +2d90 : tand7 + set_ax absANa,$ff + > load_flag $ff +2d90 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2d92 : 48 > pha ;use stack to load status +2d93 : bd4b02 > lda absANa,x ;precharge accu +2d96 : 28 > plp + +2d97 : 351c and zpAN,x + tst_ax absrlo,absflo,$ff-fnz +2d99 : 08 > php ;save flags +2d9a : dd5302 > cmp absrlo,x ;test result + > trap_ne +2d9d : d0fe > bne * ;failed not equal (non zero) + > +2d9f : 68 > pla ;load status + > eor_flag $ff-fnz +2da0 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2da2 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2da5 : d0fe > bne * ;failed not equal (non zero) + > + +2da7 : ca dex +2da8 : 10e6 bpl tand7 + +2daa : a203 ldx #3 ;abs,x +2dac : tand8 + set_ax absANa,0 + > load_flag 0 +2dac : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2dae : 48 > pha ;use stack to load status +2daf : bd4b02 > lda absANa,x ;precharge accu +2db2 : 28 > plp + +2db3 : 3d3f02 and absAN,x + tst_ax absrlo,absflo,0 +2db6 : 08 > php ;save flags +2db7 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2dba : d0fe > bne * ;failed not equal (non zero) + > +2dbc : 68 > pla ;load status + > eor_flag 0 +2dbd : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2dbf : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2dc2 : d0fe > bne * ;failed not equal (non zero) + > + +2dc4 : ca dex +2dc5 : 10e5 bpl tand8 +2dc7 : a203 ldx #3 +2dc9 : tand9 + set_ax absANa,$ff + > load_flag $ff +2dc9 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2dcb : 48 > pha ;use stack to load status +2dcc : bd4b02 > lda absANa,x ;precharge accu +2dcf : 28 > plp + +2dd0 : 3d3f02 and absAN,x + tst_ax absrlo,absflo,$ff-fnz +2dd3 : 08 > php ;save flags +2dd4 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2dd7 : d0fe > bne * ;failed not equal (non zero) + > +2dd9 : 68 > pla ;load status + > eor_flag $ff-fnz +2dda : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2ddc : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2ddf : d0fe > bne * ;failed not equal (non zero) + > + +2de1 : ca dex +2de2 : 10e5 bpl tand9 + +2de4 : a003 ldy #3 ;abs,y +2de6 : tand10 + set_ay absANa,0 + > load_flag 0 +2de6 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2de8 : 48 > pha ;use stack to load status +2de9 : b94b02 > lda absANa,y ;precharge accu +2dec : 28 > plp + +2ded : 393f02 and absAN,y + tst_ay absrlo,absflo,0 +2df0 : 08 > php ;save flags +2df1 : d95302 > cmp absrlo,y ;test result + > trap_ne ; +2df4 : d0fe > bne * ;failed not equal (non zero) + > +2df6 : 68 > pla ;load status + > eor_flag 0 +2df7 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2df9 : d95702 > cmp absflo,y ;test flags + > trap_ne +2dfc : d0fe > bne * ;failed not equal (non zero) + > + +2dfe : 88 dey +2dff : 10e5 bpl tand10 +2e01 : a003 ldy #3 +2e03 : tand11 + set_ay absANa,$ff + > load_flag $ff +2e03 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2e05 : 48 > pha ;use stack to load status +2e06 : b94b02 > lda absANa,y ;precharge accu +2e09 : 28 > plp + +2e0a : 393f02 and absAN,y + tst_ay absrlo,absflo,$ff-fnz +2e0d : 08 > php ;save flags +2e0e : d95302 > cmp absrlo,y ;test result + > trap_ne ; +2e11 : d0fe > bne * ;failed not equal (non zero) + > +2e13 : 68 > pla ;load status + > eor_flag $ff-fnz +2e14 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2e16 : d95702 > cmp absflo,y ;test flags + > trap_ne +2e19 : d0fe > bne * ;failed not equal (non zero) + > + +2e1b : 88 dey +2e1c : 10e5 bpl tand11 + +2e1e : a206 ldx #6 ;(zp,x) +2e20 : a003 ldy #3 +2e22 : tand12 + set_ay absANa,0 + > load_flag 0 +2e22 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2e24 : 48 > pha ;use stack to load status +2e25 : b94b02 > lda absANa,y ;precharge accu +2e28 : 28 > plp + +2e29 : 213a and (indAN,x) + tst_ay absrlo,absflo,0 +2e2b : 08 > php ;save flags +2e2c : d95302 > cmp absrlo,y ;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 : d95702 > cmp absflo,y ;test flags + > trap_ne +2e37 : d0fe > bne * ;failed not equal (non zero) + > + +2e39 : ca dex +2e3a : ca dex +2e3b : 88 dey +2e3c : 10e4 bpl tand12 +2e3e : a206 ldx #6 +2e40 : a003 ldy #3 +2e42 : tand13 + set_ay absANa,$ff + > load_flag $ff +2e42 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2e44 : 48 > pha ;use stack to load status +2e45 : b94b02 > lda absANa,y ;precharge accu +2e48 : 28 > plp + +2e49 : 213a and (indAN,x) + tst_ay absrlo,absflo,$ff-fnz +2e4b : 08 > php ;save flags +2e4c : d95302 > cmp absrlo,y ;test result + > trap_ne ; +2e4f : d0fe > bne * ;failed not equal (non zero) + > +2e51 : 68 > pla ;load status + > eor_flag $ff-fnz +2e52 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2e54 : d95702 > cmp absflo,y ;test flags + > trap_ne +2e57 : d0fe > bne * ;failed not equal (non zero) + > + +2e59 : ca dex +2e5a : ca dex +2e5b : 88 dey +2e5c : 10e4 bpl tand13 + +2e5e : a003 ldy #3 ;(zp),y +2e60 : tand14 + set_ay absANa,0 + > load_flag 0 +2e60 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2e62 : 48 > pha ;use stack to load status +2e63 : b94b02 > lda absANa,y ;precharge accu +2e66 : 28 > plp + +2e67 : 313a and (indAN),y + tst_ay absrlo,absflo,0 +2e69 : 08 > php ;save flags +2e6a : d95302 > cmp absrlo,y ;test result + > trap_ne ; +2e6d : d0fe > bne * ;failed not equal (non zero) + > +2e6f : 68 > pla ;load status + > eor_flag 0 +2e70 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2e72 : d95702 > cmp absflo,y ;test flags + > trap_ne +2e75 : d0fe > bne * ;failed not equal (non zero) + > + +2e77 : 88 dey +2e78 : 10e6 bpl tand14 +2e7a : a003 ldy #3 +2e7c : tand15 + set_ay absANa,$ff + > load_flag $ff +2e7c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2e7e : 48 > pha ;use stack to load status +2e7f : b94b02 > lda absANa,y ;precharge accu +2e82 : 28 > plp + +2e83 : 313a and (indAN),y + tst_ay absrlo,absflo,$ff-fnz +2e85 : 08 > php ;save flags +2e86 : d95302 > cmp absrlo,y ;test result + > trap_ne ; +2e89 : d0fe > bne * ;failed not equal (non zero) + > +2e8b : 68 > pla ;load status + > eor_flag $ff-fnz +2e8c : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2e8e : d95702 > cmp absflo,y ;test flags + > trap_ne +2e91 : d0fe > bne * ;failed not equal (non zero) + > + +2e93 : 88 dey +2e94 : 10e6 bpl tand15 + next_test +2e96 : ad0002 > lda test_case ;previous test +2e99 : c926 > cmp #test_num + > trap_ne ;test is out of sequence +2e9b : d0fe > bne * ;failed not equal (non zero) + > +0027 = >test_num = test_num + 1 +2e9d : a927 > lda #test_num ;*** next tests' number +2e9f : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; EOR +2ea2 : a203 ldx #3 ;immediate - self modifying code +2ea4 : b520 teor lda zpEO,x +2ea6 : 8db12e sta teori1 + set_ax absEOa,0 + > load_flag 0 +2ea9 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2eab : 48 > pha ;use stack to load status +2eac : bd4f02 > lda absEOa,x ;precharge accu +2eaf : 28 > plp + +2eb1 = teori1 equ *+1 ;target for immediate operand +2eb0 : 4963 eor #99 + tst_ax absrlo,absflo,0 +2eb2 : 08 > php ;save flags +2eb3 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2eb6 : d0fe > bne * ;failed not equal (non zero) + > +2eb8 : 68 > pla ;load status + > eor_flag 0 +2eb9 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2ebb : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2ebe : d0fe > bne * ;failed not equal (non zero) + > + +2ec0 : ca dex +2ec1 : 10e1 bpl teor +2ec3 : a203 ldx #3 +2ec5 : b520 teor1 lda zpEO,x +2ec7 : 8dd22e sta teori2 + set_ax absEOa,$ff + > load_flag $ff +2eca : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2ecc : 48 > pha ;use stack to load status +2ecd : bd4f02 > lda absEOa,x ;precharge accu +2ed0 : 28 > plp + +2ed2 = teori2 equ *+1 ;target for immediate operand +2ed1 : 4963 eor #99 + tst_ax absrlo,absflo,$ff-fnz +2ed3 : 08 > php ;save flags +2ed4 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2ed7 : d0fe > bne * ;failed not equal (non zero) + > +2ed9 : 68 > pla ;load status + > eor_flag $ff-fnz +2eda : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2edc : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2edf : d0fe > bne * ;failed not equal (non zero) + > + +2ee1 : ca dex +2ee2 : 10e1 bpl teor1 + +2ee4 : a203 ldx #3 ;zp +2ee6 : b520 teor2 lda zpEO,x +2ee8 : 850c sta zpt + set_ax absEOa,0 + > load_flag 0 +2eea : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2eec : 48 > pha ;use stack to load status +2eed : bd4f02 > lda absEOa,x ;precharge accu +2ef0 : 28 > plp + +2ef1 : 450c eor zpt + tst_ax absrlo,absflo,0 +2ef3 : 08 > php ;save flags +2ef4 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2ef7 : d0fe > bne * ;failed not equal (non zero) + > +2ef9 : 68 > pla ;load status + > eor_flag 0 +2efa : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2efc : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2eff : d0fe > bne * ;failed not equal (non zero) + > + +2f01 : ca dex +2f02 : 10e2 bpl teor2 +2f04 : a203 ldx #3 +2f06 : b520 teor3 lda zpEO,x +2f08 : 850c sta zpt + set_ax absEOa,$ff + > load_flag $ff +2f0a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2f0c : 48 > pha ;use stack to load status +2f0d : bd4f02 > lda absEOa,x ;precharge accu +2f10 : 28 > plp + +2f11 : 450c eor zpt + tst_ax absrlo,absflo,$ff-fnz +2f13 : 08 > php ;save flags +2f14 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2f17 : d0fe > bne * ;failed not equal (non zero) + > +2f19 : 68 > pla ;load status + > eor_flag $ff-fnz +2f1a : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2f1c : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2f1f : d0fe > bne * ;failed not equal (non zero) + > + +2f21 : ca dex +2f22 : 10e2 bpl teor3 + +2f24 : a203 ldx #3 ;abs +2f26 : b520 teor4 lda zpEO,x +2f28 : 8d0302 sta abst + set_ax absEOa,0 + > load_flag 0 +2f2b : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2f2d : 48 > pha ;use stack to load status +2f2e : bd4f02 > lda absEOa,x ;precharge accu +2f31 : 28 > plp + +2f32 : 4d0302 eor abst + tst_ax absrlo,absflo,0 +2f35 : 08 > php ;save flags +2f36 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2f39 : d0fe > bne * ;failed not equal (non zero) + > +2f3b : 68 > pla ;load status + > eor_flag 0 +2f3c : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2f3e : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2f41 : d0fe > bne * ;failed not equal (non zero) + > + +2f43 : ca dex +2f44 : 10e0 bpl teor4 +2f46 : a203 ldx #3 +2f48 : b520 teor5 lda zpEO,x +2f4a : 8d0302 sta abst + set_ax absEOa,$ff + > load_flag $ff +2f4d : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2f4f : 48 > pha ;use stack to load status +2f50 : bd4f02 > lda absEOa,x ;precharge accu +2f53 : 28 > plp + +2f54 : 4d0302 eor abst + tst_ax absrlo,absflo,$ff-fnz +2f57 : 08 > php ;save flags +2f58 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2f5b : d0fe > bne * ;failed not equal (non zero) + > +2f5d : 68 > pla ;load status + > eor_flag $ff-fnz +2f5e : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2f60 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2f63 : d0fe > bne * ;failed not equal (non zero) + > + +2f65 : ca dex +2f66 : 1002 bpl teor6 + +2f68 : a203 ldx #3 ;zp,x +2f6a : teor6 + set_ax absEOa,0 + > load_flag 0 +2f6a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2f6c : 48 > pha ;use stack to load status +2f6d : bd4f02 > lda absEOa,x ;precharge accu +2f70 : 28 > plp + +2f71 : 5520 eor zpEO,x + tst_ax absrlo,absflo,0 +2f73 : 08 > php ;save flags +2f74 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2f77 : d0fe > bne * ;failed not equal (non zero) + > +2f79 : 68 > pla ;load status + > eor_flag 0 +2f7a : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2f7c : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2f7f : d0fe > bne * ;failed not equal (non zero) + > + +2f81 : ca dex +2f82 : 10e6 bpl teor6 +2f84 : a203 ldx #3 +2f86 : teor7 + set_ax absEOa,$ff + > load_flag $ff +2f86 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2f88 : 48 > pha ;use stack to load status +2f89 : bd4f02 > lda absEOa,x ;precharge accu +2f8c : 28 > plp + +2f8d : 5520 eor zpEO,x + tst_ax absrlo,absflo,$ff-fnz +2f8f : 08 > php ;save flags +2f90 : dd5302 > cmp absrlo,x ;test result + > trap_ne +2f93 : d0fe > bne * ;failed not equal (non zero) + > +2f95 : 68 > pla ;load status + > eor_flag $ff-fnz +2f96 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2f98 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2f9b : d0fe > bne * ;failed not equal (non zero) + > + +2f9d : ca dex +2f9e : 10e6 bpl teor7 + +2fa0 : a203 ldx #3 ;abs,x +2fa2 : teor8 + 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 : bd4f02 > lda absEOa,x ;precharge accu +2fa8 : 28 > plp + +2fa9 : 5d4302 eor absEO,x + tst_ax absrlo,absflo,0 +2fac : 08 > php ;save flags +2fad : dd5302 > 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 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2fb8 : d0fe > bne * ;failed not equal (non zero) + > + +2fba : ca dex +2fbb : 10e5 bpl teor8 +2fbd : a203 ldx #3 +2fbf : teor9 + set_ax absEOa,$ff + > load_flag $ff +2fbf : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2fc1 : 48 > pha ;use stack to load status +2fc2 : bd4f02 > lda absEOa,x ;precharge accu +2fc5 : 28 > plp + +2fc6 : 5d4302 eor absEO,x + tst_ax absrlo,absflo,$ff-fnz +2fc9 : 08 > php ;save flags +2fca : dd5302 > cmp absrlo,x ;test result + > trap_ne +2fcd : d0fe > bne * ;failed not equal (non zero) + > +2fcf : 68 > pla ;load status + > eor_flag $ff-fnz +2fd0 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2fd2 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +2fd5 : d0fe > bne * ;failed not equal (non zero) + > + +2fd7 : ca dex +2fd8 : 10e5 bpl teor9 + +2fda : a003 ldy #3 ;abs,y +2fdc : teor10 + set_ay absEOa,0 + > load_flag 0 +2fdc : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2fde : 48 > pha ;use stack to load status +2fdf : b94f02 > lda absEOa,y ;precharge accu +2fe2 : 28 > plp + +2fe3 : 594302 eor absEO,y + tst_ay absrlo,absflo,0 +2fe6 : 08 > php ;save flags +2fe7 : d95302 > cmp absrlo,y ;test result + > trap_ne ; +2fea : d0fe > bne * ;failed not equal (non zero) + > +2fec : 68 > pla ;load status + > eor_flag 0 +2fed : 4930 > eor #0|fao ;invert expected flags + always on bits + > +2fef : d95702 > cmp absflo,y ;test flags + > trap_ne +2ff2 : d0fe > bne * ;failed not equal (non zero) + > + +2ff4 : 88 dey +2ff5 : 10e5 bpl teor10 +2ff7 : a003 ldy #3 +2ff9 : teor11 + set_ay absEOa,$ff + > load_flag $ff +2ff9 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2ffb : 48 > pha ;use stack to load status +2ffc : b94f02 > lda absEOa,y ;precharge accu +2fff : 28 > plp + +3000 : 594302 eor absEO,y + tst_ay absrlo,absflo,$ff-fnz +3003 : 08 > php ;save flags +3004 : d95302 > cmp absrlo,y ;test result + > trap_ne ; +3007 : d0fe > bne * ;failed not equal (non zero) + > +3009 : 68 > pla ;load status + > eor_flag $ff-fnz +300a : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +300c : d95702 > cmp absflo,y ;test flags + > trap_ne +300f : d0fe > bne * ;failed not equal (non zero) + > + +3011 : 88 dey +3012 : 10e5 bpl teor11 + +3014 : a206 ldx #6 ;(zp,x) +3016 : a003 ldy #3 +3018 : teor12 + set_ay absEOa,0 + > load_flag 0 +3018 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +301a : 48 > pha ;use stack to load status +301b : b94f02 > lda absEOa,y ;precharge accu +301e : 28 > plp + +301f : 4142 eor (indEO,x) + tst_ay absrlo,absflo,0 +3021 : 08 > php ;save flags +3022 : d95302 > cmp absrlo,y ;test result + > trap_ne ; +3025 : d0fe > bne * ;failed not equal (non zero) + > +3027 : 68 > pla ;load status + > eor_flag 0 +3028 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +302a : d95702 > cmp absflo,y ;test flags + > trap_ne +302d : d0fe > bne * ;failed not equal (non zero) + > + +302f : ca dex +3030 : ca dex +3031 : 88 dey +3032 : 10e4 bpl teor12 +3034 : a206 ldx #6 +3036 : a003 ldy #3 +3038 : teor13 + set_ay absEOa,$ff + > load_flag $ff +3038 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +303a : 48 > pha ;use stack to load status +303b : b94f02 > lda absEOa,y ;precharge accu +303e : 28 > plp + +303f : 4142 eor (indEO,x) + tst_ay absrlo,absflo,$ff-fnz +3041 : 08 > php ;save flags +3042 : d95302 > cmp absrlo,y ;test result + > trap_ne ; +3045 : d0fe > bne * ;failed not equal (non zero) + > +3047 : 68 > pla ;load status + > eor_flag $ff-fnz +3048 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +304a : d95702 > cmp absflo,y ;test flags + > trap_ne +304d : d0fe > bne * ;failed not equal (non zero) + > + +304f : ca dex +3050 : ca dex +3051 : 88 dey +3052 : 10e4 bpl teor13 + +3054 : a003 ldy #3 ;(zp),y +3056 : teor14 + set_ay absEOa,0 + > load_flag 0 +3056 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +3058 : 48 > pha ;use stack to load status +3059 : b94f02 > lda absEOa,y ;precharge accu +305c : 28 > plp + +305d : 5142 eor (indEO),y + tst_ay absrlo,absflo,0 +305f : 08 > php ;save flags +3060 : d95302 > cmp absrlo,y ;test result + > trap_ne ; +3063 : d0fe > bne * ;failed not equal (non zero) + > +3065 : 68 > pla ;load status + > eor_flag 0 +3066 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +3068 : d95702 > cmp absflo,y ;test flags + > trap_ne +306b : d0fe > bne * ;failed not equal (non zero) + > + +306d : 88 dey +306e : 10e6 bpl teor14 +3070 : a003 ldy #3 +3072 : teor15 + set_ay absEOa,$ff + > load_flag $ff +3072 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +3074 : 48 > pha ;use stack to load status +3075 : b94f02 > lda absEOa,y ;precharge accu +3078 : 28 > plp + +3079 : 5142 eor (indEO),y + tst_ay absrlo,absflo,$ff-fnz +307b : 08 > php ;save flags +307c : d95302 > cmp absrlo,y ;test result + > trap_ne ; +307f : d0fe > bne * ;failed not equal (non zero) + > +3081 : 68 > pla ;load status + > eor_flag $ff-fnz +3082 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +3084 : d95702 > cmp absflo,y ;test flags + > trap_ne +3087 : d0fe > bne * ;failed not equal (non zero) + > + +3089 : 88 dey +308a : 10e6 bpl teor15 + next_test +308c : ad0002 > lda test_case ;previous test +308f : c927 > cmp #test_num + > trap_ne ;test is out of sequence +3091 : d0fe > bne * ;failed not equal (non zero) + > +0028 = >test_num = test_num + 1 +3093 : a928 > lda #test_num ;*** next tests' number +3095 : 8d0002 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; OR +3098 : a203 ldx #3 ;immediate - self modifying code +309a : b518 tora lda zpOR,x +309c : 8da730 sta torai1 + set_ax absORa,0 + > load_flag 0 +309f : a900 > lda #0 ;allow test to change I-flag (no mask) + > +30a1 : 48 > pha ;use stack to load status +30a2 : bd4702 > lda absORa,x ;precharge accu +30a5 : 28 > plp + +30a7 = torai1 equ *+1 ;target for immediate operand +30a6 : 0963 ora #99 + tst_ax absrlo,absflo,0 +30a8 : 08 > php ;save flags +30a9 : dd5302 > cmp absrlo,x ;test result + > trap_ne +30ac : d0fe > bne * ;failed not equal (non zero) + > +30ae : 68 > pla ;load status + > eor_flag 0 +30af : 4930 > eor #0|fao ;invert expected flags + always on bits + > +30b1 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +30b4 : d0fe > bne * ;failed not equal (non zero) + > + +30b6 : ca dex +30b7 : 10e1 bpl tora +30b9 : a203 ldx #3 +30bb : b518 tora1 lda zpOR,x +30bd : 8dc830 sta torai2 + set_ax absORa,$ff + > load_flag $ff +30c0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +30c2 : 48 > pha ;use stack to load status +30c3 : bd4702 > lda absORa,x ;precharge accu +30c6 : 28 > plp + +30c8 = torai2 equ *+1 ;target for immediate operand +30c7 : 0963 ora #99 + tst_ax absrlo,absflo,$ff-fnz +30c9 : 08 > php ;save flags +30ca : dd5302 > cmp absrlo,x ;test result + > trap_ne +30cd : d0fe > bne * ;failed not equal (non zero) + > +30cf : 68 > pla ;load status + > eor_flag $ff-fnz +30d0 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +30d2 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +30d5 : d0fe > bne * ;failed not equal (non zero) + > + +30d7 : ca dex +30d8 : 10e1 bpl tora1 + +30da : a203 ldx #3 ;zp +30dc : b518 tora2 lda zpOR,x +30de : 850c sta zpt + set_ax absORa,0 + > load_flag 0 +30e0 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +30e2 : 48 > pha ;use stack to load status +30e3 : bd4702 > lda absORa,x ;precharge accu +30e6 : 28 > plp + +30e7 : 050c ora zpt + tst_ax absrlo,absflo,0 +30e9 : 08 > php ;save flags +30ea : dd5302 > cmp absrlo,x ;test result + > trap_ne +30ed : d0fe > bne * ;failed not equal (non zero) + > +30ef : 68 > pla ;load status + > eor_flag 0 +30f0 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +30f2 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +30f5 : d0fe > bne * ;failed not equal (non zero) + > + +30f7 : ca dex +30f8 : 10e2 bpl tora2 +30fa : a203 ldx #3 +30fc : b518 tora3 lda zpOR,x +30fe : 850c sta zpt + set_ax absORa,$ff + > load_flag $ff +3100 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +3102 : 48 > pha ;use stack to load status +3103 : bd4702 > lda absORa,x ;precharge accu +3106 : 28 > plp + +3107 : 050c ora zpt + tst_ax absrlo,absflo,$ff-fnz +3109 : 08 > php ;save flags +310a : dd5302 > cmp absrlo,x ;test result + > trap_ne +310d : d0fe > bne * ;failed not equal (non zero) + > +310f : 68 > pla ;load status + > eor_flag $ff-fnz +3110 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +3112 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +3115 : d0fe > bne * ;failed not equal (non zero) + > + +3117 : ca dex +3118 : 10e2 bpl tora3 + +311a : a203 ldx #3 ;abs +311c : b518 tora4 lda zpOR,x +311e : 8d0302 sta abst + set_ax absORa,0 + > load_flag 0 +3121 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +3123 : 48 > pha ;use stack to load status +3124 : bd4702 > lda absORa,x ;precharge accu +3127 : 28 > plp + +3128 : 0d0302 ora abst + tst_ax absrlo,absflo,0 +312b : 08 > php ;save flags +312c : dd5302 > cmp absrlo,x ;test result + > trap_ne +312f : d0fe > bne * ;failed not equal (non zero) + > +3131 : 68 > pla ;load status + > eor_flag 0 +3132 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +3134 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +3137 : d0fe > bne * ;failed not equal (non zero) + > + +3139 : ca dex +313a : 10e0 bpl tora4 +313c : a203 ldx #3 +313e : b518 tora5 lda zpOR,x +3140 : 8d0302 sta abst + set_ax absORa,$ff + > load_flag $ff +3143 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +3145 : 48 > pha ;use stack to load status +3146 : bd4702 > lda absORa,x ;precharge accu +3149 : 28 > plp + +314a : 0d0302 ora abst + tst_ax absrlo,absflo,$ff-fnz +314d : 08 > php ;save flags +314e : dd5302 > cmp absrlo,x ;test result + > trap_ne +3151 : d0fe > bne * ;failed not equal (non zero) + > +3153 : 68 > pla ;load status + > eor_flag $ff-fnz +3154 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +3156 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +3159 : d0fe > bne * ;failed not equal (non zero) + > + +315b : ca dex +315c : 1002 bpl tora6 + +315e : a203 ldx #3 ;zp,x +3160 : tora6 + set_ax absORa,0 + > load_flag 0 +3160 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +3162 : 48 > pha ;use stack to load status +3163 : bd4702 > lda absORa,x ;precharge accu +3166 : 28 > plp + +3167 : 1518 ora zpOR,x + tst_ax absrlo,absflo,0 +3169 : 08 > php ;save flags +316a : dd5302 > cmp absrlo,x ;test result + > trap_ne +316d : d0fe > bne * ;failed not equal (non zero) + > +316f : 68 > pla ;load status + > eor_flag 0 +3170 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +3172 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +3175 : d0fe > bne * ;failed not equal (non zero) + > + +3177 : ca dex +3178 : 10e6 bpl tora6 +317a : a203 ldx #3 +317c : tora7 + set_ax absORa,$ff + > load_flag $ff +317c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +317e : 48 > pha ;use stack to load status +317f : bd4702 > lda absORa,x ;precharge accu +3182 : 28 > plp + +3183 : 1518 ora zpOR,x + tst_ax absrlo,absflo,$ff-fnz +3185 : 08 > php ;save flags +3186 : dd5302 > cmp absrlo,x ;test result + > trap_ne +3189 : d0fe > bne * ;failed not equal (non zero) + > +318b : 68 > pla ;load status + > eor_flag $ff-fnz +318c : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +318e : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +3191 : d0fe > bne * ;failed not equal (non zero) + > + +3193 : ca dex +3194 : 10e6 bpl tora7 + +3196 : a203 ldx #3 ;abs,x +3198 : tora8 + set_ax absORa,0 + > load_flag 0 +3198 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +319a : 48 > pha ;use stack to load status +319b : bd4702 > lda absORa,x ;precharge accu +319e : 28 > plp + +319f : 1d3b02 ora absOR,x + tst_ax absrlo,absflo,0 +31a2 : 08 > php ;save flags +31a3 : dd5302 > cmp absrlo,x ;test result + > trap_ne +31a6 : d0fe > bne * ;failed not equal (non zero) + > +31a8 : 68 > pla ;load status + > eor_flag 0 +31a9 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +31ab : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +31ae : d0fe > bne * ;failed not equal (non zero) + > + +31b0 : ca dex +31b1 : 10e5 bpl tora8 +31b3 : a203 ldx #3 +31b5 : tora9 + set_ax absORa,$ff + > load_flag $ff +31b5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +31b7 : 48 > pha ;use stack to load status +31b8 : bd4702 > lda absORa,x ;precharge accu +31bb : 28 > plp + +31bc : 1d3b02 ora absOR,x + tst_ax absrlo,absflo,$ff-fnz +31bf : 08 > php ;save flags +31c0 : dd5302 > cmp absrlo,x ;test result + > trap_ne +31c3 : d0fe > bne * ;failed not equal (non zero) + > +31c5 : 68 > pla ;load status + > eor_flag $ff-fnz +31c6 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +31c8 : dd5702 > cmp absflo,x ;test flags + > trap_ne ; +31cb : d0fe > bne * ;failed not equal (non zero) + > + +31cd : ca dex +31ce : 10e5 bpl tora9 + +31d0 : a003 ldy #3 ;abs,y +31d2 : tora10 + set_ay absORa,0 + > load_flag 0 +31d2 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +31d4 : 48 > pha ;use stack to load status +31d5 : b94702 > lda absORa,y ;precharge accu +31d8 : 28 > plp + +31d9 : 193b02 ora absOR,y + tst_ay absrlo,absflo,0 +31dc : 08 > php ;save flags +31dd : d95302 > cmp absrlo,y ;test result + > trap_ne ; +31e0 : d0fe > bne * ;failed not equal (non zero) + > +31e2 : 68 > pla ;load status + > eor_flag 0 +31e3 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +31e5 : d95702 > cmp absflo,y ;test flags + > trap_ne +31e8 : d0fe > bne * ;failed not equal (non zero) + > + +31ea : 88 dey +31eb : 10e5 bpl tora10 +31ed : a003 ldy #3 +31ef : tora11 + set_ay absORa,$ff + > load_flag $ff +31ef : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +31f1 : 48 > pha ;use stack to load status +31f2 : b94702 > lda absORa,y ;precharge accu +31f5 : 28 > plp + +31f6 : 193b02 ora absOR,y + tst_ay absrlo,absflo,$ff-fnz +31f9 : 08 > php ;save flags +31fa : d95302 > cmp absrlo,y ;test result + > trap_ne ; +31fd : d0fe > bne * ;failed not equal (non zero) + > +31ff : 68 > pla ;load status + > eor_flag $ff-fnz +3200 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +3202 : d95702 > cmp absflo,y ;test flags + > trap_ne +3205 : d0fe > bne * ;failed not equal (non zero) + > + +3207 : 88 dey +3208 : 10e5 bpl tora11 + +320a : a206 ldx #6 ;(zp,x) +320c : a003 ldy #3 +320e : tora12 + set_ay absORa,0 + > load_flag 0 +320e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +3210 : 48 > pha ;use stack to load status +3211 : b94702 > lda absORa,y ;precharge accu +3214 : 28 > plp + +3215 : 014a ora (indOR,x) + tst_ay absrlo,absflo,0 +3217 : 08 > php ;save flags +3218 : d95302 > cmp absrlo,y ;test result + > trap_ne ; +321b : d0fe > bne * ;failed not equal (non zero) + > +321d : 68 > pla ;load status + > eor_flag 0 +321e : 4930 > eor #0|fao ;invert expected flags + always on bits + > +3220 : d95702 > cmp absflo,y ;test flags + > trap_ne +3223 : d0fe > bne * ;failed not equal (non zero) + > + +3225 : ca dex +3226 : ca dex +3227 : 88 dey +3228 : 10e4 bpl tora12 +322a : a206 ldx #6 +322c : a003 ldy #3 +322e : tora13 + set_ay 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 : b94702 > lda absORa,y ;precharge accu +3234 : 28 > plp + +3235 : 014a ora (indOR,x) + tst_ay absrlo,absflo,$ff-fnz +3237 : 08 > php ;save flags +3238 : d95302 > cmp absrlo,y ;test result + > trap_ne ; +323b : d0fe > bne * ;failed not equal (non zero) + > +323d : 68 > pla ;load status + > eor_flag $ff-fnz +323e : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +3240 : d95702 > cmp absflo,y ;test flags + > trap_ne +3243 : d0fe > bne * ;failed not equal (non zero) + > + +3245 : ca dex +3246 : ca dex +3247 : 88 dey +3248 : 10e4 bpl tora13 + +324a : a003 ldy #3 ;(zp),y +324c : tora14 + set_ay absORa,0 + > load_flag 0 +324c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +324e : 48 > pha ;use stack to load status +324f : b94702 > lda absORa,y ;precharge accu +3252 : 28 > plp + +3253 : 114a ora (indOR),y + tst_ay absrlo,absflo,0 +3255 : 08 > php ;save flags +3256 : d95302 > 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 : d95702 > cmp absflo,y ;test flags + > trap_ne +3261 : d0fe > bne * ;failed not equal (non zero) + > + +3263 : 88 dey +3264 : 10e6 bpl tora14 +3266 : a003 ldy #3 +3268 : tora15 + 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 : b94702 > lda absORa,y ;precharge accu +326e : 28 > plp + +326f : 114a ora (indOR),y + tst_ay absrlo,absflo,$ff-fnz +3271 : 08 > php ;save flags +3272 : d95302 > cmp absrlo,y ;test result + > trap_ne ; +3275 : d0fe > bne * ;failed not equal (non zero) + > +3277 : 68 > pla ;load status + > eor_flag $ff-fnz +3278 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +327a : d95702 > cmp absflo,y ;test flags + > trap_ne +327d : d0fe > bne * ;failed not equal (non zero) + > + +327f : 88 dey +3280 : 10e6 bpl tora15 + if I_flag = 3 +3282 : 58 cli + endif + next_test +3283 : ad0002 > lda test_case ;previous test +3286 : c928 > cmp #test_num + > trap_ne ;test is out of sequence +3288 : d0fe > bne * ;failed not equal (non zero) + > +0029 = >test_num = test_num + 1 +328a : a929 > lda #test_num ;*** next tests' number +328c : 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 +328f : d8 cld +3290 : a20e ldx #ad2 ;for indexed test +3292 : a0ff ldy #$ff ;max range +3294 : a900 lda #0 ;start with adding zeroes & no carry +3296 : 850c sta adfc ;carry in - for diag +3298 : 850d sta ad1 ;operand 1 - accumulator +329a : 850e sta ad2 ;operand 2 - memory or immediate +329c : 8d0302 sta ada2 ;non zp +329f : 850f sta adrl ;expected result bits 0-7 +32a1 : 8510 sta adrh ;expected result bit 8 (carry out) +32a3 : a9ff lda #$ff ;complemented operand 2 for subtract +32a5 : 8512 sta sb2 +32a7 : 8d0402 sta sba2 ;non zp +32aa : a902 lda #2 ;expected Z-flag +32ac : 8511 sta adrf +32ae : 18 tadd clc ;test with carry clear +32af : 20d034 jsr chkadd +32b2 : e60c inc adfc ;now with carry +32b4 : e60f inc adrl ;result +1 +32b6 : 08 php ;save N & Z from low result +32b7 : 08 php +32b8 : 68 pla ;accu holds expected flags +32b9 : 2982 and #$82 ;mask N & Z +32bb : 28 plp +32bc : d002 bne tadd1 +32be : e610 inc adrh ;result bit 8 - carry +32c0 : 0510 tadd1 ora adrh ;merge C to expected flags +32c2 : 8511 sta adrf ;save expected flags except overflow +32c4 : 38 sec ;test with carry set +32c5 : 20d034 jsr chkadd +32c8 : c60c dec adfc ;same for operand +1 but no carry +32ca : e60d inc ad1 +32cc : d0e0 bne tadd ;iterate op1 +32ce : a900 lda #0 ;preset result to op2 when op1 = 0 +32d0 : 8510 sta adrh +32d2 : ee0302 inc ada2 +32d5 : e60e inc ad2 +32d7 : 08 php ;save NZ as operand 2 becomes the new result +32d8 : 68 pla +32d9 : 2982 and #$82 ;mask N00000Z0 +32db : 8511 sta adrf ;no need to check carry as we are adding to 0 +32dd : c612 dec sb2 ;complement subtract operand 2 +32df : ce0402 dec sba2 +32e2 : a50e lda ad2 +32e4 : 850f sta adrl +32e6 : d0c6 bne tadd ;iterate op2 + next_test +32e8 : ad0002 > lda test_case ;previous test +32eb : c929 > cmp #test_num + > trap_ne ;test is out of sequence +32ed : d0fe > bne * ;failed not equal (non zero) + > +002a = >test_num = test_num + 1 +32ef : a92a > lda #test_num ;*** next tests' number +32f1 : 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 +32f4 : f8 sed +32f5 : a20e ldx #ad2 ;for indexed test +32f7 : a0ff ldy #$ff ;max range +32f9 : a999 lda #$99 ;start with adding 99 to 99 with carry +32fb : 850d sta ad1 ;operand 1 - accumulator +32fd : 850e sta ad2 ;operand 2 - memory or immediate +32ff : 8d0302 sta ada2 ;non zp +3302 : 850f sta adrl ;expected result bits 0-7 +3304 : a901 lda #1 ;set carry in & out +3306 : 850c sta adfc ;carry in - for diag +3308 : 8510 sta adrh ;expected result bit 8 (carry out) +330a : a900 lda #0 ;complemented operand 2 for subtract +330c : 8512 sta sb2 +330e : 8d0402 sta sba2 ;non zp +3311 : 38 tdad sec ;test with carry set +3312 : 209f33 jsr chkdad +3315 : c60c dec adfc ;now with carry clear +3317 : a50f lda adrl ;decimal adjust result +3319 : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1) +331b : c610 dec adrh +331d : a999 lda #$99 +331f : 850f sta adrl +3321 : d012 bne tdad3 +3323 : 290f tdad1 and #$f ;lower nibble mask +3325 : d00c bne tdad2 ;no decimal adjust needed +3327 : c60f dec adrl ;decimal adjust (?0-6) +3329 : c60f dec adrl +332b : c60f dec adrl +332d : c60f dec adrl +332f : c60f dec adrl +3331 : c60f dec adrl +3333 : c60f tdad2 dec adrl ;result -1 +3335 : 18 tdad3 clc ;test with carry clear +3336 : 209f33 jsr chkdad +3339 : e60c inc adfc ;same for operand -1 but with carry +333b : a50d lda ad1 ;decimal adjust operand 1 +333d : f015 beq tdad5 ;iterate operand 2 +333f : 290f and #$f ;lower nibble mask +3341 : d00c bne tdad4 ;skip decimal adjust +3343 : c60d dec ad1 ;decimal adjust (?0-6) +3345 : c60d dec ad1 +3347 : c60d dec ad1 +3349 : c60d dec ad1 +334b : c60d dec ad1 +334d : c60d dec ad1 +334f : c60d tdad4 dec ad1 ;operand 1 -1 +3351 : 4c1133 jmp tdad ;iterate op1 + +3354 : a999 tdad5 lda #$99 ;precharge op1 max +3356 : 850d sta ad1 +3358 : a50e lda ad2 ;decimal adjust operand 2 +335a : f030 beq tdad7 ;end of iteration +335c : 290f and #$f ;lower nibble mask +335e : d018 bne tdad6 ;skip decimal adjust +3360 : c60e dec ad2 ;decimal adjust (?0-6) +3362 : c60e dec ad2 +3364 : c60e dec ad2 +3366 : c60e dec ad2 +3368 : c60e dec ad2 +336a : c60e dec ad2 +336c : e612 inc sb2 ;complemented decimal adjust for subtract (?9+6) +336e : e612 inc sb2 +3370 : e612 inc sb2 +3372 : e612 inc sb2 +3374 : e612 inc sb2 +3376 : e612 inc sb2 +3378 : c60e tdad6 dec ad2 ;operand 2 -1 +337a : e612 inc sb2 ;complemented operand for subtract +337c : a512 lda sb2 +337e : 8d0402 sta sba2 ;copy as non zp operand +3381 : a50e lda ad2 +3383 : 8d0302 sta ada2 ;copy as non zp operand +3386 : 850f sta adrl ;new result since op1+carry=00+carry +op2=op2 +3388 : e610 inc adrh ;result carry +338a : d085 bne tdad ;iterate op2 +338c : d8 tdad7 cld + +338d : ad0002 lda test_case +3390 : c92a cmp #test_num + trap_ne ;previous test is out of sequence +3392 : d0fe > bne * ;failed not equal (non zero) + +3394 : a9f0 lda #$f0 ;mark opcode testing complete +3396 : 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 +3399 : 4c9933 > jmp * ;test passed, no errors + + ; ------------- + ; S U C C E S S ************************************************ +339c : 4c0004 jmp start ;run again + + ; 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 +339f : chkdad + ; decimal ADC / SBC zp +339f : 08 php ;save carry for subtract +33a0 : a50d lda ad1 +33a2 : 650e adc ad2 ;perform add +33a4 : 08 php +33a5 : c50f cmp adrl ;check result + trap_ne ;bad result +33a7 : d0fe > bne * ;failed not equal (non zero) + +33a9 : 68 pla ;check flags +33aa : 2901 and #1 ;mask carry +33ac : c510 cmp adrh + trap_ne ;bad carry +33ae : d0fe > bne * ;failed not equal (non zero) + +33b0 : 28 plp +33b1 : 08 php ;save carry for next add +33b2 : a50d lda ad1 +33b4 : e512 sbc sb2 ;perform subtract +33b6 : 08 php +33b7 : c50f cmp adrl ;check result + trap_ne ;bad result +33b9 : d0fe > bne * ;failed not equal (non zero) + +33bb : 68 pla ;check flags +33bc : 2901 and #1 ;mask carry +33be : c510 cmp adrh + trap_ne ;bad flags +33c0 : d0fe > bne * ;failed not equal (non zero) + +33c2 : 28 plp + ; decimal ADC / SBC abs +33c3 : 08 php ;save carry for subtract +33c4 : a50d lda ad1 +33c6 : 6d0302 adc ada2 ;perform add +33c9 : 08 php +33ca : c50f cmp adrl ;check result + trap_ne ;bad result +33cc : d0fe > bne * ;failed not equal (non zero) + +33ce : 68 pla ;check flags +33cf : 2901 and #1 ;mask carry +33d1 : c510 cmp adrh + trap_ne ;bad carry +33d3 : d0fe > bne * ;failed not equal (non zero) + +33d5 : 28 plp +33d6 : 08 php ;save carry for next add +33d7 : a50d lda ad1 +33d9 : ed0402 sbc sba2 ;perform subtract +33dc : 08 php +33dd : c50f cmp adrl ;check result + trap_ne ;bad result +33df : d0fe > bne * ;failed not equal (non zero) + +33e1 : 68 pla ;check flags +33e2 : 2901 and #1 ;mask carry +33e4 : c510 cmp adrh + trap_ne ;bad carry +33e6 : d0fe > bne * ;failed not equal (non zero) + +33e8 : 28 plp + ; decimal ADC / SBC # +33e9 : 08 php ;save carry for subtract +33ea : a50e lda ad2 +33ec : 8df233 sta chkdadi ;self modify immediate +33ef : a50d lda ad1 +33f2 = chkdadi = * + 1 ;operand of the immediate ADC +33f1 : 6900 adc #0 ;perform add +33f3 : 08 php +33f4 : c50f cmp adrl ;check result + trap_ne ;bad result +33f6 : d0fe > bne * ;failed not equal (non zero) + +33f8 : 68 pla ;check flags +33f9 : 2901 and #1 ;mask carry +33fb : c510 cmp adrh + trap_ne ;bad carry +33fd : d0fe > bne * ;failed not equal (non zero) + +33ff : 28 plp +3400 : 08 php ;save carry for next add +3401 : a512 lda sb2 +3403 : 8d0934 sta chkdsbi ;self modify immediate +3406 : a50d lda ad1 +3409 = chkdsbi = * + 1 ;operand of the immediate SBC +3408 : e900 sbc #0 ;perform subtract +340a : 08 php +340b : c50f cmp adrl ;check result + trap_ne ;bad result +340d : d0fe > bne * ;failed not equal (non zero) + +340f : 68 pla ;check flags +3410 : 2901 and #1 ;mask carry +3412 : c510 cmp adrh + trap_ne ;bad carry +3414 : d0fe > bne * ;failed not equal (non zero) + +3416 : 28 plp + ; decimal ADC / SBC zp,x +3417 : 08 php ;save carry for subtract +3418 : a50d lda ad1 +341a : 7500 adc 0,x ;perform add +341c : 08 php +341d : c50f cmp adrl ;check result + trap_ne ;bad result +341f : d0fe > bne * ;failed not equal (non zero) + +3421 : 68 pla ;check flags +3422 : 2901 and #1 ;mask carry +3424 : c510 cmp adrh + trap_ne ;bad carry +3426 : d0fe > bne * ;failed not equal (non zero) + +3428 : 28 plp +3429 : 08 php ;save carry for next add +342a : a50d lda ad1 +342c : f504 sbc sb2-ad2,x ;perform subtract +342e : 08 php +342f : c50f cmp adrl ;check result + trap_ne ;bad result +3431 : d0fe > bne * ;failed not equal (non zero) + +3433 : 68 pla ;check flags +3434 : 2901 and #1 ;mask carry +3436 : c510 cmp adrh + trap_ne ;bad carry +3438 : d0fe > bne * ;failed not equal (non zero) + +343a : 28 plp + ; decimal ADC / SBC abs,x +343b : 08 php ;save carry for subtract +343c : a50d lda ad1 +343e : 7df501 adc ada2-ad2,x ;perform add +3441 : 08 php +3442 : c50f cmp adrl ;check result + trap_ne ;bad result +3444 : d0fe > bne * ;failed not equal (non zero) + +3446 : 68 pla ;check flags +3447 : 2901 and #1 ;mask carry +3449 : c510 cmp adrh + trap_ne ;bad carry +344b : d0fe > bne * ;failed not equal (non zero) + +344d : 28 plp +344e : 08 php ;save carry for next add +344f : a50d lda ad1 +3451 : fdf601 sbc sba2-ad2,x ;perform subtract +3454 : 08 php +3455 : c50f cmp adrl ;check result + trap_ne ;bad result +3457 : d0fe > bne * ;failed not equal (non zero) + +3459 : 68 pla ;check flags +345a : 2901 and #1 ;mask carry +345c : c510 cmp adrh + trap_ne ;bad carry +345e : d0fe > bne * ;failed not equal (non zero) + +3460 : 28 plp + ; decimal ADC / SBC abs,y +3461 : 08 php ;save carry for subtract +3462 : a50d lda ad1 +3464 : 790401 adc ada2-$ff,y ;perform add +3467 : 08 php +3468 : c50f cmp adrl ;check result + trap_ne ;bad result +346a : d0fe > bne * ;failed not equal (non zero) + +346c : 68 pla ;check flags +346d : 2901 and #1 ;mask carry +346f : c510 cmp adrh + trap_ne ;bad carry +3471 : d0fe > bne * ;failed not equal (non zero) + +3473 : 28 plp +3474 : 08 php ;save carry for next add +3475 : a50d lda ad1 +3477 : f90501 sbc sba2-$ff,y ;perform subtract +347a : 08 php +347b : c50f cmp adrl ;check result + trap_ne ;bad result +347d : d0fe > bne * ;failed not equal (non zero) + +347f : 68 pla ;check flags +3480 : 2901 and #1 ;mask carry +3482 : c510 cmp adrh + trap_ne ;bad carry +3484 : d0fe > bne * ;failed not equal (non zero) + +3486 : 28 plp + ; decimal ADC / SBC (zp,x) +3487 : 08 php ;save carry for subtract +3488 : a50d lda ad1 +348a : 6144 adc (lo adi2-ad2,x) ;perform add +348c : 08 php +348d : c50f cmp adrl ;check result + trap_ne ;bad result +348f : d0fe > bne * ;failed not equal (non zero) + +3491 : 68 pla ;check flags +3492 : 2901 and #1 ;mask carry +3494 : c510 cmp adrh + trap_ne ;bad carry +3496 : d0fe > bne * ;failed not equal (non zero) + +3498 : 28 plp +3499 : 08 php ;save carry for next add +349a : a50d lda ad1 +349c : e146 sbc (lo sbi2-ad2,x) ;perform subtract +349e : 08 php +349f : c50f cmp adrl ;check result + trap_ne ;bad result +34a1 : d0fe > bne * ;failed not equal (non zero) + +34a3 : 68 pla ;check flags +34a4 : 2901 and #1 ;mask carry +34a6 : c510 cmp adrh + trap_ne ;bad carry +34a8 : d0fe > bne * ;failed not equal (non zero) + +34aa : 28 plp + ; decimal ADC / SBC (abs),y +34ab : 08 php ;save carry for subtract +34ac : a50d lda ad1 +34ae : 7156 adc (adiy2),y ;perform add +34b0 : 08 php +34b1 : c50f cmp adrl ;check result + trap_ne ;bad result +34b3 : d0fe > bne * ;failed not equal (non zero) + +34b5 : 68 pla ;check flags +34b6 : 2901 and #1 ;mask carry +34b8 : c510 cmp adrh + trap_ne ;bad carry +34ba : d0fe > bne * ;failed not equal (non zero) + +34bc : 28 plp +34bd : 08 php ;save carry for next add +34be : a50d lda ad1 +34c0 : f158 sbc (sbiy2),y ;perform subtract +34c2 : 08 php +34c3 : c50f cmp adrl ;check result + trap_ne ;bad result +34c5 : d0fe > bne * ;failed not equal (non zero) + +34c7 : 68 pla ;check flags +34c8 : 2901 and #1 ;mask carry +34ca : c510 cmp adrh + trap_ne ;bad carry +34cc : d0fe > bne * ;failed not equal (non zero) + +34ce : 28 plp +34cf : 60 rts + + ; core subroutine of the full binary add/subtract test + ; iterates through all combinations of operands and carry input + ; uses increments/decrements to predict result & result flags +34d0 : a511 chkadd lda adrf ;add V-flag if overflow +34d2 : 2983 and #$83 ;keep N-----ZC / clear V +34d4 : 48 pha +34d5 : a50d lda ad1 ;test sign unequal between operands +34d7 : 450e eor ad2 +34d9 : 300a bmi ckad1 ;no overflow possible - operands have different sign +34db : a50d lda ad1 ;test sign equal between operands and result +34dd : 450f eor adrl +34df : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign +34e1 : 68 pla +34e2 : 0940 ora #$40 ;set V +34e4 : 48 pha +34e5 : 68 ckad1 pla +34e6 : 8511 sta adrf ;save expected flags + ; binary ADC / SBC zp +34e8 : 08 php ;save carry for subtract +34e9 : a50d lda ad1 +34eb : 650e adc ad2 ;perform add +34ed : 08 php +34ee : c50f cmp adrl ;check result + trap_ne ;bad result +34f0 : d0fe > bne * ;failed not equal (non zero) + +34f2 : 68 pla ;check flags +34f3 : 29c3 and #$c3 ;mask NV----ZC +34f5 : c511 cmp adrf + trap_ne ;bad flags +34f7 : d0fe > bne * ;failed not equal (non zero) + +34f9 : 28 plp +34fa : 08 php ;save carry for next add +34fb : a50d lda ad1 +34fd : e512 sbc sb2 ;perform subtract +34ff : 08 php +3500 : c50f cmp adrl ;check result + trap_ne ;bad result +3502 : d0fe > bne * ;failed not equal (non zero) + +3504 : 68 pla ;check flags +3505 : 29c3 and #$c3 ;mask NV----ZC +3507 : c511 cmp adrf + trap_ne ;bad flags +3509 : d0fe > bne * ;failed not equal (non zero) + +350b : 28 plp + ; binary ADC / SBC abs +350c : 08 php ;save carry for subtract +350d : a50d lda ad1 +350f : 6d0302 adc ada2 ;perform add +3512 : 08 php +3513 : c50f cmp adrl ;check result + trap_ne ;bad result +3515 : d0fe > bne * ;failed not equal (non zero) + +3517 : 68 pla ;check flags +3518 : 29c3 and #$c3 ;mask NV----ZC +351a : c511 cmp adrf + trap_ne ;bad flags +351c : d0fe > bne * ;failed not equal (non zero) + +351e : 28 plp +351f : 08 php ;save carry for next add +3520 : a50d lda ad1 +3522 : ed0402 sbc sba2 ;perform subtract +3525 : 08 php +3526 : c50f cmp adrl ;check result + trap_ne ;bad result +3528 : d0fe > bne * ;failed not equal (non zero) + +352a : 68 pla ;check flags +352b : 29c3 and #$c3 ;mask NV----ZC +352d : c511 cmp adrf + trap_ne ;bad flags +352f : d0fe > bne * ;failed not equal (non zero) + +3531 : 28 plp + ; binary ADC / SBC # +3532 : 08 php ;save carry for subtract +3533 : a50e lda ad2 +3535 : 8d3b35 sta chkadi ;self modify immediate +3538 : a50d lda ad1 +353b = chkadi = * + 1 ;operand of the immediate ADC +353a : 6900 adc #0 ;perform add +353c : 08 php +353d : c50f cmp adrl ;check result + trap_ne ;bad result +353f : d0fe > bne * ;failed not equal (non zero) + +3541 : 68 pla ;check flags +3542 : 29c3 and #$c3 ;mask NV----ZC +3544 : c511 cmp adrf + trap_ne ;bad flags +3546 : d0fe > bne * ;failed not equal (non zero) + +3548 : 28 plp +3549 : 08 php ;save carry for next add +354a : a512 lda sb2 +354c : 8d5235 sta chksbi ;self modify immediate +354f : a50d lda ad1 +3552 = chksbi = * + 1 ;operand of the immediate SBC +3551 : e900 sbc #0 ;perform subtract +3553 : 08 php +3554 : c50f cmp adrl ;check result + trap_ne ;bad result +3556 : d0fe > bne * ;failed not equal (non zero) + +3558 : 68 pla ;check flags +3559 : 29c3 and #$c3 ;mask NV----ZC +355b : c511 cmp adrf + trap_ne ;bad flags +355d : d0fe > bne * ;failed not equal (non zero) + +355f : 28 plp + ; binary ADC / SBC zp,x +3560 : 08 php ;save carry for subtract +3561 : a50d lda ad1 +3563 : 7500 adc 0,x ;perform add +3565 : 08 php +3566 : c50f cmp adrl ;check result + trap_ne ;bad result +3568 : d0fe > bne * ;failed not equal (non zero) + +356a : 68 pla ;check flags +356b : 29c3 and #$c3 ;mask NV----ZC +356d : c511 cmp adrf + trap_ne ;bad flags +356f : d0fe > bne * ;failed not equal (non zero) + +3571 : 28 plp +3572 : 08 php ;save carry for next add +3573 : a50d lda ad1 +3575 : f504 sbc sb2-ad2,x ;perform subtract +3577 : 08 php +3578 : c50f cmp adrl ;check result + trap_ne ;bad result +357a : d0fe > bne * ;failed not equal (non zero) + +357c : 68 pla ;check flags +357d : 29c3 and #$c3 ;mask NV----ZC +357f : c511 cmp adrf + trap_ne ;bad flags +3581 : d0fe > bne * ;failed not equal (non zero) + +3583 : 28 plp + ; binary ADC / SBC abs,x +3584 : 08 php ;save carry for subtract +3585 : a50d lda ad1 +3587 : 7df501 adc ada2-ad2,x ;perform add +358a : 08 php +358b : c50f cmp adrl ;check result + trap_ne ;bad result +358d : d0fe > bne * ;failed not equal (non zero) + +358f : 68 pla ;check flags +3590 : 29c3 and #$c3 ;mask NV----ZC +3592 : c511 cmp adrf + trap_ne ;bad flags +3594 : d0fe > bne * ;failed not equal (non zero) + +3596 : 28 plp +3597 : 08 php ;save carry for next add +3598 : a50d lda ad1 +359a : fdf601 sbc sba2-ad2,x ;perform subtract +359d : 08 php +359e : c50f cmp adrl ;check result + trap_ne ;bad result +35a0 : d0fe > bne * ;failed not equal (non zero) + +35a2 : 68 pla ;check flags +35a3 : 29c3 and #$c3 ;mask NV----ZC +35a5 : c511 cmp adrf + trap_ne ;bad flags +35a7 : d0fe > bne * ;failed not equal (non zero) + +35a9 : 28 plp + ; binary ADC / SBC abs,y +35aa : 08 php ;save carry for subtract +35ab : a50d lda ad1 +35ad : 790401 adc ada2-$ff,y ;perform add +35b0 : 08 php +35b1 : c50f cmp adrl ;check result + trap_ne ;bad result +35b3 : d0fe > bne * ;failed not equal (non zero) + +35b5 : 68 pla ;check flags +35b6 : 29c3 and #$c3 ;mask NV----ZC +35b8 : c511 cmp adrf + trap_ne ;bad flags +35ba : d0fe > bne * ;failed not equal (non zero) + +35bc : 28 plp +35bd : 08 php ;save carry for next add +35be : a50d lda ad1 +35c0 : f90501 sbc sba2-$ff,y ;perform subtract +35c3 : 08 php +35c4 : c50f cmp adrl ;check result + trap_ne ;bad result +35c6 : d0fe > bne * ;failed not equal (non zero) + +35c8 : 68 pla ;check flags +35c9 : 29c3 and #$c3 ;mask NV----ZC +35cb : c511 cmp adrf + trap_ne ;bad flags +35cd : d0fe > bne * ;failed not equal (non zero) + +35cf : 28 plp + ; binary ADC / SBC (zp,x) +35d0 : 08 php ;save carry for subtract +35d1 : a50d lda ad1 +35d3 : 6144 adc (lo adi2-ad2,x) ;perform add +35d5 : 08 php +35d6 : c50f cmp adrl ;check result + trap_ne ;bad result +35d8 : d0fe > bne * ;failed not equal (non zero) + +35da : 68 pla ;check flags +35db : 29c3 and #$c3 ;mask NV----ZC +35dd : c511 cmp adrf + trap_ne ;bad flags +35df : d0fe > bne * ;failed not equal (non zero) + +35e1 : 28 plp +35e2 : 08 php ;save carry for next add +35e3 : a50d lda ad1 +35e5 : e146 sbc (lo sbi2-ad2,x) ;perform subtract +35e7 : 08 php +35e8 : c50f cmp adrl ;check result + trap_ne ;bad result +35ea : d0fe > bne * ;failed not equal (non zero) + +35ec : 68 pla ;check flags +35ed : 29c3 and #$c3 ;mask NV----ZC +35ef : c511 cmp adrf + trap_ne ;bad flags +35f1 : d0fe > bne * ;failed not equal (non zero) + +35f3 : 28 plp + ; binary ADC / SBC (abs),y +35f4 : 08 php ;save carry for subtract +35f5 : a50d lda ad1 +35f7 : 7156 adc (adiy2),y ;perform add +35f9 : 08 php +35fa : c50f cmp adrl ;check result + trap_ne ;bad result +35fc : d0fe > bne * ;failed not equal (non zero) + +35fe : 68 pla ;check flags +35ff : 29c3 and #$c3 ;mask NV----ZC +3601 : c511 cmp adrf + trap_ne ;bad flags +3603 : d0fe > bne * ;failed not equal (non zero) + +3605 : 28 plp +3606 : 08 php ;save carry for next add +3607 : a50d lda ad1 +3609 : f158 sbc (sbiy2),y ;perform subtract +360b : 08 php +360c : c50f cmp adrl ;check result + trap_ne ;bad result +360e : d0fe > bne * ;failed not equal (non zero) + +3610 : 68 pla ;check flags +3611 : 29c3 and #$c3 ;mask NV----ZC +3613 : c511 cmp adrf + trap_ne ;bad flags +3615 : d0fe > bne * ;failed not equal (non zero) + +3617 : 28 plp +3618 : 60 rts + + ; target for the jump absolute test +3619 : 88 dey +361a : 88 dey +361b : test_far +361b : 08 php ;either SP or Y count will fail, if we do not hit +361c : 88 dey +361d : 88 dey +361e : 88 dey +361f : 28 plp + trap_cs ;flags loaded? +3620 : b0fe > bcs * ;failed carry set + + trap_vs +3622 : 70fe > bvs * ;failed overflow set + + trap_mi +3624 : 30fe > bmi * ;failed minus (bit 7 set) + + trap_eq +3626 : f0fe > beq * ;failed equal (zero) + +3628 : c946 cmp #'F' ;registers loaded? + trap_ne +362a : d0fe > bne * ;failed not equal (non zero) + +362c : e041 cpx #'A' + trap_ne +362e : d0fe > bne * ;failed not equal (non zero) + +3630 : c04f cpy #('R'-3) + trap_ne +3632 : d0fe > bne * ;failed not equal (non zero) + +3634 : 48 pha ;save a,x +3635 : 8a txa +3636 : 48 pha +3637 : ba tsx +3638 : e0fd cpx #$fd ;check SP + trap_ne +363a : d0fe > bne * ;failed not equal (non zero) + +363c : 68 pla ;restore x +363d : aa tax + set_stat $ff + > load_flag $ff +363e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +3640 : 48 > pha ;use stack to load status +3641 : 28 > plp + +3642 : 68 pla ;restore a +3643 : e8 inx ;return registers with modifications +3644 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 +3646 : 4cc208 jmp far_ret + + ; target for the jump indirect test +3649 : 00 align +364a : 5336 ptr_tst_ind dw test_ind +364c : 1709 ptr_ind_ret dw ind_ret + trap ;runover protection +364e : 4c4e36 > jmp * ;failed anyway + +3651 : 88 dey +3652 : 88 dey +3653 : test_ind +3653 : 08 php ;either SP or Y count will fail, if we do not hit +3654 : 88 dey +3655 : 88 dey +3656 : 88 dey +3657 : 28 plp + trap_cs ;flags loaded? +3658 : b0fe > bcs * ;failed carry set + + trap_vs +365a : 70fe > bvs * ;failed overflow set + + trap_mi +365c : 30fe > bmi * ;failed minus (bit 7 set) + + trap_eq +365e : f0fe > beq * ;failed equal (zero) + +3660 : c949 cmp #'I' ;registers loaded? + trap_ne +3662 : d0fe > bne * ;failed not equal (non zero) + +3664 : e04e cpx #'N' + trap_ne +3666 : d0fe > bne * ;failed not equal (non zero) + +3668 : c041 cpy #('D'-3) + trap_ne +366a : d0fe > bne * ;failed not equal (non zero) + +366c : 48 pha ;save a,x +366d : 8a txa +366e : 48 pha +366f : ba tsx +3670 : e0fd cpx #$fd ;check SP + trap_ne +3672 : d0fe > bne * ;failed not equal (non zero) + +3674 : 68 pla ;restore x +3675 : aa tax + set_stat $ff + > load_flag $ff +3676 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +3678 : 48 > pha ;use stack to load status +3679 : 28 > plp + +367a : 68 pla ;restore a +367b : e8 inx ;return registers with modifications +367c : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 +367e : 6c4c36 jmp (ptr_ind_ret) + trap ;runover protection +3681 : 4c8136 > jmp * ;failed anyway + + + ; target for the jump subroutine test +3684 : 88 dey +3685 : 88 dey +3686 : test_jsr +3686 : 08 php ;either SP or Y count will fail, if we do not hit +3687 : 88 dey +3688 : 88 dey +3689 : 88 dey +368a : 28 plp + trap_cs ;flags loaded? +368b : b0fe > bcs * ;failed carry set + + trap_vs +368d : 70fe > bvs * ;failed overflow set + + trap_mi +368f : 30fe > bmi * ;failed minus (bit 7 set) + + trap_eq +3691 : f0fe > beq * ;failed equal (zero) + +3693 : c94a cmp #'J' ;registers loaded? + trap_ne +3695 : d0fe > bne * ;failed not equal (non zero) + +3697 : e053 cpx #'S' + trap_ne +3699 : d0fe > bne * ;failed not equal (non zero) + +369b : c04f cpy #('R'-3) + trap_ne +369d : d0fe > bne * ;failed not equal (non zero) + +369f : 48 pha ;save a,x +36a0 : 8a txa +36a1 : 48 pha +36a2 : ba tsx ;sp -4? (return addr,a,x) +36a3 : e0fb cpx #$fb + trap_ne +36a5 : d0fe > bne * ;failed not equal (non zero) + +36a7 : adff01 lda $1ff ;propper return on stack +36aa : c909 cmp #hi(jsr_ret) + trap_ne +36ac : d0fe > bne * ;failed not equal (non zero) + +36ae : adfe01 lda $1fe +36b1 : c94d cmp #lo(jsr_ret) + trap_ne +36b3 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +36b5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +36b7 : 48 > pha ;use stack to load status +36b8 : 28 > plp + +36b9 : 68 pla ;pull x,a +36ba : aa tax +36bb : 68 pla +36bc : e8 inx ;return registers with modifications +36bd : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 +36bf : 60 rts + trap ;runover protection +36c0 : 4cc036 > jmp * ;failed anyway + + + ;trap in case of unexpected IRQ, NMI, BRK, RESET - BRK test target +36c3 : nmi_trap + trap ;check stack for conditions at NMI +36c3 : 4cc336 > jmp * ;failed anyway + +36c6 : res_trap + trap ;unexpected RESET +36c6 : 4cc636 > jmp * ;failed anyway + + +36c9 : 88 dey +36ca : 88 dey +36cb : irq_trap ;BRK test or unextpected BRK or IRQ +36cb : 08 php ;either SP or Y count will fail, if we do not hit +36cc : 88 dey +36cd : 88 dey +36ce : 88 dey + ;next 4 traps could be caused by unexpected BRK or IRQ + ;check stack for BREAK and originating location + ;possible jump/branch into weeds (uninitialized space) +36cf : c942 cmp #'B' ;registers loaded? + trap_ne +36d1 : d0fe > bne * ;failed not equal (non zero) + +36d3 : e052 cpx #'R' + trap_ne +36d5 : d0fe > bne * ;failed not equal (non zero) + +36d7 : c048 cpy #('K'-3) + trap_ne +36d9 : d0fe > bne * ;failed not equal (non zero) + +36db : 850a sta irq_a ;save registers during break test +36dd : 860b stx irq_x +36df : ba tsx ;test break on stack +36e0 : bd0201 lda $102,x + cmp_flag 0 ;break test should have B=1 +36e3 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits + + trap_ne ; - no break flag on stack +36e5 : d0fe > bne * ;failed not equal (non zero) + +36e7 : 68 pla +36e8 : c934 cmp #fai ;should have added interrupt disable + trap_ne +36ea : d0fe > bne * ;failed not equal (non zero) + +36ec : ba tsx +36ed : e0fc cpx #$fc ;sp -3? (return addr, flags) + trap_ne +36ef : d0fe > bne * ;failed not equal (non zero) + +36f1 : adff01 lda $1ff ;propper return on stack +36f4 : c909 cmp #hi(brk_ret) + trap_ne +36f6 : d0fe > bne * ;failed not equal (non zero) + +36f8 : adfe01 lda $1fe +36fb : c984 cmp #lo(brk_ret) + trap_ne +36fd : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +36ff : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +3701 : 48 > pha ;use stack to load status +3702 : 28 > plp + +3703 : a60b ldx irq_x +3705 : e8 inx ;return registers with modifications +3706 : a50a lda irq_a +3708 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 but original flags should be restored +370a : 40 rti + trap ;runover protection +370b : 4c0b37 > jmp * ;failed anyway + + + 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 + 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 : c336 dw nmi_trap +fffc : c636 dw res_trap +fffe : cb36 dw irq_trap + endif + +fffa = end start + +No errors in pass 2. +Wrote binary from address $0000 through $ffff. +Total size 65536 bytes. +Program start address is at $0400 (1024). + \ No newline at end of file diff --git a/bin_files/65C02_extended_opcodes_test.bin b/bin_files/65C02_extended_opcodes_test.bin new file mode 100644 index 0000000000000000000000000000000000000000..de99bc47273d0d03a0e3bf10bfe717ebdcf07abe GIT binary patch literal 65536 zcmeI2dvH|M9mnsU?BnL{CcC_ZQ5-UW;ZU4H!H)Rk4N1L%3aCY9@R8zL>7dnW6+)Ir zN>C|nwFN4aoyAp`hcIfjf;5pxNHT~!l@Vo7;-e9fmZ&($Yq!7OJ@?+d=jJB;r!%e7 zUozYzzjHp{d(P)R_U>5}#r4&=WSml?47fiL&DSLI(N(K77G@Dv!b(|BUw{Q!h^ef^ zH;#>G6WByHiA`oxSOvR=UCYL>u?%|zeIZ|-zP=L%3P;~K@QH-Ne&t`HEDtR8-7&6A z`RI*gVzDp5;Gg1Cd~9)IaRN>Y_&t$eit{v4z8s)*;FLQ$q6(ZkETJU669)dj2l-wq z|Hq87lCiCfwJ6zK#s|M=)k@E3FY8#Z|6)lj%GfG8D!4eDs zN+YlYz4BOsc1JGge3CvsOKp&5om8+S%{rOKk~C{4XwJt8nzMF-g~*v z7nGz~Cv#YmW)1N+XwKRRnzMF-xW_g)J8;%TFl#@~dU0|Q%sZp-M3Mf}po(W$;aFz! zSY8ZeFbmNTm27B>*W&C21Iqqp_(~KRTV`y1##X^? zgO<%Dde*^Lq7*mZz`s*Gd8dX6vDl{((CMPsj6C3PeCxovC_2?K~s1wM^9q zL8~+)IFmAdD`mJA+y*HXs(zhEirG3>)$ehq;Nd-Mr9cF9)qkz(zx7BlTeqnCHh0Qd zNKvhnF*!+rDrl9woPv~? zl`>5Wz6~k27wdOoby6Vps>lu#}v-QnleXl#^1f-N%DRZ>o z5lA^+te@~mFHve-zfQ_ee2Y<6-??cM9A^+j_wLZlJi|1tBy9_nnM_ z$x)3}`Ub#;4Tp_?3~bbCu!+rqP1$_djIDu9ViMfuGWk{Tt8W8r*f!Ys>tUn54V%~z z*p!`s&DcC_jNa{9Hi`GS5P&M|FF8KNSaWMD{0Vou^PC+!rnbN}9=BhJGtZ0S^Y(qM zVLXf-ZkfmqwAl~%Kx99V*g8?H^JK@{>@GeY*KepM6`Nzm!EV0d^*zCzpwAr0}BC}Ea#+07Drvnbx|$sVxTVf+BH!zA`yQGC~vJ!!LHeiGTR#J(bmuXwS( z+0D)7Ik}O~Ms}mbP8G$ep6p?p9mEeKJ4j;pi{gGy_MFWY@pH(+Lr1)DExaI#FL<#< zMXlC#bdDDxdro4X6UFB|*q4vw}(aXVNZ5~&A!ejAp5$s-@8TeZclc)&2Hh-k=-J(w}|2`p6p#VyN=(5 z>^g~^B8pQy*#~U)3H|`GPe|OK9%4Xl>S0VeR#LgGR z`JU``Hv2Na4%wF_c8(~{@nmna*=P7|$UY;n(?oHaCws5WKE>}v_9=-SBZ^}@*#$Pc zj4wcTnZynk#o?ap<2L&se;nBdC3b))4)A23w%IEFG_q9^8x_T??iT@#GVkv6Q1lBHrtzjfoyMytrx|5Pxh?M`uSO8{Sv!P6t{I^@!3*^ zhsk1iwoDc68e6{pJZp`e$_!blz_V=y&s3(SCMV82&yHntb#*GdH|HI>SnfBu8*(k5 zz+>e!cqG0SSDioyW)(x0hFRfVkCd-JEoa@D@+T`7p7zT63bNptx?zHu1rNJQQKs)o zUlA-Tz);{fmdY>mF+I>1_k$18Vc5^N$}#*Co>Vds-0ha+VSF9T@e3=grHb?L+8D<_ z;So4q(NbgmSy)4fUn#fZpW^Tu?3MVa?M&QmMTkUPk1}>367jXzk!Z9Q5)HO(3rzK} zLmS-nG9@_vwaK}t{l$T5Wh4LH_hH-82*a)%@m3Vq1F&hZ(KG^^mWZa9)l_aYjl`yL zqN#_~#EquQun9*EfjyzA4HoJ7i8-~Y@N#1 z6*K2Pb_Kv&YwTOxNr5u<(upeU%1OyHc~Envx5hqC`5oi3`x-mIzJ*M8-@<5&Is7Rg zjk`5=H05^=qtM;RHo7~*9o-uiIL_cwI4n^-EaOu}c)jHLWj(B`2rq$FEc%S1xJ>Tz zD!%Ad?0_O304I$X=23UC-m6$`6`dm*gOSE4uhzhaxY!-TG^(A(>8Lse>Zle*>L@yf z>Zm%#>Zm#fYgEO+3Zq@2cno&MI29Kz;cUm#*A%^CiB)t=Yel0~#GXQ5q2?H9frb%S zq6_=6d**pzMA)+p-hScZj(xSlD{Ll)H@1ePQWahUi!K@}gXE8Gl$xyZjZj9-YJz6&RM1YA-{ow@evKJ&N?j)E$>{CuMI!Q_H zUe=iW-eW42#uVvdOhzwjOwJ_7-s~h}Oj44&S98|i9_}d8clU2=a5#>E;~waEM>3nq zi8Rn-4X}-E!7F#72 zUdpW1{xpBCTNYa-7M?q;)%i4kwObZjB^Dn<&DHcY-`g#VtrCkDfw}sf<_EiFu~lNr zfHhaE)BLk;S!|WqvA~+E%V~b9TNYa-HUSS{JK%Pi7xRb7t@sL+;D7s` z+5$b}6)iu&n>N&Hj2fIdP=lp?qqfMX!KZOh+m1CjEu1XAvS7{0LV{6qvge@I_8|;v zt7A|-VNktrP~($IdUUOpzM?h^19|Ow#z$)E`!nH$fhWrMe+)m{wPyIR?&G>9Jf-Ch z)kcRVtuFQ{#K7f}9w%aMWc;RXW26ppOa;VLikM2qdv+Tmb#TPAIbX4Q!CZU8TyK3Z z6-nmt3abs*Mpgz`ZAon@+$3WwgADG5(SBt`smM+PvO{JN&kkxZ&G#hCuaem|Oa3uYpZ@ZQbcl0s(gqs}SIvWglI34M@ z0vh`@MGD{TvBGy#q&=3#{ienIF}m1S8*MLz0BIKQZG|^seP9|LFb)0r!MfsC)8U^) z)IIRH9v`}N4?G8OsQf+VuKWyNI^|CP2)av=mA*^T;d>NU&)CX-Q2yLq4*#N4{L1(>QuU8qC4uN$?nSiGu)LgZ+2IHeuKO6)lE|6_H=aUQh2_Z z6d3_Wc2Y^qA1@wT5wDGcS{rV(WZST)+&;N{$pz+n`0cs-awBpbxt2<}1;MI(1H4_V zc&x(s&m-|oaOLv&(aKHp^6c0#{h{(*@V&fz{{{Hd9dIiIz&*cVa_0a@z&HEH^uLrJ zgD<_lT;E-;?|(y5u?{#f;EvDZEq&n}!HwRxZ{hzq{qOx|Ok&xP|H#0Mtn85g z@Bh$5vnK;&fDDiUGC&5%02v?yWPl8i0Wv@a$N(8217v^fDDiUGC&5%02v?yWPl8i0Wv@a$N(8217v^fDDiUGC&5%02v?yWPl8i0Wv@a$N(8217v^fDDiUGC&5%02v?yWPl8i0Wv@a$N(8217v^fDDiUGC&5%02v?yWPl8i0Wv@a$N(8217v^fDDiUGC&5%02v?yWPl8i0Wv@a$N(8217v^fDDiUGC&5%02v?yWPl8i0Wv@a$N(8217v^. + + + ; This program is designed to test all additional 65C02 opcodes, addressing + ; modes and functionality not available in the NMOS version of the 6502. + ; The 6502_functional_test is a prerequisite to this test. + ; NMI, IRQ, BRK, STP & WAI are covered in the 6502_interrupt_test. + ; + ; version 16-aug-2013 + ; edited to provide a pre-configured bin file loadable at $0000 for full 64k + ; contact info at http://2m5.de or email K@2m5.de + ; + ; assembled with AS65 from http://www.kingswood-consulting.co.uk/assemblers/ + ; command line switches: -l -m -s2 -w -x -h0 + ; | | | | | no page headers in listing + ; | | | | 65C02 extensions + ; | | | wide listing (133 char/col) + ; | | write intel hex file instead of binary + ; | expand macros in listing + ; generate pass2 listing + ; + ; No IO - should be run from a monitor with access to registers. + ; To run load intel hex image with a load command, than alter PC to 400 hex + ; (code_segment) and enter a go command. + ; Loop on program counter determines error or successful completion of test. + ; Check listing for relevant traps (jump/branch *). + ; Please note that in early tests some instructions will have to be used before + ; they are actually tested! + ; + ; RESET, NMI or IRQ should not occur and will be trapped if vectors are enabled. + ; Tests documented behavior of the original 65C02 only! + ; Decimal ops will only be tested with valid BCD operands and the V flag will + ; be ignored as it is absolutely useless in decimal mode. + ; + ; Debugging hints: + ; Most of the code is written sequentially. if you hit a trap, check the + ; immediately preceeding code for the instruction to be tested. Results are + ; tested first, flags are checked second by pushing them onto the stack and + ; pulling them to the accumulator after the result was checked. The "real" + ; flags are no longer valid for the tested instruction at this time! + ; If the tested instruction was indexed, the relevant index (X or Y) must + ; also be checked. Opposed to the flags, X and Y registers are still valid. + ; + ; versions: + ; 19-jul-2013 1st version distributed for testing + ; 23-jul-2013 fixed BRA out of range due to larger trap macros + ; added RAM integrity check + ; 16-aug-2013 added error report to standard output option + + + ; C O N F I G U R A T I O N + + ;ROM_vectors writable (0=no, 1=yes) + ;if ROM vectors can not be used interrupts will not be trapped + ;as a consequence BRK can not be tested but will be emulated to test RTI +0001 = ROM_vectors = 1 + + ;load_data_direct (0=move from code segment, 1=load directly) + ;loading directly is preferred but may not be supported by your platform + ;0 produces only consecutive object code, 1 is not suitable for a binary image +0001 = load_data_direct = 1 + + ;I_flag behavior (0=force enabled, 1=force disabled, 2=prohibit change, 3=allow + ;change) 2 requires extra code and is not recommended. +0003 = I_flag = 3 + + ;configure memory - try to stay away from memory used by the system + ;zero_page memory start address, $4e (78) consecutive Bytes required + ; add 2 if I_flag = 2 +000a = zero_page = $a + + ;data_segment memory start address, $5D (93) consecutive Bytes required + ; + 12 Bytes at data_segment + $f9 (JMP indirect page cross test) +0200 = data_segment = $200 + if (data_segment & $ff) != 0 + ERROR ERROR ERROR low byte of data_segment MUST be $00 !! + endif + + ;code_segment memory start address, 10kB of consecutive space required + ; add 1 kB if I_flag = 2 + ;parts of the code are self modifying and must reside in RAM +0400 = code_segment = $400 + + ;added WDC only opcodes WAI & STP (0=test as NOPs, >0=no test) +0001 = wdc_op = 1 + + ;added Rockwell & WDC opcodes BBR, BBS, RMB & SMB + ;(0=test as NOPs, 1=full test, >1=no test) +0001 = rkwl_wdc_op = 1 + + ;report errors through I/O channel (0=use standard self trap loops, 1=include + ;report.i65 as I/O channel, add 3 kB) +0000 = report = 0 + + ;RAM integrity test option. Checks for undesired RAM writes. + ;set lowest non RAM or RAM mirror address page (-1=disable, 0=64k, $40=16k) + ;leave disabled if a monitor, OS or background interrupt is allowed to alter RAM +ffff = ram_top = -1 + + noopt ;do not take shortcuts + + ;macros for error & success traps to allow user modification + ;example: + ;trap macro + ; jsr my_error_handler + ; endm + ;trap_eq macro + ; bne skip\? + ; trap ;failed equal (zero) + ;skip\? + ; endm + ; + ; my_error_handler should pop the calling address from the stack and report it. + ; putting larger portions of code (more than 3 bytes) inside the trap macro + ; may lead to branch range problems for some tests. + if report = 0 + trap macro + jmp * ;failed anyway + endm + trap_eq macro + beq * ;failed equal (zero) + endm + trap_ne macro + bne * ;failed not equal (non zero) + endm + trap_cs macro + bcs * ;failed carry set + endm + trap_cc macro + bcc * ;failed carry clear + endm + trap_mi macro + bmi * ;failed minus (bit 7 set) + endm + trap_pl macro + bpl * ;failed plus (bit 7 clear) + endm + trap_vs macro + bvs * ;failed overflow set + endm + trap_vc macro + bvc * ;failed overflow clear + endm + ; please observe that during the test the stack gets invalidated + ; therefore a RTS inside the success macro is not possible + success macro + jmp * ;test passed, no errors + endm + endif + if report = 1 + trap macro + jsr report_error + endm + trap_eq macro + bne skip\? + trap ;failed equal (zero) + skip\? + endm + trap_ne macro + beq skip\? + trap ;failed not equal (non zero) + skip\? + endm + trap_cs macro + bcc skip\? + trap ;failed carry set + skip\? + endm + trap_cc macro + bcs skip\? + trap ;failed carry clear + skip\? + endm + trap_mi macro + bpl skip\? + trap ;failed minus (bit 7 set) + skip\? + endm + trap_pl macro + bmi skip\? + trap ;failed plus (bit 7 clear) + skip\? + endm + trap_vs macro + bvc skip\? + trap ;failed overflow set + skip\? + endm + trap_vc macro + bvs skip\? + trap ;failed overflow clear + skip\? + endm + ; please observe that during the test the stack gets invalidated + ; therefore a RTS inside the success macro is not possible + success macro + jsr report_success + endm + endif + + +0001 = carry equ %00000001 ;flag bits in status +0002 = zero equ %00000010 +0004 = intdis equ %00000100 +0008 = decmode equ %00001000 +0010 = break equ %00010000 +0020 = reserv equ %00100000 +0040 = overfl equ %01000000 +0080 = minus equ %10000000 + +0001 = fc equ carry +0002 = fz equ zero +0003 = fzc equ carry+zero +0040 = fv equ overfl +0042 = fvz equ overfl+zero +0080 = fn equ minus +0081 = fnc equ minus+carry +0082 = fnz equ minus+zero +0083 = fnzc equ minus+zero+carry +00c0 = fnv equ minus+overfl + +0030 = fao equ break+reserv ;bits always on after PHP, BRK +0034 = fai equ fao+intdis ;+ forced interrupt disable +00ff = m8 equ $ff ;8 bit mask +00fb = m8i equ $ff&~intdis ;8 bit mask - interrupt disable + + ;macros to allow masking of status bits. + ;masking of interrupt enable/disable on load and compare + ;masking of always on bits after PHP or BRK (unused & break) on compare + if I_flag = 0 + load_flag macro + lda #\1&m8i ;force enable interrupts (mask I) + endm + cmp_flag macro + cmp #(\1|fao)&m8i ;I_flag is always enabled + always on bits + endm + eor_flag macro + eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits + endm + endif + if I_flag = 1 + load_flag macro + lda #\1|intdis ;force disable interrupts + endm + cmp_flag macro + cmp #(\1|fai)&m8 ;I_flag is always disabled + always on bits + endm + eor_flag macro + eor #(\1|fai) ;invert expected flags + always on bits + I + endm + endif + if I_flag = 2 + load_flag macro + lda #\1 + ora flag_I_on ;restore I-flag + and flag_I_off + endm + cmp_flag macro + eor flag_I_on ;I_flag is never changed + cmp #(\1|fao)&m8i ;expected flags + always on bits, mask I + endm + eor_flag macro + eor flag_I_on ;I_flag is never changed + eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits + endm + endif + if I_flag = 3 + load_flag macro + lda #\1 ;allow test to change I-flag (no mask) + endm + cmp_flag macro + cmp #(\1|fao)&m8 ;expected flags + always on bits + endm + eor_flag macro + eor #\1|fao ;invert expected flags + always on bits + endm + endif + + ;macros to set (register|memory|zeropage) & status + set_stat macro ;setting flags in the processor status register + load_flag \1 + pha ;use stack to load status + plp + endm + + set_a macro ;precharging accu & status + load_flag \2 + pha ;use stack to load status + lda #\1 ;precharge accu + plp + endm + + set_x macro ;precharging index & status + load_flag \2 + pha ;use stack to load status + ldx #\1 ;precharge index x + plp + endm + + set_y macro ;precharging index & status + load_flag \2 + pha ;use stack to load status + ldy #\1 ;precharge index y + plp + endm + + set_ax macro ;precharging indexed accu & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,x ;precharge accu + plp + endm + + set_ay macro ;precharging indexed accu & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,y ;precharge accu + plp + endm + + set_z macro ;precharging indexed zp & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,x ;load to zeropage + sta zpt + plp + endm + + set_zx macro ;precharging zp,x & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,x ;load to indexed zeropage + sta zpt,x + plp + endm + + set_abs macro ;precharging indexed memory & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,x ;load to memory + sta abst + plp + endm + + set_absx macro ;precharging abs,x & immediate status + load_flag \2 + pha ;use stack to load status + lda \1,x ;load to indexed memory + sta abst,x + plp + endm + + ;macros to test (register|memory|zeropage) & status & (mask) + tst_stat macro ;testing flags in the processor status register + php ;save status + pla ;use stack to retrieve status + pha + cmp_flag \1 + trap_ne + plp ;restore status + endm + + tst_a macro ;testing result in accu & flags + php ;save flags + cmp #\1 ;test result + trap_ne + pla ;load status + pha + cmp_flag \2 + trap_ne + plp ;restore status + endm + + tst_as macro ;testing result in accu & flags, save accu + pha + php ;save flags + cmp #\1 ;test result + trap_ne + pla ;load status + pha + cmp_flag \2 + trap_ne + plp ;restore status + pla + endm + + tst_x macro ;testing result in x index & flags + php ;save flags + cpx #\1 ;test result + trap_ne + pla ;load status + pha + cmp_flag \2 + trap_ne + plp ;restore status + endm + + tst_y macro ;testing result in y index & flags + php ;save flags + cpy #\1 ;test result + trap_ne + pla ;load status + pha + cmp_flag \2 + trap_ne + plp ;restore status + endm + + tst_ax macro ;indexed testing result in accu & flags + php ;save flags + cmp \1,x ;test result + trap_ne + pla ;load status + eor_flag \3 + cmp \2,x ;test flags + trap_ne ; + endm + + tst_ay macro ;indexed testing result in accu & flags + php ;save flags + cmp \1,y ;test result + trap_ne ; + pla ;load status + eor_flag \3 + cmp \2,y ;test flags + trap_ne + endm + + tst_z macro ;indexed testing result in zp & flags + php ;save flags + lda zpt + cmp \1,x ;test result + trap_ne + pla ;load status + eor_flag \3 + cmp \2,x ;test flags + trap_ne + endm + + tst_zx macro ;testing result in zp,x & flags + php ;save flags + lda zpt,x + cmp \1,x ;test result + trap_ne + pla ;load status + eor_flag \3 + cmp \2,x ;test flags + trap_ne + endm + + tst_abs macro ;indexed testing result in memory & flags + php ;save flags + lda abst + cmp \1,x ;test result + trap_ne + pla ;load status + eor_flag \3 + cmp \2,x ;test flags + trap_ne + endm + + tst_absx macro ;testing result in abs,x & flags + php ;save flags + lda abst,x + cmp \1,x ;test result + trap_ne + pla ;load status + eor_flag \3 + cmp \2,x ;test flags + trap_ne + endm + + ; RAM integrity test + ; verifies that none of the previous tests has altered RAM outside of the + ; designated write areas. + ; uses zpt word as indirect pointer, zpt+2 word as checksum + if ram_top > -1 + check_ram macro + cld + lda #0 + sta zpt ;set low byte of indirect pointer + sta zpt+3 ;checksum high byte + ldx #11 ;reset modifiable RAM + ccs1\? sta jxi_tab,x ;JMP indirect page cross area + dex + bpl ccs1\? + sta chkdadi ;self modifying code + sta chkdsbi + 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(data_segment) ;set high byte of indirect pointer + stx zpt+1 + ldy #lo(data_bss) ;data after write test area + ccs5\? adc (zpt),y + bcc ccs4\? + inc zpt+3 ;carry to high byte + clc + ccs4\? iny + bne ccs5\? + inx ;advance RAM high address + stx zpt+1 + cpx #ram_top + bne ccs5\? + sta zpt+2 ;checksum low is + cmp ram_chksm ;checksum low expected + trap_ne ;checksum mismatch + lda zpt+3 ;checksum high is + cmp ram_chksm+1 ;checksum high expected + trap_ne ;checksum mismatch + endm + else + check_ram macro + ;RAM check disabled - RAM size not set + endm + endif + + next_test macro ;make sure, tests don't jump the fence + lda test_case ;previous test + cmp #test_num + trap_ne ;test is out of sequence + test_num = test_num + 1 + lda #test_num ;*** next tests' number + sta test_case + ;check_ram ;uncomment to find altered RAM after each test + endm + + if load_data_direct = 1 + data + else + bss ;uninitialized segment, copy of data at end of code! + endif + ; org zero_page +0000 = org 0 ;edited to provide binaries loading from 0 +0000 : 00000000000000.. ds zero_page + 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 +000a : zpt ;5 bytes store/modify test area + ;add/subtract operand generation and result/flag prediction +000a : 00 adfc ds 1 ;carry flag before op +000b : 00 ad1 ds 1 ;operand 1 - accumulator +000c : 00 ad2 ds 1 ;operand 2 - memory / immediate +000d : 00 adrl ds 1 ;expected result bits 0-7 +000e : 00 adrh ds 1 ;expected result bit 8 (carry) +000f : 00 adrf ds 1 ;expected flags NV0000ZC (-V in decimal mode) +0010 : 00 sb2 ds 1 ;operand 2 complemented for subtract +0011 : zp_bss +0011 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR +0015 : 7f zp7f db $7f ;test pattern for compare + ;logical zeropage operands +0016 : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR +001a : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND +001e : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR + ;indirect addressing pointers +0022 : 0a02 ind1 dw abs1 ;indirect pointer to pattern in absolute memory +0024 : 0b02 dw abs1+1 +0026 : 0c02 dw abs1+2 +0028 : 0d02 dw abs1+3 +002a : 0e02 dw abs7f +002c : 1201 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern +002e : 0502 indt dw abst ;indirect pointer to store area in absolute memory +0030 : 0602 dw abst+1 +0032 : 0702 dw abst+2 +0034 : 0802 dw abst+3 +0036 : 0d01 inwt dw abst-$f8 ;indirect pointer for wrap-test store +0038 : 4102 indAN dw absAN ;indirect pointer to AND pattern in absolute memory +003a : 4202 dw absAN+1 +003c : 4302 dw absAN+2 +003e : 4402 dw absAN+3 +0040 : 4502 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory +0042 : 4602 dw absEO+1 +0044 : 4702 dw absEO+2 +0046 : 4802 dw absEO+3 +0048 : 3d02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory +004a : 3e02 dw absOR+1 +004c : 3f02 dw absOR+2 +004e : 4002 dw absOR+3 + ;add/subtract indirect pointers +0050 : 0502 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory +0052 : 0602 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC) +0054 : 0601 adiy2 dw ada2-$ff ;with offset for indirect indexed +0056 : 0701 sbiy2 dw sba2-$ff +0058 : zp_bss_end + +0200 = org data_segment +0200 : 0000 pg_x ds 2 ;high JMP indirect address for page cross bug +0202 : 00 test_case ds 1 ;current test number +0203 : 0000 ram_chksm ds 2 ;checksum for RAM integrity test + ;add/subtract operand copy - abs tests write area +0205 : abst ;5 bytes store/modify test area +0205 : 00 ada2 ds 1 ;operand 2 +0206 : 00 sba2 ds 1 ;operand 2 complemented for subtract +0207 : 000000 ds 3 ;fill remaining bytes +020a : data_bss +020a : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR +020e : 7f abs7f db $7f ;test pattern for compare + ;loads +020f : 80800002 fLDx db fn,fn,0,fz ;expected flags for load + ;shifts +0213 : rASL ;expected result ASL & ROL -carry +0213 : 86048200 rROL db $86,$04,$82,0 ; " +0217 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry +021b : rLSR ;expected result LSR & ROR -carry +021b : 61412000 rROR db $61,$41,$20,0 ; " +021f : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carry +0223 : fASL ;expected flags for shifts +0223 : 81018002 fROL db fnc,fc,fn,fz ;no carry in +0227 : 81018000 fROLc db fnc,fc,fn,0 ;carry in +022b : fLSR +022b : 01000102 fROR db fc,0,fc,fz ;no carry in +022f : 81808180 fRORc db fnc,fn,fnc,fn ;carry in + ;increments (decrements) +0233 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC +0238 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC + ;logical memory operand +023d : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR +0241 : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND +0245 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR + ;logical accu operand +0249 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR +024d : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND +0251 : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR + ;logical results +0255 : 00ff7f80 absrlo db 0,$ff,$7f,$80 +0259 : 02800080 absflo db fz,fn,0,fn +025d : data_bss_end + ;define area for page crossing JMP (abs) & JMP (abs,x) test +02f9 = jxi_tab equ data_segment + $100 - 7 ;JMP (jxi_tab,x) x=6 +02fd = ji_tab equ data_segment + $100 - 3 ;JMP (ji_tab+2) +0300 = jxp_tab equ data_segment + $100 ;JMP (jxp_tab-255) x=255 + + + code +0400 = org code_segment +0400 : d8 start cld +0401 : a2ff ldx #$ff +0403 : 9a txs +0404 : a900 lda #0 ;*** test 0 = initialize +0406 : 8d0202 sta test_case +0000 = test_num = 0 + + ;stop interrupts before initializing BSS + if I_flag = 1 + sei + endif + + ;initialize I/O for report channel + if report = 1 + jsr report_init + endif + + ;initialize BSS segment + if load_data_direct != 1 + ldx #zp_end-zp_init-1 + ld_zp lda zp_init,x + sta zp_bss,x + dex + bpl ld_zp + ldx #data_end-data_init-1 + ld_data lda data_init,x + sta data_bss,x + dex + bpl ld_data + if ROM_vectors = 1 + ldx #5 + ld_vect lda vec_init,x + sta vec_bss,x + dex + bpl ld_vect + endif + endif + + ;retain status of interrupt flag + if I_flag = 2 + php + pla + and #4 ;isolate flag + sta flag_I_on ;or mask + eor #lo(~4) ;reverse + sta flag_I_off ;and mask + endif + + ;generate checksum for RAM integrity test + if ram_top > -1 + lda #0 + sta zpt ;set low byte of indirect pointer + sta ram_chksm+1 ;checksum high byte + ldx #11 ;reset modifiable RAM + gcs1 sta jxi_tab,x ;JMP indirect page cross area + dex + bpl gcs1 + sta chkdadi ;self modifying code + sta chkdsbi + 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(data_segment) ;set high byte of indirect pointer + stx zpt+1 + ldy #lo(data_bss) ;data after write test area + gcs5 adc (zpt),y + bcc gcs4 + inc ram_chksm+1 ;carry to high byte + clc + gcs4 iny + bne gcs5 + inx ;advance RAM high address + stx zpt+1 + cpx #ram_top + bne gcs5 + sta ram_chksm ;checksum complete + endif + next_test +0409 : ad0202 > lda test_case ;previous test +040c : c900 > cmp #test_num + > trap_ne ;test is out of sequence +040e : d0fe > bne * ;failed not equal (non zero) + > +0001 = >test_num = test_num + 1 +0410 : a901 > lda #test_num ;*** next tests' number +0412 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ;testing stack operations PHX PHY PLX PLY +0415 : a999 lda #$99 ;protect a +0417 : a2ff ldx #$ff ;initialize stack +0419 : 9a txs +041a : a255 ldx #$55 +041c : da phx +041d : a2aa ldx #$aa +041f : da phx +0420 : ecfe01 cpx $1fe ;on stack ? + trap_ne +0423 : d0fe > bne * ;failed not equal (non zero) + +0425 : ba tsx +0426 : e0fd cpx #$fd ;sp decremented? + trap_ne +0428 : d0fe > bne * ;failed not equal (non zero) + +042a : 7a ply +042b : c0aa cpy #$aa ;successful retreived from stack? + trap_ne +042d : d0fe > bne * ;failed not equal (non zero) + +042f : 7a ply +0430 : c055 cpy #$55 + trap_ne +0432 : d0fe > bne * ;failed not equal (non zero) + +0434 : ccff01 cpy $1ff ;remains on stack? + trap_ne +0437 : d0fe > bne * ;failed not equal (non zero) + +0439 : ba tsx +043a : e0ff cpx #$ff ;sp incremented? + trap_ne +043c : d0fe > bne * ;failed not equal (non zero) + + +043e : a0a5 ldy #$a5 +0440 : 5a phy +0441 : a05a ldy #$5a +0443 : 5a phy +0444 : ccfe01 cpy $1fe ;on stack ? + trap_ne +0447 : d0fe > bne * ;failed not equal (non zero) + +0449 : ba tsx +044a : e0fd cpx #$fd ;sp decremented? + trap_ne +044c : d0fe > bne * ;failed not equal (non zero) + +044e : fa plx +044f : e05a cpx #$5a ;successful retreived from stack? + trap_ne +0451 : d0fe > bne * ;failed not equal (non zero) + +0453 : fa plx +0454 : e0a5 cpx #$a5 + trap_ne +0456 : d0fe > bne * ;failed not equal (non zero) + +0458 : ecff01 cpx $1ff ;remains on stack? + trap_ne +045b : d0fe > bne * ;failed not equal (non zero) + +045d : ba tsx +045e : e0ff cpx #$ff ;sp incremented? + trap_ne +0460 : d0fe > bne * ;failed not equal (non zero) + +0462 : c999 cmp #$99 ;unchanged? + trap_ne +0464 : d0fe > bne * ;failed not equal (non zero) + + next_test +0466 : ad0202 > lda test_case ;previous test +0469 : c901 > cmp #test_num + > trap_ne ;test is out of sequence +046b : d0fe > bne * ;failed not equal (non zero) + > +0002 = >test_num = test_num + 1 +046d : a902 > lda #test_num ;*** next tests' number +046f : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; test PHX does not alter flags or X but PLX does +0472 : a0aa ldy #$aa ;protect y + set_x 1,$ff ;push + > load_flag $ff +0474 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0476 : 48 > pha ;use stack to load status +0477 : a201 > ldx #1 ;precharge index x +0479 : 28 > plp + +047a : da phx + tst_x 1,$ff +047b : 08 > php ;save flags +047c : e001 > cpx #1 ;test result + > trap_ne +047e : d0fe > bne * ;failed not equal (non zero) + > +0480 : 68 > pla ;load status +0481 : 48 > pha + > cmp_flag $ff +0482 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0484 : d0fe > bne * ;failed not equal (non zero) + > +0486 : 28 > plp ;restore status + + set_x 0,0 + > load_flag 0 +0487 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0489 : 48 > pha ;use stack to load status +048a : a200 > ldx #0 ;precharge index x +048c : 28 > plp + +048d : da phx + tst_x 0,0 +048e : 08 > php ;save flags +048f : e000 > cpx #0 ;test result + > trap_ne +0491 : d0fe > bne * ;failed not equal (non zero) + > +0493 : 68 > pla ;load status +0494 : 48 > pha + > cmp_flag 0 +0495 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0497 : d0fe > bne * ;failed not equal (non zero) + > +0499 : 28 > plp ;restore status + + set_x $ff,$ff + > load_flag $ff +049a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +049c : 48 > pha ;use stack to load status +049d : a2ff > ldx #$ff ;precharge index x +049f : 28 > plp + +04a0 : da phx + tst_x $ff,$ff +04a1 : 08 > php ;save flags +04a2 : e0ff > cpx #$ff ;test result + > trap_ne +04a4 : d0fe > bne * ;failed not equal (non zero) + > +04a6 : 68 > pla ;load status +04a7 : 48 > pha + > cmp_flag $ff +04a8 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +04aa : d0fe > bne * ;failed not equal (non zero) + > +04ac : 28 > plp ;restore status + + set_x 1,0 + > load_flag 0 +04ad : a900 > lda #0 ;allow test to change I-flag (no mask) + > +04af : 48 > pha ;use stack to load status +04b0 : a201 > ldx #1 ;precharge index x +04b2 : 28 > plp + +04b3 : da phx + tst_x 1,0 +04b4 : 08 > php ;save flags +04b5 : e001 > cpx #1 ;test result + > trap_ne +04b7 : d0fe > bne * ;failed not equal (non zero) + > +04b9 : 68 > pla ;load status +04ba : 48 > pha + > cmp_flag 0 +04bb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +04bd : d0fe > bne * ;failed not equal (non zero) + > +04bf : 28 > plp ;restore status + + set_x 0,$ff + > load_flag $ff +04c0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +04c2 : 48 > pha ;use stack to load status +04c3 : a200 > ldx #0 ;precharge index x +04c5 : 28 > plp + +04c6 : da phx + tst_x 0,$ff +04c7 : 08 > php ;save flags +04c8 : e000 > cpx #0 ;test result + > trap_ne +04ca : d0fe > bne * ;failed not equal (non zero) + > +04cc : 68 > pla ;load status +04cd : 48 > pha + > cmp_flag $ff +04ce : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +04d0 : d0fe > bne * ;failed not equal (non zero) + > +04d2 : 28 > plp ;restore status + + set_x $ff,0 + > load_flag 0 +04d3 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +04d5 : 48 > pha ;use stack to load status +04d6 : a2ff > ldx #$ff ;precharge index x +04d8 : 28 > plp + +04d9 : da phx + tst_x $ff,0 +04da : 08 > php ;save flags +04db : e0ff > cpx #$ff ;test result + > trap_ne +04dd : d0fe > bne * ;failed not equal (non zero) + > +04df : 68 > pla ;load status +04e0 : 48 > pha + > cmp_flag 0 +04e1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +04e3 : d0fe > bne * ;failed not equal (non zero) + > +04e5 : 28 > plp ;restore status + + set_x 0,$ff ;pull + > load_flag $ff +04e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +04e8 : 48 > pha ;use stack to load status +04e9 : a200 > ldx #0 ;precharge index x +04eb : 28 > plp + +04ec : fa plx + tst_x $ff,$ff-zero +04ed : 08 > php ;save flags +04ee : e0ff > cpx #$ff ;test result + > trap_ne +04f0 : d0fe > bne * ;failed not equal (non zero) + > +04f2 : 68 > pla ;load status +04f3 : 48 > pha + > cmp_flag $ff-zero +04f4 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +04f6 : d0fe > bne * ;failed not equal (non zero) + > +04f8 : 28 > plp ;restore status + + set_x $ff,0 + > load_flag 0 +04f9 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +04fb : 48 > pha ;use stack to load status +04fc : a2ff > ldx #$ff ;precharge index x +04fe : 28 > plp + +04ff : fa plx + tst_x 0,zero +0500 : 08 > php ;save flags +0501 : e000 > cpx #0 ;test result + > trap_ne +0503 : d0fe > bne * ;failed not equal (non zero) + > +0505 : 68 > pla ;load status +0506 : 48 > pha + > cmp_flag zero +0507 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0509 : d0fe > bne * ;failed not equal (non zero) + > +050b : 28 > plp ;restore status + + set_x $fe,$ff + > load_flag $ff +050c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +050e : 48 > pha ;use stack to load status +050f : a2fe > ldx #$fe ;precharge index x +0511 : 28 > plp + +0512 : fa plx + tst_x 1,$ff-zero-minus +0513 : 08 > php ;save flags +0514 : e001 > cpx #1 ;test result + > trap_ne +0516 : d0fe > bne * ;failed not equal (non zero) + > +0518 : 68 > pla ;load status +0519 : 48 > pha + > cmp_flag $ff-zero-minus +051a : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +051c : d0fe > bne * ;failed not equal (non zero) + > +051e : 28 > plp ;restore status + + set_x 0,0 + > load_flag 0 +051f : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0521 : 48 > pha ;use stack to load status +0522 : a200 > ldx #0 ;precharge index x +0524 : 28 > plp + +0525 : fa plx + tst_x $ff,minus +0526 : 08 > php ;save flags +0527 : e0ff > cpx #$ff ;test result + > trap_ne +0529 : d0fe > bne * ;failed not equal (non zero) + > +052b : 68 > pla ;load status +052c : 48 > pha + > cmp_flag minus +052d : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +052f : d0fe > bne * ;failed not equal (non zero) + > +0531 : 28 > plp ;restore status + + set_x $ff,$ff + > load_flag $ff +0532 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0534 : 48 > pha ;use stack to load status +0535 : a2ff > ldx #$ff ;precharge index x +0537 : 28 > plp + +0538 : fa plx + tst_x 0,$ff-minus +0539 : 08 > php ;save flags +053a : e000 > cpx #0 ;test result + > trap_ne +053c : d0fe > bne * ;failed not equal (non zero) + > +053e : 68 > pla ;load status +053f : 48 > pha + > cmp_flag $ff-minus +0540 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0542 : d0fe > bne * ;failed not equal (non zero) + > +0544 : 28 > plp ;restore status + + set_x $fe,0 + > load_flag 0 +0545 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0547 : 48 > pha ;use stack to load status +0548 : a2fe > ldx #$fe ;precharge index x +054a : 28 > plp + +054b : fa plx + tst_x 1,0 +054c : 08 > php ;save flags +054d : e001 > cpx #1 ;test result + > trap_ne +054f : d0fe > bne * ;failed not equal (non zero) + > +0551 : 68 > pla ;load status +0552 : 48 > pha + > cmp_flag 0 +0553 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0555 : d0fe > bne * ;failed not equal (non zero) + > +0557 : 28 > plp ;restore status + +0558 : c0aa cpy #$aa ;Y unchanged + trap_ne +055a : d0fe > bne * ;failed not equal (non zero) + + next_test +055c : ad0202 > lda test_case ;previous test +055f : c902 > cmp #test_num + > trap_ne ;test is out of sequence +0561 : d0fe > bne * ;failed not equal (non zero) + > +0003 = >test_num = test_num + 1 +0563 : a903 > lda #test_num ;*** next tests' number +0565 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; test PHY does not alter flags or Y but PLY does +0568 : a255 ldx #$55 ;x & a protected + set_y 1,$ff ;push + > load_flag $ff +056a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +056c : 48 > pha ;use stack to load status +056d : a001 > ldy #1 ;precharge index y +056f : 28 > plp + +0570 : 5a phy + tst_y 1,$ff +0571 : 08 > php ;save flags +0572 : c001 > cpy #1 ;test result + > trap_ne +0574 : d0fe > bne * ;failed not equal (non zero) + > +0576 : 68 > pla ;load status +0577 : 48 > pha + > cmp_flag $ff +0578 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +057a : d0fe > bne * ;failed not equal (non zero) + > +057c : 28 > plp ;restore status + + set_y 0,0 + > load_flag 0 +057d : a900 > lda #0 ;allow test to change I-flag (no mask) + > +057f : 48 > pha ;use stack to load status +0580 : a000 > ldy #0 ;precharge index y +0582 : 28 > plp + +0583 : 5a phy + tst_y 0,0 +0584 : 08 > php ;save flags +0585 : c000 > cpy #0 ;test result + > trap_ne +0587 : d0fe > bne * ;failed not equal (non zero) + > +0589 : 68 > pla ;load status +058a : 48 > pha + > cmp_flag 0 +058b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +058d : d0fe > bne * ;failed not equal (non zero) + > +058f : 28 > plp ;restore status + + set_y $ff,$ff + > load_flag $ff +0590 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0592 : 48 > pha ;use stack to load status +0593 : a0ff > ldy #$ff ;precharge index y +0595 : 28 > plp + +0596 : 5a phy + tst_y $ff,$ff +0597 : 08 > php ;save flags +0598 : c0ff > cpy #$ff ;test result + > trap_ne +059a : d0fe > bne * ;failed not equal (non zero) + > +059c : 68 > pla ;load status +059d : 48 > pha + > cmp_flag $ff +059e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +05a0 : d0fe > bne * ;failed not equal (non zero) + > +05a2 : 28 > plp ;restore status + + set_y 1,0 + > load_flag 0 +05a3 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +05a5 : 48 > pha ;use stack to load status +05a6 : a001 > ldy #1 ;precharge index y +05a8 : 28 > plp + +05a9 : 5a phy + tst_y 1,0 +05aa : 08 > php ;save flags +05ab : c001 > cpy #1 ;test result + > trap_ne +05ad : d0fe > bne * ;failed not equal (non zero) + > +05af : 68 > pla ;load status +05b0 : 48 > pha + > cmp_flag 0 +05b1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +05b3 : d0fe > bne * ;failed not equal (non zero) + > +05b5 : 28 > plp ;restore status + + set_y 0,$ff + > load_flag $ff +05b6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +05b8 : 48 > pha ;use stack to load status +05b9 : a000 > ldy #0 ;precharge index y +05bb : 28 > plp + +05bc : 5a phy + tst_y 0,$ff +05bd : 08 > php ;save flags +05be : c000 > cpy #0 ;test result + > trap_ne +05c0 : d0fe > bne * ;failed not equal (non zero) + > +05c2 : 68 > pla ;load status +05c3 : 48 > pha + > cmp_flag $ff +05c4 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +05c6 : d0fe > bne * ;failed not equal (non zero) + > +05c8 : 28 > plp ;restore status + + set_y $ff,0 + > load_flag 0 +05c9 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +05cb : 48 > pha ;use stack to load status +05cc : a0ff > ldy #$ff ;precharge index y +05ce : 28 > plp + +05cf : 5a phy + tst_y $ff,0 +05d0 : 08 > php ;save flags +05d1 : c0ff > cpy #$ff ;test result + > trap_ne +05d3 : d0fe > bne * ;failed not equal (non zero) + > +05d5 : 68 > pla ;load status +05d6 : 48 > pha + > cmp_flag 0 +05d7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +05d9 : d0fe > bne * ;failed not equal (non zero) + > +05db : 28 > plp ;restore status + + set_y 0,$ff ;pull + > load_flag $ff +05dc : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +05de : 48 > pha ;use stack to load status +05df : a000 > ldy #0 ;precharge index y +05e1 : 28 > plp + +05e2 : 7a ply + tst_y $ff,$ff-zero +05e3 : 08 > php ;save flags +05e4 : c0ff > cpy #$ff ;test result + > trap_ne +05e6 : d0fe > bne * ;failed not equal (non zero) + > +05e8 : 68 > pla ;load status +05e9 : 48 > pha + > cmp_flag $ff-zero +05ea : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +05ec : d0fe > bne * ;failed not equal (non zero) + > +05ee : 28 > plp ;restore status + + set_y $ff,0 + > load_flag 0 +05ef : a900 > lda #0 ;allow test to change I-flag (no mask) + > +05f1 : 48 > pha ;use stack to load status +05f2 : a0ff > ldy #$ff ;precharge index y +05f4 : 28 > plp + +05f5 : 7a ply + tst_y 0,zero +05f6 : 08 > php ;save flags +05f7 : c000 > cpy #0 ;test result + > trap_ne +05f9 : d0fe > bne * ;failed not equal (non zero) + > +05fb : 68 > pla ;load status +05fc : 48 > pha + > cmp_flag zero +05fd : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +05ff : d0fe > bne * ;failed not equal (non zero) + > +0601 : 28 > plp ;restore status + + set_y $fe,$ff + > load_flag $ff +0602 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0604 : 48 > pha ;use stack to load status +0605 : a0fe > ldy #$fe ;precharge index y +0607 : 28 > plp + +0608 : 7a ply + tst_y 1,$ff-zero-minus +0609 : 08 > php ;save flags +060a : c001 > cpy #1 ;test result + > trap_ne +060c : d0fe > bne * ;failed not equal (non zero) + > +060e : 68 > pla ;load status +060f : 48 > pha + > cmp_flag $ff-zero-minus +0610 : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0612 : d0fe > bne * ;failed not equal (non zero) + > +0614 : 28 > plp ;restore status + + set_y 0,0 + > load_flag 0 +0615 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0617 : 48 > pha ;use stack to load status +0618 : a000 > ldy #0 ;precharge index y +061a : 28 > plp + +061b : 7a ply + tst_y $ff,minus +061c : 08 > php ;save flags +061d : c0ff > cpy #$ff ;test result + > trap_ne +061f : d0fe > bne * ;failed not equal (non zero) + > +0621 : 68 > pla ;load status +0622 : 48 > pha + > cmp_flag minus +0623 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0625 : d0fe > bne * ;failed not equal (non zero) + > +0627 : 28 > plp ;restore status + + set_y $ff,$ff + > load_flag $ff +0628 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +062a : 48 > pha ;use stack to load status +062b : a0ff > ldy #$ff ;precharge index y +062d : 28 > plp + +062e : 7a ply + tst_y 0,$ff-minus +062f : 08 > php ;save flags +0630 : c000 > cpy #0 ;test result + > trap_ne +0632 : d0fe > bne * ;failed not equal (non zero) + > +0634 : 68 > pla ;load status +0635 : 48 > pha + > cmp_flag $ff-minus +0636 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0638 : d0fe > bne * ;failed not equal (non zero) + > +063a : 28 > plp ;restore status + + set_y $fe,0 + > load_flag 0 +063b : a900 > lda #0 ;allow test to change I-flag (no mask) + > +063d : 48 > pha ;use stack to load status +063e : a0fe > ldy #$fe ;precharge index y +0640 : 28 > plp + +0641 : 7a ply + tst_y 1,0 +0642 : 08 > php ;save flags +0643 : c001 > cpy #1 ;test result + > trap_ne +0645 : d0fe > bne * ;failed not equal (non zero) + > +0647 : 68 > pla ;load status +0648 : 48 > pha + > cmp_flag 0 +0649 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +064b : d0fe > bne * ;failed not equal (non zero) + > +064d : 28 > plp ;restore status + +064e : e055 cpx #$55 ;x unchanged? + trap_ne +0650 : d0fe > bne * ;failed not equal (non zero) + + next_test +0652 : ad0202 > lda test_case ;previous test +0655 : c903 > cmp #test_num + > trap_ne ;test is out of sequence +0657 : d0fe > bne * ;failed not equal (non zero) + > +0004 = >test_num = test_num + 1 +0659 : a904 > lda #test_num ;*** next tests' number +065b : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; PC modifying instructions (BRA, BBR, BBS, 1, 2, 3 byte NOPs, JMP(abs,x)) + ; testing unconditional branch BRA + +065e : a281 ldx #$81 ;protect unused registers +0660 : a07e ldy #$7e + set_a 0,$ff + > load_flag $ff +0662 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0664 : 48 > pha ;use stack to load status +0665 : a900 > lda #0 ;precharge accu +0667 : 28 > plp + +0668 : 8003 bra br1 ;branch should always be taken + trap +066a : 4c6a06 > jmp * ;failed anyway + +066d : br1 + tst_a 0,$ff +066d : 08 > php ;save flags +066e : c900 > cmp #0 ;test result + > trap_ne +0670 : d0fe > bne * ;failed not equal (non zero) + > +0672 : 68 > pla ;load status +0673 : 48 > pha + > cmp_flag $ff +0674 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0676 : d0fe > bne * ;failed not equal (non zero) + > +0678 : 28 > plp ;restore status + + set_a $ff,0 + > load_flag 0 +0679 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +067b : 48 > pha ;use stack to load status +067c : a9ff > lda #$ff ;precharge accu +067e : 28 > plp + +067f : 8003 bra br2 ;branch should always be taken + trap +0681 : 4c8106 > jmp * ;failed anyway + +0684 : br2 + tst_a $ff,0 +0684 : 08 > php ;save flags +0685 : c9ff > cmp #$ff ;test result + > trap_ne +0687 : d0fe > bne * ;failed not equal (non zero) + > +0689 : 68 > pla ;load status +068a : 48 > pha + > cmp_flag 0 +068b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +068d : d0fe > bne * ;failed not equal (non zero) + > +068f : 28 > plp ;restore status + +0690 : e081 cpx #$81 + trap_ne +0692 : d0fe > bne * ;failed not equal (non zero) + +0694 : c07e cpy #$7e + trap_ne +0696 : d0fe > bne * ;failed not equal (non zero) + + next_test +0698 : ad0202 > lda test_case ;previous test +069b : c904 > cmp #test_num + > trap_ne ;test is out of sequence +069d : d0fe > bne * ;failed not equal (non zero) + > +0005 = >test_num = test_num + 1 +069f : a905 > lda #test_num ;*** next tests' number +06a1 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + +06a4 : a000 ldy #0 ;branch range test +06a6 : 8061 bra bra0 + +06a8 : c001 bra1 cpy #1 + trap_ne ;long range backward +06aa : d0fe > bne * ;failed not equal (non zero) + +06ac : c8 iny +06ad : 8053 bra bra2 + +06af : c003 bra3 cpy #3 + trap_ne ;long range backward +06b1 : d0fe > bne * ;failed not equal (non zero) + +06b3 : c8 iny +06b4 : 8045 bra bra4 + +06b6 : c005 bra5 cpy #5 + trap_ne ;long range backward +06b8 : d0fe > bne * ;failed not equal (non zero) + +06ba : c8 iny +06bb : a000 ldy #0 +06bd : 8004 bra brf0 + +06bf : c8 iny +06c0 : c8 iny +06c1 : c8 iny +06c2 : c8 iny +06c3 : 8003 brf0 bra brf1 + +06c5 : c8 iny +06c6 : c8 iny +06c7 : c8 iny +06c8 : c8 brf1 iny +06c9 : 8002 bra brf2 + +06cb : c8 iny +06cc : c8 iny +06cd : c8 brf2 iny +06ce : c8 iny +06cf : 8001 bra brf3 + +06d1 : c8 iny +06d2 : c8 brf3 iny +06d3 : c8 iny +06d4 : c8 iny +06d5 : 8000 bra brf4 + +06d7 : c8 brf4 iny +06d8 : c8 iny +06d9 : c8 iny +06da : c8 iny +06db : c00a cpy #10 + trap_ne ;short range forward +06dd : d0fe > bne * ;failed not equal (non zero) + +06df : 8012 bra brb0 + +06e1 : 88 brb4 dey +06e2 : 88 dey +06e3 : 88 dey +06e4 : 88 dey +06e5 : 800e bra brb5 + +06e7 : 88 brb3 dey +06e8 : 88 dey +06e9 : 88 dey +06ea : 80f5 bra brb4 + +06ec : 88 brb2 dey +06ed : 88 dey +06ee : 80f7 bra brb3 + +06f0 : 88 brb1 dey +06f1 : 80f9 bra brb2 + +06f3 : 80fb brb0 bra brb1 + +06f5 : c000 brb5 cpy #0 + trap_ne ;short range backward +06f7 : d0fe > bne * ;failed not equal (non zero) + +06f9 : 8015 bra bra6 + +06fb : c004 bra4 cpy #4 + trap_ne ;long range forward +06fd : d0fe > bne * ;failed not equal (non zero) + +06ff : c8 iny +0700 : 80b4 bra bra5 + +0702 : c002 bra2 cpy #2 + trap_ne ;long range forward +0704 : d0fe > bne * ;failed not equal (non zero) + +0706 : c8 iny +0707 : 80a6 bra bra3 + +0709 : c000 bra0 cpy #0 + trap_ne ;long range forward +070b : d0fe > bne * ;failed not equal (non zero) + +070d : c8 iny +070e : 8098 bra bra1 + +0710 : bra6 + next_test +0710 : ad0202 > lda test_case ;previous test +0713 : c905 > cmp #test_num + > trap_ne ;test is out of sequence +0715 : d0fe > bne * ;failed not equal (non zero) + > +0006 = >test_num = test_num + 1 +0717 : a906 > lda #test_num ;*** next tests' number +0719 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + if rkwl_wdc_op = 1 + ; testing BBR & BBS + + bbt macro ;\1 = bitnum + lda #(1<<\1) ;testing 1 bit on + sta zpt + set_a $33,0 ;with flags off + bbr \1,zpt,fail1\? + bbs \1,zpt,ok1\? + trap ;bbs branch not taken + fail1\? + trap ;bbr branch taken + ok1\? + tst_a $33,0 + set_a $cc,$ff ;with flags on + bbr \1,zpt,fail2\? + bbs \1,zpt,ok2\? + trap ;bbs branch not taken + fail2\? + trap ;bbr branch taken + ok2\? + tst_a $cc,$ff + lda zpt + cmp #(1<<\1) + trap_ne ;zp altered + lda #$ff-(1<<\1) ;testing 1 bit off + sta zpt + set_a $33,0 ;with flags off + bbs \1,zpt,fail3\? + bbr \1,zpt,ok3\? + trap ;bbr branch not taken + fail3\? + trap ;bbs branch taken + ok3\? + tst_a $33,0 + set_a $cc,$ff ;with flags on + bbs \1,zpt,fail4\? + bbr \1,zpt,ok4\? + trap ;bbr branch not taken + fail4\? + trap ;bbs branch taken + ok4\? + tst_a $cc,$ff + lda zpt + cmp #$ff-(1<<\1) + trap_ne ;zp altered + endm + +071c : a211 ldx #$11 ;test bbr/bbs integrity +071e : a022 ldy #$22 + bbt 0 +0720 : a901 > lda #(1<<0) ;testing 1 bit on +0722 : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +0724 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0726 : 48 > pha ;use stack to load status +0727 : a933 > lda #$33 ;precharge accu +0729 : 28 > plp + > +072a : 0f0a06 > bbr 0,zpt,fail10196 +072d : 8f0a06 > bbs 0,zpt,ok10196 + > trap ;bbs branch not taken +0730 : 4c3007 > jmp * ;failed anyway + > +0733 : >fail10196 + > trap ;bbr branch taken +0733 : 4c3307 > jmp * ;failed anyway + > +0736 : >ok10196 + > tst_a $33,0 +0736 : 08 > php ;save flags +0737 : c933 > cmp #$33 ;test result + > trap_ne +0739 : d0fe > bne * ;failed not equal (non zero) + > +073b : 68 > pla ;load status +073c : 48 > pha + > cmp_flag 0 +073d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +073f : d0fe > bne * ;failed not equal (non zero) + > +0741 : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +0742 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0744 : 48 > pha ;use stack to load status +0745 : a9cc > lda #$cc ;precharge accu +0747 : 28 > plp + > +0748 : 0f0a06 > bbr 0,zpt,fail20196 +074b : 8f0a06 > bbs 0,zpt,ok20196 + > trap ;bbs branch not taken +074e : 4c4e07 > jmp * ;failed anyway + > +0751 : >fail20196 + > trap ;bbr branch taken +0751 : 4c5107 > jmp * ;failed anyway + > +0754 : >ok20196 + > tst_a $cc,$ff +0754 : 08 > php ;save flags +0755 : c9cc > cmp #$cc ;test result + > trap_ne +0757 : d0fe > bne * ;failed not equal (non zero) + > +0759 : 68 > pla ;load status +075a : 48 > pha + > cmp_flag $ff +075b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +075d : d0fe > bne * ;failed not equal (non zero) + > +075f : 28 > plp ;restore status + > +0760 : a50a > lda zpt +0762 : c901 > cmp #(1<<0) + > trap_ne ;zp altered +0764 : d0fe > bne * ;failed not equal (non zero) + > +0766 : a9fe > lda #$ff-(1<<0) ;testing 1 bit off +0768 : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +076a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +076c : 48 > pha ;use stack to load status +076d : a933 > lda #$33 ;precharge accu +076f : 28 > plp + > +0770 : 8f0a06 > bbs 0,zpt,fail30196 +0773 : 0f0a06 > bbr 0,zpt,ok30196 + > trap ;bbr branch not taken +0776 : 4c7607 > jmp * ;failed anyway + > +0779 : >fail30196 + > trap ;bbs branch taken +0779 : 4c7907 > jmp * ;failed anyway + > +077c : >ok30196 + > tst_a $33,0 +077c : 08 > php ;save flags +077d : c933 > cmp #$33 ;test result + > trap_ne +077f : d0fe > bne * ;failed not equal (non zero) + > +0781 : 68 > pla ;load status +0782 : 48 > pha + > cmp_flag 0 +0783 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0785 : d0fe > bne * ;failed not equal (non zero) + > +0787 : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +0788 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +078a : 48 > pha ;use stack to load status +078b : a9cc > lda #$cc ;precharge accu +078d : 28 > plp + > +078e : 8f0a06 > bbs 0,zpt,fail40196 +0791 : 0f0a06 > bbr 0,zpt,ok40196 + > trap ;bbr branch not taken +0794 : 4c9407 > jmp * ;failed anyway + > +0797 : >fail40196 + > trap ;bbs branch taken +0797 : 4c9707 > jmp * ;failed anyway + > +079a : >ok40196 + > tst_a $cc,$ff +079a : 08 > php ;save flags +079b : c9cc > cmp #$cc ;test result + > trap_ne +079d : d0fe > bne * ;failed not equal (non zero) + > +079f : 68 > pla ;load status +07a0 : 48 > pha + > cmp_flag $ff +07a1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +07a3 : d0fe > bne * ;failed not equal (non zero) + > +07a5 : 28 > plp ;restore status + > +07a6 : a50a > lda zpt +07a8 : c9fe > cmp #$ff-(1<<0) + > trap_ne ;zp altered +07aa : d0fe > bne * ;failed not equal (non zero) + > + + bbt 1 +07ac : a902 > lda #(1<<1) ;testing 1 bit on +07ae : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +07b0 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +07b2 : 48 > pha ;use stack to load status +07b3 : a933 > lda #$33 ;precharge accu +07b5 : 28 > plp + > +07b6 : 1f0a06 > bbr 1,zpt,fail10231 +07b9 : 9f0a06 > bbs 1,zpt,ok10231 + > trap ;bbs branch not taken +07bc : 4cbc07 > jmp * ;failed anyway + > +07bf : >fail10231 + > trap ;bbr branch taken +07bf : 4cbf07 > jmp * ;failed anyway + > +07c2 : >ok10231 + > tst_a $33,0 +07c2 : 08 > php ;save flags +07c3 : c933 > cmp #$33 ;test result + > trap_ne +07c5 : d0fe > bne * ;failed not equal (non zero) + > +07c7 : 68 > pla ;load status +07c8 : 48 > pha + > cmp_flag 0 +07c9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +07cb : d0fe > bne * ;failed not equal (non zero) + > +07cd : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +07ce : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +07d0 : 48 > pha ;use stack to load status +07d1 : a9cc > lda #$cc ;precharge accu +07d3 : 28 > plp + > +07d4 : 1f0a06 > bbr 1,zpt,fail20231 +07d7 : 9f0a06 > bbs 1,zpt,ok20231 + > trap ;bbs branch not taken +07da : 4cda07 > jmp * ;failed anyway + > +07dd : >fail20231 + > trap ;bbr branch taken +07dd : 4cdd07 > jmp * ;failed anyway + > +07e0 : >ok20231 + > tst_a $cc,$ff +07e0 : 08 > php ;save flags +07e1 : c9cc > cmp #$cc ;test result + > trap_ne +07e3 : d0fe > bne * ;failed not equal (non zero) + > +07e5 : 68 > pla ;load status +07e6 : 48 > pha + > cmp_flag $ff +07e7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +07e9 : d0fe > bne * ;failed not equal (non zero) + > +07eb : 28 > plp ;restore status + > +07ec : a50a > lda zpt +07ee : c902 > cmp #(1<<1) + > trap_ne ;zp altered +07f0 : d0fe > bne * ;failed not equal (non zero) + > +07f2 : a9fd > lda #$ff-(1<<1) ;testing 1 bit off +07f4 : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +07f6 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +07f8 : 48 > pha ;use stack to load status +07f9 : a933 > lda #$33 ;precharge accu +07fb : 28 > plp + > +07fc : 9f0a06 > bbs 1,zpt,fail30231 +07ff : 1f0a06 > bbr 1,zpt,ok30231 + > trap ;bbr branch not taken +0802 : 4c0208 > jmp * ;failed anyway + > +0805 : >fail30231 + > trap ;bbs branch taken +0805 : 4c0508 > jmp * ;failed anyway + > +0808 : >ok30231 + > tst_a $33,0 +0808 : 08 > php ;save flags +0809 : c933 > cmp #$33 ;test result + > trap_ne +080b : d0fe > bne * ;failed not equal (non zero) + > +080d : 68 > pla ;load status +080e : 48 > pha + > cmp_flag 0 +080f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0811 : d0fe > bne * ;failed not equal (non zero) + > +0813 : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +0814 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0816 : 48 > pha ;use stack to load status +0817 : a9cc > lda #$cc ;precharge accu +0819 : 28 > plp + > +081a : 9f0a06 > bbs 1,zpt,fail40231 +081d : 1f0a06 > bbr 1,zpt,ok40231 + > trap ;bbr branch not taken +0820 : 4c2008 > jmp * ;failed anyway + > +0823 : >fail40231 + > trap ;bbs branch taken +0823 : 4c2308 > jmp * ;failed anyway + > +0826 : >ok40231 + > tst_a $cc,$ff +0826 : 08 > php ;save flags +0827 : c9cc > cmp #$cc ;test result + > trap_ne +0829 : d0fe > bne * ;failed not equal (non zero) + > +082b : 68 > pla ;load status +082c : 48 > pha + > cmp_flag $ff +082d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +082f : d0fe > bne * ;failed not equal (non zero) + > +0831 : 28 > plp ;restore status + > +0832 : a50a > lda zpt +0834 : c9fd > cmp #$ff-(1<<1) + > trap_ne ;zp altered +0836 : d0fe > bne * ;failed not equal (non zero) + > + + bbt 2 +0838 : a904 > lda #(1<<2) ;testing 1 bit on +083a : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +083c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +083e : 48 > pha ;use stack to load status +083f : a933 > lda #$33 ;precharge accu +0841 : 28 > plp + > +0842 : 2f0a06 > bbr 2,zpt,fail10266 +0845 : af0a06 > bbs 2,zpt,ok10266 + > trap ;bbs branch not taken +0848 : 4c4808 > jmp * ;failed anyway + > +084b : >fail10266 + > trap ;bbr branch taken +084b : 4c4b08 > jmp * ;failed anyway + > +084e : >ok10266 + > tst_a $33,0 +084e : 08 > php ;save flags +084f : c933 > cmp #$33 ;test result + > trap_ne +0851 : d0fe > bne * ;failed not equal (non zero) + > +0853 : 68 > pla ;load status +0854 : 48 > pha + > cmp_flag 0 +0855 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0857 : d0fe > bne * ;failed not equal (non zero) + > +0859 : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +085a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +085c : 48 > pha ;use stack to load status +085d : a9cc > lda #$cc ;precharge accu +085f : 28 > plp + > +0860 : 2f0a06 > bbr 2,zpt,fail20266 +0863 : af0a06 > bbs 2,zpt,ok20266 + > trap ;bbs branch not taken +0866 : 4c6608 > jmp * ;failed anyway + > +0869 : >fail20266 + > trap ;bbr branch taken +0869 : 4c6908 > jmp * ;failed anyway + > +086c : >ok20266 + > tst_a $cc,$ff +086c : 08 > php ;save flags +086d : c9cc > cmp #$cc ;test result + > trap_ne +086f : d0fe > bne * ;failed not equal (non zero) + > +0871 : 68 > pla ;load status +0872 : 48 > pha + > cmp_flag $ff +0873 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0875 : d0fe > bne * ;failed not equal (non zero) + > +0877 : 28 > plp ;restore status + > +0878 : a50a > lda zpt +087a : c904 > cmp #(1<<2) + > trap_ne ;zp altered +087c : d0fe > bne * ;failed not equal (non zero) + > +087e : a9fb > lda #$ff-(1<<2) ;testing 1 bit off +0880 : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +0882 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0884 : 48 > pha ;use stack to load status +0885 : a933 > lda #$33 ;precharge accu +0887 : 28 > plp + > +0888 : af0a06 > bbs 2,zpt,fail30266 +088b : 2f0a06 > bbr 2,zpt,ok30266 + > trap ;bbr branch not taken +088e : 4c8e08 > jmp * ;failed anyway + > +0891 : >fail30266 + > trap ;bbs branch taken +0891 : 4c9108 > jmp * ;failed anyway + > +0894 : >ok30266 + > tst_a $33,0 +0894 : 08 > php ;save flags +0895 : c933 > cmp #$33 ;test result + > trap_ne +0897 : d0fe > bne * ;failed not equal (non zero) + > +0899 : 68 > pla ;load status +089a : 48 > pha + > cmp_flag 0 +089b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +089d : d0fe > bne * ;failed not equal (non zero) + > +089f : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +08a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +08a2 : 48 > pha ;use stack to load status +08a3 : a9cc > lda #$cc ;precharge accu +08a5 : 28 > plp + > +08a6 : af0a06 > bbs 2,zpt,fail40266 +08a9 : 2f0a06 > bbr 2,zpt,ok40266 + > trap ;bbr branch not taken +08ac : 4cac08 > jmp * ;failed anyway + > +08af : >fail40266 + > trap ;bbs branch taken +08af : 4caf08 > jmp * ;failed anyway + > +08b2 : >ok40266 + > tst_a $cc,$ff +08b2 : 08 > php ;save flags +08b3 : c9cc > cmp #$cc ;test result + > trap_ne +08b5 : d0fe > bne * ;failed not equal (non zero) + > +08b7 : 68 > pla ;load status +08b8 : 48 > pha + > cmp_flag $ff +08b9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +08bb : d0fe > bne * ;failed not equal (non zero) + > +08bd : 28 > plp ;restore status + > +08be : a50a > lda zpt +08c0 : c9fb > cmp #$ff-(1<<2) + > trap_ne ;zp altered +08c2 : d0fe > bne * ;failed not equal (non zero) + > + + bbt 3 +08c4 : a908 > lda #(1<<3) ;testing 1 bit on +08c6 : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +08c8 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +08ca : 48 > pha ;use stack to load status +08cb : a933 > lda #$33 ;precharge accu +08cd : 28 > plp + > +08ce : 3f0a06 > bbr 3,zpt,fail10301 +08d1 : bf0a06 > bbs 3,zpt,ok10301 + > trap ;bbs branch not taken +08d4 : 4cd408 > jmp * ;failed anyway + > +08d7 : >fail10301 + > trap ;bbr branch taken +08d7 : 4cd708 > jmp * ;failed anyway + > +08da : >ok10301 + > tst_a $33,0 +08da : 08 > php ;save flags +08db : c933 > cmp #$33 ;test result + > trap_ne +08dd : d0fe > bne * ;failed not equal (non zero) + > +08df : 68 > pla ;load status +08e0 : 48 > pha + > cmp_flag 0 +08e1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +08e3 : d0fe > bne * ;failed not equal (non zero) + > +08e5 : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +08e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +08e8 : 48 > pha ;use stack to load status +08e9 : a9cc > lda #$cc ;precharge accu +08eb : 28 > plp + > +08ec : 3f0a06 > bbr 3,zpt,fail20301 +08ef : bf0a06 > bbs 3,zpt,ok20301 + > trap ;bbs branch not taken +08f2 : 4cf208 > jmp * ;failed anyway + > +08f5 : >fail20301 + > trap ;bbr branch taken +08f5 : 4cf508 > jmp * ;failed anyway + > +08f8 : >ok20301 + > tst_a $cc,$ff +08f8 : 08 > php ;save flags +08f9 : c9cc > cmp #$cc ;test result + > trap_ne +08fb : d0fe > bne * ;failed not equal (non zero) + > +08fd : 68 > pla ;load status +08fe : 48 > pha + > cmp_flag $ff +08ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0901 : d0fe > bne * ;failed not equal (non zero) + > +0903 : 28 > plp ;restore status + > +0904 : a50a > lda zpt +0906 : c908 > cmp #(1<<3) + > trap_ne ;zp altered +0908 : d0fe > bne * ;failed not equal (non zero) + > +090a : a9f7 > lda #$ff-(1<<3) ;testing 1 bit off +090c : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +090e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0910 : 48 > pha ;use stack to load status +0911 : a933 > lda #$33 ;precharge accu +0913 : 28 > plp + > +0914 : bf0a06 > bbs 3,zpt,fail30301 +0917 : 3f0a06 > bbr 3,zpt,ok30301 + > trap ;bbr branch not taken +091a : 4c1a09 > jmp * ;failed anyway + > +091d : >fail30301 + > trap ;bbs branch taken +091d : 4c1d09 > jmp * ;failed anyway + > +0920 : >ok30301 + > tst_a $33,0 +0920 : 08 > php ;save flags +0921 : c933 > cmp #$33 ;test result + > trap_ne +0923 : d0fe > bne * ;failed not equal (non zero) + > +0925 : 68 > pla ;load status +0926 : 48 > pha + > cmp_flag 0 +0927 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0929 : d0fe > bne * ;failed not equal (non zero) + > +092b : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +092c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +092e : 48 > pha ;use stack to load status +092f : a9cc > lda #$cc ;precharge accu +0931 : 28 > plp + > +0932 : bf0a06 > bbs 3,zpt,fail40301 +0935 : 3f0a06 > bbr 3,zpt,ok40301 + > trap ;bbr branch not taken +0938 : 4c3809 > jmp * ;failed anyway + > +093b : >fail40301 + > trap ;bbs branch taken +093b : 4c3b09 > jmp * ;failed anyway + > +093e : >ok40301 + > tst_a $cc,$ff +093e : 08 > php ;save flags +093f : c9cc > cmp #$cc ;test result + > trap_ne +0941 : d0fe > bne * ;failed not equal (non zero) + > +0943 : 68 > pla ;load status +0944 : 48 > pha + > cmp_flag $ff +0945 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0947 : d0fe > bne * ;failed not equal (non zero) + > +0949 : 28 > plp ;restore status + > +094a : a50a > lda zpt +094c : c9f7 > cmp #$ff-(1<<3) + > trap_ne ;zp altered +094e : d0fe > bne * ;failed not equal (non zero) + > + + bbt 4 +0950 : a910 > lda #(1<<4) ;testing 1 bit on +0952 : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +0954 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0956 : 48 > pha ;use stack to load status +0957 : a933 > lda #$33 ;precharge accu +0959 : 28 > plp + > +095a : 4f0a06 > bbr 4,zpt,fail10336 +095d : cf0a06 > bbs 4,zpt,ok10336 + > trap ;bbs branch not taken +0960 : 4c6009 > jmp * ;failed anyway + > +0963 : >fail10336 + > trap ;bbr branch taken +0963 : 4c6309 > jmp * ;failed anyway + > +0966 : >ok10336 + > tst_a $33,0 +0966 : 08 > php ;save flags +0967 : c933 > cmp #$33 ;test result + > trap_ne +0969 : d0fe > bne * ;failed not equal (non zero) + > +096b : 68 > pla ;load status +096c : 48 > pha + > cmp_flag 0 +096d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +096f : d0fe > bne * ;failed not equal (non zero) + > +0971 : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +0972 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0974 : 48 > pha ;use stack to load status +0975 : a9cc > lda #$cc ;precharge accu +0977 : 28 > plp + > +0978 : 4f0a06 > bbr 4,zpt,fail20336 +097b : cf0a06 > bbs 4,zpt,ok20336 + > trap ;bbs branch not taken +097e : 4c7e09 > jmp * ;failed anyway + > +0981 : >fail20336 + > trap ;bbr branch taken +0981 : 4c8109 > jmp * ;failed anyway + > +0984 : >ok20336 + > tst_a $cc,$ff +0984 : 08 > php ;save flags +0985 : c9cc > cmp #$cc ;test result + > trap_ne +0987 : d0fe > bne * ;failed not equal (non zero) + > +0989 : 68 > pla ;load status +098a : 48 > pha + > cmp_flag $ff +098b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +098d : d0fe > bne * ;failed not equal (non zero) + > +098f : 28 > plp ;restore status + > +0990 : a50a > lda zpt +0992 : c910 > cmp #(1<<4) + > trap_ne ;zp altered +0994 : d0fe > bne * ;failed not equal (non zero) + > +0996 : a9ef > lda #$ff-(1<<4) ;testing 1 bit off +0998 : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +099a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +099c : 48 > pha ;use stack to load status +099d : a933 > lda #$33 ;precharge accu +099f : 28 > plp + > +09a0 : cf0a06 > bbs 4,zpt,fail30336 +09a3 : 4f0a06 > bbr 4,zpt,ok30336 + > trap ;bbr branch not taken +09a6 : 4ca609 > jmp * ;failed anyway + > +09a9 : >fail30336 + > trap ;bbs branch taken +09a9 : 4ca909 > jmp * ;failed anyway + > +09ac : >ok30336 + > tst_a $33,0 +09ac : 08 > php ;save flags +09ad : c933 > cmp #$33 ;test result + > trap_ne +09af : d0fe > bne * ;failed not equal (non zero) + > +09b1 : 68 > pla ;load status +09b2 : 48 > pha + > cmp_flag 0 +09b3 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09b5 : d0fe > bne * ;failed not equal (non zero) + > +09b7 : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +09b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +09ba : 48 > pha ;use stack to load status +09bb : a9cc > lda #$cc ;precharge accu +09bd : 28 > plp + > +09be : cf0a06 > bbs 4,zpt,fail40336 +09c1 : 4f0a06 > bbr 4,zpt,ok40336 + > trap ;bbr branch not taken +09c4 : 4cc409 > jmp * ;failed anyway + > +09c7 : >fail40336 + > trap ;bbs branch taken +09c7 : 4cc709 > jmp * ;failed anyway + > +09ca : >ok40336 + > tst_a $cc,$ff +09ca : 08 > php ;save flags +09cb : c9cc > cmp #$cc ;test result + > trap_ne +09cd : d0fe > bne * ;failed not equal (non zero) + > +09cf : 68 > pla ;load status +09d0 : 48 > pha + > cmp_flag $ff +09d1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09d3 : d0fe > bne * ;failed not equal (non zero) + > +09d5 : 28 > plp ;restore status + > +09d6 : a50a > lda zpt +09d8 : c9ef > cmp #$ff-(1<<4) + > trap_ne ;zp altered +09da : d0fe > bne * ;failed not equal (non zero) + > + + bbt 5 +09dc : a920 > lda #(1<<5) ;testing 1 bit on +09de : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +09e0 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +09e2 : 48 > pha ;use stack to load status +09e3 : a933 > lda #$33 ;precharge accu +09e5 : 28 > plp + > +09e6 : 5f0a06 > bbr 5,zpt,fail10371 +09e9 : df0a06 > bbs 5,zpt,ok10371 + > trap ;bbs branch not taken +09ec : 4cec09 > jmp * ;failed anyway + > +09ef : >fail10371 + > trap ;bbr branch taken +09ef : 4cef09 > jmp * ;failed anyway + > +09f2 : >ok10371 + > tst_a $33,0 +09f2 : 08 > php ;save flags +09f3 : c933 > cmp #$33 ;test result + > trap_ne +09f5 : d0fe > bne * ;failed not equal (non zero) + > +09f7 : 68 > pla ;load status +09f8 : 48 > pha + > cmp_flag 0 +09f9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +09fb : d0fe > bne * ;failed not equal (non zero) + > +09fd : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +09fe : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0a00 : 48 > pha ;use stack to load status +0a01 : a9cc > lda #$cc ;precharge accu +0a03 : 28 > plp + > +0a04 : 5f0a06 > bbr 5,zpt,fail20371 +0a07 : df0a06 > bbs 5,zpt,ok20371 + > trap ;bbs branch not taken +0a0a : 4c0a0a > jmp * ;failed anyway + > +0a0d : >fail20371 + > trap ;bbr branch taken +0a0d : 4c0d0a > jmp * ;failed anyway + > +0a10 : >ok20371 + > tst_a $cc,$ff +0a10 : 08 > php ;save flags +0a11 : c9cc > cmp #$cc ;test result + > trap_ne +0a13 : d0fe > bne * ;failed not equal (non zero) + > +0a15 : 68 > pla ;load status +0a16 : 48 > pha + > cmp_flag $ff +0a17 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a19 : d0fe > bne * ;failed not equal (non zero) + > +0a1b : 28 > plp ;restore status + > +0a1c : a50a > lda zpt +0a1e : c920 > cmp #(1<<5) + > trap_ne ;zp altered +0a20 : d0fe > bne * ;failed not equal (non zero) + > +0a22 : a9df > lda #$ff-(1<<5) ;testing 1 bit off +0a24 : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +0a26 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0a28 : 48 > pha ;use stack to load status +0a29 : a933 > lda #$33 ;precharge accu +0a2b : 28 > plp + > +0a2c : df0a06 > bbs 5,zpt,fail30371 +0a2f : 5f0a06 > bbr 5,zpt,ok30371 + > trap ;bbr branch not taken +0a32 : 4c320a > jmp * ;failed anyway + > +0a35 : >fail30371 + > trap ;bbs branch taken +0a35 : 4c350a > jmp * ;failed anyway + > +0a38 : >ok30371 + > tst_a $33,0 +0a38 : 08 > php ;save flags +0a39 : c933 > cmp #$33 ;test result + > trap_ne +0a3b : d0fe > bne * ;failed not equal (non zero) + > +0a3d : 68 > pla ;load status +0a3e : 48 > pha + > cmp_flag 0 +0a3f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a41 : d0fe > bne * ;failed not equal (non zero) + > +0a43 : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +0a44 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0a46 : 48 > pha ;use stack to load status +0a47 : a9cc > lda #$cc ;precharge accu +0a49 : 28 > plp + > +0a4a : df0a06 > bbs 5,zpt,fail40371 +0a4d : 5f0a06 > bbr 5,zpt,ok40371 + > trap ;bbr branch not taken +0a50 : 4c500a > jmp * ;failed anyway + > +0a53 : >fail40371 + > trap ;bbs branch taken +0a53 : 4c530a > jmp * ;failed anyway + > +0a56 : >ok40371 + > tst_a $cc,$ff +0a56 : 08 > php ;save flags +0a57 : c9cc > cmp #$cc ;test result + > trap_ne +0a59 : d0fe > bne * ;failed not equal (non zero) + > +0a5b : 68 > pla ;load status +0a5c : 48 > pha + > cmp_flag $ff +0a5d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a5f : d0fe > bne * ;failed not equal (non zero) + > +0a61 : 28 > plp ;restore status + > +0a62 : a50a > lda zpt +0a64 : c9df > cmp #$ff-(1<<5) + > trap_ne ;zp altered +0a66 : d0fe > bne * ;failed not equal (non zero) + > + + bbt 6 +0a68 : a940 > lda #(1<<6) ;testing 1 bit on +0a6a : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +0a6c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0a6e : 48 > pha ;use stack to load status +0a6f : a933 > lda #$33 ;precharge accu +0a71 : 28 > plp + > +0a72 : 6f0a06 > bbr 6,zpt,fail10406 +0a75 : ef0a06 > bbs 6,zpt,ok10406 + > trap ;bbs branch not taken +0a78 : 4c780a > jmp * ;failed anyway + > +0a7b : >fail10406 + > trap ;bbr branch taken +0a7b : 4c7b0a > jmp * ;failed anyway + > +0a7e : >ok10406 + > tst_a $33,0 +0a7e : 08 > php ;save flags +0a7f : c933 > cmp #$33 ;test result + > trap_ne +0a81 : d0fe > bne * ;failed not equal (non zero) + > +0a83 : 68 > pla ;load status +0a84 : 48 > pha + > cmp_flag 0 +0a85 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0a87 : d0fe > bne * ;failed not equal (non zero) + > +0a89 : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +0a8a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0a8c : 48 > pha ;use stack to load status +0a8d : a9cc > lda #$cc ;precharge accu +0a8f : 28 > plp + > +0a90 : 6f0a06 > bbr 6,zpt,fail20406 +0a93 : ef0a06 > bbs 6,zpt,ok20406 + > trap ;bbs branch not taken +0a96 : 4c960a > jmp * ;failed anyway + > +0a99 : >fail20406 + > trap ;bbr branch taken +0a99 : 4c990a > jmp * ;failed anyway + > +0a9c : >ok20406 + > tst_a $cc,$ff +0a9c : 08 > php ;save flags +0a9d : c9cc > cmp #$cc ;test result + > trap_ne +0a9f : d0fe > bne * ;failed not equal (non zero) + > +0aa1 : 68 > pla ;load status +0aa2 : 48 > pha + > cmp_flag $ff +0aa3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0aa5 : d0fe > bne * ;failed not equal (non zero) + > +0aa7 : 28 > plp ;restore status + > +0aa8 : a50a > lda zpt +0aaa : c940 > cmp #(1<<6) + > trap_ne ;zp altered +0aac : d0fe > bne * ;failed not equal (non zero) + > +0aae : a9bf > lda #$ff-(1<<6) ;testing 1 bit off +0ab0 : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +0ab2 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0ab4 : 48 > pha ;use stack to load status +0ab5 : a933 > lda #$33 ;precharge accu +0ab7 : 28 > plp + > +0ab8 : ef0a06 > bbs 6,zpt,fail30406 +0abb : 6f0a06 > bbr 6,zpt,ok30406 + > trap ;bbr branch not taken +0abe : 4cbe0a > jmp * ;failed anyway + > +0ac1 : >fail30406 + > trap ;bbs branch taken +0ac1 : 4cc10a > jmp * ;failed anyway + > +0ac4 : >ok30406 + > tst_a $33,0 +0ac4 : 08 > php ;save flags +0ac5 : c933 > cmp #$33 ;test result + > trap_ne +0ac7 : d0fe > bne * ;failed not equal (non zero) + > +0ac9 : 68 > pla ;load status +0aca : 48 > pha + > cmp_flag 0 +0acb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0acd : d0fe > bne * ;failed not equal (non zero) + > +0acf : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +0ad0 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0ad2 : 48 > pha ;use stack to load status +0ad3 : a9cc > lda #$cc ;precharge accu +0ad5 : 28 > plp + > +0ad6 : ef0a06 > bbs 6,zpt,fail40406 +0ad9 : 6f0a06 > bbr 6,zpt,ok40406 + > trap ;bbr branch not taken +0adc : 4cdc0a > jmp * ;failed anyway + > +0adf : >fail40406 + > trap ;bbs branch taken +0adf : 4cdf0a > jmp * ;failed anyway + > +0ae2 : >ok40406 + > tst_a $cc,$ff +0ae2 : 08 > php ;save flags +0ae3 : c9cc > cmp #$cc ;test result + > trap_ne +0ae5 : d0fe > bne * ;failed not equal (non zero) + > +0ae7 : 68 > pla ;load status +0ae8 : 48 > pha + > cmp_flag $ff +0ae9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0aeb : d0fe > bne * ;failed not equal (non zero) + > +0aed : 28 > plp ;restore status + > +0aee : a50a > lda zpt +0af0 : c9bf > cmp #$ff-(1<<6) + > trap_ne ;zp altered +0af2 : d0fe > bne * ;failed not equal (non zero) + > + + bbt 7 +0af4 : a980 > lda #(1<<7) ;testing 1 bit on +0af6 : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +0af8 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0afa : 48 > pha ;use stack to load status +0afb : a933 > lda #$33 ;precharge accu +0afd : 28 > plp + > +0afe : 7f0a06 > bbr 7,zpt,fail10441 +0b01 : ff0a06 > bbs 7,zpt,ok10441 + > trap ;bbs branch not taken +0b04 : 4c040b > jmp * ;failed anyway + > +0b07 : >fail10441 + > trap ;bbr branch taken +0b07 : 4c070b > jmp * ;failed anyway + > +0b0a : >ok10441 + > tst_a $33,0 +0b0a : 08 > php ;save flags +0b0b : c933 > cmp #$33 ;test result + > trap_ne +0b0d : d0fe > bne * ;failed not equal (non zero) + > +0b0f : 68 > pla ;load status +0b10 : 48 > pha + > cmp_flag 0 +0b11 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b13 : d0fe > bne * ;failed not equal (non zero) + > +0b15 : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +0b16 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0b18 : 48 > pha ;use stack to load status +0b19 : a9cc > lda #$cc ;precharge accu +0b1b : 28 > plp + > +0b1c : 7f0a06 > bbr 7,zpt,fail20441 +0b1f : ff0a06 > bbs 7,zpt,ok20441 + > trap ;bbs branch not taken +0b22 : 4c220b > jmp * ;failed anyway + > +0b25 : >fail20441 + > trap ;bbr branch taken +0b25 : 4c250b > jmp * ;failed anyway + > +0b28 : >ok20441 + > tst_a $cc,$ff +0b28 : 08 > php ;save flags +0b29 : c9cc > cmp #$cc ;test result + > trap_ne +0b2b : d0fe > bne * ;failed not equal (non zero) + > +0b2d : 68 > pla ;load status +0b2e : 48 > pha + > cmp_flag $ff +0b2f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b31 : d0fe > bne * ;failed not equal (non zero) + > +0b33 : 28 > plp ;restore status + > +0b34 : a50a > lda zpt +0b36 : c980 > cmp #(1<<7) + > trap_ne ;zp altered +0b38 : d0fe > bne * ;failed not equal (non zero) + > +0b3a : a97f > lda #$ff-(1<<7) ;testing 1 bit off +0b3c : 850a > sta zpt + > set_a $33,0 ;with flags off + > load_flag 0 +0b3e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0b40 : 48 > pha ;use stack to load status +0b41 : a933 > lda #$33 ;precharge accu +0b43 : 28 > plp + > +0b44 : ff0a06 > bbs 7,zpt,fail30441 +0b47 : 7f0a06 > bbr 7,zpt,ok30441 + > trap ;bbr branch not taken +0b4a : 4c4a0b > jmp * ;failed anyway + > +0b4d : >fail30441 + > trap ;bbs branch taken +0b4d : 4c4d0b > jmp * ;failed anyway + > +0b50 : >ok30441 + > tst_a $33,0 +0b50 : 08 > php ;save flags +0b51 : c933 > cmp #$33 ;test result + > trap_ne +0b53 : d0fe > bne * ;failed not equal (non zero) + > +0b55 : 68 > pla ;load status +0b56 : 48 > pha + > cmp_flag 0 +0b57 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b59 : d0fe > bne * ;failed not equal (non zero) + > +0b5b : 28 > plp ;restore status + > + > set_a $cc,$ff ;with flags on + > load_flag $ff +0b5c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0b5e : 48 > pha ;use stack to load status +0b5f : a9cc > lda #$cc ;precharge accu +0b61 : 28 > plp + > +0b62 : ff0a06 > bbs 7,zpt,fail40441 +0b65 : 7f0a06 > bbr 7,zpt,ok40441 + > trap ;bbr branch not taken +0b68 : 4c680b > jmp * ;failed anyway + > +0b6b : >fail40441 + > trap ;bbs branch taken +0b6b : 4c6b0b > jmp * ;failed anyway + > +0b6e : >ok40441 + > tst_a $cc,$ff +0b6e : 08 > php ;save flags +0b6f : c9cc > cmp #$cc ;test result + > trap_ne +0b71 : d0fe > bne * ;failed not equal (non zero) + > +0b73 : 68 > pla ;load status +0b74 : 48 > pha + > cmp_flag $ff +0b75 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0b77 : d0fe > bne * ;failed not equal (non zero) + > +0b79 : 28 > plp ;restore status + > +0b7a : a50a > lda zpt +0b7c : c97f > cmp #$ff-(1<<7) + > trap_ne ;zp altered +0b7e : d0fe > bne * ;failed not equal (non zero) + > + +0b80 : e011 cpx #$11 + trap_ne ;x overwritten +0b82 : d0fe > bne * ;failed not equal (non zero) + +0b84 : c022 cpy #$22 + trap_ne ;y overwritten +0b86 : d0fe > bne * ;failed not equal (non zero) + + next_test +0b88 : ad0202 > lda test_case ;previous test +0b8b : c906 > cmp #test_num + > trap_ne ;test is out of sequence +0b8d : d0fe > bne * ;failed not equal (non zero) + > +0007 = >test_num = test_num + 1 +0b8f : a907 > lda #test_num ;*** next tests' number +0b91 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + bbrc macro ;\1 = bitnum + bbr \1,zpt,skip\? + eor #(1<<\1) + skip\? + endm + bbsc macro ;\1 = bitnum + bbs \1,zpt,skip\? + eor #(1<<\1) + skip\? + endm + +0b94 : a900 lda #0 ;combined bit test +0b96 : 850a sta zpt +0b98 : a900 bbcl lda #0 + bbrc 0 +0b9a : 0f0a02 > bbr 0,zpt,skip0480 +0b9d : 4901 > eor #(1<<0) +0b9f : >skip0480 + + bbrc 1 +0b9f : 1f0a02 > bbr 1,zpt,skip0481 +0ba2 : 4902 > eor #(1<<1) +0ba4 : >skip0481 + + bbrc 2 +0ba4 : 2f0a02 > bbr 2,zpt,skip0482 +0ba7 : 4904 > eor #(1<<2) +0ba9 : >skip0482 + + bbrc 3 +0ba9 : 3f0a02 > bbr 3,zpt,skip0483 +0bac : 4908 > eor #(1<<3) +0bae : >skip0483 + + bbrc 4 +0bae : 4f0a02 > bbr 4,zpt,skip0484 +0bb1 : 4910 > eor #(1<<4) +0bb3 : >skip0484 + + bbrc 5 +0bb3 : 5f0a02 > bbr 5,zpt,skip0485 +0bb6 : 4920 > eor #(1<<5) +0bb8 : >skip0485 + + bbrc 6 +0bb8 : 6f0a02 > bbr 6,zpt,skip0486 +0bbb : 4940 > eor #(1<<6) +0bbd : >skip0486 + + bbrc 7 +0bbd : 7f0a02 > bbr 7,zpt,skip0487 +0bc0 : 4980 > eor #(1<<7) +0bc2 : >skip0487 + +0bc2 : 450a eor zpt + trap_ne ;failed bbr bitnum in accu +0bc4 : d0fe > bne * ;failed not equal (non zero) + +0bc6 : a9ff lda #$ff + bbsc 0 +0bc8 : 8f0a02 > bbs 0,zpt,skip0489 +0bcb : 4901 > eor #(1<<0) +0bcd : >skip0489 + + bbsc 1 +0bcd : 9f0a02 > bbs 1,zpt,skip0490 +0bd0 : 4902 > eor #(1<<1) +0bd2 : >skip0490 + + bbsc 2 +0bd2 : af0a02 > bbs 2,zpt,skip0491 +0bd5 : 4904 > eor #(1<<2) +0bd7 : >skip0491 + + bbsc 3 +0bd7 : bf0a02 > bbs 3,zpt,skip0492 +0bda : 4908 > eor #(1<<3) +0bdc : >skip0492 + + bbsc 4 +0bdc : cf0a02 > bbs 4,zpt,skip0493 +0bdf : 4910 > eor #(1<<4) +0be1 : >skip0493 + + bbsc 5 +0be1 : df0a02 > bbs 5,zpt,skip0494 +0be4 : 4920 > eor #(1<<5) +0be6 : >skip0494 + + bbsc 6 +0be6 : ef0a02 > bbs 6,zpt,skip0495 +0be9 : 4940 > eor #(1<<6) +0beb : >skip0495 + + bbsc 7 +0beb : ff0a02 > bbs 7,zpt,skip0496 +0bee : 4980 > eor #(1<<7) +0bf0 : >skip0496 + +0bf0 : 450a eor zpt + trap_ne ;failed bbs bitnum in accu +0bf2 : d0fe > bne * ;failed not equal (non zero) + +0bf4 : e60a inc zpt +0bf6 : d0a0 bne bbcl + next_test +0bf8 : ad0202 > lda test_case ;previous test +0bfb : c907 > cmp #test_num + > trap_ne ;test is out of sequence +0bfd : d0fe > bne * ;failed not equal (non zero) + > +0008 = >test_num = test_num + 1 +0bff : a908 > lda #test_num ;*** next tests' number +0c01 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + endif + + ; testing NOP + + nop_test macro ;\1 = opcode, \2 = # of bytes + ldy #$42 + ldx #4-\2 + db \1 ;test nop length + if \2 = 1 + dex + dex + endif + if \2 = 2 + iny + dex + endif + if \2 = 3 + iny + iny + endif + dex + trap_ne ;wrong number of bytes + set_a $ff-\1,0 + db \1 ;test nop integrity - flags off + nop + nop + tst_a $ff-\1,0 + set_a $aa-\1,$ff + db \1 ;test nop integrity - flags on + nop + nop + tst_a $aa-\1,$ff + cpy #$42 + trap_ne ;y changed + cpx #0 + trap_ne ;x changed + endm + + nop_test $02,2 +0c04 : a042 > ldy #$42 +0c06 : a202 > ldx #4-2 +0c08 : 02 > db $02 ;test nop length + > if 2 = 1 + > dex + > dex + > endif + > if 2 = 2 +0c09 : c8 > iny +0c0a : ca > dex + > endif + > if 2 = 3 + > iny + > iny + > endif +0c0b : ca > dex + > trap_ne ;wrong number of bytes +0c0c : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$02,0 + > load_flag 0 +0c0e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0c10 : 48 > pha ;use stack to load status +0c11 : a9fd > lda #$ff-$02 ;precharge accu +0c13 : 28 > plp + > +0c14 : 02 > db $02 ;test nop integrity - flags off +0c15 : ea > nop +0c16 : ea > nop + > tst_a $ff-$02,0 +0c17 : 08 > php ;save flags +0c18 : c9fd > cmp #$ff-$02 ;test result + > trap_ne +0c1a : d0fe > bne * ;failed not equal (non zero) + > +0c1c : 68 > pla ;load status +0c1d : 48 > pha + > cmp_flag 0 +0c1e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c20 : d0fe > bne * ;failed not equal (non zero) + > +0c22 : 28 > plp ;restore status + > + > set_a $aa-$02,$ff + > load_flag $ff +0c23 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0c25 : 48 > pha ;use stack to load status +0c26 : a9a8 > lda #$aa-$02 ;precharge accu +0c28 : 28 > plp + > +0c29 : 02 > db $02 ;test nop integrity - flags on +0c2a : ea > nop +0c2b : ea > nop + > tst_a $aa-$02,$ff +0c2c : 08 > php ;save flags +0c2d : c9a8 > cmp #$aa-$02 ;test result + > trap_ne +0c2f : d0fe > bne * ;failed not equal (non zero) + > +0c31 : 68 > pla ;load status +0c32 : 48 > pha + > cmp_flag $ff +0c33 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c35 : d0fe > bne * ;failed not equal (non zero) + > +0c37 : 28 > plp ;restore status + > +0c38 : c042 > cpy #$42 + > trap_ne ;y changed +0c3a : d0fe > bne * ;failed not equal (non zero) + > +0c3c : e000 > cpx #0 + > trap_ne ;x changed +0c3e : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $22,2 +0c40 : a042 > ldy #$42 +0c42 : a202 > ldx #4-2 +0c44 : 22 > db $22 ;test nop length + > if 2 = 1 + > dex + > dex + > endif + > if 2 = 2 +0c45 : c8 > iny +0c46 : ca > dex + > endif + > if 2 = 3 + > iny + > iny + > endif +0c47 : ca > dex + > trap_ne ;wrong number of bytes +0c48 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$22,0 + > load_flag 0 +0c4a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0c4c : 48 > pha ;use stack to load status +0c4d : a9dd > lda #$ff-$22 ;precharge accu +0c4f : 28 > plp + > +0c50 : 22 > db $22 ;test nop integrity - flags off +0c51 : ea > nop +0c52 : ea > nop + > tst_a $ff-$22,0 +0c53 : 08 > php ;save flags +0c54 : c9dd > cmp #$ff-$22 ;test result + > trap_ne +0c56 : d0fe > bne * ;failed not equal (non zero) + > +0c58 : 68 > pla ;load status +0c59 : 48 > pha + > cmp_flag 0 +0c5a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c5c : d0fe > bne * ;failed not equal (non zero) + > +0c5e : 28 > plp ;restore status + > + > set_a $aa-$22,$ff + > load_flag $ff +0c5f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0c61 : 48 > pha ;use stack to load status +0c62 : a988 > lda #$aa-$22 ;precharge accu +0c64 : 28 > plp + > +0c65 : 22 > db $22 ;test nop integrity - flags on +0c66 : ea > nop +0c67 : ea > nop + > tst_a $aa-$22,$ff +0c68 : 08 > php ;save flags +0c69 : c988 > cmp #$aa-$22 ;test result + > trap_ne +0c6b : d0fe > bne * ;failed not equal (non zero) + > +0c6d : 68 > pla ;load status +0c6e : 48 > pha + > cmp_flag $ff +0c6f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c71 : d0fe > bne * ;failed not equal (non zero) + > +0c73 : 28 > plp ;restore status + > +0c74 : c042 > cpy #$42 + > trap_ne ;y changed +0c76 : d0fe > bne * ;failed not equal (non zero) + > +0c78 : e000 > cpx #0 + > trap_ne ;x changed +0c7a : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $42,2 +0c7c : a042 > ldy #$42 +0c7e : a202 > ldx #4-2 +0c80 : 42 > db $42 ;test nop length + > if 2 = 1 + > dex + > dex + > endif + > if 2 = 2 +0c81 : c8 > iny +0c82 : ca > dex + > endif + > if 2 = 3 + > iny + > iny + > endif +0c83 : ca > dex + > trap_ne ;wrong number of bytes +0c84 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$42,0 + > load_flag 0 +0c86 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0c88 : 48 > pha ;use stack to load status +0c89 : a9bd > lda #$ff-$42 ;precharge accu +0c8b : 28 > plp + > +0c8c : 42 > db $42 ;test nop integrity - flags off +0c8d : ea > nop +0c8e : ea > nop + > tst_a $ff-$42,0 +0c8f : 08 > php ;save flags +0c90 : c9bd > cmp #$ff-$42 ;test result + > trap_ne +0c92 : d0fe > bne * ;failed not equal (non zero) + > +0c94 : 68 > pla ;load status +0c95 : 48 > pha + > cmp_flag 0 +0c96 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0c98 : d0fe > bne * ;failed not equal (non zero) + > +0c9a : 28 > plp ;restore status + > + > set_a $aa-$42,$ff + > load_flag $ff +0c9b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0c9d : 48 > pha ;use stack to load status +0c9e : a968 > lda #$aa-$42 ;precharge accu +0ca0 : 28 > plp + > +0ca1 : 42 > db $42 ;test nop integrity - flags on +0ca2 : ea > nop +0ca3 : ea > nop + > tst_a $aa-$42,$ff +0ca4 : 08 > php ;save flags +0ca5 : c968 > cmp #$aa-$42 ;test result + > trap_ne +0ca7 : d0fe > bne * ;failed not equal (non zero) + > +0ca9 : 68 > pla ;load status +0caa : 48 > pha + > cmp_flag $ff +0cab : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0cad : d0fe > bne * ;failed not equal (non zero) + > +0caf : 28 > plp ;restore status + > +0cb0 : c042 > cpy #$42 + > trap_ne ;y changed +0cb2 : d0fe > bne * ;failed not equal (non zero) + > +0cb4 : e000 > cpx #0 + > trap_ne ;x changed +0cb6 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $62,2 +0cb8 : a042 > ldy #$42 +0cba : a202 > ldx #4-2 +0cbc : 62 > db $62 ;test nop length + > if 2 = 1 + > dex + > dex + > endif + > if 2 = 2 +0cbd : c8 > iny +0cbe : ca > dex + > endif + > if 2 = 3 + > iny + > iny + > endif +0cbf : ca > dex + > trap_ne ;wrong number of bytes +0cc0 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$62,0 + > load_flag 0 +0cc2 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0cc4 : 48 > pha ;use stack to load status +0cc5 : a99d > lda #$ff-$62 ;precharge accu +0cc7 : 28 > plp + > +0cc8 : 62 > db $62 ;test nop integrity - flags off +0cc9 : ea > nop +0cca : ea > nop + > tst_a $ff-$62,0 +0ccb : 08 > php ;save flags +0ccc : c99d > cmp #$ff-$62 ;test result + > trap_ne +0cce : d0fe > bne * ;failed not equal (non zero) + > +0cd0 : 68 > pla ;load status +0cd1 : 48 > pha + > cmp_flag 0 +0cd2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0cd4 : d0fe > bne * ;failed not equal (non zero) + > +0cd6 : 28 > plp ;restore status + > + > set_a $aa-$62,$ff + > load_flag $ff +0cd7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0cd9 : 48 > pha ;use stack to load status +0cda : a948 > lda #$aa-$62 ;precharge accu +0cdc : 28 > plp + > +0cdd : 62 > db $62 ;test nop integrity - flags on +0cde : ea > nop +0cdf : ea > nop + > tst_a $aa-$62,$ff +0ce0 : 08 > php ;save flags +0ce1 : c948 > cmp #$aa-$62 ;test result + > trap_ne +0ce3 : d0fe > bne * ;failed not equal (non zero) + > +0ce5 : 68 > pla ;load status +0ce6 : 48 > pha + > cmp_flag $ff +0ce7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0ce9 : d0fe > bne * ;failed not equal (non zero) + > +0ceb : 28 > plp ;restore status + > +0cec : c042 > cpy #$42 + > trap_ne ;y changed +0cee : d0fe > bne * ;failed not equal (non zero) + > +0cf0 : e000 > cpx #0 + > trap_ne ;x changed +0cf2 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $82,2 +0cf4 : a042 > ldy #$42 +0cf6 : a202 > ldx #4-2 +0cf8 : 82 > db $82 ;test nop length + > if 2 = 1 + > dex + > dex + > endif + > if 2 = 2 +0cf9 : c8 > iny +0cfa : ca > dex + > endif + > if 2 = 3 + > iny + > iny + > endif +0cfb : ca > dex + > trap_ne ;wrong number of bytes +0cfc : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$82,0 + > load_flag 0 +0cfe : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0d00 : 48 > pha ;use stack to load status +0d01 : a97d > lda #$ff-$82 ;precharge accu +0d03 : 28 > plp + > +0d04 : 82 > db $82 ;test nop integrity - flags off +0d05 : ea > nop +0d06 : ea > nop + > tst_a $ff-$82,0 +0d07 : 08 > php ;save flags +0d08 : c97d > cmp #$ff-$82 ;test result + > trap_ne +0d0a : d0fe > bne * ;failed not equal (non zero) + > +0d0c : 68 > pla ;load status +0d0d : 48 > pha + > cmp_flag 0 +0d0e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0d10 : d0fe > bne * ;failed not equal (non zero) + > +0d12 : 28 > plp ;restore status + > + > set_a $aa-$82,$ff + > load_flag $ff +0d13 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0d15 : 48 > pha ;use stack to load status +0d16 : a928 > lda #$aa-$82 ;precharge accu +0d18 : 28 > plp + > +0d19 : 82 > db $82 ;test nop integrity - flags on +0d1a : ea > nop +0d1b : ea > nop + > tst_a $aa-$82,$ff +0d1c : 08 > php ;save flags +0d1d : c928 > cmp #$aa-$82 ;test result + > trap_ne +0d1f : d0fe > bne * ;failed not equal (non zero) + > +0d21 : 68 > pla ;load status +0d22 : 48 > pha + > cmp_flag $ff +0d23 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0d25 : d0fe > bne * ;failed not equal (non zero) + > +0d27 : 28 > plp ;restore status + > +0d28 : c042 > cpy #$42 + > trap_ne ;y changed +0d2a : d0fe > bne * ;failed not equal (non zero) + > +0d2c : e000 > cpx #0 + > trap_ne ;x changed +0d2e : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $c2,2 +0d30 : a042 > ldy #$42 +0d32 : a202 > ldx #4-2 +0d34 : c2 > db $c2 ;test nop length + > if 2 = 1 + > dex + > dex + > endif + > if 2 = 2 +0d35 : c8 > iny +0d36 : ca > dex + > endif + > if 2 = 3 + > iny + > iny + > endif +0d37 : ca > dex + > trap_ne ;wrong number of bytes +0d38 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$c2,0 + > load_flag 0 +0d3a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0d3c : 48 > pha ;use stack to load status +0d3d : a93d > lda #$ff-$c2 ;precharge accu +0d3f : 28 > plp + > +0d40 : c2 > db $c2 ;test nop integrity - flags off +0d41 : ea > nop +0d42 : ea > nop + > tst_a $ff-$c2,0 +0d43 : 08 > php ;save flags +0d44 : c93d > cmp #$ff-$c2 ;test result + > trap_ne +0d46 : d0fe > bne * ;failed not equal (non zero) + > +0d48 : 68 > pla ;load status +0d49 : 48 > pha + > cmp_flag 0 +0d4a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0d4c : d0fe > bne * ;failed not equal (non zero) + > +0d4e : 28 > plp ;restore status + > + > set_a $aa-$c2,$ff + > load_flag $ff +0d4f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0d51 : 48 > pha ;use stack to load status +0d52 : a9e8 > lda #$aa-$c2 ;precharge accu +0d54 : 28 > plp + > +0d55 : c2 > db $c2 ;test nop integrity - flags on +0d56 : ea > nop +0d57 : ea > nop + > tst_a $aa-$c2,$ff +0d58 : 08 > php ;save flags +0d59 : c9e8 > cmp #$aa-$c2 ;test result + > trap_ne +0d5b : d0fe > bne * ;failed not equal (non zero) + > +0d5d : 68 > pla ;load status +0d5e : 48 > pha + > cmp_flag $ff +0d5f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0d61 : d0fe > bne * ;failed not equal (non zero) + > +0d63 : 28 > plp ;restore status + > +0d64 : c042 > cpy #$42 + > trap_ne ;y changed +0d66 : d0fe > bne * ;failed not equal (non zero) + > +0d68 : e000 > cpx #0 + > trap_ne ;x changed +0d6a : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $e2,2 +0d6c : a042 > ldy #$42 +0d6e : a202 > ldx #4-2 +0d70 : e2 > db $e2 ;test nop length + > if 2 = 1 + > dex + > dex + > endif + > if 2 = 2 +0d71 : c8 > iny +0d72 : ca > dex + > endif + > if 2 = 3 + > iny + > iny + > endif +0d73 : ca > dex + > trap_ne ;wrong number of bytes +0d74 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$e2,0 + > load_flag 0 +0d76 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0d78 : 48 > pha ;use stack to load status +0d79 : a91d > lda #$ff-$e2 ;precharge accu +0d7b : 28 > plp + > +0d7c : e2 > db $e2 ;test nop integrity - flags off +0d7d : ea > nop +0d7e : ea > nop + > tst_a $ff-$e2,0 +0d7f : 08 > php ;save flags +0d80 : c91d > cmp #$ff-$e2 ;test result + > trap_ne +0d82 : d0fe > bne * ;failed not equal (non zero) + > +0d84 : 68 > pla ;load status +0d85 : 48 > pha + > cmp_flag 0 +0d86 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0d88 : d0fe > bne * ;failed not equal (non zero) + > +0d8a : 28 > plp ;restore status + > + > set_a $aa-$e2,$ff + > load_flag $ff +0d8b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0d8d : 48 > pha ;use stack to load status +0d8e : a9c8 > lda #$aa-$e2 ;precharge accu +0d90 : 28 > plp + > +0d91 : e2 > db $e2 ;test nop integrity - flags on +0d92 : ea > nop +0d93 : ea > nop + > tst_a $aa-$e2,$ff +0d94 : 08 > php ;save flags +0d95 : c9c8 > cmp #$aa-$e2 ;test result + > trap_ne +0d97 : d0fe > bne * ;failed not equal (non zero) + > +0d99 : 68 > pla ;load status +0d9a : 48 > pha + > cmp_flag $ff +0d9b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0d9d : d0fe > bne * ;failed not equal (non zero) + > +0d9f : 28 > plp ;restore status + > +0da0 : c042 > cpy #$42 + > trap_ne ;y changed +0da2 : d0fe > bne * ;failed not equal (non zero) + > +0da4 : e000 > cpx #0 + > trap_ne ;x changed +0da6 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $44,2 +0da8 : a042 > ldy #$42 +0daa : a202 > ldx #4-2 +0dac : 44 > db $44 ;test nop length + > if 2 = 1 + > dex + > dex + > endif + > if 2 = 2 +0dad : c8 > iny +0dae : ca > dex + > endif + > if 2 = 3 + > iny + > iny + > endif +0daf : ca > dex + > trap_ne ;wrong number of bytes +0db0 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$44,0 + > load_flag 0 +0db2 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0db4 : 48 > pha ;use stack to load status +0db5 : a9bb > lda #$ff-$44 ;precharge accu +0db7 : 28 > plp + > +0db8 : 44 > db $44 ;test nop integrity - flags off +0db9 : ea > nop +0dba : ea > nop + > tst_a $ff-$44,0 +0dbb : 08 > php ;save flags +0dbc : c9bb > cmp #$ff-$44 ;test result + > trap_ne +0dbe : d0fe > bne * ;failed not equal (non zero) + > +0dc0 : 68 > pla ;load status +0dc1 : 48 > pha + > cmp_flag 0 +0dc2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0dc4 : d0fe > bne * ;failed not equal (non zero) + > +0dc6 : 28 > plp ;restore status + > + > set_a $aa-$44,$ff + > load_flag $ff +0dc7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0dc9 : 48 > pha ;use stack to load status +0dca : a966 > lda #$aa-$44 ;precharge accu +0dcc : 28 > plp + > +0dcd : 44 > db $44 ;test nop integrity - flags on +0dce : ea > nop +0dcf : ea > nop + > tst_a $aa-$44,$ff +0dd0 : 08 > php ;save flags +0dd1 : c966 > cmp #$aa-$44 ;test result + > trap_ne +0dd3 : d0fe > bne * ;failed not equal (non zero) + > +0dd5 : 68 > pla ;load status +0dd6 : 48 > pha + > cmp_flag $ff +0dd7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0dd9 : d0fe > bne * ;failed not equal (non zero) + > +0ddb : 28 > plp ;restore status + > +0ddc : c042 > cpy #$42 + > trap_ne ;y changed +0dde : d0fe > bne * ;failed not equal (non zero) + > +0de0 : e000 > cpx #0 + > trap_ne ;x changed +0de2 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $54,2 +0de4 : a042 > ldy #$42 +0de6 : a202 > ldx #4-2 +0de8 : 54 > db $54 ;test nop length + > if 2 = 1 + > dex + > dex + > endif + > if 2 = 2 +0de9 : c8 > iny +0dea : ca > dex + > endif + > if 2 = 3 + > iny + > iny + > endif +0deb : ca > dex + > trap_ne ;wrong number of bytes +0dec : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$54,0 + > load_flag 0 +0dee : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0df0 : 48 > pha ;use stack to load status +0df1 : a9ab > lda #$ff-$54 ;precharge accu +0df3 : 28 > plp + > +0df4 : 54 > db $54 ;test nop integrity - flags off +0df5 : ea > nop +0df6 : ea > nop + > tst_a $ff-$54,0 +0df7 : 08 > php ;save flags +0df8 : c9ab > cmp #$ff-$54 ;test result + > trap_ne +0dfa : d0fe > bne * ;failed not equal (non zero) + > +0dfc : 68 > pla ;load status +0dfd : 48 > pha + > cmp_flag 0 +0dfe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0e00 : d0fe > bne * ;failed not equal (non zero) + > +0e02 : 28 > plp ;restore status + > + > set_a $aa-$54,$ff + > load_flag $ff +0e03 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0e05 : 48 > pha ;use stack to load status +0e06 : a956 > lda #$aa-$54 ;precharge accu +0e08 : 28 > plp + > +0e09 : 54 > db $54 ;test nop integrity - flags on +0e0a : ea > nop +0e0b : ea > nop + > tst_a $aa-$54,$ff +0e0c : 08 > php ;save flags +0e0d : c956 > cmp #$aa-$54 ;test result + > trap_ne +0e0f : d0fe > bne * ;failed not equal (non zero) + > +0e11 : 68 > pla ;load status +0e12 : 48 > pha + > cmp_flag $ff +0e13 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0e15 : d0fe > bne * ;failed not equal (non zero) + > +0e17 : 28 > plp ;restore status + > +0e18 : c042 > cpy #$42 + > trap_ne ;y changed +0e1a : d0fe > bne * ;failed not equal (non zero) + > +0e1c : e000 > cpx #0 + > trap_ne ;x changed +0e1e : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $d4,2 +0e20 : a042 > ldy #$42 +0e22 : a202 > ldx #4-2 +0e24 : d4 > db $d4 ;test nop length + > if 2 = 1 + > dex + > dex + > endif + > if 2 = 2 +0e25 : c8 > iny +0e26 : ca > dex + > endif + > if 2 = 3 + > iny + > iny + > endif +0e27 : ca > dex + > trap_ne ;wrong number of bytes +0e28 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$d4,0 + > load_flag 0 +0e2a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0e2c : 48 > pha ;use stack to load status +0e2d : a92b > lda #$ff-$d4 ;precharge accu +0e2f : 28 > plp + > +0e30 : d4 > db $d4 ;test nop integrity - flags off +0e31 : ea > nop +0e32 : ea > nop + > tst_a $ff-$d4,0 +0e33 : 08 > php ;save flags +0e34 : c92b > cmp #$ff-$d4 ;test result + > trap_ne +0e36 : d0fe > bne * ;failed not equal (non zero) + > +0e38 : 68 > pla ;load status +0e39 : 48 > pha + > cmp_flag 0 +0e3a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0e3c : d0fe > bne * ;failed not equal (non zero) + > +0e3e : 28 > plp ;restore status + > + > set_a $aa-$d4,$ff + > load_flag $ff +0e3f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0e41 : 48 > pha ;use stack to load status +0e42 : a9d6 > lda #$aa-$d4 ;precharge accu +0e44 : 28 > plp + > +0e45 : d4 > db $d4 ;test nop integrity - flags on +0e46 : ea > nop +0e47 : ea > nop + > tst_a $aa-$d4,$ff +0e48 : 08 > php ;save flags +0e49 : c9d6 > cmp #$aa-$d4 ;test result + > trap_ne +0e4b : d0fe > bne * ;failed not equal (non zero) + > +0e4d : 68 > pla ;load status +0e4e : 48 > pha + > cmp_flag $ff +0e4f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0e51 : d0fe > bne * ;failed not equal (non zero) + > +0e53 : 28 > plp ;restore status + > +0e54 : c042 > cpy #$42 + > trap_ne ;y changed +0e56 : d0fe > bne * ;failed not equal (non zero) + > +0e58 : e000 > cpx #0 + > trap_ne ;x changed +0e5a : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $f4,2 +0e5c : a042 > ldy #$42 +0e5e : a202 > ldx #4-2 +0e60 : f4 > db $f4 ;test nop length + > if 2 = 1 + > dex + > dex + > endif + > if 2 = 2 +0e61 : c8 > iny +0e62 : ca > dex + > endif + > if 2 = 3 + > iny + > iny + > endif +0e63 : ca > dex + > trap_ne ;wrong number of bytes +0e64 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$f4,0 + > load_flag 0 +0e66 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0e68 : 48 > pha ;use stack to load status +0e69 : a90b > lda #$ff-$f4 ;precharge accu +0e6b : 28 > plp + > +0e6c : f4 > db $f4 ;test nop integrity - flags off +0e6d : ea > nop +0e6e : ea > nop + > tst_a $ff-$f4,0 +0e6f : 08 > php ;save flags +0e70 : c90b > cmp #$ff-$f4 ;test result + > trap_ne +0e72 : d0fe > bne * ;failed not equal (non zero) + > +0e74 : 68 > pla ;load status +0e75 : 48 > pha + > cmp_flag 0 +0e76 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0e78 : d0fe > bne * ;failed not equal (non zero) + > +0e7a : 28 > plp ;restore status + > + > set_a $aa-$f4,$ff + > load_flag $ff +0e7b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0e7d : 48 > pha ;use stack to load status +0e7e : a9b6 > lda #$aa-$f4 ;precharge accu +0e80 : 28 > plp + > +0e81 : f4 > db $f4 ;test nop integrity - flags on +0e82 : ea > nop +0e83 : ea > nop + > tst_a $aa-$f4,$ff +0e84 : 08 > php ;save flags +0e85 : c9b6 > cmp #$aa-$f4 ;test result + > trap_ne +0e87 : d0fe > bne * ;failed not equal (non zero) + > +0e89 : 68 > pla ;load status +0e8a : 48 > pha + > cmp_flag $ff +0e8b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0e8d : d0fe > bne * ;failed not equal (non zero) + > +0e8f : 28 > plp ;restore status + > +0e90 : c042 > cpy #$42 + > trap_ne ;y changed +0e92 : d0fe > bne * ;failed not equal (non zero) + > +0e94 : e000 > cpx #0 + > trap_ne ;x changed +0e96 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $5c,3 +0e98 : a042 > ldy #$42 +0e9a : a201 > ldx #4-3 +0e9c : 5c > db $5c ;test nop length + > if 3 = 1 + > dex + > dex + > endif + > if 3 = 2 + > iny + > dex + > endif + > if 3 = 3 +0e9d : c8 > iny +0e9e : c8 > iny + > endif +0e9f : ca > dex + > trap_ne ;wrong number of bytes +0ea0 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$5c,0 + > load_flag 0 +0ea2 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0ea4 : 48 > pha ;use stack to load status +0ea5 : a9a3 > lda #$ff-$5c ;precharge accu +0ea7 : 28 > plp + > +0ea8 : 5c > db $5c ;test nop integrity - flags off +0ea9 : ea > nop +0eaa : ea > nop + > tst_a $ff-$5c,0 +0eab : 08 > php ;save flags +0eac : c9a3 > cmp #$ff-$5c ;test result + > trap_ne +0eae : d0fe > bne * ;failed not equal (non zero) + > +0eb0 : 68 > pla ;load status +0eb1 : 48 > pha + > cmp_flag 0 +0eb2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0eb4 : d0fe > bne * ;failed not equal (non zero) + > +0eb6 : 28 > plp ;restore status + > + > set_a $aa-$5c,$ff + > load_flag $ff +0eb7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0eb9 : 48 > pha ;use stack to load status +0eba : a94e > lda #$aa-$5c ;precharge accu +0ebc : 28 > plp + > +0ebd : 5c > db $5c ;test nop integrity - flags on +0ebe : ea > nop +0ebf : ea > nop + > tst_a $aa-$5c,$ff +0ec0 : 08 > php ;save flags +0ec1 : c94e > cmp #$aa-$5c ;test result + > trap_ne +0ec3 : d0fe > bne * ;failed not equal (non zero) + > +0ec5 : 68 > pla ;load status +0ec6 : 48 > pha + > cmp_flag $ff +0ec7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0ec9 : d0fe > bne * ;failed not equal (non zero) + > +0ecb : 28 > plp ;restore status + > +0ecc : c042 > cpy #$42 + > trap_ne ;y changed +0ece : d0fe > bne * ;failed not equal (non zero) + > +0ed0 : e000 > cpx #0 + > trap_ne ;x changed +0ed2 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $dc,3 +0ed4 : a042 > ldy #$42 +0ed6 : a201 > ldx #4-3 +0ed8 : dc > db $dc ;test nop length + > if 3 = 1 + > dex + > dex + > endif + > if 3 = 2 + > iny + > dex + > endif + > if 3 = 3 +0ed9 : c8 > iny +0eda : c8 > iny + > endif +0edb : ca > dex + > trap_ne ;wrong number of bytes +0edc : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$dc,0 + > load_flag 0 +0ede : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0ee0 : 48 > pha ;use stack to load status +0ee1 : a923 > lda #$ff-$dc ;precharge accu +0ee3 : 28 > plp + > +0ee4 : dc > db $dc ;test nop integrity - flags off +0ee5 : ea > nop +0ee6 : ea > nop + > tst_a $ff-$dc,0 +0ee7 : 08 > php ;save flags +0ee8 : c923 > cmp #$ff-$dc ;test result + > trap_ne +0eea : d0fe > bne * ;failed not equal (non zero) + > +0eec : 68 > pla ;load status +0eed : 48 > pha + > cmp_flag 0 +0eee : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0ef0 : d0fe > bne * ;failed not equal (non zero) + > +0ef2 : 28 > plp ;restore status + > + > set_a $aa-$dc,$ff + > load_flag $ff +0ef3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0ef5 : 48 > pha ;use stack to load status +0ef6 : a9ce > lda #$aa-$dc ;precharge accu +0ef8 : 28 > plp + > +0ef9 : dc > db $dc ;test nop integrity - flags on +0efa : ea > nop +0efb : ea > nop + > tst_a $aa-$dc,$ff +0efc : 08 > php ;save flags +0efd : c9ce > cmp #$aa-$dc ;test result + > trap_ne +0eff : d0fe > bne * ;failed not equal (non zero) + > +0f01 : 68 > pla ;load status +0f02 : 48 > pha + > cmp_flag $ff +0f03 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0f05 : d0fe > bne * ;failed not equal (non zero) + > +0f07 : 28 > plp ;restore status + > +0f08 : c042 > cpy #$42 + > trap_ne ;y changed +0f0a : d0fe > bne * ;failed not equal (non zero) + > +0f0c : e000 > cpx #0 + > trap_ne ;x changed +0f0e : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $fc,3 +0f10 : a042 > ldy #$42 +0f12 : a201 > ldx #4-3 +0f14 : fc > db $fc ;test nop length + > if 3 = 1 + > dex + > dex + > endif + > if 3 = 2 + > iny + > dex + > endif + > if 3 = 3 +0f15 : c8 > iny +0f16 : c8 > iny + > endif +0f17 : ca > dex + > trap_ne ;wrong number of bytes +0f18 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$fc,0 + > load_flag 0 +0f1a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0f1c : 48 > pha ;use stack to load status +0f1d : a903 > lda #$ff-$fc ;precharge accu +0f1f : 28 > plp + > +0f20 : fc > db $fc ;test nop integrity - flags off +0f21 : ea > nop +0f22 : ea > nop + > tst_a $ff-$fc,0 +0f23 : 08 > php ;save flags +0f24 : c903 > cmp #$ff-$fc ;test result + > trap_ne +0f26 : d0fe > bne * ;failed not equal (non zero) + > +0f28 : 68 > pla ;load status +0f29 : 48 > pha + > cmp_flag 0 +0f2a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0f2c : d0fe > bne * ;failed not equal (non zero) + > +0f2e : 28 > plp ;restore status + > + > set_a $aa-$fc,$ff + > load_flag $ff +0f2f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0f31 : 48 > pha ;use stack to load status +0f32 : a9ae > lda #$aa-$fc ;precharge accu +0f34 : 28 > plp + > +0f35 : fc > db $fc ;test nop integrity - flags on +0f36 : ea > nop +0f37 : ea > nop + > tst_a $aa-$fc,$ff +0f38 : 08 > php ;save flags +0f39 : c9ae > cmp #$aa-$fc ;test result + > trap_ne +0f3b : d0fe > bne * ;failed not equal (non zero) + > +0f3d : 68 > pla ;load status +0f3e : 48 > pha + > cmp_flag $ff +0f3f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0f41 : d0fe > bne * ;failed not equal (non zero) + > +0f43 : 28 > plp ;restore status + > +0f44 : c042 > cpy #$42 + > trap_ne ;y changed +0f46 : d0fe > bne * ;failed not equal (non zero) + > +0f48 : e000 > cpx #0 + > trap_ne ;x changed +0f4a : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $03,1 +0f4c : a042 > ldy #$42 +0f4e : a203 > ldx #4-1 +0f50 : 03 > db $03 ;test nop length + > if 1 = 1 +0f51 : ca > dex +0f52 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +0f53 : ca > dex + > trap_ne ;wrong number of bytes +0f54 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$03,0 + > load_flag 0 +0f56 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0f58 : 48 > pha ;use stack to load status +0f59 : a9fc > lda #$ff-$03 ;precharge accu +0f5b : 28 > plp + > +0f5c : 03 > db $03 ;test nop integrity - flags off +0f5d : ea > nop +0f5e : ea > nop + > tst_a $ff-$03,0 +0f5f : 08 > php ;save flags +0f60 : c9fc > cmp #$ff-$03 ;test result + > trap_ne +0f62 : d0fe > bne * ;failed not equal (non zero) + > +0f64 : 68 > pla ;load status +0f65 : 48 > pha + > cmp_flag 0 +0f66 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0f68 : d0fe > bne * ;failed not equal (non zero) + > +0f6a : 28 > plp ;restore status + > + > set_a $aa-$03,$ff + > load_flag $ff +0f6b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0f6d : 48 > pha ;use stack to load status +0f6e : a9a7 > lda #$aa-$03 ;precharge accu +0f70 : 28 > plp + > +0f71 : 03 > db $03 ;test nop integrity - flags on +0f72 : ea > nop +0f73 : ea > nop + > tst_a $aa-$03,$ff +0f74 : 08 > php ;save flags +0f75 : c9a7 > cmp #$aa-$03 ;test result + > trap_ne +0f77 : d0fe > bne * ;failed not equal (non zero) + > +0f79 : 68 > pla ;load status +0f7a : 48 > pha + > cmp_flag $ff +0f7b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0f7d : d0fe > bne * ;failed not equal (non zero) + > +0f7f : 28 > plp ;restore status + > +0f80 : c042 > cpy #$42 + > trap_ne ;y changed +0f82 : d0fe > bne * ;failed not equal (non zero) + > +0f84 : e000 > cpx #0 + > trap_ne ;x changed +0f86 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $13,1 +0f88 : a042 > ldy #$42 +0f8a : a203 > ldx #4-1 +0f8c : 13 > db $13 ;test nop length + > if 1 = 1 +0f8d : ca > dex +0f8e : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +0f8f : ca > dex + > trap_ne ;wrong number of bytes +0f90 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$13,0 + > load_flag 0 +0f92 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0f94 : 48 > pha ;use stack to load status +0f95 : a9ec > lda #$ff-$13 ;precharge accu +0f97 : 28 > plp + > +0f98 : 13 > db $13 ;test nop integrity - flags off +0f99 : ea > nop +0f9a : ea > nop + > tst_a $ff-$13,0 +0f9b : 08 > php ;save flags +0f9c : c9ec > cmp #$ff-$13 ;test result + > trap_ne +0f9e : d0fe > bne * ;failed not equal (non zero) + > +0fa0 : 68 > pla ;load status +0fa1 : 48 > pha + > cmp_flag 0 +0fa2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0fa4 : d0fe > bne * ;failed not equal (non zero) + > +0fa6 : 28 > plp ;restore status + > + > set_a $aa-$13,$ff + > load_flag $ff +0fa7 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0fa9 : 48 > pha ;use stack to load status +0faa : a997 > lda #$aa-$13 ;precharge accu +0fac : 28 > plp + > +0fad : 13 > db $13 ;test nop integrity - flags on +0fae : ea > nop +0faf : ea > nop + > tst_a $aa-$13,$ff +0fb0 : 08 > php ;save flags +0fb1 : c997 > cmp #$aa-$13 ;test result + > trap_ne +0fb3 : d0fe > bne * ;failed not equal (non zero) + > +0fb5 : 68 > pla ;load status +0fb6 : 48 > pha + > cmp_flag $ff +0fb7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0fb9 : d0fe > bne * ;failed not equal (non zero) + > +0fbb : 28 > plp ;restore status + > +0fbc : c042 > cpy #$42 + > trap_ne ;y changed +0fbe : d0fe > bne * ;failed not equal (non zero) + > +0fc0 : e000 > cpx #0 + > trap_ne ;x changed +0fc2 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $23,1 +0fc4 : a042 > ldy #$42 +0fc6 : a203 > ldx #4-1 +0fc8 : 23 > db $23 ;test nop length + > if 1 = 1 +0fc9 : ca > dex +0fca : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +0fcb : ca > dex + > trap_ne ;wrong number of bytes +0fcc : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$23,0 + > load_flag 0 +0fce : a900 > lda #0 ;allow test to change I-flag (no mask) + > +0fd0 : 48 > pha ;use stack to load status +0fd1 : a9dc > lda #$ff-$23 ;precharge accu +0fd3 : 28 > plp + > +0fd4 : 23 > db $23 ;test nop integrity - flags off +0fd5 : ea > nop +0fd6 : ea > nop + > tst_a $ff-$23,0 +0fd7 : 08 > php ;save flags +0fd8 : c9dc > cmp #$ff-$23 ;test result + > trap_ne +0fda : d0fe > bne * ;failed not equal (non zero) + > +0fdc : 68 > pla ;load status +0fdd : 48 > pha + > cmp_flag 0 +0fde : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0fe0 : d0fe > bne * ;failed not equal (non zero) + > +0fe2 : 28 > plp ;restore status + > + > set_a $aa-$23,$ff + > load_flag $ff +0fe3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +0fe5 : 48 > pha ;use stack to load status +0fe6 : a987 > lda #$aa-$23 ;precharge accu +0fe8 : 28 > plp + > +0fe9 : 23 > db $23 ;test nop integrity - flags on +0fea : ea > nop +0feb : ea > nop + > tst_a $aa-$23,$ff +0fec : 08 > php ;save flags +0fed : c987 > cmp #$aa-$23 ;test result + > trap_ne +0fef : d0fe > bne * ;failed not equal (non zero) + > +0ff1 : 68 > pla ;load status +0ff2 : 48 > pha + > cmp_flag $ff +0ff3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +0ff5 : d0fe > bne * ;failed not equal (non zero) + > +0ff7 : 28 > plp ;restore status + > +0ff8 : c042 > cpy #$42 + > trap_ne ;y changed +0ffa : d0fe > bne * ;failed not equal (non zero) + > +0ffc : e000 > cpx #0 + > trap_ne ;x changed +0ffe : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $33,1 +1000 : a042 > ldy #$42 +1002 : a203 > ldx #4-1 +1004 : 33 > db $33 ;test nop length + > if 1 = 1 +1005 : ca > dex +1006 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +1007 : ca > dex + > trap_ne ;wrong number of bytes +1008 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$33,0 + > load_flag 0 +100a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +100c : 48 > pha ;use stack to load status +100d : a9cc > lda #$ff-$33 ;precharge accu +100f : 28 > plp + > +1010 : 33 > db $33 ;test nop integrity - flags off +1011 : ea > nop +1012 : ea > nop + > tst_a $ff-$33,0 +1013 : 08 > php ;save flags +1014 : c9cc > cmp #$ff-$33 ;test result + > trap_ne +1016 : d0fe > bne * ;failed not equal (non zero) + > +1018 : 68 > pla ;load status +1019 : 48 > pha + > cmp_flag 0 +101a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +101c : d0fe > bne * ;failed not equal (non zero) + > +101e : 28 > plp ;restore status + > + > set_a $aa-$33,$ff + > load_flag $ff +101f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1021 : 48 > pha ;use stack to load status +1022 : a977 > lda #$aa-$33 ;precharge accu +1024 : 28 > plp + > +1025 : 33 > db $33 ;test nop integrity - flags on +1026 : ea > nop +1027 : ea > nop + > tst_a $aa-$33,$ff +1028 : 08 > php ;save flags +1029 : c977 > cmp #$aa-$33 ;test result + > trap_ne +102b : d0fe > bne * ;failed not equal (non zero) + > +102d : 68 > pla ;load status +102e : 48 > pha + > cmp_flag $ff +102f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1031 : d0fe > bne * ;failed not equal (non zero) + > +1033 : 28 > plp ;restore status + > +1034 : c042 > cpy #$42 + > trap_ne ;y changed +1036 : d0fe > bne * ;failed not equal (non zero) + > +1038 : e000 > cpx #0 + > trap_ne ;x changed +103a : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $43,1 +103c : a042 > ldy #$42 +103e : a203 > ldx #4-1 +1040 : 43 > db $43 ;test nop length + > if 1 = 1 +1041 : ca > dex +1042 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +1043 : ca > dex + > trap_ne ;wrong number of bytes +1044 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$43,0 + > load_flag 0 +1046 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1048 : 48 > pha ;use stack to load status +1049 : a9bc > lda #$ff-$43 ;precharge accu +104b : 28 > plp + > +104c : 43 > db $43 ;test nop integrity - flags off +104d : ea > nop +104e : ea > nop + > tst_a $ff-$43,0 +104f : 08 > php ;save flags +1050 : c9bc > cmp #$ff-$43 ;test result + > trap_ne +1052 : d0fe > bne * ;failed not equal (non zero) + > +1054 : 68 > pla ;load status +1055 : 48 > pha + > cmp_flag 0 +1056 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1058 : d0fe > bne * ;failed not equal (non zero) + > +105a : 28 > plp ;restore status + > + > set_a $aa-$43,$ff + > load_flag $ff +105b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +105d : 48 > pha ;use stack to load status +105e : a967 > lda #$aa-$43 ;precharge accu +1060 : 28 > plp + > +1061 : 43 > db $43 ;test nop integrity - flags on +1062 : ea > nop +1063 : ea > nop + > tst_a $aa-$43,$ff +1064 : 08 > php ;save flags +1065 : c967 > cmp #$aa-$43 ;test result + > trap_ne +1067 : d0fe > bne * ;failed not equal (non zero) + > +1069 : 68 > pla ;load status +106a : 48 > pha + > cmp_flag $ff +106b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +106d : d0fe > bne * ;failed not equal (non zero) + > +106f : 28 > plp ;restore status + > +1070 : c042 > cpy #$42 + > trap_ne ;y changed +1072 : d0fe > bne * ;failed not equal (non zero) + > +1074 : e000 > cpx #0 + > trap_ne ;x changed +1076 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $53,1 +1078 : a042 > ldy #$42 +107a : a203 > ldx #4-1 +107c : 53 > db $53 ;test nop length + > if 1 = 1 +107d : ca > dex +107e : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +107f : ca > dex + > trap_ne ;wrong number of bytes +1080 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$53,0 + > load_flag 0 +1082 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1084 : 48 > pha ;use stack to load status +1085 : a9ac > lda #$ff-$53 ;precharge accu +1087 : 28 > plp + > +1088 : 53 > db $53 ;test nop integrity - flags off +1089 : ea > nop +108a : ea > nop + > tst_a $ff-$53,0 +108b : 08 > php ;save flags +108c : c9ac > cmp #$ff-$53 ;test result + > trap_ne +108e : d0fe > bne * ;failed not equal (non zero) + > +1090 : 68 > pla ;load status +1091 : 48 > pha + > cmp_flag 0 +1092 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1094 : d0fe > bne * ;failed not equal (non zero) + > +1096 : 28 > plp ;restore status + > + > set_a $aa-$53,$ff + > load_flag $ff +1097 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1099 : 48 > pha ;use stack to load status +109a : a957 > lda #$aa-$53 ;precharge accu +109c : 28 > plp + > +109d : 53 > db $53 ;test nop integrity - flags on +109e : ea > nop +109f : ea > nop + > tst_a $aa-$53,$ff +10a0 : 08 > php ;save flags +10a1 : c957 > cmp #$aa-$53 ;test result + > trap_ne +10a3 : d0fe > bne * ;failed not equal (non zero) + > +10a5 : 68 > pla ;load status +10a6 : 48 > pha + > cmp_flag $ff +10a7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +10a9 : d0fe > bne * ;failed not equal (non zero) + > +10ab : 28 > plp ;restore status + > +10ac : c042 > cpy #$42 + > trap_ne ;y changed +10ae : d0fe > bne * ;failed not equal (non zero) + > +10b0 : e000 > cpx #0 + > trap_ne ;x changed +10b2 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $63,1 +10b4 : a042 > ldy #$42 +10b6 : a203 > ldx #4-1 +10b8 : 63 > db $63 ;test nop length + > if 1 = 1 +10b9 : ca > dex +10ba : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +10bb : ca > dex + > trap_ne ;wrong number of bytes +10bc : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$63,0 + > load_flag 0 +10be : a900 > lda #0 ;allow test to change I-flag (no mask) + > +10c0 : 48 > pha ;use stack to load status +10c1 : a99c > lda #$ff-$63 ;precharge accu +10c3 : 28 > plp + > +10c4 : 63 > db $63 ;test nop integrity - flags off +10c5 : ea > nop +10c6 : ea > nop + > tst_a $ff-$63,0 +10c7 : 08 > php ;save flags +10c8 : c99c > cmp #$ff-$63 ;test result + > trap_ne +10ca : d0fe > bne * ;failed not equal (non zero) + > +10cc : 68 > pla ;load status +10cd : 48 > pha + > cmp_flag 0 +10ce : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +10d0 : d0fe > bne * ;failed not equal (non zero) + > +10d2 : 28 > plp ;restore status + > + > set_a $aa-$63,$ff + > load_flag $ff +10d3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +10d5 : 48 > pha ;use stack to load status +10d6 : a947 > lda #$aa-$63 ;precharge accu +10d8 : 28 > plp + > +10d9 : 63 > db $63 ;test nop integrity - flags on +10da : ea > nop +10db : ea > nop + > tst_a $aa-$63,$ff +10dc : 08 > php ;save flags +10dd : c947 > cmp #$aa-$63 ;test result + > trap_ne +10df : d0fe > bne * ;failed not equal (non zero) + > +10e1 : 68 > pla ;load status +10e2 : 48 > pha + > cmp_flag $ff +10e3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +10e5 : d0fe > bne * ;failed not equal (non zero) + > +10e7 : 28 > plp ;restore status + > +10e8 : c042 > cpy #$42 + > trap_ne ;y changed +10ea : d0fe > bne * ;failed not equal (non zero) + > +10ec : e000 > cpx #0 + > trap_ne ;x changed +10ee : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $73,1 +10f0 : a042 > ldy #$42 +10f2 : a203 > ldx #4-1 +10f4 : 73 > db $73 ;test nop length + > if 1 = 1 +10f5 : ca > dex +10f6 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +10f7 : ca > dex + > trap_ne ;wrong number of bytes +10f8 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$73,0 + > load_flag 0 +10fa : a900 > lda #0 ;allow test to change I-flag (no mask) + > +10fc : 48 > pha ;use stack to load status +10fd : a98c > lda #$ff-$73 ;precharge accu +10ff : 28 > plp + > +1100 : 73 > db $73 ;test nop integrity - flags off +1101 : ea > nop +1102 : ea > nop + > tst_a $ff-$73,0 +1103 : 08 > php ;save flags +1104 : c98c > cmp #$ff-$73 ;test result + > trap_ne +1106 : d0fe > bne * ;failed not equal (non zero) + > +1108 : 68 > pla ;load status +1109 : 48 > pha + > cmp_flag 0 +110a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +110c : d0fe > bne * ;failed not equal (non zero) + > +110e : 28 > plp ;restore status + > + > set_a $aa-$73,$ff + > load_flag $ff +110f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1111 : 48 > pha ;use stack to load status +1112 : a937 > lda #$aa-$73 ;precharge accu +1114 : 28 > plp + > +1115 : 73 > db $73 ;test nop integrity - flags on +1116 : ea > nop +1117 : ea > nop + > tst_a $aa-$73,$ff +1118 : 08 > php ;save flags +1119 : c937 > cmp #$aa-$73 ;test result + > trap_ne +111b : d0fe > bne * ;failed not equal (non zero) + > +111d : 68 > pla ;load status +111e : 48 > pha + > cmp_flag $ff +111f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1121 : d0fe > bne * ;failed not equal (non zero) + > +1123 : 28 > plp ;restore status + > +1124 : c042 > cpy #$42 + > trap_ne ;y changed +1126 : d0fe > bne * ;failed not equal (non zero) + > +1128 : e000 > cpx #0 + > trap_ne ;x changed +112a : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $83,1 +112c : a042 > ldy #$42 +112e : a203 > ldx #4-1 +1130 : 83 > db $83 ;test nop length + > if 1 = 1 +1131 : ca > dex +1132 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +1133 : ca > dex + > trap_ne ;wrong number of bytes +1134 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$83,0 + > load_flag 0 +1136 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1138 : 48 > pha ;use stack to load status +1139 : a97c > lda #$ff-$83 ;precharge accu +113b : 28 > plp + > +113c : 83 > db $83 ;test nop integrity - flags off +113d : ea > nop +113e : ea > nop + > tst_a $ff-$83,0 +113f : 08 > php ;save flags +1140 : c97c > cmp #$ff-$83 ;test result + > trap_ne +1142 : d0fe > bne * ;failed not equal (non zero) + > +1144 : 68 > pla ;load status +1145 : 48 > pha + > cmp_flag 0 +1146 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1148 : d0fe > bne * ;failed not equal (non zero) + > +114a : 28 > plp ;restore status + > + > set_a $aa-$83,$ff + > load_flag $ff +114b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +114d : 48 > pha ;use stack to load status +114e : a927 > lda #$aa-$83 ;precharge accu +1150 : 28 > plp + > +1151 : 83 > db $83 ;test nop integrity - flags on +1152 : ea > nop +1153 : ea > nop + > tst_a $aa-$83,$ff +1154 : 08 > php ;save flags +1155 : c927 > cmp #$aa-$83 ;test result + > trap_ne +1157 : d0fe > bne * ;failed not equal (non zero) + > +1159 : 68 > pla ;load status +115a : 48 > pha + > cmp_flag $ff +115b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +115d : d0fe > bne * ;failed not equal (non zero) + > +115f : 28 > plp ;restore status + > +1160 : c042 > cpy #$42 + > trap_ne ;y changed +1162 : d0fe > bne * ;failed not equal (non zero) + > +1164 : e000 > cpx #0 + > trap_ne ;x changed +1166 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $93,1 +1168 : a042 > ldy #$42 +116a : a203 > ldx #4-1 +116c : 93 > db $93 ;test nop length + > if 1 = 1 +116d : ca > dex +116e : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +116f : ca > dex + > trap_ne ;wrong number of bytes +1170 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$93,0 + > load_flag 0 +1172 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1174 : 48 > pha ;use stack to load status +1175 : a96c > lda #$ff-$93 ;precharge accu +1177 : 28 > plp + > +1178 : 93 > db $93 ;test nop integrity - flags off +1179 : ea > nop +117a : ea > nop + > tst_a $ff-$93,0 +117b : 08 > php ;save flags +117c : c96c > cmp #$ff-$93 ;test result + > trap_ne +117e : d0fe > bne * ;failed not equal (non zero) + > +1180 : 68 > pla ;load status +1181 : 48 > pha + > cmp_flag 0 +1182 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1184 : d0fe > bne * ;failed not equal (non zero) + > +1186 : 28 > plp ;restore status + > + > set_a $aa-$93,$ff + > load_flag $ff +1187 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1189 : 48 > pha ;use stack to load status +118a : a917 > lda #$aa-$93 ;precharge accu +118c : 28 > plp + > +118d : 93 > db $93 ;test nop integrity - flags on +118e : ea > nop +118f : ea > nop + > tst_a $aa-$93,$ff +1190 : 08 > php ;save flags +1191 : c917 > cmp #$aa-$93 ;test result + > trap_ne +1193 : d0fe > bne * ;failed not equal (non zero) + > +1195 : 68 > pla ;load status +1196 : 48 > pha + > cmp_flag $ff +1197 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1199 : d0fe > bne * ;failed not equal (non zero) + > +119b : 28 > plp ;restore status + > +119c : c042 > cpy #$42 + > trap_ne ;y changed +119e : d0fe > bne * ;failed not equal (non zero) + > +11a0 : e000 > cpx #0 + > trap_ne ;x changed +11a2 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $a3,1 +11a4 : a042 > ldy #$42 +11a6 : a203 > ldx #4-1 +11a8 : a3 > db $a3 ;test nop length + > if 1 = 1 +11a9 : ca > dex +11aa : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +11ab : ca > dex + > trap_ne ;wrong number of bytes +11ac : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$a3,0 + > load_flag 0 +11ae : a900 > lda #0 ;allow test to change I-flag (no mask) + > +11b0 : 48 > pha ;use stack to load status +11b1 : a95c > lda #$ff-$a3 ;precharge accu +11b3 : 28 > plp + > +11b4 : a3 > db $a3 ;test nop integrity - flags off +11b5 : ea > nop +11b6 : ea > nop + > tst_a $ff-$a3,0 +11b7 : 08 > php ;save flags +11b8 : c95c > cmp #$ff-$a3 ;test result + > trap_ne +11ba : d0fe > bne * ;failed not equal (non zero) + > +11bc : 68 > pla ;load status +11bd : 48 > pha + > cmp_flag 0 +11be : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +11c0 : d0fe > bne * ;failed not equal (non zero) + > +11c2 : 28 > plp ;restore status + > + > set_a $aa-$a3,$ff + > load_flag $ff +11c3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +11c5 : 48 > pha ;use stack to load status +11c6 : a907 > lda #$aa-$a3 ;precharge accu +11c8 : 28 > plp + > +11c9 : a3 > db $a3 ;test nop integrity - flags on +11ca : ea > nop +11cb : ea > nop + > tst_a $aa-$a3,$ff +11cc : 08 > php ;save flags +11cd : c907 > cmp #$aa-$a3 ;test result + > trap_ne +11cf : d0fe > bne * ;failed not equal (non zero) + > +11d1 : 68 > pla ;load status +11d2 : 48 > pha + > cmp_flag $ff +11d3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +11d5 : d0fe > bne * ;failed not equal (non zero) + > +11d7 : 28 > plp ;restore status + > +11d8 : c042 > cpy #$42 + > trap_ne ;y changed +11da : d0fe > bne * ;failed not equal (non zero) + > +11dc : e000 > cpx #0 + > trap_ne ;x changed +11de : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $b3,1 +11e0 : a042 > ldy #$42 +11e2 : a203 > ldx #4-1 +11e4 : b3 > db $b3 ;test nop length + > if 1 = 1 +11e5 : ca > dex +11e6 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +11e7 : ca > dex + > trap_ne ;wrong number of bytes +11e8 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$b3,0 + > load_flag 0 +11ea : a900 > lda #0 ;allow test to change I-flag (no mask) + > +11ec : 48 > pha ;use stack to load status +11ed : a94c > lda #$ff-$b3 ;precharge accu +11ef : 28 > plp + > +11f0 : b3 > db $b3 ;test nop integrity - flags off +11f1 : ea > nop +11f2 : ea > nop + > tst_a $ff-$b3,0 +11f3 : 08 > php ;save flags +11f4 : c94c > cmp #$ff-$b3 ;test result + > trap_ne +11f6 : d0fe > bne * ;failed not equal (non zero) + > +11f8 : 68 > pla ;load status +11f9 : 48 > pha + > cmp_flag 0 +11fa : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +11fc : d0fe > bne * ;failed not equal (non zero) + > +11fe : 28 > plp ;restore status + > + > set_a $aa-$b3,$ff + > load_flag $ff +11ff : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1201 : 48 > pha ;use stack to load status +1202 : a9f7 > lda #$aa-$b3 ;precharge accu +1204 : 28 > plp + > +1205 : b3 > db $b3 ;test nop integrity - flags on +1206 : ea > nop +1207 : ea > nop + > tst_a $aa-$b3,$ff +1208 : 08 > php ;save flags +1209 : c9f7 > cmp #$aa-$b3 ;test result + > trap_ne +120b : d0fe > bne * ;failed not equal (non zero) + > +120d : 68 > pla ;load status +120e : 48 > pha + > cmp_flag $ff +120f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1211 : d0fe > bne * ;failed not equal (non zero) + > +1213 : 28 > plp ;restore status + > +1214 : c042 > cpy #$42 + > trap_ne ;y changed +1216 : d0fe > bne * ;failed not equal (non zero) + > +1218 : e000 > cpx #0 + > trap_ne ;x changed +121a : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $c3,1 +121c : a042 > ldy #$42 +121e : a203 > ldx #4-1 +1220 : c3 > db $c3 ;test nop length + > if 1 = 1 +1221 : ca > dex +1222 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +1223 : ca > dex + > trap_ne ;wrong number of bytes +1224 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$c3,0 + > load_flag 0 +1226 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1228 : 48 > pha ;use stack to load status +1229 : a93c > lda #$ff-$c3 ;precharge accu +122b : 28 > plp + > +122c : c3 > db $c3 ;test nop integrity - flags off +122d : ea > nop +122e : ea > nop + > tst_a $ff-$c3,0 +122f : 08 > php ;save flags +1230 : c93c > cmp #$ff-$c3 ;test result + > trap_ne +1232 : d0fe > bne * ;failed not equal (non zero) + > +1234 : 68 > pla ;load status +1235 : 48 > pha + > cmp_flag 0 +1236 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1238 : d0fe > bne * ;failed not equal (non zero) + > +123a : 28 > plp ;restore status + > + > set_a $aa-$c3,$ff + > load_flag $ff +123b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +123d : 48 > pha ;use stack to load status +123e : a9e7 > lda #$aa-$c3 ;precharge accu +1240 : 28 > plp + > +1241 : c3 > db $c3 ;test nop integrity - flags on +1242 : ea > nop +1243 : ea > nop + > tst_a $aa-$c3,$ff +1244 : 08 > php ;save flags +1245 : c9e7 > cmp #$aa-$c3 ;test result + > trap_ne +1247 : d0fe > bne * ;failed not equal (non zero) + > +1249 : 68 > pla ;load status +124a : 48 > pha + > cmp_flag $ff +124b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +124d : d0fe > bne * ;failed not equal (non zero) + > +124f : 28 > plp ;restore status + > +1250 : c042 > cpy #$42 + > trap_ne ;y changed +1252 : d0fe > bne * ;failed not equal (non zero) + > +1254 : e000 > cpx #0 + > trap_ne ;x changed +1256 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $d3,1 +1258 : a042 > ldy #$42 +125a : a203 > ldx #4-1 +125c : d3 > db $d3 ;test nop length + > if 1 = 1 +125d : ca > dex +125e : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +125f : ca > dex + > trap_ne ;wrong number of bytes +1260 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$d3,0 + > load_flag 0 +1262 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1264 : 48 > pha ;use stack to load status +1265 : a92c > lda #$ff-$d3 ;precharge accu +1267 : 28 > plp + > +1268 : d3 > db $d3 ;test nop integrity - flags off +1269 : ea > nop +126a : ea > nop + > tst_a $ff-$d3,0 +126b : 08 > php ;save flags +126c : c92c > cmp #$ff-$d3 ;test result + > trap_ne +126e : d0fe > bne * ;failed not equal (non zero) + > +1270 : 68 > pla ;load status +1271 : 48 > pha + > cmp_flag 0 +1272 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1274 : d0fe > bne * ;failed not equal (non zero) + > +1276 : 28 > plp ;restore status + > + > set_a $aa-$d3,$ff + > load_flag $ff +1277 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1279 : 48 > pha ;use stack to load status +127a : a9d7 > lda #$aa-$d3 ;precharge accu +127c : 28 > plp + > +127d : d3 > db $d3 ;test nop integrity - flags on +127e : ea > nop +127f : ea > nop + > tst_a $aa-$d3,$ff +1280 : 08 > php ;save flags +1281 : c9d7 > cmp #$aa-$d3 ;test result + > trap_ne +1283 : d0fe > bne * ;failed not equal (non zero) + > +1285 : 68 > pla ;load status +1286 : 48 > pha + > cmp_flag $ff +1287 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1289 : d0fe > bne * ;failed not equal (non zero) + > +128b : 28 > plp ;restore status + > +128c : c042 > cpy #$42 + > trap_ne ;y changed +128e : d0fe > bne * ;failed not equal (non zero) + > +1290 : e000 > cpx #0 + > trap_ne ;x changed +1292 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $e3,1 +1294 : a042 > ldy #$42 +1296 : a203 > ldx #4-1 +1298 : e3 > db $e3 ;test nop length + > if 1 = 1 +1299 : ca > dex +129a : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +129b : ca > dex + > trap_ne ;wrong number of bytes +129c : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$e3,0 + > load_flag 0 +129e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +12a0 : 48 > pha ;use stack to load status +12a1 : a91c > lda #$ff-$e3 ;precharge accu +12a3 : 28 > plp + > +12a4 : e3 > db $e3 ;test nop integrity - flags off +12a5 : ea > nop +12a6 : ea > nop + > tst_a $ff-$e3,0 +12a7 : 08 > php ;save flags +12a8 : c91c > cmp #$ff-$e3 ;test result + > trap_ne +12aa : d0fe > bne * ;failed not equal (non zero) + > +12ac : 68 > pla ;load status +12ad : 48 > pha + > cmp_flag 0 +12ae : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +12b0 : d0fe > bne * ;failed not equal (non zero) + > +12b2 : 28 > plp ;restore status + > + > set_a $aa-$e3,$ff + > load_flag $ff +12b3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +12b5 : 48 > pha ;use stack to load status +12b6 : a9c7 > lda #$aa-$e3 ;precharge accu +12b8 : 28 > plp + > +12b9 : e3 > db $e3 ;test nop integrity - flags on +12ba : ea > nop +12bb : ea > nop + > tst_a $aa-$e3,$ff +12bc : 08 > php ;save flags +12bd : c9c7 > cmp #$aa-$e3 ;test result + > trap_ne +12bf : d0fe > bne * ;failed not equal (non zero) + > +12c1 : 68 > pla ;load status +12c2 : 48 > pha + > cmp_flag $ff +12c3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +12c5 : d0fe > bne * ;failed not equal (non zero) + > +12c7 : 28 > plp ;restore status + > +12c8 : c042 > cpy #$42 + > trap_ne ;y changed +12ca : d0fe > bne * ;failed not equal (non zero) + > +12cc : e000 > cpx #0 + > trap_ne ;x changed +12ce : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $f3,1 +12d0 : a042 > ldy #$42 +12d2 : a203 > ldx #4-1 +12d4 : f3 > db $f3 ;test nop length + > if 1 = 1 +12d5 : ca > dex +12d6 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +12d7 : ca > dex + > trap_ne ;wrong number of bytes +12d8 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$f3,0 + > load_flag 0 +12da : a900 > lda #0 ;allow test to change I-flag (no mask) + > +12dc : 48 > pha ;use stack to load status +12dd : a90c > lda #$ff-$f3 ;precharge accu +12df : 28 > plp + > +12e0 : f3 > db $f3 ;test nop integrity - flags off +12e1 : ea > nop +12e2 : ea > nop + > tst_a $ff-$f3,0 +12e3 : 08 > php ;save flags +12e4 : c90c > cmp #$ff-$f3 ;test result + > trap_ne +12e6 : d0fe > bne * ;failed not equal (non zero) + > +12e8 : 68 > pla ;load status +12e9 : 48 > pha + > cmp_flag 0 +12ea : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +12ec : d0fe > bne * ;failed not equal (non zero) + > +12ee : 28 > plp ;restore status + > + > set_a $aa-$f3,$ff + > load_flag $ff +12ef : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +12f1 : 48 > pha ;use stack to load status +12f2 : a9b7 > lda #$aa-$f3 ;precharge accu +12f4 : 28 > plp + > +12f5 : f3 > db $f3 ;test nop integrity - flags on +12f6 : ea > nop +12f7 : ea > nop + > tst_a $aa-$f3,$ff +12f8 : 08 > php ;save flags +12f9 : c9b7 > cmp #$aa-$f3 ;test result + > trap_ne +12fb : d0fe > bne * ;failed not equal (non zero) + > +12fd : 68 > pla ;load status +12fe : 48 > pha + > cmp_flag $ff +12ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1301 : d0fe > bne * ;failed not equal (non zero) + > +1303 : 28 > plp ;restore status + > +1304 : c042 > cpy #$42 + > trap_ne ;y changed +1306 : d0fe > bne * ;failed not equal (non zero) + > +1308 : e000 > cpx #0 + > trap_ne ;x changed +130a : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $0b,1 +130c : a042 > ldy #$42 +130e : a203 > ldx #4-1 +1310 : 0b > db $0b ;test nop length + > if 1 = 1 +1311 : ca > dex +1312 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +1313 : ca > dex + > trap_ne ;wrong number of bytes +1314 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$0b,0 + > load_flag 0 +1316 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1318 : 48 > pha ;use stack to load status +1319 : a9f4 > lda #$ff-$0b ;precharge accu +131b : 28 > plp + > +131c : 0b > db $0b ;test nop integrity - flags off +131d : ea > nop +131e : ea > nop + > tst_a $ff-$0b,0 +131f : 08 > php ;save flags +1320 : c9f4 > cmp #$ff-$0b ;test result + > trap_ne +1322 : d0fe > bne * ;failed not equal (non zero) + > +1324 : 68 > pla ;load status +1325 : 48 > pha + > cmp_flag 0 +1326 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1328 : d0fe > bne * ;failed not equal (non zero) + > +132a : 28 > plp ;restore status + > + > set_a $aa-$0b,$ff + > load_flag $ff +132b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +132d : 48 > pha ;use stack to load status +132e : a99f > lda #$aa-$0b ;precharge accu +1330 : 28 > plp + > +1331 : 0b > db $0b ;test nop integrity - flags on +1332 : ea > nop +1333 : ea > nop + > tst_a $aa-$0b,$ff +1334 : 08 > php ;save flags +1335 : c99f > cmp #$aa-$0b ;test result + > trap_ne +1337 : d0fe > bne * ;failed not equal (non zero) + > +1339 : 68 > pla ;load status +133a : 48 > pha + > cmp_flag $ff +133b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +133d : d0fe > bne * ;failed not equal (non zero) + > +133f : 28 > plp ;restore status + > +1340 : c042 > cpy #$42 + > trap_ne ;y changed +1342 : d0fe > bne * ;failed not equal (non zero) + > +1344 : e000 > cpx #0 + > trap_ne ;x changed +1346 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $1b,1 +1348 : a042 > ldy #$42 +134a : a203 > ldx #4-1 +134c : 1b > db $1b ;test nop length + > if 1 = 1 +134d : ca > dex +134e : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +134f : ca > dex + > trap_ne ;wrong number of bytes +1350 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$1b,0 + > load_flag 0 +1352 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1354 : 48 > pha ;use stack to load status +1355 : a9e4 > lda #$ff-$1b ;precharge accu +1357 : 28 > plp + > +1358 : 1b > db $1b ;test nop integrity - flags off +1359 : ea > nop +135a : ea > nop + > tst_a $ff-$1b,0 +135b : 08 > php ;save flags +135c : c9e4 > cmp #$ff-$1b ;test result + > trap_ne +135e : d0fe > bne * ;failed not equal (non zero) + > +1360 : 68 > pla ;load status +1361 : 48 > pha + > cmp_flag 0 +1362 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1364 : d0fe > bne * ;failed not equal (non zero) + > +1366 : 28 > plp ;restore status + > + > set_a $aa-$1b,$ff + > load_flag $ff +1367 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1369 : 48 > pha ;use stack to load status +136a : a98f > lda #$aa-$1b ;precharge accu +136c : 28 > plp + > +136d : 1b > db $1b ;test nop integrity - flags on +136e : ea > nop +136f : ea > nop + > tst_a $aa-$1b,$ff +1370 : 08 > php ;save flags +1371 : c98f > cmp #$aa-$1b ;test result + > trap_ne +1373 : d0fe > bne * ;failed not equal (non zero) + > +1375 : 68 > pla ;load status +1376 : 48 > pha + > cmp_flag $ff +1377 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1379 : d0fe > bne * ;failed not equal (non zero) + > +137b : 28 > plp ;restore status + > +137c : c042 > cpy #$42 + > trap_ne ;y changed +137e : d0fe > bne * ;failed not equal (non zero) + > +1380 : e000 > cpx #0 + > trap_ne ;x changed +1382 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $2b,1 +1384 : a042 > ldy #$42 +1386 : a203 > ldx #4-1 +1388 : 2b > db $2b ;test nop length + > if 1 = 1 +1389 : ca > dex +138a : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +138b : ca > dex + > trap_ne ;wrong number of bytes +138c : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$2b,0 + > load_flag 0 +138e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1390 : 48 > pha ;use stack to load status +1391 : a9d4 > lda #$ff-$2b ;precharge accu +1393 : 28 > plp + > +1394 : 2b > db $2b ;test nop integrity - flags off +1395 : ea > nop +1396 : ea > nop + > tst_a $ff-$2b,0 +1397 : 08 > php ;save flags +1398 : c9d4 > cmp #$ff-$2b ;test result + > trap_ne +139a : d0fe > bne * ;failed not equal (non zero) + > +139c : 68 > pla ;load status +139d : 48 > pha + > cmp_flag 0 +139e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +13a0 : d0fe > bne * ;failed not equal (non zero) + > +13a2 : 28 > plp ;restore status + > + > set_a $aa-$2b,$ff + > load_flag $ff +13a3 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +13a5 : 48 > pha ;use stack to load status +13a6 : a97f > lda #$aa-$2b ;precharge accu +13a8 : 28 > plp + > +13a9 : 2b > db $2b ;test nop integrity - flags on +13aa : ea > nop +13ab : ea > nop + > tst_a $aa-$2b,$ff +13ac : 08 > php ;save flags +13ad : c97f > cmp #$aa-$2b ;test result + > trap_ne +13af : d0fe > bne * ;failed not equal (non zero) + > +13b1 : 68 > pla ;load status +13b2 : 48 > pha + > cmp_flag $ff +13b3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +13b5 : d0fe > bne * ;failed not equal (non zero) + > +13b7 : 28 > plp ;restore status + > +13b8 : c042 > cpy #$42 + > trap_ne ;y changed +13ba : d0fe > bne * ;failed not equal (non zero) + > +13bc : e000 > cpx #0 + > trap_ne ;x changed +13be : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $3b,1 +13c0 : a042 > ldy #$42 +13c2 : a203 > ldx #4-1 +13c4 : 3b > db $3b ;test nop length + > if 1 = 1 +13c5 : ca > dex +13c6 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +13c7 : ca > dex + > trap_ne ;wrong number of bytes +13c8 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$3b,0 + > load_flag 0 +13ca : a900 > lda #0 ;allow test to change I-flag (no mask) + > +13cc : 48 > pha ;use stack to load status +13cd : a9c4 > lda #$ff-$3b ;precharge accu +13cf : 28 > plp + > +13d0 : 3b > db $3b ;test nop integrity - flags off +13d1 : ea > nop +13d2 : ea > nop + > tst_a $ff-$3b,0 +13d3 : 08 > php ;save flags +13d4 : c9c4 > cmp #$ff-$3b ;test result + > trap_ne +13d6 : d0fe > bne * ;failed not equal (non zero) + > +13d8 : 68 > pla ;load status +13d9 : 48 > pha + > cmp_flag 0 +13da : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +13dc : d0fe > bne * ;failed not equal (non zero) + > +13de : 28 > plp ;restore status + > + > set_a $aa-$3b,$ff + > load_flag $ff +13df : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +13e1 : 48 > pha ;use stack to load status +13e2 : a96f > lda #$aa-$3b ;precharge accu +13e4 : 28 > plp + > +13e5 : 3b > db $3b ;test nop integrity - flags on +13e6 : ea > nop +13e7 : ea > nop + > tst_a $aa-$3b,$ff +13e8 : 08 > php ;save flags +13e9 : c96f > cmp #$aa-$3b ;test result + > trap_ne +13eb : d0fe > bne * ;failed not equal (non zero) + > +13ed : 68 > pla ;load status +13ee : 48 > pha + > cmp_flag $ff +13ef : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +13f1 : d0fe > bne * ;failed not equal (non zero) + > +13f3 : 28 > plp ;restore status + > +13f4 : c042 > cpy #$42 + > trap_ne ;y changed +13f6 : d0fe > bne * ;failed not equal (non zero) + > +13f8 : e000 > cpx #0 + > trap_ne ;x changed +13fa : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $4b,1 +13fc : a042 > ldy #$42 +13fe : a203 > ldx #4-1 +1400 : 4b > db $4b ;test nop length + > if 1 = 1 +1401 : ca > dex +1402 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +1403 : ca > dex + > trap_ne ;wrong number of bytes +1404 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$4b,0 + > load_flag 0 +1406 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1408 : 48 > pha ;use stack to load status +1409 : a9b4 > lda #$ff-$4b ;precharge accu +140b : 28 > plp + > +140c : 4b > db $4b ;test nop integrity - flags off +140d : ea > nop +140e : ea > nop + > tst_a $ff-$4b,0 +140f : 08 > php ;save flags +1410 : c9b4 > cmp #$ff-$4b ;test result + > trap_ne +1412 : d0fe > bne * ;failed not equal (non zero) + > +1414 : 68 > pla ;load status +1415 : 48 > pha + > cmp_flag 0 +1416 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1418 : d0fe > bne * ;failed not equal (non zero) + > +141a : 28 > plp ;restore status + > + > set_a $aa-$4b,$ff + > load_flag $ff +141b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +141d : 48 > pha ;use stack to load status +141e : a95f > lda #$aa-$4b ;precharge accu +1420 : 28 > plp + > +1421 : 4b > db $4b ;test nop integrity - flags on +1422 : ea > nop +1423 : ea > nop + > tst_a $aa-$4b,$ff +1424 : 08 > php ;save flags +1425 : c95f > cmp #$aa-$4b ;test result + > trap_ne +1427 : d0fe > bne * ;failed not equal (non zero) + > +1429 : 68 > pla ;load status +142a : 48 > pha + > cmp_flag $ff +142b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +142d : d0fe > bne * ;failed not equal (non zero) + > +142f : 28 > plp ;restore status + > +1430 : c042 > cpy #$42 + > trap_ne ;y changed +1432 : d0fe > bne * ;failed not equal (non zero) + > +1434 : e000 > cpx #0 + > trap_ne ;x changed +1436 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $5b,1 +1438 : a042 > ldy #$42 +143a : a203 > ldx #4-1 +143c : 5b > db $5b ;test nop length + > if 1 = 1 +143d : ca > dex +143e : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +143f : ca > dex + > trap_ne ;wrong number of bytes +1440 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$5b,0 + > load_flag 0 +1442 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1444 : 48 > pha ;use stack to load status +1445 : a9a4 > lda #$ff-$5b ;precharge accu +1447 : 28 > plp + > +1448 : 5b > db $5b ;test nop integrity - flags off +1449 : ea > nop +144a : ea > nop + > tst_a $ff-$5b,0 +144b : 08 > php ;save flags +144c : c9a4 > cmp #$ff-$5b ;test result + > trap_ne +144e : d0fe > bne * ;failed not equal (non zero) + > +1450 : 68 > pla ;load status +1451 : 48 > pha + > cmp_flag 0 +1452 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1454 : d0fe > bne * ;failed not equal (non zero) + > +1456 : 28 > plp ;restore status + > + > set_a $aa-$5b,$ff + > load_flag $ff +1457 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1459 : 48 > pha ;use stack to load status +145a : a94f > lda #$aa-$5b ;precharge accu +145c : 28 > plp + > +145d : 5b > db $5b ;test nop integrity - flags on +145e : ea > nop +145f : ea > nop + > tst_a $aa-$5b,$ff +1460 : 08 > php ;save flags +1461 : c94f > cmp #$aa-$5b ;test result + > trap_ne +1463 : d0fe > bne * ;failed not equal (non zero) + > +1465 : 68 > pla ;load status +1466 : 48 > pha + > cmp_flag $ff +1467 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1469 : d0fe > bne * ;failed not equal (non zero) + > +146b : 28 > plp ;restore status + > +146c : c042 > cpy #$42 + > trap_ne ;y changed +146e : d0fe > bne * ;failed not equal (non zero) + > +1470 : e000 > cpx #0 + > trap_ne ;x changed +1472 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $6b,1 +1474 : a042 > ldy #$42 +1476 : a203 > ldx #4-1 +1478 : 6b > db $6b ;test nop length + > if 1 = 1 +1479 : ca > dex +147a : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +147b : ca > dex + > trap_ne ;wrong number of bytes +147c : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$6b,0 + > load_flag 0 +147e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1480 : 48 > pha ;use stack to load status +1481 : a994 > lda #$ff-$6b ;precharge accu +1483 : 28 > plp + > +1484 : 6b > db $6b ;test nop integrity - flags off +1485 : ea > nop +1486 : ea > nop + > tst_a $ff-$6b,0 +1487 : 08 > php ;save flags +1488 : c994 > cmp #$ff-$6b ;test result + > trap_ne +148a : d0fe > bne * ;failed not equal (non zero) + > +148c : 68 > pla ;load status +148d : 48 > pha + > cmp_flag 0 +148e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1490 : d0fe > bne * ;failed not equal (non zero) + > +1492 : 28 > plp ;restore status + > + > set_a $aa-$6b,$ff + > load_flag $ff +1493 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1495 : 48 > pha ;use stack to load status +1496 : a93f > lda #$aa-$6b ;precharge accu +1498 : 28 > plp + > +1499 : 6b > db $6b ;test nop integrity - flags on +149a : ea > nop +149b : ea > nop + > tst_a $aa-$6b,$ff +149c : 08 > php ;save flags +149d : c93f > cmp #$aa-$6b ;test result + > trap_ne +149f : d0fe > bne * ;failed not equal (non zero) + > +14a1 : 68 > pla ;load status +14a2 : 48 > pha + > cmp_flag $ff +14a3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +14a5 : d0fe > bne * ;failed not equal (non zero) + > +14a7 : 28 > plp ;restore status + > +14a8 : c042 > cpy #$42 + > trap_ne ;y changed +14aa : d0fe > bne * ;failed not equal (non zero) + > +14ac : e000 > cpx #0 + > trap_ne ;x changed +14ae : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $7b,1 +14b0 : a042 > ldy #$42 +14b2 : a203 > ldx #4-1 +14b4 : 7b > db $7b ;test nop length + > if 1 = 1 +14b5 : ca > dex +14b6 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +14b7 : ca > dex + > trap_ne ;wrong number of bytes +14b8 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$7b,0 + > load_flag 0 +14ba : a900 > lda #0 ;allow test to change I-flag (no mask) + > +14bc : 48 > pha ;use stack to load status +14bd : a984 > lda #$ff-$7b ;precharge accu +14bf : 28 > plp + > +14c0 : 7b > db $7b ;test nop integrity - flags off +14c1 : ea > nop +14c2 : ea > nop + > tst_a $ff-$7b,0 +14c3 : 08 > php ;save flags +14c4 : c984 > cmp #$ff-$7b ;test result + > trap_ne +14c6 : d0fe > bne * ;failed not equal (non zero) + > +14c8 : 68 > pla ;load status +14c9 : 48 > pha + > cmp_flag 0 +14ca : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +14cc : d0fe > bne * ;failed not equal (non zero) + > +14ce : 28 > plp ;restore status + > + > set_a $aa-$7b,$ff + > load_flag $ff +14cf : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +14d1 : 48 > pha ;use stack to load status +14d2 : a92f > lda #$aa-$7b ;precharge accu +14d4 : 28 > plp + > +14d5 : 7b > db $7b ;test nop integrity - flags on +14d6 : ea > nop +14d7 : ea > nop + > tst_a $aa-$7b,$ff +14d8 : 08 > php ;save flags +14d9 : c92f > cmp #$aa-$7b ;test result + > trap_ne +14db : d0fe > bne * ;failed not equal (non zero) + > +14dd : 68 > pla ;load status +14de : 48 > pha + > cmp_flag $ff +14df : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +14e1 : d0fe > bne * ;failed not equal (non zero) + > +14e3 : 28 > plp ;restore status + > +14e4 : c042 > cpy #$42 + > trap_ne ;y changed +14e6 : d0fe > bne * ;failed not equal (non zero) + > +14e8 : e000 > cpx #0 + > trap_ne ;x changed +14ea : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $8b,1 +14ec : a042 > ldy #$42 +14ee : a203 > ldx #4-1 +14f0 : 8b > db $8b ;test nop length + > if 1 = 1 +14f1 : ca > dex +14f2 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +14f3 : ca > dex + > trap_ne ;wrong number of bytes +14f4 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$8b,0 + > load_flag 0 +14f6 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +14f8 : 48 > pha ;use stack to load status +14f9 : a974 > lda #$ff-$8b ;precharge accu +14fb : 28 > plp + > +14fc : 8b > db $8b ;test nop integrity - flags off +14fd : ea > nop +14fe : ea > nop + > tst_a $ff-$8b,0 +14ff : 08 > php ;save flags +1500 : c974 > cmp #$ff-$8b ;test result + > trap_ne +1502 : d0fe > bne * ;failed not equal (non zero) + > +1504 : 68 > pla ;load status +1505 : 48 > pha + > cmp_flag 0 +1506 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1508 : d0fe > bne * ;failed not equal (non zero) + > +150a : 28 > plp ;restore status + > + > set_a $aa-$8b,$ff + > load_flag $ff +150b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +150d : 48 > pha ;use stack to load status +150e : a91f > lda #$aa-$8b ;precharge accu +1510 : 28 > plp + > +1511 : 8b > db $8b ;test nop integrity - flags on +1512 : ea > nop +1513 : ea > nop + > tst_a $aa-$8b,$ff +1514 : 08 > php ;save flags +1515 : c91f > cmp #$aa-$8b ;test result + > trap_ne +1517 : d0fe > bne * ;failed not equal (non zero) + > +1519 : 68 > pla ;load status +151a : 48 > pha + > cmp_flag $ff +151b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +151d : d0fe > bne * ;failed not equal (non zero) + > +151f : 28 > plp ;restore status + > +1520 : c042 > cpy #$42 + > trap_ne ;y changed +1522 : d0fe > bne * ;failed not equal (non zero) + > +1524 : e000 > cpx #0 + > trap_ne ;x changed +1526 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $9b,1 +1528 : a042 > ldy #$42 +152a : a203 > ldx #4-1 +152c : 9b > db $9b ;test nop length + > if 1 = 1 +152d : ca > dex +152e : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +152f : ca > dex + > trap_ne ;wrong number of bytes +1530 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$9b,0 + > load_flag 0 +1532 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1534 : 48 > pha ;use stack to load status +1535 : a964 > lda #$ff-$9b ;precharge accu +1537 : 28 > plp + > +1538 : 9b > db $9b ;test nop integrity - flags off +1539 : ea > nop +153a : ea > nop + > tst_a $ff-$9b,0 +153b : 08 > php ;save flags +153c : c964 > cmp #$ff-$9b ;test result + > trap_ne +153e : d0fe > bne * ;failed not equal (non zero) + > +1540 : 68 > pla ;load status +1541 : 48 > pha + > cmp_flag 0 +1542 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1544 : d0fe > bne * ;failed not equal (non zero) + > +1546 : 28 > plp ;restore status + > + > set_a $aa-$9b,$ff + > load_flag $ff +1547 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1549 : 48 > pha ;use stack to load status +154a : a90f > lda #$aa-$9b ;precharge accu +154c : 28 > plp + > +154d : 9b > db $9b ;test nop integrity - flags on +154e : ea > nop +154f : ea > nop + > tst_a $aa-$9b,$ff +1550 : 08 > php ;save flags +1551 : c90f > cmp #$aa-$9b ;test result + > trap_ne +1553 : d0fe > bne * ;failed not equal (non zero) + > +1555 : 68 > pla ;load status +1556 : 48 > pha + > cmp_flag $ff +1557 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1559 : d0fe > bne * ;failed not equal (non zero) + > +155b : 28 > plp ;restore status + > +155c : c042 > cpy #$42 + > trap_ne ;y changed +155e : d0fe > bne * ;failed not equal (non zero) + > +1560 : e000 > cpx #0 + > trap_ne ;x changed +1562 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $ab,1 +1564 : a042 > ldy #$42 +1566 : a203 > ldx #4-1 +1568 : ab > db $ab ;test nop length + > if 1 = 1 +1569 : ca > dex +156a : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +156b : ca > dex + > trap_ne ;wrong number of bytes +156c : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$ab,0 + > load_flag 0 +156e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1570 : 48 > pha ;use stack to load status +1571 : a954 > lda #$ff-$ab ;precharge accu +1573 : 28 > plp + > +1574 : ab > db $ab ;test nop integrity - flags off +1575 : ea > nop +1576 : ea > nop + > tst_a $ff-$ab,0 +1577 : 08 > php ;save flags +1578 : c954 > cmp #$ff-$ab ;test result + > trap_ne +157a : d0fe > bne * ;failed not equal (non zero) + > +157c : 68 > pla ;load status +157d : 48 > pha + > cmp_flag 0 +157e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1580 : d0fe > bne * ;failed not equal (non zero) + > +1582 : 28 > plp ;restore status + > + > set_a $aa-$ab,$ff + > load_flag $ff +1583 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1585 : 48 > pha ;use stack to load status +1586 : a9ff > lda #$aa-$ab ;precharge accu +1588 : 28 > plp + > +1589 : ab > db $ab ;test nop integrity - flags on +158a : ea > nop +158b : ea > nop + > tst_a $aa-$ab,$ff +158c : 08 > php ;save flags +158d : c9ff > cmp #$aa-$ab ;test result + > trap_ne +158f : d0fe > bne * ;failed not equal (non zero) + > +1591 : 68 > pla ;load status +1592 : 48 > pha + > cmp_flag $ff +1593 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1595 : d0fe > bne * ;failed not equal (non zero) + > +1597 : 28 > plp ;restore status + > +1598 : c042 > cpy #$42 + > trap_ne ;y changed +159a : d0fe > bne * ;failed not equal (non zero) + > +159c : e000 > cpx #0 + > trap_ne ;x changed +159e : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $bb,1 +15a0 : a042 > ldy #$42 +15a2 : a203 > ldx #4-1 +15a4 : bb > db $bb ;test nop length + > if 1 = 1 +15a5 : ca > dex +15a6 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +15a7 : ca > dex + > trap_ne ;wrong number of bytes +15a8 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$bb,0 + > load_flag 0 +15aa : a900 > lda #0 ;allow test to change I-flag (no mask) + > +15ac : 48 > pha ;use stack to load status +15ad : a944 > lda #$ff-$bb ;precharge accu +15af : 28 > plp + > +15b0 : bb > db $bb ;test nop integrity - flags off +15b1 : ea > nop +15b2 : ea > nop + > tst_a $ff-$bb,0 +15b3 : 08 > php ;save flags +15b4 : c944 > cmp #$ff-$bb ;test result + > trap_ne +15b6 : d0fe > bne * ;failed not equal (non zero) + > +15b8 : 68 > pla ;load status +15b9 : 48 > pha + > cmp_flag 0 +15ba : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +15bc : d0fe > bne * ;failed not equal (non zero) + > +15be : 28 > plp ;restore status + > + > set_a $aa-$bb,$ff + > load_flag $ff +15bf : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +15c1 : 48 > pha ;use stack to load status +15c2 : a9ef > lda #$aa-$bb ;precharge accu +15c4 : 28 > plp + > +15c5 : bb > db $bb ;test nop integrity - flags on +15c6 : ea > nop +15c7 : ea > nop + > tst_a $aa-$bb,$ff +15c8 : 08 > php ;save flags +15c9 : c9ef > cmp #$aa-$bb ;test result + > trap_ne +15cb : d0fe > bne * ;failed not equal (non zero) + > +15cd : 68 > pla ;load status +15ce : 48 > pha + > cmp_flag $ff +15cf : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +15d1 : d0fe > bne * ;failed not equal (non zero) + > +15d3 : 28 > plp ;restore status + > +15d4 : c042 > cpy #$42 + > trap_ne ;y changed +15d6 : d0fe > bne * ;failed not equal (non zero) + > +15d8 : e000 > cpx #0 + > trap_ne ;x changed +15da : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $eb,1 +15dc : a042 > ldy #$42 +15de : a203 > ldx #4-1 +15e0 : eb > db $eb ;test nop length + > if 1 = 1 +15e1 : ca > dex +15e2 : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +15e3 : ca > dex + > trap_ne ;wrong number of bytes +15e4 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$eb,0 + > load_flag 0 +15e6 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +15e8 : 48 > pha ;use stack to load status +15e9 : a914 > lda #$ff-$eb ;precharge accu +15eb : 28 > plp + > +15ec : eb > db $eb ;test nop integrity - flags off +15ed : ea > nop +15ee : ea > nop + > tst_a $ff-$eb,0 +15ef : 08 > php ;save flags +15f0 : c914 > cmp #$ff-$eb ;test result + > trap_ne +15f2 : d0fe > bne * ;failed not equal (non zero) + > +15f4 : 68 > pla ;load status +15f5 : 48 > pha + > cmp_flag 0 +15f6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +15f8 : d0fe > bne * ;failed not equal (non zero) + > +15fa : 28 > plp ;restore status + > + > set_a $aa-$eb,$ff + > load_flag $ff +15fb : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +15fd : 48 > pha ;use stack to load status +15fe : a9bf > lda #$aa-$eb ;precharge accu +1600 : 28 > plp + > +1601 : eb > db $eb ;test nop integrity - flags on +1602 : ea > nop +1603 : ea > nop + > tst_a $aa-$eb,$ff +1604 : 08 > php ;save flags +1605 : c9bf > cmp #$aa-$eb ;test result + > trap_ne +1607 : d0fe > bne * ;failed not equal (non zero) + > +1609 : 68 > pla ;load status +160a : 48 > pha + > cmp_flag $ff +160b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +160d : d0fe > bne * ;failed not equal (non zero) + > +160f : 28 > plp ;restore status + > +1610 : c042 > cpy #$42 + > trap_ne ;y changed +1612 : d0fe > bne * ;failed not equal (non zero) + > +1614 : e000 > cpx #0 + > trap_ne ;x changed +1616 : d0fe > bne * ;failed not equal (non zero) + > + + nop_test $fb,1 +1618 : a042 > ldy #$42 +161a : a203 > ldx #4-1 +161c : fb > db $fb ;test nop length + > if 1 = 1 +161d : ca > dex +161e : ca > dex + > endif + > if 1 = 2 + > iny + > dex + > endif + > if 1 = 3 + > iny + > iny + > endif +161f : ca > dex + > trap_ne ;wrong number of bytes +1620 : d0fe > bne * ;failed not equal (non zero) + > + > set_a $ff-$fb,0 + > load_flag 0 +1622 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1624 : 48 > pha ;use stack to load status +1625 : a904 > lda #$ff-$fb ;precharge accu +1627 : 28 > plp + > +1628 : fb > db $fb ;test nop integrity - flags off +1629 : ea > nop +162a : ea > nop + > tst_a $ff-$fb,0 +162b : 08 > php ;save flags +162c : c904 > cmp #$ff-$fb ;test result + > trap_ne +162e : d0fe > bne * ;failed not equal (non zero) + > +1630 : 68 > pla ;load status +1631 : 48 > pha + > cmp_flag 0 +1632 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1634 : d0fe > bne * ;failed not equal (non zero) + > +1636 : 28 > plp ;restore status + > + > set_a $aa-$fb,$ff + > load_flag $ff +1637 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1639 : 48 > pha ;use stack to load status +163a : a9af > lda #$aa-$fb ;precharge accu +163c : 28 > plp + > +163d : fb > db $fb ;test nop integrity - flags on +163e : ea > nop +163f : ea > nop + > tst_a $aa-$fb,$ff +1640 : 08 > php ;save flags +1641 : c9af > cmp #$aa-$fb ;test result + > trap_ne +1643 : d0fe > bne * ;failed not equal (non zero) + > +1645 : 68 > pla ;load status +1646 : 48 > pha + > cmp_flag $ff +1647 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1649 : d0fe > bne * ;failed not equal (non zero) + > +164b : 28 > plp ;restore status + > +164c : c042 > cpy #$42 + > trap_ne ;y changed +164e : d0fe > bne * ;failed not equal (non zero) + > +1650 : e000 > cpx #0 + > trap_ne ;x changed +1652 : d0fe > bne * ;failed not equal (non zero) + > + + if rkwl_wdc_op = 0 ;NOPs not available on Rockwell & WDC 65C02 + nop_test $07,1 + nop_test $17,1 + nop_test $27,1 + nop_test $37,1 + nop_test $47,1 + nop_test $57,1 + nop_test $67,1 + nop_test $77,1 + nop_test $87,1 + nop_test $97,1 + nop_test $a7,1 + nop_test $b7,1 + nop_test $c7,1 + nop_test $d7,1 + nop_test $e7,1 + nop_test $f7,1 + nop_test $0f,1 + nop_test $1f,1 + nop_test $2f,1 + nop_test $3f,1 + nop_test $4f,1 + nop_test $5f,1 + nop_test $6f,1 + nop_test $7f,1 + nop_test $8f,1 + nop_test $9f,1 + nop_test $af,1 + nop_test $bf,1 + nop_test $cf,1 + nop_test $df,1 + nop_test $ef,1 + nop_test $ff,1 + endif + if wdc_op = 0 ;NOPs not available on WDC 65C02 (WAI, STP) + nop_test $cb,1 + nop_test $db,1 + endif + next_test +1654 : ad0202 > lda test_case ;previous test +1657 : c908 > cmp #test_num + > trap_ne ;test is out of sequence +1659 : d0fe > bne * ;failed not equal (non zero) + > +0009 = >test_num = test_num + 1 +165b : a909 > lda #test_num ;*** next tests' number +165d : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; jump indirect (test page cross bug is fixed) +1660 : a203 ldx #3 ;prepare table +1662 : bd4026 ji1 lda ji_adr,x +1665 : 9dfd02 sta ji_tab,x +1668 : ca dex +1669 : 10f7 bpl ji1 +166b : a927 lda #hi(ji_px) ;high address if page cross bug +166d : 8d0002 sta pg_x + set_stat 0 + > load_flag 0 +1670 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1672 : 48 > pha ;use stack to load status +1673 : 28 > plp + +1674 : a949 lda #'I' +1676 : a24e ldx #'N' +1678 : a044 ldy #'D' ;N=0, V=0, Z=0, C=0 +167a : 6cfd02 jmp (ji_tab) +167d : ea nop + trap_ne ;runover protection +167e : d0fe > bne * ;failed not equal (non zero) + + +1680 : 88 dey +1681 : 88 dey +1682 : 08 ji_ret php ;either SP or Y count will fail, if we do not hit +1683 : 88 dey +1684 : 88 dey +1685 : 88 dey +1686 : 28 plp + trap_eq ;returned flags OK? +1687 : f0fe > beq * ;failed equal (zero) + + trap_pl +1689 : 10fe > bpl * ;failed plus (bit 7 clear) + + trap_cc +168b : 90fe > bcc * ;failed carry clear + + trap_vc +168d : 50fe > bvc * ;failed overflow clear + +168f : c9e3 cmp #('I'^$aa) ;returned registers OK? + trap_ne +1691 : d0fe > bne * ;failed not equal (non zero) + +1693 : e04f cpx #('N'+1) + trap_ne +1695 : d0fe > bne * ;failed not equal (non zero) + +1697 : c03e cpy #('D'-6) + trap_ne +1699 : d0fe > bne * ;failed not equal (non zero) + +169b : ba tsx ;SP check +169c : e0ff cpx #$ff + trap_ne +169e : d0fe > bne * ;failed not equal (non zero) + + next_test +16a0 : ad0202 > lda test_case ;previous test +16a3 : c909 > cmp #test_num + > trap_ne ;test is out of sequence +16a5 : d0fe > bne * ;failed not equal (non zero) + > +000a = >test_num = test_num + 1 +16a7 : a90a > lda #test_num ;*** next tests' number +16a9 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; jump indexed indirect +16ac : a20b ldx #11 ;prepare table +16ae : bd7926 jxi1 lda jxi_adr,x +16b1 : 9df902 sta jxi_tab,x +16b4 : ca dex +16b5 : 10f7 bpl jxi1 +16b7 : a927 lda #hi(jxi_px) ;high address if page cross bug +16b9 : 8d0002 sta pg_x + set_stat 0 + > load_flag 0 +16bc : a900 > lda #0 ;allow test to change I-flag (no mask) + > +16be : 48 > pha ;use stack to load status +16bf : 28 > plp + +16c0 : a958 lda #'X' +16c2 : a204 ldx #4 +16c4 : a049 ldy #'I' ;N=0, V=0, Z=0, C=0 +16c6 : 7cf902 jmp (jxi_tab,x) +16c9 : ea nop + trap_ne ;runover protection +16ca : d0fe > bne * ;failed not equal (non zero) + + +16cc : 88 dey +16cd : 88 dey +16ce : 08 jxi_ret php ;either SP or Y count will fail, if we do not hit +16cf : 88 dey +16d0 : 88 dey +16d1 : 88 dey +16d2 : 28 plp + trap_eq ;returned flags OK? +16d3 : f0fe > beq * ;failed equal (zero) + + trap_pl +16d5 : 10fe > bpl * ;failed plus (bit 7 clear) + + trap_cc +16d7 : 90fe > bcc * ;failed carry clear + + trap_vc +16d9 : 50fe > bvc * ;failed overflow clear + +16db : c9f2 cmp #('X'^$aa) ;returned registers OK? + trap_ne +16dd : d0fe > bne * ;failed not equal (non zero) + +16df : e006 cpx #6 + trap_ne +16e1 : d0fe > bne * ;failed not equal (non zero) + +16e3 : c043 cpy #('I'-6) + trap_ne +16e5 : d0fe > bne * ;failed not equal (non zero) + +16e7 : ba tsx ;SP check +16e8 : e0ff cpx #$ff + trap_ne +16ea : d0fe > bne * ;failed not equal (non zero) + + +16ec : a908 lda #lo(jxp_ok) ;test with index causing a page cross +16ee : 8d0003 sta jxp_tab +16f1 : a917 lda #hi(jxp_ok) +16f3 : 8d0103 sta jxp_tab+1 +16f6 : a905 lda #lo(jxp_px) +16f8 : 8d0002 sta pg_x +16fb : a917 lda #hi(jxp_px) +16fd : 8d0102 sta pg_x+1 +1700 : a2ff ldx #$ff +1702 : 7c0102 jmp (jxp_tab-$ff,x) + +1705 : jxp_px + trap ;page cross by index to wrong page +1705 : 4c0517 > jmp * ;failed anyway + + +1708 : jxp_ok + next_test +1708 : ad0202 > lda test_case ;previous test +170b : c90a > cmp #test_num + > trap_ne ;test is out of sequence +170d : d0fe > bne * ;failed not equal (non zero) + > +000b = >test_num = test_num + 1 +170f : a90b > lda #test_num ;*** next tests' number +1711 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + if ROM_vectors = 1 + ; test BRK clears decimal mode +1714 : f8 sed +1715 : 00 brk +1716 : ea nop +1717 : brk_ret + next_test +1717 : ad0202 > lda test_case ;previous test +171a : c90b > cmp #test_num + > trap_ne ;test is out of sequence +171c : d0fe > bne * ;failed not equal (non zero) + > +000c = >test_num = test_num + 1 +171e : a90c > lda #test_num ;*** next tests' number +1720 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + endif + + ; testing accumulator increment/decrement INC A & DEC A +1723 : a2ac ldx #$ac ;protect x & y +1725 : a0dc ldy #$dc + set_a $fe,$ff + > load_flag $ff +1727 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1729 : 48 > pha ;use stack to load status +172a : a9fe > lda #$fe ;precharge accu +172c : 28 > plp + +172d : 1a inc a ;ff + tst_as $ff,$ff-zero +172e : 48 > pha +172f : 08 > php ;save flags +1730 : c9ff > cmp #$ff ;test result + > trap_ne +1732 : d0fe > bne * ;failed not equal (non zero) + > +1734 : 68 > pla ;load status +1735 : 48 > pha + > cmp_flag $ff-zero +1736 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1738 : d0fe > bne * ;failed not equal (non zero) + > +173a : 28 > plp ;restore status +173b : 68 > pla + +173c : 1a inc a ;00 + tst_as 0,$ff-minus +173d : 48 > pha +173e : 08 > php ;save flags +173f : c900 > cmp #0 ;test result + > trap_ne +1741 : d0fe > bne * ;failed not equal (non zero) + > +1743 : 68 > pla ;load status +1744 : 48 > pha + > cmp_flag $ff-minus +1745 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1747 : d0fe > bne * ;failed not equal (non zero) + > +1749 : 28 > plp ;restore status +174a : 68 > pla + +174b : 1a inc a ;01 + tst_as 1,$ff-minus-zero +174c : 48 > pha +174d : 08 > php ;save flags +174e : c901 > cmp #1 ;test result + > trap_ne +1750 : d0fe > bne * ;failed not equal (non zero) + > +1752 : 68 > pla ;load status +1753 : 48 > pha + > cmp_flag $ff-minus-zero +1754 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1756 : d0fe > bne * ;failed not equal (non zero) + > +1758 : 28 > plp ;restore status +1759 : 68 > pla + +175a : 3a dec a ;00 + tst_as 0,$ff-minus +175b : 48 > pha +175c : 08 > php ;save flags +175d : c900 > cmp #0 ;test result + > trap_ne +175f : d0fe > bne * ;failed not equal (non zero) + > +1761 : 68 > pla ;load status +1762 : 48 > pha + > cmp_flag $ff-minus +1763 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1765 : d0fe > bne * ;failed not equal (non zero) + > +1767 : 28 > plp ;restore status +1768 : 68 > pla + +1769 : 3a dec a ;ff + tst_as $ff,$ff-zero +176a : 48 > pha +176b : 08 > php ;save flags +176c : c9ff > cmp #$ff ;test result + > trap_ne +176e : d0fe > bne * ;failed not equal (non zero) + > +1770 : 68 > pla ;load status +1771 : 48 > pha + > cmp_flag $ff-zero +1772 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1774 : d0fe > bne * ;failed not equal (non zero) + > +1776 : 28 > plp ;restore status +1777 : 68 > pla + +1778 : 3a dec a ;fe + set_a $fe,0 + > load_flag 0 +1779 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +177b : 48 > pha ;use stack to load status +177c : a9fe > lda #$fe ;precharge accu +177e : 28 > plp + +177f : 1a inc a ;ff + tst_as $ff,minus +1780 : 48 > pha +1781 : 08 > php ;save flags +1782 : c9ff > cmp #$ff ;test result + > trap_ne +1784 : d0fe > bne * ;failed not equal (non zero) + > +1786 : 68 > pla ;load status +1787 : 48 > pha + > cmp_flag minus +1788 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +178a : d0fe > bne * ;failed not equal (non zero) + > +178c : 28 > plp ;restore status +178d : 68 > pla + +178e : 1a inc a ;00 + tst_as 0,zero +178f : 48 > pha +1790 : 08 > php ;save flags +1791 : c900 > cmp #0 ;test result + > trap_ne +1793 : d0fe > bne * ;failed not equal (non zero) + > +1795 : 68 > pla ;load status +1796 : 48 > pha + > cmp_flag zero +1797 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1799 : d0fe > bne * ;failed not equal (non zero) + > +179b : 28 > plp ;restore status +179c : 68 > pla + +179d : 1a inc a ;01 + tst_as 1,0 +179e : 48 > pha +179f : 08 > php ;save flags +17a0 : c901 > cmp #1 ;test result + > trap_ne +17a2 : d0fe > bne * ;failed not equal (non zero) + > +17a4 : 68 > pla ;load status +17a5 : 48 > pha + > cmp_flag 0 +17a6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +17a8 : d0fe > bne * ;failed not equal (non zero) + > +17aa : 28 > plp ;restore status +17ab : 68 > pla + +17ac : 3a dec a ;00 + tst_as 0,zero +17ad : 48 > pha +17ae : 08 > php ;save flags +17af : c900 > cmp #0 ;test result + > trap_ne +17b1 : d0fe > bne * ;failed not equal (non zero) + > +17b3 : 68 > pla ;load status +17b4 : 48 > pha + > cmp_flag zero +17b5 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits + > + > trap_ne +17b7 : d0fe > bne * ;failed not equal (non zero) + > +17b9 : 28 > plp ;restore status +17ba : 68 > pla + +17bb : 3a dec a ;ff + tst_as $ff,minus +17bc : 48 > pha +17bd : 08 > php ;save flags +17be : c9ff > cmp #$ff ;test result + > trap_ne +17c0 : d0fe > bne * ;failed not equal (non zero) + > +17c2 : 68 > pla ;load status +17c3 : 48 > pha + > cmp_flag minus +17c4 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits + > + > trap_ne +17c6 : d0fe > bne * ;failed not equal (non zero) + > +17c8 : 28 > plp ;restore status +17c9 : 68 > pla + +17ca : e0ac cpx #$ac + trap_ne ;x altered during test +17cc : d0fe > bne * ;failed not equal (non zero) + +17ce : c0dc cpy #$dc + trap_ne ;y altered during test +17d0 : d0fe > bne * ;failed not equal (non zero) + +17d2 : ba tsx +17d3 : e0ff cpx #$ff + trap_ne ;sp push/pop mismatch +17d5 : d0fe > bne * ;failed not equal (non zero) + + next_test +17d7 : ad0202 > lda test_case ;previous test +17da : c90c > cmp #test_num + > trap_ne ;test is out of sequence +17dc : d0fe > bne * ;failed not equal (non zero) + > +000d = >test_num = test_num + 1 +17de : a90d > lda #test_num ;*** next tests' number +17e0 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; testing load / store accumulator LDA / STA (zp) +17e3 : a299 ldx #$99 ;protect x & y +17e5 : a066 ldy #$66 + set_stat 0 + > load_flag 0 +17e7 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +17e9 : 48 > pha ;use stack to load status +17ea : 28 > plp + +17eb : b222 lda (ind1) +17ed : 08 php ;test stores do not alter flags +17ee : 49c3 eor #$c3 +17f0 : 28 plp +17f1 : 922e sta (indt) +17f3 : 08 php ;flags after load/store sequence +17f4 : 49c3 eor #$c3 +17f6 : c9c3 cmp #$c3 ;test result + trap_ne +17f8 : d0fe > bne * ;failed not equal (non zero) + +17fa : 68 pla ;load status + eor_flag 0 +17fb : 4930 > eor #0|fao ;invert expected flags + always on bits + +17fd : cd0f02 cmp fLDx ;test flags + trap_ne +1800 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1802 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1804 : 48 > pha ;use stack to load status +1805 : 28 > plp + +1806 : b224 lda (ind1+2) +1808 : 08 php ;test stores do not alter flags +1809 : 49c3 eor #$c3 +180b : 28 plp +180c : 9230 sta (indt+2) +180e : 08 php ;flags after load/store sequence +180f : 49c3 eor #$c3 +1811 : c982 cmp #$82 ;test result + trap_ne +1813 : d0fe > bne * ;failed not equal (non zero) + +1815 : 68 pla ;load status + eor_flag 0 +1816 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1818 : cd1002 cmp fLDx+1 ;test flags + trap_ne +181b : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +181d : a900 > lda #0 ;allow test to change I-flag (no mask) + > +181f : 48 > pha ;use stack to load status +1820 : 28 > plp + +1821 : b226 lda (ind1+4) +1823 : 08 php ;test stores do not alter flags +1824 : 49c3 eor #$c3 +1826 : 28 plp +1827 : 9232 sta (indt+4) +1829 : 08 php ;flags after load/store sequence +182a : 49c3 eor #$c3 +182c : c941 cmp #$41 ;test result + trap_ne +182e : d0fe > bne * ;failed not equal (non zero) + +1830 : 68 pla ;load status + eor_flag 0 +1831 : 4930 > eor #0|fao ;invert expected flags + always on bits + +1833 : cd1102 cmp fLDx+2 ;test flags + trap_ne +1836 : d0fe > bne * ;failed not equal (non zero) + + set_stat 0 + > load_flag 0 +1838 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +183a : 48 > pha ;use stack to load status +183b : 28 > plp + +183c : b228 lda (ind1+6) +183e : 08 php ;test stores do not alter flags +183f : 49c3 eor #$c3 +1841 : 28 plp +1842 : 9234 sta (indt+6) +1844 : 08 php ;flags after load/store sequence +1845 : 49c3 eor #$c3 +1847 : c900 cmp #0 ;test result + trap_ne +1849 : d0fe > bne * ;failed not equal (non zero) + +184b : 68 pla ;load status + eor_flag 0 +184c : 4930 > eor #0|fao ;invert expected flags + always on bits + +184e : cd1202 cmp fLDx+3 ;test flags + trap_ne +1851 : d0fe > bne * ;failed not equal (non zero) + +1853 : e099 cpx #$99 + trap_ne ;x altered during test +1855 : d0fe > bne * ;failed not equal (non zero) + +1857 : c066 cpy #$66 + trap_ne ;y altered during test +1859 : d0fe > bne * ;failed not equal (non zero) + + +185b : a003 ldy #3 ;testing store result +185d : a200 ldx #0 +185f : b90502 tstai1 lda abst,y +1862 : 49c3 eor #$c3 +1864 : d90a02 cmp abs1,y + trap_ne ;store to indirect data +1867 : d0fe > bne * ;failed not equal (non zero) + +1869 : 8a txa +186a : 990502 sta abst,y ;clear +186d : 88 dey +186e : 10ef bpl tstai1 + +1870 : a299 ldx #$99 ;protect x & y +1872 : a066 ldy #$66 + set_stat $ff + > load_flag $ff +1874 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1876 : 48 > pha ;use stack to load status +1877 : 28 > plp + +1878 : b222 lda (ind1) +187a : 08 php ;test stores do not alter flags +187b : 49c3 eor #$c3 +187d : 28 plp +187e : 922e sta (indt) +1880 : 08 php ;flags after load/store sequence +1881 : 49c3 eor #$c3 +1883 : c9c3 cmp #$c3 ;test result + trap_ne +1885 : d0fe > bne * ;failed not equal (non zero) + +1887 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +1888 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +188a : cd0f02 cmp fLDx ;test flags + trap_ne +188d : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +188f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1891 : 48 > pha ;use stack to load status +1892 : 28 > plp + +1893 : b224 lda (ind1+2) +1895 : 08 php ;test stores do not alter flags +1896 : 49c3 eor #$c3 +1898 : 28 plp +1899 : 9230 sta (indt+2) +189b : 08 php ;flags after load/store sequence +189c : 49c3 eor #$c3 +189e : c982 cmp #$82 ;test result + trap_ne +18a0 : d0fe > bne * ;failed not equal (non zero) + +18a2 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +18a3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +18a5 : cd1002 cmp fLDx+1 ;test flags + trap_ne +18a8 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +18aa : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +18ac : 48 > pha ;use stack to load status +18ad : 28 > plp + +18ae : b226 lda (ind1+4) +18b0 : 08 php ;test stores do not alter flags +18b1 : 49c3 eor #$c3 +18b3 : 28 plp +18b4 : 9232 sta (indt+4) +18b6 : 08 php ;flags after load/store sequence +18b7 : 49c3 eor #$c3 +18b9 : c941 cmp #$41 ;test result + trap_ne +18bb : d0fe > bne * ;failed not equal (non zero) + +18bd : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +18be : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +18c0 : cd1102 cmp fLDx+2 ;test flags + trap_ne +18c3 : d0fe > bne * ;failed not equal (non zero) + + set_stat $ff + > load_flag $ff +18c5 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +18c7 : 48 > pha ;use stack to load status +18c8 : 28 > plp + +18c9 : b228 lda (ind1+6) +18cb : 08 php ;test stores do not alter flags +18cc : 49c3 eor #$c3 +18ce : 28 plp +18cf : 9234 sta (indt+6) +18d1 : 08 php ;flags after load/store sequence +18d2 : 49c3 eor #$c3 +18d4 : c900 cmp #0 ;test result + trap_ne +18d6 : d0fe > bne * ;failed not equal (non zero) + +18d8 : 68 pla ;load status + eor_flag lo~fnz ;mask bits not altered +18d9 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits + +18db : cd1202 cmp fLDx+3 ;test flags + trap_ne +18de : d0fe > bne * ;failed not equal (non zero) + +18e0 : e099 cpx #$99 + trap_ne ;x altered during test +18e2 : d0fe > bne * ;failed not equal (non zero) + +18e4 : c066 cpy #$66 + trap_ne ;y altered during test +18e6 : d0fe > bne * ;failed not equal (non zero) + + +18e8 : a003 ldy #3 ;testing store result +18ea : a200 ldx #0 +18ec : b90502 tstai2 lda abst,y +18ef : 49c3 eor #$c3 +18f1 : d90a02 cmp abs1,y + trap_ne ;store to indirect data +18f4 : d0fe > bne * ;failed not equal (non zero) + +18f6 : 8a txa +18f7 : 990502 sta abst,y ;clear +18fa : 88 dey +18fb : 10ef bpl tstai2 +18fd : ba tsx +18fe : e0ff cpx #$ff + trap_ne ;sp push/pop mismatch +1900 : d0fe > bne * ;failed not equal (non zero) + + next_test +1902 : ad0202 > lda test_case ;previous test +1905 : c90d > cmp #test_num + > trap_ne ;test is out of sequence +1907 : d0fe > bne * ;failed not equal (non zero) + > +000e = >test_num = test_num + 1 +1909 : a90e > lda #test_num ;*** next tests' number +190b : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; testing STZ - zp / abs / zp,x / abs,x +190e : a07b ldy #123 ;protect y +1910 : a204 ldx #4 ;precharge test area +1912 : a907 lda #7 +1914 : 950a tstz1 sta zpt,x +1916 : 0a asl a +1917 : ca dex +1918 : 10fa bpl tstz1 +191a : a204 ldx #4 + set_a $55,$ff + > load_flag $ff +191c : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +191e : 48 > pha ;use stack to load status +191f : a955 > lda #$55 ;precharge accu +1921 : 28 > plp + +1922 : 640a stz zpt +1924 : 640b stz zpt+1 +1926 : 640c stz zpt+2 +1928 : 640d stz zpt+3 +192a : 640e stz zpt+4 + tst_a $55,$ff +192c : 08 > php ;save flags +192d : c955 > cmp #$55 ;test result + > trap_ne +192f : d0fe > bne * ;failed not equal (non zero) + > +1931 : 68 > pla ;load status +1932 : 48 > pha + > cmp_flag $ff +1933 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1935 : d0fe > bne * ;failed not equal (non zero) + > +1937 : 28 > plp ;restore status + +1938 : b50a tstz2 lda zpt,x ;verify zeros stored + trap_ne ;non zero after STZ zp +193a : d0fe > bne * ;failed not equal (non zero) + +193c : ca dex +193d : 10f9 bpl tstz2 +193f : a204 ldx #4 ;precharge test area +1941 : a907 lda #7 +1943 : 950a tstz3 sta zpt,x +1945 : 0a asl a +1946 : ca dex +1947 : 10fa bpl tstz3 +1949 : a204 ldx #4 + set_a $aa,0 + > load_flag 0 +194b : a900 > lda #0 ;allow test to change I-flag (no mask) + > +194d : 48 > pha ;use stack to load status +194e : a9aa > lda #$aa ;precharge accu +1950 : 28 > plp + +1951 : 640a stz zpt +1953 : 640b stz zpt+1 +1955 : 640c stz zpt+2 +1957 : 640d stz zpt+3 +1959 : 640e stz zpt+4 + tst_a $aa,0 +195b : 08 > php ;save flags +195c : c9aa > cmp #$aa ;test result + > trap_ne +195e : d0fe > bne * ;failed not equal (non zero) + > +1960 : 68 > pla ;load status +1961 : 48 > pha + > cmp_flag 0 +1962 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1964 : d0fe > bne * ;failed not equal (non zero) + > +1966 : 28 > plp ;restore status + +1967 : b50a tstz4 lda zpt,x ;verify zeros stored + trap_ne ;non zero after STZ zp +1969 : d0fe > bne * ;failed not equal (non zero) + +196b : ca dex +196c : 10f9 bpl tstz4 + +196e : a204 ldx #4 ;precharge test area +1970 : a907 lda #7 +1972 : 9d0502 tstz5 sta abst,x +1975 : 0a asl a +1976 : ca dex +1977 : 10f9 bpl tstz5 +1979 : a204 ldx #4 + set_a $55,$ff + > load_flag $ff +197b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +197d : 48 > pha ;use stack to load status +197e : a955 > lda #$55 ;precharge accu +1980 : 28 > plp + +1981 : 9c0502 stz abst +1984 : 9c0602 stz abst+1 +1987 : 9c0702 stz abst+2 +198a : 9c0802 stz abst+3 +198d : 9c0902 stz abst+4 + tst_a $55,$ff +1990 : 08 > php ;save flags +1991 : c955 > cmp #$55 ;test result + > trap_ne +1993 : d0fe > bne * ;failed not equal (non zero) + > +1995 : 68 > pla ;load status +1996 : 48 > pha + > cmp_flag $ff +1997 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1999 : d0fe > bne * ;failed not equal (non zero) + > +199b : 28 > plp ;restore status + +199c : bd0502 tstz6 lda abst,x ;verify zeros stored + trap_ne ;non zero after STZ abs +199f : d0fe > bne * ;failed not equal (non zero) + +19a1 : ca dex +19a2 : 10f8 bpl tstz6 +19a4 : a204 ldx #4 ;precharge test area +19a6 : a907 lda #7 +19a8 : 9d0502 tstz7 sta abst,x +19ab : 0a asl a +19ac : ca dex +19ad : 10f9 bpl tstz7 +19af : a204 ldx #4 + set_a $aa,0 + > load_flag 0 +19b1 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +19b3 : 48 > pha ;use stack to load status +19b4 : a9aa > lda #$aa ;precharge accu +19b6 : 28 > plp + +19b7 : 9c0502 stz abst +19ba : 9c0602 stz abst+1 +19bd : 9c0702 stz abst+2 +19c0 : 9c0802 stz abst+3 +19c3 : 9c0902 stz abst+4 + tst_a $aa,0 +19c6 : 08 > php ;save flags +19c7 : c9aa > cmp #$aa ;test result + > trap_ne +19c9 : d0fe > bne * ;failed not equal (non zero) + > +19cb : 68 > pla ;load status +19cc : 48 > pha + > cmp_flag 0 +19cd : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +19cf : d0fe > bne * ;failed not equal (non zero) + > +19d1 : 28 > plp ;restore status + +19d2 : bd0502 tstz8 lda abst,x ;verify zeros stored + trap_ne ;non zero after STZ abs +19d5 : d0fe > bne * ;failed not equal (non zero) + +19d7 : ca dex +19d8 : 10f8 bpl tstz8 + +19da : a204 ldx #4 ;precharge test area +19dc : a907 lda #7 +19de : 950a tstz11 sta zpt,x +19e0 : 0a asl a +19e1 : ca dex +19e2 : 10fa bpl tstz11 +19e4 : a204 ldx #4 +19e6 : tstz15 + set_a $55,$ff + > load_flag $ff +19e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +19e8 : 48 > pha ;use stack to load status +19e9 : a955 > lda #$55 ;precharge accu +19eb : 28 > plp + +19ec : 740a stz zpt,x + tst_a $55,$ff +19ee : 08 > php ;save flags +19ef : c955 > cmp #$55 ;test result + > trap_ne +19f1 : d0fe > bne * ;failed not equal (non zero) + > +19f3 : 68 > pla ;load status +19f4 : 48 > pha + > cmp_flag $ff +19f5 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +19f7 : d0fe > bne * ;failed not equal (non zero) + > +19f9 : 28 > plp ;restore status + +19fa : ca dex +19fb : 10e9 bpl tstz15 +19fd : a204 ldx #4 +19ff : b50a tstz12 lda zpt,x ;verify zeros stored + trap_ne ;non zero after STZ zp +1a01 : d0fe > bne * ;failed not equal (non zero) + +1a03 : ca dex +1a04 : 10f9 bpl tstz12 +1a06 : a204 ldx #4 ;precharge test area +1a08 : a907 lda #7 +1a0a : 950a tstz13 sta zpt,x +1a0c : 0a asl a +1a0d : ca dex +1a0e : 10fa bpl tstz13 +1a10 : a204 ldx #4 +1a12 : tstz16 + set_a $aa,0 + > load_flag 0 +1a12 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1a14 : 48 > pha ;use stack to load status +1a15 : a9aa > lda #$aa ;precharge accu +1a17 : 28 > plp + +1a18 : 740a stz zpt,x + tst_a $aa,0 +1a1a : 08 > php ;save flags +1a1b : c9aa > cmp #$aa ;test result + > trap_ne +1a1d : d0fe > bne * ;failed not equal (non zero) + > +1a1f : 68 > pla ;load status +1a20 : 48 > pha + > cmp_flag 0 +1a21 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1a23 : d0fe > bne * ;failed not equal (non zero) + > +1a25 : 28 > plp ;restore status + +1a26 : ca dex +1a27 : 10e9 bpl tstz16 +1a29 : a204 ldx #4 +1a2b : b50a tstz14 lda zpt,x ;verify zeros stored + trap_ne ;non zero after STZ zp +1a2d : d0fe > bne * ;failed not equal (non zero) + +1a2f : ca dex +1a30 : 10f9 bpl tstz14 + +1a32 : a204 ldx #4 ;precharge test area +1a34 : a907 lda #7 +1a36 : 9d0502 tstz21 sta abst,x +1a39 : 0a asl a +1a3a : ca dex +1a3b : 10f9 bpl tstz21 +1a3d : a204 ldx #4 +1a3f : tstz25 + set_a $55,$ff + > load_flag $ff +1a3f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1a41 : 48 > pha ;use stack to load status +1a42 : a955 > lda #$55 ;precharge accu +1a44 : 28 > plp + +1a45 : 9e0502 stz abst,x + tst_a $55,$ff +1a48 : 08 > php ;save flags +1a49 : c955 > cmp #$55 ;test result + > trap_ne +1a4b : d0fe > bne * ;failed not equal (non zero) + > +1a4d : 68 > pla ;load status +1a4e : 48 > pha + > cmp_flag $ff +1a4f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1a51 : d0fe > bne * ;failed not equal (non zero) + > +1a53 : 28 > plp ;restore status + +1a54 : ca dex +1a55 : 10e8 bpl tstz25 +1a57 : a204 ldx #4 +1a59 : bd0502 tstz22 lda abst,x ;verify zeros stored + trap_ne ;non zero after STZ zp +1a5c : d0fe > bne * ;failed not equal (non zero) + +1a5e : ca dex +1a5f : 10f8 bpl tstz22 +1a61 : a204 ldx #4 ;precharge test area +1a63 : a907 lda #7 +1a65 : 9d0502 tstz23 sta abst,x +1a68 : 0a asl a +1a69 : ca dex +1a6a : 10f9 bpl tstz23 +1a6c : a204 ldx #4 +1a6e : tstz26 + set_a $aa,0 + > load_flag 0 +1a6e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1a70 : 48 > pha ;use stack to load status +1a71 : a9aa > lda #$aa ;precharge accu +1a73 : 28 > plp + +1a74 : 9e0502 stz abst,x + tst_a $aa,0 +1a77 : 08 > php ;save flags +1a78 : c9aa > cmp #$aa ;test result + > trap_ne +1a7a : d0fe > bne * ;failed not equal (non zero) + > +1a7c : 68 > pla ;load status +1a7d : 48 > pha + > cmp_flag 0 +1a7e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1a80 : d0fe > bne * ;failed not equal (non zero) + > +1a82 : 28 > plp ;restore status + +1a83 : ca dex +1a84 : 10e8 bpl tstz26 +1a86 : a204 ldx #4 +1a88 : bd0502 tstz24 lda abst,x ;verify zeros stored + trap_ne ;non zero after STZ zp +1a8b : d0fe > bne * ;failed not equal (non zero) + +1a8d : ca dex +1a8e : 10f8 bpl tstz24 + +1a90 : c07b cpy #123 + trap_ne ;y altered during test +1a92 : d0fe > bne * ;failed not equal (non zero) + +1a94 : ba tsx +1a95 : e0ff cpx #$ff + trap_ne ;sp push/pop mismatch +1a97 : d0fe > bne * ;failed not equal (non zero) + + next_test +1a99 : ad0202 > lda test_case ;previous test +1a9c : c90e > cmp #test_num + > trap_ne ;test is out of sequence +1a9e : d0fe > bne * ;failed not equal (non zero) + > +000f = >test_num = test_num + 1 +1aa0 : a90f > lda #test_num ;*** next tests' number +1aa2 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; testing BIT - zp,x / abs,x / # +1aa5 : a042 ldy #$42 +1aa7 : a203 ldx #3 + set_a $ff,0 + > load_flag 0 +1aa9 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1aab : 48 > pha ;use stack to load status +1aac : a9ff > lda #$ff ;precharge accu +1aae : 28 > plp + +1aaf : 3411 bit zp1,x ;00 - should set Z / clear NV + tst_a $ff,fz +1ab1 : 08 > php ;save flags +1ab2 : c9ff > cmp #$ff ;test result + > trap_ne +1ab4 : d0fe > bne * ;failed not equal (non zero) + > +1ab6 : 68 > pla ;load status +1ab7 : 48 > pha + > cmp_flag fz +1ab8 : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits + > + > trap_ne +1aba : d0fe > bne * ;failed not equal (non zero) + > +1abc : 28 > plp ;restore status + +1abd : ca dex + set_a 1,0 + > load_flag 0 +1abe : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1ac0 : 48 > pha ;use stack to load status +1ac1 : a901 > lda #1 ;precharge accu +1ac3 : 28 > plp + +1ac4 : 3411 bit zp1,x ;41 - should set V (M6) / clear NZ + tst_a 1,fv +1ac6 : 08 > php ;save flags +1ac7 : c901 > cmp #1 ;test result + > trap_ne +1ac9 : d0fe > bne * ;failed not equal (non zero) + > +1acb : 68 > pla ;load status +1acc : 48 > pha + > cmp_flag fv +1acd : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1acf : d0fe > bne * ;failed not equal (non zero) + > +1ad1 : 28 > plp ;restore status + +1ad2 : ca dex + set_a 1,0 + > load_flag 0 +1ad3 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1ad5 : 48 > pha ;use stack to load status +1ad6 : a901 > lda #1 ;precharge accu +1ad8 : 28 > plp + +1ad9 : 3411 bit zp1,x ;82 - should set N (M7) & Z / clear V + tst_a 1,fnz +1adb : 08 > php ;save flags +1adc : c901 > cmp #1 ;test result + > trap_ne +1ade : d0fe > bne * ;failed not equal (non zero) + > +1ae0 : 68 > pla ;load status +1ae1 : 48 > pha + > cmp_flag fnz +1ae2 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ae4 : d0fe > bne * ;failed not equal (non zero) + > +1ae6 : 28 > plp ;restore status + +1ae7 : ca dex + set_a 1,0 + > load_flag 0 +1ae8 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1aea : 48 > pha ;use stack to load status +1aeb : a901 > lda #1 ;precharge accu +1aed : 28 > plp + +1aee : 3411 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z + tst_a 1,fnv +1af0 : 08 > php ;save flags +1af1 : c901 > cmp #1 ;test result + > trap_ne +1af3 : d0fe > bne * ;failed not equal (non zero) + > +1af5 : 68 > pla ;load status +1af6 : 48 > pha + > cmp_flag fnv +1af7 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1af9 : d0fe > bne * ;failed not equal (non zero) + > +1afb : 28 > plp ;restore status + + + set_a 1,$ff + > load_flag $ff +1afc : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1afe : 48 > pha ;use stack to load status +1aff : a901 > lda #1 ;precharge accu +1b01 : 28 > plp + +1b02 : 3411 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z + tst_a 1,~fz +1b04 : 08 > php ;save flags +1b05 : c901 > cmp #1 ;test result + > trap_ne +1b07 : d0fe > bne * ;failed not equal (non zero) + > +1b09 : 68 > pla ;load status +1b0a : 48 > pha + > cmp_flag ~fz +1b0b : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b0d : d0fe > bne * ;failed not equal (non zero) + > +1b0f : 28 > plp ;restore status + +1b10 : e8 inx + set_a 1,$ff + > load_flag $ff +1b11 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1b13 : 48 > pha ;use stack to load status +1b14 : a901 > lda #1 ;precharge accu +1b16 : 28 > plp + +1b17 : 3411 bit zp1,x ;82 - should set N (M7) & Z / clear V + tst_a 1,~fv +1b19 : 08 > php ;save flags +1b1a : c901 > cmp #1 ;test result + > trap_ne +1b1c : d0fe > bne * ;failed not equal (non zero) + > +1b1e : 68 > pla ;load status +1b1f : 48 > pha + > cmp_flag ~fv +1b20 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b22 : d0fe > bne * ;failed not equal (non zero) + > +1b24 : 28 > plp ;restore status + +1b25 : e8 inx + set_a 1,$ff + > load_flag $ff +1b26 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1b28 : 48 > pha ;use stack to load status +1b29 : a901 > lda #1 ;precharge accu +1b2b : 28 > plp + +1b2c : 3411 bit zp1,x ;41 - should set V (M6) / clear NZ + tst_a 1,~fnz +1b2e : 08 > php ;save flags +1b2f : c901 > cmp #1 ;test result + > trap_ne +1b31 : d0fe > bne * ;failed not equal (non zero) + > +1b33 : 68 > pla ;load status +1b34 : 48 > pha + > cmp_flag ~fnz +1b35 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b37 : d0fe > bne * ;failed not equal (non zero) + > +1b39 : 28 > plp ;restore status + +1b3a : e8 inx + set_a $ff,$ff + > load_flag $ff +1b3b : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1b3d : 48 > pha ;use stack to load status +1b3e : a9ff > lda #$ff ;precharge accu +1b40 : 28 > plp + +1b41 : 3411 bit zp1,x ;00 - should set Z / clear NV + tst_a $ff,~fnv +1b43 : 08 > php ;save flags +1b44 : c9ff > cmp #$ff ;test result + > trap_ne +1b46 : d0fe > bne * ;failed not equal (non zero) + > +1b48 : 68 > pla ;load status +1b49 : 48 > pha + > cmp_flag ~fnv +1b4a : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b4c : d0fe > bne * ;failed not equal (non zero) + > +1b4e : 28 > plp ;restore status + + + set_a $ff,0 + > load_flag 0 +1b4f : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1b51 : 48 > pha ;use stack to load status +1b52 : a9ff > lda #$ff ;precharge accu +1b54 : 28 > plp + +1b55 : 3c0a02 bit abs1,x ;00 - should set Z / clear NV + tst_a $ff,fz +1b58 : 08 > php ;save flags +1b59 : c9ff > cmp #$ff ;test result + > trap_ne +1b5b : d0fe > bne * ;failed not equal (non zero) + > +1b5d : 68 > pla ;load status +1b5e : 48 > pha + > cmp_flag fz +1b5f : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b61 : d0fe > bne * ;failed not equal (non zero) + > +1b63 : 28 > plp ;restore status + +1b64 : ca dex + set_a 1,0 + > load_flag 0 +1b65 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1b67 : 48 > pha ;use stack to load status +1b68 : a901 > lda #1 ;precharge accu +1b6a : 28 > plp + +1b6b : 3c0a02 bit abs1,x ;41 - should set V (M6) / clear NZ + tst_a 1,fv +1b6e : 08 > php ;save flags +1b6f : c901 > cmp #1 ;test result + > trap_ne +1b71 : d0fe > bne * ;failed not equal (non zero) + > +1b73 : 68 > pla ;load status +1b74 : 48 > pha + > cmp_flag fv +1b75 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b77 : d0fe > bne * ;failed not equal (non zero) + > +1b79 : 28 > plp ;restore status + +1b7a : ca dex + set_a 1,0 + > load_flag 0 +1b7b : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1b7d : 48 > pha ;use stack to load status +1b7e : a901 > lda #1 ;precharge accu +1b80 : 28 > plp + +1b81 : 3c0a02 bit abs1,x ;82 - should set N (M7) & Z / clear V + tst_a 1,fnz +1b84 : 08 > php ;save flags +1b85 : c901 > cmp #1 ;test result + > trap_ne +1b87 : d0fe > bne * ;failed not equal (non zero) + > +1b89 : 68 > pla ;load status +1b8a : 48 > pha + > cmp_flag fnz +1b8b : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1b8d : d0fe > bne * ;failed not equal (non zero) + > +1b8f : 28 > plp ;restore status + +1b90 : ca dex + set_a 1,0 + > load_flag 0 +1b91 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1b93 : 48 > pha ;use stack to load status +1b94 : a901 > lda #1 ;precharge accu +1b96 : 28 > plp + +1b97 : 3c0a02 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z + tst_a 1,fnv +1b9a : 08 > php ;save flags +1b9b : c901 > cmp #1 ;test result + > trap_ne +1b9d : d0fe > bne * ;failed not equal (non zero) + > +1b9f : 68 > pla ;load status +1ba0 : 48 > pha + > cmp_flag fnv +1ba1 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ba3 : d0fe > bne * ;failed not equal (non zero) + > +1ba5 : 28 > plp ;restore status + + + set_a 1,$ff + > load_flag $ff +1ba6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1ba8 : 48 > pha ;use stack to load status +1ba9 : a901 > lda #1 ;precharge accu +1bab : 28 > plp + +1bac : 3c0a02 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z + tst_a 1,~fz +1baf : 08 > php ;save flags +1bb0 : c901 > cmp #1 ;test result + > trap_ne +1bb2 : d0fe > bne * ;failed not equal (non zero) + > +1bb4 : 68 > pla ;load status +1bb5 : 48 > pha + > cmp_flag ~fz +1bb6 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1bb8 : d0fe > bne * ;failed not equal (non zero) + > +1bba : 28 > plp ;restore status + +1bbb : e8 inx + set_a 1,$ff + > load_flag $ff +1bbc : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1bbe : 48 > pha ;use stack to load status +1bbf : a901 > lda #1 ;precharge accu +1bc1 : 28 > plp + +1bc2 : 3c0a02 bit abs1,x ;82 - should set N (M7) & Z / clear V + tst_a 1,~fv +1bc5 : 08 > php ;save flags +1bc6 : c901 > cmp #1 ;test result + > trap_ne +1bc8 : d0fe > bne * ;failed not equal (non zero) + > +1bca : 68 > pla ;load status +1bcb : 48 > pha + > cmp_flag ~fv +1bcc : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1bce : d0fe > bne * ;failed not equal (non zero) + > +1bd0 : 28 > plp ;restore status + +1bd1 : e8 inx + set_a 1,$ff + > load_flag $ff +1bd2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1bd4 : 48 > pha ;use stack to load status +1bd5 : a901 > lda #1 ;precharge accu +1bd7 : 28 > plp + +1bd8 : 3c0a02 bit abs1,x ;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 + +1be7 : e8 inx + set_a $ff,$ff + > load_flag $ff +1be8 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1bea : 48 > pha ;use stack to load status +1beb : a9ff > lda #$ff ;precharge accu +1bed : 28 > plp + +1bee : 3c0a02 bit abs1,x ;00 - should set Z / clear NV + tst_a $ff,~fnv +1bf1 : 08 > php ;save flags +1bf2 : c9ff > cmp #$ff ;test result + > trap_ne +1bf4 : d0fe > bne * ;failed not equal (non zero) + > +1bf6 : 68 > pla ;load status +1bf7 : 48 > pha + > cmp_flag ~fnv +1bf8 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits + > + > trap_ne +1bfa : d0fe > bne * ;failed not equal (non zero) + > +1bfc : 28 > plp ;restore status + + + set_a $ff,0 + > load_flag 0 +1bfd : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1bff : 48 > pha ;use stack to load status +1c00 : a9ff > lda #$ff ;precharge accu +1c02 : 28 > plp + +1c03 : 8900 bit #$00 ;00 - should set Z + tst_a $ff,fz +1c05 : 08 > php ;save flags +1c06 : c9ff > cmp #$ff ;test result + > trap_ne +1c08 : d0fe > bne * ;failed not equal (non zero) + > +1c0a : 68 > pla ;load status +1c0b : 48 > pha + > cmp_flag fz +1c0c : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c0e : d0fe > bne * ;failed not equal (non zero) + > +1c10 : 28 > plp ;restore status + +1c11 : ca dex + set_a 1,0 + > load_flag 0 +1c12 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1c14 : 48 > pha ;use stack to load status +1c15 : a901 > lda #1 ;precharge accu +1c17 : 28 > plp + +1c18 : 8941 bit #$41 ;41 - should clear Z + tst_a 1,0 +1c1a : 08 > php ;save flags +1c1b : c901 > cmp #1 ;test result + > trap_ne +1c1d : d0fe > bne * ;failed not equal (non zero) + > +1c1f : 68 > pla ;load status +1c20 : 48 > pha + > cmp_flag 0 +1c21 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c23 : d0fe > bne * ;failed not equal (non zero) + > +1c25 : 28 > plp ;restore status + + ; *** DEBUG INFO *** + ; if it fails the previous test and your BIT # has set the V flag + ; see http://forum.6502.org/viewtopic.php?f=2&t=2241&p=27243#p27239 + ; why it shouldn't alter N or V flags on a BIT # +1c26 : ca dex + set_a 1,0 + > load_flag 0 +1c27 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1c29 : 48 > pha ;use stack to load status +1c2a : a901 > lda #1 ;precharge accu +1c2c : 28 > plp + +1c2d : 8982 bit #$82 ;82 - should set Z + tst_a 1,fz +1c2f : 08 > php ;save flags +1c30 : c901 > cmp #1 ;test result + > trap_ne +1c32 : d0fe > bne * ;failed not equal (non zero) + > +1c34 : 68 > pla ;load status +1c35 : 48 > pha + > cmp_flag fz +1c36 : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c38 : d0fe > bne * ;failed not equal (non zero) + > +1c3a : 28 > plp ;restore status + +1c3b : ca dex + set_a 1,0 + > load_flag 0 +1c3c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1c3e : 48 > pha ;use stack to load status +1c3f : a901 > lda #1 ;precharge accu +1c41 : 28 > plp + +1c42 : 89c3 bit #$c3 ;c3 - should clear Z + tst_a 1,0 +1c44 : 08 > php ;save flags +1c45 : c901 > cmp #1 ;test result + > trap_ne +1c47 : d0fe > bne * ;failed not equal (non zero) + > +1c49 : 68 > pla ;load status +1c4a : 48 > pha + > cmp_flag 0 +1c4b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c4d : d0fe > bne * ;failed not equal (non zero) + > +1c4f : 28 > plp ;restore status + + + set_a 1,$ff + > load_flag $ff +1c50 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1c52 : 48 > pha ;use stack to load status +1c53 : a901 > lda #1 ;precharge accu +1c55 : 28 > plp + +1c56 : 89c3 bit #$c3 ;c3 - clear Z + tst_a 1,~fz +1c58 : 08 > php ;save flags +1c59 : c901 > cmp #1 ;test result + > trap_ne +1c5b : d0fe > bne * ;failed not equal (non zero) + > +1c5d : 68 > pla ;load status +1c5e : 48 > pha + > cmp_flag ~fz +1c5f : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c61 : d0fe > bne * ;failed not equal (non zero) + > +1c63 : 28 > plp ;restore status + +1c64 : e8 inx + set_a 1,$ff + > load_flag $ff +1c65 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1c67 : 48 > pha ;use stack to load status +1c68 : a901 > lda #1 ;precharge accu +1c6a : 28 > plp + +1c6b : 8982 bit #$82 ;82 - should set Z + tst_a 1,$ff +1c6d : 08 > php ;save flags +1c6e : c901 > cmp #1 ;test result + > trap_ne +1c70 : d0fe > bne * ;failed not equal (non zero) + > +1c72 : 68 > pla ;load status +1c73 : 48 > pha + > cmp_flag $ff +1c74 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c76 : d0fe > bne * ;failed not equal (non zero) + > +1c78 : 28 > plp ;restore status + +1c79 : e8 inx + set_a 1,$ff + > load_flag $ff +1c7a : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1c7c : 48 > pha ;use stack to load status +1c7d : a901 > lda #1 ;precharge accu +1c7f : 28 > plp + +1c80 : 8941 bit #$41 ;41 - should clear Z + tst_a 1,~fz +1c82 : 08 > php ;save flags +1c83 : c901 > cmp #1 ;test result + > trap_ne +1c85 : d0fe > bne * ;failed not equal (non zero) + > +1c87 : 68 > pla ;load status +1c88 : 48 > pha + > cmp_flag ~fz +1c89 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1c8b : d0fe > bne * ;failed not equal (non zero) + > +1c8d : 28 > plp ;restore status + +1c8e : e8 inx + set_a $ff,$ff + > load_flag $ff +1c8f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1c91 : 48 > pha ;use stack to load status +1c92 : a9ff > lda #$ff ;precharge accu +1c94 : 28 > plp + +1c95 : 8900 bit #$00 ;00 - should set Z + tst_a $ff,$ff +1c97 : 08 > php ;save flags +1c98 : c9ff > cmp #$ff ;test result + > trap_ne +1c9a : d0fe > bne * ;failed not equal (non zero) + > +1c9c : 68 > pla ;load status +1c9d : 48 > pha + > cmp_flag $ff +1c9e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ca0 : d0fe > bne * ;failed not equal (non zero) + > +1ca2 : 28 > plp ;restore status + + +1ca3 : e003 cpx #3 + trap_ne ;x altered during test +1ca5 : d0fe > bne * ;failed not equal (non zero) + +1ca7 : c042 cpy #$42 + trap_ne ;y altered during test +1ca9 : d0fe > bne * ;failed not equal (non zero) + +1cab : ba tsx +1cac : e0ff cpx #$ff + trap_ne ;sp push/pop mismatch +1cae : d0fe > bne * ;failed not equal (non zero) + + next_test +1cb0 : ad0202 > lda test_case ;previous test +1cb3 : c90f > cmp #test_num + > trap_ne ;test is out of sequence +1cb5 : d0fe > bne * ;failed not equal (non zero) + > +0010 = >test_num = test_num + 1 +1cb7 : a910 > lda #test_num ;*** next tests' number +1cb9 : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; testing TRB, TSB - zp / abs + + trbt macro ;\1 = memory, \2 = flags + sty \1 + load_flag \2 + pha + lda zpt+1 + plp + trb \1 + php + cmp zpt+1 + trap_ne ;accu was changed + pla + pha + ora #fz ;mask Z + cmp_flag \2|fz + trap_ne ;flags changed except Z + pla + and #fz + cmp zpt+2 + trap_ne ;Z flag invalid + lda zpt+3 + cmp zpt + trap_ne ;altered bits in memory wrong + endm + + tsbt macro ;\1 = memory, \2 = flags + sty \1 + load_flag \2 + pha + lda zpt+1 + plp + tsb \1 + php + cmp zpt+1 + trap_ne ;accu was changed + pla + pha + ora #fz ;mask Z + cmp_flag \2|fz + trap_ne ;flags changed except Z + pla + and #fz + cmp zpt+2 + trap_ne ;Z flag invalid + lda zpt+4 + cmp zpt + trap_ne ;altered bits in memory wrong + endm + +1cbc : a2c0 ldx #$c0 +1cbe : a000 ldy #0 ;op1 - memory save + ; zpt ;op1 - memory modifiable +1cc0 : 640b stz zpt+1 ;op2 - accu + ; zpt+2 ;and flags + ; zpt+3 ;memory after reset + ; zpt+4 ;memory after set + +1cc2 : 98 tbt1 tya +1cc3 : 250b and zpt+1 ;set Z by anding the 2 operands +1cc5 : 08 php +1cc6 : 68 pla +1cc7 : 2902 and #fz ;mask Z +1cc9 : 850c sta zpt+2 +1ccb : 98 tya ;reset op1 bits by op2 +1ccc : 49ff eor #$ff +1cce : 050b ora zpt+1 +1cd0 : 49ff eor #$ff +1cd2 : 850d sta zpt+3 +1cd4 : 98 tya ;set op1 bits by op2 +1cd5 : 050b ora zpt+1 +1cd7 : 850e sta zpt+4 + + trbt zpt,$ff +1cd9 : 840a > sty zpt + > load_flag $ff +1cdb : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1cdd : 48 > pha +1cde : a50b > lda zpt+1 +1ce0 : 28 > plp +1ce1 : 140a > trb zpt +1ce3 : 08 > php +1ce4 : c50b > cmp zpt+1 + > trap_ne ;accu was changed +1ce6 : d0fe > bne * ;failed not equal (non zero) + > +1ce8 : 68 > pla +1ce9 : 48 > pha +1cea : 0902 > ora #fz ;mask Z + > cmp_flag $ff|fz +1cec : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne ;flags changed except Z +1cee : d0fe > bne * ;failed not equal (non zero) + > +1cf0 : 68 > pla +1cf1 : 2902 > and #fz +1cf3 : c50c > cmp zpt+2 + > trap_ne ;Z flag invalid +1cf5 : d0fe > bne * ;failed not equal (non zero) + > +1cf7 : a50d > lda zpt+3 +1cf9 : c50a > cmp zpt + > trap_ne ;altered bits in memory wrong +1cfb : d0fe > bne * ;failed not equal (non zero) + > + + trbt abst,$ff +1cfd : 8c0502 > sty abst + > load_flag $ff +1d00 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1d02 : 48 > pha +1d03 : a50b > lda zpt+1 +1d05 : 28 > plp +1d06 : 1c0502 > trb abst +1d09 : 08 > php +1d0a : c50b > cmp zpt+1 + > trap_ne ;accu was changed +1d0c : d0fe > bne * ;failed not equal (non zero) + > +1d0e : 68 > pla +1d0f : 48 > pha +1d10 : 0902 > ora #fz ;mask Z + > cmp_flag $ff|fz +1d12 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne ;flags changed except Z +1d14 : d0fe > bne * ;failed not equal (non zero) + > +1d16 : 68 > pla +1d17 : 2902 > and #fz +1d19 : c50c > cmp zpt+2 + > trap_ne ;Z flag invalid +1d1b : d0fe > bne * ;failed not equal (non zero) + > +1d1d : a50d > lda zpt+3 +1d1f : c50a > cmp zpt + > trap_ne ;altered bits in memory wrong +1d21 : d0fe > bne * ;failed not equal (non zero) + > + + trbt zpt,0 +1d23 : 840a > sty zpt + > load_flag 0 +1d25 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1d27 : 48 > pha +1d28 : a50b > lda zpt+1 +1d2a : 28 > plp +1d2b : 140a > trb zpt +1d2d : 08 > php +1d2e : c50b > cmp zpt+1 + > trap_ne ;accu was changed +1d30 : d0fe > bne * ;failed not equal (non zero) + > +1d32 : 68 > pla +1d33 : 48 > pha +1d34 : 0902 > ora #fz ;mask Z + > cmp_flag 0|fz +1d36 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne ;flags changed except Z +1d38 : d0fe > bne * ;failed not equal (non zero) + > +1d3a : 68 > pla +1d3b : 2902 > and #fz +1d3d : c50c > cmp zpt+2 + > trap_ne ;Z flag invalid +1d3f : d0fe > bne * ;failed not equal (non zero) + > +1d41 : a50d > lda zpt+3 +1d43 : c50a > cmp zpt + > trap_ne ;altered bits in memory wrong +1d45 : d0fe > bne * ;failed not equal (non zero) + > + + trbt abst,0 +1d47 : 8c0502 > sty abst + > load_flag 0 +1d4a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1d4c : 48 > pha +1d4d : a50b > lda zpt+1 +1d4f : 28 > plp +1d50 : 1c0502 > trb abst +1d53 : 08 > php +1d54 : c50b > cmp zpt+1 + > trap_ne ;accu was changed +1d56 : d0fe > bne * ;failed not equal (non zero) + > +1d58 : 68 > pla +1d59 : 48 > pha +1d5a : 0902 > ora #fz ;mask Z + > cmp_flag 0|fz +1d5c : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne ;flags changed except Z +1d5e : d0fe > bne * ;failed not equal (non zero) + > +1d60 : 68 > pla +1d61 : 2902 > and #fz +1d63 : c50c > cmp zpt+2 + > trap_ne ;Z flag invalid +1d65 : d0fe > bne * ;failed not equal (non zero) + > +1d67 : a50d > lda zpt+3 +1d69 : c50a > cmp zpt + > trap_ne ;altered bits in memory wrong +1d6b : d0fe > bne * ;failed not equal (non zero) + > + + tsbt zpt,$ff +1d6d : 840a > sty zpt + > load_flag $ff +1d6f : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1d71 : 48 > pha +1d72 : a50b > lda zpt+1 +1d74 : 28 > plp +1d75 : 040a > tsb zpt +1d77 : 08 > php +1d78 : c50b > cmp zpt+1 + > trap_ne ;accu was changed +1d7a : d0fe > bne * ;failed not equal (non zero) + > +1d7c : 68 > pla +1d7d : 48 > pha +1d7e : 0902 > ora #fz ;mask Z + > cmp_flag $ff|fz +1d80 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne ;flags changed except Z +1d82 : d0fe > bne * ;failed not equal (non zero) + > +1d84 : 68 > pla +1d85 : 2902 > and #fz +1d87 : c50c > cmp zpt+2 + > trap_ne ;Z flag invalid +1d89 : d0fe > bne * ;failed not equal (non zero) + > +1d8b : a50e > lda zpt+4 +1d8d : c50a > cmp zpt + > trap_ne ;altered bits in memory wrong +1d8f : d0fe > bne * ;failed not equal (non zero) + > + + tsbt abst,$ff +1d91 : 8c0502 > sty abst + > load_flag $ff +1d94 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1d96 : 48 > pha +1d97 : a50b > lda zpt+1 +1d99 : 28 > plp +1d9a : 0c0502 > tsb abst +1d9d : 08 > php +1d9e : c50b > cmp zpt+1 + > trap_ne ;accu was changed +1da0 : d0fe > bne * ;failed not equal (non zero) + > +1da2 : 68 > pla +1da3 : 48 > pha +1da4 : 0902 > ora #fz ;mask Z + > cmp_flag $ff|fz +1da6 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne ;flags changed except Z +1da8 : d0fe > bne * ;failed not equal (non zero) + > +1daa : 68 > pla +1dab : 2902 > and #fz +1dad : c50c > cmp zpt+2 + > trap_ne ;Z flag invalid +1daf : d0fe > bne * ;failed not equal (non zero) + > +1db1 : a50e > lda zpt+4 +1db3 : c50a > cmp zpt + > trap_ne ;altered bits in memory wrong +1db5 : d0fe > bne * ;failed not equal (non zero) + > + + tsbt zpt,0 +1db7 : 840a > sty zpt + > load_flag 0 +1db9 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1dbb : 48 > pha +1dbc : a50b > lda zpt+1 +1dbe : 28 > plp +1dbf : 040a > tsb zpt +1dc1 : 08 > php +1dc2 : c50b > cmp zpt+1 + > trap_ne ;accu was changed +1dc4 : d0fe > bne * ;failed not equal (non zero) + > +1dc6 : 68 > pla +1dc7 : 48 > pha +1dc8 : 0902 > ora #fz ;mask Z + > cmp_flag 0|fz +1dca : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne ;flags changed except Z +1dcc : d0fe > bne * ;failed not equal (non zero) + > +1dce : 68 > pla +1dcf : 2902 > and #fz +1dd1 : c50c > cmp zpt+2 + > trap_ne ;Z flag invalid +1dd3 : d0fe > bne * ;failed not equal (non zero) + > +1dd5 : a50e > lda zpt+4 +1dd7 : c50a > cmp zpt + > trap_ne ;altered bits in memory wrong +1dd9 : d0fe > bne * ;failed not equal (non zero) + > + + tsbt abst,0 +1ddb : 8c0502 > sty abst + > load_flag 0 +1dde : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1de0 : 48 > pha +1de1 : a50b > lda zpt+1 +1de3 : 28 > plp +1de4 : 0c0502 > tsb abst +1de7 : 08 > php +1de8 : c50b > cmp zpt+1 + > trap_ne ;accu was changed +1dea : d0fe > bne * ;failed not equal (non zero) + > +1dec : 68 > pla +1ded : 48 > pha +1dee : 0902 > ora #fz ;mask Z + > cmp_flag 0|fz +1df0 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits + > + > trap_ne ;flags changed except Z +1df2 : d0fe > bne * ;failed not equal (non zero) + > +1df4 : 68 > pla +1df5 : 2902 > and #fz +1df7 : c50c > cmp zpt+2 + > trap_ne ;Z flag invalid +1df9 : d0fe > bne * ;failed not equal (non zero) + > +1dfb : a50e > lda zpt+4 +1dfd : c50a > cmp zpt + > trap_ne ;altered bits in memory wrong +1dff : d0fe > bne * ;failed not equal (non zero) + > + + +1e01 : c8 iny ;iterate op1 +1e02 : d004 bne tbt3 +1e04 : e60b inc zpt+1 ;iterate op2 +1e06 : f003 beq tbt2 +1e08 : 4cc21c tbt3 jmp tbt1 +1e0b : tbt2 +1e0b : e0c0 cpx #$c0 + trap_ne ;x altered during test +1e0d : d0fe > bne * ;failed not equal (non zero) + +1e0f : ba tsx +1e10 : e0ff cpx #$ff + trap_ne ;sp push/pop mismatch +1e12 : d0fe > bne * ;failed not equal (non zero) + + next_test +1e14 : ad0202 > lda test_case ;previous test +1e17 : c910 > cmp #test_num + > trap_ne ;test is out of sequence +1e19 : d0fe > bne * ;failed not equal (non zero) + > +0011 = >test_num = test_num + 1 +1e1b : a911 > lda #test_num ;*** next tests' number +1e1d : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + if rkwl_wdc_op + ; testing RMB, SMB - zp + rmbt macro ;\1 = bitnum + lda #$ff + sta zpt + set_a $a5,0 + rmb \1,zpt + tst_a $a5,0 + lda zpt + cmp #$ff-(1<<\1) + trap_ne ;wrong bits set or cleared + lda #1<<\1 + sta zpt + set_a $5a,$ff + rmb \1,zpt + tst_a $5a,$ff + lda zpt + trap_ne ;wrong bits set or cleared + endm + smbt macro ;\1 = bitnum + lda #$ff-(1<<\1) + sta zpt + set_a $a5,0 + smb \1,zpt + tst_a $a5,0 + lda zpt + cmp #$ff + trap_ne ;wrong bits set or cleared + lda #0 + sta zpt + set_a $5a,$ff + smb \1,zpt + tst_a $5a,$ff + lda zpt + cmp #1<<\1 + trap_ne ;wrong bits set or cleared + endm + +1e20 : a2ba ldx #$ba ;protect x & y +1e22 : a0d0 ldy #$d0 + rmbt 0 +1e24 : a9ff > lda #$ff +1e26 : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +1e28 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1e2a : 48 > pha ;use stack to load status +1e2b : a9a5 > lda #$a5 ;precharge accu +1e2d : 28 > plp + > +1e2e : 070a > rmb 0,zpt + > tst_a $a5,0 +1e30 : 08 > php ;save flags +1e31 : c9a5 > cmp #$a5 ;test result + > trap_ne +1e33 : d0fe > bne * ;failed not equal (non zero) + > +1e35 : 68 > pla ;load status +1e36 : 48 > pha + > cmp_flag 0 +1e37 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e39 : d0fe > bne * ;failed not equal (non zero) + > +1e3b : 28 > plp ;restore status + > +1e3c : a50a > lda zpt +1e3e : c9fe > cmp #$ff-(1<<0) + > trap_ne ;wrong bits set or cleared +1e40 : d0fe > bne * ;failed not equal (non zero) + > +1e42 : a901 > lda #1<<0 +1e44 : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +1e46 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1e48 : 48 > pha ;use stack to load status +1e49 : a95a > lda #$5a ;precharge accu +1e4b : 28 > plp + > +1e4c : 070a > rmb 0,zpt + > tst_a $5a,$ff +1e4e : 08 > php ;save flags +1e4f : c95a > cmp #$5a ;test result + > trap_ne +1e51 : d0fe > bne * ;failed not equal (non zero) + > +1e53 : 68 > pla ;load status +1e54 : 48 > pha + > cmp_flag $ff +1e55 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e57 : d0fe > bne * ;failed not equal (non zero) + > +1e59 : 28 > plp ;restore status + > +1e5a : a50a > lda zpt + > trap_ne ;wrong bits set or cleared +1e5c : d0fe > bne * ;failed not equal (non zero) + > + + rmbt 1 +1e5e : a9ff > lda #$ff +1e60 : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +1e62 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1e64 : 48 > pha ;use stack to load status +1e65 : a9a5 > lda #$a5 ;precharge accu +1e67 : 28 > plp + > +1e68 : 170a > rmb 1,zpt + > tst_a $a5,0 +1e6a : 08 > php ;save flags +1e6b : c9a5 > cmp #$a5 ;test result + > trap_ne +1e6d : d0fe > bne * ;failed not equal (non zero) + > +1e6f : 68 > pla ;load status +1e70 : 48 > pha + > cmp_flag 0 +1e71 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e73 : d0fe > bne * ;failed not equal (non zero) + > +1e75 : 28 > plp ;restore status + > +1e76 : a50a > lda zpt +1e78 : c9fd > cmp #$ff-(1<<1) + > trap_ne ;wrong bits set or cleared +1e7a : d0fe > bne * ;failed not equal (non zero) + > +1e7c : a902 > lda #1<<1 +1e7e : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +1e80 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1e82 : 48 > pha ;use stack to load status +1e83 : a95a > lda #$5a ;precharge accu +1e85 : 28 > plp + > +1e86 : 170a > rmb 1,zpt + > tst_a $5a,$ff +1e88 : 08 > php ;save flags +1e89 : c95a > cmp #$5a ;test result + > trap_ne +1e8b : d0fe > bne * ;failed not equal (non zero) + > +1e8d : 68 > pla ;load status +1e8e : 48 > pha + > cmp_flag $ff +1e8f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1e91 : d0fe > bne * ;failed not equal (non zero) + > +1e93 : 28 > plp ;restore status + > +1e94 : a50a > lda zpt + > trap_ne ;wrong bits set or cleared +1e96 : d0fe > bne * ;failed not equal (non zero) + > + + rmbt 2 +1e98 : a9ff > lda #$ff +1e9a : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +1e9c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1e9e : 48 > pha ;use stack to load status +1e9f : a9a5 > lda #$a5 ;precharge accu +1ea1 : 28 > plp + > +1ea2 : 270a > rmb 2,zpt + > tst_a $a5,0 +1ea4 : 08 > php ;save flags +1ea5 : c9a5 > cmp #$a5 ;test result + > trap_ne +1ea7 : d0fe > bne * ;failed not equal (non zero) + > +1ea9 : 68 > pla ;load status +1eaa : 48 > pha + > cmp_flag 0 +1eab : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ead : d0fe > bne * ;failed not equal (non zero) + > +1eaf : 28 > plp ;restore status + > +1eb0 : a50a > lda zpt +1eb2 : c9fb > cmp #$ff-(1<<2) + > trap_ne ;wrong bits set or cleared +1eb4 : d0fe > bne * ;failed not equal (non zero) + > +1eb6 : a904 > lda #1<<2 +1eb8 : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +1eba : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1ebc : 48 > pha ;use stack to load status +1ebd : a95a > lda #$5a ;precharge accu +1ebf : 28 > plp + > +1ec0 : 270a > rmb 2,zpt + > tst_a $5a,$ff +1ec2 : 08 > php ;save flags +1ec3 : c95a > cmp #$5a ;test result + > trap_ne +1ec5 : d0fe > bne * ;failed not equal (non zero) + > +1ec7 : 68 > pla ;load status +1ec8 : 48 > pha + > cmp_flag $ff +1ec9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ecb : d0fe > bne * ;failed not equal (non zero) + > +1ecd : 28 > plp ;restore status + > +1ece : a50a > lda zpt + > trap_ne ;wrong bits set or cleared +1ed0 : d0fe > bne * ;failed not equal (non zero) + > + + rmbt 3 +1ed2 : a9ff > lda #$ff +1ed4 : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +1ed6 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1ed8 : 48 > pha ;use stack to load status +1ed9 : a9a5 > lda #$a5 ;precharge accu +1edb : 28 > plp + > +1edc : 370a > rmb 3,zpt + > tst_a $a5,0 +1ede : 08 > php ;save flags +1edf : c9a5 > cmp #$a5 ;test result + > trap_ne +1ee1 : d0fe > bne * ;failed not equal (non zero) + > +1ee3 : 68 > pla ;load status +1ee4 : 48 > pha + > cmp_flag 0 +1ee5 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1ee7 : d0fe > bne * ;failed not equal (non zero) + > +1ee9 : 28 > plp ;restore status + > +1eea : a50a > lda zpt +1eec : c9f7 > cmp #$ff-(1<<3) + > trap_ne ;wrong bits set or cleared +1eee : d0fe > bne * ;failed not equal (non zero) + > +1ef0 : a908 > lda #1<<3 +1ef2 : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +1ef4 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1ef6 : 48 > pha ;use stack to load status +1ef7 : a95a > lda #$5a ;precharge accu +1ef9 : 28 > plp + > +1efa : 370a > rmb 3,zpt + > tst_a $5a,$ff +1efc : 08 > php ;save flags +1efd : c95a > cmp #$5a ;test result + > trap_ne +1eff : d0fe > bne * ;failed not equal (non zero) + > +1f01 : 68 > pla ;load status +1f02 : 48 > pha + > cmp_flag $ff +1f03 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f05 : d0fe > bne * ;failed not equal (non zero) + > +1f07 : 28 > plp ;restore status + > +1f08 : a50a > lda zpt + > trap_ne ;wrong bits set or cleared +1f0a : d0fe > bne * ;failed not equal (non zero) + > + + rmbt 4 +1f0c : a9ff > lda #$ff +1f0e : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +1f10 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1f12 : 48 > pha ;use stack to load status +1f13 : a9a5 > lda #$a5 ;precharge accu +1f15 : 28 > plp + > +1f16 : 470a > rmb 4,zpt + > tst_a $a5,0 +1f18 : 08 > php ;save flags +1f19 : c9a5 > cmp #$a5 ;test result + > trap_ne +1f1b : d0fe > bne * ;failed not equal (non zero) + > +1f1d : 68 > pla ;load status +1f1e : 48 > pha + > cmp_flag 0 +1f1f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f21 : d0fe > bne * ;failed not equal (non zero) + > +1f23 : 28 > plp ;restore status + > +1f24 : a50a > lda zpt +1f26 : c9ef > cmp #$ff-(1<<4) + > trap_ne ;wrong bits set or cleared +1f28 : d0fe > bne * ;failed not equal (non zero) + > +1f2a : a910 > lda #1<<4 +1f2c : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +1f2e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1f30 : 48 > pha ;use stack to load status +1f31 : a95a > lda #$5a ;precharge accu +1f33 : 28 > plp + > +1f34 : 470a > rmb 4,zpt + > tst_a $5a,$ff +1f36 : 08 > php ;save flags +1f37 : c95a > cmp #$5a ;test result + > trap_ne +1f39 : d0fe > bne * ;failed not equal (non zero) + > +1f3b : 68 > pla ;load status +1f3c : 48 > pha + > cmp_flag $ff +1f3d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f3f : d0fe > bne * ;failed not equal (non zero) + > +1f41 : 28 > plp ;restore status + > +1f42 : a50a > lda zpt + > trap_ne ;wrong bits set or cleared +1f44 : d0fe > bne * ;failed not equal (non zero) + > + + rmbt 5 +1f46 : a9ff > lda #$ff +1f48 : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +1f4a : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1f4c : 48 > pha ;use stack to load status +1f4d : a9a5 > lda #$a5 ;precharge accu +1f4f : 28 > plp + > +1f50 : 570a > rmb 5,zpt + > tst_a $a5,0 +1f52 : 08 > php ;save flags +1f53 : c9a5 > cmp #$a5 ;test result + > trap_ne +1f55 : d0fe > bne * ;failed not equal (non zero) + > +1f57 : 68 > pla ;load status +1f58 : 48 > pha + > cmp_flag 0 +1f59 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f5b : d0fe > bne * ;failed not equal (non zero) + > +1f5d : 28 > plp ;restore status + > +1f5e : a50a > lda zpt +1f60 : c9df > cmp #$ff-(1<<5) + > trap_ne ;wrong bits set or cleared +1f62 : d0fe > bne * ;failed not equal (non zero) + > +1f64 : a920 > lda #1<<5 +1f66 : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +1f68 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1f6a : 48 > pha ;use stack to load status +1f6b : a95a > lda #$5a ;precharge accu +1f6d : 28 > plp + > +1f6e : 570a > rmb 5,zpt + > tst_a $5a,$ff +1f70 : 08 > php ;save flags +1f71 : c95a > cmp #$5a ;test result + > trap_ne +1f73 : d0fe > bne * ;failed not equal (non zero) + > +1f75 : 68 > pla ;load status +1f76 : 48 > pha + > cmp_flag $ff +1f77 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f79 : d0fe > bne * ;failed not equal (non zero) + > +1f7b : 28 > plp ;restore status + > +1f7c : a50a > lda zpt + > trap_ne ;wrong bits set or cleared +1f7e : d0fe > bne * ;failed not equal (non zero) + > + + rmbt 6 +1f80 : a9ff > lda #$ff +1f82 : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +1f84 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1f86 : 48 > pha ;use stack to load status +1f87 : a9a5 > lda #$a5 ;precharge accu +1f89 : 28 > plp + > +1f8a : 670a > rmb 6,zpt + > tst_a $a5,0 +1f8c : 08 > php ;save flags +1f8d : c9a5 > cmp #$a5 ;test result + > trap_ne +1f8f : d0fe > bne * ;failed not equal (non zero) + > +1f91 : 68 > pla ;load status +1f92 : 48 > pha + > cmp_flag 0 +1f93 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1f95 : d0fe > bne * ;failed not equal (non zero) + > +1f97 : 28 > plp ;restore status + > +1f98 : a50a > lda zpt +1f9a : c9bf > cmp #$ff-(1<<6) + > trap_ne ;wrong bits set or cleared +1f9c : d0fe > bne * ;failed not equal (non zero) + > +1f9e : a940 > lda #1<<6 +1fa0 : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +1fa2 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1fa4 : 48 > pha ;use stack to load status +1fa5 : a95a > lda #$5a ;precharge accu +1fa7 : 28 > plp + > +1fa8 : 670a > rmb 6,zpt + > tst_a $5a,$ff +1faa : 08 > php ;save flags +1fab : c95a > cmp #$5a ;test result + > trap_ne +1fad : d0fe > bne * ;failed not equal (non zero) + > +1faf : 68 > pla ;load status +1fb0 : 48 > pha + > cmp_flag $ff +1fb1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1fb3 : d0fe > bne * ;failed not equal (non zero) + > +1fb5 : 28 > plp ;restore status + > +1fb6 : a50a > lda zpt + > trap_ne ;wrong bits set or cleared +1fb8 : d0fe > bne * ;failed not equal (non zero) + > + + rmbt 7 +1fba : a9ff > lda #$ff +1fbc : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +1fbe : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1fc0 : 48 > pha ;use stack to load status +1fc1 : a9a5 > lda #$a5 ;precharge accu +1fc3 : 28 > plp + > +1fc4 : 770a > rmb 7,zpt + > tst_a $a5,0 +1fc6 : 08 > php ;save flags +1fc7 : c9a5 > cmp #$a5 ;test result + > trap_ne +1fc9 : d0fe > bne * ;failed not equal (non zero) + > +1fcb : 68 > pla ;load status +1fcc : 48 > pha + > cmp_flag 0 +1fcd : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1fcf : d0fe > bne * ;failed not equal (non zero) + > +1fd1 : 28 > plp ;restore status + > +1fd2 : a50a > lda zpt +1fd4 : c97f > cmp #$ff-(1<<7) + > trap_ne ;wrong bits set or cleared +1fd6 : d0fe > bne * ;failed not equal (non zero) + > +1fd8 : a980 > lda #1<<7 +1fda : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +1fdc : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +1fde : 48 > pha ;use stack to load status +1fdf : a95a > lda #$5a ;precharge accu +1fe1 : 28 > plp + > +1fe2 : 770a > rmb 7,zpt + > tst_a $5a,$ff +1fe4 : 08 > php ;save flags +1fe5 : c95a > cmp #$5a ;test result + > trap_ne +1fe7 : d0fe > bne * ;failed not equal (non zero) + > +1fe9 : 68 > pla ;load status +1fea : 48 > pha + > cmp_flag $ff +1feb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +1fed : d0fe > bne * ;failed not equal (non zero) + > +1fef : 28 > plp ;restore status + > +1ff0 : a50a > lda zpt + > trap_ne ;wrong bits set or cleared +1ff2 : d0fe > bne * ;failed not equal (non zero) + > + + smbt 0 +1ff4 : a9fe > lda #$ff-(1<<0) +1ff6 : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +1ff8 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +1ffa : 48 > pha ;use stack to load status +1ffb : a9a5 > lda #$a5 ;precharge accu +1ffd : 28 > plp + > +1ffe : 870a > smb 0,zpt + > tst_a $a5,0 +2000 : 08 > php ;save flags +2001 : c9a5 > cmp #$a5 ;test result + > trap_ne +2003 : d0fe > bne * ;failed not equal (non zero) + > +2005 : 68 > pla ;load status +2006 : 48 > pha + > cmp_flag 0 +2007 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2009 : d0fe > bne * ;failed not equal (non zero) + > +200b : 28 > plp ;restore status + > +200c : a50a > lda zpt +200e : c9ff > cmp #$ff + > trap_ne ;wrong bits set or cleared +2010 : d0fe > bne * ;failed not equal (non zero) + > +2012 : a900 > lda #0 +2014 : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +2016 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2018 : 48 > pha ;use stack to load status +2019 : a95a > lda #$5a ;precharge accu +201b : 28 > plp + > +201c : 870a > smb 0,zpt + > tst_a $5a,$ff +201e : 08 > php ;save flags +201f : c95a > cmp #$5a ;test result + > trap_ne +2021 : d0fe > bne * ;failed not equal (non zero) + > +2023 : 68 > pla ;load status +2024 : 48 > pha + > cmp_flag $ff +2025 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2027 : d0fe > bne * ;failed not equal (non zero) + > +2029 : 28 > plp ;restore status + > +202a : a50a > lda zpt +202c : c901 > cmp #1<<0 + > trap_ne ;wrong bits set or cleared +202e : d0fe > bne * ;failed not equal (non zero) + > + + smbt 1 +2030 : a9fd > lda #$ff-(1<<1) +2032 : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +2034 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2036 : 48 > pha ;use stack to load status +2037 : a9a5 > lda #$a5 ;precharge accu +2039 : 28 > plp + > +203a : 970a > smb 1,zpt + > tst_a $a5,0 +203c : 08 > php ;save flags +203d : c9a5 > cmp #$a5 ;test result + > trap_ne +203f : d0fe > bne * ;failed not equal (non zero) + > +2041 : 68 > pla ;load status +2042 : 48 > pha + > cmp_flag 0 +2043 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2045 : d0fe > bne * ;failed not equal (non zero) + > +2047 : 28 > plp ;restore status + > +2048 : a50a > lda zpt +204a : c9ff > cmp #$ff + > trap_ne ;wrong bits set or cleared +204c : d0fe > bne * ;failed not equal (non zero) + > +204e : a900 > lda #0 +2050 : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +2052 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2054 : 48 > pha ;use stack to load status +2055 : a95a > lda #$5a ;precharge accu +2057 : 28 > plp + > +2058 : 970a > smb 1,zpt + > tst_a $5a,$ff +205a : 08 > php ;save flags +205b : c95a > cmp #$5a ;test result + > trap_ne +205d : d0fe > bne * ;failed not equal (non zero) + > +205f : 68 > pla ;load status +2060 : 48 > pha + > cmp_flag $ff +2061 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2063 : d0fe > bne * ;failed not equal (non zero) + > +2065 : 28 > plp ;restore status + > +2066 : a50a > lda zpt +2068 : c902 > cmp #1<<1 + > trap_ne ;wrong bits set or cleared +206a : d0fe > bne * ;failed not equal (non zero) + > + + smbt 2 +206c : a9fb > lda #$ff-(1<<2) +206e : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +2070 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2072 : 48 > pha ;use stack to load status +2073 : a9a5 > lda #$a5 ;precharge accu +2075 : 28 > plp + > +2076 : a70a > smb 2,zpt + > tst_a $a5,0 +2078 : 08 > php ;save flags +2079 : c9a5 > cmp #$a5 ;test result + > trap_ne +207b : d0fe > bne * ;failed not equal (non zero) + > +207d : 68 > pla ;load status +207e : 48 > pha + > cmp_flag 0 +207f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2081 : d0fe > bne * ;failed not equal (non zero) + > +2083 : 28 > plp ;restore status + > +2084 : a50a > lda zpt +2086 : c9ff > cmp #$ff + > trap_ne ;wrong bits set or cleared +2088 : d0fe > bne * ;failed not equal (non zero) + > +208a : a900 > lda #0 +208c : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +208e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2090 : 48 > pha ;use stack to load status +2091 : a95a > lda #$5a ;precharge accu +2093 : 28 > plp + > +2094 : a70a > smb 2,zpt + > tst_a $5a,$ff +2096 : 08 > php ;save flags +2097 : c95a > cmp #$5a ;test result + > trap_ne +2099 : d0fe > bne * ;failed not equal (non zero) + > +209b : 68 > pla ;load status +209c : 48 > pha + > cmp_flag $ff +209d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +209f : d0fe > bne * ;failed not equal (non zero) + > +20a1 : 28 > plp ;restore status + > +20a2 : a50a > lda zpt +20a4 : c904 > cmp #1<<2 + > trap_ne ;wrong bits set or cleared +20a6 : d0fe > bne * ;failed not equal (non zero) + > + + smbt 3 +20a8 : a9f7 > lda #$ff-(1<<3) +20aa : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +20ac : a900 > lda #0 ;allow test to change I-flag (no mask) + > +20ae : 48 > pha ;use stack to load status +20af : a9a5 > lda #$a5 ;precharge accu +20b1 : 28 > plp + > +20b2 : b70a > smb 3,zpt + > tst_a $a5,0 +20b4 : 08 > php ;save flags +20b5 : c9a5 > cmp #$a5 ;test result + > trap_ne +20b7 : d0fe > bne * ;failed not equal (non zero) + > +20b9 : 68 > pla ;load status +20ba : 48 > pha + > cmp_flag 0 +20bb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +20bd : d0fe > bne * ;failed not equal (non zero) + > +20bf : 28 > plp ;restore status + > +20c0 : a50a > lda zpt +20c2 : c9ff > cmp #$ff + > trap_ne ;wrong bits set or cleared +20c4 : d0fe > bne * ;failed not equal (non zero) + > +20c6 : a900 > lda #0 +20c8 : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +20ca : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +20cc : 48 > pha ;use stack to load status +20cd : a95a > lda #$5a ;precharge accu +20cf : 28 > plp + > +20d0 : b70a > smb 3,zpt + > tst_a $5a,$ff +20d2 : 08 > php ;save flags +20d3 : c95a > cmp #$5a ;test result + > trap_ne +20d5 : d0fe > bne * ;failed not equal (non zero) + > +20d7 : 68 > pla ;load status +20d8 : 48 > pha + > cmp_flag $ff +20d9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +20db : d0fe > bne * ;failed not equal (non zero) + > +20dd : 28 > plp ;restore status + > +20de : a50a > lda zpt +20e0 : c908 > cmp #1<<3 + > trap_ne ;wrong bits set or cleared +20e2 : d0fe > bne * ;failed not equal (non zero) + > + + smbt 4 +20e4 : a9ef > lda #$ff-(1<<4) +20e6 : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +20e8 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +20ea : 48 > pha ;use stack to load status +20eb : a9a5 > lda #$a5 ;precharge accu +20ed : 28 > plp + > +20ee : c70a > smb 4,zpt + > tst_a $a5,0 +20f0 : 08 > php ;save flags +20f1 : c9a5 > cmp #$a5 ;test result + > trap_ne +20f3 : d0fe > bne * ;failed not equal (non zero) + > +20f5 : 68 > pla ;load status +20f6 : 48 > pha + > cmp_flag 0 +20f7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +20f9 : d0fe > bne * ;failed not equal (non zero) + > +20fb : 28 > plp ;restore status + > +20fc : a50a > lda zpt +20fe : c9ff > cmp #$ff + > trap_ne ;wrong bits set or cleared +2100 : d0fe > bne * ;failed not equal (non zero) + > +2102 : a900 > lda #0 +2104 : 850a > sta zpt + > set_a $5a,$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 : a95a > lda #$5a ;precharge accu +210b : 28 > plp + > +210c : c70a > smb 4,zpt + > tst_a $5a,$ff +210e : 08 > php ;save flags +210f : c95a > cmp #$5a ;test result + > trap_ne +2111 : d0fe > bne * ;failed not equal (non zero) + > +2113 : 68 > pla ;load status +2114 : 48 > pha + > cmp_flag $ff +2115 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2117 : d0fe > bne * ;failed not equal (non zero) + > +2119 : 28 > plp ;restore status + > +211a : a50a > lda zpt +211c : c910 > cmp #1<<4 + > trap_ne ;wrong bits set or cleared +211e : d0fe > bne * ;failed not equal (non zero) + > + + smbt 5 +2120 : a9df > lda #$ff-(1<<5) +2122 : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +2124 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2126 : 48 > pha ;use stack to load status +2127 : a9a5 > lda #$a5 ;precharge accu +2129 : 28 > plp + > +212a : d70a > smb 5,zpt + > tst_a $a5,0 +212c : 08 > php ;save flags +212d : c9a5 > cmp #$a5 ;test result + > trap_ne +212f : d0fe > bne * ;failed not equal (non zero) + > +2131 : 68 > pla ;load status +2132 : 48 > pha + > cmp_flag 0 +2133 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2135 : d0fe > bne * ;failed not equal (non zero) + > +2137 : 28 > plp ;restore status + > +2138 : a50a > lda zpt +213a : c9ff > cmp #$ff + > trap_ne ;wrong bits set or cleared +213c : d0fe > bne * ;failed not equal (non zero) + > +213e : a900 > lda #0 +2140 : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +2142 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2144 : 48 > pha ;use stack to load status +2145 : a95a > lda #$5a ;precharge accu +2147 : 28 > plp + > +2148 : d70a > smb 5,zpt + > tst_a $5a,$ff +214a : 08 > php ;save flags +214b : c95a > cmp #$5a ;test result + > trap_ne +214d : d0fe > bne * ;failed not equal (non zero) + > +214f : 68 > pla ;load status +2150 : 48 > pha + > cmp_flag $ff +2151 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2153 : d0fe > bne * ;failed not equal (non zero) + > +2155 : 28 > plp ;restore status + > +2156 : a50a > lda zpt +2158 : c920 > cmp #1<<5 + > trap_ne ;wrong bits set or cleared +215a : d0fe > bne * ;failed not equal (non zero) + > + + smbt 6 +215c : a9bf > lda #$ff-(1<<6) +215e : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +2160 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2162 : 48 > pha ;use stack to load status +2163 : a9a5 > lda #$a5 ;precharge accu +2165 : 28 > plp + > +2166 : e70a > smb 6,zpt + > tst_a $a5,0 +2168 : 08 > php ;save flags +2169 : c9a5 > cmp #$a5 ;test result + > trap_ne +216b : d0fe > bne * ;failed not equal (non zero) + > +216d : 68 > pla ;load status +216e : 48 > pha + > cmp_flag 0 +216f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2171 : d0fe > bne * ;failed not equal (non zero) + > +2173 : 28 > plp ;restore status + > +2174 : a50a > lda zpt +2176 : c9ff > cmp #$ff + > trap_ne ;wrong bits set or cleared +2178 : d0fe > bne * ;failed not equal (non zero) + > +217a : a900 > lda #0 +217c : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +217e : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2180 : 48 > pha ;use stack to load status +2181 : a95a > lda #$5a ;precharge accu +2183 : 28 > plp + > +2184 : e70a > smb 6,zpt + > tst_a $5a,$ff +2186 : 08 > php ;save flags +2187 : c95a > cmp #$5a ;test result + > trap_ne +2189 : d0fe > bne * ;failed not equal (non zero) + > +218b : 68 > pla ;load status +218c : 48 > pha + > cmp_flag $ff +218d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +218f : d0fe > bne * ;failed not equal (non zero) + > +2191 : 28 > plp ;restore status + > +2192 : a50a > lda zpt +2194 : c940 > cmp #1<<6 + > trap_ne ;wrong bits set or cleared +2196 : d0fe > bne * ;failed not equal (non zero) + > + + smbt 7 +2198 : a97f > lda #$ff-(1<<7) +219a : 850a > sta zpt + > set_a $a5,0 + > load_flag 0 +219c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +219e : 48 > pha ;use stack to load status +219f : a9a5 > lda #$a5 ;precharge accu +21a1 : 28 > plp + > +21a2 : f70a > smb 7,zpt + > tst_a $a5,0 +21a4 : 08 > php ;save flags +21a5 : c9a5 > cmp #$a5 ;test result + > trap_ne +21a7 : d0fe > bne * ;failed not equal (non zero) + > +21a9 : 68 > pla ;load status +21aa : 48 > pha + > cmp_flag 0 +21ab : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits + > + > trap_ne +21ad : d0fe > bne * ;failed not equal (non zero) + > +21af : 28 > plp ;restore status + > +21b0 : a50a > lda zpt +21b2 : c9ff > cmp #$ff + > trap_ne ;wrong bits set or cleared +21b4 : d0fe > bne * ;failed not equal (non zero) + > +21b6 : a900 > lda #0 +21b8 : 850a > sta zpt + > set_a $5a,$ff + > load_flag $ff +21ba : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +21bc : 48 > pha ;use stack to load status +21bd : a95a > lda #$5a ;precharge accu +21bf : 28 > plp + > +21c0 : f70a > smb 7,zpt + > tst_a $5a,$ff +21c2 : 08 > php ;save flags +21c3 : c95a > cmp #$5a ;test result + > trap_ne +21c5 : d0fe > bne * ;failed not equal (non zero) + > +21c7 : 68 > pla ;load status +21c8 : 48 > pha + > cmp_flag $ff +21c9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits + > + > trap_ne +21cb : d0fe > bne * ;failed not equal (non zero) + > +21cd : 28 > plp ;restore status + > +21ce : a50a > lda zpt +21d0 : c980 > cmp #1<<7 + > trap_ne ;wrong bits set or cleared +21d2 : d0fe > bne * ;failed not equal (non zero) + > + +21d4 : e0ba cpx #$ba + trap_ne ;x altered during test +21d6 : d0fe > bne * ;failed not equal (non zero) + +21d8 : c0d0 cpy #$d0 + trap_ne ;y altered during test +21da : d0fe > bne * ;failed not equal (non zero) + +21dc : ba tsx +21dd : e0ff cpx #$ff + trap_ne ;sp push/pop mismatch +21df : d0fe > bne * ;failed not equal (non zero) + + next_test +21e1 : ad0202 > lda test_case ;previous test +21e4 : c911 > cmp #test_num + > trap_ne ;test is out of sequence +21e6 : d0fe > bne * ;failed not equal (non zero) + > +0012 = >test_num = test_num + 1 +21e8 : a912 > lda #test_num ;*** next tests' number +21ea : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + endif + + ; testing CMP - (zp) +21ed : a2de ldx #$de ;protect x & y +21ef : a0ad ldy #$ad + set_a $80,0 + > load_flag 0 +21f1 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +21f3 : 48 > pha ;use stack to load status +21f4 : a980 > lda #$80 ;precharge accu +21f6 : 28 > plp + +21f7 : d22a cmp (ind1+8) + tst_a $80,fc +21f9 : 08 > php ;save flags +21fa : c980 > cmp #$80 ;test result + > trap_ne +21fc : d0fe > bne * ;failed not equal (non zero) + > +21fe : 68 > pla ;load status +21ff : 48 > pha + > cmp_flag fc +2200 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2202 : d0fe > bne * ;failed not equal (non zero) + > +2204 : 28 > plp ;restore status + + set_a $7f,0 + > load_flag 0 +2205 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2207 : 48 > pha ;use stack to load status +2208 : a97f > lda #$7f ;precharge accu +220a : 28 > plp + +220b : d22a cmp (ind1+8) + tst_a $7f,fzc +220d : 08 > php ;save flags +220e : c97f > cmp #$7f ;test result + > trap_ne +2210 : d0fe > bne * ;failed not equal (non zero) + > +2212 : 68 > pla ;load status +2213 : 48 > pha + > cmp_flag fzc +2214 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2216 : d0fe > bne * ;failed not equal (non zero) + > +2218 : 28 > plp ;restore status + + set_a $7e,0 + > load_flag 0 +2219 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +221b : 48 > pha ;use stack to load status +221c : a97e > lda #$7e ;precharge accu +221e : 28 > plp + +221f : d22a cmp (ind1+8) + tst_a $7e,fn +2221 : 08 > php ;save flags +2222 : c97e > cmp #$7e ;test result + > trap_ne +2224 : d0fe > bne * ;failed not equal (non zero) + > +2226 : 68 > pla ;load status +2227 : 48 > pha + > cmp_flag fn +2228 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +222a : d0fe > bne * ;failed not equal (non zero) + > +222c : 28 > plp ;restore status + + set_a $80,$ff + > load_flag $ff +222d : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +222f : 48 > pha ;use stack to load status +2230 : a980 > lda #$80 ;precharge accu +2232 : 28 > plp + +2233 : d22a cmp (ind1+8) + tst_a $80,~fnz +2235 : 08 > php ;save flags +2236 : c980 > cmp #$80 ;test result + > trap_ne +2238 : d0fe > bne * ;failed not equal (non zero) + > +223a : 68 > pla ;load status +223b : 48 > pha + > cmp_flag ~fnz +223c : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits + > + > trap_ne +223e : d0fe > bne * ;failed not equal (non zero) + > +2240 : 28 > plp ;restore status + + set_a $7f,$ff + > load_flag $ff +2241 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2243 : 48 > pha ;use stack to load status +2244 : a97f > lda #$7f ;precharge accu +2246 : 28 > plp + +2247 : d22a cmp (ind1+8) + tst_a $7f,~fn +2249 : 08 > php ;save flags +224a : c97f > cmp #$7f ;test result + > trap_ne +224c : d0fe > bne * ;failed not equal (non zero) + > +224e : 68 > pla ;load status +224f : 48 > pha + > cmp_flag ~fn +2250 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2252 : d0fe > bne * ;failed not equal (non zero) + > +2254 : 28 > plp ;restore status + + set_a $7e,$ff + > load_flag $ff +2255 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +2257 : 48 > pha ;use stack to load status +2258 : a97e > lda #$7e ;precharge accu +225a : 28 > plp + +225b : d22a cmp (ind1+8) + tst_a $7e,~fzc +225d : 08 > php ;save flags +225e : c97e > cmp #$7e ;test result + > trap_ne +2260 : d0fe > bne * ;failed not equal (non zero) + > +2262 : 68 > pla ;load status +2263 : 48 > pha + > cmp_flag ~fzc +2264 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits + > + > trap_ne +2266 : d0fe > bne * ;failed not equal (non zero) + > +2268 : 28 > plp ;restore status + +2269 : e0de cpx #$de + trap_ne ;x altered during test +226b : d0fe > bne * ;failed not equal (non zero) + +226d : c0ad cpy #$ad + trap_ne ;y altered during test +226f : d0fe > bne * ;failed not equal (non zero) + +2271 : ba tsx +2272 : e0ff cpx #$ff + trap_ne ;sp push/pop mismatch +2274 : d0fe > bne * ;failed not equal (non zero) + + next_test +2276 : ad0202 > lda test_case ;previous test +2279 : c912 > cmp #test_num + > trap_ne ;test is out of sequence +227b : d0fe > bne * ;failed not equal (non zero) + > +0013 = >test_num = test_num + 1 +227d : a913 > lda #test_num ;*** next tests' number +227f : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; testing logical instructions - AND EOR ORA (zp) +2282 : a242 ldx #$42 ;protect x & y + +2284 : a000 ldy #0 ;AND +2286 : a538 lda indAN ;set indirect address +2288 : 850a sta zpt +228a : a539 lda indAN+1 +228c : 850b sta zpt+1 +228e : tand1 + set_ay absANa,0 + > load_flag 0 +228e : a900 > lda #0 ;allow test to change I-flag (no mask) + > +2290 : 48 > pha ;use stack to load status +2291 : b94d02 > lda absANa,y ;precharge accu +2294 : 28 > plp + +2295 : 320a and (zpt) + tst_ay absrlo,absflo,0 +2297 : 08 > php ;save flags +2298 : d95502 > cmp absrlo,y ;test result + > trap_ne ; +229b : d0fe > bne * ;failed not equal (non zero) + > +229d : 68 > pla ;load status + > eor_flag 0 +229e : 4930 > eor #0|fao ;invert expected flags + always on bits + > +22a0 : d95902 > cmp absflo,y ;test flags + > trap_ne +22a3 : d0fe > bne * ;failed not equal (non zero) + > + +22a5 : e60a inc zpt +22a7 : c8 iny +22a8 : c004 cpy #4 +22aa : d0e2 bne tand1 +22ac : 88 dey +22ad : c60a dec zpt +22af : tand2 + set_ay absANa,$ff + > load_flag $ff +22af : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +22b1 : 48 > pha ;use stack to load status +22b2 : b94d02 > lda absANa,y ;precharge accu +22b5 : 28 > plp + +22b6 : 320a and (zpt) + tst_ay absrlo,absflo,$ff-fnz +22b8 : 08 > php ;save flags +22b9 : d95502 > cmp absrlo,y ;test result + > trap_ne ; +22bc : d0fe > bne * ;failed not equal (non zero) + > +22be : 68 > pla ;load status + > eor_flag $ff-fnz +22bf : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +22c1 : d95902 > cmp absflo,y ;test flags + > trap_ne +22c4 : d0fe > bne * ;failed not equal (non zero) + > + +22c6 : c60a dec zpt +22c8 : 88 dey +22c9 : 10e4 bpl tand2 + +22cb : a000 ldy #0 ;EOR +22cd : a540 lda indEO ;set indirect address +22cf : 850a sta zpt +22d1 : a541 lda indEO+1 +22d3 : 850b sta zpt+1 +22d5 : teor1 + set_ay absEOa,0 + > load_flag 0 +22d5 : a900 > lda #0 ;allow test to change I-flag (no mask) + > +22d7 : 48 > pha ;use stack to load status +22d8 : b95102 > lda absEOa,y ;precharge accu +22db : 28 > plp + +22dc : 520a eor (zpt) + tst_ay absrlo,absflo,0 +22de : 08 > php ;save flags +22df : d95502 > cmp absrlo,y ;test result + > trap_ne ; +22e2 : d0fe > bne * ;failed not equal (non zero) + > +22e4 : 68 > pla ;load status + > eor_flag 0 +22e5 : 4930 > eor #0|fao ;invert expected flags + always on bits + > +22e7 : d95902 > cmp absflo,y ;test flags + > trap_ne +22ea : d0fe > bne * ;failed not equal (non zero) + > + +22ec : e60a inc zpt +22ee : c8 iny +22ef : c004 cpy #4 +22f1 : d0e2 bne teor1 +22f3 : 88 dey +22f4 : c60a dec zpt +22f6 : teor2 + set_ay absEOa,$ff + > load_flag $ff +22f6 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +22f8 : 48 > pha ;use stack to load status +22f9 : b95102 > lda absEOa,y ;precharge accu +22fc : 28 > plp + +22fd : 520a eor (zpt) + tst_ay absrlo,absflo,$ff-fnz +22ff : 08 > php ;save flags +2300 : d95502 > cmp absrlo,y ;test result + > trap_ne ; +2303 : d0fe > bne * ;failed not equal (non zero) + > +2305 : 68 > pla ;load status + > eor_flag $ff-fnz +2306 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +2308 : d95902 > cmp absflo,y ;test flags + > trap_ne +230b : d0fe > bne * ;failed not equal (non zero) + > + +230d : c60a dec zpt +230f : 88 dey +2310 : 10e4 bpl teor2 + +2312 : a000 ldy #0 ;ORA +2314 : a548 lda indOR ;set indirect address +2316 : 850a sta zpt +2318 : a549 lda indOR+1 +231a : 850b sta zpt+1 +231c : tora1 + set_ay absORa,0 + > load_flag 0 +231c : a900 > lda #0 ;allow test to change I-flag (no mask) + > +231e : 48 > pha ;use stack to load status +231f : b94902 > lda absORa,y ;precharge accu +2322 : 28 > plp + +2323 : 120a ora (zpt) + tst_ay absrlo,absflo,0 +2325 : 08 > php ;save flags +2326 : d95502 > cmp absrlo,y ;test result + > trap_ne ; +2329 : d0fe > bne * ;failed not equal (non zero) + > +232b : 68 > pla ;load status + > eor_flag 0 +232c : 4930 > eor #0|fao ;invert expected flags + always on bits + > +232e : d95902 > cmp absflo,y ;test flags + > trap_ne +2331 : d0fe > bne * ;failed not equal (non zero) + > + +2333 : e60a inc zpt +2335 : c8 iny +2336 : c004 cpy #4 +2338 : d0e2 bne tora1 +233a : 88 dey +233b : c60a dec zpt +233d : tora2 + set_ay absORa,$ff + > load_flag $ff +233d : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +233f : 48 > pha ;use stack to load status +2340 : b94902 > lda absORa,y ;precharge accu +2343 : 28 > plp + +2344 : 120a ora (zpt) + tst_ay absrlo,absflo,$ff-fnz +2346 : 08 > php ;save flags +2347 : d95502 > cmp absrlo,y ;test result + > trap_ne ; +234a : d0fe > bne * ;failed not equal (non zero) + > +234c : 68 > pla ;load status + > eor_flag $ff-fnz +234d : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits + > +234f : d95902 > cmp absflo,y ;test flags + > trap_ne +2352 : d0fe > bne * ;failed not equal (non zero) + > + +2354 : c60a dec zpt +2356 : 88 dey +2357 : 10e4 bpl tora2 + +2359 : e042 cpx #$42 + trap_ne ;x altered during test +235b : d0fe > bne * ;failed not equal (non zero) + +235d : ba tsx +235e : e0ff cpx #$ff + trap_ne ;sp push/pop mismatch +2360 : d0fe > bne * ;failed not equal (non zero) + + next_test +2362 : ad0202 > lda test_case ;previous test +2365 : c913 > cmp #test_num + > trap_ne ;test is out of sequence +2367 : d0fe > bne * ;failed not equal (non zero) + > +0014 = >test_num = test_num + 1 +2369 : a914 > lda #test_num ;*** next tests' number +236b : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + if I_flag = 3 +236e : 58 cli + endif + + ; full binary add/subtract test - (zp) only + ; iterates through all combinations of operands and carry input + ; uses increments/decrements to predict result & result flags +236f : d8 cld +2370 : a20c ldx #ad2 ;for indexed test +2372 : a0ff ldy #$ff ;max range +2374 : a900 lda #0 ;start with adding zeroes & no carry +2376 : 850a sta adfc ;carry in - for diag +2378 : 850b sta ad1 ;operand 1 - accumulator +237a : 850c sta ad2 ;operand 2 - memory or immediate +237c : 8d0502 sta ada2 ;non zp +237f : 850d sta adrl ;expected result bits 0-7 +2381 : 850e sta adrh ;expected result bit 8 (carry out) +2383 : a9ff lda #$ff ;complemented operand 2 for subtract +2385 : 8510 sta sb2 +2387 : 8d0602 sta sba2 ;non zp +238a : a902 lda #2 ;expected Z-flag +238c : 850f sta adrf +238e : 18 tadd clc ;test with carry clear +238f : 200326 jsr chkadd +2392 : e60a inc adfc ;now with carry +2394 : e60d inc adrl ;result +1 +2396 : 08 php ;save N & Z from low result +2397 : 08 php +2398 : 68 pla ;accu holds expected flags +2399 : 2982 and #$82 ;mask N & Z +239b : 28 plp +239c : d002 bne tadd1 +239e : e60e inc adrh ;result bit 8 - carry +23a0 : 050e tadd1 ora adrh ;merge C to expected flags +23a2 : 850f sta adrf ;save expected flags except overflow +23a4 : 38 sec ;test with carry set +23a5 : 200326 jsr chkadd +23a8 : c60a dec adfc ;same for operand +1 but no carry +23aa : e60b inc ad1 +23ac : d0e0 bne tadd ;iterate op1 +23ae : a900 lda #0 ;preset result to op2 when op1 = 0 +23b0 : 850e sta adrh +23b2 : ee0502 inc ada2 +23b5 : e60c inc ad2 +23b7 : 08 php ;save NZ as operand 2 becomes the new result +23b8 : 68 pla +23b9 : 2982 and #$82 ;mask N00000Z0 +23bb : 850f sta adrf ;no need to check carry as we are adding to 0 +23bd : c610 dec sb2 ;complement subtract operand 2 +23bf : ce0602 dec sba2 +23c2 : a50c lda ad2 +23c4 : 850d sta adrl +23c6 : d0c6 bne tadd ;iterate op2 + +23c8 : e00c cpx #ad2 + trap_ne ;x altered during test +23ca : d0fe > bne * ;failed not equal (non zero) + +23cc : c0ff cpy #$ff + trap_ne ;y altered during test +23ce : d0fe > bne * ;failed not equal (non zero) + +23d0 : ba tsx +23d1 : e0ff cpx #$ff + trap_ne ;sp push/pop mismatch +23d3 : d0fe > bne * ;failed not equal (non zero) + + next_test +23d5 : ad0202 > lda test_case ;previous test +23d8 : c914 > cmp #test_num + > trap_ne ;test is out of sequence +23da : d0fe > bne * ;failed not equal (non zero) + > +0015 = >test_num = test_num + 1 +23dc : a915 > lda #test_num ;*** next tests' number +23de : 8d0202 > sta test_case + > ;check_ram ;uncomment to find altered RAM after each test + + + ; decimal add/subtract test + ; *** WARNING - tests documented behavior only! *** + ; only valid BCD operands are tested, the V flag is ignored + ; although V is declared as beeing valid on the 65C02 it has absolutely + ; no use in BCD math. No sign = no overflow! + ; iterates through all valid combinations of operands and carry input + ; uses increments/decrements to predict result & carry flag +23e1 : f8 sed +23e2 : a20c ldx #ad2 ;for indexed test +23e4 : a0ff ldy #$ff ;max range +23e6 : a999 lda #$99 ;start with adding 99 to 99 with carry +23e8 : 850b sta ad1 ;operand 1 - accumulator +23ea : 850c sta ad2 ;operand 2 - memory or immediate +23ec : 8d0502 sta ada2 ;non zp +23ef : 850d sta adrl ;expected result bits 0-7 +23f1 : a901 lda #1 ;set carry in & out +23f3 : 850a sta adfc ;carry in - for diag +23f5 : 850e sta adrh ;expected result bit 8 (carry out) +23f7 : a981 lda #$81 ;set N & C (99 + 99 + C = 99 + C) +23f9 : 850f sta adrf +23fb : a900 lda #0 ;complemented operand 2 for subtract +23fd : 8510 sta sb2 +23ff : 8d0602 sta sba2 ;non zp +2402 : 38 tdad sec ;test with carry set +2403 : 20ae24 jsr chkdad +2406 : c60a dec adfc ;now with carry clear +2408 : a50d lda adrl ;decimal adjust result +240a : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1) +240c : c60e dec adrh +240e : a999 lda #$99 +2410 : 850d sta adrl +2412 : d012 bne tdad3 +2414 : 290f tdad1 and #$f ;lower nibble mask +2416 : d00c bne tdad2 ;no decimal adjust needed +2418 : c60d dec adrl ;decimal adjust (?0-6) +241a : c60d dec adrl +241c : c60d dec adrl +241e : c60d dec adrl +2420 : c60d dec adrl +2422 : c60d dec adrl +2424 : c60d tdad2 dec adrl ;result -1 +2426 : 08 tdad3 php ;save valid flags +2427 : 68 pla +2428 : 2982 and #$82 ;N-----Z- +242a : 050e ora adrh ;N-----ZC +242c : 850f sta adrf +242e : 18 clc ;test with carry clear +242f : 20ae24 jsr chkdad +2432 : e60a inc adfc ;same for operand -1 but with carry +2434 : a50b lda ad1 ;decimal adjust operand 1 +2436 : f015 beq tdad5 ;iterate operand 2 +2438 : 290f and #$f ;lower nibble mask +243a : d00c bne tdad4 ;skip decimal adjust +243c : c60b dec ad1 ;decimal adjust (?0-6) +243e : c60b dec ad1 +2440 : c60b dec ad1 +2442 : c60b dec ad1 +2444 : c60b dec ad1 +2446 : c60b dec ad1 +2448 : c60b tdad4 dec ad1 ;operand 1 -1 +244a : 4c0224 jmp tdad ;iterate op1 + +244d : a999 tdad5 lda #$99 ;precharge op1 max +244f : 850b sta ad1 +2451 : a50c lda ad2 ;decimal adjust operand 2 +2453 : f039 beq tdad7 ;end of iteration +2455 : 290f and #$f ;lower nibble mask +2457 : d018 bne tdad6 ;skip decimal adjust +2459 : c60c dec ad2 ;decimal adjust (?0-6) +245b : c60c dec ad2 +245d : c60c dec ad2 +245f : c60c dec ad2 +2461 : c60c dec ad2 +2463 : c60c dec ad2 +2465 : e610 inc sb2 ;complemented decimal adjust for subtract (?9+6) +2467 : e610 inc sb2 +2469 : e610 inc sb2 +246b : e610 inc sb2 +246d : e610 inc sb2 +246f : e610 inc sb2 +2471 : c60c tdad6 dec ad2 ;operand 2 -1 +2473 : e610 inc sb2 ;complemented operand for subtract +2475 : a510 lda sb2 +2477 : 8d0602 sta sba2 ;copy as non zp operand +247a : a50c lda ad2 +247c : 8d0502 sta ada2 ;copy as non zp operand +247f : 850d sta adrl ;new result since op1+carry=00+carry +op2=op2 +2481 : 08 php ;save flags +2482 : 68 pla +2483 : 2982 and #$82 ;N-----Z- +2485 : 0901 ora #1 ;N-----ZC +2487 : 850f sta adrf +2489 : e60e inc adrh ;result carry +248b : 4c0224 jmp tdad ;iterate op2 + +248e : e00c tdad7 cpx #ad2 + trap_ne ;x altered during test +2490 : d0fe > bne * ;failed not equal (non zero) + +2492 : c0ff cpy #$ff + trap_ne ;y altered during test +2494 : d0fe > bne * ;failed not equal (non zero) + +2496 : ba tsx +2497 : e0ff cpx #$ff + trap_ne ;sp push/pop mismatch +2499 : d0fe > bne * ;failed not equal (non zero) + +249b : d8 cld + +249c : ad0202 lda test_case +249f : c915 cmp #test_num + trap_ne ;previous test is out of sequence +24a1 : d0fe > bne * ;failed not equal (non zero) + +24a3 : a9f0 lda #$f0 ;mark opcode testing complete +24a5 : 8d0202 sta test_case + + ; final RAM integrity test + ; verifies that none of the previous tests has altered RAM outside of the + ; designated write areas. + check_ram + > ;RAM check disabled - RAM size not set + + ; *** DEBUG INFO *** + ; to debug checksum errors uncomment check_ram in the next_test macro to + ; narrow down the responsible opcode. + ; may give false errors when monitor, OS or other background activity is + ; allowed during previous tests. + + + ; S U C C E S S ************************************************ + ; ------------- + success ;if you get here everything went well +24a8 : 4ca824 > jmp * ;test passed, no errors + + ; ------------- + ; S U C C E S S ************************************************ +24ab : 4c0004 jmp start ;run again + + ; core subroutine of the decimal add/subtract test + ; *** WARNING - tests documented behavior only! *** + ; only valid BCD operands are tested, V flag is ignored + ; iterates through all valid combinations of operands and carry input + ; uses increments/decrements to predict result & carry flag +24ae : chkdad + ; decimal ADC / SBC zp +24ae : 08 php ;save carry for subtract +24af : a50b lda ad1 +24b1 : 650c adc ad2 ;perform add +24b3 : 08 php +24b4 : c50d cmp adrl ;check result + trap_ne ;bad result +24b6 : d0fe > bne * ;failed not equal (non zero) + +24b8 : 68 pla ;check flags +24b9 : 2983 and #$83 ;mask N-----ZC +24bb : c50f cmp adrf + trap_ne ;bad flags +24bd : d0fe > bne * ;failed not equal (non zero) + +24bf : 28 plp +24c0 : 08 php ;save carry for next add +24c1 : a50b lda ad1 +24c3 : e510 sbc sb2 ;perform subtract +24c5 : 08 php +24c6 : c50d cmp adrl ;check result + trap_ne ;bad result +24c8 : d0fe > bne * ;failed not equal (non zero) + +24ca : 68 pla ;check flags +24cb : 2983 and #$83 ;mask N-----ZC +24cd : c50f cmp adrf + trap_ne ;bad flags +24cf : d0fe > bne * ;failed not equal (non zero) + +24d1 : 28 plp + ; decimal ADC / SBC abs +24d2 : 08 php ;save carry for subtract +24d3 : a50b lda ad1 +24d5 : 6d0502 adc ada2 ;perform add +24d8 : 08 php +24d9 : c50d cmp adrl ;check result + trap_ne ;bad result +24db : d0fe > bne * ;failed not equal (non zero) + +24dd : 68 pla ;check flags +24de : 2983 and #$83 ;mask N-----ZC +24e0 : c50f cmp adrf + trap_ne ;bad flags +24e2 : d0fe > bne * ;failed not equal (non zero) + +24e4 : 28 plp +24e5 : 08 php ;save carry for next add +24e6 : a50b lda ad1 +24e8 : ed0602 sbc sba2 ;perform subtract +24eb : 08 php +24ec : c50d cmp adrl ;check result + trap_ne ;bad result +24ee : d0fe > bne * ;failed not equal (non zero) + +24f0 : 68 pla ;check flags +24f1 : 2983 and #$83 ;mask N-----ZC +24f3 : c50f cmp adrf + trap_ne ;bad flags +24f5 : d0fe > bne * ;failed not equal (non zero) + +24f7 : 28 plp + ; decimal ADC / SBC # +24f8 : 08 php ;save carry for subtract +24f9 : a50c lda ad2 +24fb : 8d0125 sta chkdadi ;self modify immediate +24fe : a50b lda ad1 +2501 = chkdadi = * + 1 ;operand of the immediate ADC +2500 : 6900 adc #0 ;perform add +2502 : 08 php +2503 : c50d cmp adrl ;check result + trap_ne ;bad result +2505 : d0fe > bne * ;failed not equal (non zero) + +2507 : 68 pla ;check flags +2508 : 2983 and #$83 ;mask N-----ZC +250a : c50f cmp adrf + trap_ne ;bad flags +250c : d0fe > bne * ;failed not equal (non zero) + +250e : 28 plp +250f : 08 php ;save carry for next add +2510 : a510 lda sb2 +2512 : 8d1825 sta chkdsbi ;self modify immediate +2515 : a50b lda ad1 +2518 = chkdsbi = * + 1 ;operand of the immediate SBC +2517 : e900 sbc #0 ;perform subtract +2519 : 08 php +251a : c50d cmp adrl ;check result + trap_ne ;bad result +251c : d0fe > bne * ;failed not equal (non zero) + +251e : 68 pla ;check flags +251f : 2983 and #$83 ;mask N-----ZC +2521 : c50f cmp adrf + trap_ne ;bad flags +2523 : d0fe > bne * ;failed not equal (non zero) + +2525 : 28 plp + ; decimal ADC / SBC zp,x +2526 : 08 php ;save carry for subtract +2527 : a50b lda ad1 +2529 : 7500 adc 0,x ;perform add +252b : 08 php +252c : c50d cmp adrl ;check result + trap_ne ;bad result +252e : d0fe > bne * ;failed not equal (non zero) + +2530 : 68 pla ;check flags +2531 : 2983 and #$83 ;mask N-----ZC +2533 : c50f cmp adrf + trap_ne ;bad flags +2535 : d0fe > bne * ;failed not equal (non zero) + +2537 : 28 plp +2538 : 08 php ;save carry for next add +2539 : a50b lda ad1 +253b : f504 sbc sb2-ad2,x ;perform subtract +253d : 08 php +253e : c50d cmp adrl ;check result + trap_ne ;bad result +2540 : d0fe > bne * ;failed not equal (non zero) + +2542 : 68 pla ;check flags +2543 : 2983 and #$83 ;mask N-----ZC +2545 : c50f cmp adrf + trap_ne ;bad flags +2547 : d0fe > bne * ;failed not equal (non zero) + +2549 : 28 plp + ; decimal ADC / SBC abs,x +254a : 08 php ;save carry for subtract +254b : a50b lda ad1 +254d : 7df901 adc ada2-ad2,x ;perform add +2550 : 08 php +2551 : c50d cmp adrl ;check result + trap_ne ;bad result +2553 : d0fe > bne * ;failed not equal (non zero) + +2555 : 68 pla ;check flags +2556 : 2983 and #$83 ;mask N-----ZC +2558 : c50f cmp adrf + trap_ne ;bad flags +255a : d0fe > bne * ;failed not equal (non zero) + +255c : 28 plp +255d : 08 php ;save carry for next add +255e : a50b lda ad1 +2560 : fdfa01 sbc sba2-ad2,x ;perform subtract +2563 : 08 php +2564 : c50d cmp adrl ;check result + trap_ne ;bad result +2566 : d0fe > bne * ;failed not equal (non zero) + +2568 : 68 pla ;check flags +2569 : 2983 and #$83 ;mask N-----ZC +256b : c50f cmp adrf + trap_ne ;bad flags +256d : d0fe > bne * ;failed not equal (non zero) + +256f : 28 plp + ; decimal ADC / SBC abs,y +2570 : 08 php ;save carry for subtract +2571 : a50b lda ad1 +2573 : 790601 adc ada2-$ff,y ;perform add +2576 : 08 php +2577 : c50d cmp adrl ;check result + trap_ne ;bad result +2579 : d0fe > bne * ;failed not equal (non zero) + +257b : 68 pla ;check flags +257c : 2983 and #$83 ;mask N-----ZC +257e : c50f cmp adrf + trap_ne ;bad flags +2580 : d0fe > bne * ;failed not equal (non zero) + +2582 : 28 plp +2583 : 08 php ;save carry for next add +2584 : a50b lda ad1 +2586 : f90701 sbc sba2-$ff,y ;perform subtract +2589 : 08 php +258a : c50d cmp adrl ;check result + trap_ne ;bad result +258c : d0fe > bne * ;failed not equal (non zero) + +258e : 68 pla ;check flags +258f : 2983 and #$83 ;mask N-----ZC +2591 : c50f cmp adrf + trap_ne ;bad flags +2593 : d0fe > bne * ;failed not equal (non zero) + +2595 : 28 plp + ; decimal ADC / SBC (zp,x) +2596 : 08 php ;save carry for subtract +2597 : a50b lda ad1 +2599 : 6144 adc (lo adi2-ad2,x) ;perform add +259b : 08 php +259c : c50d cmp adrl ;check result + trap_ne ;bad result +259e : d0fe > bne * ;failed not equal (non zero) + +25a0 : 68 pla ;check flags +25a1 : 2983 and #$83 ;mask N-----ZC +25a3 : c50f cmp adrf + trap_ne ;bad flags +25a5 : d0fe > bne * ;failed not equal (non zero) + +25a7 : 28 plp +25a8 : 08 php ;save carry for next add +25a9 : a50b lda ad1 +25ab : e146 sbc (lo sbi2-ad2,x) ;perform subtract +25ad : 08 php +25ae : c50d cmp adrl ;check result + trap_ne ;bad result +25b0 : d0fe > bne * ;failed not equal (non zero) + +25b2 : 68 pla ;check flags +25b3 : 2983 and #$83 ;mask N-----ZC +25b5 : c50f cmp adrf + trap_ne ;bad flags +25b7 : d0fe > bne * ;failed not equal (non zero) + +25b9 : 28 plp + ; decimal ADC / SBC (abs),y +25ba : 08 php ;save carry for subtract +25bb : a50b lda ad1 +25bd : 7154 adc (adiy2),y ;perform add +25bf : 08 php +25c0 : c50d cmp adrl ;check result + trap_ne ;bad result +25c2 : d0fe > bne * ;failed not equal (non zero) + +25c4 : 68 pla ;check flags +25c5 : 2983 and #$83 ;mask N-----ZC +25c7 : c50f cmp adrf + trap_ne ;bad flags +25c9 : d0fe > bne * ;failed not equal (non zero) + +25cb : 28 plp +25cc : 08 php ;save carry for next add +25cd : a50b lda ad1 +25cf : f156 sbc (sbiy2),y ;perform subtract +25d1 : 08 php +25d2 : c50d cmp adrl ;check result + trap_ne ;bad result +25d4 : d0fe > bne * ;failed not equal (non zero) + +25d6 : 68 pla ;check flags +25d7 : 2983 and #$83 ;mask N-----ZC +25d9 : c50f cmp adrf + trap_ne ;bad flags +25db : d0fe > bne * ;failed not equal (non zero) + +25dd : 28 plp + ; decimal ADC / SBC (zp) +25de : 08 php ;save carry for subtract +25df : a50b lda ad1 +25e1 : 7250 adc (adi2) ;perform add +25e3 : 08 php +25e4 : c50d cmp adrl ;check result + trap_ne ;bad result +25e6 : d0fe > bne * ;failed not equal (non zero) + +25e8 : 68 pla ;check flags +25e9 : 2983 and #$83 ;mask N-----ZC +25eb : c50f cmp adrf + trap_ne ;bad flags +25ed : d0fe > bne * ;failed not equal (non zero) + +25ef : 28 plp +25f0 : 08 php ;save carry for next add +25f1 : a50b lda ad1 +25f3 : f252 sbc (sbi2) ;perform subtract +25f5 : 08 php +25f6 : c50d cmp adrl ;check result + trap_ne ;bad result +25f8 : d0fe > bne * ;failed not equal (non zero) + +25fa : 68 pla ;check flags +25fb : 2983 and #$83 ;mask N-----ZC +25fd : c50f cmp adrf + trap_ne ;bad flags +25ff : d0fe > bne * ;failed not equal (non zero) + +2601 : 28 plp +2602 : 60 rts + + ; core subroutine of the full binary add/subtract test + ; iterates through all combinations of operands and carry input + ; uses increments/decrements to predict result & result flags +2603 : a50f chkadd lda adrf ;add V-flag if overflow +2605 : 2983 and #$83 ;keep N-----ZC / clear V +2607 : 48 pha +2608 : a50b lda ad1 ;test sign unequal between operands +260a : 450c eor ad2 +260c : 300a bmi ckad1 ;no overflow possible - operands have different sign +260e : a50b lda ad1 ;test sign equal between operands and result +2610 : 450d eor adrl +2612 : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign +2614 : 68 pla +2615 : 0940 ora #$40 ;set V +2617 : 48 pha +2618 : 68 ckad1 pla +2619 : 850f sta adrf ;save expected flags + ; binary ADC / SBC (zp) +261b : 08 php ;save carry for subtract +261c : a50b lda ad1 +261e : 7250 adc (adi2) ;perform add +2620 : 08 php +2621 : c50d cmp adrl ;check result + trap_ne ;bad result +2623 : d0fe > bne * ;failed not equal (non zero) + +2625 : 68 pla ;check flags +2626 : 29c3 and #$c3 ;mask NV----ZC +2628 : c50f cmp adrf + trap_ne ;bad flags +262a : d0fe > bne * ;failed not equal (non zero) + +262c : 28 plp +262d : 08 php ;save carry for next add +262e : a50b lda ad1 +2630 : f252 sbc (sbi2) ;perform subtract +2632 : 08 php +2633 : c50d cmp adrl ;check result + trap_ne ;bad result +2635 : d0fe > bne * ;failed not equal (non zero) + +2637 : 68 pla ;check flags +2638 : 29c3 and #$c3 ;mask NV----ZC +263a : c50f cmp adrf + trap_ne ;bad flags +263c : d0fe > bne * ;failed not equal (non zero) + +263e : 28 plp +263f : 60 rts + + ; target for the jump indirect test +2640 : 4626 ji_adr dw test_ji +2642 : 8216 dw ji_ret + +2644 : 88 dey +2645 : 88 dey +2646 : test_ji +2646 : 08 php ;either SP or Y count will fail, if we do not hit +2647 : 88 dey +2648 : 88 dey +2649 : 88 dey +264a : 28 plp + trap_cs ;flags loaded? +264b : b0fe > bcs * ;failed carry set + + trap_vs +264d : 70fe > bvs * ;failed overflow set + + trap_mi +264f : 30fe > bmi * ;failed minus (bit 7 set) + + trap_eq +2651 : f0fe > beq * ;failed equal (zero) + +2653 : c949 cmp #'I' ;registers loaded? + trap_ne +2655 : d0fe > bne * ;failed not equal (non zero) + +2657 : e04e cpx #'N' + trap_ne +2659 : d0fe > bne * ;failed not equal (non zero) + +265b : c041 cpy #('D'-3) + trap_ne +265d : d0fe > bne * ;failed not equal (non zero) + +265f : 48 pha ;save a,x +2660 : 8a txa +2661 : 48 pha +2662 : ba tsx +2663 : e0fd cpx #$fd ;check SP + trap_ne +2665 : d0fe > bne * ;failed not equal (non zero) + +2667 : 68 pla ;restore x +2668 : aa tax + set_stat $ff + > load_flag $ff +2669 : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +266b : 48 > pha ;use stack to load status +266c : 28 > plp + +266d : 68 pla ;restore a +266e : e8 inx ;return registers with modifications +266f : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 +2671 : 6cff02 jmp (ji_tab+2) +2674 : ea nop +2675 : ea nop + trap ;runover protection +2676 : 4c7626 > jmp * ;failed anyway + + + ; target for the jump indirect test +2679 : bd26 jxi_adr dw trap_ind +267b : bd26 dw trap_ind +267d : 8726 dw test_jxi ;+4 +267f : ce16 dw jxi_ret ;+6 +2681 : bd26 dw trap_ind +2683 : bd26 dw trap_ind + +2685 : 88 dey +2686 : 88 dey +2687 : test_jxi +2687 : 08 php ;either SP or Y count will fail, if we do not hit +2688 : 88 dey +2689 : 88 dey +268a : 88 dey +268b : 28 plp + trap_cs ;flags loaded? +268c : b0fe > bcs * ;failed carry set + + trap_vs +268e : 70fe > bvs * ;failed overflow set + + trap_mi +2690 : 30fe > bmi * ;failed minus (bit 7 set) + + trap_eq +2692 : f0fe > beq * ;failed equal (zero) + +2694 : c958 cmp #'X' ;registers loaded? + trap_ne +2696 : d0fe > bne * ;failed not equal (non zero) + +2698 : e004 cpx #4 + trap_ne +269a : d0fe > bne * ;failed not equal (non zero) + +269c : c046 cpy #('I'-3) + trap_ne +269e : d0fe > bne * ;failed not equal (non zero) + +26a0 : 48 pha ;save a,x +26a1 : 8a txa +26a2 : 48 pha +26a3 : ba tsx +26a4 : e0fd cpx #$fd ;check SP + trap_ne +26a6 : d0fe > bne * ;failed not equal (non zero) + +26a8 : 68 pla ;restore x +26a9 : aa tax + set_stat $ff + > load_flag $ff +26aa : a9ff > lda #$ff ;allow test to change I-flag (no mask) + > +26ac : 48 > pha ;use stack to load status +26ad : 28 > plp + +26ae : 68 pla ;restore a +26af : e8 inx ;return registers with modifications +26b0 : e8 inx +26b1 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 +26b3 : 7cf902 jmp (jxi_tab,x) +26b6 : ea nop +26b7 : ea nop + trap ;runover protection +26b8 : 4cb826 > jmp * ;failed anyway + + + ; JMP (abs,x) with bad x +26bb : ea nop +26bc : ea nop +26bd : trap_ind +26bd : ea nop +26be : ea nop + trap ;near miss indexed indirect jump +26bf : 4cbf26 > jmp * ;failed anyway + + + ;trap in case of unexpected IRQ, NMI, BRK, RESET +26c2 : nmi_trap + trap ;check stack for conditions at NMI +26c2 : 4cc226 > jmp * ;failed anyway + +26c5 : res_trap + trap ;unexpected RESET +26c5 : 4cc526 > jmp * ;failed anyway + +26c8 : irq_trap +26c8 : 08 php ;save decimal flag +26c9 : ba tsx ;test break on stack +26ca : bd0201 lda $102,x +26cd : 2910 and #break + trap_eq ;check stack for conditions at IRQ +26cf : f0fe > beq * ;failed equal (zero) + + if ROM_vectors = 1 +26d1 : 68 pla ;test decimal mode cleared +26d2 : 2908 and #decmode + trap_ne ;decimal mode not cleared after BRK +26d4 : d0fe > bne * ;failed not equal (non zero) + +26d6 : 28 plp ;pop saved flags +26d7 : 68 pla ;return address low +26d8 : c917 cmp #lo(brk_ret) + trap_ne ;unexpected BRK +26da : d0fe > bne * ;failed not equal (non zero) + +26dc : 68 pla ;return address high +26dd : c917 cmp #hi(brk_ret) + trap_ne ;unexpected BRK +26df : d0fe > bne * ;failed not equal (non zero) + +26e1 : 4c1717 jmp brk_ret + else + trap_ne ;check stack for conditions at BRK + endif + + 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 + abs1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR + abs7f_ db $7f ;test pattern for compare + ;loads + fLDx_ db fn,fn,0,fz ;expected flags for load + ;shifts + rASL_ ;expected result ASL & ROL -carry + rROL_ db $86,$04,$82,0 ; " + rROLc_ db $87,$05,$83,1 ;expected result ROL +carry + rLSR_ ;expected result LSR & ROR -carry + rROR_ db $61,$41,$20,0 ; " + rRORc_ db $e1,$c1,$a0,$80 ;expected result ROR +carry + fASL_ ;expected flags for shifts + fROL_ db fnc,fc,fn,fz ;no carry in + fROLc_ db fnc,fc,fn,0 ;carry in + fLSR_ + fROR_ db fc,0,fc,fz ;no carry in + fRORc_ db fnc,fn,fnc,fn ;carry in + ;increments (decrements) + rINC_ db $7f,$80,$ff,0,1 ;expected result for INC/DEC + fINC_ db 0,fn,fn,fz,0 ;expected flags for INC/DEC + ;logical memory operand + absOR_ db 0,$1f,$71,$80 ;test pattern for OR + absAN_ db $0f,$ff,$7f,$80 ;test pattern for AND + absEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR + ;logical accu operand + absORa_ db 0,$f1,$1f,0 ;test pattern for OR + absANa_ db $f0,$ff,$ff,$ff ;test pattern for AND + absEOa_ db $ff,$f0,$f0,$0f ;test pattern for EOR + ;logical results + absrlo_ db 0,$ff,$7f,$80 + absflo_ db fz,fn,0,fn + data_end + if (data_end - data_init) != (data_bss_end - data_bss) + ;force assembler error if size is different + ERROR ERROR ERROR ;mismatch between bss and data + endif + + vec_init + dw nmi_trap + dw res_trap + dw irq_trap + vec_bss equ $fffa + endif ;end of RAM init data + + ; code at end of image due to the need to add blank space as required + if ($ff & (ji_ret - * - 2)) < ($ff & (jxi_ret - * - 2)) + ; JMP (abs) when $xxff and $xx00 are from same page +26e4 : 00000000000000.. ds lo(ji_ret - * - 2) +2780 : ea nop +2781 : ea nop +2782 : ea ji_px nop ;low address byte matched with ji_ret +2783 : ea nop + trap ;jmp indirect page cross bug +2784 : 4c8427 > jmp * ;failed anyway + + + ; JMP (abs,x) when $xxff and $xx00 are from same page +2787 : 00000000000000.. ds lo(jxi_ret - * - 2) +27cc : ea nop +27cd : ea nop +27ce : ea jxi_px nop ;low address byte matched with jxi_ret +27cf : ea nop + trap ;jmp indexed indirect page cross bug +27d0 : 4cd027 > jmp * ;failed anyway + + else + ; JMP (abs,x) when $xxff and $xx00 are from same page + ds lo(jxi_ret - * - 2) + nop + nop + jxi_px nop ;low address byte matched with jxi_ret + nop + trap ;jmp indexed indirect page cross bug + + ; JMP (abs) when $xxff and $xx00 are from same page + ds lo(ji_ret - * - 2) + nop + nop + ji_px nop ;low address byte matched with ji_ret + nop + trap ;jmp indirect page cross bug + endif + + if (load_data_direct = 1) & (ROM_vectors = 1) +fffa = org $fffa ;vectors +fffa : c226 dw nmi_trap +fffc : c526 dw res_trap +fffe : c826 dw irq_trap + endif + +fffa = end start + +No errors in pass 2. +Wrote binary from address $0000 through $ffff. +Total size 65536 bytes. +Program start address is at $0400 (1024). + \ No newline at end of file