Previous

199869 Revisions

Next

r30965 Friday 13th June, 2014 at 21:20:34 UTC by hap
renamed opcode lists.h to .inc, renamed LR35902_FLAG_x to FLAG_x

[src/emu/cpu]	cpu.mak
[src/emu/cpu/lr35902]	lr35902.c lr35902.h opc_cb.h opc_cb.inc* opc_main.h opc_main.inc*

trunk/src/emu/cpu/lr35902/opc_cb.h

r30964	r30965
1		#define RLC_8BIT(x)             \
2		{                               \
3		register UINT8 f;           \
4		(x)=(UINT8)(((x)<<1)|((x)>>7));      \
5		if( (x)&1 )                 \
6		f=LR35902_FLAG_C;               \
7		else                        \
8		f=0;                    \
9		if( (x)==0 )                \
10		f|=LR35902_FLAG_Z;              \
11		m_F=f;          \
12		}
13
14		#define RL_8BIT(x)              \
15		{                               \
16		register UINT8 r;           \
17		r=((x)&0x80)?LR35902_FLAG_C:0;      \
18		(x)=(UINT8)(((x)<<1)|((m_F&LR35902_FLAG_C)?1:0));    \
19		if( (x)==0 )                \
20		r|=LR35902_FLAG_Z;              \
21		m_F=r;          \
22		}
23
24		#define RRC_8BIT(x)             \
25		{                               \
26		register UINT8 f;           \
27		(x)=(UINT8)(((x)>>1)|((x)<<7));      \
28		if( (x)&0x80 )              \
29		f=LR35902_FLAG_C;               \
30		else                        \
31		f=0;                    \
32		if( (x)==0 )                \
33		f|=LR35902_FLAG_Z;              \
34		m_F=f;          \
35		}
36
37		#define RR_8BIT(x)              \
38		{                               \
39		register UINT8 r;           \
40		r=((x)&1)?LR35902_FLAG_C:0;         \
41		(x)=(UINT8)(((x)>>1)|((m_F&LR35902_FLAG_C)?0x80:0));     \
42		if( (x)==0 )                \
43		r|=LR35902_FLAG_Z;              \
44		m_F=r;          \
45		}
46
47		#define SLA_8BIT(x)             \
48		{                               \
49		register UINT8 f;           \
50		if( (x)&0x80 )              \
51		f=LR35902_FLAG_C;               \
52		else                        \
53		f=0;                    \
54		(x)<<=1;                    \
55		if( (x)==0 )                \
56		f|=LR35902_FLAG_Z;              \
57		m_F=f;          \
58		}
59
60		#define SRA_8BIT(x)             \
61		{                               \
62		register UINT8 f;           \
63		if( (x)&1 )                 \
64		f=LR35902_FLAG_C;               \
65		else                        \
66		f=0;                    \
67		(x)=(UINT8)(((char)(x))>>1);     \
68		if( (x)==0 )                \
69		f|=LR35902_FLAG_Z;              \
70		m_F=f;          \
71		}
72
73		#define SWAP_8BIT(x)            \
74		(x)=(UINT8)(((x)>>4)|((x)<<4));      \
75		if( (x)==0 )                \
76		m_F=LR35902_FLAG_Z; \
77		else                        \
78		m_F=0;
79
80
81		#define SRL_8BIT(x)             \
82		{                               \
83		register UINT8 f;           \
84		if( (x)&1 )                 \
85		f=LR35902_FLAG_C;               \
86		else                        \
87		f=0;                    \
88		(x)>>=1;                    \
89		if( (x)==0 )                \
90		f|=LR35902_FLAG_Z;              \
91		m_F=f;          \
92		}
93
94		#define BIT_8BIT(n,x)           \
95		if( (x)&(1<<(n)) )          \
96		m_F=(UINT8)(LR35902_FLAG_H|(m_F&LR35902_FLAG_C));  \
97		else                        \
98		m_F=(UINT8)(LR35902_FLAG_Z|LR35902_FLAG_H|(m_F&LR35902_FLAG_C));
99
100		#define RES_8BIT(n,x)   (x)&=~(1<<(n));
101
102		#define SET_8BIT(n,x)   (x)|=(1<<(n));
103
104
105		case 0x00:
106		/*      RLC B */
107
108		RLC_8BIT (m_B)
109		break;
110		case 0x01:
111		/*      RLC C */
112
113		RLC_8BIT (m_C)
114		break;
115		case 0x02:
116		/*      RLC D */
117
118		RLC_8BIT (m_D)
119		break;
120		case 0x03:
121		/*      RLC E */
122
123		RLC_8BIT (m_E)
124		break;
125		case 0x04:
126		/*      RLC H */
127
128		RLC_8BIT (m_H)
129		break;
130		case 0x05:
131		/*      RLC L */
132
133		RLC_8BIT (m_L)
134		break;
135		case 0x06:
136		/*      RLC (HL) */
137		{
138		UINT16 addr = ( m_H << 8 ) | m_L;
139
140		x = mem_read_byte( addr );
141		RLC_8BIT (x)
142		mem_write_byte( addr, x );
143		}
144		break;
145		case 0x07:
146		/*      RLC A */
147
148		RLC_8BIT (m_A)
149		break;
150		case 0x08:
151		/*      RRC B */
152
153		RRC_8BIT (m_B)
154		break;
155		case 0x09:
156		/*      RRC C */
157
158		RRC_8BIT (m_C)
159		break;
160		case 0x0A:
161		/*      RRC D */
162
163		RRC_8BIT (m_D)
164		break;
165		case 0x0B:
166		/*      RRC E */
167
168		RRC_8BIT (m_E)
169		break;
170		case 0x0C:
171		/*      RRC H */
172
173		RRC_8BIT (m_H)
174		break;
175		case 0x0D:
176		/*      RRC L */
177
178		RRC_8BIT (m_L)
179		break;
180		case 0x0E:
181		/*      RRC (HL) */
182		{
183		UINT16 addr = ( m_H << 8 ) | m_L;
184
185		x = mem_read_byte( addr);
186		RRC_8BIT (x)
187		mem_write_byte( addr, x);
188		}
189		break;
190		case 0x0F:
191		/*      RRC A */
192
193		RRC_8BIT (m_A)
194		break;
195		case 0x10:
196		/*      RL B */
197
198		RL_8BIT (m_B)
199		break;
200		case 0x11:
201		/*      RL C */
202
203		RL_8BIT (m_C)
204		break;
205		case 0x12:
206		/*      RL D */
207
208		RL_8BIT (m_D)
209		break;
210		case 0x13:
211		/*      RL E */
212
213		RL_8BIT (m_E)
214		break;
215		case 0x14:
216		/*      RL H */
217
218		RL_8BIT (m_H)
219		break;
220		case 0x15:
221		/*      RL L */
222
223		RL_8BIT (m_L)
224		break;
225		case 0x16:
226		/*      RL (HL) */
227		{
228		UINT16 addr = ( m_H << 8 ) | m_L;
229
230		x = mem_read_byte( addr);
231		RL_8BIT (x)
232		mem_write_byte( addr, x);
233		}
234		break;
235		case 0x17:
236		/*      RL A */
237
238		RL_8BIT (m_A)
239		break;
240		case 0x18:
241		/*      RR B */
242
243		RR_8BIT (m_B)
244		break;
245		case 0x19:
246		/*      RR C */
247
248		RR_8BIT (m_C)
249		break;
250		case 0x1A:
251		/*      RR D */
252
253		RR_8BIT (m_D)
254		break;
255		case 0x1B:
256		/*      RR E */
257
258		RR_8BIT (m_E)
259		break;
260		case 0x1C:
261		/*      RR H */
262
263		RR_8BIT (m_H)
264		break;
265		case 0x1D:
266		/*      RR L */
267
268		RR_8BIT (m_L)
269		break;
270		case 0x1E:
271		/*      RR (HL) */
272		{
273		UINT16 addr = ( m_H << 8 ) | m_L;
274
275		x = mem_read_byte( addr);
276		RR_8BIT (x)
277		mem_write_byte( addr, x);
278		}
279		break;
280		case 0x1F:
281		/*      RR A */
282
283		RR_8BIT (m_A)
284		break;
285		case 0x20:
286		/*      SLA B */
287
288		SLA_8BIT (m_B)
289		break;
290		case 0x21:
291		/*      SLA C */
292
293		SLA_8BIT (m_C)
294		break;
295		case 0x22:
296		/*      SLA D */
297
298		SLA_8BIT (m_D)
299		break;
300		case 0x23:
301		/*      SLA E */
302
303		SLA_8BIT (m_E)
304		break;
305		case 0x24:
306		/*      SLA H */
307
308		SLA_8BIT (m_H)
309		break;
310		case 0x25:
311		/*      SLA L */
312
313		SLA_8BIT (m_L)
314		break;
315		case 0x26:
316		/*      SLA (HL) */
317		{
318		UINT16 addr = ( m_H << 8 ) | m_L;
319
320		x = mem_read_byte( addr);
321		SLA_8BIT (x)
322		mem_write_byte( addr, x);
323		}
324		break;
325		case 0x27:
326		/*      SLA A */
327
328		SLA_8BIT (m_A)
329		break;
330		case 0x28:
331		/*      SRA B */
332
333		SRA_8BIT (m_B)
334		break;
335		case 0x29:
336		/*      SRA C */
337
338		SRA_8BIT (m_C)
339		break;
340		case 0x2A:
341		/*      SRA D */
342
343		SRA_8BIT (m_D)
344		break;
345		case 0x2B:
346		/*      SRA E */
347
348		SRA_8BIT (m_E)
349		break;
350		case 0x2C:
351		/*      SRA H */
352
353		SRA_8BIT (m_H)
354		break;
355		case 0x2D:
356		/*      SRA L */
357
358		SRA_8BIT (m_L)
359		break;
360		case 0x2E:
361		/*      SRA (HL) */
362		{
363		UINT16 addr = ( m_H << 8 ) | m_L;
364
365		x = mem_read_byte( addr);
366		SRA_8BIT (x)
367		mem_write_byte( addr, x);
368		}
369		break;
370		case 0x2F:
371		/*      SRA A */
372
373		SRA_8BIT (m_A)
374		break;
375		case 0x30:
376		/*      SWAP B */
377
378		SWAP_8BIT (m_B)
379		break;
380		case 0x31:
381		/*      SWAP C */
382
383		SWAP_8BIT (m_C)
384		break;
385		case 0x32:
386		/*      SWAP D */
387
388		SWAP_8BIT (m_D)
389		break;
390		case 0x33:
391		/*      SWAP E */
392
393		SWAP_8BIT (m_E)
394		break;
395		case 0x34:
396		/*      SWAP H */
397
398		SWAP_8BIT (m_H)
399		break;
400		case 0x35:
401		/*      SWAP L */
402
403		SWAP_8BIT (m_L)
404		break;
405		case 0x36:
406		/*      SWAP (HL) */
407		{
408		UINT16 addr = ( m_H << 8 ) | m_L;
409
410		x = mem_read_byte( addr);
411		SWAP_8BIT (x)
412		mem_write_byte( addr, x);
413		}
414		break;
415		case 0x37:
416		/*      SWAP A */
417
418		SWAP_8BIT (m_A)
419		break;
420		case 0x38:
421		/*      SRL B */
422
423		SRL_8BIT (m_B)
424		break;
425		case 0x39:
426		/*      SRL C */
427
428		SRL_8BIT (m_C)
429		break;
430		case 0x3A:
431		/*      SRL D */
432
433		SRL_8BIT (m_D)
434		break;
435		case 0x3B:
436		/*      SRL E */
437
438		SRL_8BIT (m_E)
439		break;
440		case 0x3C:
441		/*      SRL H */
442
443		SRL_8BIT (m_H)
444		break;
445		case 0x3D:
446		/*      SRL L */
447
448		SRL_8BIT (m_L)
449		break;
450		case 0x3E:
451		/*      SRL (HL) */
452		{
453		UINT16 addr = ( m_H << 8 ) | m_L;
454
455		x = mem_read_byte( addr);
456		SRL_8BIT (x)
457		mem_write_byte( addr, x);
458		}
459		break;
460		case 0x3F:
461		/*      SRL A */
462
463		SRL_8BIT (m_A)
464		break;
465		case 0x40:
466		/*      BIT 0,B */
467
468		BIT_8BIT (0, m_B)
469		break;
470		case 0x41:
471		/*      BIT 0,C */
472
473		BIT_8BIT (0, m_C)
474		break;
475		case 0x42:
476		/*      BIT 0,D */
477
478		BIT_8BIT (0, m_D)
479		break;
480		case 0x43:
481		/*      BIT 0,E */
482
483		BIT_8BIT (0, m_E)
484		break;
485		case 0x44:
486		/*      BIT 0,H */
487
488		BIT_8BIT (0, m_H)
489		break;
490		case 0x45:
491		/*      BIT 0,L */
492
493		BIT_8BIT (0, m_L)
494		break;
495		case 0x46:
496		/*      BIT 0,(HL) */
497		{
498		UINT16 addr = ( m_H << 8 ) | m_L;
499
500		x = mem_read_byte( addr);
501		BIT_8BIT (0, x)
502		}
503		break;
504		case 0x47:
505		/*      BIT 0,A */
506
507		BIT_8BIT (0, m_A)
508		break;
509		case 0x48:
510		/*      BIT 1,B */
511
512		BIT_8BIT (1, m_B)
513		break;
514		case 0x49:
515		/*      BIT 1,C */
516
517		BIT_8BIT (1, m_C)
518		break;
519		case 0x4A:
520		/*      BIT 1,D */
521
522		BIT_8BIT (1, m_D)
523		break;
524		case 0x4B:
525		/*      BIT 1,E */
526
527		BIT_8BIT (1, m_E)
528		break;
529		case 0x4C:
530		/*      BIT 1,H */
531
532		BIT_8BIT (1, m_H)
533		break;
534		case 0x4D:
535		/*      BIT 1,L */
536
537		BIT_8BIT (1, m_L)
538		break;
539		case 0x4E:
540		/*      BIT 1,(HL) */
541		{
542		UINT16 addr = ( m_H << 8 ) | m_L;
543
544		x = mem_read_byte( addr);
545		BIT_8BIT (1, x)
546		}
547		break;
548		case 0x4F:
549		/*      BIT 1,A */
550
551		BIT_8BIT (1, m_A)
552		break;
553		case 0x50:
554		/*      BIT 2,B */
555
556		BIT_8BIT (2, m_B)
557		break;
558		case 0x51:
559		/*      BIT 2,C */
560
561		BIT_8BIT (2, m_C)
562		break;
563		case 0x52:
564		/*      BIT 2,D */
565
566		BIT_8BIT (2, m_D)
567		break;
568		case 0x53:
569		/*      BIT 2,E */
570
571		BIT_8BIT (2, m_E)
572		break;
573		case 0x54:
574		/*      BIT 2,H */
575
576		BIT_8BIT (2, m_H)
577		break;
578		case 0x55:
579		/*      BIT 2,L */
580
581		BIT_8BIT (2, m_L)
582		break;
583		case 0x56:
584		/*      BIT 2,(HL) */
585		{
586		UINT16 addr = ( m_H << 8 ) | m_L;
587
588		x = mem_read_byte( addr);
589		BIT_8BIT (2, x)
590		}
591		break;
592		case 0x57:
593		/*      BIT 2,A */
594
595		BIT_8BIT (2, m_A)
596		break;
597		case 0x58:
598		/*      BIT 3,B */
599
600		BIT_8BIT (3, m_B)
601		break;
602		case 0x59:
603		/*      BIT 3,C */
604
605		BIT_8BIT (3, m_C)
606		break;
607		case 0x5A:
608		/*      BIT 3,D */
609
610		BIT_8BIT (3, m_D)
611		break;
612		case 0x5B:
613		/*      BIT 3,E */
614
615		BIT_8BIT (3, m_E)
616		break;
617		case 0x5C:
618		/*      BIT 3,H */
619
620		BIT_8BIT (3, m_H)
621		break;
622		case 0x5D:
623		/*      BIT 3,L */
624
625		BIT_8BIT (3, m_L)
626		break;
627		case 0x5E:
628		/*      BIT 3,(HL) */
629		{
630		UINT16 addr = ( m_H << 8 ) | m_L;
631
632		x = mem_read_byte( addr);
633		BIT_8BIT (3, x)
634		}
635		break;
636		case 0x5F:
637		/*      BIT 3,A */
638
639		BIT_8BIT (3, m_A)
640		break;
641		case 0x60:
642		/*      BIT 4,B */
643
644		BIT_8BIT (4, m_B)
645		break;
646		case 0x61:
647		/*      BIT 4,C */
648
649		BIT_8BIT (4, m_C)
650		break;
651		case 0x62:
652		/*      BIT 4,D */
653
654		BIT_8BIT (4, m_D)
655		break;
656		case 0x63:
657		/*      BIT 4,E */
658
659		BIT_8BIT (4, m_E)
660		break;
661		case 0x64:
662		/*      BIT 4,H */
663
664		BIT_8BIT (4, m_H)
665		break;
666		case 0x65:
667		/*      BIT 4,L */
668
669		BIT_8BIT (4, m_L)
670		break;
671		case 0x66:
672		/*      BIT 4,(HL) */
673		{
674		UINT16 addr = ( m_H << 8 ) | m_L;
675
676		x = mem_read_byte( addr);
677		BIT_8BIT (4, x)
678		}
679		break;
680		case 0x67:
681		/*      BIT 4,A */
682
683		BIT_8BIT (4, m_A)
684		break;
685		case 0x68:
686		/*      BIT 5,B */
687
688		BIT_8BIT (5, m_B)
689		break;
690		case 0x69:
691		/*      BIT 5,C */
692
693		BIT_8BIT (5, m_C)
694		break;
695		case 0x6A:
696		/*      BIT 5,D */
697
698		BIT_8BIT (5, m_D)
699		break;
700		case 0x6B:
701		/*      BIT 5,E */
702
703		BIT_8BIT (5, m_E)
704		break;
705		case 0x6C:
706		/*      BIT 5,H */
707
708		BIT_8BIT (5, m_H)
709		break;
710		case 0x6D:
711		/*      BIT 5,L */
712
713		BIT_8BIT (5, m_L)
714		break;
715		case 0x6E:
716		/*      BIT 5,(HL) */
717		{
718		UINT16 addr = ( m_H << 8 ) | m_L;
719
720		x = mem_read_byte( addr);
721		BIT_8BIT (5, x)
722		}
723		break;
724		case 0x6F:
725		/*      BIT 5,A */
726
727		BIT_8BIT (5, m_A)
728		break;
729		case 0x70:
730		/*      BIT 6,B */
731
732		BIT_8BIT (6, m_B)
733		break;
734		case 0x71:
735		/*      BIT 6,C */
736
737		BIT_8BIT (6, m_C)
738		break;
739		case 0x72:
740		/*      BIT 6,D */
741
742		BIT_8BIT (6, m_D)
743		break;
744		case 0x73:
745		/*      BIT 6,E */
746
747		BIT_8BIT (6, m_E)
748		break;
749		case 0x74:
750		/*      BIT 6,H */
751
752		BIT_8BIT (6, m_H)
753		break;
754		case 0x75:
755		/*      BIT 6,L */
756
757		BIT_8BIT (6, m_L)
758		break;
759		case 0x76:
760		/*      BIT 6,(HL) */
761		{
762		UINT16 addr = ( m_H << 8 ) | m_L;
763
764		x = mem_read_byte( addr);
765		BIT_8BIT (6, x)
766		}
767		break;
768		case 0x77:
769		/*      BIT 6,A */
770
771		BIT_8BIT (6, m_A)
772		break;
773		case 0x78:
774		/*      BIT 7,B */
775
776		BIT_8BIT (7, m_B)
777		break;
778		case 0x79:
779		/*      BIT 7,C */
780
781		BIT_8BIT (7, m_C)
782		break;
783		case 0x7A:
784		/*      BIT 7,D */
785
786		BIT_8BIT (7, m_D)
787		break;
788		case 0x7B:
789		/*      BIT 7,E */
790
791		BIT_8BIT (7, m_E)
792		break;
793		case 0x7C:
794		/*      BIT 7,H */
795
796		BIT_8BIT (7, m_H)
797		break;
798		case 0x7D:
799		/*      BIT 7,L */
800
801		BIT_8BIT (7, m_L)
802		break;
803		case 0x7E:
804		/*      BIT 7,(HL) */
805		{
806		UINT16 addr = ( m_H << 8 ) | m_L;
807
808		x = mem_read_byte( addr);
809		BIT_8BIT (7, x)
810		}
811		break;
812		case 0x7F:
813		/*      BIT 7,A */
814
815		BIT_8BIT (7, m_A)
816		break;
817		case 0x80:
818		/*      RES 0,B */
819
820		RES_8BIT (0, m_B)
821		break;
822		case 0x81:
823		/*      RES 0,C */
824
825		RES_8BIT (0, m_C)
826		break;
827		case 0x82:
828		/*      RES 0,D */
829
830		RES_8BIT (0, m_D)
831		break;
832		case 0x83:
833		/*      RES 0,E */
834
835		RES_8BIT (0, m_E)
836		break;
837		case 0x84:
838		/*      RES 0,H */
839
840		RES_8BIT (0, m_H)
841		break;
842		case 0x85:
843		/*      RES 0,L */
844
845		RES_8BIT (0, m_L)
846		break;
847		case 0x86:
848		/*      RES 0,(HL) */
849		{
850		UINT16 addr = ( m_H << 8 ) | m_L;
851
852		x = mem_read_byte( addr);
853		RES_8BIT (0, x)
854		mem_write_byte( addr, x);
855		}
856		break;
857		case 0x87:
858		/*      RES 0,A */
859
860		RES_8BIT (0, m_A)
861		break;
862		case 0x88:
863		/*      RES 1,B */
864
865		RES_8BIT (1, m_B)
866		break;
867		case 0x89:
868		/*      RES 1,C */
869
870		RES_8BIT (1, m_C)
871		break;
872		case 0x8A:
873		/*      RES 1,D */
874
875		RES_8BIT (1, m_D)
876		break;
877		case 0x8B:
878		/*      RES 1,E */
879
880		RES_8BIT (1, m_E)
881		break;
882		case 0x8C:
883		/*      RES 1,H */
884
885		RES_8BIT (1, m_H)
886		break;
887		case 0x8D:
888		/*      RES 1,L */
889
890		RES_8BIT (1, m_L)
891		break;
892		case 0x8E:
893		/*      RES 1,(HL) */
894		{
895		UINT16 addr = ( m_H << 8 ) | m_L;
896
897		x = mem_read_byte( addr);
898		RES_8BIT (1, x)
899		mem_write_byte( addr, x);
900		}
901		break;
902		case 0x8F:
903		/*      RES 1,A */
904
905		RES_8BIT (1, m_A)
906		break;
907		case 0x90:
908		/*      RES 2,B */
909
910		RES_8BIT (2, m_B)
911		break;
912		case 0x91:
913		/*      RES 2,C */
914
915		RES_8BIT (2, m_C)
916		break;
917		case 0x92:
918		/*      RES 2,D */
919
920		RES_8BIT (2, m_D)
921		break;
922		case 0x93:
923		/*      RES 2,E */
924
925		RES_8BIT (2, m_E)
926		break;
927		case 0x94:
928		/*      RES 2,H */
929
930		RES_8BIT (2, m_H)
931		break;
932		case 0x95:
933		/*      RES 2,L */
934
935		RES_8BIT (2, m_L)
936		break;
937		case 0x96:
938		/*      RES 2,(HL) */
939		{
940		UINT16 addr = ( m_H << 8 ) | m_L;
941
942		x = mem_read_byte( addr);
943		RES_8BIT (2, x)
944		mem_write_byte( addr, x);
945		}
946		break;
947		case 0x97:
948		/*      RES 2,A */
949
950		RES_8BIT (2, m_A)
951		break;
952		case 0x98:
953		/*      RES 3,B */
954
955		RES_8BIT (3, m_B)
956		break;
957		case 0x99:
958		/*      RES 3,C */
959
960		RES_8BIT (3, m_C)
961		break;
962		case 0x9A:
963		/*      RES 3,D */
964
965		RES_8BIT (3, m_D)
966		break;
967		case 0x9B:
968		/*      RES 3,E */
969
970		RES_8BIT (3, m_E)
971		break;
972		case 0x9C:
973		/*      RES 3,H */
974
975		RES_8BIT (3, m_H)
976		break;
977		case 0x9D:
978		/*      RES 3,L */
979
980		RES_8BIT (3, m_L)
981		break;
982		case 0x9E:
983		/*      RES 3,(HL) */
984		{
985		UINT16 addr = ( m_H << 8 ) | m_L;
986
987		x = mem_read_byte( addr);
988		RES_8BIT (3, x)
989		mem_write_byte( addr, x);
990		}
991		break;
992		case 0x9F:
993		/*      RES 3,A */
994
995		RES_8BIT (3, m_A)
996		break;
997		case 0xA0:
998		/*      RES 4,B */
999
1000		RES_8BIT (4, m_B)
1001		break;
1002		case 0xA1:
1003		/*      RES 4,C */
1004
1005		RES_8BIT (4, m_C)
1006		break;
1007		case 0xA2:
1008		/*      RES 4,D */
1009
1010		RES_8BIT (4, m_D)
1011		break;
1012		case 0xA3:
1013		/*      RES 4,E */
1014
1015		RES_8BIT (4, m_E)
1016		break;
1017		case 0xA4:
1018		/*      RES 4,H */
1019
1020		RES_8BIT (4, m_H)
1021		break;
1022		case 0xA5:
1023		/*      RES 4,L */
1024
1025		RES_8BIT (4, m_L)
1026		break;
1027		case 0xA6:
1028		/*      RES 4,(HL) */
1029		{
1030		UINT16 addr = ( m_H << 8 ) | m_L;
1031
1032		x = mem_read_byte( addr);
1033		RES_8BIT (4, x)
1034		mem_write_byte( addr, x);
1035		}
1036		break;
1037		case 0xA7:
1038		/*      RES 4,A */
1039
1040		RES_8BIT (4, m_A)
1041		break;
1042		case 0xA8:
1043		/*      RES 5,B */
1044
1045		RES_8BIT (5, m_B)
1046		break;
1047		case 0xA9:
1048		/*      RES 5,C */
1049
1050		RES_8BIT (5, m_C)
1051		break;
1052		case 0xAA:
1053		/*      RES 5,D */
1054
1055		RES_8BIT (5, m_D)
1056		break;
1057		case 0xAB:
1058		/*      RES 5,E */
1059
1060		RES_8BIT (5, m_E)
1061		break;
1062		case 0xAC:
1063		/*      RES 5,H */
1064
1065		RES_8BIT (5, m_H)
1066		break;
1067		case 0xAD:
1068		/*      RES 5,L */
1069
1070		RES_8BIT (5, m_L)
1071		break;
1072		case 0xAE:
1073		/*      RES 5,(HL) */
1074		{
1075		UINT16 addr = ( m_H << 8 ) | m_L;
1076
1077		x = mem_read_byte( addr);
1078		RES_8BIT (5, x)
1079		mem_write_byte( addr, x);
1080		}
1081		break;
1082		case 0xAF:
1083		/*      RES 5,A */
1084
1085		RES_8BIT (5, m_A)
1086		break;
1087		case 0xB0:
1088		/*      RES 6,B */
1089
1090		RES_8BIT (6, m_B)
1091		break;
1092		case 0xB1:
1093		/*      RES 6,C */
1094
1095		RES_8BIT (6, m_C)
1096		break;
1097		case 0xB2:
1098		/*      RES 6,D */
1099
1100		RES_8BIT (6, m_D)
1101		break;
1102		case 0xB3:
1103		/*      RES 6,E */
1104
1105		RES_8BIT (6, m_E)
1106		break;
1107		case 0xB4:
1108		/*      RES 6,H */
1109
1110		RES_8BIT (6, m_H)
1111		break;
1112		case 0xB5:
1113		/*      RES 6,L */
1114
1115		RES_8BIT (6, m_L)
1116		break;
1117		case 0xB6:
1118		/*      RES 6,(HL) */
1119		{
1120		UINT16 addr = ( m_H << 8 ) | m_L;
1121
1122		x = mem_read_byte( addr);
1123		RES_8BIT (6, x)
1124		mem_write_byte( addr, x);
1125		}
1126		break;
1127		case 0xB7:
1128		/*      RES 6,A */
1129
1130		RES_8BIT (6, m_A)
1131		break;
1132		case 0xB8:
1133		/*      RES 7,B */
1134
1135		RES_8BIT (7, m_B)
1136		break;
1137		case 0xB9:
1138		/*      RES 7,C */
1139
1140		RES_8BIT (7, m_C)
1141		break;
1142		case 0xBA:
1143		/*      RES 7,D */
1144
1145		RES_8BIT (7, m_D)
1146		break;
1147		case 0xBB:
1148		/*      RES 7,E */
1149
1150		RES_8BIT (7, m_E)
1151		break;
1152		case 0xBC:
1153		/*      RES 7,H */
1154
1155		RES_8BIT (7, m_H)
1156		break;
1157		case 0xBD:
1158		/*      RES 7,L */
1159
1160		RES_8BIT (7, m_L)
1161		break;
1162		case 0xBE:
1163		/*      RES 7,(HL) */
1164		{
1165		UINT16 addr = ( m_H << 8 ) | m_L;
1166
1167		x = mem_read_byte( addr);
1168		RES_8BIT (7, x)
1169		mem_write_byte( addr, x);
1170		}
1171		break;
1172		case 0xBF:
1173		/*      RES 7,A */
1174
1175		RES_8BIT (7, m_A)
1176		break;
1177		case 0xC0:
1178		/*      SET 0,B */
1179
1180		SET_8BIT (0, m_B)
1181		break;
1182		case 0xC1:
1183		/*      SET 0,C */
1184
1185		SET_8BIT (0, m_C)
1186		break;
1187		case 0xC2:
1188		/*      SET 0,D */
1189
1190		SET_8BIT (0, m_D)
1191		break;
1192		case 0xC3:
1193		/*      SET 0,E */
1194
1195		SET_8BIT (0, m_E)
1196		break;
1197		case 0xC4:
1198		/*      SET 0,H */
1199
1200		SET_8BIT (0, m_H)
1201		break;
1202		case 0xC5:
1203		/*      SET 0,L */
1204
1205		SET_8BIT (0, m_L)
1206		break;
1207		case 0xC6:
1208		/*      SET 0,(HL) */
1209		{
1210		UINT16 addr = ( m_H << 8 ) | m_L;
1211
1212		x = mem_read_byte( addr);
1213		SET_8BIT (0, x)
1214		mem_write_byte( addr, x);
1215		}
1216		break;
1217		case 0xC7:
1218		/*      SET 0,A */
1219
1220		SET_8BIT (0, m_A)
1221		break;
1222		case 0xC8:
1223		/*      SET 1,B */
1224
1225		SET_8BIT (1, m_B)
1226		break;
1227		case 0xC9:
1228		/*      SET 1,C */
1229
1230		SET_8BIT (1, m_C)
1231		break;
1232		case 0xCA:
1233		/*      SET 1,D */
1234
1235		SET_8BIT (1, m_D)
1236		break;
1237		case 0xCB:
1238		/*      SET 1,E */
1239
1240		SET_8BIT (1, m_E)
1241		break;
1242		case 0xCC:
1243		/*      SET 1,H */
1244
1245		SET_8BIT (1, m_H)
1246		break;
1247		case 0xCD:
1248		/*      SET 1,L */
1249
1250		SET_8BIT (1, m_L)
1251		break;
1252		case 0xCE:
1253		/*      SET 1,(HL) */
1254		{
1255		UINT16 addr = ( m_H << 8 ) | m_L;
1256
1257		x = mem_read_byte( addr);
1258		SET_8BIT (1, x)
1259		mem_write_byte( addr, x);
1260		}
1261		break;
1262		case 0xCF:
1263		/*      SET 1,A */
1264
1265		SET_8BIT (1, m_A)
1266		break;
1267		case 0xD0:
1268		/*      SET 2,B */
1269
1270		SET_8BIT (2, m_B)
1271		break;
1272		case 0xD1:
1273		/*      SET 2,C */
1274
1275		SET_8BIT (2, m_C)
1276		break;
1277		case 0xD2:
1278		/*      SET 2,D */
1279
1280		SET_8BIT (2, m_D)
1281		break;
1282		case 0xD3:
1283		/*      SET 2,E */
1284
1285		SET_8BIT (2, m_E)
1286		break;
1287		case 0xD4:
1288		/*      SET 2,H */
1289
1290		SET_8BIT (2, m_H)
1291		break;
1292		case 0xD5:
1293		/*      SET 2,L */
1294
1295		SET_8BIT (2, m_L)
1296		break;
1297		case 0xD6:
1298		/*      SET 2,(HL) */
1299		{
1300		UINT16 addr = ( m_H << 8 ) | m_L;
1301
1302		x = mem_read_byte( addr);
1303		SET_8BIT (2, x)
1304		mem_write_byte( addr, x);
1305		}
1306		break;
1307		case 0xD7:
1308		/*      SET 2,A */
1309
1310		SET_8BIT (2, m_A)
1311		break;
1312		case 0xD8:
1313		/*      SET 3,B */
1314
1315		SET_8BIT (3, m_B)
1316		break;
1317		case 0xD9:
1318		/*      SET 3,C */
1319
1320		SET_8BIT (3, m_C)
1321		break;
1322		case 0xDA:
1323		/*      SET 3,D */
1324
1325		SET_8BIT (3, m_D)
1326		break;
1327		case 0xDB:
1328		/*      SET 3,E */
1329
1330		SET_8BIT (3, m_E)
1331		break;
1332		case 0xDC:
1333		/*      SET 3,H */
1334
1335		SET_8BIT (3, m_H)
1336		break;
1337		case 0xDD:
1338		/*      SET 3,L */
1339
1340		SET_8BIT (3, m_L)
1341		break;
1342		case 0xDE:
1343		/*      SET 3,(HL) */
1344		{
1345		UINT16 addr = ( m_H << 8 ) | m_L;
1346
1347		x = mem_read_byte( addr);
1348		SET_8BIT (3, x)
1349		mem_write_byte( addr, x);
1350		}
1351		break;
1352		case 0xDF:
1353		/*      SET 3,A */
1354
1355		SET_8BIT (3, m_A)
1356		break;
1357		case 0xE0:
1358		/*      SET 4,B */
1359
1360		SET_8BIT (4, m_B)
1361		break;
1362		case 0xE1:
1363		/*      SET 4,C */
1364
1365		SET_8BIT (4, m_C)
1366		break;
1367		case 0xE2:
1368		/*      SET 4,D */
1369
1370		SET_8BIT (4, m_D)
1371		break;
1372		case 0xE3:
1373		/*      SET 4,E */
1374
1375		SET_8BIT (4, m_E)
1376		break;
1377		case 0xE4:
1378		/*      SET 4,H */
1379
1380		SET_8BIT (4, m_H)
1381		break;
1382		case 0xE5:
1383		/*      SET 4,L */
1384
1385		SET_8BIT (4, m_L)
1386		break;
1387		case 0xE6:
1388		/*      SET 4,(HL) */
1389		{
1390		UINT16 addr = ( m_H << 8 ) | m_L;
1391
1392		x = mem_read_byte( addr);
1393		SET_8BIT (4, x)
1394		mem_write_byte( addr, x);
1395		}
1396		break;
1397		case 0xE7:
1398		/*      SET 4,A */
1399
1400		SET_8BIT (4, m_A)
1401		break;
1402		case 0xE8:
1403		/*      SET 5,B */
1404
1405		SET_8BIT (5, m_B)
1406		break;
1407		case 0xE9:
1408		/*      SET 5,C */
1409
1410		SET_8BIT (5, m_C)
1411		break;
1412		case 0xEA:
1413		/*      SET 5,D */
1414
1415		SET_8BIT (5, m_D)
1416		break;
1417		case 0xEB:
1418		/*      SET 5,E */
1419
1420		SET_8BIT (5, m_E)
1421		break;
1422		case 0xEC:
1423		/*      SET 5,H */
1424
1425		SET_8BIT (5, m_H)
1426		break;
1427		case 0xED:
1428		/*      SET 5,L */
1429
1430		SET_8BIT (5, m_L)
1431		break;
1432		case 0xEE:
1433		/*      SET 5,(HL) */
1434		{
1435		UINT16 addr = ( m_H << 8 ) | m_L;
1436
1437		x = mem_read_byte( addr);
1438		SET_8BIT (5, x)
1439		mem_write_byte( addr, x);
1440		}
1441		break;
1442		case 0xEF:
1443		/*      SET 5,A */
1444
1445		SET_8BIT (5, m_A)
1446		break;
1447		case 0xF0:
1448		/*      SET 6,B */
1449
1450		SET_8BIT (6, m_B)
1451		break;
1452		case 0xF1:
1453		/*      SET 6,C */
1454
1455		SET_8BIT (6, m_C)
1456		break;
1457		case 0xF2:
1458		/*      SET 6,D */
1459
1460		SET_8BIT (6, m_D)
1461		break;
1462		case 0xF3:
1463		/*      SET 6,E */
1464
1465		SET_8BIT (6, m_E)
1466		break;
1467		case 0xF4:
1468		/*      SET 6,H */
1469
1470		SET_8BIT (6, m_H)
1471		break;
1472		case 0xF5:
1473		/*      SET 6,L */
1474
1475		SET_8BIT (6, m_L)
1476		break;
1477		case 0xF6:
1478		/*      SET 6,(HL) */
1479		{
1480		UINT16 addr = ( m_H << 8 ) | m_L;
1481
1482		x = mem_read_byte( addr);
1483		SET_8BIT (6, x)
1484		mem_write_byte( addr, x);
1485		}
1486		break;
1487		case 0xF7:
1488		/*      SET 6,A */
1489
1490		SET_8BIT (6, m_A)
1491		break;
1492		case 0xF8:
1493		/*      SET 7,B */
1494
1495		SET_8BIT (7, m_B)
1496		break;
1497		case 0xF9:
1498		/*      SET 7,C */
1499
1500		SET_8BIT (7, m_C)
1501		break;
1502		case 0xFA:
1503		/*      SET 7,D */
1504
1505		SET_8BIT (7, m_D)
1506		break;
1507		case 0xFB:
1508		/*      SET 7,E */
1509
1510		SET_8BIT (7, m_E)
1511		break;
1512		case 0xFC:
1513		/*      SET 7,H */
1514
1515		SET_8BIT (7, m_H)
1516		break;
1517		case 0xFD:
1518		/*      SET 7,L */
1519
1520		SET_8BIT (7, m_L)
1521		break;
1522		case 0xFE:
1523		/*      SET 7,(HL) */
1524		{
1525		UINT16 addr = ( m_H << 8 ) | m_L;
1526
1527		x = mem_read_byte( addr);
1528		SET_8BIT (7, x)
1529		mem_write_byte( addr, x);
1530		}
1531		break;
1532		case 0xFF:
1533		/*      SET 7,A */
1534
1535		SET_8BIT (7, m_A)
1536		break;

trunk/src/emu/cpu/lr35902/opc_main.h

r30964	r30965
1		#define INC_8BIT(x) \
2		{ \
3		register UINT8 r,f; \
4		x++; \
5		r=(x);  \
6		f=(UINT8)(m_F&LR35902_FLAG_C); \
7		if( r==0 )       f|=LR35902_FLAG_Z; \
8		if( (r&0xF)==0 ) f|=LR35902_FLAG_H; \
9		m_F=f; \
10		}
11
12		#define DEC_8BIT(x) \
13		{ \
14		register UINT8 r,f; \
15		x--; \
16		r=(x);  \
17		f=(UINT8)((m_F&LR35902_FLAG_C)|LR35902_FLAG_N); \
18		if( r==0 )       f|=LR35902_FLAG_Z; \
19		if( (r&0xF)==0xF ) f|=LR35902_FLAG_H; \
20		m_F=f; \
21		}
22
23		#define ADD_HL_RR(x) \
24		{ \
25		register UINT32 r1,r2; \
26		register UINT8 f; \
27		r1=((m_H<<8)|m_L)+(x); \
28		r2=(((m_H<<8)|m_L)&0xFFF)+((x)&0xFFF); \
29		f=(UINT8)(m_F&LR35902_FLAG_Z); \
30		if( r1>0xFFFF ) f|=LR35902_FLAG_C; \
31		if( r2>0x0FFF ) f|=LR35902_FLAG_H; \
32		m_L = r1; \
33		m_H = r1 >> 8; \
34		m_F=f; \
35		}
36
37		#define ADD_A_X(x) \
38		{ \
39		register UINT16 r1,r2; \
40		register UINT8 f; \
41		r1=(UINT16)((m_A&0xF)+((x)&0xF)); \
42		r2=(UINT16)(m_A+(x)); \
43		m_A=(UINT8)r2; \
44		if( ((UINT8)r2)==0 ) f=LR35902_FLAG_Z; \
45		else f=0; \
46		if( r2>0xFF ) f|=LR35902_FLAG_C; \
47		if( r1>0xF )  f|=LR35902_FLAG_H; \
48		m_F=f; \
49		}
50
51		#define SUB_A_X(x) \
52		{ \
53		register UINT16 r1,r2; \
54		register UINT8 f; \
55		r1=(UINT16)((m_A&0xF)-((x)&0xF)); \
56		r2=(UINT16)(m_A-(x)); \
57		m_A=(UINT8)r2; \
58		if( ((UINT8)r2)==0 ) f=LR35902_FLAG_N|LR35902_FLAG_Z; \
59		else f=LR35902_FLAG_N; \
60		if( r2>0xFF ) f|=LR35902_FLAG_C; \
61		if( r1>0xF )  f|=LR35902_FLAG_H; \
62		m_F=f; \
63		}
64
65		/*
66		#define      CP_A_X(x) \
67		{ \
68		register UINT16 r; \
69		register UINT8 f; \
70		r=(UINT16)(m_A-(x)); \
71		if( ((UINT8)r)==0 ) \
72		f=LR35902_FLAG_N|LR35902_FLAG_Z; \
73		else \
74		f=LR35902_FLAG_N; \
75		f|=(UINT8)((r>>8)&LR35902_FLAG_C); \
76		if( (r^m_A^(x))&0x10 ) \
77		f|=LR35902_FLAG_H; \
78		m_F=f; \
79		}
80		*/
81
82		#define CP_A_X(x) \
83		{ \
84		register UINT16 r1,r2; \
85		register UINT8 f; \
86		r1=(UINT16)((m_A&0xF)-((x)&0xF)); \
87		r2=(UINT16)(m_A-(x)); \
88		if( ((UINT8)r2)==0 ) f=LR35902_FLAG_N|LR35902_FLAG_Z; \
89		else f=LR35902_FLAG_N; \
90		if( r2>0xFF ) f|=LR35902_FLAG_C; \
91		if( r1>0xF )  f|=LR35902_FLAG_H; \
92		m_F=f; \
93		}
94
95		#define SBC_A_X(x) \
96		{ \
97		register UINT16 r1,r2; \
98		register UINT8 f; \
99		r1=(UINT16)((m_A&0xF)-((x)&0xF)-((m_F&LR35902_FLAG_C)?1:0)); \
100		r2=(UINT16)(m_A-(x)-((m_F&LR35902_FLAG_C)?1:0)); \
101		m_A=(UINT8)r2; \
102		if( ((UINT8)r2)==0 ) f=LR35902_FLAG_N|LR35902_FLAG_Z; \
103		else f=LR35902_FLAG_N; \
104		if( r2>0xFF ) f|=LR35902_FLAG_C; \
105		if( r1>0xF )  f|=LR35902_FLAG_H; \
106		m_F=f; \
107		}
108
109		#define ADC_A_X(x) \
110		{ \
111		register UINT16 r1,r2;  \
112		register UINT8 f; \
113		r1=(UINT16)((m_A&0xF)+((x)&0xF)+((m_F&LR35902_FLAG_C)?1:0));  \
114		r2=(UINT16)(m_A+(x)+((m_F&LR35902_FLAG_C)?1:0)); \
115		if( (m_A=(UINT8)r2)==0 ) f=LR35902_FLAG_Z; \
116		else f=0; \
117		if( r2>0xFF )   f|=LR35902_FLAG_C; \
118		if( r1>0xF )    f|=LR35902_FLAG_H; \
119		m_F=f; \
120		}
121
122		#define AND_A_X(x) \
123		if( (m_A&=(x))==0 ) \
124		m_F=LR35902_FLAG_H|LR35902_FLAG_Z; \
125		else \
126		m_F=LR35902_FLAG_H;
127
128		#define XOR_A_X(x) \
129		if( (m_A^=(x))==0 ) \
130		m_F=LR35902_FLAG_Z; \
131		else \
132		m_F=0;
133
134		#define OR_A_X(x) \
135		if( (m_A|=(x))==0 ) \
136		m_F=LR35902_FLAG_Z; \
137		else \
138		m_F=0;
139
140		#define POP(x,y) \
141		y = mem_read_byte( m_SP++ ); \
142		x = mem_read_byte( m_SP++ );
143
144		#define PUSH(x,y) \
145		m_SP--; \
146		mem_write_byte( m_SP, x ); \
147		m_SP--; \
148		mem_write_byte( m_SP, y );
149
150		case 0x00: /*      NOP */
151		break;
152
153		case 0x01: /*      LD BC,n16 */
154		m_C = mem_read_byte( m_PC++ );
155		m_B = mem_read_byte( m_PC++ );
156		break;
157
158		case 0x02: /*      LD (BC),A */
159		mem_write_byte( ( m_B << 8 ) | m_C, m_A );
160		break;
161
162		case 0x03: /*      INC BC */
163		#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
164		if (m_B == 0xFE)
165		{
166		trash_sprites (state);
167		}
168		#endif
169		m_C++;
170		if ( m_C == 0 )
171		{
172		m_B++;
173		}
174		cycles_passed( 4 );
175		break;
176		case 0x04: /*      INC B */
177		INC_8BIT (m_B)
178		break;
179		case 0x05: /*      DEC B */
180
181		DEC_8BIT (m_B)
182		break;
183
184		case 0x06: /*      LD B,n8 */
185		m_B = mem_read_byte( m_PC++ );
186		break;
187
188		case 0x07: /*      RLCA */
189
190		m_A = (UINT8) ((m_A << 1) | (m_A >> 7));
191		if (m_A & 1)
192		{
193		m_F = LR35902_FLAG_C;
194		}
195		else
196		{
197		m_F = 0;
198		}
199		break;
200
201		case 0x08: /*      LD (n16),SP */
202		mem_write_word (mem_read_word (m_PC), m_SP);
203		m_PC += 2;
204		break;
205
206		case 0x09: /*      ADD HL,BC */
207		ADD_HL_RR ((m_B<<8)|m_C)
208		cycles_passed( 4 );
209		break;
210		case 0x0A: /*      LD A,(BC) */
211
212		m_A = mem_read_byte ( (m_B<<8)|m_C );
213		break;
214		case 0x0B: /*      DEC BC */
215
216		#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
217		if (m_B == 0xFE)
218		{
219		trash_sprites (state);
220		}
221		#endif
222		m_C--;
223		if ( m_C == 0xFF )
224		{
225		m_B--;
226		}
227		cycles_passed( 4 );
228		break;
229		case 0x0C: /*      INC C */
230
231		INC_8BIT (m_C)
232		break;
233		case 0x0D: /*      DEC C */
234
235		DEC_8BIT (m_C)
236		break;
237		case 0x0E: /*      LD C,n8 */
238
239		m_C = mem_read_byte ( m_PC++ );
240		break;
241		case 0x0F: /*      RRCA */
242
243		m_A = (UINT8) ((m_A >> 1) | (m_A << 7));
244		m_F = 0;
245		if (m_A & 0x80)
246		{
247		m_F |= LR35902_FLAG_C;
248		}
249		break;
250		case 0x10: /*      STOP */
251		if ( m_gb_speed_change_pending ) {
252		m_gb_speed = ( m_gb_speed == 1 ) ? 2 : 1;
253		}
254		m_gb_speed_change_pending = 0;
255		break;
256		case 0x11: /*      LD DE,n16 */
257		m_E = mem_read_byte( m_PC++ );
258		m_D = mem_read_byte( m_PC++ );
259		break;
260		case 0x12: /*      LD (DE),A */
261		mem_write_byte( ( m_D << 8 ) | m_E, m_A );
262		break;
263		case 0x13: /*      INC DE */
264
265		#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
266		if (m_D == 0xFE)
267		{
268		trash_sprites (state);
269		}
270		#endif
271		m_E++;
272		if ( m_E == 0 )
273		{
274		m_D++;
275		}
276		cycles_passed( 4 );
277		break;
278		case 0x14: /*      INC D */
279
280		INC_8BIT (m_D)
281		break;
282		case 0x15: /*      DEC D */
283
284		DEC_8BIT (m_D)
285		break;
286		case 0x16: /*      LD D,n8 */
287
288		m_D = mem_read_byte ( m_PC++ );
289		break;
290		case 0x17: /*      RLA */
291
292		x = (m_A & 0x80) ? LR35902_FLAG_C : 0;
293
294		m_A = (UINT8) ((m_A << 1) | ((m_F & LR35902_FLAG_C) ? 1 : 0));
295		m_F = x;
296		break;
297		case 0x18: /*      JR      n8 */
298		{
299		INT8 offset;
300
301		offset = mem_read_byte( m_PC++ );
302		m_PC += offset;
303		cycles_passed( 4 );
304		}
305		break;
306		case 0x19: /*      ADD HL,DE */
307		ADD_HL_RR (( m_D << 8 ) | m_E)
308		cycles_passed( 4 );
309		break;
310		case 0x1A: /*      LD A,(DE) */
311
312		m_A = mem_read_byte( ( m_D << 8 ) | m_E );
313		break;
314		case 0x1B: /*      DEC DE */
315
316		#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
317		if (m_D == 0xFE)
318		{
319		trash_sprites (state);
320		}
321		#endif
322		m_E--;
323		if ( m_E == 0xFF )
324		{
325		m_D--;
326		}
327		cycles_passed( 4 );
328		break;
329		case 0x1C: /*      INC E */
330
331		INC_8BIT (m_E)
332		break;
333		case 0x1D: /*      DEC E */
334
335		DEC_8BIT (m_E)
336		break;
337		case 0x1E: /*      LD E,n8 */
338
339		m_E = mem_read_byte( m_PC++ );
340		break;
341		case 0x1F: /*      RRA */
342
343		x = (m_A & 1) ? LR35902_FLAG_C : 0;
344
345		m_A = (UINT8) ((m_A >> 1) | ((m_F & LR35902_FLAG_C) ? 0x80 : 0));
346		m_F = x;
347		break;
348		case 0x20: /*      JR NZ,n8 */
349		{
350		INT8 offset = mem_read_byte( m_PC++ );
351		if (! (m_F & LR35902_FLAG_Z) )
352		{
353		m_PC += offset;
354		cycles_passed( 4 );
355		}
356		}
357		break;
358		case 0x21: /*      LD HL,n16 */
359		m_L = mem_read_byte( m_PC++ );
360		m_H = mem_read_byte( m_PC++ );
361		break;
362		case 0x22: /*      LD (HL+),A */
363
364		#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
365		if (m_H == 0xFE)
366		{
367		trash_sprites (state);
368		}
369		#endif
370		mem_write_byte( (m_H << 8 ) | m_L, m_A );
371		m_L++;
372		if ( m_L == 0 )
373		{
374		m_H++;
375		}
376		break;
377		case 0x23: /*      INC HL */
378
379		#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
380		if (m_H == 0xFE)
381		{
382		trash_sprites (state);
383		}
384		#endif
385		m_L++;
386		if ( m_L == 0 )
387		{
388		m_H++;
389		}
390		cycles_passed( 4 );
391		break;
392		case 0x24: /*      INC H */
393
394		INC_8BIT (m_H);
395		break;
396		case 0x25: /*      DEC H */
397
398		DEC_8BIT (m_H);
399		break;
400		case 0x26: /*      LD H,n8 */
401
402		m_H = mem_read_byte( m_PC++ );
403		break;
404		case 0x27: /*      DAA */
405		{
406		int tmp = m_A;
407
408		if ( ! ( m_F & LR35902_FLAG_N ) ) {
409		if ( ( m_F & LR35902_FLAG_H ) || ( tmp & 0x0F ) > 9 )
410		tmp += 6;
411		if ( ( m_F & LR35902_FLAG_C ) || tmp > 0x9F )
412		tmp += 0x60;
413		} else {
414		if ( m_F & LR35902_FLAG_H ) {
415		tmp -= 6;
416		if ( ! ( m_F & LR35902_FLAG_C ) )
417		tmp &= 0xFF;
418		}
419		if ( m_F & LR35902_FLAG_C )
420		tmp -= 0x60;
421		}
422		m_F &= ~ ( LR35902_FLAG_H | LR35902_FLAG_Z );
423		if ( tmp & 0x100 )
424		m_F |= LR35902_FLAG_C;
425		m_A = tmp & 0xFF;
426		if ( ! m_A )
427		m_F |= LR35902_FLAG_Z;
428		}
429		break;
430		case 0x28: /*      JR Z,n8 */
431		{
432		INT8 offset = mem_read_byte( m_PC++ );
433
434		if (m_F & LR35902_FLAG_Z)
435		{
436		m_PC += offset;
437		cycles_passed( 4 );
438		}
439		}
440		break;
441		case 0x29: /*      ADD HL,HL */
442		ADD_HL_RR ((m_H << 8 ) | m_L)
443		cycles_passed( 4 );
444		break;
445		case 0x2A: /*      LD A,(HL+) */
446		#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
447		if (m_H == 0xFE)
448		{
449		trash_sprites (state);
450		}
451		#endif
452		m_A = mem_read_byte( ( m_H << 8 ) | m_L );
453		m_L++;
454		if ( m_L == 0 )
455		{
456		m_H++;
457		}
458		break;
459		case 0x2B: /*      DEC HL */
460
461		#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
462		if (m_H == 0xFE)
463		{
464		trash_sprites (state);
465		}
466		#endif
467		m_L--;
468		if ( m_L == 0xFF )
469		{
470		m_H--;
471		}
472		cycles_passed( 4 );
473		break;
474		case 0x2C: /*      INC L */
475
476		INC_8BIT (m_L);
477		break;
478		case 0x2D: /*      DEC L */
479
480		DEC_8BIT (m_L);
481		break;
482		case 0x2E: /*      LD L,n8 */
483
484		m_L = mem_read_byte( m_PC++ );
485		break;
486		case 0x2F: /*      CPL */
487
488		m_A = ~m_A;
489		m_F |= LR35902_FLAG_N | LR35902_FLAG_H;
490		break;
491		case 0x30: /*      JR NC,n8 */
492		{
493		INT8 offset = mem_read_byte( m_PC++ );
494
495		if ( ! (m_F & LR35902_FLAG_C) )
496		{
497		m_PC += offset;
498		cycles_passed( 4 );
499		}
500		}
501		break;
502		case 0x31: /*      LD SP,n16 */
503
504		m_SP = mem_read_word( m_PC );
505		m_PC += 2;
506		break;
507		case 0x32: /*      LD (HL-),A */
508
509		#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
510		if (m_H == 0xFE)
511		{
512		trash_sprites (state);
513		}
514		#endif
515		mem_write_byte( ( m_H << 8 ) | m_L, m_A );
516		m_L--;
517		if ( m_L == 0xFF )
518		{
519		m_H--;
520		}
521		break;
522		case 0x33: /*      INC SP */
523		m_SP += 1;
524		cycles_passed( 4 );
525		break;
526		case 0x34: /*      INC (HL) */
527		{
528		UINT16 addr = ( m_H << 8 ) | m_L;
529		register UINT8 r, f;
530
531		f = (UINT8) (m_F & LR35902_FLAG_C);
532		r = mem_read_byte( addr );
533		r += 1;
534		mem_write_byte( addr, r );
535
536		if (r == 0)
537		f |= LR35902_FLAG_Z;
538
539		if ((r & 0xF) == 0)
540		f |= LR35902_FLAG_H;
541
542		m_F = f;
543		}
544		break;
545		case 0x35: /*      DEC (HL) */
546		{
547		UINT16 addr = ( m_H << 8 ) | m_L;
548		register UINT8 r, f;
549
550		f = (UINT8) ((m_F & LR35902_FLAG_C) | LR35902_FLAG_N);
551		r = mem_read_byte( addr );
552		r -= 1;
553		mem_write_byte( addr, r );
554
555		if (r == 0)
556		f |= LR35902_FLAG_Z;
557
558		if ((r & 0xF) == 0xF)
559		f |= LR35902_FLAG_H;
560
561		m_F = f;
562		}
563		break;
564		case 0x36: /*      LD (HL),n8 */
565		{
566		UINT8 v = mem_read_byte( m_PC++ );
567		mem_write_byte( ( m_H << 8 ) | m_L, v );
568		}
569		break;
570		case 0x37: /*      SCF */
571
572		m_F = (UINT8) ((m_F & LR35902_FLAG_Z) | LR35902_FLAG_C);
573		break;
574		case 0x38: /*      JR C,n8 */
575		{
576		INT8 offset = mem_read_byte( m_PC++ );
577
578		if (m_F & LR35902_FLAG_C)
579		{
580		m_PC += offset;
581		cycles_passed( 4 );
582		}
583		}
584		break;
585		case 0x39: /*      ADD HL,SP */
586		ADD_HL_RR (m_SP)
587		cycles_passed( 4 );
588		break;
589		case 0x3A: /*      LD A,(HL-) */
590		#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
591		if (m_H == 0xFE)
592		{
593		trash_sprites (state);
594		}
595		#endif
596		m_A = mem_read_byte( ( m_H << 8 ) | m_L );
597		m_L--;
598		if ( m_L == 0xFF )
599		{
600		m_H--;
601		}
602		break;
603		case 0x3B: /*      DEC SP */
604		m_SP -= 1;
605		cycles_passed( 4 );
606		break;
607		case 0x3C: /*      INC     A */
608
609		INC_8BIT (m_A);
610		break;
611		case 0x3D: /*      DEC     A */
612
613		DEC_8BIT (m_A);
614		break;
615		case 0x3E: /*      LD A,n8 */
616
617		m_A = mem_read_byte( m_PC++ );
618		break;
619		case 0x3F: /*      CCF */
620
621		m_F = (UINT8) ((m_F & LR35902_FLAG_Z) | ((m_F & LR35902_FLAG_C) ? 0 : LR35902_FLAG_C));
622		break;
623		case 0x40: /*      LD B,B */
624		break;
625		case 0x41: /*      LD B,C */
626
627		m_B = m_C;
628		break;
629		case 0x42: /*      LD B,D */
630
631		m_B = m_D;
632		break;
633		case 0x43: /*      LD B,E */
634
635		m_B = m_E;
636		break;
637		case 0x44: /*      LD B,H */
638
639		m_B = m_H;
640		break;
641		case 0x45: /*      LD B,L */
642
643		m_B = m_L;
644		break;
645		case 0x46: /*      LD B,(HL) */
646		m_B = mem_read_byte( ( m_H << 8 ) | m_L) ;
647		break;
648
649		case 0x47: /*      LD B,A */
650
651		m_B = m_A;
652		break;
653		case 0x48: /*      LD C,B */
654
655		m_C = m_B;
656		break;
657		case 0x49: /*      LD C,C */
658		break;
659		case 0x4A: /*      LD C,D */
660
661		m_C = m_D;
662		break;
663		case 0x4B: /*      LD C,E */
664
665		m_C = m_E;
666		break;
667		case 0x4C: /*      LD C,H */
668
669		m_C = m_H;
670		break;
671		case 0x4D: /*      LD C,L */
672
673		m_C = m_L;
674		break;
675
676		case 0x4E: /*      LD C,(HL) */
677		m_C = mem_read_byte( ( m_H << 8 ) | m_L );
678		break;
679
680		case 0x4F: /*      LD C,A */
681
682		m_C = m_A;
683		break;
684		case 0x50: /*      LD D,B */
685
686		m_D = m_B;
687		break;
688		case 0x51: /*      LD D,C */
689
690		m_D = m_C;
691		break;
692		case 0x52: /*      LD D,D */
693		break;
694		case 0x53: /*      LD D,E */
695
696		m_D = m_E;
697		break;
698		case 0x54: /*      LD D,H */
699
700		m_D = m_H;
701		break;
702		case 0x55: /*      LD D,L */
703
704		m_D = m_L;
705		break;
706		case 0x56: /*      LD D,(HL) */
707
708		m_D = mem_read_byte( ( m_H << 8 ) | m_L );
709		break;
710		case 0x57: /*      LD D,A */
711
712		m_D = m_A;
713		break;
714		case 0x58: /*      LD E,B */
715
716		m_E = m_B;
717		break;
718		case 0x59: /*      LD E,C */
719
720		m_E = m_C;
721		break;
722		case 0x5A: /*      LD E,D */
723
724		m_E = m_D;
725		break;
726		case 0x5B: /*      LD E,E */
727		break;
728		case 0x5C: /*      LD E,H */
729
730		m_E = m_H;
731		break;
732		case 0x5D: /*      LD E,L */
733
734		m_E = m_L;
735		break;
736		case 0x5E: /*      LD E,(HL) */
737
738		m_E = mem_read_byte( ( m_H << 8 ) | m_L );
739		break;
740		case 0x5F: /*      LD E,A */
741
742		m_E = m_A;
743		break;
744		case 0x60: /*      LD H,B */
745
746		m_H = m_B;
747		break;
748		case 0x61: /*      LD H,C */
749
750		m_H = m_C;
751		break;
752		case 0x62: /*      LD H,D */
753
754		m_H = m_D;
755		break;
756		case 0x63: /*      LD H,E */
757
758		m_H = m_E;
759		break;
760		case 0x64: /*      LD H,H */
761		break;
762		case 0x65: /*      LD H,L */
763
764		m_H = m_L;
765		break;
766		case 0x66: /*      LD H,(HL) */
767
768		m_H = mem_read_byte( ( m_H << 8 ) | m_L );
769		break;
770		case 0x67: /*      LD H,A */
771
772		m_H = m_A;
773		break;
774		case 0x68: /*      LD L,B */
775
776		m_L = m_B;
777		break;
778		case 0x69: /*      LD L,C */
779
780		m_L = m_C;
781		break;
782		case 0x6A: /*      LD L,D */
783		m_L = m_D;
784		break;
785		case 0x6B: /*      LD L,E */
786
787		m_L = m_E;
788		break;
789		case 0x6C: /*      LD L,H */
790
791		m_L = m_H;
792		break;
793		case 0x6D: /*      LD L,L */
794		break;
795		case 0x6E: /*      LD L,(HL) */
796
797		m_L = mem_read_byte( ( m_H << 8 ) | m_L );
798		break;
799		case 0x6F: /*      LD L,A */
800
801		m_L = m_A;
802		break;
803
804		case 0x70: /*      LD (HL),B */
805		mem_write_byte( ( m_H << 8 ) | m_L, m_B );
806		break;
807
808		case 0x71: /*      LD (HL),C */
809		mem_write_byte( ( m_H << 8 ) | m_L, m_C );
810		break;
811		case 0x72: /*      LD (HL),D */
812		mem_write_byte( ( m_H << 8 ) | m_L, m_D );
813		break;
814		case 0x73: /*      LD (HL),E */
815		mem_write_byte( ( m_H << 8 ) | m_L, m_E );
816		break;
817		case 0x74: /*      LD (HL),H */
818		mem_write_byte( ( m_H << 8 ) | m_L, m_H );
819		break;
820		case 0x75: /*      LD (HL),L */
821		mem_write_byte( ( m_H << 8 ) | m_L, m_L );
822		break;
823		case 0x76: /*      HALT */
824		m_enable |= HALTED;
825		m_PC--;
826		break;
827		case 0x77: /*      LD (HL),A */
828		mem_write_byte( ( m_H << 8 ) | m_L, m_A );
829		break;
830		case 0x78: /*      LD A,B */
831
832		m_A = m_B;
833		break;
834		case 0x79: /*      LD A,C */
835
836		m_A = m_C;
837		break;
838		case 0x7A: /*      LD A,D */
839
840		m_A = m_D;
841		break;
842		case 0x7B: /*      LD A,E */
843
844		m_A = m_E;
845		break;
846		case 0x7C: /*      LD A,H */
847
848		m_A = m_H;
849		break;
850		case 0x7D: /*      LD A,L */
851
852		m_A = m_L;
853		break;
854		case 0x7E: /*      LD A,(HL) */
855
856		m_A = mem_read_byte( ( m_H << 8 ) | m_L );
857		break;
858		case 0x7F: /*      LD A,A */
859		break;
860		case 0x80: /*      ADD A,B */
861
862		ADD_A_X (m_B)
863		break;
864		case 0x81: /*      ADD A,C */
865
866		ADD_A_X (m_C)
867		break;
868		case 0x82: /*      ADD A,D */
869
870		ADD_A_X (m_D)
871		break;
872		case 0x83: /*      ADD A,E */
873
874		ADD_A_X (m_E)
875		break;
876		case 0x84: /*      ADD A,H */
877
878		ADD_A_X (m_H)
879		break;
880		case 0x85: /*      ADD A,L */
881
882		ADD_A_X (m_L)
883		break;
884		case 0x86: /*      ADD A,(HL) */
885
886		x = mem_read_byte( ( m_H << 8 ) | m_L );
887
888		ADD_A_X (x)
889		break;
890		case 0x87: /*      ADD A,A */
891
892		ADD_A_X (m_A)
893		break;
894		case 0x88: /*      ADC A,B */
895
896		ADC_A_X (m_B)
897		break;
898		case 0x89: /*      ADC A,C */
899
900		ADC_A_X (m_C)
901		break;
902		case 0x8A: /*      ADC A,D */
903
904		ADC_A_X (m_D)
905		break;
906		case 0x8B: /*      ADC A,E */
907
908		ADC_A_X (m_E)
909		break;
910		case 0x8C: /*      ADC A,H */
911
912		ADC_A_X (m_H)
913		break;
914		case 0x8D: /*      ADC A,L */
915
916		ADC_A_X (m_L)
917		break;
918		case 0x8E: /*      ADC A,(HL) */
919
920		x = mem_read_byte( ( m_H << 8 ) | m_L );
921
922		ADC_A_X (x)
923		break;
924		case 0x8F: /*      ADC A,A */
925
926		ADC_A_X (m_A)
927		break;
928		case 0x90: /*      SUB A,B */
929
930		SUB_A_X (m_B)
931		break;
932		case 0x91: /*      SUB A,C */
933
934		SUB_A_X (m_C)
935		break;
936		case 0x92: /*      SUB A,D */
937
938		SUB_A_X (m_D)
939		break;
940		case 0x93: /*      SUB A,E */
941
942		SUB_A_X (m_E)
943		break;
944		case 0x94: /*      SUB A,H */
945
946		SUB_A_X (m_H)
947		break;
948		case 0x95: /*      SUB A,L */
949
950		SUB_A_X (m_L)
951		break;
952		case 0x96: /*      SUB A,(HL) */
953
954
955		x = mem_read_byte( ( m_H << 8 ) | m_L );
956
957		SUB_A_X (x)
958		break;
959		case 0x97: /*      SUB A,A */
960
961		SUB_A_X (m_A)
962		break;
963		case 0x98: /*      SBC A,B */
964
965		SBC_A_X (m_B)
966		break;
967		case 0x99: /*      SBC A,C */
968
969		SBC_A_X (m_C)
970		break;
971		case 0x9A: /*      SBC A,D */
972
973		SBC_A_X (m_D)
974		break;
975		case 0x9B: /*      SBC A,E */
976
977		SBC_A_X (m_E)
978		break;
979		case 0x9C: /*      SBC A,H */
980
981		SBC_A_X (m_H)
982		break;
983		case 0x9D: /*      SBC A,L */
984
985		SBC_A_X (m_L)
986		break;
987		case 0x9E: /*      SBC A,(HL) */
988
989		x = mem_read_byte( ( m_H << 8 ) | m_L );
990
991		SBC_A_X (x)
992		break;
993		case 0x9F: /*      SBC A,A */
994
995		SBC_A_X (m_A)
996		break;
997		case 0xA0: /*      AND A,B */
998
999		AND_A_X (m_B)
1000		break;
1001		case 0xA1: /*      AND A,C */
1002
1003		AND_A_X (m_C)
1004		break;
1005		case 0xA2: /*      AND A,D */
1006
1007		AND_A_X (m_D)
1008		break;
1009		case 0xA3: /*      AND A,E */
1010
1011		AND_A_X (m_E)
1012		break;
1013		case 0xA4: /*      AND A,H */
1014
1015		AND_A_X (m_H)
1016		break;
1017		case 0xA5: /*      AND A,L */
1018
1019		AND_A_X (m_L)
1020		break;
1021		case 0xA6: /*      AND A,(HL) */
1022
1023		x = mem_read_byte( ( m_H << 8 ) | m_L );
1024
1025		AND_A_X (x)
1026		break;
1027		case 0xA7: /*      AND A,A */
1028
1029		m_F = (m_A == 0) ? (LR35902_FLAG_H | LR35902_FLAG_Z) : LR35902_FLAG_H;
1030		break;
1031		case 0xA8: /*      XOR A,B */
1032
1033		XOR_A_X (m_B)
1034		break;
1035		case 0xA9: /*      XOR A,C */
1036
1037		XOR_A_X (m_C)
1038		break;
1039		case 0xAA: /*      XOR A,D */
1040
1041		XOR_A_X (m_D)
1042		break;
1043		case 0xAB: /*      XOR A,E */
1044
1045		XOR_A_X (m_E)
1046		break;
1047		case 0xAC: /*      XOR A,H */
1048
1049		XOR_A_X (m_H)
1050		break;
1051		case 0xAD: /*      XOR A,L */
1052
1053		XOR_A_X (m_L)
1054		break;
1055		case 0xAE: /*      XOR A,(HL) */
1056
1057		x = mem_read_byte( ( m_H << 8 ) | m_L );
1058
1059		XOR_A_X (x)
1060		break;
1061		case 0xAF: /*      XOR A,A */
1062
1063		XOR_A_X (m_A)
1064		break;
1065		case 0xB0: /*      OR A,B */
1066
1067		OR_A_X (m_B)
1068		break;
1069		case 0xB1: /*      OR A,C */
1070
1071		OR_A_X (m_C)
1072		break;
1073		case 0xB2: /*      OR A,D */
1074
1075		OR_A_X (m_D)
1076		break;
1077		case 0xB3: /*      OR A,E */
1078
1079		OR_A_X (m_E)
1080		break;
1081		case 0xB4: /*      OR A,H */
1082
1083		OR_A_X (m_H)
1084		break;
1085		case 0xB5: /*      OR A,L */
1086
1087		OR_A_X (m_L)
1088		break;
1089		case 0xB6: /*      OR A,(HL) */
1090
1091		x = mem_read_byte( ( m_H << 8 ) | m_L );
1092
1093		OR_A_X (x)
1094		break;
1095		case 0xB7: /*      OR A,A */
1096
1097		OR_A_X (m_A)
1098		break;
1099		case 0xB8: /*      CP A,B */
1100
1101		CP_A_X (m_B)
1102		break;
1103		case 0xB9: /*      CP A,C */
1104
1105		CP_A_X (m_C)
1106		break;
1107		case 0xBA: /*      CP A,D */
1108
1109		CP_A_X (m_D)
1110		break;
1111		case 0xBB: /*      CP A,E */
1112
1113		CP_A_X (m_E)
1114		break;
1115		case 0xBC: /*      CP A,H */
1116
1117		CP_A_X (m_H)
1118		break;
1119		case 0xBD: /*      CP A,L */
1120
1121		CP_A_X (m_L)
1122		break;
1123		case 0xBE: /*      CP A,(HL) */
1124
1125		x = mem_read_byte( ( m_H << 8 ) | m_L );
1126
1127		CP_A_X (x)
1128		break;
1129		case 0xBF: /*      CP A,A */
1130
1131		CP_A_X (m_A)
1132		break;
1133		case 0xC0: /*      RET NZ */
1134		cycles_passed( 4 );
1135		if (!(m_F & LR35902_FLAG_Z))
1136		{
1137		m_PC = mem_read_word( m_SP );
1138		m_SP += 2;
1139		cycles_passed( 4 );
1140		}
1141		break;
1142		case 0xC1: /*      POP BC */
1143		POP( m_B, m_C );
1144		break;
1145		case 0xC2: /*      JP NZ,n16 */
1146		{
1147		UINT16 addr = mem_read_word( m_PC );
1148		m_PC += 2;
1149
1150		if ( ! (m_F & LR35902_FLAG_Z) )
1151		{
1152		m_PC = addr;
1153		cycles_passed( 4 );
1154		}
1155		}
1156		break;
1157		case 0xC3: /*      JP n16 */
1158		m_PC = mem_read_word( m_PC );
1159		cycles_passed( 4 );
1160		break;
1161		case 0xC4: /*      CALL NZ,n16 */
1162		{
1163		UINT16 addr = mem_read_word( m_PC );
1164		m_PC += 2;
1165
1166		if ( ! (m_F & LR35902_FLAG_Z) )
1167		{
1168		m_SP -= 2;
1169		mem_write_word( m_SP, m_PC );
1170		m_PC = addr;
1171		cycles_passed( 4 );
1172		}
1173		}
1174		break;
1175		case 0xC5: /*      PUSH BC */
1176		PUSH( m_B, m_C );
1177		cycles_passed( 4 );
1178		break;
1179		case 0xC6: /*      ADD A,n8 */
1180
1181		x = mem_read_byte( m_PC++ );
1182		ADD_A_X (x)
1183		break;
1184		case 0xC7: /*      RST 0 */
1185		m_SP -= 2;
1186		mem_write_word( m_SP, m_PC );
1187		m_PC = 0;
1188		cycles_passed( 4 );
1189		break;
1190		case 0xC8: /*      RET Z */
1191		cycles_passed( 4 );
1192		if (m_F & LR35902_FLAG_Z)
1193		{
1194		m_PC = mem_read_word( m_SP );
1195		m_SP += 2;
1196		cycles_passed( 4 );
1197		}
1198		break;
1199		case 0xC9: /*      RET */
1200		m_PC = mem_read_word( m_SP );
1201		m_SP += 2;
1202		cycles_passed( 4 );
1203		break;
1204		case 0xCA: /*      JP Z,n16 */
1205		{
1206		UINT16 addr = mem_read_word( m_PC );
1207		m_PC += 2;
1208
1209		if (m_F & LR35902_FLAG_Z)
1210		{
1211		m_PC = addr;
1212		cycles_passed( 4 );
1213		}
1214		}
1215		break;
1216		case 0xCB: /*      PREFIX! */
1217		x = mem_read_byte( m_PC++ );
1218		switch (x)
1219		{
1220		#include "opc_cb.h"
1221		}
1222		break;
1223		case 0xCC: /*      CALL Z,n16 */
1224		{
1225		UINT16 addr = mem_read_word( m_PC );
1226		m_PC += 2;
1227
1228		if (m_F & LR35902_FLAG_Z)
1229		{
1230		m_SP -= 2;
1231		mem_write_word( m_SP, m_PC );
1232		m_PC = addr;
1233		cycles_passed( 4 );
1234		}
1235		}
1236		break;
1237		case 0xCD: /*      CALL n16 */
1238		{
1239		UINT16 addr = mem_read_word( m_PC );
1240		m_PC += 2;
1241
1242		m_SP -= 2;
1243		mem_write_word( m_SP, m_PC );
1244		m_PC = addr;
1245		cycles_passed( 4 );
1246		}
1247		break;
1248		case 0xCE: /*      ADC A,n8 */
1249
1250		x = mem_read_byte( m_PC++ );
1251		ADC_A_X (x)
1252		break;
1253		case 0xCF: /*      RST 8 */
1254		m_SP -= 2;
1255		mem_write_word( m_SP, m_PC );
1256		m_PC = 8;
1257		cycles_passed( 4 );
1258		break;
1259		case 0xD0: /*      RET NC */
1260		cycles_passed( 4 );
1261		if (!(m_F & LR35902_FLAG_C))
1262		{
1263		m_PC = mem_read_word( m_SP );
1264		m_SP += 2;
1265		cycles_passed( 4 );
1266		}
1267		break;
1268		case 0xD1: /*      POP DE */
1269		POP( m_D, m_E );
1270		break;
1271		case 0xD2: /*      JP NC,n16 */
1272		{
1273		UINT16 addr = mem_read_word( m_PC );
1274		m_PC += 2;
1275
1276		if ( ! (m_F & LR35902_FLAG_C) )
1277		{
1278		m_PC = addr;
1279		cycles_passed( 4 );
1280		}
1281		}
1282		break;
1283		case 0xD3: /*      EH? */
1284		break;
1285		case 0xD4: /*      CALL NC,n16 */
1286		{
1287		UINT16 addr = mem_read_word( m_PC );
1288		m_PC += 2;
1289
1290		if ( ! (m_F & LR35902_FLAG_C) )
1291		{
1292		m_SP -= 2;
1293		mem_write_word( m_SP, m_PC );
1294		m_PC = addr;
1295		cycles_passed( 4 );
1296		}
1297		}
1298		break;
1299		case 0xD5: /*      PUSH DE */
1300		PUSH( m_D, m_E );
1301		cycles_passed( 4 );
1302		break;
1303		case 0xD6: /*      SUB A,n8 */
1304
1305		x = mem_read_byte( m_PC++ );
1306		SUB_A_X (x)
1307		break;
1308		case 0xD7: /*      RST     $10 */
1309		m_SP -= 2;
1310		mem_write_word( m_SP, m_PC );
1311		m_PC = 0x10;
1312		cycles_passed( 4 );
1313		break;
1314		case 0xD8: /*      RET C */
1315		cycles_passed( 4 );
1316		if (m_F & LR35902_FLAG_C)
1317		{
1318		m_PC = mem_read_word( m_SP );
1319		m_SP += 2;
1320		cycles_passed( 4 );
1321		}
1322		break;
1323		case 0xD9: /*      RETI */
1324		m_PC = mem_read_word( m_SP );
1325		m_SP += 2;
1326		m_enable |= IME;
1327		cycles_passed( 4 );
1328		break;
1329		case 0xDA: /*      JP C,n16 */
1330		{
1331		UINT16 addr = mem_read_word( m_PC );
1332		m_PC += 2;
1333
1334		if (m_F & LR35902_FLAG_C)
1335		{
1336		m_PC = addr;
1337		cycles_passed( 4 );
1338		}
1339		}
1340		break;
1341		case 0xDB: /*      EH? */
1342		break;
1343		case 0xDC: /*      CALL C,n16 */
1344		{
1345		UINT16 addr = mem_read_word( m_PC );
1346		m_PC += 2;
1347
1348		if (m_F & LR35902_FLAG_C)
1349		{
1350		m_SP -= 2;
1351		mem_write_word( m_SP, m_PC );
1352		m_PC = addr;
1353		cycles_passed( 4 );
1354		}
1355		}
1356		break;
1357		case 0xDD: /*      EH? */
1358		break;
1359		case 0xDE: /*      SBC A,n8 */
1360
1361		x = mem_read_byte( m_PC++ );
1362		SBC_A_X (x)
1363		break;
1364		case 0xDF: /*      RST     $18 */
1365		m_SP -= 2;
1366		mem_write_word( m_SP, m_PC );
1367		m_PC = 0x18;
1368		cycles_passed( 4 );
1369		break;
1370		case 0xE0: /*      LD      ($FF00+n8),A */
1371		{
1372		UINT8 v = mem_read_byte( m_PC++ );
1373		mem_write_byte( 0xFF00 + v, m_A );
1374		}
1375		break;
1376		case 0xE1: /*      POP HL */
1377		POP( m_H, m_L );
1378		break;
1379		case 0xE2: /*      LD ($FF00+C),A */
1380
1381		mem_write_byte( 0xFF00 + m_C, m_A );
1382		break;
1383		case 0xE3: /*      EH? */
1384		break;
1385		case 0xE4: /*      EH? */
1386		break;
1387		case 0xE5: /*      PUSH HL */
1388		PUSH( m_H, m_L );
1389		cycles_passed( 4 );
1390		break;
1391		case 0xE6: /*      AND A,n8 */
1392
1393		x = mem_read_byte( m_PC++ );
1394		AND_A_X (x)
1395		break;
1396		case 0xE7: /*      RST $20 */
1397		m_SP -= 2;
1398		mem_write_word( m_SP, m_PC );
1399		m_PC = 0x20;
1400		cycles_passed( 4 );
1401		break;
1402		case 0xE8: /*      ADD SP,n8 */
1403		/*
1404		*   Z - Reset.
1405		*   N - Reset.
1406		*   H - Set or reset according to operation.
1407		*   C - Set or reset according to operation.
1408		*/
1409
1410		{
1411		register INT32 n;
1412
1413		n = (INT8) mem_read_byte( m_PC++ );
1414
1415		if ( ( m_SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF )
1416		{
1417		m_F = LR35902_FLAG_C;
1418		}
1419		else
1420		{
1421		m_F = 0;
1422		}
1423
1424		if ( ( m_SP & 0x0F ) + ( n & 0x0F ) > 0x0F )
1425		{
1426		m_F |= LR35902_FLAG_H;
1427		}
1428
1429		m_SP = (UINT16) ( m_SP + n );
1430		}
1431		cycles_passed( 8 );
1432		break;
1433		case 0xE9: /*      JP (HL) */
1434		m_PC = ( m_H << 8 ) | m_L;
1435		break;
1436		case 0xEA: /*      LD (n16),A */
1437
1438		mem_write_byte( mem_read_word( m_PC ), m_A );
1439		m_PC += 2;
1440		break;
1441		case 0xEB: /*      EH? */
1442		break;
1443		case 0xEC: /*      EH? */
1444		break;
1445		case 0xED: /*      EH? */
1446		break;
1447		case 0xEE: /*      XOR A,n8 */
1448
1449		x = mem_read_byte( m_PC++ );
1450		XOR_A_X (x)
1451		break;
1452		case 0xEF: /*      RST $28 */
1453		m_SP -= 2;
1454		mem_write_word( m_SP, m_PC );
1455		m_PC = 0x28;
1456		cycles_passed( 4 );
1457		break;
1458		case 0xF0: /*      LD A,($FF00+n8) */
1459		{
1460		UINT8 v = mem_read_byte( m_PC++ );
1461		m_A = mem_read_byte( 0xFF00 + v );
1462		}
1463		break;
1464		case 0xF1: /*      POP AF */
1465		POP( m_A, m_F );
1466		m_F &= 0xF0;
1467		break;
1468		case 0xF2: /*      LD A,($FF00+C) */
1469
1470		m_A = mem_read_byte( 0xFF00 + m_C );
1471		break;
1472		case 0xF3: /*      DI */
1473		m_ei_delay = 0;
1474		m_enable &= ~IME;
1475		break;
1476		case 0xF4: /*      EH? */
1477		break;
1478		case 0xF5: /*      PUSH AF */
1479		m_F &= 0xF0;
1480		PUSH( m_A, m_F );
1481		cycles_passed( 4 );
1482		break;
1483		case 0xF6: /*      OR A,n8 */
1484
1485		x = mem_read_byte( m_PC++ );
1486		OR_A_X (x)
1487		break;
1488		case 0xF7: /*      RST $30 */
1489		m_SP -= 2;
1490		mem_write_word( m_SP, m_PC );
1491		m_PC = 0x30;
1492		cycles_passed( 4 );
1493		break;
1494		case 0xF8: /*      LD HL,SP+n8 */
1495		/*
1496		*   n = one UINT8 signed immediate value.
1497		* Flags affected:
1498		*   Z - Reset.
1499		*   N - Reset.
1500		*   H - Set or reset according to operation.
1501		*   C - Set or reset according to operation.
1502		*
1503		*/
1504
1505		{
1506		register INT32 n;
1507
1508		n = (INT8) mem_read_byte( m_PC++ );
1509
1510		if ( ( m_SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF )
1511		{
1512		m_F = LR35902_FLAG_C;
1513		}
1514		else
1515		{
1516		m_F = 0;
1517		}
1518
1519		if ( ( m_SP & 0x0F ) + ( n & 0x0F ) > 0x0F )
1520		{
1521		m_F |= LR35902_FLAG_H;
1522		}
1523
1524		UINT16 res = m_SP + n;
1525
1526		m_L = res & 0xFF;
1527		m_H = res >> 8;
1528		}
1529		cycles_passed( 4 );
1530		break;
1531		case 0xF9: /*      LD SP,HL */
1532		m_SP = ( m_H << 8 ) | m_L;
1533		cycles_passed( 4 );
1534		break;
1535		case 0xFA: /*      LD A,(n16) */
1536		m_A = mem_read_byte( mem_read_word( m_PC ) );
1537		m_PC += 2;
1538		break;
1539		case 0xFB: /*      EI */
1540		m_enable |= IME;
1541		m_ei_delay = 1;
1542		break;
1543		case 0xFC: /*      EH? */
1544		break;
1545		case 0xFD: /*      EH? */
1546		break;
1547		case 0xFE: /*      CP A,n8 */
1548		x = mem_read_byte( m_PC++ );
1549		CP_A_X (x)
1550		break;
1551		case 0xFF: /*      RST $38 */
1552		m_SP -= 2;
1553		mem_write_word( m_SP, m_PC );
1554		m_PC = 0x38;
1555		cycles_passed( 4 );
1556		break;

trunk/src/emu/cpu/lr35902/opc_cb.inc

r0	r30965
	1	#define RLC_8BIT(x)             \
	2	{                               \
	3	register UINT8 f;           \
	4	(x)=(UINT8)(((x)<<1)|((x)>>7));      \
	5	if( (x)&1 )                 \
	6	f=FLAG_C;               \
	7	else                        \
	8	f=0;                    \
	9	if( (x)==0 )                \
	10	f|=FLAG_Z;              \
	11	m_F=f;          \
	12	}
	13
	14	#define RL_8BIT(x)              \
	15	{                               \
	16	register UINT8 r;           \
	17	r=((x)&0x80)?FLAG_C:0;      \
	18	(x)=(UINT8)(((x)<<1)|((m_F&FLAG_C)?1:0));    \
	19	if( (x)==0 )                \
	20	r|=FLAG_Z;              \
	21	m_F=r;          \
	22	}
	23
	24	#define RRC_8BIT(x)             \
	25	{                               \
	26	register UINT8 f;           \
	27	(x)=(UINT8)(((x)>>1)|((x)<<7));      \
	28	if( (x)&0x80 )              \
	29	f=FLAG_C;               \
	30	else                        \
	31	f=0;                    \
	32	if( (x)==0 )                \
	33	f|=FLAG_Z;              \
	34	m_F=f;          \
	35	}
	36
	37	#define RR_8BIT(x)              \
	38	{                               \
	39	register UINT8 r;           \
	40	r=((x)&1)?FLAG_C:0;         \
	41	(x)=(UINT8)(((x)>>1)|((m_F&FLAG_C)?0x80:0));     \
	42	if( (x)==0 )                \
	43	r|=FLAG_Z;              \
	44	m_F=r;          \
	45	}
	46
	47	#define SLA_8BIT(x)             \
	48	{                               \
	49	register UINT8 f;           \
	50	if( (x)&0x80 )              \
	51	f=FLAG_C;               \
	52	else                        \
	53	f=0;                    \
	54	(x)<<=1;                    \
	55	if( (x)==0 )                \
	56	f|=FLAG_Z;              \
	57	m_F=f;          \
	58	}
	59
	60	#define SRA_8BIT(x)             \
	61	{                               \
	62	register UINT8 f;           \
	63	if( (x)&1 )                 \
	64	f=FLAG_C;               \
	65	else                        \
	66	f=0;                    \
	67	(x)=(UINT8)(((char)(x))>>1);     \
	68	if( (x)==0 )                \
	69	f|=FLAG_Z;              \
	70	m_F=f;          \
	71	}
	72
	73	#define SWAP_8BIT(x)            \
	74	(x)=(UINT8)(((x)>>4)|((x)<<4));      \
	75	if( (x)==0 )                \
	76	m_F=FLAG_Z; \
	77	else                        \
	78	m_F=0;
	79
	80
	81	#define SRL_8BIT(x)             \
	82	{                               \
	83	register UINT8 f;           \
	84	if( (x)&1 )                 \
	85	f=FLAG_C;               \
	86	else                        \
	87	f=0;                    \
	88	(x)>>=1;                    \
	89	if( (x)==0 )                \
	90	f|=FLAG_Z;              \
	91	m_F=f;          \
	92	}
	93
	94	#define BIT_8BIT(n,x)           \
	95	if( (x)&(1<<(n)) )          \
	96	m_F=(UINT8)(FLAG_H|(m_F&FLAG_C));  \
	97	else                        \
	98	m_F=(UINT8)(FLAG_Z|FLAG_H|(m_F&FLAG_C));
	99
	100	#define RES_8BIT(n,x)   (x)&=~(1<<(n));
	101
	102	#define SET_8BIT(n,x)   (x)|=(1<<(n));
	103
	104
	105	case 0x00:
	106	/*      RLC B */
	107
	108	RLC_8BIT (m_B)
	109	break;
	110	case 0x01:
	111	/*      RLC C */
	112
	113	RLC_8BIT (m_C)
	114	break;
	115	case 0x02:
	116	/*      RLC D */
	117
	118	RLC_8BIT (m_D)
	119	break;
	120	case 0x03:
	121	/*      RLC E */
	122
	123	RLC_8BIT (m_E)
	124	break;
	125	case 0x04:
	126	/*      RLC H */
	127
	128	RLC_8BIT (m_H)
	129	break;
	130	case 0x05:
	131	/*      RLC L */
	132
	133	RLC_8BIT (m_L)
	134	break;
	135	case 0x06:
	136	/*      RLC (HL) */
	137	{
	138	UINT16 addr = ( m_H << 8 ) | m_L;
	139
	140	x = mem_read_byte( addr );
	141	RLC_8BIT (x)
	142	mem_write_byte( addr, x );
	143	}
	144	break;
	145	case 0x07:
	146	/*      RLC A */
	147
	148	RLC_8BIT (m_A)
	149	break;
	150	case 0x08:
	151	/*      RRC B */
	152
	153	RRC_8BIT (m_B)
	154	break;
	155	case 0x09:
	156	/*      RRC C */
	157
	158	RRC_8BIT (m_C)
	159	break;
	160	case 0x0A:
	161	/*      RRC D */
	162
	163	RRC_8BIT (m_D)
	164	break;
	165	case 0x0B:
	166	/*      RRC E */
	167
	168	RRC_8BIT (m_E)
	169	break;
	170	case 0x0C:
	171	/*      RRC H */
	172
	173	RRC_8BIT (m_H)
	174	break;
	175	case 0x0D:
	176	/*      RRC L */
	177
	178	RRC_8BIT (m_L)
	179	break;
	180	case 0x0E:
	181	/*      RRC (HL) */
	182	{
	183	UINT16 addr = ( m_H << 8 ) | m_L;
	184
	185	x = mem_read_byte( addr);
	186	RRC_8BIT (x)
	187	mem_write_byte( addr, x);
	188	}
	189	break;
	190	case 0x0F:
	191	/*      RRC A */
	192
	193	RRC_8BIT (m_A)
	194	break;
	195	case 0x10:
	196	/*      RL B */
	197
	198	RL_8BIT (m_B)
	199	break;
	200	case 0x11:
	201	/*      RL C */
	202
	203	RL_8BIT (m_C)
	204	break;
	205	case 0x12:
	206	/*      RL D */
	207
	208	RL_8BIT (m_D)
	209	break;
	210	case 0x13:
	211	/*      RL E */
	212
	213	RL_8BIT (m_E)
	214	break;
	215	case 0x14:
	216	/*      RL H */
	217
	218	RL_8BIT (m_H)
	219	break;
	220	case 0x15:
	221	/*      RL L */
	222
	223	RL_8BIT (m_L)
	224	break;
	225	case 0x16:
	226	/*      RL (HL) */
	227	{
	228	UINT16 addr = ( m_H << 8 ) | m_L;
	229
	230	x = mem_read_byte( addr);
	231	RL_8BIT (x)
	232	mem_write_byte( addr, x);
	233	}
	234	break;
	235	case 0x17:
	236	/*      RL A */
	237
	238	RL_8BIT (m_A)
	239	break;
	240	case 0x18:
	241	/*      RR B */
	242
	243	RR_8BIT (m_B)
	244	break;
	245	case 0x19:
	246	/*      RR C */
	247
	248	RR_8BIT (m_C)
	249	break;
	250	case 0x1A:
	251	/*      RR D */
	252
	253	RR_8BIT (m_D)
	254	break;
	255	case 0x1B:
	256	/*      RR E */
	257
	258	RR_8BIT (m_E)
	259	break;
	260	case 0x1C:
	261	/*      RR H */
	262
	263	RR_8BIT (m_H)
	264	break;
	265	case 0x1D:
	266	/*      RR L */
	267
	268	RR_8BIT (m_L)
	269	break;
	270	case 0x1E:
	271	/*      RR (HL) */
	272	{
	273	UINT16 addr = ( m_H << 8 ) | m_L;
	274
	275	x = mem_read_byte( addr);
	276	RR_8BIT (x)
	277	mem_write_byte( addr, x);
	278	}
	279	break;
	280	case 0x1F:
	281	/*      RR A */
	282
	283	RR_8BIT (m_A)
	284	break;
	285	case 0x20:
	286	/*      SLA B */
	287
	288	SLA_8BIT (m_B)
	289	break;
	290	case 0x21:
	291	/*      SLA C */
	292
	293	SLA_8BIT (m_C)
	294	break;
	295	case 0x22:
	296	/*      SLA D */
	297
	298	SLA_8BIT (m_D)
	299	break;
	300	case 0x23:
	301	/*      SLA E */
	302
	303	SLA_8BIT (m_E)
	304	break;
	305	case 0x24:
	306	/*      SLA H */
	307
	308	SLA_8BIT (m_H)
	309	break;
	310	case 0x25:
	311	/*      SLA L */
	312
	313	SLA_8BIT (m_L)
	314	break;
	315	case 0x26:
	316	/*      SLA (HL) */
	317	{
	318	UINT16 addr = ( m_H << 8 ) | m_L;
	319
	320	x = mem_read_byte( addr);
	321	SLA_8BIT (x)
	322	mem_write_byte( addr, x);
	323	}
	324	break;
	325	case 0x27:
	326	/*      SLA A */
	327
	328	SLA_8BIT (m_A)
	329	break;
	330	case 0x28:
	331	/*      SRA B */
	332
	333	SRA_8BIT (m_B)
	334	break;
	335	case 0x29:
	336	/*      SRA C */
	337
	338	SRA_8BIT (m_C)
	339	break;
	340	case 0x2A:
	341	/*      SRA D */
	342
	343	SRA_8BIT (m_D)
	344	break;
	345	case 0x2B:
	346	/*      SRA E */
	347
	348	SRA_8BIT (m_E)
	349	break;
	350	case 0x2C:
	351	/*      SRA H */
	352
	353	SRA_8BIT (m_H)
	354	break;
	355	case 0x2D:
	356	/*      SRA L */
	357
	358	SRA_8BIT (m_L)
	359	break;
	360	case 0x2E:
	361	/*      SRA (HL) */
	362	{
	363	UINT16 addr = ( m_H << 8 ) | m_L;
	364
	365	x = mem_read_byte( addr);
	366	SRA_8BIT (x)
	367	mem_write_byte( addr, x);
	368	}
	369	break;
	370	case 0x2F:
	371	/*      SRA A */
	372
	373	SRA_8BIT (m_A)
	374	break;
	375	case 0x30:
	376	/*      SWAP B */
	377
	378	SWAP_8BIT (m_B)
	379	break;
	380	case 0x31:
	381	/*      SWAP C */
	382
	383	SWAP_8BIT (m_C)
	384	break;
	385	case 0x32:
	386	/*      SWAP D */
	387
	388	SWAP_8BIT (m_D)
	389	break;
	390	case 0x33:
	391	/*      SWAP E */
	392
	393	SWAP_8BIT (m_E)
	394	break;
	395	case 0x34:
	396	/*      SWAP H */
	397
	398	SWAP_8BIT (m_H)
	399	break;
	400	case 0x35:
	401	/*      SWAP L */
	402
	403	SWAP_8BIT (m_L)
	404	break;
	405	case 0x36:
	406	/*      SWAP (HL) */
	407	{
	408	UINT16 addr = ( m_H << 8 ) | m_L;
	409
	410	x = mem_read_byte( addr);
	411	SWAP_8BIT (x)
	412	mem_write_byte( addr, x);
	413	}
	414	break;
	415	case 0x37:
	416	/*      SWAP A */
	417
	418	SWAP_8BIT (m_A)
	419	break;
	420	case 0x38:
	421	/*      SRL B */
	422
	423	SRL_8BIT (m_B)
	424	break;
	425	case 0x39:
	426	/*      SRL C */
	427
	428	SRL_8BIT (m_C)
	429	break;
	430	case 0x3A:
	431	/*      SRL D */
	432
	433	SRL_8BIT (m_D)
	434	break;
	435	case 0x3B:
	436	/*      SRL E */
	437
	438	SRL_8BIT (m_E)
	439	break;
	440	case 0x3C:
	441	/*      SRL H */
	442
	443	SRL_8BIT (m_H)
	444	break;
	445	case 0x3D:
	446	/*      SRL L */
	447
	448	SRL_8BIT (m_L)
	449	break;
	450	case 0x3E:
	451	/*      SRL (HL) */
	452	{
	453	UINT16 addr = ( m_H << 8 ) | m_L;
	454
	455	x = mem_read_byte( addr);
	456	SRL_8BIT (x)
	457	mem_write_byte( addr, x);
	458	}
	459	break;
	460	case 0x3F:
	461	/*      SRL A */
	462
	463	SRL_8BIT (m_A)
	464	break;
	465	case 0x40:
	466	/*      BIT 0,B */
	467
	468	BIT_8BIT (0, m_B)
	469	break;
	470	case 0x41:
	471	/*      BIT 0,C */
	472
	473	BIT_8BIT (0, m_C)
	474	break;
	475	case 0x42:
	476	/*      BIT 0,D */
	477
	478	BIT_8BIT (0, m_D)
	479	break;
	480	case 0x43:
	481	/*      BIT 0,E */
	482
	483	BIT_8BIT (0, m_E)
	484	break;
	485	case 0x44:
	486	/*      BIT 0,H */
	487
	488	BIT_8BIT (0, m_H)
	489	break;
	490	case 0x45:
	491	/*      BIT 0,L */
	492
	493	BIT_8BIT (0, m_L)
	494	break;
	495	case 0x46:
	496	/*      BIT 0,(HL) */
	497	{
	498	UINT16 addr = ( m_H << 8 ) | m_L;
	499
	500	x = mem_read_byte( addr);
	501	BIT_8BIT (0, x)
	502	}
	503	break;
	504	case 0x47:
	505	/*      BIT 0,A */
	506
	507	BIT_8BIT (0, m_A)
	508	break;
	509	case 0x48:
	510	/*      BIT 1,B */
	511
	512	BIT_8BIT (1, m_B)
	513	break;
	514	case 0x49:
	515	/*      BIT 1,C */
	516
	517	BIT_8BIT (1, m_C)
	518	break;
	519	case 0x4A:
	520	/*      BIT 1,D */
	521
	522	BIT_8BIT (1, m_D)
	523	break;
	524	case 0x4B:
	525	/*      BIT 1,E */
	526
	527	BIT_8BIT (1, m_E)
	528	break;
	529	case 0x4C:
	530	/*      BIT 1,H */
	531
	532	BIT_8BIT (1, m_H)
	533	break;
	534	case 0x4D:
	535	/*      BIT 1,L */
	536
	537	BIT_8BIT (1, m_L)
	538	break;
	539	case 0x4E:
	540	/*      BIT 1,(HL) */
	541	{
	542	UINT16 addr = ( m_H << 8 ) | m_L;
	543
	544	x = mem_read_byte( addr);
	545	BIT_8BIT (1, x)
	546	}
	547	break;
	548	case 0x4F:
	549	/*      BIT 1,A */
	550
	551	BIT_8BIT (1, m_A)
	552	break;
	553	case 0x50:
	554	/*      BIT 2,B */
	555
	556	BIT_8BIT (2, m_B)
	557	break;
	558	case 0x51:
	559	/*      BIT 2,C */
	560
	561	BIT_8BIT (2, m_C)
	562	break;
	563	case 0x52:
	564	/*      BIT 2,D */
	565
	566	BIT_8BIT (2, m_D)
	567	break;
	568	case 0x53:
	569	/*      BIT 2,E */
	570
	571	BIT_8BIT (2, m_E)
	572	break;
	573	case 0x54:
	574	/*      BIT 2,H */
	575
	576	BIT_8BIT (2, m_H)
	577	break;
	578	case 0x55:
	579	/*      BIT 2,L */
	580
	581	BIT_8BIT (2, m_L)
	582	break;
	583	case 0x56:
	584	/*      BIT 2,(HL) */
	585	{
	586	UINT16 addr = ( m_H << 8 ) | m_L;
	587
	588	x = mem_read_byte( addr);
	589	BIT_8BIT (2, x)
	590	}
	591	break;
	592	case 0x57:
	593	/*      BIT 2,A */
	594
	595	BIT_8BIT (2, m_A)
	596	break;
	597	case 0x58:
	598	/*      BIT 3,B */
	599
	600	BIT_8BIT (3, m_B)
	601	break;
	602	case 0x59:
	603	/*      BIT 3,C */
	604
	605	BIT_8BIT (3, m_C)
	606	break;
	607	case 0x5A:
	608	/*      BIT 3,D */
	609
	610	BIT_8BIT (3, m_D)
	611	break;
	612	case 0x5B:
	613	/*      BIT 3,E */
	614
	615	BIT_8BIT (3, m_E)
	616	break;
	617	case 0x5C:
	618	/*      BIT 3,H */
	619
	620	BIT_8BIT (3, m_H)
	621	break;
	622	case 0x5D:
	623	/*      BIT 3,L */
	624
	625	BIT_8BIT (3, m_L)
	626	break;
	627	case 0x5E:
	628	/*      BIT 3,(HL) */
	629	{
	630	UINT16 addr = ( m_H << 8 ) | m_L;
	631
	632	x = mem_read_byte( addr);
	633	BIT_8BIT (3, x)
	634	}
	635	break;
	636	case 0x5F:
	637	/*      BIT 3,A */
	638
	639	BIT_8BIT (3, m_A)
	640	break;
	641	case 0x60:
	642	/*      BIT 4,B */
	643
	644	BIT_8BIT (4, m_B)
	645	break;
	646	case 0x61:
	647	/*      BIT 4,C */
	648
	649	BIT_8BIT (4, m_C)
	650	break;
	651	case 0x62:
	652	/*      BIT 4,D */
	653
	654	BIT_8BIT (4, m_D)
	655	break;
	656	case 0x63:
	657	/*      BIT 4,E */
	658
	659	BIT_8BIT (4, m_E)
	660	break;
	661	case 0x64:
	662	/*      BIT 4,H */
	663
	664	BIT_8BIT (4, m_H)
	665	break;
	666	case 0x65:
	667	/*      BIT 4,L */
	668
	669	BIT_8BIT (4, m_L)
	670	break;
	671	case 0x66:
	672	/*      BIT 4,(HL) */
	673	{
	674	UINT16 addr = ( m_H << 8 ) | m_L;
	675
	676	x = mem_read_byte( addr);
	677	BIT_8BIT (4, x)
	678	}
	679	break;
	680	case 0x67:
	681	/*      BIT 4,A */
	682
	683	BIT_8BIT (4, m_A)
	684	break;
	685	case 0x68:
	686	/*      BIT 5,B */
	687
	688	BIT_8BIT (5, m_B)
	689	break;
	690	case 0x69:
	691	/*      BIT 5,C */
	692
	693	BIT_8BIT (5, m_C)
	694	break;
	695	case 0x6A:
	696	/*      BIT 5,D */
	697
	698	BIT_8BIT (5, m_D)
	699	break;
	700	case 0x6B:
	701	/*      BIT 5,E */
	702
	703	BIT_8BIT (5, m_E)
	704	break;
	705	case 0x6C:
	706	/*      BIT 5,H */
	707
	708	BIT_8BIT (5, m_H)
	709	break;
	710	case 0x6D:
	711	/*      BIT 5,L */
	712
	713	BIT_8BIT (5, m_L)
	714	break;
	715	case 0x6E:
	716	/*      BIT 5,(HL) */
	717	{
	718	UINT16 addr = ( m_H << 8 ) | m_L;
	719
	720	x = mem_read_byte( addr);
	721	BIT_8BIT (5, x)
	722	}
	723	break;
	724	case 0x6F:
	725	/*      BIT 5,A */
	726
	727	BIT_8BIT (5, m_A)
	728	break;
	729	case 0x70:
	730	/*      BIT 6,B */
	731
	732	BIT_8BIT (6, m_B)
	733	break;
	734	case 0x71:
	735	/*      BIT 6,C */
	736
	737	BIT_8BIT (6, m_C)
	738	break;
	739	case 0x72:
	740	/*      BIT 6,D */
	741
	742	BIT_8BIT (6, m_D)
	743	break;
	744	case 0x73:
	745	/*      BIT 6,E */
	746
	747	BIT_8BIT (6, m_E)
	748	break;
	749	case 0x74:
	750	/*      BIT 6,H */
	751
	752	BIT_8BIT (6, m_H)
	753	break;
	754	case 0x75:
	755	/*      BIT 6,L */
	756
	757	BIT_8BIT (6, m_L)
	758	break;
	759	case 0x76:
	760	/*      BIT 6,(HL) */
	761	{
	762	UINT16 addr = ( m_H << 8 ) | m_L;
	763
	764	x = mem_read_byte( addr);
	765	BIT_8BIT (6, x)
	766	}
	767	break;
	768	case 0x77:
	769	/*      BIT 6,A */
	770
	771	BIT_8BIT (6, m_A)
	772	break;
	773	case 0x78:
	774	/*      BIT 7,B */
	775
	776	BIT_8BIT (7, m_B)
	777	break;
	778	case 0x79:
	779	/*      BIT 7,C */
	780
	781	BIT_8BIT (7, m_C)
	782	break;
	783	case 0x7A:
	784	/*      BIT 7,D */
	785
	786	BIT_8BIT (7, m_D)
	787	break;
	788	case 0x7B:
	789	/*      BIT 7,E */
	790
	791	BIT_8BIT (7, m_E)
	792	break;
	793	case 0x7C:
	794	/*      BIT 7,H */
	795
	796	BIT_8BIT (7, m_H)
	797	break;
	798	case 0x7D:
	799	/*      BIT 7,L */
	800
	801	BIT_8BIT (7, m_L)
	802	break;
	803	case 0x7E:
	804	/*      BIT 7,(HL) */
	805	{
	806	UINT16 addr = ( m_H << 8 ) | m_L;
	807
	808	x = mem_read_byte( addr);
	809	BIT_8BIT (7, x)
	810	}
	811	break;
	812	case 0x7F:
	813	/*      BIT 7,A */
	814
	815	BIT_8BIT (7, m_A)
	816	break;
	817	case 0x80:
	818	/*      RES 0,B */
	819
	820	RES_8BIT (0, m_B)
	821	break;
	822	case 0x81:
	823	/*      RES 0,C */
	824
	825	RES_8BIT (0, m_C)
	826	break;
	827	case 0x82:
	828	/*      RES 0,D */
	829
	830	RES_8BIT (0, m_D)
	831	break;
	832	case 0x83:
	833	/*      RES 0,E */
	834
	835	RES_8BIT (0, m_E)
	836	break;
	837	case 0x84:
	838	/*      RES 0,H */
	839
	840	RES_8BIT (0, m_H)
	841	break;
	842	case 0x85:
	843	/*      RES 0,L */
	844
	845	RES_8BIT (0, m_L)
	846	break;
	847	case 0x86:
	848	/*      RES 0,(HL) */
	849	{
	850	UINT16 addr = ( m_H << 8 ) | m_L;
	851
	852	x = mem_read_byte( addr);
	853	RES_8BIT (0, x)
	854	mem_write_byte( addr, x);
	855	}
	856	break;
	857	case 0x87:
	858	/*      RES 0,A */
	859
	860	RES_8BIT (0, m_A)
	861	break;
	862	case 0x88:
	863	/*      RES 1,B */
	864
	865	RES_8BIT (1, m_B)
	866	break;
	867	case 0x89:
	868	/*      RES 1,C */
	869
	870	RES_8BIT (1, m_C)
	871	break;
	872	case 0x8A:
	873	/*      RES 1,D */
	874
	875	RES_8BIT (1, m_D)
	876	break;
	877	case 0x8B:
	878	/*      RES 1,E */
	879
	880	RES_8BIT (1, m_E)
	881	break;
	882	case 0x8C:
	883	/*      RES 1,H */
	884
	885	RES_8BIT (1, m_H)
	886	break;
	887	case 0x8D:
	888	/*      RES 1,L */
	889
	890	RES_8BIT (1, m_L)
	891	break;
	892	case 0x8E:
	893	/*      RES 1,(HL) */
	894	{
	895	UINT16 addr = ( m_H << 8 ) | m_L;
	896
	897	x = mem_read_byte( addr);
	898	RES_8BIT (1, x)
	899	mem_write_byte( addr, x);
	900	}
	901	break;
	902	case 0x8F:
	903	/*      RES 1,A */
	904
	905	RES_8BIT (1, m_A)
	906	break;
	907	case 0x90:
	908	/*      RES 2,B */
	909
	910	RES_8BIT (2, m_B)
	911	break;
	912	case 0x91:
	913	/*      RES 2,C */
	914
	915	RES_8BIT (2, m_C)
	916	break;
	917	case 0x92:
	918	/*      RES 2,D */
	919
	920	RES_8BIT (2, m_D)
	921	break;
	922	case 0x93:
	923	/*      RES 2,E */
	924
	925	RES_8BIT (2, m_E)
	926	break;
	927	case 0x94:
	928	/*      RES 2,H */
	929
	930	RES_8BIT (2, m_H)
	931	break;
	932	case 0x95:
	933	/*      RES 2,L */
	934
	935	RES_8BIT (2, m_L)
	936	break;
	937	case 0x96:
	938	/*      RES 2,(HL) */
	939	{
	940	UINT16 addr = ( m_H << 8 ) | m_L;
	941
	942	x = mem_read_byte( addr);
	943	RES_8BIT (2, x)
	944	mem_write_byte( addr, x);
	945	}
	946	break;
	947	case 0x97:
	948	/*      RES 2,A */
	949
	950	RES_8BIT (2, m_A)
	951	break;
	952	case 0x98:
	953	/*      RES 3,B */
	954
	955	RES_8BIT (3, m_B)
	956	break;
	957	case 0x99:
	958	/*      RES 3,C */
	959
	960	RES_8BIT (3, m_C)
	961	break;
	962	case 0x9A:
	963	/*      RES 3,D */
	964
	965	RES_8BIT (3, m_D)
	966	break;
	967	case 0x9B:
	968	/*      RES 3,E */
	969
	970	RES_8BIT (3, m_E)
	971	break;
	972	case 0x9C:
	973	/*      RES 3,H */
	974
	975	RES_8BIT (3, m_H)
	976	break;
	977	case 0x9D:
	978	/*      RES 3,L */
	979
	980	RES_8BIT (3, m_L)
	981	break;
	982	case 0x9E:
	983	/*      RES 3,(HL) */
	984	{
	985	UINT16 addr = ( m_H << 8 ) | m_L;
	986
	987	x = mem_read_byte( addr);
	988	RES_8BIT (3, x)
	989	mem_write_byte( addr, x);
	990	}
	991	break;
	992	case 0x9F:
	993	/*      RES 3,A */
	994
	995	RES_8BIT (3, m_A)
	996	break;
	997	case 0xA0:
	998	/*      RES 4,B */
	999
	1000	RES_8BIT (4, m_B)
	1001	break;
	1002	case 0xA1:
	1003	/*      RES 4,C */
	1004
	1005	RES_8BIT (4, m_C)
	1006	break;
	1007	case 0xA2:
	1008	/*      RES 4,D */
	1009
	1010	RES_8BIT (4, m_D)
	1011	break;
	1012	case 0xA3:
	1013	/*      RES 4,E */
	1014
	1015	RES_8BIT (4, m_E)
	1016	break;
	1017	case 0xA4:
	1018	/*      RES 4,H */
	1019
	1020	RES_8BIT (4, m_H)
	1021	break;
	1022	case 0xA5:
	1023	/*      RES 4,L */
	1024
	1025	RES_8BIT (4, m_L)
	1026	break;
	1027	case 0xA6:
	1028	/*      RES 4,(HL) */
	1029	{
	1030	UINT16 addr = ( m_H << 8 ) | m_L;
	1031
	1032	x = mem_read_byte( addr);
	1033	RES_8BIT (4, x)
	1034	mem_write_byte( addr, x);
	1035	}
	1036	break;
	1037	case 0xA7:
	1038	/*      RES 4,A */
	1039
	1040	RES_8BIT (4, m_A)
	1041	break;
	1042	case 0xA8:
	1043	/*      RES 5,B */
	1044
	1045	RES_8BIT (5, m_B)
	1046	break;
	1047	case 0xA9:
	1048	/*      RES 5,C */
	1049
	1050	RES_8BIT (5, m_C)
	1051	break;
	1052	case 0xAA:
	1053	/*      RES 5,D */
	1054
	1055	RES_8BIT (5, m_D)
	1056	break;
	1057	case 0xAB:
	1058	/*      RES 5,E */
	1059
	1060	RES_8BIT (5, m_E)
	1061	break;
	1062	case 0xAC:
	1063	/*      RES 5,H */
	1064
	1065	RES_8BIT (5, m_H)
	1066	break;
	1067	case 0xAD:
	1068	/*      RES 5,L */
	1069
	1070	RES_8BIT (5, m_L)
	1071	break;
	1072	case 0xAE:
	1073	/*      RES 5,(HL) */
	1074	{
	1075	UINT16 addr = ( m_H << 8 ) | m_L;
	1076
	1077	x = mem_read_byte( addr);
	1078	RES_8BIT (5, x)
	1079	mem_write_byte( addr, x);
	1080	}
	1081	break;
	1082	case 0xAF:
	1083	/*      RES 5,A */
	1084
	1085	RES_8BIT (5, m_A)
	1086	break;
	1087	case 0xB0:
	1088	/*      RES 6,B */
	1089
	1090	RES_8BIT (6, m_B)
	1091	break;
	1092	case 0xB1:
	1093	/*      RES 6,C */
	1094
	1095	RES_8BIT (6, m_C)
	1096	break;
	1097	case 0xB2:
	1098	/*      RES 6,D */
	1099
	1100	RES_8BIT (6, m_D)
	1101	break;
	1102	case 0xB3:
	1103	/*      RES 6,E */
	1104
	1105	RES_8BIT (6, m_E)
	1106	break;
	1107	case 0xB4:
	1108	/*      RES 6,H */
	1109
	1110	RES_8BIT (6, m_H)
	1111	break;
	1112	case 0xB5:
	1113	/*      RES 6,L */
	1114
	1115	RES_8BIT (6, m_L)
	1116	break;
	1117	case 0xB6:
	1118	/*      RES 6,(HL) */
	1119	{
	1120	UINT16 addr = ( m_H << 8 ) | m_L;
	1121
	1122	x = mem_read_byte( addr);
	1123	RES_8BIT (6, x)
	1124	mem_write_byte( addr, x);
	1125	}
	1126	break;
	1127	case 0xB7:
	1128	/*      RES 6,A */
	1129
	1130	RES_8BIT (6, m_A)
	1131	break;
	1132	case 0xB8:
	1133	/*      RES 7,B */
	1134
	1135	RES_8BIT (7, m_B)
	1136	break;
	1137	case 0xB9:
	1138	/*      RES 7,C */
	1139
	1140	RES_8BIT (7, m_C)
	1141	break;
	1142	case 0xBA:
	1143	/*      RES 7,D */
	1144
	1145	RES_8BIT (7, m_D)
	1146	break;
	1147	case 0xBB:
	1148	/*      RES 7,E */
	1149
	1150	RES_8BIT (7, m_E)
	1151	break;
	1152	case 0xBC:
	1153	/*      RES 7,H */
	1154
	1155	RES_8BIT (7, m_H)
	1156	break;
	1157	case 0xBD:
	1158	/*      RES 7,L */
	1159
	1160	RES_8BIT (7, m_L)
	1161	break;
	1162	case 0xBE:
	1163	/*      RES 7,(HL) */
	1164	{
	1165	UINT16 addr = ( m_H << 8 ) | m_L;
	1166
	1167	x = mem_read_byte( addr);
	1168	RES_8BIT (7, x)
	1169	mem_write_byte( addr, x);
	1170	}
	1171	break;
	1172	case 0xBF:
	1173	/*      RES 7,A */
	1174
	1175	RES_8BIT (7, m_A)
	1176	break;
	1177	case 0xC0:
	1178	/*      SET 0,B */
	1179
	1180	SET_8BIT (0, m_B)
	1181	break;
	1182	case 0xC1:
	1183	/*      SET 0,C */
	1184
	1185	SET_8BIT (0, m_C)
	1186	break;
	1187	case 0xC2:
	1188	/*      SET 0,D */
	1189
	1190	SET_8BIT (0, m_D)
	1191	break;
	1192	case 0xC3:
	1193	/*      SET 0,E */
	1194
	1195	SET_8BIT (0, m_E)
	1196	break;
	1197	case 0xC4:
	1198	/*      SET 0,H */
	1199
	1200	SET_8BIT (0, m_H)
	1201	break;
	1202	case 0xC5:
	1203	/*      SET 0,L */
	1204
	1205	SET_8BIT (0, m_L)
	1206	break;
	1207	case 0xC6:
	1208	/*      SET 0,(HL) */
	1209	{
	1210	UINT16 addr = ( m_H << 8 ) | m_L;
	1211
	1212	x = mem_read_byte( addr);
	1213	SET_8BIT (0, x)
	1214	mem_write_byte( addr, x);
	1215	}
	1216	break;
	1217	case 0xC7:
	1218	/*      SET 0,A */
	1219
	1220	SET_8BIT (0, m_A)
	1221	break;
	1222	case 0xC8:
	1223	/*      SET 1,B */
	1224
	1225	SET_8BIT (1, m_B)
	1226	break;
	1227	case 0xC9:
	1228	/*      SET 1,C */
	1229
	1230	SET_8BIT (1, m_C)
	1231	break;
	1232	case 0xCA:
	1233	/*      SET 1,D */
	1234
	1235	SET_8BIT (1, m_D)
	1236	break;
	1237	case 0xCB:
	1238	/*      SET 1,E */
	1239
	1240	SET_8BIT (1, m_E)
	1241	break;
	1242	case 0xCC:
	1243	/*      SET 1,H */
	1244
	1245	SET_8BIT (1, m_H)
	1246	break;
	1247	case 0xCD:
	1248	/*      SET 1,L */
	1249
	1250	SET_8BIT (1, m_L)
	1251	break;
	1252	case 0xCE:
	1253	/*      SET 1,(HL) */
	1254	{
	1255	UINT16 addr = ( m_H << 8 ) | m_L;
	1256
	1257	x = mem_read_byte( addr);
	1258	SET_8BIT (1, x)
	1259	mem_write_byte( addr, x);
	1260	}
	1261	break;
	1262	case 0xCF:
	1263	/*      SET 1,A */
	1264
	1265	SET_8BIT (1, m_A)
	1266	break;
	1267	case 0xD0:
	1268	/*      SET 2,B */
	1269
	1270	SET_8BIT (2, m_B)
	1271	break;
	1272	case 0xD1:
	1273	/*      SET 2,C */
	1274
	1275	SET_8BIT (2, m_C)
	1276	break;
	1277	case 0xD2:
	1278	/*      SET 2,D */
	1279
	1280	SET_8BIT (2, m_D)
	1281	break;
	1282	case 0xD3:
	1283	/*      SET 2,E */
	1284
	1285	SET_8BIT (2, m_E)
	1286	break;
	1287	case 0xD4:
	1288	/*      SET 2,H */
	1289
	1290	SET_8BIT (2, m_H)
	1291	break;
	1292	case 0xD5:
	1293	/*      SET 2,L */
	1294
	1295	SET_8BIT (2, m_L)
	1296	break;
	1297	case 0xD6:
	1298	/*      SET 2,(HL) */
	1299	{
	1300	UINT16 addr = ( m_H << 8 ) | m_L;
	1301
	1302	x = mem_read_byte( addr);
	1303	SET_8BIT (2, x)
	1304	mem_write_byte( addr, x);
	1305	}
	1306	break;
	1307	case 0xD7:
	1308	/*      SET 2,A */
	1309
	1310	SET_8BIT (2, m_A)
	1311	break;
	1312	case 0xD8:
	1313	/*      SET 3,B */
	1314
	1315	SET_8BIT (3, m_B)
	1316	break;
	1317	case 0xD9:
	1318	/*      SET 3,C */
	1319
	1320	SET_8BIT (3, m_C)
	1321	break;
	1322	case 0xDA:
	1323	/*      SET 3,D */
	1324
	1325	SET_8BIT (3, m_D)
	1326	break;
	1327	case 0xDB:
	1328	/*      SET 3,E */
	1329
	1330	SET_8BIT (3, m_E)
	1331	break;
	1332	case 0xDC:
	1333	/*      SET 3,H */
	1334
	1335	SET_8BIT (3, m_H)
	1336	break;
	1337	case 0xDD:
	1338	/*      SET 3,L */
	1339
	1340	SET_8BIT (3, m_L)
	1341	break;
	1342	case 0xDE:
	1343	/*      SET 3,(HL) */
	1344	{
	1345	UINT16 addr = ( m_H << 8 ) | m_L;
	1346
	1347	x = mem_read_byte( addr);
	1348	SET_8BIT (3, x)
	1349	mem_write_byte( addr, x);
	1350	}
	1351	break;
	1352	case 0xDF:
	1353	/*      SET 3,A */
	1354
	1355	SET_8BIT (3, m_A)
	1356	break;
	1357	case 0xE0:
	1358	/*      SET 4,B */
	1359
	1360	SET_8BIT (4, m_B)
	1361	break;
	1362	case 0xE1:
	1363	/*      SET 4,C */
	1364
	1365	SET_8BIT (4, m_C)
	1366	break;
	1367	case 0xE2:
	1368	/*      SET 4,D */
	1369
	1370	SET_8BIT (4, m_D)
	1371	break;
	1372	case 0xE3:
	1373	/*      SET 4,E */
	1374
	1375	SET_8BIT (4, m_E)
	1376	break;
	1377	case 0xE4:
	1378	/*      SET 4,H */
	1379
	1380	SET_8BIT (4, m_H)
	1381	break;
	1382	case 0xE5:
	1383	/*      SET 4,L */
	1384
	1385	SET_8BIT (4, m_L)
	1386	break;
	1387	case 0xE6:
	1388	/*      SET 4,(HL) */
	1389	{
	1390	UINT16 addr = ( m_H << 8 ) | m_L;
	1391
	1392	x = mem_read_byte( addr);
	1393	SET_8BIT (4, x)
	1394	mem_write_byte( addr, x);
	1395	}
	1396	break;
	1397	case 0xE7:
	1398	/*      SET 4,A */
	1399
	1400	SET_8BIT (4, m_A)
	1401	break;
	1402	case 0xE8:
	1403	/*      SET 5,B */
	1404
	1405	SET_8BIT (5, m_B)
	1406	break;
	1407	case 0xE9:
	1408	/*      SET 5,C */
	1409
	1410	SET_8BIT (5, m_C)
	1411	break;
	1412	case 0xEA:
	1413	/*      SET 5,D */
	1414
	1415	SET_8BIT (5, m_D)
	1416	break;
	1417	case 0xEB:
	1418	/*      SET 5,E */
	1419
	1420	SET_8BIT (5, m_E)
	1421	break;
	1422	case 0xEC:
	1423	/*      SET 5,H */
	1424
	1425	SET_8BIT (5, m_H)
	1426	break;
	1427	case 0xED:
	1428	/*      SET 5,L */
	1429
	1430	SET_8BIT (5, m_L)
	1431	break;
	1432	case 0xEE:
	1433	/*      SET 5,(HL) */
	1434	{
	1435	UINT16 addr = ( m_H << 8 ) | m_L;
	1436
	1437	x = mem_read_byte( addr);
	1438	SET_8BIT (5, x)
	1439	mem_write_byte( addr, x);
	1440	}
	1441	break;
	1442	case 0xEF:
	1443	/*      SET 5,A */
	1444
	1445	SET_8BIT (5, m_A)
	1446	break;
	1447	case 0xF0:
	1448	/*      SET 6,B */
	1449
	1450	SET_8BIT (6, m_B)
	1451	break;
	1452	case 0xF1:
	1453	/*      SET 6,C */
	1454
	1455	SET_8BIT (6, m_C)
	1456	break;
	1457	case 0xF2:
	1458	/*      SET 6,D */
	1459
	1460	SET_8BIT (6, m_D)
	1461	break;
	1462	case 0xF3:
	1463	/*      SET 6,E */
	1464
	1465	SET_8BIT (6, m_E)
	1466	break;
	1467	case 0xF4:
	1468	/*      SET 6,H */
	1469
	1470	SET_8BIT (6, m_H)
	1471	break;
	1472	case 0xF5:
	1473	/*      SET 6,L */
	1474
	1475	SET_8BIT (6, m_L)
	1476	break;
	1477	case 0xF6:
	1478	/*      SET 6,(HL) */
	1479	{
	1480	UINT16 addr = ( m_H << 8 ) | m_L;
	1481
	1482	x = mem_read_byte( addr);
	1483	SET_8BIT (6, x)
	1484	mem_write_byte( addr, x);
	1485	}
	1486	break;
	1487	case 0xF7:
	1488	/*      SET 6,A */
	1489
	1490	SET_8BIT (6, m_A)
	1491	break;
	1492	case 0xF8:
	1493	/*      SET 7,B */
	1494
	1495	SET_8BIT (7, m_B)
	1496	break;
	1497	case 0xF9:
	1498	/*      SET 7,C */
	1499
	1500	SET_8BIT (7, m_C)
	1501	break;
	1502	case 0xFA:
	1503	/*      SET 7,D */
	1504
	1505	SET_8BIT (7, m_D)
	1506	break;
	1507	case 0xFB:
	1508	/*      SET 7,E */
	1509
	1510	SET_8BIT (7, m_E)
	1511	break;
	1512	case 0xFC:
	1513	/*      SET 7,H */
	1514
	1515	SET_8BIT (7, m_H)
	1516	break;
	1517	case 0xFD:
	1518	/*      SET 7,L */
	1519
	1520	SET_8BIT (7, m_L)
	1521	break;
	1522	case 0xFE:
	1523	/*      SET 7,(HL) */
	1524	{
	1525	UINT16 addr = ( m_H << 8 ) | m_L;
	1526
	1527	x = mem_read_byte( addr);
	1528	SET_8BIT (7, x)
	1529	mem_write_byte( addr, x);
	1530	}
	1531	break;
	1532	case 0xFF:
	1533	/*      SET 7,A */
	1534
	1535	SET_8BIT (7, m_A)
	1536	break;

Property changes on: trunk/src/emu/cpu/lr35902/opc_cb.inc

Added: svn:mime-type    + text/plain Added: svn:eol-style    + native

trunk/src/emu/cpu/lr35902/opc_main.inc

r0	r30965
	1	#define INC_8BIT(x) \
	2	{ \
	3	register UINT8 r,f; \
	4	x++; \
	5	r=(x);  \
	6	f=(UINT8)(m_F&FLAG_C); \
	7	if( r==0 )       f|=FLAG_Z; \
	8	if( (r&0xF)==0 ) f|=FLAG_H; \
	9	m_F=f; \
	10	}
	11
	12	#define DEC_8BIT(x) \
	13	{ \
	14	register UINT8 r,f; \
	15	x--; \
	16	r=(x);  \
	17	f=(UINT8)((m_F&FLAG_C)|FLAG_N); \
	18	if( r==0 )       f|=FLAG_Z; \
	19	if( (r&0xF)==0xF ) f|=FLAG_H; \
	20	m_F=f; \
	21	}
	22
	23	#define ADD_HL_RR(x) \
	24	{ \
	25	register UINT32 r1,r2; \
	26	register UINT8 f; \
	27	r1=((m_H<<8)|m_L)+(x); \
	28	r2=(((m_H<<8)|m_L)&0xFFF)+((x)&0xFFF); \
	29	f=(UINT8)(m_F&FLAG_Z); \
	30	if( r1>0xFFFF ) f|=FLAG_C; \
	31	if( r2>0x0FFF ) f|=FLAG_H; \
	32	m_L = r1; \
	33	m_H = r1 >> 8; \
	34	m_F=f; \
	35	}
	36
	37	#define ADD_A_X(x) \
	38	{ \
	39	register UINT16 r1,r2; \
	40	register UINT8 f; \
	41	r1=(UINT16)((m_A&0xF)+((x)&0xF)); \
	42	r2=(UINT16)(m_A+(x)); \
	43	m_A=(UINT8)r2; \
	44	if( ((UINT8)r2)==0 ) f=FLAG_Z; \
	45	else f=0; \
	46	if( r2>0xFF ) f|=FLAG_C; \
	47	if( r1>0xF )  f|=FLAG_H; \
	48	m_F=f; \
	49	}
	50
	51	#define SUB_A_X(x) \
	52	{ \
	53	register UINT16 r1,r2; \
	54	register UINT8 f; \
	55	r1=(UINT16)((m_A&0xF)-((x)&0xF)); \
	56	r2=(UINT16)(m_A-(x)); \
	57	m_A=(UINT8)r2; \
	58	if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
	59	else f=FLAG_N; \
	60	if( r2>0xFF ) f|=FLAG_C; \
	61	if( r1>0xF )  f|=FLAG_H; \
	62	m_F=f; \
	63	}
	64
	65	/*
	66	#define      CP_A_X(x) \
	67	{ \
	68	register UINT16 r; \
	69	register UINT8 f; \
	70	r=(UINT16)(m_A-(x)); \
	71	if( ((UINT8)r)==0 ) \
	72	f=FLAG_N|FLAG_Z; \
	73	else \
	74	f=FLAG_N; \
	75	f|=(UINT8)((r>>8)&FLAG_C); \
	76	if( (r^m_A^(x))&0x10 ) \
	77	f|=FLAG_H; \
	78	m_F=f; \
	79	}
	80	*/
	81
	82	#define CP_A_X(x) \
	83	{ \
	84	register UINT16 r1,r2; \
	85	register UINT8 f; \
	86	r1=(UINT16)((m_A&0xF)-((x)&0xF)); \
	87	r2=(UINT16)(m_A-(x)); \
	88	if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
	89	else f=FLAG_N; \
	90	if( r2>0xFF ) f|=FLAG_C; \
	91	if( r1>0xF )  f|=FLAG_H; \
	92	m_F=f; \
	93	}
	94
	95	#define SBC_A_X(x) \
	96	{ \
	97	register UINT16 r1,r2; \
	98	register UINT8 f; \
	99	r1=(UINT16)((m_A&0xF)-((x)&0xF)-((m_F&FLAG_C)?1:0)); \
	100	r2=(UINT16)(m_A-(x)-((m_F&FLAG_C)?1:0)); \
	101	m_A=(UINT8)r2; \
	102	if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
	103	else f=FLAG_N; \
	104	if( r2>0xFF ) f|=FLAG_C; \
	105	if( r1>0xF )  f|=FLAG_H; \
	106	m_F=f; \
	107	}
	108
	109	#define ADC_A_X(x) \
	110	{ \
	111	register UINT16 r1,r2;  \
	112	register UINT8 f; \
	113	r1=(UINT16)((m_A&0xF)+((x)&0xF)+((m_F&FLAG_C)?1:0));  \
	114	r2=(UINT16)(m_A+(x)+((m_F&FLAG_C)?1:0)); \
	115	if( (m_A=(UINT8)r2)==0 ) f=FLAG_Z; \
	116	else f=0; \
	117	if( r2>0xFF )   f|=FLAG_C; \
	118	if( r1>0xF )    f|=FLAG_H; \
	119	m_F=f; \
	120	}
	121
	122	#define AND_A_X(x) \
	123	if( (m_A&=(x))==0 ) \
	124	m_F=FLAG_H|FLAG_Z; \
	125	else \
	126	m_F=FLAG_H;
	127
	128	#define XOR_A_X(x) \
	129	if( (m_A^=(x))==0 ) \
	130	m_F=FLAG_Z; \
	131	else \
	132	m_F=0;
	133
	134	#define OR_A_X(x) \
	135	if( (m_A|=(x))==0 ) \
	136	m_F=FLAG_Z; \
	137	else \
	138	m_F=0;
	139
	140	#define POP(x,y) \
	141	y = mem_read_byte( m_SP++ ); \
	142	x = mem_read_byte( m_SP++ );
	143
	144	#define PUSH(x,y) \
	145	m_SP--; \
	146	mem_write_byte( m_SP, x ); \
	147	m_SP--; \
	148	mem_write_byte( m_SP, y );
	149
	150	case 0x00: /*      NOP */
	151	break;
	152
	153	case 0x01: /*      LD BC,n16 */
	154	m_C = mem_read_byte( m_PC++ );
	155	m_B = mem_read_byte( m_PC++ );
	156	break;
	157
	158	case 0x02: /*      LD (BC),A */
	159	mem_write_byte( ( m_B << 8 ) | m_C, m_A );
	160	break;
	161
	162	case 0x03: /*      INC BC */
	163	#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
	164	if (m_B == 0xFE)
	165	{
	166	trash_sprites (state);
	167	}
	168	#endif
	169	m_C++;
	170	if ( m_C == 0 )
	171	{
	172	m_B++;
	173	}
	174	cycles_passed( 4 );
	175	break;
	176	case 0x04: /*      INC B */
	177	INC_8BIT (m_B)
	178	break;
	179	case 0x05: /*      DEC B */
	180
	181	DEC_8BIT (m_B)
	182	break;
	183
	184	case 0x06: /*      LD B,n8 */
	185	m_B = mem_read_byte( m_PC++ );
	186	break;
	187
	188	case 0x07: /*      RLCA */
	189
	190	m_A = (UINT8) ((m_A << 1) | (m_A >> 7));
	191	if (m_A & 1)
	192	{
	193	m_F = FLAG_C;
	194	}
	195	else
	196	{
	197	m_F = 0;
	198	}
	199	break;
	200
	201	case 0x08: /*      LD (n16),SP */
	202	mem_write_word (mem_read_word (m_PC), m_SP);
	203	m_PC += 2;
	204	break;
	205
	206	case 0x09: /*      ADD HL,BC */
	207	ADD_HL_RR ((m_B<<8)|m_C)
	208	cycles_passed( 4 );
	209	break;
	210	case 0x0A: /*      LD A,(BC) */
	211
	212	m_A = mem_read_byte ( (m_B<<8)|m_C );
	213	break;
	214	case 0x0B: /*      DEC BC */
	215
	216	#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
	217	if (m_B == 0xFE)
	218	{
	219	trash_sprites (state);
	220	}
	221	#endif
	222	m_C--;
	223	if ( m_C == 0xFF )
	224	{
	225	m_B--;
	226	}
	227	cycles_passed( 4 );
	228	break;
	229	case 0x0C: /*      INC C */
	230
	231	INC_8BIT (m_C)
	232	break;
	233	case 0x0D: /*      DEC C */
	234
	235	DEC_8BIT (m_C)
	236	break;
	237	case 0x0E: /*      LD C,n8 */
	238
	239	m_C = mem_read_byte ( m_PC++ );
	240	break;
	241	case 0x0F: /*      RRCA */
	242
	243	m_A = (UINT8) ((m_A >> 1) | (m_A << 7));
	244	m_F = 0;
	245	if (m_A & 0x80)
	246	{
	247	m_F |= FLAG_C;
	248	}
	249	break;
	250	case 0x10: /*      STOP */
	251	if ( m_gb_speed_change_pending ) {
	252	m_gb_speed = ( m_gb_speed == 1 ) ? 2 : 1;
	253	}
	254	m_gb_speed_change_pending = 0;
	255	break;
	256	case 0x11: /*      LD DE,n16 */
	257	m_E = mem_read_byte( m_PC++ );
	258	m_D = mem_read_byte( m_PC++ );
	259	break;
	260	case 0x12: /*      LD (DE),A */
	261	mem_write_byte( ( m_D << 8 ) | m_E, m_A );
	262	break;
	263	case 0x13: /*      INC DE */
	264
	265	#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
	266	if (m_D == 0xFE)
	267	{
	268	trash_sprites (state);
	269	}
	270	#endif
	271	m_E++;
	272	if ( m_E == 0 )
	273	{
	274	m_D++;
	275	}
	276	cycles_passed( 4 );
	277	break;
	278	case 0x14: /*      INC D */
	279
	280	INC_8BIT (m_D)
	281	break;
	282	case 0x15: /*      DEC D */
	283
	284	DEC_8BIT (m_D)
	285	break;
	286	case 0x16: /*      LD D,n8 */
	287
	288	m_D = mem_read_byte ( m_PC++ );
	289	break;
	290	case 0x17: /*      RLA */
	291
	292	x = (m_A & 0x80) ? FLAG_C : 0;
	293
	294	m_A = (UINT8) ((m_A << 1) | ((m_F & FLAG_C) ? 1 : 0));
	295	m_F = x;
	296	break;
	297	case 0x18: /*      JR      n8 */
	298	{
	299	INT8 offset;
	300
	301	offset = mem_read_byte( m_PC++ );
	302	m_PC += offset;
	303	cycles_passed( 4 );
	304	}
	305	break;
	306	case 0x19: /*      ADD HL,DE */
	307	ADD_HL_RR (( m_D << 8 ) | m_E)
	308	cycles_passed( 4 );
	309	break;
	310	case 0x1A: /*      LD A,(DE) */
	311
	312	m_A = mem_read_byte( ( m_D << 8 ) | m_E );
	313	break;
	314	case 0x1B: /*      DEC DE */
	315
	316	#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
	317	if (m_D == 0xFE)
	318	{
	319	trash_sprites (state);
	320	}
	321	#endif
	322	m_E--;
	323	if ( m_E == 0xFF )
	324	{
	325	m_D--;
	326	}
	327	cycles_passed( 4 );
	328	break;
	329	case 0x1C: /*      INC E */
	330
	331	INC_8BIT (m_E)
	332	break;
	333	case 0x1D: /*      DEC E */
	334
	335	DEC_8BIT (m_E)
	336	break;
	337	case 0x1E: /*      LD E,n8 */
	338
	339	m_E = mem_read_byte( m_PC++ );
	340	break;
	341	case 0x1F: /*      RRA */
	342
	343	x = (m_A & 1) ? FLAG_C : 0;
	344
	345	m_A = (UINT8) ((m_A >> 1) | ((m_F & FLAG_C) ? 0x80 : 0));
	346	m_F = x;
	347	break;
	348	case 0x20: /*      JR NZ,n8 */
	349	{
	350	INT8 offset = mem_read_byte( m_PC++ );
	351	if (! (m_F & FLAG_Z) )
	352	{
	353	m_PC += offset;
	354	cycles_passed( 4 );
	355	}
	356	}
	357	break;
	358	case 0x21: /*      LD HL,n16 */
	359	m_L = mem_read_byte( m_PC++ );
	360	m_H = mem_read_byte( m_PC++ );
	361	break;
	362	case 0x22: /*      LD (HL+),A */
	363
	364	#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
	365	if (m_H == 0xFE)
	366	{
	367	trash_sprites (state);
	368	}
	369	#endif
	370	mem_write_byte( (m_H << 8 ) | m_L, m_A );
	371	m_L++;
	372	if ( m_L == 0 )
	373	{
	374	m_H++;
	375	}
	376	break;
	377	case 0x23: /*      INC HL */
	378
	379	#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
	380	if (m_H == 0xFE)
	381	{
	382	trash_sprites (state);
	383	}
	384	#endif
	385	m_L++;
	386	if ( m_L == 0 )
	387	{
	388	m_H++;
	389	}
	390	cycles_passed( 4 );
	391	break;
	392	case 0x24: /*      INC H */
	393
	394	INC_8BIT (m_H);
	395	break;
	396	case 0x25: /*      DEC H */
	397
	398	DEC_8BIT (m_H);
	399	break;
	400	case 0x26: /*      LD H,n8 */
	401
	402	m_H = mem_read_byte( m_PC++ );
	403	break;
	404	case 0x27: /*      DAA */
	405	{
	406	int tmp = m_A;
	407
	408	if ( ! ( m_F & FLAG_N ) ) {
	409	if ( ( m_F & FLAG_H ) || ( tmp & 0x0F ) > 9 )
	410	tmp += 6;
	411	if ( ( m_F & FLAG_C ) || tmp > 0x9F )
	412	tmp += 0x60;
	413	} else {
	414	if ( m_F & FLAG_H ) {
	415	tmp -= 6;
	416	if ( ! ( m_F & FLAG_C ) )
	417	tmp &= 0xFF;
	418	}
	419	if ( m_F & FLAG_C )
	420	tmp -= 0x60;
	421	}
	422	m_F &= ~ ( FLAG_H | FLAG_Z );
	423	if ( tmp & 0x100 )
	424	m_F |= FLAG_C;
	425	m_A = tmp & 0xFF;
	426	if ( ! m_A )
	427	m_F |= FLAG_Z;
	428	}
	429	break;
	430	case 0x28: /*      JR Z,n8 */
	431	{
	432	INT8 offset = mem_read_byte( m_PC++ );
	433
	434	if (m_F & FLAG_Z)
	435	{
	436	m_PC += offset;
	437	cycles_passed( 4 );
	438	}
	439	}
	440	break;
	441	case 0x29: /*      ADD HL,HL */
	442	ADD_HL_RR ((m_H << 8 ) | m_L)
	443	cycles_passed( 4 );
	444	break;
	445	case 0x2A: /*      LD A,(HL+) */
	446	#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
	447	if (m_H == 0xFE)
	448	{
	449	trash_sprites (state);
	450	}
	451	#endif
	452	m_A = mem_read_byte( ( m_H << 8 ) | m_L );
	453	m_L++;
	454	if ( m_L == 0 )
	455	{
	456	m_H++;
	457	}
	458	break;
	459	case 0x2B: /*      DEC HL */
	460
	461	#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
	462	if (m_H == 0xFE)
	463	{
	464	trash_sprites (state);
	465	}
	466	#endif
	467	m_L--;
	468	if ( m_L == 0xFF )
	469	{
	470	m_H--;
	471	}
	472	cycles_passed( 4 );
	473	break;
	474	case 0x2C: /*      INC L */
	475
	476	INC_8BIT (m_L);
	477	break;
	478	case 0x2D: /*      DEC L */
	479
	480	DEC_8BIT (m_L);
	481	break;
	482	case 0x2E: /*      LD L,n8 */
	483
	484	m_L = mem_read_byte( m_PC++ );
	485	break;
	486	case 0x2F: /*      CPL */
	487
	488	m_A = ~m_A;
	489	m_F |= FLAG_N | FLAG_H;
	490	break;
	491	case 0x30: /*      JR NC,n8 */
	492	{
	493	INT8 offset = mem_read_byte( m_PC++ );
	494
	495	if ( ! (m_F & FLAG_C) )
	496	{
	497	m_PC += offset;
	498	cycles_passed( 4 );
	499	}
	500	}
	501	break;
	502	case 0x31: /*      LD SP,n16 */
	503
	504	m_SP = mem_read_word( m_PC );
	505	m_PC += 2;
	506	break;
	507	case 0x32: /*      LD (HL-),A */
	508
	509	#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
	510	if (m_H == 0xFE)
	511	{
	512	trash_sprites (state);
	513	}
	514	#endif
	515	mem_write_byte( ( m_H << 8 ) | m_L, m_A );
	516	m_L--;
	517	if ( m_L == 0xFF )
	518	{
	519	m_H--;
	520	}
	521	break;
	522	case 0x33: /*      INC SP */
	523	m_SP += 1;
	524	cycles_passed( 4 );
	525	break;
	526	case 0x34: /*      INC (HL) */
	527	{
	528	UINT16 addr = ( m_H << 8 ) | m_L;
	529	register UINT8 r, f;
	530
	531	f = (UINT8) (m_F & FLAG_C);
	532	r = mem_read_byte( addr );
	533	r += 1;
	534	mem_write_byte( addr, r );
	535
	536	if (r == 0)
	537	f |= FLAG_Z;
	538
	539	if ((r & 0xF) == 0)
	540	f |= FLAG_H;
	541
	542	m_F = f;
	543	}
	544	break;
	545	case 0x35: /*      DEC (HL) */
	546	{
	547	UINT16 addr = ( m_H << 8 ) | m_L;
	548	register UINT8 r, f;
	549
	550	f = (UINT8) ((m_F & FLAG_C) | FLAG_N);
	551	r = mem_read_byte( addr );
	552	r -= 1;
	553	mem_write_byte( addr, r );
	554
	555	if (r == 0)
	556	f |= FLAG_Z;
	557
	558	if ((r & 0xF) == 0xF)
	559	f |= FLAG_H;
	560
	561	m_F = f;
	562	}
	563	break;
	564	case 0x36: /*      LD (HL),n8 */
	565	{
	566	UINT8 v = mem_read_byte( m_PC++ );
	567	mem_write_byte( ( m_H << 8 ) | m_L, v );
	568	}
	569	break;
	570	case 0x37: /*      SCF */
	571
	572	m_F = (UINT8) ((m_F & FLAG_Z) | FLAG_C);
	573	break;
	574	case 0x38: /*      JR C,n8 */
	575	{
	576	INT8 offset = mem_read_byte( m_PC++ );
	577
	578	if (m_F & FLAG_C)
	579	{
	580	m_PC += offset;
	581	cycles_passed( 4 );
	582	}
	583	}
	584	break;
	585	case 0x39: /*      ADD HL,SP */
	586	ADD_HL_RR (m_SP)
	587	cycles_passed( 4 );
	588	break;
	589	case 0x3A: /*      LD A,(HL-) */
	590	#if 0               /* FIXME ?? do we want to support this? (bug emulation) */
	591	if (m_H == 0xFE)
	592	{
	593	trash_sprites (state);
	594	}
	595	#endif
	596	m_A = mem_read_byte( ( m_H << 8 ) | m_L );
	597	m_L--;
	598	if ( m_L == 0xFF )
	599	{
	600	m_H--;
	601	}
	602	break;
	603	case 0x3B: /*      DEC SP */
	604	m_SP -= 1;
	605	cycles_passed( 4 );
	606	break;
	607	case 0x3C: /*      INC     A */
	608
	609	INC_8BIT (m_A);
	610	break;
	611	case 0x3D: /*      DEC     A */
	612
	613	DEC_8BIT (m_A);
	614	break;
	615	case 0x3E: /*      LD A,n8 */
	616
	617	m_A = mem_read_byte( m_PC++ );
	618	break;
	619	case 0x3F: /*      CCF */
	620
	621	m_F = (UINT8) ((m_F & FLAG_Z) | ((m_F & FLAG_C) ? 0 : FLAG_C));
	622	break;
	623	case 0x40: /*      LD B,B */
	624	break;
	625	case 0x41: /*      LD B,C */
	626
	627	m_B = m_C;
	628	break;
	629	case 0x42: /*      LD B,D */
	630
	631	m_B = m_D;
	632	break;
	633	case 0x43: /*      LD B,E */
	634
	635	m_B = m_E;
	636	break;
	637	case 0x44: /*      LD B,H */
	638
	639	m_B = m_H;
	640	break;
	641	case 0x45: /*      LD B,L */
	642
	643	m_B = m_L;
	644	break;
	645	case 0x46: /*      LD B,(HL) */
	646	m_B = mem_read_byte( ( m_H << 8 ) | m_L) ;
	647	break;
	648
	649	case 0x47: /*      LD B,A */
	650
	651	m_B = m_A;
	652	break;
	653	case 0x48: /*      LD C,B */
	654
	655	m_C = m_B;
	656	break;
	657	case 0x49: /*      LD C,C */
	658	break;
	659	case 0x4A: /*      LD C,D */
	660
	661	m_C = m_D;
	662	break;
	663	case 0x4B: /*      LD C,E */
	664
	665	m_C = m_E;
	666	break;
	667	case 0x4C: /*      LD C,H */
	668
	669	m_C = m_H;
	670	break;
	671	case 0x4D: /*      LD C,L */
	672
	673	m_C = m_L;
	674	break;
	675
	676	case 0x4E: /*      LD C,(HL) */
	677	m_C = mem_read_byte( ( m_H << 8 ) | m_L );
	678	break;
	679
	680	case 0x4F: /*      LD C,A */
	681
	682	m_C = m_A;
	683	break;
	684	case 0x50: /*      LD D,B */
	685
	686	m_D = m_B;
	687	break;
	688	case 0x51: /*      LD D,C */
	689
	690	m_D = m_C;
	691	break;
	692	case 0x52: /*      LD D,D */
	693	break;
	694	case 0x53: /*      LD D,E */
	695
	696	m_D = m_E;
	697	break;
	698	case 0x54: /*      LD D,H */
	699
	700	m_D = m_H;
	701	break;
	702	case 0x55: /*      LD D,L */
	703
	704	m_D = m_L;
	705	break;
	706	case 0x56: /*      LD D,(HL) */
	707
	708	m_D = mem_read_byte( ( m_H << 8 ) | m_L );
	709	break;
	710	case 0x57: /*      LD D,A */
	711
	712	m_D = m_A;
	713	break;
	714	case 0x58: /*      LD E,B */
	715
	716	m_E = m_B;
	717	break;
	718	case 0x59: /*      LD E,C */
	719
	720	m_E = m_C;
	721	break;
	722	case 0x5A: /*      LD E,D */
	723
	724	m_E = m_D;
	725	break;
	726	case 0x5B: /*      LD E,E */
	727	break;
	728	case 0x5C: /*      LD E,H */
	729
	730	m_E = m_H;
	731	break;
	732	case 0x5D: /*      LD E,L */
	733
	734	m_E = m_L;
	735	break;
	736	case 0x5E: /*      LD E,(HL) */
	737
	738	m_E = mem_read_byte( ( m_H << 8 ) | m_L );
	739	break;
	740	case 0x5F: /*      LD E,A */
	741
	742	m_E = m_A;
	743	break;
	744	case 0x60: /*      LD H,B */
	745
	746	m_H = m_B;
	747	break;
	748	case 0x61: /*      LD H,C */
	749
	750	m_H = m_C;
	751	break;
	752	case 0x62: /*      LD H,D */
	753
	754	m_H = m_D;
	755	break;
	756	case 0x63: /*      LD H,E */
	757
	758	m_H = m_E;
	759	break;
	760	case 0x64: /*      LD H,H */
	761	break;
	762	case 0x65: /*      LD H,L */
	763
	764	m_H = m_L;
	765	break;
	766	case 0x66: /*      LD H,(HL) */
	767
	768	m_H = mem_read_byte( ( m_H << 8 ) | m_L );
	769	break;
	770	case 0x67: /*      LD H,A */
	771
	772	m_H = m_A;
	773	break;
	774	case 0x68: /*      LD L,B */
	775
	776	m_L = m_B;
	777	break;
	778	case 0x69: /*      LD L,C */
	779
	780	m_L = m_C;
	781	break;
	782	case 0x6A: /*      LD L,D */
	783	m_L = m_D;
	784	break;
	785	case 0x6B: /*      LD L,E */
	786
	787	m_L = m_E;
	788	break;
	789	case 0x6C: /*      LD L,H */
	790
	791	m_L = m_H;
	792	break;
	793	case 0x6D: /*      LD L,L */
	794	break;
	795	case 0x6E: /*      LD L,(HL) */
	796
	797	m_L = mem_read_byte( ( m_H << 8 ) | m_L );
	798	break;
	799	case 0x6F: /*      LD L,A */
	800
	801	m_L = m_A;
	802	break;
	803
	804	case 0x70: /*      LD (HL),B */
	805	mem_write_byte( ( m_H << 8 ) | m_L, m_B );
	806	break;
	807
	808	case 0x71: /*      LD (HL),C */
	809	mem_write_byte( ( m_H << 8 ) | m_L, m_C );
	810	break;
	811	case 0x72: /*      LD (HL),D */
	812	mem_write_byte( ( m_H << 8 ) | m_L, m_D );
	813	break;
	814	case 0x73: /*      LD (HL),E */
	815	mem_write_byte( ( m_H << 8 ) | m_L, m_E );
	816	break;
	817	case 0x74: /*      LD (HL),H */
	818	mem_write_byte( ( m_H << 8 ) | m_L, m_H );
	819	break;
	820	case 0x75: /*      LD (HL),L */
	821	mem_write_byte( ( m_H << 8 ) | m_L, m_L );
	822	break;
	823	case 0x76: /*      HALT */
	824	m_enable |= HALTED;
	825	m_PC--;
	826	break;
	827	case 0x77: /*      LD (HL),A */
	828	mem_write_byte( ( m_H << 8 ) | m_L, m_A );
	829	break;
	830	case 0x78: /*      LD A,B */
	831
	832	m_A = m_B;
	833	break;
	834	case 0x79: /*      LD A,C */
	835
	836	m_A = m_C;
	837	break;
	838	case 0x7A: /*      LD A,D */
	839
	840	m_A = m_D;
	841	break;
	842	case 0x7B: /*      LD A,E */
	843
	844	m_A = m_E;
	845	break;
	846	case 0x7C: /*      LD A,H */
	847
	848	m_A = m_H;
	849	break;
	850	case 0x7D: /*      LD A,L */
	851
	852	m_A = m_L;
	853	break;
	854	case 0x7E: /*      LD A,(HL) */
	855
	856	m_A = mem_read_byte( ( m_H << 8 ) | m_L );
	857	break;
	858	case 0x7F: /*      LD A,A */
	859	break;
	860	case 0x80: /*      ADD A,B */
	861
	862	ADD_A_X (m_B)
	863	break;
	864	case 0x81: /*      ADD A,C */
	865
	866	ADD_A_X (m_C)
	867	break;
	868	case 0x82: /*      ADD A,D */
	869
	870	ADD_A_X (m_D)
	871	break;
	872	case 0x83: /*      ADD A,E */
	873
	874	ADD_A_X (m_E)
	875	break;
	876	case 0x84: /*      ADD A,H */
	877
	878	ADD_A_X (m_H)
	879	break;
	880	case 0x85: /*      ADD A,L */
	881
	882	ADD_A_X (m_L)
	883	break;
	884	case 0x86: /*      ADD A,(HL) */
	885
	886	x = mem_read_byte( ( m_H << 8 ) | m_L );
	887
	888	ADD_A_X (x)
	889	break;
	890	case 0x87: /*      ADD A,A */
	891
	892	ADD_A_X (m_A)
	893	break;
	894	case 0x88: /*      ADC A,B */
	895
	896	ADC_A_X (m_B)
	897	break;
	898	case 0x89: /*      ADC A,C */
	899
	900	ADC_A_X (m_C)
	901	break;
	902	case 0x8A: /*      ADC A,D */
	903
	904	ADC_A_X (m_D)
	905	break;
	906	case 0x8B: /*      ADC A,E */
	907
	908	ADC_A_X (m_E)
	909	break;
	910	case 0x8C: /*      ADC A,H */
	911
	912	ADC_A_X (m_H)
	913	break;
	914	case 0x8D: /*      ADC A,L */
	915
	916	ADC_A_X (m_L)
	917	break;
	918	case 0x8E: /*      ADC A,(HL) */
	919
	920	x = mem_read_byte( ( m_H << 8 ) | m_L );
	921
	922	ADC_A_X (x)
	923	break;
	924	case 0x8F: /*      ADC A,A */
	925
	926	ADC_A_X (m_A)
	927	break;
	928	case 0x90: /*      SUB A,B */
	929
	930	SUB_A_X (m_B)
	931	break;
	932	case 0x91: /*      SUB A,C */
	933
	934	SUB_A_X (m_C)
	935	break;
	936	case 0x92: /*      SUB A,D */
	937
	938	SUB_A_X (m_D)
	939	break;
	940	case 0x93: /*      SUB A,E */
	941
	942	SUB_A_X (m_E)
	943	break;
	944	case 0x94: /*      SUB A,H */
	945
	946	SUB_A_X (m_H)
	947	break;
	948	case 0x95: /*      SUB A,L */
	949
	950	SUB_A_X (m_L)
	951	break;
	952	case 0x96: /*      SUB A,(HL) */
	953
	954
	955	x = mem_read_byte( ( m_H << 8 ) | m_L );
	956
	957	SUB_A_X (x)
	958	break;
	959	case 0x97: /*      SUB A,A */
	960
	961	SUB_A_X (m_A)
	962	break;
	963	case 0x98: /*      SBC A,B */
	964
	965	SBC_A_X (m_B)
	966	break;
	967	case 0x99: /*      SBC A,C */
	968
	969	SBC_A_X (m_C)
	970	break;
	971	case 0x9A: /*      SBC A,D */
	972
	973	SBC_A_X (m_D)
	974	break;
	975	case 0x9B: /*      SBC A,E */
	976
	977	SBC_A_X (m_E)
	978	break;
	979	case 0x9C: /*      SBC A,H */
	980
	981	SBC_A_X (m_H)
	982	break;
	983	case 0x9D: /*      SBC A,L */
	984
	985	SBC_A_X (m_L)
	986	break;
	987	case 0x9E: /*      SBC A,(HL) */
	988
	989	x = mem_read_byte( ( m_H << 8 ) | m_L );
	990
	991	SBC_A_X (x)
	992	break;
	993	case 0x9F: /*      SBC A,A */
	994
	995	SBC_A_X (m_A)
	996	break;
	997	case 0xA0: /*      AND A,B */
	998
	999	AND_A_X (m_B)
	1000	break;
	1001	case 0xA1: /*      AND A,C */
	1002
	1003	AND_A_X (m_C)
	1004	break;
	1005	case 0xA2: /*      AND A,D */
	1006
	1007	AND_A_X (m_D)
	1008	break;
	1009	case 0xA3: /*      AND A,E */
	1010
	1011	AND_A_X (m_E)
	1012	break;
	1013	case 0xA4: /*      AND A,H */
	1014
	1015	AND_A_X (m_H)
	1016	break;
	1017	case 0xA5: /*      AND A,L */
	1018
	1019	AND_A_X (m_L)
	1020	break;
	1021	case 0xA6: /*      AND A,(HL) */
	1022
	1023	x = mem_read_byte( ( m_H << 8 ) | m_L );
	1024
	1025	AND_A_X (x)
	1026	break;
	1027	case 0xA7: /*      AND A,A */
	1028
	1029	m_F = (m_A == 0) ? (FLAG_H | FLAG_Z) : FLAG_H;
	1030	break;
	1031	case 0xA8: /*      XOR A,B */
	1032
	1033	XOR_A_X (m_B)
	1034	break;
	1035	case 0xA9: /*      XOR A,C */
	1036
	1037	XOR_A_X (m_C)
	1038	break;
	1039	case 0xAA: /*      XOR A,D */
	1040
	1041	XOR_A_X (m_D)
	1042	break;
	1043	case 0xAB: /*      XOR A,E */
	1044
	1045	XOR_A_X (m_E)
	1046	break;
	1047	case 0xAC: /*      XOR A,H */
	1048
	1049	XOR_A_X (m_H)
	1050	break;
	1051	case 0xAD: /*      XOR A,L */
	1052
	1053	XOR_A_X (m_L)
	1054	break;
	1055	case 0xAE: /*      XOR A,(HL) */
	1056
	1057	x = mem_read_byte( ( m_H << 8 ) | m_L );
	1058
	1059	XOR_A_X (x)
	1060	break;
	1061	case 0xAF: /*      XOR A,A */
	1062
	1063	XOR_A_X (m_A)
	1064	break;
	1065	case 0xB0: /*      OR A,B */
	1066
	1067	OR_A_X (m_B)
	1068	break;
	1069	case 0xB1: /*      OR A,C */
	1070
	1071	OR_A_X (m_C)
	1072	break;
	1073	case 0xB2: /*      OR A,D */
	1074
	1075	OR_A_X (m_D)
	1076	break;
	1077	case 0xB3: /*      OR A,E */
	1078
	1079	OR_A_X (m_E)
	1080	break;
	1081	case 0xB4: /*      OR A,H */
	1082
	1083	OR_A_X (m_H)
	1084	break;
	1085	case 0xB5: /*      OR A,L */
	1086
	1087	OR_A_X (m_L)
	1088	break;
	1089	case 0xB6: /*      OR A,(HL) */
	1090
	1091	x = mem_read_byte( ( m_H << 8 ) | m_L );
	1092
	1093	OR_A_X (x)
	1094	break;
	1095	case 0xB7: /*      OR A,A */
	1096
	1097	OR_A_X (m_A)
	1098	break;
	1099	case 0xB8: /*      CP A,B */
	1100
	1101	CP_A_X (m_B)
	1102	break;
	1103	case 0xB9: /*      CP A,C */
	1104
	1105	CP_A_X (m_C)
	1106	break;
	1107	case 0xBA: /*      CP A,D */
	1108
	1109	CP_A_X (m_D)
	1110	break;
	1111	case 0xBB: /*      CP A,E */
	1112
	1113	CP_A_X (m_E)
	1114	break;
	1115	case 0xBC: /*      CP A,H */
	1116
	1117	CP_A_X (m_H)
	1118	break;
	1119	case 0xBD: /*      CP A,L */
	1120
	1121	CP_A_X (m_L)
	1122	break;
	1123	case 0xBE: /*      CP A,(HL) */
	1124
	1125	x = mem_read_byte( ( m_H << 8 ) | m_L );
	1126
	1127	CP_A_X (x)
	1128	break;
	1129	case 0xBF: /*      CP A,A */
	1130
	1131	CP_A_X (m_A)
	1132	break;
	1133	case 0xC0: /*      RET NZ */
	1134	cycles_passed( 4 );
	1135	if (!(m_F & FLAG_Z))
	1136	{
	1137	m_PC = mem_read_word( m_SP );
	1138	m_SP += 2;
	1139	cycles_passed( 4 );
	1140	}
	1141	break;
	1142	case 0xC1: /*      POP BC */
	1143	POP( m_B, m_C );
	1144	break;
	1145	case 0xC2: /*      JP NZ,n16 */
	1146	{
	1147	UINT16 addr = mem_read_word( m_PC );
	1148	m_PC += 2;
	1149
	1150	if ( ! (m_F & FLAG_Z) )
	1151	{
	1152	m_PC = addr;
	1153	cycles_passed( 4 );
	1154	}
	1155	}
	1156	break;
	1157	case 0xC3: /*      JP n16 */
	1158	m_PC = mem_read_word( m_PC );
	1159	cycles_passed( 4 );
	1160	break;
	1161	case 0xC4: /*      CALL NZ,n16 */
	1162	{
	1163	UINT16 addr = mem_read_word( m_PC );
	1164	m_PC += 2;
	1165
	1166	if ( ! (m_F & FLAG_Z) )
	1167	{
	1168	m_SP -= 2;
	1169	mem_write_word( m_SP, m_PC );
	1170	m_PC = addr;
	1171	cycles_passed( 4 );
	1172	}
	1173	}
	1174	break;
	1175	case 0xC5: /*      PUSH BC */
	1176	PUSH( m_B, m_C );
	1177	cycles_passed( 4 );
	1178	break;
	1179	case 0xC6: /*      ADD A,n8 */
	1180
	1181	x = mem_read_byte( m_PC++ );
	1182	ADD_A_X (x)
	1183	break;
	1184	case 0xC7: /*      RST 0 */
	1185	m_SP -= 2;
	1186	mem_write_word( m_SP, m_PC );
	1187	m_PC = 0;
	1188	cycles_passed( 4 );
	1189	break;
	1190	case 0xC8: /*      RET Z */
	1191	cycles_passed( 4 );
	1192	if (m_F & FLAG_Z)
	1193	{
	1194	m_PC = mem_read_word( m_SP );
	1195	m_SP += 2;
	1196	cycles_passed( 4 );
	1197	}
	1198	break;
	1199	case 0xC9: /*      RET */
	1200	m_PC = mem_read_word( m_SP );
	1201	m_SP += 2;
	1202	cycles_passed( 4 );
	1203	break;
	1204	case 0xCA: /*      JP Z,n16 */
	1205	{
	1206	UINT16 addr = mem_read_word( m_PC );
	1207	m_PC += 2;
	1208
	1209	if (m_F & FLAG_Z)
	1210	{
	1211	m_PC = addr;
	1212	cycles_passed( 4 );
	1213	}
	1214	}
	1215	break;
	1216	case 0xCB: /*      PREFIX! */
	1217	x = mem_read_byte( m_PC++ );
	1218	switch (x)
	1219	{
	1220	#include "opc_cb.inc"
	1221	}
	1222	break;
	1223	case 0xCC: /*      CALL Z,n16 */
	1224	{
	1225	UINT16 addr = mem_read_word( m_PC );
	1226	m_PC += 2;
	1227
	1228	if (m_F & FLAG_Z)
	1229	{
	1230	m_SP -= 2;
	1231	mem_write_word( m_SP, m_PC );
	1232	m_PC = addr;
	1233	cycles_passed( 4 );
	1234	}
	1235	}
	1236	break;
	1237	case 0xCD: /*      CALL n16 */
	1238	{
	1239	UINT16 addr = mem_read_word( m_PC );
	1240	m_PC += 2;
	1241
	1242	m_SP -= 2;
	1243	mem_write_word( m_SP, m_PC );
	1244	m_PC = addr;
	1245	cycles_passed( 4 );
	1246	}
	1247	break;
	1248	case 0xCE: /*      ADC A,n8 */
	1249
	1250	x = mem_read_byte( m_PC++ );
	1251	ADC_A_X (x)
	1252	break;
	1253	case 0xCF: /*      RST 8 */
	1254	m_SP -= 2;
	1255	mem_write_word( m_SP, m_PC );
	1256	m_PC = 8;
	1257	cycles_passed( 4 );
	1258	break;
	1259	case 0xD0: /*      RET NC */
	1260	cycles_passed( 4 );
	1261	if (!(m_F & FLAG_C))
	1262	{
	1263	m_PC = mem_read_word( m_SP );
	1264	m_SP += 2;
	1265	cycles_passed( 4 );
	1266	}
	1267	break;
	1268	case 0xD1: /*      POP DE */
	1269	POP( m_D, m_E );
	1270	break;
	1271	case 0xD2: /*      JP NC,n16 */
	1272	{
	1273	UINT16 addr = mem_read_word( m_PC );
	1274	m_PC += 2;
	1275
	1276	if ( ! (m_F & FLAG_C) )
	1277	{
	1278	m_PC = addr;
	1279	cycles_passed( 4 );
	1280	}
	1281	}
	1282	break;
	1283	case 0xD3: /*      EH? */
	1284	break;
	1285	case 0xD4: /*      CALL NC,n16 */
	1286	{
	1287	UINT16 addr = mem_read_word( m_PC );
	1288	m_PC += 2;
	1289
	1290	if ( ! (m_F & FLAG_C) )
	1291	{
	1292	m_SP -= 2;
	1293	mem_write_word( m_SP, m_PC );
	1294	m_PC = addr;
	1295	cycles_passed( 4 );
	1296	}
	1297	}
	1298	break;
	1299	case 0xD5: /*      PUSH DE */
	1300	PUSH( m_D, m_E );
	1301	cycles_passed( 4 );
	1302	break;
	1303	case 0xD6: /*      SUB A,n8 */
	1304
	1305	x = mem_read_byte( m_PC++ );
	1306	SUB_A_X (x)
	1307	break;
	1308	case 0xD7: /*      RST     $10 */
	1309	m_SP -= 2;
	1310	mem_write_word( m_SP, m_PC );
	1311	m_PC = 0x10;
	1312	cycles_passed( 4 );
	1313	break;
	1314	case 0xD8: /*      RET C */
	1315	cycles_passed( 4 );
	1316	if (m_F & FLAG_C)
	1317	{
	1318	m_PC = mem_read_word( m_SP );
	1319	m_SP += 2;
	1320	cycles_passed( 4 );
	1321	}
	1322	break;
	1323	case 0xD9: /*      RETI */
	1324	m_PC = mem_read_word( m_SP );
	1325	m_SP += 2;
	1326	m_enable |= IME;
	1327	cycles_passed( 4 );
	1328	break;
	1329	case 0xDA: /*      JP C,n16 */
	1330	{
	1331	UINT16 addr = mem_read_word( m_PC );
	1332	m_PC += 2;
	1333
	1334	if (m_F & FLAG_C)
	1335	{
	1336	m_PC = addr;
	1337	cycles_passed( 4 );
	1338	}
	1339	}
	1340	break;
	1341	case 0xDB: /*      EH? */
	1342	break;
	1343	case 0xDC: /*      CALL C,n16 */
	1344	{
	1345	UINT16 addr = mem_read_word( m_PC );
	1346	m_PC += 2;
	1347
	1348	if (m_F & FLAG_C)
	1349	{
	1350	m_SP -= 2;
	1351	mem_write_word( m_SP, m_PC );
	1352	m_PC = addr;
	1353	cycles_passed( 4 );
	1354	}
	1355	}
	1356	break;
	1357	case 0xDD: /*      EH? */
	1358	break;
	1359	case 0xDE: /*      SBC A,n8 */
	1360
	1361	x = mem_read_byte( m_PC++ );
	1362	SBC_A_X (x)
	1363	break;
	1364	case 0xDF: /*      RST     $18 */
	1365	m_SP -= 2;
	1366	mem_write_word( m_SP, m_PC );
	1367	m_PC = 0x18;
	1368	cycles_passed( 4 );
	1369	break;
	1370	case 0xE0: /*      LD      ($FF00+n8),A */
	1371	{
	1372	UINT8 v = mem_read_byte( m_PC++ );
	1373	mem_write_byte( 0xFF00 + v, m_A );
	1374	}
	1375	break;
	1376	case 0xE1: /*      POP HL */
	1377	POP( m_H, m_L );
	1378	break;
	1379	case 0xE2: /*      LD ($FF00+C),A */
	1380
	1381	mem_write_byte( 0xFF00 + m_C, m_A );
	1382	break;
	1383	case 0xE3: /*      EH? */
	1384	break;
	1385	case 0xE4: /*      EH? */
	1386	break;
	1387	case 0xE5: /*      PUSH HL */
	1388	PUSH( m_H, m_L );
	1389	cycles_passed( 4 );
	1390	break;
	1391	case 0xE6: /*      AND A,n8 */
	1392
	1393	x = mem_read_byte( m_PC++ );
	1394	AND_A_X (x)
	1395	break;
	1396	case 0xE7: /*      RST $20 */
	1397	m_SP -= 2;
	1398	mem_write_word( m_SP, m_PC );
	1399	m_PC = 0x20;
	1400	cycles_passed( 4 );
	1401	break;
	1402	case 0xE8: /*      ADD SP,n8 */
	1403	/*
	1404	*   Z - Reset.
	1405	*   N - Reset.
	1406	*   H - Set or reset according to operation.
	1407	*   C - Set or reset according to operation.
	1408	*/
	1409
	1410	{
	1411	register INT32 n;
	1412
	1413	n = (INT8) mem_read_byte( m_PC++ );
	1414
	1415	if ( ( m_SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF )
	1416	{
	1417	m_F = FLAG_C;
	1418	}
	1419	else
	1420	{
	1421	m_F = 0;
	1422	}
	1423
	1424	if ( ( m_SP & 0x0F ) + ( n & 0x0F ) > 0x0F )
	1425	{
	1426	m_F |= FLAG_H;
	1427	}
	1428
	1429	m_SP = (UINT16) ( m_SP + n );
	1430	}
	1431	cycles_passed( 8 );
	1432	break;
	1433	case 0xE9: /*      JP (HL) */
	1434	m_PC = ( m_H << 8 ) | m_L;
	1435	break;
	1436	case 0xEA: /*      LD (n16),A */
	1437
	1438	mem_write_byte( mem_read_word( m_PC ), m_A );
	1439	m_PC += 2;
	1440	break;
	1441	case 0xEB: /*      EH? */
	1442	break;
	1443	case 0xEC: /*      EH? */
	1444	break;
	1445	case 0xED: /*      EH? */
	1446	break;
	1447	case 0xEE: /*      XOR A,n8 */
	1448
	1449	x = mem_read_byte( m_PC++ );
	1450	XOR_A_X (x)
	1451	break;
	1452	case 0xEF: /*      RST $28 */
	1453	m_SP -= 2;
	1454	mem_write_word( m_SP, m_PC );
	1455	m_PC = 0x28;
	1456	cycles_passed( 4 );
	1457	break;
	1458	case 0xF0: /*      LD A,($FF00+n8) */
	1459	{
	1460	UINT8 v = mem_read_byte( m_PC++ );
	1461	m_A = mem_read_byte( 0xFF00 + v );
	1462	}
	1463	break;
	1464	case 0xF1: /*      POP AF */
	1465	POP( m_A, m_F );
	1466	m_F &= 0xF0;
	1467	break;
	1468	case 0xF2: /*      LD A,($FF00+C) */
	1469
	1470	m_A = mem_read_byte( 0xFF00 + m_C );
	1471	break;
	1472	case 0xF3: /*      DI */
	1473	m_ei_delay = 0;
	1474	m_enable &= ~IME;
	1475	break;
	1476	case 0xF4: /*      EH? */
	1477	break;
	1478	case 0xF5: /*      PUSH AF */
	1479	m_F &= 0xF0;
	1480	PUSH( m_A, m_F );
	1481	cycles_passed( 4 );
	1482	break;
	1483	case 0xF6: /*      OR A,n8 */
	1484
	1485	x = mem_read_byte( m_PC++ );
	1486	OR_A_X (x)
	1487	break;
	1488	case 0xF7: /*      RST $30 */
	1489	m_SP -= 2;
	1490	mem_write_word( m_SP, m_PC );
	1491	m_PC = 0x30;
	1492	cycles_passed( 4 );
	1493	break;
	1494	case 0xF8: /*      LD HL,SP+n8 */
	1495	/*
	1496	*   n = one UINT8 signed immediate value.
	1497	* Flags affected:
	1498	*   Z - Reset.
	1499	*   N - Reset.
	1500	*   H - Set or reset according to operation.
	1501	*   C - Set or reset according to operation.
	1502	*
	1503	*/
	1504
	1505	{
	1506	register INT32 n;
	1507
	1508	n = (INT8) mem_read_byte( m_PC++ );
	1509
	1510	if ( ( m_SP & 0xFF ) + (UINT8)(n & 0xFF) > 0xFF )
	1511	{
	1512	m_F = FLAG_C;
	1513	}
	1514	else
	1515	{
	1516	m_F = 0;
	1517	}
	1518
	1519	if ( ( m_SP & 0x0F ) + ( n & 0x0F ) > 0x0F )
	1520	{
	1521	m_F |= FLAG_H;
	1522	}
	1523
	1524	UINT16 res = m_SP + n;
	1525
	1526	m_L = res & 0xFF;
	1527	m_H = res >> 8;
	1528	}
	1529	cycles_passed( 4 );
	1530	break;
	1531	case 0xF9: /*      LD SP,HL */
	1532	m_SP = ( m_H << 8 ) | m_L;
	1533	cycles_passed( 4 );
	1534	break;
	1535	case 0xFA: /*      LD A,(n16) */
	1536	m_A = mem_read_byte( mem_read_word( m_PC ) );
	1537	m_PC += 2;
	1538	break;
	1539	case 0xFB: /*      EI */
	1540	m_enable |= IME;
	1541	m_ei_delay = 1;
	1542	break;
	1543	case 0xFC: /*      EH? */
	1544	break;
	1545	case 0xFD: /*      EH? */
	1546	break;
	1547	case 0xFE: /*      CP A,n8 */
	1548	x = mem_read_byte( m_PC++ );
	1549	CP_A_X (x)
	1550	break;
	1551	case 0xFF: /*      RST $38 */
	1552	m_SP -= 2;
	1553	mem_write_word( m_SP, m_PC );
	1554	m_PC = 0x38;
	1555	cycles_passed( 4 );
	1556	break;

Property changes on: trunk/src/emu/cpu/lr35902/opc_main.inc

Added: svn:mime-type    + text/plain Added: svn:eol-style    + native

trunk/src/emu/cpu/lr35902/lr35902.c

r30964	r30965
41	41	#include "debugger.h"
42	42	#include "lr35902.h"
43	43
	44	/* Flag bit definitions */
	45	enum lr35902_flag
	46	{
	47	FLAG_C = 0x10,
	48	FLAG_H = 0x20,
	49	FLAG_N = 0x40,
	50	FLAG_Z = 0x80
	51	};
44	52
45	53	#define IME     0x01
46	54	#define HALTED  0x02
r30964	r30965
54	62
55	63
56	64	lr35902_cpu_device::lr35902_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
57		: cpu_device(mconfig, LR35902, "LR35902 CPU", tag, owner, clock, "lr35902", __FILE__)
	65	: cpu_device(mconfig, LR35902, "LR35902", tag, owner, clock, "lr35902", __FILE__)
58	66	, m_program_config("program", ENDIANNESS_LITTLE, 8, 16, 0)
59	67	, m_A(0)
60	68	, m_F(0)
r30964	r30965
177	185
178	186	case STATE_GENFLAGS:
179	187	string.printf("%c%c%c%c",
180		m_F & LR35902_FLAG_Z   ? 'Z' : '.',
181		m_F & LR35902_FLAG_N   ? 'N' : '.',
182		m_F & LR35902_FLAG_H   ? 'H' : '.',
183		m_F & LR35902_FLAG_C   ? 'C' : '.'
	188	m_F & FLAG_Z   ? 'Z' : '.',
	189	m_F & FLAG_N   ? 'N' : '.',
	190	m_F & FLAG_H   ? 'H' : '.',
	191	m_F & FLAG_C   ? 'C' : '.'
184	192	);
185	193	break;
186	194	}
r30964	r30965
307	315	UINT8   x;
308	316	/* Execute instruction */
309	317	switch( m_op ) {
310		#include "opc_main.h"
	318	#include "opc_main.inc"
311	319	}
312	320	} else {
313	321	/* Fetch and count cycles */

trunk/src/emu/cpu/lr35902/lr35902.h

r30964	r30965
110	110	UINT8   m_features;
111	111	const UINT16 *c_regs;
112	112	const struct lr35902_config *m_config;
113
114		/* Flag bit definitions */
115		static const UINT8 LR35902_FLAG_Z = 0x80;
116		static const UINT8 LR35902_FLAG_N = 0x40;
117		static const UINT8 LR35902_FLAG_H = 0x20;
118		static const UINT8 LR35902_FLAG_C = 0x10;
119	113	};
120	114
121	115	extern const device_type LR35902;

trunk/src/emu/cpu/cpu.mak

r30964	r30965
2252	2252
2253	2253	$(CPUOBJ)/lr35902/lr35902.o:    $(CPUSRC)/lr35902/lr35902.c \
2254	2254	$(CPUSRC)/lr35902/lr35902.h \
2255		$(CPUSRC)/lr35902/opc_cb.h \
2256		$(CPUSRC)/lr35902/opc_main.h
	2255	$(CPUSRC)/lr35902/opc_cb.inc \
	2256	$(CPUSRC)/lr35902/opc_main.inc
2257	2257
2258	2258
2259	2259

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team