1 /*
2
3 HNZVC
4
5 ? = undefined
6 * = affected
7 - = unaffected
8 0 = cleared
9 1 = set
10 # = CCr directly affected by instruction
11 @ = special - carry set if bit 7 is set
12
13 */
14
15 #ifdef NEW
illegal(void)16 static void illegal( void )
17 #else
18 static INLINE void illegal( void )
19 #endif
20 {
21 log_cb(RETRO_LOG_DEBUG, LOGPRE "KONAMI: illegal opcode at %04x\n",PC);
22 }
23
24 #ifdef macintosh
25 #pragma mark ____0x____
26 #endif
27
28 /* $00 NEG direct ?**** */
neg_di(void)29 static INLINE void neg_di( void )
30 {
31 UINT16 r,t;
32 DIRBYTE(t);
33 r = -t;
34 CLR_NZVC;
35 SET_FLAGS8(0,t,r);
36 WM(EAD,r);
37 }
38
39 /* $01 ILLEGAL */
40
41 /* $02 ILLEGAL */
42
43 /* $03 COM direct -**01 */
com_di(void)44 static INLINE void com_di( void )
45 {
46 UINT8 t;
47 DIRBYTE(t);
48 t = ~t;
49 CLR_NZV;
50 SET_NZ8(t);
51 SEC;
52 WM(EAD,t);
53 }
54
55 /* $04 LSR direct -0*-* */
lsr_di(void)56 static INLINE void lsr_di( void )
57 {
58 UINT8 t;
59 DIRBYTE(t);
60 CLR_NZC;
61 CC |= (t & CC_C);
62 t >>= 1;
63 SET_Z8(t);
64 WM(EAD,t);
65 }
66
67 /* $05 ILLEGAL */
68
69 /* $06 ROR direct -**-* */
ror_di(void)70 static INLINE void ror_di( void )
71 {
72 UINT8 t,r;
73 DIRBYTE(t);
74 r= (CC & CC_C) << 7;
75 CLR_NZC;
76 CC |= (t & CC_C);
77 r |= t>>1;
78 SET_NZ8(r);
79 WM(EAD,r);
80 }
81
82 /* $07 ASR direct ?**-* */
asr_di(void)83 static INLINE void asr_di( void )
84 {
85 UINT8 t;
86 DIRBYTE(t);
87 CLR_NZC;
88 CC |= (t & CC_C);
89 t = (t & 0x80) | (t >> 1);
90 SET_NZ8(t);
91 WM(EAD,t);
92 }
93
94 /* $08 ASL direct ?**** */
asl_di(void)95 static INLINE void asl_di( void )
96 {
97 UINT16 t,r;
98 DIRBYTE(t);
99 r = t << 1;
100 CLR_NZVC;
101 SET_FLAGS8(t,t,r);
102 WM(EAD,r);
103 }
104
105 /* $09 ROL direct -**** */
rol_di(void)106 static INLINE void rol_di( void )
107 {
108 UINT16 t,r;
109 DIRBYTE(t);
110 r = (CC & CC_C) | (t << 1);
111 CLR_NZVC;
112 SET_FLAGS8(t,t,r);
113 WM(EAD,r);
114 }
115
116 /* $0A DEC direct -***- */
dec_di(void)117 static INLINE void dec_di( void )
118 {
119 UINT8 t;
120 DIRBYTE(t);
121 --t;
122 CLR_NZV;
123 SET_FLAGS8D(t);
124 WM(EAD,t);
125 }
126
127 /* $0B ILLEGAL */
128
129 /* $OC INC direct -***- */
inc_di(void)130 static INLINE void inc_di( void )
131 {
132 UINT8 t;
133 DIRBYTE(t);
134 ++t;
135 CLR_NZV;
136 SET_FLAGS8I(t);
137 WM(EAD,t);
138 }
139
140 /* $OD TST direct -**0- */
tst_di(void)141 static INLINE void tst_di( void )
142 {
143 UINT8 t;
144 DIRBYTE(t);
145 CLR_NZV;
146 SET_NZ8(t);
147 }
148
149 /* $0E JMP direct ----- */
jmp_di(void)150 static INLINE void jmp_di( void )
151 {
152 DIRECT;
153 PCD=EAD;
154 change_pc16(PCD);
155 }
156
157 /* $0F CLR direct -0100 */
clr_di(void)158 static INLINE void clr_di( void )
159 {
160 DIRECT;
161 WM(EAD,0);
162 CLR_NZVC;
163 SEZ;
164 }
165
166 #ifdef macintosh
167 #pragma mark ____1x____
168 #endif
169
170 /* $10 FLAG */
171
172 /* $11 FLAG */
173
174 /* $12 NOP inherent ----- */
nop(void)175 static INLINE void nop( void )
176 {
177 ;
178 }
179
180 /* $13 SYNC inherent ----- */
sync(void)181 static INLINE void sync( void )
182 {
183 /* SYNC stops processing instructions until an interrupt request happens. */
184 /* This doesn't require the corresponding interrupt to be enabled: if it */
185 /* is disabled, execution continues with the next instruction. */
186 konami.int_state |= KONAMI_SYNC;
187 CHECK_IRQ_LINES;
188 /* if KONAMI_SYNC has not been cleared by CHECK_IRQ_LINES,
189 * stop execution until the interrupt lines change. */
190 if( (konami.int_state & KONAMI_SYNC) && konami_ICount > 0 )
191 konami_ICount = 0;
192 }
193
194 /* $14 ILLEGAL */
195
196 /* $15 ILLEGAL */
197
198 /* $16 LBRA relative ----- */
lbra(void)199 static INLINE void lbra( void )
200 {
201 IMMWORD(ea);
202 PC += EA;
203 change_pc16(PCD);
204
205 /* EHC 980508 speed up busy loop */
206 if( EA == 0xfffd && konami_ICount > 0 )
207 konami_ICount = 0;
208 }
209
210 /* $17 LBSR relative ----- */
lbsr(void)211 static INLINE void lbsr( void )
212 {
213 IMMWORD(ea);
214 PUSHWORD(pPC);
215 PC += EA;
216 change_pc16(PCD);
217 }
218
219 /* $18 ILLEGAL */
220
221 #if 1
222 /* $19 DAA inherent (A) -**0* */
daa(void)223 static INLINE void daa( void )
224 {
225 UINT8 msn, lsn;
226 UINT16 t, cf = 0;
227 msn = A & 0xf0; lsn = A & 0x0f;
228 if( lsn>0x09 || CC & CC_H) cf |= 0x06;
229 if( msn>0x80 && lsn>0x09 ) cf |= 0x60;
230 if( msn>0x90 || CC & CC_C) cf |= 0x60;
231 t = cf + A;
232 CLR_NZV; /* keep carry from previous operation */
233 SET_NZ8((UINT8)t); SET_C8(t);
234 A = t;
235 }
236 #else
237 /* $19 DAA inherent (A) -**0* */
daa(void)238 static INLINE void daa( void )
239 {
240 UINT16 t;
241 t = A;
242 if (CC & CC_H) t+=0x06;
243 if ((t&0x0f)>9) t+=0x06; /* ASG -- this code is broken! $66+$99=$FF -> DAA should = $65, we get $05! */
244 if (CC & CC_C) t+=0x60;
245 if ((t&0xf0)>0x90) t+=0x60;
246 if (t&0x100) SEC;
247 A = t;
248 }
249 #endif
250
251 /* $1A ORCC immediate ##### */
orcc(void)252 static INLINE void orcc( void )
253 {
254 UINT8 t;
255 IMMBYTE(t);
256 CC |= t;
257 CHECK_IRQ_LINES;
258 }
259
260 /* $1B ILLEGAL */
261
262 /* $1C ANDCC immediate ##### */
andcc(void)263 static INLINE void andcc( void )
264 {
265 UINT8 t;
266 IMMBYTE(t);
267 CC &= t;
268 CHECK_IRQ_LINES;
269 }
270
271 /* $1D SEX inherent -**0- */
sex(void)272 static INLINE void sex( void )
273 {
274 UINT16 t;
275 t = SIGNED(B);
276 D = t;
277 /* CLR_NZV; NS 20020905: applying the same fix that was applied to 6809 and 6309*/
278 CLR_NZ;
279 SET_NZ16(t);
280 }
281
282 /* $1E EXG inherent ----- */
exg(void)283 static INLINE void exg( void )
284 {
285 UINT16 t1 = 0, t2 = 0;
286 UINT8 tb;
287
288 IMMBYTE(tb);
289
290 GETREG( t1, tb >> 4 );
291 GETREG( t2, tb & 0x0f );
292
293 SETREG( t2, tb >> 4 );
294 SETREG( t1, tb & 0x0f );
295 }
296
297 /* $1F TFR inherent ----- */
tfr(void)298 static INLINE void tfr( void )
299 {
300 UINT8 tb;
301 UINT16 t = 0;
302
303 IMMBYTE(tb);
304
305 GETREG( t, tb & 0x0f );
306 SETREG( t, ( tb >> 4 ) & 0x07 );
307 }
308
309 #ifdef macintosh
310 #pragma mark ____2x____
311 #endif
312
313 /* $20 BRA relative ----- */
bra(void)314 static INLINE void bra( void )
315 {
316 UINT8 t;
317 IMMBYTE(t);
318 PC += SIGNED(t);
319 change_pc16(PCD);
320 /* JB 970823 - speed up busy loops */
321 if( t == 0xfe && konami_ICount > 0 )
322 konami_ICount = 0;
323 }
324
325 /* $21 BRN relative ----- */
brn(void)326 static INLINE void brn( void )
327 {
328 UINT8 t;
329 IMMBYTE(t);
330 }
331
332 /* $1021 LBRN relative ----- */
lbrn(void)333 static INLINE void lbrn( void )
334 {
335 IMMWORD(ea);
336 }
337
338 /* $22 BHI relative ----- */
bhi(void)339 static INLINE void bhi( void )
340 {
341 BRANCH( !(CC & (CC_Z|CC_C)) );
342 }
343
344 /* $1022 LBHI relative ----- */
lbhi(void)345 static INLINE void lbhi( void )
346 {
347 LBRANCH( !(CC & (CC_Z|CC_C)) );
348 }
349
350 /* $23 BLS relative ----- */
bls(void)351 static INLINE void bls( void )
352 {
353 BRANCH( (CC & (CC_Z|CC_C)) );
354 }
355
356 /* $1023 LBLS relative ----- */
lbls(void)357 static INLINE void lbls( void )
358 {
359 LBRANCH( (CC&(CC_Z|CC_C)) );
360 }
361
362 /* $24 BCC relative ----- */
bcc(void)363 static INLINE void bcc( void )
364 {
365 BRANCH( !(CC&CC_C) );
366 }
367
368 /* $1024 LBCC relative ----- */
lbcc(void)369 static INLINE void lbcc( void )
370 {
371 LBRANCH( !(CC&CC_C) );
372 }
373
374 /* $25 BCS relative ----- */
bcs(void)375 static INLINE void bcs( void )
376 {
377 BRANCH( (CC&CC_C) );
378 }
379
380 /* $1025 LBCS relative ----- */
lbcs(void)381 static INLINE void lbcs( void )
382 {
383 LBRANCH( (CC&CC_C) );
384 }
385
386 /* $26 BNE relative ----- */
bne(void)387 static INLINE void bne( void )
388 {
389 BRANCH( !(CC&CC_Z) );
390 }
391
392 /* $1026 LBNE relative ----- */
lbne(void)393 static INLINE void lbne( void )
394 {
395 LBRANCH( !(CC&CC_Z) );
396 }
397
398 /* $27 BEQ relative ----- */
beq(void)399 static INLINE void beq( void )
400 {
401 BRANCH( (CC&CC_Z) );
402 }
403
404 /* $1027 LBEQ relative ----- */
lbeq(void)405 static INLINE void lbeq( void )
406 {
407 LBRANCH( (CC&CC_Z) );
408 }
409
410 /* $28 BVC relative ----- */
bvc(void)411 static INLINE void bvc( void )
412 {
413 BRANCH( !(CC&CC_V) );
414 }
415
416 /* $1028 LBVC relative ----- */
lbvc(void)417 static INLINE void lbvc( void )
418 {
419 LBRANCH( !(CC&CC_V) );
420 }
421
422 /* $29 BVS relative ----- */
bvs(void)423 static INLINE void bvs( void )
424 {
425 BRANCH( (CC&CC_V) );
426 }
427
428 /* $1029 LBVS relative ----- */
lbvs(void)429 static INLINE void lbvs( void )
430 {
431 LBRANCH( (CC&CC_V) );
432 }
433
434 /* $2A BPL relative ----- */
bpl(void)435 static INLINE void bpl( void )
436 {
437 BRANCH( !(CC&CC_N) );
438 }
439
440 /* $102A LBPL relative ----- */
lbpl(void)441 static INLINE void lbpl( void )
442 {
443 LBRANCH( !(CC&CC_N) );
444 }
445
446 /* $2B BMI relative ----- */
bmi(void)447 static INLINE void bmi( void )
448 {
449 BRANCH( (CC&CC_N) );
450 }
451
452 /* $102B LBMI relative ----- */
lbmi(void)453 static INLINE void lbmi( void )
454 {
455 LBRANCH( (CC&CC_N) );
456 }
457
458 /* $2C BGE relative ----- */
bge(void)459 static INLINE void bge( void )
460 {
461 BRANCH( !NXORV );
462 }
463
464 /* $102C LBGE relative ----- */
lbge(void)465 static INLINE void lbge( void )
466 {
467 LBRANCH( !NXORV );
468 }
469
470 /* $2D BLT relative ----- */
blt(void)471 static INLINE void blt( void )
472 {
473 BRANCH( NXORV );
474 }
475
476 /* $102D LBLT relative ----- */
lblt(void)477 static INLINE void lblt( void )
478 {
479 LBRANCH( NXORV );
480 }
481
482 /* $2E BGT relative ----- */
bgt(void)483 static INLINE void bgt( void )
484 {
485 BRANCH( !(NXORV || (CC&CC_Z)) );
486 }
487
488 /* $102E LBGT relative ----- */
lbgt(void)489 static INLINE void lbgt( void )
490 {
491 LBRANCH( !(NXORV || (CC&CC_Z)) );
492 }
493
494 /* $2F BLE relative ----- */
ble(void)495 static INLINE void ble( void )
496 {
497 BRANCH( (NXORV || (CC&CC_Z)) );
498 }
499
500 /* $102F LBLE relative ----- */
lble(void)501 static INLINE void lble( void )
502 {
503 LBRANCH( (NXORV || (CC&CC_Z)) );
504 }
505
506 #ifdef macintosh
507 #pragma mark ____3x____
508 #endif
509
510 /* $30 LEAX indexed --*-- */
leax(void)511 static INLINE void leax( void )
512 {
513 X = EA;
514 CLR_Z;
515 SET_Z(X);
516 }
517
518 /* $31 LEAY indexed --*-- */
leay(void)519 static INLINE void leay( void )
520 {
521 Y = EA;
522 CLR_Z;
523 SET_Z(Y);
524 }
525
526 /* $32 LEAS indexed ----- */
leas(void)527 static INLINE void leas( void )
528 {
529 S = EA;
530 konami.int_state |= KONAMI_LDS;
531 }
532
533 /* $33 LEAU indexed ----- */
leau(void)534 static INLINE void leau( void )
535 {
536 U = EA;
537 }
538
539 /* $34 PSHS inherent ----- */
pshs(void)540 static INLINE void pshs( void )
541 {
542 UINT8 t;
543 IMMBYTE(t);
544 if( t&0x80 ) { PUSHWORD(pPC); konami_ICount -= 2; }
545 if( t&0x40 ) { PUSHWORD(pU); konami_ICount -= 2; }
546 if( t&0x20 ) { PUSHWORD(pY); konami_ICount -= 2; }
547 if( t&0x10 ) { PUSHWORD(pX); konami_ICount -= 2; }
548 if( t&0x08 ) { PUSHBYTE(DP); konami_ICount -= 1; }
549 if( t&0x04 ) { PUSHBYTE(B); konami_ICount -= 1; }
550 if( t&0x02 ) { PUSHBYTE(A); konami_ICount -= 1; }
551 if( t&0x01 ) { PUSHBYTE(CC); konami_ICount -= 1; }
552 }
553
554 /* 35 PULS inherent ----- */
puls(void)555 static INLINE void puls( void )
556 {
557 UINT8 t;
558 IMMBYTE(t);
559 if( t&0x01 ) { PULLBYTE(CC); konami_ICount -= 1; }
560 if( t&0x02 ) { PULLBYTE(A); konami_ICount -= 1; }
561 if( t&0x04 ) { PULLBYTE(B); konami_ICount -= 1; }
562 if( t&0x08 ) { PULLBYTE(DP); konami_ICount -= 1; }
563 if( t&0x10 ) { PULLWORD(XD); konami_ICount -= 2; }
564 if( t&0x20 ) { PULLWORD(YD); konami_ICount -= 2; }
565 if( t&0x40 ) { PULLWORD(UD); konami_ICount -= 2; }
566 if( t&0x80 ) { PULLWORD(PCD); change_pc16(PCD); konami_ICount -= 2; }
567
568 /* check after all PULLs */
569 if( t&0x01 ) { CHECK_IRQ_LINES; }
570 }
571
572 /* $36 PSHU inherent ----- */
pshu(void)573 static INLINE void pshu( void )
574 {
575 UINT8 t;
576 IMMBYTE(t);
577 if( t&0x80 ) { PSHUWORD(pPC); konami_ICount -= 2; }
578 if( t&0x40 ) { PSHUWORD(pS); konami_ICount -= 2; }
579 if( t&0x20 ) { PSHUWORD(pY); konami_ICount -= 2; }
580 if( t&0x10 ) { PSHUWORD(pX); konami_ICount -= 2; }
581 if( t&0x08 ) { PSHUBYTE(DP); konami_ICount -= 1; }
582 if( t&0x04 ) { PSHUBYTE(B); konami_ICount -= 1; }
583 if( t&0x02 ) { PSHUBYTE(A); konami_ICount -= 1; }
584 if( t&0x01 ) { PSHUBYTE(CC); konami_ICount -= 1; }
585 }
586
587 /* 37 PULU inherent ----- */
pulu(void)588 static INLINE void pulu( void )
589 {
590 UINT8 t;
591 IMMBYTE(t);
592 if( t&0x01 ) { PULUBYTE(CC); konami_ICount -= 1; }
593 if( t&0x02 ) { PULUBYTE(A); konami_ICount -= 1; }
594 if( t&0x04 ) { PULUBYTE(B); konami_ICount -= 1; }
595 if( t&0x08 ) { PULUBYTE(DP); konami_ICount -= 1; }
596 if( t&0x10 ) { PULUWORD(XD); konami_ICount -= 2; }
597 if( t&0x20 ) { PULUWORD(YD); konami_ICount -= 2; }
598 if( t&0x40 ) { PULUWORD(SD); konami_ICount -= 2; }
599 if( t&0x80 ) { PULUWORD(PCD); change_pc16(PCD); konami_ICount -= 2; }
600
601 /* check after all PULLs */
602 if( t&0x01 ) { CHECK_IRQ_LINES; }
603 }
604
605 /* $38 ILLEGAL */
606
607 /* $39 RTS inherent ----- */
rts(void)608 static INLINE void rts( void )
609 {
610 PULLWORD(PCD);
611 change_pc16(PCD);
612 }
613
614 /* $3A ABX inherent ----- */
abx(void)615 static INLINE void abx( void )
616 {
617 X += B;
618 }
619
620 /* $3B RTI inherent ##### */
rti(void)621 static INLINE void rti( void )
622 {
623 PULLBYTE(CC);
624 if( CC & CC_E ) /* entire state saved? */
625 {
626 konami_ICount -= 9;
627 PULLBYTE(A);
628 PULLBYTE(B);
629 PULLBYTE(DP);
630 PULLWORD(XD);
631 PULLWORD(YD);
632 PULLWORD(UD);
633 }
634 PULLWORD(PCD);
635 change_pc16(PCD);
636 CHECK_IRQ_LINES;
637 }
638
639 /* $3C CWAI inherent ----1 */
cwai(void)640 static INLINE void cwai( void )
641 {
642 UINT8 t;
643 IMMBYTE(t);
644 CC &= t;
645 /*
646 * CWAI stacks the entire machine state on the hardware stack,
647 * then waits for an interrupt; when the interrupt is taken
648 * later, the state is *not* saved again after CWAI.
649 */
650 CC |= CC_E; /* HJB 990225: save entire state */
651 PUSHWORD(pPC);
652 PUSHWORD(pU);
653 PUSHWORD(pY);
654 PUSHWORD(pX);
655 PUSHBYTE(DP);
656 PUSHBYTE(B);
657 PUSHBYTE(A);
658 PUSHBYTE(CC);
659 konami.int_state |= KONAMI_CWAI;
660 CHECK_IRQ_LINES;
661 if( (konami.int_state & KONAMI_CWAI) && konami_ICount > 0 )
662 konami_ICount = 0;
663 }
664
665 /* $3D MUL inherent --*-@ */
mul(void)666 static INLINE void mul( void )
667 {
668 UINT16 t;
669 t = A * B;
670 CLR_ZC; SET_Z16(t); if(t&0x80) SEC;
671 D = t;
672 }
673
674 /* $3E ILLEGAL */
675
676 /* $3F SWI (SWI2 SWI3) absolute indirect ----- */
swi(void)677 static INLINE void swi( void )
678 {
679 CC |= CC_E; /* HJB 980225: save entire state */
680 PUSHWORD(pPC);
681 PUSHWORD(pU);
682 PUSHWORD(pY);
683 PUSHWORD(pX);
684 PUSHBYTE(DP);
685 PUSHBYTE(B);
686 PUSHBYTE(A);
687 PUSHBYTE(CC);
688 CC |= CC_IF | CC_II; /* inhibit FIRQ and IRQ */
689 PCD=RM16(0xfffa);
690 change_pc16(PCD);
691 }
692
693 /* $103F SWI2 absolute indirect ----- */
swi2(void)694 static INLINE void swi2( void )
695 {
696 CC |= CC_E; /* HJB 980225: save entire state */
697 PUSHWORD(pPC);
698 PUSHWORD(pU);
699 PUSHWORD(pY);
700 PUSHWORD(pX);
701 PUSHBYTE(DP);
702 PUSHBYTE(B);
703 PUSHBYTE(A);
704 PUSHBYTE(CC);
705 PCD=RM16(0xfff4);
706 change_pc16(PCD);
707 }
708
709 /* $113F SWI3 absolute indirect ----- */
swi3(void)710 static INLINE void swi3( void )
711 {
712 CC |= CC_E; /* HJB 980225: save entire state */
713 PUSHWORD(pPC);
714 PUSHWORD(pU);
715 PUSHWORD(pY);
716 PUSHWORD(pX);
717 PUSHBYTE(DP);
718 PUSHBYTE(B);
719 PUSHBYTE(A);
720 PUSHBYTE(CC);
721 PCD=RM16(0xfff2);
722 change_pc16(PCD);
723 }
724
725 #ifdef macintosh
726 #pragma mark ____4x____
727 #endif
728
729 /* $40 NEGA inherent ?**** */
nega(void)730 static INLINE void nega( void )
731 {
732 UINT16 r;
733 r = -A;
734 CLR_NZVC;
735 SET_FLAGS8(0,A,r);
736 A = r;
737 }
738
739 /* $41 ILLEGAL */
740
741 /* $42 ILLEGAL */
742
743 /* $43 COMA inherent -**01 */
coma(void)744 static INLINE void coma( void )
745 {
746 A = ~A;
747 CLR_NZV;
748 SET_NZ8(A);
749 SEC;
750 }
751
752 /* $44 LSRA inherent -0*-* */
lsra(void)753 static INLINE void lsra( void )
754 {
755 CLR_NZC;
756 CC |= (A & CC_C);
757 A >>= 1;
758 SET_Z8(A);
759 }
760
761 /* $45 ILLEGAL */
762
763 /* $46 RORA inherent -**-* */
rora(void)764 static INLINE void rora( void )
765 {
766 UINT8 r;
767 r = (CC & CC_C) << 7;
768 CLR_NZC;
769 CC |= (A & CC_C);
770 r |= A >> 1;
771 SET_NZ8(r);
772 A = r;
773 }
774
775 /* $47 ASRA inherent ?**-* */
asra(void)776 static INLINE void asra( void )
777 {
778 CLR_NZC;
779 CC |= (A & CC_C);
780 A = (A & 0x80) | (A >> 1);
781 SET_NZ8(A);
782 }
783
784 /* $48 ASLA inherent ?**** */
asla(void)785 static INLINE void asla( void )
786 {
787 UINT16 r;
788 r = A << 1;
789 CLR_NZVC;
790 SET_FLAGS8(A,A,r);
791 A = r;
792 }
793
794 /* $49 ROLA inherent -**** */
rola(void)795 static INLINE void rola( void )
796 {
797 UINT16 t,r;
798 t = A;
799 r = (CC & CC_C) | (t<<1);
800 CLR_NZVC; SET_FLAGS8(t,t,r);
801 A = r;
802 }
803
804 /* $4A DECA inherent -***- */
deca(void)805 static INLINE void deca( void )
806 {
807 --A;
808 CLR_NZV;
809 SET_FLAGS8D(A);
810 }
811
812 /* $4B ILLEGAL */
813
814 /* $4C INCA inherent -***- */
inca(void)815 static INLINE void inca( void )
816 {
817 ++A;
818 CLR_NZV;
819 SET_FLAGS8I(A);
820 }
821
822 /* $4D TSTA inherent -**0- */
tsta(void)823 static INLINE void tsta( void )
824 {
825 CLR_NZV;
826 SET_NZ8(A);
827 }
828
829 /* $4E ILLEGAL */
830
831 /* $4F CLRA inherent -0100 */
clra(void)832 static INLINE void clra( void )
833 {
834 A = 0;
835 CLR_NZVC; SEZ;
836 }
837
838 #ifdef macintosh
839 #pragma mark ____5x____
840 #endif
841
842 /* $50 NEGB inherent ?**** */
negb(void)843 static INLINE void negb( void )
844 {
845 UINT16 r;
846 r = -B;
847 CLR_NZVC;
848 SET_FLAGS8(0,B,r);
849 B = r;
850 }
851
852 /* $51 ILLEGAL */
853
854 /* $52 ILLEGAL */
855
856 /* $53 COMB inherent -**01 */
comb(void)857 static INLINE void comb( void )
858 {
859 B = ~B;
860 CLR_NZV;
861 SET_NZ8(B);
862 SEC;
863 }
864
865 /* $54 LSRB inherent -0*-* */
lsrb(void)866 static INLINE void lsrb( void )
867 {
868 CLR_NZC;
869 CC |= (B & CC_C);
870 B >>= 1;
871 SET_Z8(B);
872 }
873
874 /* $55 ILLEGAL */
875
876 /* $56 RORB inherent -**-* */
rorb(void)877 static INLINE void rorb( void )
878 {
879 UINT8 r;
880 r = (CC & CC_C) << 7;
881 CLR_NZC;
882 CC |= (B & CC_C);
883 r |= B >> 1;
884 SET_NZ8(r);
885 B = r;
886 }
887
888 /* $57 ASRB inherent ?**-* */
asrb(void)889 static INLINE void asrb( void )
890 {
891 CLR_NZC;
892 CC |= (B & CC_C);
893 B= (B & 0x80) | (B >> 1);
894 SET_NZ8(B);
895 }
896
897 /* $58 ASLB inherent ?**** */
aslb(void)898 static INLINE void aslb( void )
899 {
900 UINT16 r;
901 r = B << 1;
902 CLR_NZVC;
903 SET_FLAGS8(B,B,r);
904 B = r;
905 }
906
907 /* $59 ROLB inherent -**** */
rolb(void)908 static INLINE void rolb( void )
909 {
910 UINT16 t,r;
911 t = B;
912 r = CC & CC_C;
913 r |= t << 1;
914 CLR_NZVC;
915 SET_FLAGS8(t,t,r);
916 B = r;
917 }
918
919 /* $5A DECB inherent -***- */
decb(void)920 static INLINE void decb( void )
921 {
922 --B;
923 CLR_NZV;
924 SET_FLAGS8D(B);
925 }
926
927 /* $5B ILLEGAL */
928
929 /* $5C INCB inherent -***- */
incb(void)930 static INLINE void incb( void )
931 {
932 ++B;
933 CLR_NZV;
934 SET_FLAGS8I(B);
935 }
936
937 /* $5D TSTB inherent -**0- */
tstb(void)938 static INLINE void tstb( void )
939 {
940 CLR_NZV;
941 SET_NZ8(B);
942 }
943
944 /* $5E ILLEGAL */
945
946 /* $5F CLRB inherent -0100 */
clrb(void)947 static INLINE void clrb( void )
948 {
949 B = 0;
950 CLR_NZVC; SEZ;
951 }
952
953 #ifdef macintosh
954 #pragma mark ____6x____
955 #endif
956
957 /* $60 NEG indexed ?**** */
neg_ix(void)958 static INLINE void neg_ix( void )
959 {
960 UINT16 r,t;
961 t = RM(EAD);
962 r = -t;
963 CLR_NZVC;
964 SET_FLAGS8(0,t,r);
965 WM(EAD,r);
966 }
967
968 /* $61 ILLEGAL */
969
970 /* $62 ILLEGAL */
971
972 /* $63 COM indexed -**01 */
com_ix(void)973 static INLINE void com_ix( void )
974 {
975 UINT8 t;
976 t = ~RM(EAD);
977 CLR_NZV;
978 SET_NZ8(t);
979 SEC;
980 WM(EAD,t);
981 }
982
983 /* $64 LSR indexed -0*-* */
lsr_ix(void)984 static INLINE void lsr_ix( void )
985 {
986 UINT8 t;
987 t = RM(EAD);
988 CLR_NZC;
989 CC |= (t & CC_C);
990 t>>=1; SET_Z8(t);
991 WM(EAD,t);
992 }
993
994 /* $65 ILLEGAL */
995
996 /* $66 ROR indexed -**-* */
ror_ix(void)997 static INLINE void ror_ix( void )
998 {
999 UINT8 t,r;
1000 t = RM(EAD);
1001 r = (CC & CC_C) << 7;
1002 CLR_NZC;
1003 CC |= (t & CC_C);
1004 r |= t>>1; SET_NZ8(r);
1005 WM(EAD,r);
1006 }
1007
1008 /* $67 ASR indexed ?**-* */
asr_ix(void)1009 static INLINE void asr_ix( void )
1010 {
1011 UINT8 t;
1012 t = RM(EAD);
1013 CLR_NZC;
1014 CC |= (t & CC_C);
1015 t=(t&0x80)|(t>>1);
1016 SET_NZ8(t);
1017 WM(EAD,t);
1018 }
1019
1020 /* $68 ASL indexed ?**** */
asl_ix(void)1021 static INLINE void asl_ix( void )
1022 {
1023 UINT16 t,r;
1024 t = RM(EAD);
1025 r = t << 1;
1026 CLR_NZVC;
1027 SET_FLAGS8(t,t,r);
1028 WM(EAD,r);
1029 }
1030
1031 /* $69 ROL indexed -**** */
rol_ix(void)1032 static INLINE void rol_ix( void )
1033 {
1034 UINT16 t,r;
1035 t = RM(EAD);
1036 r = CC & CC_C;
1037 r |= t << 1;
1038 CLR_NZVC;
1039 SET_FLAGS8(t,t,r);
1040 WM(EAD,r);
1041 }
1042
1043 /* $6A DEC indexed -***- */
dec_ix(void)1044 static INLINE void dec_ix( void )
1045 {
1046 UINT8 t;
1047 t = RM(EAD) - 1;
1048 CLR_NZV; SET_FLAGS8D(t);
1049 WM(EAD,t);
1050 }
1051
1052 /* $6B ILLEGAL */
1053
1054 /* $6C INC indexed -***- */
inc_ix(void)1055 static INLINE void inc_ix( void )
1056 {
1057 UINT8 t;
1058 t = RM(EAD) + 1;
1059 CLR_NZV; SET_FLAGS8I(t);
1060 WM(EAD,t);
1061 }
1062
1063 /* $6D TST indexed -**0- */
tst_ix(void)1064 static INLINE void tst_ix( void )
1065 {
1066 UINT8 t;
1067 t = RM(EAD);
1068 CLR_NZV;
1069 SET_NZ8(t);
1070 }
1071
1072 /* $6E JMP indexed ----- */
jmp_ix(void)1073 static INLINE void jmp_ix( void )
1074 {
1075 PCD=EAD;
1076 change_pc16(PCD);
1077 }
1078
1079 /* $6F CLR indexed -0100 */
clr_ix(void)1080 static INLINE void clr_ix( void )
1081 {
1082 WM(EAD,0);
1083 CLR_NZVC; SEZ;
1084 }
1085
1086 #ifdef macintosh
1087 #pragma mark ____7x____
1088 #endif
1089
1090 /* $70 NEG extended ?**** */
neg_ex(void)1091 static INLINE void neg_ex( void )
1092 {
1093 UINT16 r,t;
1094 EXTBYTE(t); r=-t;
1095 CLR_NZVC; SET_FLAGS8(0,t,r);
1096 WM(EAD,r);
1097 }
1098
1099 /* $71 ILLEGAL */
1100
1101 /* $72 ILLEGAL */
1102
1103 /* $73 COM extended -**01 */
com_ex(void)1104 static INLINE void com_ex( void )
1105 {
1106 UINT8 t;
1107 EXTBYTE(t); t = ~t;
1108 CLR_NZV; SET_NZ8(t); SEC;
1109 WM(EAD,t);
1110 }
1111
1112 /* $74 LSR extended -0*-* */
lsr_ex(void)1113 static INLINE void lsr_ex( void )
1114 {
1115 UINT8 t;
1116 EXTBYTE(t); CLR_NZC; CC |= (t & CC_C);
1117 t>>=1; SET_Z8(t);
1118 WM(EAD,t);
1119 }
1120
1121 /* $75 ILLEGAL */
1122
1123 /* $76 ROR extended -**-* */
ror_ex(void)1124 static INLINE void ror_ex( void )
1125 {
1126 UINT8 t,r;
1127 EXTBYTE(t); r=(CC & CC_C) << 7;
1128 CLR_NZC; CC |= (t & CC_C);
1129 r |= t>>1; SET_NZ8(r);
1130 WM(EAD,r);
1131 }
1132
1133 /* $77 ASR extended ?**-* */
asr_ex(void)1134 static INLINE void asr_ex( void )
1135 {
1136 UINT8 t;
1137 EXTBYTE(t); CLR_NZC; CC |= (t & CC_C);
1138 t=(t&0x80)|(t>>1);
1139 SET_NZ8(t);
1140 WM(EAD,t);
1141 }
1142
1143 /* $78 ASL extended ?**** */
asl_ex(void)1144 static INLINE void asl_ex( void )
1145 {
1146 UINT16 t,r;
1147 EXTBYTE(t); r=t<<1;
1148 CLR_NZVC; SET_FLAGS8(t,t,r);
1149 WM(EAD,r);
1150 }
1151
1152 /* $79 ROL extended -**** */
rol_ex(void)1153 static INLINE void rol_ex( void )
1154 {
1155 UINT16 t,r;
1156 EXTBYTE(t); r = (CC & CC_C) | (t << 1);
1157 CLR_NZVC; SET_FLAGS8(t,t,r);
1158 WM(EAD,r);
1159 }
1160
1161 /* $7A DEC extended -***- */
dec_ex(void)1162 static INLINE void dec_ex( void )
1163 {
1164 UINT8 t;
1165 EXTBYTE(t); --t;
1166 CLR_NZV; SET_FLAGS8D(t);
1167 WM(EAD,t);
1168 }
1169
1170 /* $7B ILLEGAL */
1171
1172 /* $7C INC extended -***- */
inc_ex(void)1173 static INLINE void inc_ex( void )
1174 {
1175 UINT8 t;
1176 EXTBYTE(t); ++t;
1177 CLR_NZV; SET_FLAGS8I(t);
1178 WM(EAD,t);
1179 }
1180
1181 /* $7D TST extended -**0- */
tst_ex(void)1182 static INLINE void tst_ex( void )
1183 {
1184 UINT8 t;
1185 EXTBYTE(t); CLR_NZV; SET_NZ8(t);
1186 }
1187
1188 /* $7E JMP extended ----- */
jmp_ex(void)1189 static INLINE void jmp_ex( void )
1190 {
1191 EXTENDED;
1192 PCD=EAD;
1193 change_pc16(PCD);
1194 }
1195
1196 /* $7F CLR extended -0100 */
clr_ex(void)1197 static INLINE void clr_ex( void )
1198 {
1199 EXTENDED;
1200 WM(EAD,0);
1201 CLR_NZVC; SEZ;
1202 }
1203
1204
1205 #ifdef macintosh
1206 #pragma mark ____8x____
1207 #endif
1208
1209 /* $80 SUBA immediate ?**** */
suba_im(void)1210 static INLINE void suba_im( void )
1211 {
1212 UINT16 t,r;
1213 IMMBYTE(t);
1214 r = A - t;
1215 CLR_NZVC;
1216 SET_FLAGS8(A,t,r);
1217 A = r;
1218 }
1219
1220 /* $81 CMPA immediate ?**** */
cmpa_im(void)1221 static INLINE void cmpa_im( void )
1222 {
1223 UINT16 t,r;
1224 IMMBYTE(t);
1225 r = A - t;
1226 CLR_NZVC;
1227 SET_FLAGS8(A,t,r);
1228 }
1229
1230 /* $82 SBCA immediate ?**** */
sbca_im(void)1231 static INLINE void sbca_im( void )
1232 {
1233 UINT16 t,r;
1234 IMMBYTE(t);
1235 r = A - t - (CC & CC_C);
1236 CLR_NZVC;
1237 SET_FLAGS8(A,t,r);
1238 A = r;
1239 }
1240
1241 /* $83 SUBD (CMPD CMPU) immediate -**** */
subd_im(void)1242 static INLINE void subd_im( void )
1243 {
1244 UINT32 r,d;
1245 PAIR b;
1246 IMMWORD(b);
1247 d = D;
1248 r = d - b.d;
1249 CLR_NZVC;
1250 SET_FLAGS16(d,b.d,r);
1251 D = r;
1252 }
1253
1254 /* $1083 CMPD immediate -**** */
cmpd_im(void)1255 static INLINE void cmpd_im( void )
1256 {
1257 UINT32 r,d;
1258 PAIR b;
1259 IMMWORD(b);
1260 d = D;
1261 r = d - b.d;
1262 CLR_NZVC;
1263 SET_FLAGS16(d,b.d,r);
1264 }
1265
1266 /* $1183 CMPU immediate -**** */
cmpu_im(void)1267 static INLINE void cmpu_im( void )
1268 {
1269 UINT32 r, d;
1270 PAIR b;
1271 IMMWORD(b);
1272 d = U;
1273 r = d - b.d;
1274 CLR_NZVC;
1275 SET_FLAGS16(d,b.d,r);
1276 }
1277
1278 /* $84 ANDA immediate -**0- */
anda_im(void)1279 static INLINE void anda_im( void )
1280 {
1281 UINT8 t;
1282 IMMBYTE(t);
1283 A &= t;
1284 CLR_NZV;
1285 SET_NZ8(A);
1286 }
1287
1288 /* $85 BITA immediate -**0- */
bita_im(void)1289 static INLINE void bita_im( void )
1290 {
1291 UINT8 t,r;
1292 IMMBYTE(t);
1293 r = A & t;
1294 CLR_NZV;
1295 SET_NZ8(r);
1296 }
1297
1298 /* $86 LDA immediate -**0- */
lda_im(void)1299 static INLINE void lda_im( void )
1300 {
1301 IMMBYTE(A);
1302 CLR_NZV;
1303 SET_NZ8(A);
1304 }
1305
1306 /* is this a legal instruction? */
1307 /* $87 STA immediate -**0- */
sta_im(void)1308 static INLINE void sta_im( void )
1309 {
1310 CLR_NZV;
1311 SET_NZ8(A);
1312 IMM8;
1313 WM(EAD,A);
1314 }
1315
1316 /* $88 EORA immediate -**0- */
eora_im(void)1317 static INLINE void eora_im( void )
1318 {
1319 UINT8 t;
1320 IMMBYTE(t);
1321 A ^= t;
1322 CLR_NZV;
1323 SET_NZ8(A);
1324 }
1325
1326 /* $89 ADCA immediate ***** */
adca_im(void)1327 static INLINE void adca_im( void )
1328 {
1329 UINT16 t,r;
1330 IMMBYTE(t);
1331 r = A + t + (CC & CC_C);
1332 CLR_HNZVC;
1333 SET_FLAGS8(A,t,r);
1334 SET_H(A,t,r);
1335 A = r;
1336 }
1337
1338 /* $8A ORA immediate -**0- */
ora_im(void)1339 static INLINE void ora_im( void )
1340 {
1341 UINT8 t;
1342 IMMBYTE(t);
1343 A |= t;
1344 CLR_NZV;
1345 SET_NZ8(A);
1346 }
1347
1348 /* $8B ADDA immediate ***** */
adda_im(void)1349 static INLINE void adda_im( void )
1350 {
1351 UINT16 t,r;
1352 IMMBYTE(t);
1353 r = A + t;
1354 CLR_HNZVC;
1355 SET_FLAGS8(A,t,r);
1356 SET_H(A,t,r);
1357 A = r;
1358 }
1359
1360 /* $8C CMPX (CMPY CMPS) immediate -**** */
cmpx_im(void)1361 static INLINE void cmpx_im( void )
1362 {
1363 UINT32 r,d;
1364 PAIR b;
1365 IMMWORD(b);
1366 d = X;
1367 r = d - b.d;
1368 CLR_NZVC;
1369 SET_FLAGS16(d,b.d,r);
1370 }
1371
1372 /* $108C CMPY immediate -**** */
cmpy_im(void)1373 static INLINE void cmpy_im( void )
1374 {
1375 UINT32 r,d;
1376 PAIR b;
1377 IMMWORD(b);
1378 d = Y;
1379 r = d - b.d;
1380 CLR_NZVC;
1381 SET_FLAGS16(d,b.d,r);
1382 }
1383
1384 /* $118C CMPS immediate -**** */
cmps_im(void)1385 static INLINE void cmps_im( void )
1386 {
1387 UINT32 r,d;
1388 PAIR b;
1389 IMMWORD(b);
1390 d = S;
1391 r = d - b.d;
1392 CLR_NZVC;
1393 SET_FLAGS16(d,b.d,r);
1394 }
1395
1396 /* $8D BSR ----- */
bsr(void)1397 static INLINE void bsr( void )
1398 {
1399 UINT8 t;
1400 IMMBYTE(t);
1401 PUSHWORD(pPC);
1402 PC += SIGNED(t);
1403 change_pc16(PCD);
1404 }
1405
1406 /* $8E LDX (LDY) immediate -**0- */
ldx_im(void)1407 static INLINE void ldx_im( void )
1408 {
1409 IMMWORD(pX);
1410 CLR_NZV;
1411 SET_NZ16(X);
1412 }
1413
1414 /* $108E LDY immediate -**0- */
ldy_im(void)1415 static INLINE void ldy_im( void )
1416 {
1417 IMMWORD(pY);
1418 CLR_NZV;
1419 SET_NZ16(Y);
1420 }
1421
1422 /* is this a legal instruction? */
1423 /* $8F STX (STY) immediate -**0- */
stx_im(void)1424 static INLINE void stx_im( void )
1425 {
1426 CLR_NZV;
1427 SET_NZ16(X);
1428 IMM16;
1429 WM16(EAD,&pX);
1430 }
1431
1432 /* is this a legal instruction? */
1433 /* $108F STY immediate -**0- */
sty_im(void)1434 static INLINE void sty_im( void )
1435 {
1436 CLR_NZV;
1437 SET_NZ16(Y);
1438 IMM16;
1439 WM16(EAD,&pY);
1440 }
1441
1442 #ifdef macintosh
1443 #pragma mark ____9x____
1444 #endif
1445
1446 /* $90 SUBA direct ?**** */
suba_di(void)1447 static INLINE void suba_di( void )
1448 {
1449 UINT16 t,r;
1450 DIRBYTE(t);
1451 r = A - t;
1452 CLR_NZVC;
1453 SET_FLAGS8(A,t,r);
1454 A = r;
1455 }
1456
1457 /* $91 CMPA direct ?**** */
cmpa_di(void)1458 static INLINE void cmpa_di( void )
1459 {
1460 UINT16 t,r;
1461 DIRBYTE(t);
1462 r = A - t;
1463 CLR_NZVC;
1464 SET_FLAGS8(A,t,r);
1465 }
1466
1467 /* $92 SBCA direct ?**** */
sbca_di(void)1468 static INLINE void sbca_di( void )
1469 {
1470 UINT16 t,r;
1471 DIRBYTE(t);
1472 r = A - t - (CC & CC_C);
1473 CLR_NZVC;
1474 SET_FLAGS8(A,t,r);
1475 A = r;
1476 }
1477
1478 /* $93 SUBD (CMPD CMPU) direct -**** */
subd_di(void)1479 static INLINE void subd_di( void )
1480 {
1481 UINT32 r,d;
1482 PAIR b;
1483 DIRWORD(b);
1484 d = D;
1485 r = d - b.d;
1486 CLR_NZVC;
1487 SET_FLAGS16(d,b.d,r);
1488 D = r;
1489 }
1490
1491 /* $1093 CMPD direct -**** */
cmpd_di(void)1492 static INLINE void cmpd_di( void )
1493 {
1494 UINT32 r,d;
1495 PAIR b;
1496 DIRWORD(b);
1497 d = D;
1498 r = d - b.d;
1499 CLR_NZVC;
1500 SET_FLAGS16(d,b.d,r);
1501 }
1502
1503 /* $1193 CMPU direct -**** */
cmpu_di(void)1504 static INLINE void cmpu_di( void )
1505 {
1506 UINT32 r,d;
1507 PAIR b;
1508 DIRWORD(b);
1509 d = U;
1510 r = d - b.d;
1511 CLR_NZVC;
1512 SET_FLAGS16(U,b.d,r);
1513 }
1514
1515 /* $94 ANDA direct -**0- */
anda_di(void)1516 static INLINE void anda_di( void )
1517 {
1518 UINT8 t;
1519 DIRBYTE(t);
1520 A &= t;
1521 CLR_NZV;
1522 SET_NZ8(A);
1523 }
1524
1525 /* $95 BITA direct -**0- */
bita_di(void)1526 static INLINE void bita_di( void )
1527 {
1528 UINT8 t,r;
1529 DIRBYTE(t);
1530 r = A & t;
1531 CLR_NZV;
1532 SET_NZ8(r);
1533 }
1534
1535 /* $96 LDA direct -**0- */
lda_di(void)1536 static INLINE void lda_di( void )
1537 {
1538 DIRBYTE(A);
1539 CLR_NZV;
1540 SET_NZ8(A);
1541 }
1542
1543 /* $97 STA direct -**0- */
sta_di(void)1544 static INLINE void sta_di( void )
1545 {
1546 CLR_NZV;
1547 SET_NZ8(A);
1548 DIRECT;
1549 WM(EAD,A);
1550 }
1551
1552 /* $98 EORA direct -**0- */
eora_di(void)1553 static INLINE void eora_di( void )
1554 {
1555 UINT8 t;
1556 DIRBYTE(t);
1557 A ^= t;
1558 CLR_NZV;
1559 SET_NZ8(A);
1560 }
1561
1562 /* $99 ADCA direct ***** */
adca_di(void)1563 static INLINE void adca_di( void )
1564 {
1565 UINT16 t,r;
1566 DIRBYTE(t);
1567 r = A + t + (CC & CC_C);
1568 CLR_HNZVC;
1569 SET_FLAGS8(A,t,r);
1570 SET_H(A,t,r);
1571 A = r;
1572 }
1573
1574 /* $9A ORA direct -**0- */
ora_di(void)1575 static INLINE void ora_di( void )
1576 {
1577 UINT8 t;
1578 DIRBYTE(t);
1579 A |= t;
1580 CLR_NZV;
1581 SET_NZ8(A);
1582 }
1583
1584 /* $9B ADDA direct ***** */
adda_di(void)1585 static INLINE void adda_di( void )
1586 {
1587 UINT16 t,r;
1588 DIRBYTE(t);
1589 r = A + t;
1590 CLR_HNZVC;
1591 SET_FLAGS8(A,t,r);
1592 SET_H(A,t,r);
1593 A = r;
1594 }
1595
1596 /* $9C CMPX (CMPY CMPS) direct -**** */
cmpx_di(void)1597 static INLINE void cmpx_di( void )
1598 {
1599 UINT32 r,d;
1600 PAIR b;
1601 DIRWORD(b);
1602 d = X;
1603 r = d - b.d;
1604 CLR_NZVC;
1605 SET_FLAGS16(d,b.d,r);
1606 }
1607
1608 /* $109C CMPY direct -**** */
cmpy_di(void)1609 static INLINE void cmpy_di( void )
1610 {
1611 UINT32 r,d;
1612 PAIR b;
1613 DIRWORD(b);
1614 d = Y;
1615 r = d - b.d;
1616 CLR_NZVC;
1617 SET_FLAGS16(d,b.d,r);
1618 }
1619
1620 /* $119C CMPS direct -**** */
cmps_di(void)1621 static INLINE void cmps_di( void )
1622 {
1623 UINT32 r,d;
1624 PAIR b;
1625 DIRWORD(b);
1626 d = S;
1627 r = d - b.d;
1628 CLR_NZVC;
1629 SET_FLAGS16(d,b.d,r);
1630 }
1631
1632 /* $9D JSR direct ----- */
jsr_di(void)1633 static INLINE void jsr_di( void )
1634 {
1635 DIRECT;
1636 PUSHWORD(pPC);
1637 PCD=EAD;
1638 change_pc16(PCD);
1639 }
1640
1641 /* $9E LDX (LDY) direct -**0- */
ldx_di(void)1642 static INLINE void ldx_di( void )
1643 {
1644 DIRWORD(pX);
1645 CLR_NZV;
1646 SET_NZ16(X);
1647 }
1648
1649 /* $109E LDY direct -**0- */
ldy_di(void)1650 static INLINE void ldy_di( void )
1651 {
1652 DIRWORD(pY);
1653 CLR_NZV;
1654 SET_NZ16(Y);
1655 }
1656
1657 /* $9F STX (STY) direct -**0- */
stx_di(void)1658 static INLINE void stx_di( void )
1659 {
1660 CLR_NZV;
1661 SET_NZ16(X);
1662 DIRECT;
1663 WM16(EAD,&pX);
1664 }
1665
1666 /* $109F STY direct -**0- */
sty_di(void)1667 static INLINE void sty_di( void )
1668 {
1669 CLR_NZV;
1670 SET_NZ16(Y);
1671 DIRECT;
1672 WM16(EAD,&pY);
1673 }
1674
1675 #ifdef macintosh
1676 #pragma mark ____Ax____
1677 #endif
1678
1679
1680 /* $a0 SUBA indexed ?**** */
suba_ix(void)1681 static INLINE void suba_ix( void )
1682 {
1683 UINT16 t,r;
1684 t = RM(EAD);
1685 r = A - t;
1686 CLR_NZVC;
1687 SET_FLAGS8(A,t,r);
1688 A = r;
1689 }
1690
1691 /* $a1 CMPA indexed ?**** */
cmpa_ix(void)1692 static INLINE void cmpa_ix( void )
1693 {
1694 UINT16 t,r;
1695 t = RM(EAD);
1696 r = A - t;
1697 CLR_NZVC;
1698 SET_FLAGS8(A,t,r);
1699 }
1700
1701 /* $a2 SBCA indexed ?**** */
sbca_ix(void)1702 static INLINE void sbca_ix( void )
1703 {
1704 UINT16 t,r;
1705 t = RM(EAD);
1706 r = A - t - (CC & CC_C);
1707 CLR_NZVC;
1708 SET_FLAGS8(A,t,r);
1709 A = r;
1710 }
1711
1712 /* $a3 SUBD (CMPD CMPU) indexed -**** */
subd_ix(void)1713 static INLINE void subd_ix( void )
1714 {
1715 UINT32 r,d;
1716 PAIR b;
1717 b.d=RM16(EAD);
1718 d = D;
1719 r = d - b.d;
1720 CLR_NZVC;
1721 SET_FLAGS16(d,b.d,r);
1722 D = r;
1723 }
1724
1725 /* $10a3 CMPD indexed -**** */
cmpd_ix(void)1726 static INLINE void cmpd_ix( void )
1727 {
1728 UINT32 r,d;
1729 PAIR b;
1730 b.d=RM16(EAD);
1731 d = D;
1732 r = d - b.d;
1733 CLR_NZVC;
1734 SET_FLAGS16(d,b.d,r);
1735 }
1736
1737 /* $11a3 CMPU indexed -**** */
cmpu_ix(void)1738 static INLINE void cmpu_ix( void )
1739 {
1740 UINT32 r;
1741 PAIR b;
1742 b.d=RM16(EAD);
1743 r = U - b.d;
1744 CLR_NZVC;
1745 SET_FLAGS16(U,b.d,r);
1746 }
1747
1748 /* $a4 ANDA indexed -**0- */
anda_ix(void)1749 static INLINE void anda_ix( void )
1750 {
1751 A &= RM(EAD);
1752 CLR_NZV;
1753 SET_NZ8(A);
1754 }
1755
1756 /* $a5 BITA indexed -**0- */
bita_ix(void)1757 static INLINE void bita_ix( void )
1758 {
1759 UINT8 r;
1760 r = A & RM(EAD);
1761 CLR_NZV;
1762 SET_NZ8(r);
1763 }
1764
1765 /* $a6 LDA indexed -**0- */
lda_ix(void)1766 static INLINE void lda_ix( void )
1767 {
1768 A = RM(EAD);
1769 CLR_NZV;
1770 SET_NZ8(A);
1771 }
1772
1773 /* $a7 STA indexed -**0- */
sta_ix(void)1774 static INLINE void sta_ix( void )
1775 {
1776 CLR_NZV;
1777 SET_NZ8(A);
1778 WM(EAD,A);
1779 }
1780
1781 /* $a8 EORA indexed -**0- */
eora_ix(void)1782 static INLINE void eora_ix( void )
1783 {
1784 A ^= RM(EAD);
1785 CLR_NZV;
1786 SET_NZ8(A);
1787 }
1788
1789 /* $a9 ADCA indexed ***** */
adca_ix(void)1790 static INLINE void adca_ix( void )
1791 {
1792 UINT16 t,r;
1793 t = RM(EAD);
1794 r = A + t + (CC & CC_C);
1795 CLR_HNZVC;
1796 SET_FLAGS8(A,t,r);
1797 SET_H(A,t,r);
1798 A = r;
1799 }
1800
1801 /* $aA ORA indexed -**0- */
ora_ix(void)1802 static INLINE void ora_ix( void )
1803 {
1804 A |= RM(EAD);
1805 CLR_NZV;
1806 SET_NZ8(A);
1807 }
1808
1809 /* $aB ADDA indexed ***** */
adda_ix(void)1810 static INLINE void adda_ix( void )
1811 {
1812 UINT16 t,r;
1813 t = RM(EAD);
1814 r = A + t;
1815 CLR_HNZVC;
1816 SET_FLAGS8(A,t,r);
1817 SET_H(A,t,r);
1818 A = r;
1819 }
1820
1821 /* $aC CMPX (CMPY CMPS) indexed -**** */
cmpx_ix(void)1822 static INLINE void cmpx_ix( void )
1823 {
1824 UINT32 r,d;
1825 PAIR b;
1826 b.d=RM16(EAD);
1827 d = X;
1828 r = d - b.d;
1829 CLR_NZVC;
1830 SET_FLAGS16(d,b.d,r);
1831 }
1832
1833 /* $10aC CMPY indexed -**** */
cmpy_ix(void)1834 static INLINE void cmpy_ix( void )
1835 {
1836 UINT32 r,d;
1837 PAIR b;
1838 b.d=RM16(EAD);
1839 d = Y;
1840 r = d - b.d;
1841 CLR_NZVC;
1842 SET_FLAGS16(d,b.d,r);
1843 }
1844
1845 /* $11aC CMPS indexed -**** */
cmps_ix(void)1846 static INLINE void cmps_ix( void )
1847 {
1848 UINT32 r,d;
1849 PAIR b;
1850 b.d=RM16(EAD);
1851 d = S;
1852 r = d - b.d;
1853 CLR_NZVC;
1854 SET_FLAGS16(d,b.d,r);
1855 }
1856
1857 /* $aD JSR indexed ----- */
jsr_ix(void)1858 static INLINE void jsr_ix( void )
1859 {
1860 PUSHWORD(pPC);
1861 PCD=EAD;
1862 change_pc16(PCD);
1863 }
1864
1865 /* $aE LDX (LDY) indexed -**0- */
ldx_ix(void)1866 static INLINE void ldx_ix( void )
1867 {
1868 X=RM16(EAD);
1869 CLR_NZV;
1870 SET_NZ16(X);
1871 }
1872
1873 /* $10aE LDY indexed -**0- */
ldy_ix(void)1874 static INLINE void ldy_ix( void )
1875 {
1876 Y=RM16(EAD);
1877 CLR_NZV;
1878 SET_NZ16(Y);
1879 }
1880
1881 /* $aF STX (STY) indexed -**0- */
stx_ix(void)1882 static INLINE void stx_ix( void )
1883 {
1884 CLR_NZV;
1885 SET_NZ16(X);
1886 WM16(EAD,&pX);
1887 }
1888
1889 /* $10aF STY indexed -**0- */
sty_ix(void)1890 static INLINE void sty_ix( void )
1891 {
1892 CLR_NZV;
1893 SET_NZ16(Y);
1894 WM16(EAD,&pY);
1895 }
1896
1897 #ifdef macintosh
1898 #pragma mark ____Bx____
1899 #endif
1900
1901 /* $b0 SUBA extended ?**** */
suba_ex(void)1902 static INLINE void suba_ex( void )
1903 {
1904 UINT16 t,r;
1905 EXTBYTE(t);
1906 r = A - t;
1907 CLR_NZVC;
1908 SET_FLAGS8(A,t,r);
1909 A = r;
1910 }
1911
1912 /* $b1 CMPA extended ?**** */
cmpa_ex(void)1913 static INLINE void cmpa_ex( void )
1914 {
1915 UINT16 t,r;
1916 EXTBYTE(t);
1917 r = A - t;
1918 CLR_NZVC;
1919 SET_FLAGS8(A,t,r);
1920 }
1921
1922 /* $b2 SBCA extended ?**** */
sbca_ex(void)1923 static INLINE void sbca_ex( void )
1924 {
1925 UINT16 t,r;
1926 EXTBYTE(t);
1927 r = A - t - (CC & CC_C);
1928 CLR_NZVC;
1929 SET_FLAGS8(A,t,r);
1930 A = r;
1931 }
1932
1933 /* $b3 SUBD (CMPD CMPU) extended -**** */
subd_ex(void)1934 static INLINE void subd_ex( void )
1935 {
1936 UINT32 r,d;
1937 PAIR b;
1938 EXTWORD(b);
1939 d = D;
1940 r = d - b.d;
1941 CLR_NZVC;
1942 SET_FLAGS16(d,b.d,r);
1943 D = r;
1944 }
1945
1946 /* $10b3 CMPD extended -**** */
cmpd_ex(void)1947 static INLINE void cmpd_ex( void )
1948 {
1949 UINT32 r,d;
1950 PAIR b;
1951 EXTWORD(b);
1952 d = D;
1953 r = d - b.d;
1954 CLR_NZVC;
1955 SET_FLAGS16(d,b.d,r);
1956 }
1957
1958 /* $11b3 CMPU extended -**** */
cmpu_ex(void)1959 static INLINE void cmpu_ex( void )
1960 {
1961 UINT32 r,d;
1962 PAIR b;
1963 EXTWORD(b);
1964 d = U;
1965 r = d - b.d;
1966 CLR_NZVC;
1967 SET_FLAGS16(d,b.d,r);
1968 }
1969
1970 /* $b4 ANDA extended -**0- */
anda_ex(void)1971 static INLINE void anda_ex( void )
1972 {
1973 UINT8 t;
1974 EXTBYTE(t);
1975 A &= t;
1976 CLR_NZV;
1977 SET_NZ8(A);
1978 }
1979
1980 /* $b5 BITA extended -**0- */
bita_ex(void)1981 static INLINE void bita_ex( void )
1982 {
1983 UINT8 t,r;
1984 EXTBYTE(t);
1985 r = A & t;
1986 CLR_NZV; SET_NZ8(r);
1987 }
1988
1989 /* $b6 LDA extended -**0- */
lda_ex(void)1990 static INLINE void lda_ex( void )
1991 {
1992 EXTBYTE(A);
1993 CLR_NZV;
1994 SET_NZ8(A);
1995 }
1996
1997 /* $b7 STA extended -**0- */
sta_ex(void)1998 static INLINE void sta_ex( void )
1999 {
2000 CLR_NZV;
2001 SET_NZ8(A);
2002 EXTENDED;
2003 WM(EAD,A);
2004 }
2005
2006 /* $b8 EORA extended -**0- */
eora_ex(void)2007 static INLINE void eora_ex( void )
2008 {
2009 UINT8 t;
2010 EXTBYTE(t);
2011 A ^= t;
2012 CLR_NZV;
2013 SET_NZ8(A);
2014 }
2015
2016 /* $b9 ADCA extended ***** */
adca_ex(void)2017 static INLINE void adca_ex( void )
2018 {
2019 UINT16 t,r;
2020 EXTBYTE(t);
2021 r = A + t + (CC & CC_C);
2022 CLR_HNZVC;
2023 SET_FLAGS8(A,t,r);
2024 SET_H(A,t,r);
2025 A = r;
2026 }
2027
2028 /* $bA ORA extended -**0- */
ora_ex(void)2029 static INLINE void ora_ex( void )
2030 {
2031 UINT8 t;
2032 EXTBYTE(t);
2033 A |= t;
2034 CLR_NZV;
2035 SET_NZ8(A);
2036 }
2037
2038 /* $bB ADDA extended ***** */
adda_ex(void)2039 static INLINE void adda_ex( void )
2040 {
2041 UINT16 t,r;
2042 EXTBYTE(t);
2043 r = A + t;
2044 CLR_HNZVC;
2045 SET_FLAGS8(A,t,r);
2046 SET_H(A,t,r);
2047 A = r;
2048 }
2049
2050 /* $bC CMPX (CMPY CMPS) extended -**** */
cmpx_ex(void)2051 static INLINE void cmpx_ex( void )
2052 {
2053 UINT32 r,d;
2054 PAIR b;
2055 EXTWORD(b);
2056 d = X;
2057 r = d - b.d;
2058 CLR_NZVC;
2059 SET_FLAGS16(d,b.d,r);
2060 }
2061
2062 /* $10bC CMPY extended -**** */
cmpy_ex(void)2063 static INLINE void cmpy_ex( void )
2064 {
2065 UINT32 r,d;
2066 PAIR b;
2067 EXTWORD(b);
2068 d = Y;
2069 r = d - b.d;
2070 CLR_NZVC;
2071 SET_FLAGS16(d,b.d,r);
2072 }
2073
2074 /* $11bC CMPS extended -**** */
cmps_ex(void)2075 static INLINE void cmps_ex( void )
2076 {
2077 UINT32 r,d;
2078 PAIR b;
2079 EXTWORD(b);
2080 d = S;
2081 r = d - b.d;
2082 CLR_NZVC;
2083 SET_FLAGS16(d,b.d,r);
2084 }
2085
2086 /* $bD JSR extended ----- */
jsr_ex(void)2087 static INLINE void jsr_ex( void )
2088 {
2089 EXTENDED;
2090 PUSHWORD(pPC);
2091 PCD=EAD;
2092 change_pc16(PCD);
2093 }
2094
2095 /* $bE LDX (LDY) extended -**0- */
ldx_ex(void)2096 static INLINE void ldx_ex( void )
2097 {
2098 EXTWORD(pX);
2099 CLR_NZV;
2100 SET_NZ16(X);
2101 }
2102
2103 /* $10bE LDY extended -**0- */
ldy_ex(void)2104 static INLINE void ldy_ex( void )
2105 {
2106 EXTWORD(pY);
2107 CLR_NZV;
2108 SET_NZ16(Y);
2109 }
2110
2111 /* $bF STX (STY) extended -**0- */
stx_ex(void)2112 static INLINE void stx_ex( void )
2113 {
2114 CLR_NZV;
2115 SET_NZ16(X);
2116 EXTENDED;
2117 WM16(EAD,&pX);
2118 }
2119
2120 /* $10bF STY extended -**0- */
sty_ex(void)2121 static INLINE void sty_ex( void )
2122 {
2123 CLR_NZV;
2124 SET_NZ16(Y);
2125 EXTENDED;
2126 WM16(EAD,&pY);
2127 }
2128
2129
2130 #ifdef macintosh
2131 #pragma mark ____Cx____
2132 #endif
2133
2134 /* $c0 SUBB immediate ?**** */
subb_im(void)2135 static INLINE void subb_im( void )
2136 {
2137 UINT16 t,r;
2138 IMMBYTE(t);
2139 r = B - t;
2140 CLR_NZVC;
2141 SET_FLAGS8(B,t,r);
2142 B = r;
2143 }
2144
2145 /* $c1 CMPB immediate ?**** */
cmpb_im(void)2146 static INLINE void cmpb_im( void )
2147 {
2148 UINT16 t,r;
2149 IMMBYTE(t);
2150 r = B - t;
2151 CLR_NZVC; SET_FLAGS8(B,t,r);
2152 }
2153
2154 /* $c2 SBCB immediate ?**** */
sbcb_im(void)2155 static INLINE void sbcb_im( void )
2156 {
2157 UINT16 t,r;
2158 IMMBYTE(t);
2159 r = B - t - (CC & CC_C);
2160 CLR_NZVC;
2161 SET_FLAGS8(B,t,r);
2162 B = r;
2163 }
2164
2165 /* $c3 ADDD immediate -**** */
addd_im(void)2166 static INLINE void addd_im( void )
2167 {
2168 UINT32 r,d;
2169 PAIR b;
2170 IMMWORD(b);
2171 d = D;
2172 r = d + b.d;
2173 CLR_NZVC;
2174 SET_FLAGS16(d,b.d,r);
2175 D = r;
2176 }
2177
2178 /* $c4 ANDB immediate -**0- */
andb_im(void)2179 static INLINE void andb_im( void )
2180 {
2181 UINT8 t;
2182 IMMBYTE(t);
2183 B &= t;
2184 CLR_NZV;
2185 SET_NZ8(B);
2186 }
2187
2188 /* $c5 BITB immediate -**0- */
bitb_im(void)2189 static INLINE void bitb_im( void )
2190 {
2191 UINT8 t,r;
2192 IMMBYTE(t);
2193 r = B & t;
2194 CLR_NZV;
2195 SET_NZ8(r);
2196 }
2197
2198 /* $c6 LDB immediate -**0- */
ldb_im(void)2199 static INLINE void ldb_im( void )
2200 {
2201 IMMBYTE(B);
2202 CLR_NZV;
2203 SET_NZ8(B);
2204 }
2205
2206 /* is this a legal instruction? */
2207 /* $c7 STB immediate -**0- */
stb_im(void)2208 static INLINE void stb_im( void )
2209 {
2210 CLR_NZV;
2211 SET_NZ8(B);
2212 IMM8;
2213 WM(EAD,B);
2214 }
2215
2216 /* $c8 EORB immediate -**0- */
eorb_im(void)2217 static INLINE void eorb_im( void )
2218 {
2219 UINT8 t;
2220 IMMBYTE(t);
2221 B ^= t;
2222 CLR_NZV;
2223 SET_NZ8(B);
2224 }
2225
2226 /* $c9 ADCB immediate ***** */
adcb_im(void)2227 static INLINE void adcb_im( void )
2228 {
2229 UINT16 t,r;
2230 IMMBYTE(t);
2231 r = B + t + (CC & CC_C);
2232 CLR_HNZVC;
2233 SET_FLAGS8(B,t,r);
2234 SET_H(B,t,r);
2235 B = r;
2236 }
2237
2238 /* $cA ORB immediate -**0- */
orb_im(void)2239 static INLINE void orb_im( void )
2240 {
2241 UINT8 t;
2242 IMMBYTE(t);
2243 B |= t;
2244 CLR_NZV;
2245 SET_NZ8(B);
2246 }
2247
2248 /* $cB ADDB immediate ***** */
addb_im(void)2249 static INLINE void addb_im( void )
2250 {
2251 UINT16 t,r;
2252 IMMBYTE(t);
2253 r = B + t;
2254 CLR_HNZVC;
2255 SET_FLAGS8(B,t,r);
2256 SET_H(B,t,r);
2257 B = r;
2258 }
2259
2260 /* $cC LDD immediate -**0- */
ldd_im(void)2261 static INLINE void ldd_im( void )
2262 {
2263 IMMWORD(pD);
2264 CLR_NZV;
2265 SET_NZ16(D);
2266 }
2267
2268 /* is this a legal instruction? */
2269 /* $cD STD immediate -**0- */
std_im(void)2270 static INLINE void std_im( void )
2271 {
2272 CLR_NZV;
2273 SET_NZ16(D);
2274 IMM16;
2275 WM16(EAD,&pD);
2276 }
2277
2278 /* $cE LDU (LDS) immediate -**0- */
ldu_im(void)2279 static INLINE void ldu_im( void )
2280 {
2281 IMMWORD(pU);
2282 CLR_NZV;
2283 SET_NZ16(U);
2284 }
2285
2286 /* $10cE LDS immediate -**0- */
lds_im(void)2287 static INLINE void lds_im( void )
2288 {
2289 IMMWORD(pS);
2290 CLR_NZV;
2291 SET_NZ16(S);
2292 konami.int_state |= KONAMI_LDS;
2293 }
2294
2295 /* is this a legal instruction? */
2296 /* $cF STU (STS) immediate -**0- */
stu_im(void)2297 static INLINE void stu_im( void )
2298 {
2299 CLR_NZV;
2300 SET_NZ16(U);
2301 IMM16;
2302 WM16(EAD,&pU);
2303 }
2304
2305 /* is this a legal instruction? */
2306 /* $10cF STS immediate -**0- */
sts_im(void)2307 static INLINE void sts_im( void )
2308 {
2309 CLR_NZV;
2310 SET_NZ16(S);
2311 IMM16;
2312 WM16(EAD,&pS);
2313 }
2314
2315
2316 #ifdef macintosh
2317 #pragma mark ____Dx____
2318 #endif
2319
2320 /* $d0 SUBB direct ?**** */
subb_di(void)2321 static INLINE void subb_di( void )
2322 {
2323 UINT16 t,r;
2324 DIRBYTE(t);
2325 r = B - t;
2326 CLR_NZVC;
2327 SET_FLAGS8(B,t,r);
2328 B = r;
2329 }
2330
2331 /* $d1 CMPB direct ?**** */
cmpb_di(void)2332 static INLINE void cmpb_di( void )
2333 {
2334 UINT16 t,r;
2335 DIRBYTE(t);
2336 r = B - t;
2337 CLR_NZVC;
2338 SET_FLAGS8(B,t,r);
2339 }
2340
2341 /* $d2 SBCB direct ?**** */
sbcb_di(void)2342 static INLINE void sbcb_di( void )
2343 {
2344 UINT16 t,r;
2345 DIRBYTE(t);
2346 r = B - t - (CC & CC_C);
2347 CLR_NZVC;
2348 SET_FLAGS8(B,t,r);
2349 B = r;
2350 }
2351
2352 /* $d3 ADDD direct -**** */
addd_di(void)2353 static INLINE void addd_di( void )
2354 {
2355 UINT32 r,d;
2356 PAIR b;
2357 DIRWORD(b);
2358 d = D;
2359 r = d + b.d;
2360 CLR_NZVC;
2361 SET_FLAGS16(d,b.d,r);
2362 D = r;
2363 }
2364
2365 /* $d4 ANDB direct -**0- */
andb_di(void)2366 static INLINE void andb_di( void )
2367 {
2368 UINT8 t;
2369 DIRBYTE(t);
2370 B &= t;
2371 CLR_NZV;
2372 SET_NZ8(B);
2373 }
2374
2375 /* $d5 BITB direct -**0- */
bitb_di(void)2376 static INLINE void bitb_di( void )
2377 {
2378 UINT8 t,r;
2379 DIRBYTE(t);
2380 r = B & t;
2381 CLR_NZV;
2382 SET_NZ8(r);
2383 }
2384
2385 /* $d6 LDB direct -**0- */
ldb_di(void)2386 static INLINE void ldb_di( void )
2387 {
2388 DIRBYTE(B);
2389 CLR_NZV;
2390 SET_NZ8(B);
2391 }
2392
2393 /* $d7 STB direct -**0- */
stb_di(void)2394 static INLINE void stb_di( void )
2395 {
2396 CLR_NZV;
2397 SET_NZ8(B);
2398 DIRECT;
2399 WM(EAD,B);
2400 }
2401
2402 /* $d8 EORB direct -**0- */
eorb_di(void)2403 static INLINE void eorb_di( void )
2404 {
2405 UINT8 t;
2406 DIRBYTE(t);
2407 B ^= t;
2408 CLR_NZV;
2409 SET_NZ8(B);
2410 }
2411
2412 /* $d9 ADCB direct ***** */
adcb_di(void)2413 static INLINE void adcb_di( void )
2414 {
2415 UINT16 t,r;
2416 DIRBYTE(t);
2417 r = B + t + (CC & CC_C);
2418 CLR_HNZVC;
2419 SET_FLAGS8(B,t,r);
2420 SET_H(B,t,r);
2421 B = r;
2422 }
2423
2424 /* $dA ORB direct -**0- */
orb_di(void)2425 static INLINE void orb_di( void )
2426 {
2427 UINT8 t;
2428 DIRBYTE(t);
2429 B |= t;
2430 CLR_NZV;
2431 SET_NZ8(B);
2432 }
2433
2434 /* $dB ADDB direct ***** */
addb_di(void)2435 static INLINE void addb_di( void )
2436 {
2437 UINT16 t,r;
2438 DIRBYTE(t);
2439 r = B + t;
2440 CLR_HNZVC;
2441 SET_FLAGS8(B,t,r);
2442 SET_H(B,t,r);
2443 B = r;
2444 }
2445
2446 /* $dC LDD direct -**0- */
ldd_di(void)2447 static INLINE void ldd_di( void )
2448 {
2449 DIRWORD(pD);
2450 CLR_NZV;
2451 SET_NZ16(D);
2452 }
2453
2454 /* $dD STD direct -**0- */
std_di(void)2455 static INLINE void std_di( void )
2456 {
2457 CLR_NZV;
2458 SET_NZ16(D);
2459 DIRECT;
2460 WM16(EAD,&pD);
2461 }
2462
2463 /* $dE LDU (LDS) direct -**0- */
ldu_di(void)2464 static INLINE void ldu_di( void )
2465 {
2466 DIRWORD(pU);
2467 CLR_NZV;
2468 SET_NZ16(U);
2469 }
2470
2471 /* $10dE LDS direct -**0- */
lds_di(void)2472 static INLINE void lds_di( void )
2473 {
2474 DIRWORD(pS);
2475 CLR_NZV;
2476 SET_NZ16(S);
2477 konami.int_state |= KONAMI_LDS;
2478 }
2479
2480 /* $dF STU (STS) direct -**0- */
stu_di(void)2481 static INLINE void stu_di( void )
2482 {
2483 CLR_NZV;
2484 SET_NZ16(U);
2485 DIRECT;
2486 WM16(EAD,&pU);
2487 }
2488
2489 /* $10dF STS direct -**0- */
sts_di(void)2490 static INLINE void sts_di( void )
2491 {
2492 CLR_NZV;
2493 SET_NZ16(S);
2494 DIRECT;
2495 WM16(EAD,&pS);
2496 }
2497
2498 #ifdef macintosh
2499 #pragma mark ____Ex____
2500 #endif
2501
2502
2503 /* $e0 SUBB indexed ?**** */
subb_ix(void)2504 static INLINE void subb_ix( void )
2505 {
2506 UINT16 t,r;
2507 t = RM(EAD);
2508 r = B - t;
2509 CLR_NZVC;
2510 SET_FLAGS8(B,t,r);
2511 B = r;
2512 }
2513
2514 /* $e1 CMPB indexed ?**** */
cmpb_ix(void)2515 static INLINE void cmpb_ix( void )
2516 {
2517 UINT16 t,r;
2518 t = RM(EAD);
2519 r = B - t;
2520 CLR_NZVC;
2521 SET_FLAGS8(B,t,r);
2522 }
2523
2524 /* $e2 SBCB indexed ?**** */
sbcb_ix(void)2525 static INLINE void sbcb_ix( void )
2526 {
2527 UINT16 t,r;
2528 t = RM(EAD);
2529 r = B - t - (CC & CC_C);
2530 CLR_NZVC;
2531 SET_FLAGS8(B,t,r);
2532 B = r;
2533 }
2534
2535 /* $e3 ADDD indexed -**** */
addd_ix(void)2536 static INLINE void addd_ix( void )
2537 {
2538 UINT32 r,d;
2539 PAIR b;
2540 b.d=RM16(EAD);
2541 d = D;
2542 r = d + b.d;
2543 CLR_NZVC;
2544 SET_FLAGS16(d,b.d,r);
2545 D = r;
2546 }
2547
2548 /* $e4 ANDB indexed -**0- */
andb_ix(void)2549 static INLINE void andb_ix( void )
2550 {
2551 B &= RM(EAD);
2552 CLR_NZV;
2553 SET_NZ8(B);
2554 }
2555
2556 /* $e5 BITB indexed -**0- */
bitb_ix(void)2557 static INLINE void bitb_ix( void )
2558 {
2559 UINT8 r;
2560 r = B & RM(EAD);
2561 CLR_NZV;
2562 SET_NZ8(r);
2563 }
2564
2565 /* $e6 LDB indexed -**0- */
ldb_ix(void)2566 static INLINE void ldb_ix( void )
2567 {
2568 B = RM(EAD);
2569 CLR_NZV;
2570 SET_NZ8(B);
2571 }
2572
2573 /* $e7 STB indexed -**0- */
stb_ix(void)2574 static INLINE void stb_ix( void )
2575 {
2576 CLR_NZV;
2577 SET_NZ8(B);
2578 WM(EAD,B);
2579 }
2580
2581 /* $e8 EORB indexed -**0- */
eorb_ix(void)2582 static INLINE void eorb_ix( void )
2583 {
2584 B ^= RM(EAD);
2585 CLR_NZV;
2586 SET_NZ8(B);
2587 }
2588
2589 /* $e9 ADCB indexed ***** */
adcb_ix(void)2590 static INLINE void adcb_ix( void )
2591 {
2592 UINT16 t,r;
2593 t = RM(EAD);
2594 r = B + t + (CC & CC_C);
2595 CLR_HNZVC;
2596 SET_FLAGS8(B,t,r);
2597 SET_H(B,t,r);
2598 B = r;
2599 }
2600
2601 /* $eA ORB indexed -**0- */
orb_ix(void)2602 static INLINE void orb_ix( void )
2603 {
2604 B |= RM(EAD);
2605 CLR_NZV;
2606 SET_NZ8(B);
2607 }
2608
2609 /* $eb ADDB indexed ***** */
addb_ix(void)2610 static INLINE void addb_ix( void )
2611 {
2612 UINT16 t,r;
2613 t = RM(EAD);
2614 r = B + t;
2615 CLR_HNZVC;
2616 SET_FLAGS8(B,t,r);
2617 SET_H(B,t,r);
2618 B = r;
2619 }
2620
2621 /* $ec LDD indexed -**0- */
ldd_ix(void)2622 static INLINE void ldd_ix( void )
2623 {
2624 D=RM16(EAD);
2625 CLR_NZV; SET_NZ16(D);
2626 }
2627
2628 /* $eD STD indexed -**0- */
std_ix(void)2629 static INLINE void std_ix( void )
2630 {
2631 CLR_NZV;
2632 SET_NZ16(D);
2633 WM16(EAD,&pD);
2634 }
2635
2636 /* $eE LDU (LDS) indexed -**0- */
ldu_ix(void)2637 static INLINE void ldu_ix( void )
2638 {
2639 U=RM16(EAD);
2640 CLR_NZV;
2641 SET_NZ16(U);
2642 }
2643
2644 /* $10eE LDS indexed -**0- */
lds_ix(void)2645 static INLINE void lds_ix( void )
2646 {
2647 S=RM16(EAD);
2648 CLR_NZV;
2649 SET_NZ16(S);
2650 konami.int_state |= KONAMI_LDS;
2651 }
2652
2653 /* $eF STU (STS) indexed -**0- */
stu_ix(void)2654 static INLINE void stu_ix( void )
2655 {
2656 CLR_NZV;
2657 SET_NZ16(U);
2658 WM16(EAD,&pU);
2659 }
2660
2661 /* $10eF STS indexed -**0- */
sts_ix(void)2662 static INLINE void sts_ix( void )
2663 {
2664 CLR_NZV;
2665 SET_NZ16(S);
2666 WM16(EAD,&pS);
2667 }
2668
2669 #ifdef macintosh
2670 #pragma mark ____Fx____
2671 #endif
2672
2673 /* $f0 SUBB extended ?**** */
subb_ex(void)2674 static INLINE void subb_ex( void )
2675 {
2676 UINT16 t,r;
2677 EXTBYTE(t);
2678 r = B - t;
2679 CLR_NZVC;
2680 SET_FLAGS8(B,t,r);
2681 B = r;
2682 }
2683
2684 /* $f1 CMPB extended ?**** */
cmpb_ex(void)2685 static INLINE void cmpb_ex( void )
2686 {
2687 UINT16 t,r;
2688 EXTBYTE(t);
2689 r = B - t;
2690 CLR_NZVC;
2691 SET_FLAGS8(B,t,r);
2692 }
2693
2694 /* $f2 SBCB extended ?**** */
sbcb_ex(void)2695 static INLINE void sbcb_ex( void )
2696 {
2697 UINT16 t,r;
2698 EXTBYTE(t);
2699 r = B - t - (CC & CC_C);
2700 CLR_NZVC;
2701 SET_FLAGS8(B,t,r);
2702 B = r;
2703 }
2704
2705 /* $f3 ADDD extended -**** */
addd_ex(void)2706 static INLINE void addd_ex( void )
2707 {
2708 UINT32 r,d;
2709 PAIR b;
2710 EXTWORD(b);
2711 d = D;
2712 r = d + b.d;
2713 CLR_NZVC;
2714 SET_FLAGS16(d,b.d,r);
2715 D = r;
2716 }
2717
2718 /* $f4 ANDB extended -**0- */
andb_ex(void)2719 static INLINE void andb_ex( void )
2720 {
2721 UINT8 t;
2722 EXTBYTE(t);
2723 B &= t;
2724 CLR_NZV;
2725 SET_NZ8(B);
2726 }
2727
2728 /* $f5 BITB extended -**0- */
bitb_ex(void)2729 static INLINE void bitb_ex( void )
2730 {
2731 UINT8 t,r;
2732 EXTBYTE(t);
2733 r = B & t;
2734 CLR_NZV;
2735 SET_NZ8(r);
2736 }
2737
2738 /* $f6 LDB extended -**0- */
ldb_ex(void)2739 static INLINE void ldb_ex( void )
2740 {
2741 EXTBYTE(B);
2742 CLR_NZV;
2743 SET_NZ8(B);
2744 }
2745
2746 /* $f7 STB extended -**0- */
stb_ex(void)2747 static INLINE void stb_ex( void )
2748 {
2749 CLR_NZV;
2750 SET_NZ8(B);
2751 EXTENDED;
2752 WM(EAD,B);
2753 }
2754
2755 /* $f8 EORB extended -**0- */
eorb_ex(void)2756 static INLINE void eorb_ex( void )
2757 {
2758 UINT8 t;
2759 EXTBYTE(t);
2760 B ^= t;
2761 CLR_NZV;
2762 SET_NZ8(B);
2763 }
2764
2765 /* $f9 ADCB extended ***** */
adcb_ex(void)2766 static INLINE void adcb_ex( void )
2767 {
2768 UINT16 t,r;
2769 EXTBYTE(t);
2770 r = B + t + (CC & CC_C);
2771 CLR_HNZVC;
2772 SET_FLAGS8(B,t,r);
2773 SET_H(B,t,r);
2774 B = r;
2775 }
2776
2777 /* $fA ORB extended -**0- */
orb_ex(void)2778 static INLINE void orb_ex( void )
2779 {
2780 UINT8 t;
2781 EXTBYTE(t);
2782 B |= t;
2783 CLR_NZV;
2784 SET_NZ8(B);
2785 }
2786
2787 /* $fB ADDB extended ***** */
addb_ex(void)2788 static INLINE void addb_ex( void )
2789 {
2790 UINT16 t,r;
2791 EXTBYTE(t);
2792 r = B + t;
2793 CLR_HNZVC;
2794 SET_FLAGS8(B,t,r);
2795 SET_H(B,t,r);
2796 B = r;
2797 }
2798
2799 /* $fC LDD extended -**0- */
ldd_ex(void)2800 static INLINE void ldd_ex( void )
2801 {
2802 EXTWORD(pD);
2803 CLR_NZV;
2804 SET_NZ16(D);
2805 }
2806
2807 /* $fD STD extended -**0- */
std_ex(void)2808 static INLINE void std_ex( void )
2809 {
2810 CLR_NZV;
2811 SET_NZ16(D);
2812 EXTENDED;
2813 WM16(EAD,&pD);
2814 }
2815
2816 /* $fE LDU (LDS) extended -**0- */
ldu_ex(void)2817 static INLINE void ldu_ex( void )
2818 {
2819 EXTWORD(pU);
2820 CLR_NZV;
2821 SET_NZ16(U);
2822 }
2823
2824 /* $10fE LDS extended -**0- */
lds_ex(void)2825 static INLINE void lds_ex( void )
2826 {
2827 EXTWORD(pS);
2828 CLR_NZV;
2829 SET_NZ16(S);
2830 konami.int_state |= KONAMI_LDS;
2831 }
2832
2833 /* $fF STU (STS) extended -**0- */
stu_ex(void)2834 static INLINE void stu_ex( void )
2835 {
2836 CLR_NZV;
2837 SET_NZ16(U);
2838 EXTENDED;
2839 WM16(EAD,&pU);
2840 }
2841
2842 /* $10fF STS extended -**0- */
sts_ex(void)2843 static INLINE void sts_ex( void )
2844 {
2845 CLR_NZV;
2846 SET_NZ16(S);
2847 EXTENDED;
2848 WM16(EAD,&pS);
2849 }
2850
setline_im(void)2851 static INLINE void setline_im( void )
2852 {
2853 UINT8 t;
2854 IMMBYTE(t);
2855
2856 if ( konami_cpu_setlines_callback )
2857 (*konami_cpu_setlines_callback)( t );
2858 }
2859
setline_ix(void)2860 static INLINE void setline_ix( void )
2861 {
2862 UINT8 t;
2863 t = RM(EA);
2864
2865 if ( konami_cpu_setlines_callback )
2866 (*konami_cpu_setlines_callback)( t );
2867 }
2868
setline_di(void)2869 static INLINE void setline_di( void )
2870 {
2871 UINT8 t;
2872 DIRBYTE(t);
2873
2874 if ( konami_cpu_setlines_callback )
2875 (*konami_cpu_setlines_callback)( t );
2876 }
2877
setline_ex(void)2878 static INLINE void setline_ex( void )
2879 {
2880 UINT8 t;
2881 EXTBYTE(t);
2882
2883 if ( konami_cpu_setlines_callback )
2884 (*konami_cpu_setlines_callback)( t );
2885 }
2886
bmove(void)2887 static INLINE void bmove( void )
2888 {
2889 UINT8 t;
2890
2891 while( U != 0 ) {
2892 t = RM(Y);
2893 WM(X,t);
2894 Y++;
2895 X++;
2896 U--;
2897 konami_ICount -= 2;
2898 }
2899 }
2900
move(void)2901 static INLINE void move( void )
2902 {
2903 UINT8 t;
2904
2905 t = RM(Y);
2906 WM(X,t);
2907 Y++;
2908 X++;
2909 U--;
2910 }
2911
2912 /* CLRD inherent -0100 */
clrd(void)2913 static INLINE void clrd( void )
2914 {
2915 D = 0;
2916 CLR_NZVC; SEZ;
2917 }
2918
2919 /* CLRW indexed -0100 */
clrw_ix(void)2920 static INLINE void clrw_ix( void )
2921 {
2922 PAIR t;
2923 t.d = 0;
2924 WM16(EAD,&t);
2925 CLR_NZVC; SEZ;
2926 }
2927
2928 /* CLRW direct -0100 */
clrw_di(void)2929 static INLINE void clrw_di( void )
2930 {
2931 PAIR t;
2932 t.d = 0;
2933 DIRECT;
2934 WM16(EAD,&t);
2935 CLR_NZVC;
2936 SEZ;
2937 }
2938
2939 /* CLRW extended -0100 */
clrw_ex(void)2940 static INLINE void clrw_ex( void )
2941 {
2942 PAIR t;
2943 t.d = 0;
2944 EXTENDED;
2945 WM16(EAD,&t);
2946 CLR_NZVC; SEZ;
2947 }
2948
2949 /* LSRD immediate -0*-* */
lsrd(void)2950 static INLINE void lsrd( void )
2951 {
2952 UINT8 t;
2953
2954 IMMBYTE( t );
2955
2956 while ( t-- ) {
2957 CLR_NZC;
2958 CC |= (D & CC_C);
2959 D >>= 1;
2960 SET_Z16(D);
2961 }
2962 }
2963
2964 /* RORD immediate -**-* */
rord(void)2965 static INLINE void rord( void )
2966 {
2967 UINT16 r;
2968 UINT8 t;
2969
2970 IMMBYTE(t);
2971
2972 while ( t-- ) {
2973 r = (CC & CC_C) << 15;
2974 CLR_NZC;
2975 CC |= (D & CC_C);
2976 r |= D >> 1;
2977 SET_NZ16(r);
2978 D = r;
2979 }
2980 }
2981
2982 /* ASRD immediate ?**-* */
asrd(void)2983 static INLINE void asrd( void )
2984 {
2985 UINT8 t;
2986
2987 IMMBYTE(t);
2988
2989 while ( t-- ) {
2990 CLR_NZC;
2991 CC |= (D & CC_C);
2992 D = (D & 0x8000) | (D >> 1);
2993 SET_NZ16(D);
2994 }
2995 }
2996
2997 /* ASLD immediate ?**** */
asld(void)2998 static INLINE void asld( void )
2999 {
3000 UINT32 r;
3001 UINT8 t;
3002
3003 IMMBYTE( t );
3004
3005 while ( t-- ) {
3006 r = D << 1;
3007 CLR_NZVC;
3008 SET_FLAGS16(D,D,r);
3009 D = r;
3010 }
3011 }
3012
3013 /* ROLD immediate -**-* */
rold(void)3014 static INLINE void rold( void )
3015 {
3016 UINT16 r;
3017 UINT8 t;
3018
3019 IMMBYTE(t);
3020
3021 while ( t-- ) {
3022 CLR_NZC;
3023 if ( D & 0x8000 ) SEC;
3024 r = CC & CC_C;
3025 r |= D << 1;
3026 SET_NZ16(r);
3027 D = r;
3028 }
3029 }
3030
3031 /* DECB,JNZ relative ----- */
decbjnz(void)3032 static INLINE void decbjnz( void )
3033 {
3034 --B;
3035 CLR_NZV;
3036 SET_FLAGS8D(B);
3037 BRANCH( !(CC&CC_Z) );
3038 }
3039
3040 /* DECX,JNZ relative ----- */
decxjnz(void)3041 static INLINE void decxjnz( void )
3042 {
3043 --X;
3044 CLR_NZV;
3045 SET_NZ16(X); /* should affect V as well? */
3046 BRANCH( !(CC&CC_Z) );
3047 }
3048
bset(void)3049 static INLINE void bset( void )
3050 {
3051 UINT8 t;
3052
3053 while( U != 0 ) {
3054 t = A;
3055 WM(XD,t);
3056 X++;
3057 U--;
3058 konami_ICount -= 2;
3059 }
3060 }
3061
bset2(void)3062 static INLINE void bset2( void )
3063 {
3064 while( U != 0 ) {
3065 WM16(XD,&pD);
3066 X += 2;
3067 U--;
3068 konami_ICount -= 3;
3069 }
3070 }
3071
3072 /* LMUL inherent --*-@ */
lmul(void)3073 static INLINE void lmul( void )
3074 {
3075 UINT32 t;
3076 t = X * Y;
3077 X = (t >> 16);
3078 Y = (t & 0xffff);
3079 CLR_ZC; SET_Z(t); if( t & 0x8000 ) SEC;
3080 }
3081
3082 /* DIVX inherent --*-@ */
divx(void)3083 static INLINE void divx( void )
3084 {
3085 UINT16 t;
3086 UINT8 r;
3087 if ( B != 0 )
3088 {
3089 t = X / B;
3090 r = X % B;
3091 }
3092 else
3093 {
3094 /* ?? */
3095 t = 0;
3096 r = 0;
3097 }
3098 CLR_ZC; SET_Z16(t); if ( t & 0x80 ) SEC;
3099 X = t;
3100 B = r;
3101 }
3102
3103 /* INCD inherent -***- */
incd(void)3104 static INLINE void incd( void )
3105 {
3106 UINT32 r;
3107 r = D + 1;
3108 CLR_NZV;
3109 SET_FLAGS16(D,D,r);
3110 D = r;
3111 }
3112
3113 /* INCW direct -***- */
incw_di(void)3114 static INLINE void incw_di( void )
3115 {
3116 PAIR t,r;
3117 DIRWORD(t);
3118 r = t;
3119 ++r.d;
3120 CLR_NZV;
3121 SET_FLAGS16(t.d, t.d, r.d);;
3122 WM16(EAD,&r);
3123 }
3124
3125 /* INCW indexed -***- */
incw_ix(void)3126 static INLINE void incw_ix( void )
3127 {
3128 PAIR t,r;
3129 t.d=RM16(EAD);
3130 r = t;
3131 ++r.d;
3132 CLR_NZV;
3133 SET_FLAGS16(t.d, t.d, r.d);
3134 WM16(EAD,&r);
3135 }
3136
3137 /* INCW extended -***- */
incw_ex(void)3138 static INLINE void incw_ex( void )
3139 {
3140 PAIR t, r;
3141 EXTWORD(t);
3142 r = t;
3143 ++r.d;
3144 CLR_NZV; SET_FLAGS16(t.d,t.d,r.d);
3145 WM16(EAD,&r);
3146 }
3147
3148 /* DECD inherent -***- */
decd(void)3149 static INLINE void decd( void )
3150 {
3151 UINT32 r;
3152 r = D - 1;
3153 CLR_NZV;
3154 SET_FLAGS16(D,D,r);
3155 D = r;
3156 }
3157
3158 /* DECW direct -***- */
decw_di(void)3159 static INLINE void decw_di( void )
3160 {
3161 PAIR t,r;
3162 DIRWORD(t);
3163 r = t;
3164 --r.d;
3165 CLR_NZV;
3166 SET_FLAGS16(t.d, t.d, r.d);;
3167 WM16(EAD,&r);
3168 }
3169
3170 /* DECW indexed -***- */
decw_ix(void)3171 static INLINE void decw_ix( void )
3172 {
3173 PAIR t, r;
3174 t.d=RM16(EAD);
3175 r = t;
3176 --r.d;
3177 CLR_NZV; SET_FLAGS16(t.d, t.d, r.d);
3178 WM16(EAD,&r);
3179 }
3180
3181 /* DECW extended -***- */
decw_ex(void)3182 static INLINE void decw_ex( void )
3183 {
3184 PAIR t, r;
3185 EXTWORD(t);
3186 r = t;
3187 --r.d;
3188 CLR_NZV; SET_FLAGS16(t.d,t.d,r.d);
3189 WM16(EAD,&r);
3190 }
3191
3192 /* TSTD inherent -**0- */
tstd(void)3193 static INLINE void tstd( void )
3194 {
3195 CLR_NZV;
3196 SET_NZ16(D);
3197 }
3198
3199 /* TSTW direct -**0- */
tstw_di(void)3200 static INLINE void tstw_di( void )
3201 {
3202 PAIR t;
3203 CLR_NZV;
3204 DIRWORD(t);
3205 SET_NZ16(t.d);
3206 }
3207
3208 /* TSTW indexed -**0- */
tstw_ix(void)3209 static INLINE void tstw_ix( void )
3210 {
3211 PAIR t;
3212 CLR_NZV;
3213 t.d=RM16(EAD);
3214 SET_NZ16(t.d);
3215 }
3216
3217 /* TSTW extended -**0- */
tstw_ex(void)3218 static INLINE void tstw_ex( void )
3219 {
3220 PAIR t;
3221 CLR_NZV;
3222 EXTWORD(t);
3223 SET_NZ16(t.d);
3224 }
3225
3226 /* LSRW direct -0*-* */
lsrw_di(void)3227 static INLINE void lsrw_di( void )
3228 {
3229 PAIR t;
3230 DIRWORD(t);
3231 CLR_NZC;
3232 CC |= (t.d & CC_C);
3233 t.d >>= 1;
3234 SET_Z16(t.d);
3235 WM16(EAD,&t);
3236 }
3237
3238 /* LSRW indexed -0*-* */
lsrw_ix(void)3239 static INLINE void lsrw_ix( void )
3240 {
3241 PAIR t;
3242 t.d=RM16(EAD);
3243 CLR_NZC;
3244 CC |= (t.d & CC_C);
3245 t.d >>= 1;
3246 SET_Z16(t.d);
3247 WM16(EAD,&t);
3248 }
3249
3250 /* LSRW extended -0*-* */
lsrw_ex(void)3251 static INLINE void lsrw_ex( void )
3252 {
3253 PAIR t;
3254 EXTWORD(t);
3255 CLR_NZC;
3256 CC |= (t.d & CC_C);
3257 t.d >>= 1;
3258 SET_Z16(t.d);
3259 WM16(EAD,&t);
3260 }
3261
3262 /* RORW direct -**-* */
rorw_di(void)3263 static INLINE void rorw_di( void )
3264 {
3265 PAIR t,r;
3266 DIRWORD(t);
3267 r.d = (CC & CC_C) << 15;
3268 CLR_NZC;
3269 CC |= (t.d & CC_C);
3270 r.d |= t.d>>1;
3271 SET_NZ16(r.d);
3272 WM16(EAD,&r);
3273 }
3274
3275 /* RORW indexed -**-* */
rorw_ix(void)3276 static INLINE void rorw_ix( void )
3277 {
3278 PAIR t,r;
3279 t.d=RM16(EAD);
3280 r.d = (CC & CC_C) << 15;
3281 CLR_NZC;
3282 CC |= (t.d & CC_C);
3283 r.d |= t.d>>1;
3284 SET_NZ16(r.d);
3285 WM16(EAD,&r);
3286 }
3287
3288 /* RORW extended -**-* */
rorw_ex(void)3289 static INLINE void rorw_ex( void )
3290 {
3291 PAIR t,r;
3292 EXTWORD(t);
3293 r.d = (CC & CC_C) << 15;
3294 CLR_NZC;
3295 CC |= (t.d & CC_C);
3296 r.d |= t.d>>1;
3297 SET_NZ16(r.d);
3298 WM16(EAD,&r);
3299 }
3300
3301 /* ASRW direct ?**-* */
asrw_di(void)3302 static INLINE void asrw_di( void )
3303 {
3304 PAIR t;
3305 DIRWORD(t);
3306 CLR_NZC;
3307 CC |= (t.d & CC_C);
3308 t.d = (t.d & 0x8000) | (t.d >> 1);
3309 SET_NZ16(t.d);
3310 WM16(EAD,&t);
3311 }
3312
3313 /* ASRW indexed ?**-* */
asrw_ix(void)3314 static INLINE void asrw_ix( void )
3315 {
3316 PAIR t;
3317 t.d=RM16(EAD);
3318 CLR_NZC;
3319 CC |= (t.d & CC_C);
3320 t.d = (t.d & 0x8000) | (t.d >> 1);
3321 SET_NZ16(t.d);
3322 WM16(EAD,&t);
3323 }
3324
3325 /* ASRW extended ?**-* */
asrw_ex(void)3326 static INLINE void asrw_ex( void )
3327 {
3328 PAIR t;
3329 EXTWORD(t);
3330 CLR_NZC;
3331 CC |= (t.d & CC_C);
3332 t.d = (t.d & 0x8000) | (t.d >> 1);
3333 SET_NZ16(t.d);
3334 WM16(EAD,&t);
3335 }
3336
3337 /* ASLW direct ?**** */
aslw_di(void)3338 static INLINE void aslw_di( void )
3339 {
3340 PAIR t,r;
3341 DIRWORD(t);
3342 r.d = t.d << 1;
3343 CLR_NZVC;
3344 SET_FLAGS16(t.d,t.d,r.d);
3345 WM16(EAD,&r);
3346 }
3347
3348 /* ASLW indexed ?**** */
aslw_ix(void)3349 static INLINE void aslw_ix( void )
3350 {
3351 PAIR t,r;
3352 t.d=RM16(EAD);
3353 r.d = t.d << 1;
3354 CLR_NZVC;
3355 SET_FLAGS16(t.d,t.d,r.d);
3356 WM16(EAD,&r);
3357 }
3358
3359 /* ASLW extended ?**** */
aslw_ex(void)3360 static INLINE void aslw_ex( void )
3361 {
3362 PAIR t,r;
3363 EXTWORD(t);
3364 r.d = t.d << 1;
3365 CLR_NZVC;
3366 SET_FLAGS16(t.d,t.d,r.d);
3367 WM16(EAD,&r);
3368 }
3369
3370 /* ROLW direct -**** */
rolw_di(void)3371 static INLINE void rolw_di( void )
3372 {
3373 PAIR t,r;
3374 DIRWORD(t);
3375 r.d = (CC & CC_C) | (t.d << 1);
3376 CLR_NZVC;
3377 SET_FLAGS16(t.d,t.d,r.d);
3378 WM16(EAD,&r);
3379 }
3380
3381 /* ROLW indexed -**** */
rolw_ix(void)3382 static INLINE void rolw_ix( void )
3383 {
3384 PAIR t,r;
3385 t.d=RM16(EAD);
3386 r.d = (CC & CC_C) | (t.d << 1);
3387 CLR_NZVC;
3388 SET_FLAGS16(t.d,t.d,r.d);
3389 WM16(EAD,&r);
3390 }
3391
3392 /* ROLW extended -**** */
rolw_ex(void)3393 static INLINE void rolw_ex( void )
3394 {
3395 PAIR t,r;
3396 EXTWORD(t);
3397 r.d = (CC & CC_C) | (t.d << 1);
3398 CLR_NZVC;
3399 SET_FLAGS16(t.d,t.d,r.d);
3400 WM16(EAD,&r);
3401 }
3402
3403 /* NEGD inherent ?**** */
negd(void)3404 static INLINE void negd( void )
3405 {
3406 UINT32 r;
3407 r = -D;
3408 CLR_NZVC;
3409 SET_FLAGS16(0,D,r);
3410 D = r;
3411 }
3412
3413 /* NEGW direct ?**** */
negw_di(void)3414 static INLINE void negw_di( void )
3415 {
3416 PAIR r,t;
3417 DIRWORD(t);
3418 r.d = -t.d;
3419 CLR_NZVC;
3420 SET_FLAGS16(0,t.d,r.d);
3421 WM16(EAD,&r);
3422 }
3423
3424 /* NEGW indexed ?**** */
negw_ix(void)3425 static INLINE void negw_ix( void )
3426 {
3427 PAIR r,t;
3428 t.d=RM16(EAD);
3429 r.d = -t.d;
3430 CLR_NZVC;
3431 SET_FLAGS16(0,t.d,r.d);
3432 WM16(EAD,&r);
3433 }
3434
3435 /* NEGW extended ?**** */
negw_ex(void)3436 static INLINE void negw_ex( void )
3437 {
3438 PAIR r,t;
3439 EXTWORD(t);
3440 r.d = -t.d;
3441 CLR_NZVC;
3442 SET_FLAGS16(0,t.d,r.d);
3443 WM16(EAD,&r);
3444 }
3445
3446 /* ABSA inherent ?**** */
absa(void)3447 static INLINE void absa( void )
3448 {
3449 UINT16 r;
3450 if (A & 0x80)
3451 r = -A;
3452 else
3453 r = A;
3454 CLR_NZVC;
3455 SET_FLAGS8(0,A,r);
3456 A = r;
3457 }
3458
3459 /* ABSB inherent ?**** */
absb(void)3460 static INLINE void absb( void )
3461 {
3462 UINT16 r;
3463 if (B & 0x80)
3464 r = -B;
3465 else
3466 r = B;
3467 CLR_NZVC;
3468 SET_FLAGS8(0,B,r);
3469 B = r;
3470 }
3471
3472 /* ABSD inherent ?**** */
absd(void)3473 static INLINE void absd( void )
3474 {
3475 UINT32 r;
3476 if (D & 0x8000)
3477 r = -D;
3478 else
3479 r = D;
3480 CLR_NZVC;
3481 SET_FLAGS16(0,D,r);
3482 D = r;
3483 }
3484
3485 /* LSRD direct -0*-* */
lsrd_di(void)3486 static INLINE void lsrd_di( void )
3487 {
3488 UINT8 t;
3489
3490 DIRBYTE( t );
3491
3492 while ( t-- ) {
3493 CLR_NZC;
3494 CC |= (D & CC_C);
3495 D >>= 1;
3496 SET_Z16(D);
3497 }
3498 }
3499
3500 /* RORD direct -**-* */
rord_di(void)3501 static INLINE void rord_di( void )
3502 {
3503 UINT16 r;
3504 UINT8 t;
3505
3506 DIRBYTE(t);
3507
3508 while ( t-- ) {
3509 r = (CC & CC_C) << 15;
3510 CLR_NZC;
3511 CC |= (D & CC_C);
3512 r |= D >> 1;
3513 SET_NZ16(r);
3514 D = r;
3515 }
3516 }
3517
3518 /* ASRD direct ?**-* */
asrd_di(void)3519 static INLINE void asrd_di( void )
3520 {
3521 UINT8 t;
3522
3523 DIRBYTE(t);
3524
3525 while ( t-- ) {
3526 CLR_NZC;
3527 CC |= (D & CC_C);
3528 D = (D & 0x8000) | (D >> 1);
3529 SET_NZ16(D);
3530 }
3531 }
3532
3533 /* ASLD direct ?**** */
asld_di(void)3534 static INLINE void asld_di( void )
3535 {
3536 UINT32 r;
3537 UINT8 t;
3538
3539 DIRBYTE( t );
3540
3541 while ( t-- ) {
3542 r = D << 1;
3543 CLR_NZVC;
3544 SET_FLAGS16(D,D,r);
3545 D = r;
3546 }
3547 }
3548
3549 /* ROLD direct -**-* */
rold_di(void)3550 static INLINE void rold_di( void )
3551 {
3552 UINT16 r;
3553 UINT8 t;
3554
3555 DIRBYTE(t);
3556
3557 while ( t-- ) {
3558 CLR_NZC;
3559 if ( D & 0x8000 ) SEC;
3560 r = CC & CC_C;
3561 r |= D << 1;
3562 SET_NZ16(r);
3563 D = r;
3564 }
3565 }
3566
3567 /* LSRD indexed -0*-* */
lsrd_ix(void)3568 static INLINE void lsrd_ix( void )
3569 {
3570 UINT8 t;
3571
3572 t=RM(EA);
3573
3574 while ( t-- ) {
3575 CLR_NZC;
3576 CC |= (D & CC_C);
3577 D >>= 1;
3578 SET_Z16(D);
3579 }
3580 }
3581
3582 /* RORD indexed -**-* */
rord_ix(void)3583 static INLINE void rord_ix( void )
3584 {
3585 UINT16 r;
3586 UINT8 t;
3587
3588 t=RM(EA);
3589
3590 while ( t-- ) {
3591 r = (CC & CC_C) << 15;
3592 CLR_NZC;
3593 CC |= (D & CC_C);
3594 r |= D >> 1;
3595 SET_NZ16(r);
3596 D = r;
3597 }
3598 }
3599
3600 /* ASRD indexed ?**-* */
asrd_ix(void)3601 static INLINE void asrd_ix( void )
3602 {
3603 UINT8 t;
3604
3605 t=RM(EA);
3606
3607 while ( t-- ) {
3608 CLR_NZC;
3609 CC |= (D & CC_C);
3610 D = (D & 0x8000) | (D >> 1);
3611 SET_NZ16(D);
3612 }
3613 }
3614
3615 /* ASLD indexed ?**** */
asld_ix(void)3616 static INLINE void asld_ix( void )
3617 {
3618 UINT32 r;
3619 UINT8 t;
3620
3621 t=RM(EA);
3622
3623 while ( t-- ) {
3624 r = D << 1;
3625 CLR_NZVC;
3626 SET_FLAGS16(D,D,r);
3627 D = r;
3628 }
3629 }
3630
3631 /* ROLD indexed -**-* */
rold_ix(void)3632 static INLINE void rold_ix( void )
3633 {
3634 UINT16 r;
3635 UINT8 t;
3636
3637 t=RM(EA);
3638
3639 while ( t-- ) {
3640 CLR_NZC;
3641 if ( D & 0x8000 ) SEC;
3642 r = CC & CC_C;
3643 r |= D << 1;
3644 SET_NZ16(r);
3645 D = r;
3646 }
3647 }
3648
3649 /* LSRD extended -0*-* */
lsrd_ex(void)3650 static INLINE void lsrd_ex( void )
3651 {
3652 UINT8 t;
3653
3654 EXTBYTE(t);
3655
3656 while ( t-- ) {
3657 CLR_NZC;
3658 CC |= (D & CC_C);
3659 D >>= 1;
3660 SET_Z16(D);
3661 }
3662 }
3663
3664 /* RORD extended -**-* */
rord_ex(void)3665 static INLINE void rord_ex( void )
3666 {
3667 UINT16 r;
3668 UINT8 t;
3669
3670 EXTBYTE(t);
3671
3672 while ( t-- ) {
3673 r = (CC & CC_C) << 15;
3674 CLR_NZC;
3675 CC |= (D & CC_C);
3676 r |= D >> 1;
3677 SET_NZ16(r);
3678 D = r;
3679 }
3680 }
3681
3682 /* ASRD extended ?**-* */
asrd_ex(void)3683 static INLINE void asrd_ex( void )
3684 {
3685 UINT8 t;
3686
3687 EXTBYTE(t);
3688
3689 while ( t-- ) {
3690 CLR_NZC;
3691 CC |= (D & CC_C);
3692 D = (D & 0x8000) | (D >> 1);
3693 SET_NZ16(D);
3694 }
3695 }
3696
3697 /* ASLD extended ?**** */
asld_ex(void)3698 static INLINE void asld_ex( void )
3699 {
3700 UINT32 r;
3701 UINT8 t;
3702
3703 EXTBYTE(t);
3704
3705 while ( t-- ) {
3706 r = D << 1;
3707 CLR_NZVC;
3708 SET_FLAGS16(D,D,r);
3709 D = r;
3710 }
3711 }
3712
3713 /* ROLD extended -**-* */
rold_ex(void)3714 static INLINE void rold_ex( void )
3715 {
3716 UINT16 r;
3717 UINT8 t;
3718
3719 EXTBYTE(t);
3720
3721 while ( t-- ) {
3722 CLR_NZC;
3723 if ( D & 0x8000 ) SEC;
3724 r = CC & CC_C;
3725 r |= D << 1;
3726 SET_NZ16(r);
3727 D = r;
3728 }
3729 }
3730
opcode2(void)3731 static INLINE void opcode2( void )
3732 {
3733 UINT8 ireg2 = ROP_ARG(PCD);
3734 PC++;
3735
3736 switch ( ireg2 ) {
3737 /* case 0x00: EA=0; break; *//* auto increment */
3738 /* case 0x01: EA=0; break; *//* double auto increment */
3739 /* case 0x02: EA=0; break; *//* auto decrement */
3740 /* case 0x03: EA=0; break; *//* double auto decrement */
3741 /* case 0x04: EA=0; break; *//* postbyte offs */
3742 /* case 0x05: EA=0; break; *//* postword offs */
3743 /* case 0x06: EA=0; break; *//* normal */
3744 case 0x07:
3745 EAD=0;
3746 (*konami_extended[konami.ireg])();
3747 konami_ICount -= 2;
3748 return;
3749 /* case 0x08: EA=0; break; *//* indirect - auto increment */
3750 /* case 0x09: EA=0; break; *//* indirect - double auto increment */
3751 /* case 0x0a: EA=0; break; *//* indirect - auto decrement */
3752 /* case 0x0b: EA=0; break; *//* indirect - double auto decrement */
3753 /* case 0x0c: EA=0; break; *//* indirect - postbyte offs */
3754 /* case 0x0d: EA=0; break; *//* indirect - postword offs */
3755 /* case 0x0e: EA=0; break; *//* indirect - normal */
3756 case 0x0f: /* indirect - extended */
3757 IMMWORD(ea);
3758 EA=RM16(EAD);
3759 konami_ICount-=4;
3760 break;
3761 /* case 0x10: EA=0; break; *//* auto increment */
3762 /* case 0x11: EA=0; break; *//* double auto increment */
3763 /* case 0x12: EA=0; break; *//* auto decrement */
3764 /* case 0x13: EA=0; break; *//* double auto decrement */
3765 /* case 0x14: EA=0; break; *//* postbyte offs */
3766 /* case 0x15: EA=0; break; *//* postword offs */
3767 /* case 0x16: EA=0; break; *//* normal */
3768 /* case 0x17: EA=0; break; *//* extended */
3769 /* case 0x18: EA=0; break; *//* indirect - auto increment */
3770 /* case 0x19: EA=0; break; *//* indirect - double auto increment */
3771 /* case 0x1a: EA=0; break; *//* indirect - auto decrement */
3772 /* case 0x1b: EA=0; break; *//* indirect - double auto decrement */
3773 /* case 0x1c: EA=0; break; *//* indirect - postbyte offs */
3774 /* case 0x1d: EA=0; break; *//* indirect - postword offs */
3775 /* case 0x1e: EA=0; break; *//* indirect - normal */
3776 /* case 0x1f: EA=0; break; *//* indirect - extended */
3777
3778 /* base X */
3779 case 0x20: /* auto increment */
3780 EA=X;
3781 X++;
3782 konami_ICount-=2;
3783 break;
3784 case 0x21: /* double auto increment */
3785 EA=X;
3786 X+=2;
3787 konami_ICount-=3;
3788 break;
3789 case 0x22: /* auto decrement */
3790 X--;
3791 EA=X;
3792 konami_ICount-=2;
3793 break;
3794 case 0x23: /* double auto decrement */
3795 X-=2;
3796 EA=X;
3797 konami_ICount-=3;
3798 break;
3799 case 0x24: /* postbyte offs */
3800 IMMBYTE(EA);
3801 EA=X+SIGNED(EA);
3802 konami_ICount-=2;
3803 break;
3804 case 0x25: /* postword offs */
3805 IMMWORD(ea);
3806 EA+=X;
3807 konami_ICount-=4;
3808 break;
3809 case 0x26: /* normal */
3810 EA=X;
3811 break;
3812 /* case 0x27: EA=0; break; *//* extended */
3813 case 0x28: /* indirect - auto increment */
3814 EA=X;
3815 X++;
3816 EA=RM16(EAD);
3817 konami_ICount-=5;
3818 break;
3819 case 0x29: /* indirect - double auto increment */
3820 EA=X;
3821 X+=2;
3822 EA=RM16(EAD);
3823 konami_ICount-=6;
3824 break;
3825 case 0x2a: /* indirect - auto decrement */
3826 X--;
3827 EA=X;
3828 EA=RM16(EAD);
3829 konami_ICount-=5;
3830 break;
3831 case 0x2b: /* indirect - double auto decrement */
3832 X-=2;
3833 EA=X;
3834 EA=RM16(EAD);
3835 konami_ICount-=6;
3836 break;
3837 case 0x2c: /* indirect - postbyte offs */
3838 IMMBYTE(EA);
3839 EA=X+SIGNED(EA);
3840 EA=RM16(EAD);
3841 konami_ICount-=4;
3842 break;
3843 case 0x2d: /* indirect - postword offs */
3844 IMMWORD(ea);
3845 EA+=X;
3846 EA=RM16(EAD);
3847 konami_ICount-=7;
3848 break;
3849 case 0x2e: /* indirect - normal */
3850 EA=X;
3851 EA=RM16(EAD);
3852 konami_ICount-=3;
3853 break;
3854 /* case 0x2f: EA=0; break; *//* indirect - extended */
3855
3856 /* base Y */
3857 case 0x30: /* auto increment */
3858 EA=Y;
3859 Y++;
3860 konami_ICount-=2;
3861 break;
3862 case 0x31: /* double auto increment */
3863 EA=Y;
3864 Y+=2;
3865 konami_ICount-=3;
3866 break;
3867 case 0x32: /* auto decrement */
3868 Y--;
3869 EA=Y;
3870 konami_ICount-=2;
3871 break;
3872 case 0x33: /* double auto decrement */
3873 Y-=2;
3874 EA=Y;
3875 konami_ICount-=3;
3876 break;
3877 case 0x34: /* postbyte offs */
3878 IMMBYTE(EA);
3879 EA=Y+SIGNED(EA);
3880 konami_ICount-=2;
3881 break;
3882 case 0x35: /* postword offs */
3883 IMMWORD(ea);
3884 EA+=Y;
3885 konami_ICount-=4;
3886 break;
3887 case 0x36: /* normal */
3888 EA=Y;
3889 break;
3890 /* case 0x37: EA=0; break; *//* extended */
3891 case 0x38: /* indirect - auto increment */
3892 EA=Y;
3893 Y++;
3894 EA=RM16(EAD);
3895 konami_ICount-=5;
3896 break;
3897 case 0x39: /* indirect - double auto increment */
3898 EA=Y;
3899 Y+=2;
3900 EA=RM16(EAD);
3901 konami_ICount-=6;
3902 break;
3903 case 0x3a: /* indirect - auto decrement */
3904 Y--;
3905 EA=Y;
3906 EA=RM16(EAD);
3907 konami_ICount-=5;
3908 break;
3909 case 0x3b: /* indirect - double auto decrement */
3910 Y-=2;
3911 EA=Y;
3912 EA=RM16(EAD);
3913 konami_ICount-=6;
3914 break;
3915 case 0x3c: /* indirect - postbyte offs */
3916 IMMBYTE(EA);
3917 EA=Y+SIGNED(EA);
3918 EA=RM16(EAD);
3919 konami_ICount-=4;
3920 break;
3921 case 0x3d: /* indirect - postword offs */
3922 IMMWORD(ea);
3923 EA+=Y;
3924 EA=RM16(EAD);
3925 konami_ICount-=7;
3926 break;
3927 case 0x3e: /* indirect - normal */
3928 EA=Y;
3929 EA=RM16(EAD);
3930 konami_ICount-=3;
3931 break;
3932 /* case 0x3f: EA=0; break; *//* indirect - extended */
3933
3934 /* case 0x40: EA=0; break; *//* auto increment */
3935 /* case 0x41: EA=0; break; *//* double auto increment */
3936 /* case 0x42: EA=0; break; *//* auto decrement */
3937 /* case 0x43: EA=0; break; *//* double auto decrement */
3938 /* case 0x44: EA=0; break; *//* postbyte offs */
3939 /* case 0x45: EA=0; break; *//* postword offs */
3940 /* case 0x46: EA=0; break; *//* normal */
3941 /* case 0x47: EA=0; break; *//* extended */
3942 /* case 0x48: EA=0; break; *//* indirect - auto increment */
3943 /* case 0x49: EA=0; break; *//* indirect - double auto increment */
3944 /* case 0x4a: EA=0; break; *//* indirect - auto decrement */
3945 /* case 0x4b: EA=0; break; *//* indirect - double auto decrement */
3946 /* case 0x4c: EA=0; break; *//* indirect - postbyte offs */
3947 /* case 0x4d: EA=0; break; *//* indirect - postword offs */
3948 /* case 0x4e: EA=0; break; *//* indirect - normal */
3949 /* case 0x4f: EA=0; break; *//* indirect - extended */
3950
3951 /* base U */
3952 case 0x50: /* auto increment */
3953 EA=U;
3954 U++;
3955 konami_ICount-=2;
3956 break;
3957 case 0x51: /* double auto increment */
3958 EA=U;
3959 U+=2;
3960 konami_ICount-=3;
3961 break;
3962 case 0x52: /* auto decrement */
3963 U--;
3964 EA=U;
3965 konami_ICount-=2;
3966 break;
3967 case 0x53: /* double auto decrement */
3968 U-=2;
3969 EA=U;
3970 konami_ICount-=3;
3971 break;
3972 case 0x54: /* postbyte offs */
3973 IMMBYTE(EA);
3974 EA=U+SIGNED(EA);
3975 konami_ICount-=2;
3976 break;
3977 case 0x55: /* postword offs */
3978 IMMWORD(ea);
3979 EA+=U;
3980 konami_ICount-=4;
3981 break;
3982 case 0x56: /* normal */
3983 EA=U;
3984 break;
3985 /* case 0x57: EA=0; break; *//* extended */
3986 case 0x58: /* indirect - auto increment */
3987 EA=U;
3988 U++;
3989 EA=RM16(EAD);
3990 konami_ICount-=5;
3991 break;
3992 case 0x59: /* indirect - double auto increment */
3993 EA=U;
3994 U+=2;
3995 EA=RM16(EAD);
3996 konami_ICount-=6;
3997 break;
3998 case 0x5a: /* indirect - auto decrement */
3999 U--;
4000 EA=U;
4001 EA=RM16(EAD);
4002 konami_ICount-=5;
4003 break;
4004 case 0x5b: /* indirect - double auto decrement */
4005 U-=2;
4006 EA=U;
4007 EA=RM16(EAD);
4008 konami_ICount-=6;
4009 break;
4010 case 0x5c: /* indirect - postbyte offs */
4011 IMMBYTE(EA);
4012 EA=U+SIGNED(EA);
4013 EA=RM16(EAD);
4014 konami_ICount-=4;
4015 break;
4016 case 0x5d: /* indirect - postword offs */
4017 IMMWORD(ea);
4018 EA+=U;
4019 EA=RM16(EAD);
4020 konami_ICount-=7;
4021 break;
4022 case 0x5e: /* indirect - normal */
4023 EA=U;
4024 EA=RM16(EAD);
4025 konami_ICount-=3;
4026 break;
4027 /* case 0x5f: EA=0; break; *//* indirect - extended */
4028
4029 /* base S */
4030 case 0x60: /* auto increment */
4031 EAD=SD;
4032 S++;
4033 konami_ICount-=2;
4034 break;
4035 case 0x61: /* double auto increment */
4036 EAD=SD;
4037 S+=2;
4038 konami_ICount-=3;
4039 break;
4040 case 0x62: /* auto decrement */
4041 S--;
4042 EAD=SD;
4043 konami_ICount-=2;
4044 break;
4045 case 0x63: /* double auto decrement */
4046 S-=2;
4047 EAD=SD;
4048 konami_ICount-=3;
4049 break;
4050 case 0x64: /* postbyte offs */
4051 IMMBYTE(EA);
4052 EA=S+SIGNED(EA);
4053 konami_ICount-=2;
4054 break;
4055 case 0x65: /* postword offs */
4056 IMMWORD(ea);
4057 EA+=S;
4058 konami_ICount-=4;
4059 break;
4060 case 0x66: /* normal */
4061 EAD=SD;
4062 break;
4063 /* case 0x67: EA=0; break; *//* extended */
4064 case 0x68: /* indirect - auto increment */
4065 EAD=SD;
4066 S++;
4067 EA=RM16(EAD);
4068 konami_ICount-=5;
4069 break;
4070 case 0x69: /* indirect - double auto increment */
4071 EAD=SD;
4072 S+=2;
4073 EA=RM16(EAD);
4074 konami_ICount-=6;
4075 break;
4076 case 0x6a: /* indirect - auto decrement */
4077 S--;
4078 EAD=SD;
4079 EA=RM16(EAD);
4080 konami_ICount-=5;
4081 break;
4082 case 0x6b: /* indirect - double auto decrement */
4083 S-=2;
4084 EAD=SD;
4085 EA=RM16(EAD);
4086 konami_ICount-=6;
4087 break;
4088 case 0x6c: /* indirect - postbyte offs */
4089 IMMBYTE(EA);
4090 EA=S+SIGNED(EA);
4091 EA=RM16(EAD);
4092 konami_ICount-=4;
4093 break;
4094 case 0x6d: /* indirect - postword offs */
4095 IMMWORD(ea);
4096 EA+=S;
4097 EA=RM16(EAD);
4098 konami_ICount-=7;
4099 break;
4100 case 0x6e: /* indirect - normal */
4101 EAD=SD;
4102 EA=RM16(EAD);
4103 konami_ICount-=3;
4104 break;
4105 /* case 0x6f: EA=0; break; *//* indirect - extended */
4106
4107 /* base PC */
4108 case 0x70: /* auto increment */
4109 EAD=PCD;
4110 PC++;
4111 konami_ICount-=2;
4112 break;
4113 case 0x71: /* double auto increment */
4114 EAD=PCD;
4115 PC+=2;
4116 konami_ICount-=3;
4117 break;
4118 case 0x72: /* auto decrement */
4119 PC--;
4120 EAD=PCD;
4121 konami_ICount-=2;
4122 break;
4123 case 0x73: /* double auto decrement */
4124 PC-=2;
4125 EAD=PCD;
4126 konami_ICount-=3;
4127 break;
4128 case 0x74: /* postbyte offs */
4129 IMMBYTE(EA);
4130 EA=PC-1+SIGNED(EA);
4131 konami_ICount-=2;
4132 break;
4133 case 0x75: /* postword offs */
4134 IMMWORD(ea);
4135 EA+=PC-2;
4136 konami_ICount-=4;
4137 break;
4138 case 0x76: /* normal */
4139 EAD=PCD;
4140 break;
4141 /* case 0x77: EA=0; break; *//* extended */
4142 case 0x78: /* indirect - auto increment */
4143 EAD=PCD;
4144 PC++;
4145 EA=RM16(EAD);
4146 konami_ICount-=5;
4147 break;
4148 case 0x79: /* indirect - double auto increment */
4149 EAD=PCD;
4150 PC+=2;
4151 EA=RM16(EAD);
4152 konami_ICount-=6;
4153 break;
4154 case 0x7a: /* indirect - auto decrement */
4155 PC--;
4156 EAD=PCD;
4157 EA=RM16(EAD);
4158 konami_ICount-=5;
4159 break;
4160 case 0x7b: /* indirect - double auto decrement */
4161 PC-=2;
4162 EAD=PCD;
4163 EA=RM16(EAD);
4164 konami_ICount-=6;
4165 break;
4166 case 0x7c: /* indirect - postbyte offs */
4167 IMMBYTE(EA);
4168 EA=PC-1+SIGNED(EA);
4169 EA=RM16(EAD);
4170 konami_ICount-=4;
4171 break;
4172 case 0x7d: /* indirect - postword offs */
4173 IMMWORD(ea);
4174 EA+=PC-2;
4175 EA=RM16(EAD);
4176 konami_ICount-=7;
4177 break;
4178 case 0x7e: /* indirect - normal */
4179 EAD=PCD;
4180 EA=RM16(EAD);
4181 konami_ICount-=3;
4182 break;
4183 /* case 0x7f: EA=0; break; *//* indirect - extended */
4184
4185 /* case 0x80: EA=0; break; *//* register a */
4186 /* case 0x81: EA=0; break; *//* register b */
4187 /* case 0x82: EA=0; break; *//* ???? */
4188 /* case 0x83: EA=0; break; *//* ???? */
4189 /* case 0x84: EA=0; break; *//* ???? */
4190 /* case 0x85: EA=0; break; *//* ???? */
4191 /* case 0x86: EA=0; break; *//* ???? */
4192 /* case 0x87: EA=0; break; *//* register d */
4193 /* case 0x88: EA=0; break; *//* indirect - register a */
4194 /* case 0x89: EA=0; break; *//* indirect - register b */
4195 /* case 0x8a: EA=0; break; *//* indirect - ???? */
4196 /* case 0x8b: EA=0; break; *//* indirect - ???? */
4197 /* case 0x8c: EA=0; break; *//* indirect - ???? */
4198 /* case 0x8d: EA=0; break; *//* indirect - ???? */
4199 /* case 0x8e: EA=0; break; *//* indirect - register d */
4200 /* case 0x8f: EA=0; break; *//* indirect - ???? */
4201 /* case 0x90: EA=0; break; *//* register a */
4202 /* case 0x91: EA=0; break; *//* register b */
4203 /* case 0x92: EA=0; break; *//* ???? */
4204 /* case 0x93: EA=0; break; *//* ???? */
4205 /* case 0x94: EA=0; break; *//* ???? */
4206 /* case 0x95: EA=0; break; *//* ???? */
4207 /* case 0x96: EA=0; break; *//* ???? */
4208 /* case 0x97: EA=0; break; *//* register d */
4209 /* case 0x98: EA=0; break; *//* indirect - register a */
4210 /* case 0x99: EA=0; break; *//* indirect - register b */
4211 /* case 0x9a: EA=0; break; *//* indirect - ???? */
4212 /* case 0x9b: EA=0; break; *//* indirect - ???? */
4213 /* case 0x9c: EA=0; break; *//* indirect - ???? */
4214 /* case 0x9d: EA=0; break; *//* indirect - ???? */
4215 /* case 0x9e: EA=0; break; *//* indirect - register d */
4216 /* case 0x9f: EA=0; break; *//* indirect - ???? */
4217 case 0xa0: /* register a */
4218 EA=X+SIGNED(A);
4219 konami_ICount-=1;
4220 break;
4221 case 0xa1: /* register b */
4222 EA=X+SIGNED(B);
4223 konami_ICount-=1;
4224 break;
4225 /* case 0xa2: EA=0; break; *//* ???? */
4226 /* case 0xa3: EA=0; break; *//* ???? */
4227 /* case 0xa4: EA=0; break; *//* ???? */
4228 /* case 0xa5: EA=0; break; *//* ???? */
4229 /* case 0xa6: EA=0; break; *//* ???? */
4230 case 0xa7: /* register d */
4231 EA=X+D;
4232 konami_ICount-=4;
4233 break;
4234 case 0xa8: /* indirect - register a */
4235 EA=X+SIGNED(A);
4236 EA=RM16(EAD);
4237 konami_ICount-=4;
4238 break;
4239 case 0xa9: /* indirect - register b */
4240 EA=X+SIGNED(B);
4241 EA=RM16(EAD);
4242 konami_ICount-=4;
4243 break;
4244 /* case 0xaa: EA=0; break; *//* indirect - ???? */
4245 /* case 0xab: EA=0; break; *//* indirect - ???? */
4246 /* case 0xac: EA=0; break; *//* indirect - ???? */
4247 /* case 0xad: EA=0; break; *//* indirect - ???? */
4248 /* case 0xae: EA=0; break; *//* indirect - ???? */
4249 case 0xaf: /* indirect - register d */
4250 EA=X+D;
4251 EA=RM16(EAD);
4252 konami_ICount-=7;
4253 break;
4254 case 0xb0: /* register a */
4255 EA=Y+SIGNED(A);
4256 konami_ICount-=1;
4257 break;
4258 case 0xb1: /* register b */
4259 EA=Y+SIGNED(B);
4260 konami_ICount-=1;
4261 break;
4262 /* case 0xb2: EA=0; break; *//* ???? */
4263 /* case 0xb3: EA=0; break; *//* ???? */
4264 /* case 0xb4: EA=0; break; *//* ???? */
4265 /* case 0xb5: EA=0; break; *//* ???? */
4266 /* case 0xb6: EA=0; break; *//* ???? */
4267 case 0xb7: /* register d */
4268 EA=Y+D;
4269 konami_ICount-=4;
4270 break;
4271 case 0xb8: /* indirect - register a */
4272 EA=Y+SIGNED(A);
4273 EA=RM16(EAD);
4274 konami_ICount-=4;
4275 break;
4276 case 0xb9: /* indirect - register b */
4277 EA=Y+SIGNED(B);
4278 EA=RM16(EAD);
4279 konami_ICount-=4;
4280 break;
4281 /* case 0xba: EA=0; break; *//* indirect - ???? */
4282 /* case 0xbb: EA=0; break; *//* indirect - ???? */
4283 /* case 0xbc: EA=0; break; *//* indirect - ???? */
4284 /* case 0xbd: EA=0; break; *//* indirect - ???? */
4285 /* case 0xbe: EA=0; break; *//* indirect - ???? */
4286 case 0xbf: /* indirect - register d */
4287 EA=Y+D;
4288 EA=RM16(EAD);
4289 konami_ICount-=7;
4290 break;
4291 /* case 0xc0: EA=0; break; *//* register a */
4292 /* case 0xc1: EA=0; break; *//* register b */
4293 /* case 0xc2: EA=0; break; *//* ???? */
4294 /* case 0xc3: EA=0; break; *//* ???? */
4295 case 0xc4:
4296 EAD=0;
4297 (*konami_direct[konami.ireg])();
4298 konami_ICount -= 1;
4299 return;
4300 /* case 0xc5: EA=0; break; *//* ???? */
4301 /* case 0xc6: EA=0; break; *//* ???? */
4302 /* case 0xc7: EA=0; break; *//* register d */
4303 /* case 0xc8: EA=0; break; *//* indirect - register a */
4304 /* case 0xc9: EA=0; break; *//* indirect - register b */
4305 /* case 0xca: EA=0; break; *//* indirect - ???? */
4306 /* case 0xcb: EA=0; break; *//* indirect - ???? */
4307 case 0xcc: /* indirect - direct */
4308 DIRWORD(ea);
4309 konami_ICount-=4;
4310 break;
4311 /* case 0xcd: EA=0; break; *//* indirect - ???? */
4312 /* case 0xce: EA=0; break; *//* indirect - register d */
4313 /* case 0xcf: EA=0; break; *//* indirect - ???? */
4314 case 0xd0: /* register a */
4315 EA=U+SIGNED(A);
4316 konami_ICount-=1;
4317 break;
4318 case 0xd1: /* register b */
4319 EA=U+SIGNED(B);
4320 konami_ICount-=1;
4321 break;
4322 /* case 0xd2: EA=0; break; *//* ???? */
4323 /* case 0xd3: EA=0; break; *//* ???? */
4324 /* case 0xd4: EA=0; break; *//* ???? */
4325 /* case 0xd5: EA=0; break; *//* ???? */
4326 /* case 0xd6: EA=0; break; *//* ???? */
4327 case 0xd7: /* register d */
4328 EA=U+D;
4329 konami_ICount-=4;
4330 break;
4331 case 0xd8: /* indirect - register a */
4332 EA=U+SIGNED(A);
4333 EA=RM16(EAD);
4334 konami_ICount-=4;
4335 break;
4336 case 0xd9: /* indirect - register b */
4337 EA=U+SIGNED(B);
4338 EA=RM16(EAD);
4339 konami_ICount-=4;
4340 break;
4341 /* case 0xda: EA=0; break; *//* indirect - ???? */
4342 /* case 0xdb: EA=0; break; *//* indirect - ???? */
4343 /* case 0xdc: EA=0; break; *//* indirect - ???? */
4344 /* case 0xdd: EA=0; break; *//* indirect - ???? */
4345 /* case 0xde: EA=0; break; *//* indirect - ???? */
4346 case 0xdf: /* indirect - register d */
4347 EA=U+D;
4348 EA=RM16(EAD);
4349 konami_ICount-=7;
4350 break;
4351 case 0xe0: /* register a */
4352 EA=S+SIGNED(A);
4353 konami_ICount-=1;
4354 break;
4355 case 0xe1: /* register b */
4356 EA=S+SIGNED(B);
4357 konami_ICount-=1;
4358 break;
4359 /* case 0xe2: EA=0; break; *//* ???? */
4360 /* case 0xe3: EA=0; break; *//* ???? */
4361 /* case 0xe4: EA=0; break; *//* ???? */
4362 /* case 0xe5: EA=0; break; *//* ???? */
4363 /* case 0xe6: EA=0; break; *//* ???? */
4364 case 0xe7: /* register d */
4365 EA=S+D;
4366 konami_ICount-=4;
4367 break;
4368 case 0xe8: /* indirect - register a */
4369 EA=S+SIGNED(A);
4370 EA=RM16(EAD);
4371 konami_ICount-=4;
4372 break;
4373 case 0xe9: /* indirect - register b */
4374 EA=S+SIGNED(B);
4375 EA=RM16(EAD);
4376 konami_ICount-=4;
4377 break;
4378 /* case 0xea: EA=0; break; *//* indirect - ???? */
4379 /* case 0xeb: EA=0; break; *//* indirect - ???? */
4380 /* case 0xec: EA=0; break; *//* indirect - ???? */
4381 /* case 0xed: EA=0; break; *//* indirect - ???? */
4382 /* case 0xee: EA=0; break; *//* indirect - ???? */
4383 case 0xef: /* indirect - register d */
4384 EA=S+D;
4385 EA=RM16(EAD);
4386 konami_ICount-=7;
4387 break;
4388 case 0xf0: /* register a */
4389 EA=PC+SIGNED(A);
4390 konami_ICount-=1;
4391 break;
4392 case 0xf1: /* register b */
4393 EA=PC+SIGNED(B);
4394 konami_ICount-=1;
4395 break;
4396 /* case 0xf2: EA=0; break; *//* ???? */
4397 /* case 0xf3: EA=0; break; *//* ???? */
4398 /* case 0xf4: EA=0; break; *//* ???? */
4399 /* case 0xf5: EA=0; break; *//* ???? */
4400 /* case 0xf6: EA=0; break; *//* ???? */
4401 case 0xf7: /* register d */
4402 EA=PC+D;
4403 konami_ICount-=4;
4404 break;
4405 case 0xf8: /* indirect - register a */
4406 EA=PC+SIGNED(A);
4407 EA=RM16(EAD);
4408 konami_ICount-=4;
4409 break;
4410 case 0xf9: /* indirect - register b */
4411 EA=PC+SIGNED(B);
4412 EA=RM16(EAD);
4413 konami_ICount-=4;
4414 break;
4415 /* case 0xfa: EA=0; break; *//* indirect - ???? */
4416 /* case 0xfb: EA=0; break; *//* indirect - ???? */
4417 /* case 0xfc: EA=0; break; *//* indirect - ???? */
4418 /* case 0xfd: EA=0; break; *//* indirect - ???? */
4419 /* case 0xfe: EA=0; break; *//* indirect - ???? */
4420 case 0xff: /* indirect - register d */
4421 EA=PC+D;
4422 EA=RM16(EAD);
4423 konami_ICount-=7;
4424 break;
4425 default:
4426 log_cb(RETRO_LOG_DEBUG, LOGPRE "KONAMI: Unknown/Invalid postbyte at PC = %04x\n", PC -1 );
4427 EAD = 0;
4428 }
4429 (*konami_indexed[konami.ireg])();
4430 }
4431