![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpu1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / CPU Sources|
Return to cpu1.c CVS log | Up to [UNIX Amiga Emulator] / uae / CPU Sources |
1.1 root 1: #include "config.h"
2: #include "amiga.h"
3: #include "options.h"
4: #include <stdlib.h>
5: #include "memory.h"
6: #include "custom.h"
7: #include "newcpu.h"
8: #include "cputbl.h"
9: void op_1000(UWORD opcode)
10: {
11: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
12: ULONG dstreg = (opcode & 3584) >> 9;
13: {{ BYTE src = regs.d[srcreg];
14: { regs.v = regs.c = 0;
15: regs.z = ((BYTE)(src)) == 0;
16: regs.n = ((BYTE)(src)) < 0;
17: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
18: }}}}
19: void op_1010(UWORD opcode)
20: {
21: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
22: ULONG dstreg = (opcode & 3584) >> 9;
23: {{ CPTR srca = regs.a[srcreg];
24: BYTE src = get_byte(srca);
25: { regs.v = regs.c = 0;
26: regs.z = ((BYTE)(src)) == 0;
27: regs.n = ((BYTE)(src)) < 0;
28: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
29: }}}}
30: void op_1018(UWORD opcode)
31: {
32: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
33: ULONG dstreg = (opcode & 3584) >> 9;
34: {{ CPTR srca = regs.a[srcreg];
35: BYTE src = get_byte(srca);
36: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
37: { regs.v = regs.c = 0;
38: regs.z = ((BYTE)(src)) == 0;
39: regs.n = ((BYTE)(src)) < 0;
40: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
41: }}}}}
42: void op_1020(UWORD opcode)
43: {
44: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
45: ULONG dstreg = (opcode & 3584) >> 9;
46: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
47: { CPTR srca = regs.a[srcreg];
48: BYTE src = get_byte(srca);
49: { regs.v = regs.c = 0;
50: regs.z = ((BYTE)(src)) == 0;
51: regs.n = ((BYTE)(src)) < 0;
52: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
53: }}}}}
54: void op_1028(UWORD opcode)
55: {
56: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
57: ULONG dstreg = (opcode & 3584) >> 9;
58: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
59: BYTE src = get_byte(srca);
60: { regs.v = regs.c = 0;
61: regs.z = ((BYTE)(src)) == 0;
62: regs.n = ((BYTE)(src)) < 0;
63: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
64: }}}}
65: void op_1030(UWORD opcode)
66: {
67: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
68: ULONG dstreg = (opcode & 3584) >> 9;
69: {{ CPTR srca = regs.a[srcreg];
70: UWORD srcdp = nextiword();
71: srca += (LONG)(BYTE)(srcdp & 0xFF);
72: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
73: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
74: srca += srcdpr;
75: { BYTE src = get_byte(srca);
76: { regs.v = regs.c = 0;
77: regs.z = ((BYTE)(src)) == 0;
78: regs.n = ((BYTE)(src)) < 0;
79: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
80: }}}}}}
81: void op_1038(UWORD opcode)
82: {
83: ULONG dstreg = (opcode & 3584) >> 9;
84: {{ CPTR srca = (LONG)(WORD)nextiword();
85: BYTE src = get_byte(srca);
86: { regs.v = regs.c = 0;
87: regs.z = ((BYTE)(src)) == 0;
88: regs.n = ((BYTE)(src)) < 0;
89: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
90: }}}}
91: void op_1039(UWORD opcode)
92: {
93: ULONG dstreg = (opcode & 3584) >> 9;
94: {{ CPTR srca = nextilong();
95: BYTE src = get_byte(srca);
96: { regs.v = regs.c = 0;
97: regs.z = ((BYTE)(src)) == 0;
98: regs.n = ((BYTE)(src)) < 0;
99: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
100: }}}}
101: void op_103a(UWORD opcode)
102: {
103: ULONG dstreg = (opcode & 3584) >> 9;
104: {{ CPTR srca = m68k_getpc();
105: srca += (LONG)(WORD)nextiword();
106: { BYTE src = get_byte(srca);
107: { regs.v = regs.c = 0;
108: regs.z = ((BYTE)(src)) == 0;
109: regs.n = ((BYTE)(src)) < 0;
110: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
111: }}}}}
112: void op_103b(UWORD opcode)
113: {
114: ULONG dstreg = (opcode & 3584) >> 9;
115: {{ CPTR srca = m68k_getpc();
116: UWORD srcdp = nextiword();
117: srca += (LONG)(BYTE)(srcdp & 0xFF);
118: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
119: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
120: srca += srcdpr;
121: { BYTE src = get_byte(srca);
122: { regs.v = regs.c = 0;
123: regs.z = ((BYTE)(src)) == 0;
124: regs.n = ((BYTE)(src)) < 0;
125: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
126: }}}}}}
127: void op_103c(UWORD opcode)
128: {
129: ULONG dstreg = (opcode & 3584) >> 9;
130: {{ BYTE src = nextiword();
131: { regs.v = regs.c = 0;
132: regs.z = ((BYTE)(src)) == 0;
133: regs.n = ((BYTE)(src)) < 0;
134: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
135: }}}}
136: void op_1080(UWORD opcode)
137: {
138: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
139: ULONG dstreg = (opcode & 3584) >> 9;
140: {{ BYTE src = regs.d[srcreg];
141: { CPTR dsta = regs.a[dstreg];
142: regs.v = regs.c = 0;
143: regs.z = ((BYTE)(src)) == 0;
144: regs.n = ((BYTE)(src)) < 0;
145: put_byte(dsta,src);
146: }}}}
147: void op_1090(UWORD opcode)
148: {
149: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
150: ULONG dstreg = (opcode & 3584) >> 9;
151: {{ CPTR srca = regs.a[srcreg];
152: BYTE src = get_byte(srca);
153: { CPTR dsta = regs.a[dstreg];
154: regs.v = regs.c = 0;
155: regs.z = ((BYTE)(src)) == 0;
156: regs.n = ((BYTE)(src)) < 0;
157: put_byte(dsta,src);
158: }}}}
159: void op_1098(UWORD opcode)
160: {
161: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
162: ULONG dstreg = (opcode & 3584) >> 9;
163: {{ CPTR srca = regs.a[srcreg];
164: BYTE src = get_byte(srca);
165: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
166: { CPTR dsta = regs.a[dstreg];
167: regs.v = regs.c = 0;
168: regs.z = ((BYTE)(src)) == 0;
169: regs.n = ((BYTE)(src)) < 0;
170: put_byte(dsta,src);
171: }}}}}
172: void op_10a0(UWORD opcode)
173: {
174: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
175: ULONG dstreg = (opcode & 3584) >> 9;
176: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
177: { CPTR srca = regs.a[srcreg];
178: BYTE src = get_byte(srca);
179: { CPTR dsta = regs.a[dstreg];
180: regs.v = regs.c = 0;
181: regs.z = ((BYTE)(src)) == 0;
182: regs.n = ((BYTE)(src)) < 0;
183: put_byte(dsta,src);
184: }}}}}
185: void op_10a8(UWORD opcode)
186: {
187: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
188: ULONG dstreg = (opcode & 3584) >> 9;
189: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
190: BYTE src = get_byte(srca);
191: { CPTR dsta = regs.a[dstreg];
192: regs.v = regs.c = 0;
193: regs.z = ((BYTE)(src)) == 0;
194: regs.n = ((BYTE)(src)) < 0;
195: put_byte(dsta,src);
196: }}}}
197: void op_10b0(UWORD opcode)
198: {
199: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
200: ULONG dstreg = (opcode & 3584) >> 9;
201: {{ CPTR srca = regs.a[srcreg];
202: UWORD srcdp = nextiword();
203: srca += (LONG)(BYTE)(srcdp & 0xFF);
204: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
205: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
206: srca += srcdpr;
207: { BYTE src = get_byte(srca);
208: { CPTR dsta = regs.a[dstreg];
209: regs.v = regs.c = 0;
210: regs.z = ((BYTE)(src)) == 0;
211: regs.n = ((BYTE)(src)) < 0;
212: put_byte(dsta,src);
213: }}}}}}
214: void op_10b8(UWORD opcode)
215: {
216: ULONG dstreg = (opcode & 3584) >> 9;
217: {{ CPTR srca = (LONG)(WORD)nextiword();
218: BYTE src = get_byte(srca);
219: { CPTR dsta = regs.a[dstreg];
220: regs.v = regs.c = 0;
221: regs.z = ((BYTE)(src)) == 0;
222: regs.n = ((BYTE)(src)) < 0;
223: put_byte(dsta,src);
224: }}}}
225: void op_10b9(UWORD opcode)
226: {
227: ULONG dstreg = (opcode & 3584) >> 9;
228: {{ CPTR srca = nextilong();
229: BYTE src = get_byte(srca);
230: { CPTR dsta = regs.a[dstreg];
231: regs.v = regs.c = 0;
232: regs.z = ((BYTE)(src)) == 0;
233: regs.n = ((BYTE)(src)) < 0;
234: put_byte(dsta,src);
235: }}}}
236: void op_10ba(UWORD opcode)
237: {
238: ULONG dstreg = (opcode & 3584) >> 9;
239: {{ CPTR srca = m68k_getpc();
240: srca += (LONG)(WORD)nextiword();
241: { BYTE src = get_byte(srca);
242: { CPTR dsta = regs.a[dstreg];
243: regs.v = regs.c = 0;
244: regs.z = ((BYTE)(src)) == 0;
245: regs.n = ((BYTE)(src)) < 0;
246: put_byte(dsta,src);
247: }}}}}
248: void op_10bb(UWORD opcode)
249: {
250: ULONG dstreg = (opcode & 3584) >> 9;
251: {{ CPTR srca = m68k_getpc();
252: UWORD srcdp = nextiword();
253: srca += (LONG)(BYTE)(srcdp & 0xFF);
254: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
255: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
256: srca += srcdpr;
257: { BYTE src = get_byte(srca);
258: { CPTR dsta = regs.a[dstreg];
259: regs.v = regs.c = 0;
260: regs.z = ((BYTE)(src)) == 0;
261: regs.n = ((BYTE)(src)) < 0;
262: put_byte(dsta,src);
263: }}}}}}
264: void op_10bc(UWORD opcode)
265: {
266: ULONG dstreg = (opcode & 3584) >> 9;
267: {{ BYTE src = nextiword();
268: { CPTR dsta = regs.a[dstreg];
269: regs.v = regs.c = 0;
270: regs.z = ((BYTE)(src)) == 0;
271: regs.n = ((BYTE)(src)) < 0;
272: put_byte(dsta,src);
273: }}}}
274: void op_10c0(UWORD opcode)
275: {
276: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
277: ULONG dstreg = (opcode & 3584) >> 9;
278: {{ BYTE src = regs.d[srcreg];
279: { CPTR dsta = regs.a[dstreg];
280: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
281: regs.v = regs.c = 0;
282: regs.z = ((BYTE)(src)) == 0;
283: regs.n = ((BYTE)(src)) < 0;
284: put_byte(dsta,src);
285: }}}}}
286: void op_10d0(UWORD opcode)
287: {
288: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
289: ULONG dstreg = (opcode & 3584) >> 9;
290: {{ CPTR srca = regs.a[srcreg];
291: BYTE src = get_byte(srca);
292: { CPTR dsta = regs.a[dstreg];
293: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
294: regs.v = regs.c = 0;
295: regs.z = ((BYTE)(src)) == 0;
296: regs.n = ((BYTE)(src)) < 0;
297: put_byte(dsta,src);
298: }}}}}
299: void op_10d8(UWORD opcode)
300: {
301: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
302: ULONG dstreg = (opcode & 3584) >> 9;
303: {{ CPTR srca = regs.a[srcreg];
304: BYTE src = get_byte(srca);
305: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
306: { CPTR dsta = regs.a[dstreg];
307: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
308: regs.v = regs.c = 0;
309: regs.z = ((BYTE)(src)) == 0;
310: regs.n = ((BYTE)(src)) < 0;
311: put_byte(dsta,src);
312: }}}}}}
313: void op_10e0(UWORD opcode)
314: {
315: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
316: ULONG dstreg = (opcode & 3584) >> 9;
317: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
318: { CPTR srca = regs.a[srcreg];
319: BYTE src = get_byte(srca);
320: { CPTR dsta = regs.a[dstreg];
321: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
322: regs.v = regs.c = 0;
323: regs.z = ((BYTE)(src)) == 0;
324: regs.n = ((BYTE)(src)) < 0;
325: put_byte(dsta,src);
326: }}}}}}
327: void op_10e8(UWORD opcode)
328: {
329: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
330: ULONG dstreg = (opcode & 3584) >> 9;
331: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
332: BYTE src = get_byte(srca);
333: { CPTR dsta = regs.a[dstreg];
334: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
335: regs.v = regs.c = 0;
336: regs.z = ((BYTE)(src)) == 0;
337: regs.n = ((BYTE)(src)) < 0;
338: put_byte(dsta,src);
339: }}}}}
340: void op_10f0(UWORD opcode)
341: {
342: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
343: ULONG dstreg = (opcode & 3584) >> 9;
344: {{ CPTR srca = regs.a[srcreg];
345: UWORD srcdp = nextiword();
346: srca += (LONG)(BYTE)(srcdp & 0xFF);
347: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
348: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
349: srca += srcdpr;
350: { BYTE src = get_byte(srca);
351: { CPTR dsta = regs.a[dstreg];
352: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
353: regs.v = regs.c = 0;
354: regs.z = ((BYTE)(src)) == 0;
355: regs.n = ((BYTE)(src)) < 0;
356: put_byte(dsta,src);
357: }}}}}}}
358: void op_10f8(UWORD opcode)
359: {
360: ULONG dstreg = (opcode & 3584) >> 9;
361: {{ CPTR srca = (LONG)(WORD)nextiword();
362: BYTE src = get_byte(srca);
363: { CPTR dsta = regs.a[dstreg];
364: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
365: regs.v = regs.c = 0;
366: regs.z = ((BYTE)(src)) == 0;
367: regs.n = ((BYTE)(src)) < 0;
368: put_byte(dsta,src);
369: }}}}}
370: void op_10f9(UWORD opcode)
371: {
372: ULONG dstreg = (opcode & 3584) >> 9;
373: {{ CPTR srca = nextilong();
374: BYTE src = get_byte(srca);
375: { CPTR dsta = regs.a[dstreg];
376: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
377: regs.v = regs.c = 0;
378: regs.z = ((BYTE)(src)) == 0;
379: regs.n = ((BYTE)(src)) < 0;
380: put_byte(dsta,src);
381: }}}}}
382: void op_10fa(UWORD opcode)
383: {
384: ULONG dstreg = (opcode & 3584) >> 9;
385: {{ CPTR srca = m68k_getpc();
386: srca += (LONG)(WORD)nextiword();
387: { BYTE src = get_byte(srca);
388: { CPTR dsta = regs.a[dstreg];
389: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
390: regs.v = regs.c = 0;
391: regs.z = ((BYTE)(src)) == 0;
392: regs.n = ((BYTE)(src)) < 0;
393: put_byte(dsta,src);
394: }}}}}}
395: void op_10fb(UWORD opcode)
396: {
397: ULONG dstreg = (opcode & 3584) >> 9;
398: {{ CPTR srca = m68k_getpc();
399: UWORD srcdp = nextiword();
400: srca += (LONG)(BYTE)(srcdp & 0xFF);
401: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
402: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
403: srca += srcdpr;
404: { BYTE src = get_byte(srca);
405: { CPTR dsta = regs.a[dstreg];
406: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
407: regs.v = regs.c = 0;
408: regs.z = ((BYTE)(src)) == 0;
409: regs.n = ((BYTE)(src)) < 0;
410: put_byte(dsta,src);
411: }}}}}}}
412: void op_10fc(UWORD opcode)
413: {
414: ULONG dstreg = (opcode & 3584) >> 9;
415: {{ BYTE src = nextiword();
416: { CPTR dsta = regs.a[dstreg];
417: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
418: regs.v = regs.c = 0;
419: regs.z = ((BYTE)(src)) == 0;
420: regs.n = ((BYTE)(src)) < 0;
421: put_byte(dsta,src);
422: }}}}}
423: void op_1100(UWORD opcode)
424: {
425: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
426: ULONG dstreg = (opcode & 3584) >> 9;
427: {{ BYTE src = regs.d[srcreg];
428: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
429: { CPTR dsta = regs.a[dstreg];
430: regs.v = regs.c = 0;
431: regs.z = ((BYTE)(src)) == 0;
432: regs.n = ((BYTE)(src)) < 0;
433: put_byte(dsta,src);
434: }}}}}
435: void op_1110(UWORD opcode)
436: {
437: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
438: ULONG dstreg = (opcode & 3584) >> 9;
439: {{ CPTR srca = regs.a[srcreg];
440: BYTE src = get_byte(srca);
441: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
442: { CPTR dsta = regs.a[dstreg];
443: regs.v = regs.c = 0;
444: regs.z = ((BYTE)(src)) == 0;
445: regs.n = ((BYTE)(src)) < 0;
446: put_byte(dsta,src);
447: }}}}}
448: void op_1118(UWORD opcode)
449: {
450: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
451: ULONG dstreg = (opcode & 3584) >> 9;
452: {{ CPTR srca = regs.a[srcreg];
453: BYTE src = get_byte(srca);
454: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
455: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
456: { CPTR dsta = regs.a[dstreg];
457: regs.v = regs.c = 0;
458: regs.z = ((BYTE)(src)) == 0;
459: regs.n = ((BYTE)(src)) < 0;
460: put_byte(dsta,src);
461: }}}}}}
462: void op_1120(UWORD opcode)
463: {
464: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
465: ULONG dstreg = (opcode & 3584) >> 9;
466: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
467: { CPTR srca = regs.a[srcreg];
468: BYTE src = get_byte(srca);
469: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
470: { CPTR dsta = regs.a[dstreg];
471: regs.v = regs.c = 0;
472: regs.z = ((BYTE)(src)) == 0;
473: regs.n = ((BYTE)(src)) < 0;
474: put_byte(dsta,src);
475: }}}}}}
476: void op_1128(UWORD opcode)
477: {
478: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
479: ULONG dstreg = (opcode & 3584) >> 9;
480: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
481: BYTE src = get_byte(srca);
482: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
483: { CPTR dsta = regs.a[dstreg];
484: regs.v = regs.c = 0;
485: regs.z = ((BYTE)(src)) == 0;
486: regs.n = ((BYTE)(src)) < 0;
487: put_byte(dsta,src);
488: }}}}}
489: void op_1130(UWORD opcode)
490: {
491: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
492: ULONG dstreg = (opcode & 3584) >> 9;
493: {{ CPTR srca = regs.a[srcreg];
494: UWORD srcdp = nextiword();
495: srca += (LONG)(BYTE)(srcdp & 0xFF);
496: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
497: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
498: srca += srcdpr;
499: { BYTE src = get_byte(srca);
500: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
501: { CPTR dsta = regs.a[dstreg];
502: regs.v = regs.c = 0;
503: regs.z = ((BYTE)(src)) == 0;
504: regs.n = ((BYTE)(src)) < 0;
505: put_byte(dsta,src);
506: }}}}}}}
507: void op_1138(UWORD opcode)
508: {
509: ULONG dstreg = (opcode & 3584) >> 9;
510: {{ CPTR srca = (LONG)(WORD)nextiword();
511: BYTE src = get_byte(srca);
512: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
513: { CPTR dsta = regs.a[dstreg];
514: regs.v = regs.c = 0;
515: regs.z = ((BYTE)(src)) == 0;
516: regs.n = ((BYTE)(src)) < 0;
517: put_byte(dsta,src);
518: }}}}}
519: void op_1139(UWORD opcode)
520: {
521: ULONG dstreg = (opcode & 3584) >> 9;
522: {{ CPTR srca = nextilong();
523: BYTE src = get_byte(srca);
524: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
525: { CPTR dsta = regs.a[dstreg];
526: regs.v = regs.c = 0;
527: regs.z = ((BYTE)(src)) == 0;
528: regs.n = ((BYTE)(src)) < 0;
529: put_byte(dsta,src);
530: }}}}}
531: void op_113a(UWORD opcode)
532: {
533: ULONG dstreg = (opcode & 3584) >> 9;
534: {{ CPTR srca = m68k_getpc();
535: srca += (LONG)(WORD)nextiword();
536: { BYTE src = get_byte(srca);
537: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
538: { CPTR dsta = regs.a[dstreg];
539: regs.v = regs.c = 0;
540: regs.z = ((BYTE)(src)) == 0;
541: regs.n = ((BYTE)(src)) < 0;
542: put_byte(dsta,src);
543: }}}}}}
544: void op_113b(UWORD opcode)
545: {
546: ULONG dstreg = (opcode & 3584) >> 9;
547: {{ CPTR srca = m68k_getpc();
548: UWORD srcdp = nextiword();
549: srca += (LONG)(BYTE)(srcdp & 0xFF);
550: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
551: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
552: srca += srcdpr;
553: { BYTE src = get_byte(srca);
554: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
555: { CPTR dsta = regs.a[dstreg];
556: regs.v = regs.c = 0;
557: regs.z = ((BYTE)(src)) == 0;
558: regs.n = ((BYTE)(src)) < 0;
559: put_byte(dsta,src);
560: }}}}}}}
561: void op_113c(UWORD opcode)
562: {
563: ULONG dstreg = (opcode & 3584) >> 9;
564: {{ BYTE src = nextiword();
565: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
566: { CPTR dsta = regs.a[dstreg];
567: regs.v = regs.c = 0;
568: regs.z = ((BYTE)(src)) == 0;
569: regs.n = ((BYTE)(src)) < 0;
570: put_byte(dsta,src);
571: }}}}}
572: void op_1140(UWORD opcode)
573: {
574: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
575: ULONG dstreg = (opcode & 3584) >> 9;
576: {{ BYTE src = regs.d[srcreg];
577: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
578: regs.v = regs.c = 0;
579: regs.z = ((BYTE)(src)) == 0;
580: regs.n = ((BYTE)(src)) < 0;
581: put_byte(dsta,src);
582: }}}}
583: void op_1150(UWORD opcode)
584: {
585: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
586: ULONG dstreg = (opcode & 3584) >> 9;
587: {{ CPTR srca = regs.a[srcreg];
588: BYTE src = get_byte(srca);
589: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
590: regs.v = regs.c = 0;
591: regs.z = ((BYTE)(src)) == 0;
592: regs.n = ((BYTE)(src)) < 0;
593: put_byte(dsta,src);
594: }}}}
595: void op_1158(UWORD opcode)
596: {
597: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
598: ULONG dstreg = (opcode & 3584) >> 9;
599: {{ CPTR srca = regs.a[srcreg];
600: BYTE src = get_byte(srca);
601: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
602: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
603: regs.v = regs.c = 0;
604: regs.z = ((BYTE)(src)) == 0;
605: regs.n = ((BYTE)(src)) < 0;
606: put_byte(dsta,src);
607: }}}}}
608: void op_1160(UWORD opcode)
609: {
610: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
611: ULONG dstreg = (opcode & 3584) >> 9;
612: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
613: { CPTR srca = regs.a[srcreg];
614: BYTE src = get_byte(srca);
615: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
616: regs.v = regs.c = 0;
617: regs.z = ((BYTE)(src)) == 0;
618: regs.n = ((BYTE)(src)) < 0;
619: put_byte(dsta,src);
620: }}}}}
621: void op_1168(UWORD opcode)
622: {
623: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
624: ULONG dstreg = (opcode & 3584) >> 9;
625: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
626: BYTE src = get_byte(srca);
627: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
628: regs.v = regs.c = 0;
629: regs.z = ((BYTE)(src)) == 0;
630: regs.n = ((BYTE)(src)) < 0;
631: put_byte(dsta,src);
632: }}}}
633: void op_1170(UWORD opcode)
634: {
635: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
636: ULONG dstreg = (opcode & 3584) >> 9;
637: {{ CPTR srca = regs.a[srcreg];
638: UWORD srcdp = nextiword();
639: srca += (LONG)(BYTE)(srcdp & 0xFF);
640: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
641: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
642: srca += srcdpr;
643: { BYTE src = get_byte(srca);
644: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
645: regs.v = regs.c = 0;
646: regs.z = ((BYTE)(src)) == 0;
647: regs.n = ((BYTE)(src)) < 0;
648: put_byte(dsta,src);
649: }}}}}}
650: void op_1178(UWORD opcode)
651: {
652: ULONG dstreg = (opcode & 3584) >> 9;
653: {{ CPTR srca = (LONG)(WORD)nextiword();
654: BYTE src = get_byte(srca);
655: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
656: regs.v = regs.c = 0;
657: regs.z = ((BYTE)(src)) == 0;
658: regs.n = ((BYTE)(src)) < 0;
659: put_byte(dsta,src);
660: }}}}
661: void op_1179(UWORD opcode)
662: {
663: ULONG dstreg = (opcode & 3584) >> 9;
664: {{ CPTR srca = nextilong();
665: BYTE src = get_byte(srca);
666: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
667: regs.v = regs.c = 0;
668: regs.z = ((BYTE)(src)) == 0;
669: regs.n = ((BYTE)(src)) < 0;
670: put_byte(dsta,src);
671: }}}}
672: void op_117a(UWORD opcode)
673: {
674: ULONG dstreg = (opcode & 3584) >> 9;
675: {{ CPTR srca = m68k_getpc();
676: srca += (LONG)(WORD)nextiword();
677: { BYTE src = get_byte(srca);
678: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
679: regs.v = regs.c = 0;
680: regs.z = ((BYTE)(src)) == 0;
681: regs.n = ((BYTE)(src)) < 0;
682: put_byte(dsta,src);
683: }}}}}
684: void op_117b(UWORD opcode)
685: {
686: ULONG dstreg = (opcode & 3584) >> 9;
687: {{ CPTR srca = m68k_getpc();
688: UWORD srcdp = nextiword();
689: srca += (LONG)(BYTE)(srcdp & 0xFF);
690: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
691: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
692: srca += srcdpr;
693: { BYTE src = get_byte(srca);
694: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
695: regs.v = regs.c = 0;
696: regs.z = ((BYTE)(src)) == 0;
697: regs.n = ((BYTE)(src)) < 0;
698: put_byte(dsta,src);
699: }}}}}}
700: void op_117c(UWORD opcode)
701: {
702: ULONG dstreg = (opcode & 3584) >> 9;
703: {{ BYTE src = nextiword();
704: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
705: regs.v = regs.c = 0;
706: regs.z = ((BYTE)(src)) == 0;
707: regs.n = ((BYTE)(src)) < 0;
708: put_byte(dsta,src);
709: }}}}
710: void op_1180(UWORD opcode)
711: {
712: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
713: ULONG dstreg = (opcode & 3584) >> 9;
714: {{ BYTE src = regs.d[srcreg];
715: { CPTR dsta = regs.a[dstreg];
716: UWORD dstdp = nextiword();
717: dsta += (LONG)(BYTE)(dstdp & 0xFF);
718: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
719: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
720: dsta += dstdpr;
721: regs.v = regs.c = 0;
722: regs.z = ((BYTE)(src)) == 0;
723: regs.n = ((BYTE)(src)) < 0;
724: put_byte(dsta,src);
725: }}}}}
726: void op_1190(UWORD opcode)
727: {
728: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
729: ULONG dstreg = (opcode & 3584) >> 9;
730: {{ CPTR srca = regs.a[srcreg];
731: BYTE src = get_byte(srca);
732: { CPTR dsta = regs.a[dstreg];
733: UWORD dstdp = nextiword();
734: dsta += (LONG)(BYTE)(dstdp & 0xFF);
735: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
736: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
737: dsta += dstdpr;
738: regs.v = regs.c = 0;
739: regs.z = ((BYTE)(src)) == 0;
740: regs.n = ((BYTE)(src)) < 0;
741: put_byte(dsta,src);
742: }}}}}
743: void op_1198(UWORD opcode)
744: {
745: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
746: ULONG dstreg = (opcode & 3584) >> 9;
747: {{ CPTR srca = regs.a[srcreg];
748: BYTE src = get_byte(srca);
749: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
750: { CPTR dsta = regs.a[dstreg];
751: UWORD dstdp = nextiword();
752: dsta += (LONG)(BYTE)(dstdp & 0xFF);
753: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
754: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
755: dsta += dstdpr;
756: regs.v = regs.c = 0;
757: regs.z = ((BYTE)(src)) == 0;
758: regs.n = ((BYTE)(src)) < 0;
759: put_byte(dsta,src);
760: }}}}}}
761: void op_11a0(UWORD opcode)
762: {
763: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
764: ULONG dstreg = (opcode & 3584) >> 9;
765: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
766: { CPTR srca = regs.a[srcreg];
767: BYTE src = get_byte(srca);
768: { CPTR dsta = regs.a[dstreg];
769: UWORD dstdp = nextiword();
770: dsta += (LONG)(BYTE)(dstdp & 0xFF);
771: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
772: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
773: dsta += dstdpr;
774: regs.v = regs.c = 0;
775: regs.z = ((BYTE)(src)) == 0;
776: regs.n = ((BYTE)(src)) < 0;
777: put_byte(dsta,src);
778: }}}}}}
779: void op_11a8(UWORD opcode)
780: {
781: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
782: ULONG dstreg = (opcode & 3584) >> 9;
783: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
784: BYTE src = get_byte(srca);
785: { CPTR dsta = regs.a[dstreg];
786: UWORD dstdp = nextiword();
787: dsta += (LONG)(BYTE)(dstdp & 0xFF);
788: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
789: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
790: dsta += dstdpr;
791: regs.v = regs.c = 0;
792: regs.z = ((BYTE)(src)) == 0;
793: regs.n = ((BYTE)(src)) < 0;
794: put_byte(dsta,src);
795: }}}}}
796: void op_11b0(UWORD opcode)
797: {
798: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
799: ULONG dstreg = (opcode & 3584) >> 9;
800: {{ CPTR srca = regs.a[srcreg];
801: UWORD srcdp = nextiword();
802: srca += (LONG)(BYTE)(srcdp & 0xFF);
803: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
804: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
805: srca += srcdpr;
806: { BYTE src = get_byte(srca);
807: { CPTR dsta = regs.a[dstreg];
808: UWORD dstdp = nextiword();
809: dsta += (LONG)(BYTE)(dstdp & 0xFF);
810: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
811: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
812: dsta += dstdpr;
813: regs.v = regs.c = 0;
814: regs.z = ((BYTE)(src)) == 0;
815: regs.n = ((BYTE)(src)) < 0;
816: put_byte(dsta,src);
817: }}}}}}}
818: void op_11b8(UWORD opcode)
819: {
820: ULONG dstreg = (opcode & 3584) >> 9;
821: {{ CPTR srca = (LONG)(WORD)nextiword();
822: BYTE src = get_byte(srca);
823: { CPTR dsta = regs.a[dstreg];
824: UWORD dstdp = nextiword();
825: dsta += (LONG)(BYTE)(dstdp & 0xFF);
826: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
827: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
828: dsta += dstdpr;
829: regs.v = regs.c = 0;
830: regs.z = ((BYTE)(src)) == 0;
831: regs.n = ((BYTE)(src)) < 0;
832: put_byte(dsta,src);
833: }}}}}
834: void op_11b9(UWORD opcode)
835: {
836: ULONG dstreg = (opcode & 3584) >> 9;
837: {{ CPTR srca = nextilong();
838: BYTE src = get_byte(srca);
839: { CPTR dsta = regs.a[dstreg];
840: UWORD dstdp = nextiword();
841: dsta += (LONG)(BYTE)(dstdp & 0xFF);
842: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
843: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
844: dsta += dstdpr;
845: regs.v = regs.c = 0;
846: regs.z = ((BYTE)(src)) == 0;
847: regs.n = ((BYTE)(src)) < 0;
848: put_byte(dsta,src);
849: }}}}}
850: void op_11ba(UWORD opcode)
851: {
852: ULONG dstreg = (opcode & 3584) >> 9;
853: {{ CPTR srca = m68k_getpc();
854: srca += (LONG)(WORD)nextiword();
855: { BYTE src = get_byte(srca);
856: { CPTR dsta = regs.a[dstreg];
857: UWORD dstdp = nextiword();
858: dsta += (LONG)(BYTE)(dstdp & 0xFF);
859: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
860: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
861: dsta += dstdpr;
862: regs.v = regs.c = 0;
863: regs.z = ((BYTE)(src)) == 0;
864: regs.n = ((BYTE)(src)) < 0;
865: put_byte(dsta,src);
866: }}}}}}
867: void op_11bb(UWORD opcode)
868: {
869: ULONG dstreg = (opcode & 3584) >> 9;
870: {{ CPTR srca = m68k_getpc();
871: UWORD srcdp = nextiword();
872: srca += (LONG)(BYTE)(srcdp & 0xFF);
873: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
874: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
875: srca += srcdpr;
876: { BYTE src = get_byte(srca);
877: { CPTR dsta = regs.a[dstreg];
878: UWORD dstdp = nextiword();
879: dsta += (LONG)(BYTE)(dstdp & 0xFF);
880: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
881: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
882: dsta += dstdpr;
883: regs.v = regs.c = 0;
884: regs.z = ((BYTE)(src)) == 0;
885: regs.n = ((BYTE)(src)) < 0;
886: put_byte(dsta,src);
887: }}}}}}}
888: void op_11bc(UWORD opcode)
889: {
890: ULONG dstreg = (opcode & 3584) >> 9;
891: {{ BYTE src = nextiword();
892: { CPTR dsta = regs.a[dstreg];
893: UWORD dstdp = nextiword();
894: dsta += (LONG)(BYTE)(dstdp & 0xFF);
895: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
896: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
897: dsta += dstdpr;
898: regs.v = regs.c = 0;
899: regs.z = ((BYTE)(src)) == 0;
900: regs.n = ((BYTE)(src)) < 0;
901: put_byte(dsta,src);
902: }}}}}
903: void op_11c0(UWORD opcode)
904: {
905: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
906: {{ BYTE src = regs.d[srcreg];
907: { CPTR dsta = (LONG)(WORD)nextiword();
908: regs.v = regs.c = 0;
909: regs.z = ((BYTE)(src)) == 0;
910: regs.n = ((BYTE)(src)) < 0;
911: put_byte(dsta,src);
912: }}}}
913: void op_11d0(UWORD opcode)
914: {
915: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
916: {{ CPTR srca = regs.a[srcreg];
917: BYTE src = get_byte(srca);
918: { CPTR dsta = (LONG)(WORD)nextiword();
919: regs.v = regs.c = 0;
920: regs.z = ((BYTE)(src)) == 0;
921: regs.n = ((BYTE)(src)) < 0;
922: put_byte(dsta,src);
923: }}}}
924: void op_11d8(UWORD opcode)
925: {
926: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
927: {{ CPTR srca = regs.a[srcreg];
928: BYTE src = get_byte(srca);
929: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
930: { CPTR dsta = (LONG)(WORD)nextiword();
931: regs.v = regs.c = 0;
932: regs.z = ((BYTE)(src)) == 0;
933: regs.n = ((BYTE)(src)) < 0;
934: put_byte(dsta,src);
935: }}}}}
936: void op_11e0(UWORD opcode)
937: {
938: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
939: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
940: { CPTR srca = regs.a[srcreg];
941: BYTE src = get_byte(srca);
942: { CPTR dsta = (LONG)(WORD)nextiword();
943: regs.v = regs.c = 0;
944: regs.z = ((BYTE)(src)) == 0;
945: regs.n = ((BYTE)(src)) < 0;
946: put_byte(dsta,src);
947: }}}}}
948: void op_11e8(UWORD opcode)
949: {
950: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
951: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
952: BYTE src = get_byte(srca);
953: { CPTR dsta = (LONG)(WORD)nextiword();
954: regs.v = regs.c = 0;
955: regs.z = ((BYTE)(src)) == 0;
956: regs.n = ((BYTE)(src)) < 0;
957: put_byte(dsta,src);
958: }}}}
959: void op_11f0(UWORD opcode)
960: {
961: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
962: {{ CPTR srca = regs.a[srcreg];
963: UWORD srcdp = nextiword();
964: srca += (LONG)(BYTE)(srcdp & 0xFF);
965: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
966: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
967: srca += srcdpr;
968: { BYTE src = get_byte(srca);
969: { CPTR dsta = (LONG)(WORD)nextiword();
970: regs.v = regs.c = 0;
971: regs.z = ((BYTE)(src)) == 0;
972: regs.n = ((BYTE)(src)) < 0;
973: put_byte(dsta,src);
974: }}}}}}
975: void op_11f8(UWORD opcode)
976: {
977: {{ CPTR srca = (LONG)(WORD)nextiword();
978: BYTE src = get_byte(srca);
979: { CPTR dsta = (LONG)(WORD)nextiword();
980: regs.v = regs.c = 0;
981: regs.z = ((BYTE)(src)) == 0;
982: regs.n = ((BYTE)(src)) < 0;
983: put_byte(dsta,src);
984: }}}}
985: void op_11f9(UWORD opcode)
986: {
987: {{ CPTR srca = nextilong();
988: BYTE src = get_byte(srca);
989: { CPTR dsta = (LONG)(WORD)nextiword();
990: regs.v = regs.c = 0;
991: regs.z = ((BYTE)(src)) == 0;
992: regs.n = ((BYTE)(src)) < 0;
993: put_byte(dsta,src);
994: }}}}
995: void op_11fa(UWORD opcode)
996: {
997: {{ CPTR srca = m68k_getpc();
998: srca += (LONG)(WORD)nextiword();
999: { BYTE src = get_byte(srca);
1000: { CPTR dsta = (LONG)(WORD)nextiword();
1001: regs.v = regs.c = 0;
1002: regs.z = ((BYTE)(src)) == 0;
1003: regs.n = ((BYTE)(src)) < 0;
1004: put_byte(dsta,src);
1005: }}}}}
1006: void op_11fb(UWORD opcode)
1007: {
1008: {{ CPTR srca = m68k_getpc();
1009: UWORD srcdp = nextiword();
1010: srca += (LONG)(BYTE)(srcdp & 0xFF);
1011: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1012: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1013: srca += srcdpr;
1014: { BYTE src = get_byte(srca);
1015: { CPTR dsta = (LONG)(WORD)nextiword();
1016: regs.v = regs.c = 0;
1017: regs.z = ((BYTE)(src)) == 0;
1018: regs.n = ((BYTE)(src)) < 0;
1019: put_byte(dsta,src);
1020: }}}}}}
1021: void op_11fc(UWORD opcode)
1022: {
1023: {{ BYTE src = nextiword();
1024: { CPTR dsta = (LONG)(WORD)nextiword();
1025: regs.v = regs.c = 0;
1026: regs.z = ((BYTE)(src)) == 0;
1027: regs.n = ((BYTE)(src)) < 0;
1028: put_byte(dsta,src);
1029: }}}}
1030: void op_13c0(UWORD opcode)
1031: {
1032: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1033: {{ BYTE src = regs.d[srcreg];
1034: { CPTR dsta = nextilong();
1035: regs.v = regs.c = 0;
1036: regs.z = ((BYTE)(src)) == 0;
1037: regs.n = ((BYTE)(src)) < 0;
1038: put_byte(dsta,src);
1039: }}}}
1040: void op_13d0(UWORD opcode)
1041: {
1042: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1043: {{ CPTR srca = regs.a[srcreg];
1044: BYTE src = get_byte(srca);
1045: { CPTR dsta = nextilong();
1046: regs.v = regs.c = 0;
1047: regs.z = ((BYTE)(src)) == 0;
1048: regs.n = ((BYTE)(src)) < 0;
1049: put_byte(dsta,src);
1050: }}}}
1051: void op_13d8(UWORD opcode)
1052: {
1053: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1054: {{ CPTR srca = regs.a[srcreg];
1055: BYTE src = get_byte(srca);
1056: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
1057: { CPTR dsta = nextilong();
1058: regs.v = regs.c = 0;
1059: regs.z = ((BYTE)(src)) == 0;
1060: regs.n = ((BYTE)(src)) < 0;
1061: put_byte(dsta,src);
1062: }}}}}
1063: void op_13e0(UWORD opcode)
1064: {
1065: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1066: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
1067: { CPTR srca = regs.a[srcreg];
1068: BYTE src = get_byte(srca);
1069: { CPTR dsta = nextilong();
1070: regs.v = regs.c = 0;
1071: regs.z = ((BYTE)(src)) == 0;
1072: regs.n = ((BYTE)(src)) < 0;
1073: put_byte(dsta,src);
1074: }}}}}
1075: void op_13e8(UWORD opcode)
1076: {
1077: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1078: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
1079: BYTE src = get_byte(srca);
1080: { CPTR dsta = nextilong();
1081: regs.v = regs.c = 0;
1082: regs.z = ((BYTE)(src)) == 0;
1083: regs.n = ((BYTE)(src)) < 0;
1084: put_byte(dsta,src);
1085: }}}}
1086: void op_13f0(UWORD opcode)
1087: {
1088: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1089: {{ CPTR srca = regs.a[srcreg];
1090: UWORD srcdp = nextiword();
1091: srca += (LONG)(BYTE)(srcdp & 0xFF);
1092: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1093: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1094: srca += srcdpr;
1095: { BYTE src = get_byte(srca);
1096: { CPTR dsta = nextilong();
1097: regs.v = regs.c = 0;
1098: regs.z = ((BYTE)(src)) == 0;
1099: regs.n = ((BYTE)(src)) < 0;
1100: put_byte(dsta,src);
1101: }}}}}}
1102: void op_13f8(UWORD opcode)
1103: {
1104: {{ CPTR srca = (LONG)(WORD)nextiword();
1105: BYTE src = get_byte(srca);
1106: { CPTR dsta = nextilong();
1107: regs.v = regs.c = 0;
1108: regs.z = ((BYTE)(src)) == 0;
1109: regs.n = ((BYTE)(src)) < 0;
1110: put_byte(dsta,src);
1111: }}}}
1112: void op_13f9(UWORD opcode)
1113: {
1114: {{ CPTR srca = nextilong();
1115: BYTE src = get_byte(srca);
1116: { CPTR dsta = nextilong();
1117: regs.v = regs.c = 0;
1118: regs.z = ((BYTE)(src)) == 0;
1119: regs.n = ((BYTE)(src)) < 0;
1120: put_byte(dsta,src);
1121: }}}}
1122: void op_13fa(UWORD opcode)
1123: {
1124: {{ CPTR srca = m68k_getpc();
1125: srca += (LONG)(WORD)nextiword();
1126: { BYTE src = get_byte(srca);
1127: { CPTR dsta = nextilong();
1128: regs.v = regs.c = 0;
1129: regs.z = ((BYTE)(src)) == 0;
1130: regs.n = ((BYTE)(src)) < 0;
1131: put_byte(dsta,src);
1132: }}}}}
1133: void op_13fb(UWORD opcode)
1134: {
1135: {{ CPTR srca = m68k_getpc();
1136: UWORD srcdp = nextiword();
1137: srca += (LONG)(BYTE)(srcdp & 0xFF);
1138: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1139: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1140: srca += srcdpr;
1141: { BYTE src = get_byte(srca);
1142: { CPTR dsta = nextilong();
1143: regs.v = regs.c = 0;
1144: regs.z = ((BYTE)(src)) == 0;
1145: regs.n = ((BYTE)(src)) < 0;
1146: put_byte(dsta,src);
1147: }}}}}}
1148: void op_13fc(UWORD opcode)
1149: {
1150: {{ BYTE src = nextiword();
1151: { CPTR dsta = nextilong();
1152: regs.v = regs.c = 0;
1153: regs.z = ((BYTE)(src)) == 0;
1154: regs.n = ((BYTE)(src)) < 0;
1155: put_byte(dsta,src);
1156: }}}}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.