![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpuE.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 cpuE.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_e000(UWORD opcode)
10: {
11: ULONG srcreg = 8;
12: ULONG dstreg = (opcode & 7) >> 0;
13: {{ ULONG cnt = srcreg;
14: { BYTE data = regs.d[dstreg];
15: { UBYTE val = data;
16: cnt &= 63;
17: regs.v = 0;
18: { ULONG cmask = 0x80;
19: ULONG sign = cmask & val;
20: for(;cnt;--cnt){
21: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
22: }
23: regs.n = sign != 0;
24: regs.z = val == 0;
25: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
26: }}}}}}
27: void op_e008(UWORD opcode)
28: {
29: ULONG srcreg = 8;
30: ULONG dstreg = (opcode & 7) >> 0;
31: {{ ULONG cnt = srcreg;
32: { BYTE data = regs.d[dstreg];
33: { UBYTE val = data;
34: cnt &= 63;
35: { int carry = 0;
36: for(;cnt;--cnt){
37: carry=val&1; val >>= 1;
38: }
39: regs.v = regs.c = 0;
40: regs.z = ((BYTE)(val)) == 0;
41: regs.n = ((BYTE)(val)) < 0;
42: regs.c = regs.x = carry!=0;
43: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
44: }}}}}}
45: void op_e010(UWORD opcode)
46: {
47: ULONG srcreg = 8;
48: ULONG dstreg = (opcode & 7) >> 0;
49: {{ ULONG cnt = srcreg;
50: { BYTE data = regs.d[dstreg];
51: { UBYTE val = data;
52: cnt &= 63;
53: { int carry = 0;
54: ULONG cmask = 0x80;
55: for(;cnt;--cnt){
56: carry=val&1; val >>= 1;
57: if(regs.x) val |= cmask;
58: regs.x = carry != 0;
59: }
60: regs.v = regs.c = 0;
61: regs.z = ((BYTE)(val)) == 0;
62: regs.n = ((BYTE)(val)) < 0;
63: regs.x = regs.c = carry!=0;
64: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
65: }}}}}}
66: void op_e018(UWORD opcode)
67: {
68: ULONG srcreg = 8;
69: ULONG dstreg = (opcode & 7) >> 0;
70: {{ ULONG cnt = srcreg;
71: { BYTE data = regs.d[dstreg];
72: { UBYTE val = data;
73: cnt &= 63;
74: { int carry = 0;
75: ULONG cmask = 0x80;
76: for(;cnt;--cnt){
77: carry=val&1; val = (ULONG)val >> 1;
78: if(carry) val |= cmask;
79: }
80: regs.v = regs.c = 0;
81: regs.z = ((BYTE)(val)) == 0;
82: regs.n = ((BYTE)(val)) < 0;
83: regs.c = carry!=0;
84: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
85: }}}}}}
86: void op_e020(UWORD opcode)
87: {
88: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
89: ULONG dstreg = (opcode & 7) >> 0;
90: {{ BYTE cnt = regs.d[srcreg];
91: { BYTE data = regs.d[dstreg];
92: { UBYTE val = data;
93: cnt &= 63;
94: regs.v = 0;
95: { ULONG cmask = 0x80;
96: ULONG sign = cmask & val;
97: for(;cnt;--cnt){
98: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
99: }
100: regs.n = sign != 0;
101: regs.z = val == 0;
102: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
103: }}}}}}
104: void op_e028(UWORD opcode)
105: {
106: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
107: ULONG dstreg = (opcode & 7) >> 0;
108: {{ BYTE cnt = regs.d[srcreg];
109: { BYTE data = regs.d[dstreg];
110: { UBYTE val = data;
111: cnt &= 63;
112: { int carry = 0;
113: for(;cnt;--cnt){
114: carry=val&1; val >>= 1;
115: }
116: regs.v = regs.c = 0;
117: regs.z = ((BYTE)(val)) == 0;
118: regs.n = ((BYTE)(val)) < 0;
119: regs.c = regs.x = carry!=0;
120: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
121: }}}}}}
122: void op_e030(UWORD opcode)
123: {
124: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
125: ULONG dstreg = (opcode & 7) >> 0;
126: {{ BYTE cnt = regs.d[srcreg];
127: { BYTE data = regs.d[dstreg];
128: { UBYTE val = data;
129: cnt &= 63;
130: { int carry = 0;
131: ULONG cmask = 0x80;
132: for(;cnt;--cnt){
133: carry=val&1; val >>= 1;
134: if(regs.x) val |= cmask;
135: regs.x = carry != 0;
136: }
137: regs.v = regs.c = 0;
138: regs.z = ((BYTE)(val)) == 0;
139: regs.n = ((BYTE)(val)) < 0;
140: regs.x = regs.c = carry!=0;
141: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
142: }}}}}}
143: void op_e038(UWORD opcode)
144: {
145: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
146: ULONG dstreg = (opcode & 7) >> 0;
147: {{ BYTE cnt = regs.d[srcreg];
148: { BYTE data = regs.d[dstreg];
149: { UBYTE val = data;
150: cnt &= 63;
151: { int carry = 0;
152: ULONG cmask = 0x80;
153: for(;cnt;--cnt){
154: carry=val&1; val = (ULONG)val >> 1;
155: if(carry) val |= cmask;
156: }
157: regs.v = regs.c = 0;
158: regs.z = ((BYTE)(val)) == 0;
159: regs.n = ((BYTE)(val)) < 0;
160: regs.c = carry!=0;
161: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
162: }}}}}}
163: void op_e040(UWORD opcode)
164: {
165: ULONG srcreg = 8;
166: ULONG dstreg = (opcode & 7) >> 0;
167: {{ ULONG cnt = srcreg;
168: { WORD data = regs.d[dstreg];
169: { UWORD val = data;
170: cnt &= 63;
171: regs.v = 0;
172: { ULONG cmask = 0x8000;
173: ULONG sign = cmask & val;
174: for(;cnt;--cnt){
175: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
176: }
177: regs.n = sign != 0;
178: regs.z = val == 0;
179: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
180: }}}}}}
181: void op_e048(UWORD opcode)
182: {
183: ULONG srcreg = 8;
184: ULONG dstreg = (opcode & 7) >> 0;
185: {{ ULONG cnt = srcreg;
186: { WORD data = regs.d[dstreg];
187: { UWORD val = data;
188: cnt &= 63;
189: { int carry = 0;
190: for(;cnt;--cnt){
191: carry=val&1; val >>= 1;
192: }
193: regs.v = regs.c = 0;
194: regs.z = ((WORD)(val)) == 0;
195: regs.n = ((WORD)(val)) < 0;
196: regs.c = regs.x = carry!=0;
197: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
198: }}}}}}
199: void op_e050(UWORD opcode)
200: {
201: ULONG srcreg = 8;
202: ULONG dstreg = (opcode & 7) >> 0;
203: {{ ULONG cnt = srcreg;
204: { WORD data = regs.d[dstreg];
205: { UWORD val = data;
206: cnt &= 63;
207: { int carry = 0;
208: ULONG cmask = 0x8000;
209: for(;cnt;--cnt){
210: carry=val&1; val >>= 1;
211: if(regs.x) val |= cmask;
212: regs.x = carry != 0;
213: }
214: regs.v = regs.c = 0;
215: regs.z = ((WORD)(val)) == 0;
216: regs.n = ((WORD)(val)) < 0;
217: regs.x = regs.c = carry!=0;
218: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
219: }}}}}}
220: void op_e058(UWORD opcode)
221: {
222: ULONG srcreg = 8;
223: ULONG dstreg = (opcode & 7) >> 0;
224: {{ ULONG cnt = srcreg;
225: { WORD data = regs.d[dstreg];
226: { UWORD val = data;
227: cnt &= 63;
228: { int carry = 0;
229: ULONG cmask = 0x8000;
230: for(;cnt;--cnt){
231: carry=val&1; val = (ULONG)val >> 1;
232: if(carry) val |= cmask;
233: }
234: regs.v = regs.c = 0;
235: regs.z = ((WORD)(val)) == 0;
236: regs.n = ((WORD)(val)) < 0;
237: regs.c = carry!=0;
238: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
239: }}}}}}
240: void op_e060(UWORD opcode)
241: {
242: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
243: ULONG dstreg = (opcode & 7) >> 0;
244: {{ WORD cnt = regs.d[srcreg];
245: { WORD data = regs.d[dstreg];
246: { UWORD val = data;
247: cnt &= 63;
248: regs.v = 0;
249: { ULONG cmask = 0x8000;
250: ULONG sign = cmask & val;
251: for(;cnt;--cnt){
252: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
253: }
254: regs.n = sign != 0;
255: regs.z = val == 0;
256: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
257: }}}}}}
258: void op_e068(UWORD opcode)
259: {
260: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
261: ULONG dstreg = (opcode & 7) >> 0;
262: {{ WORD cnt = regs.d[srcreg];
263: { WORD data = regs.d[dstreg];
264: { UWORD val = data;
265: cnt &= 63;
266: { int carry = 0;
267: for(;cnt;--cnt){
268: carry=val&1; val >>= 1;
269: }
270: regs.v = regs.c = 0;
271: regs.z = ((WORD)(val)) == 0;
272: regs.n = ((WORD)(val)) < 0;
273: regs.c = regs.x = carry!=0;
274: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
275: }}}}}}
276: void op_e070(UWORD opcode)
277: {
278: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
279: ULONG dstreg = (opcode & 7) >> 0;
280: {{ WORD cnt = regs.d[srcreg];
281: { WORD data = regs.d[dstreg];
282: { UWORD val = data;
283: cnt &= 63;
284: { int carry = 0;
285: ULONG cmask = 0x8000;
286: for(;cnt;--cnt){
287: carry=val&1; val >>= 1;
288: if(regs.x) val |= cmask;
289: regs.x = carry != 0;
290: }
291: regs.v = regs.c = 0;
292: regs.z = ((WORD)(val)) == 0;
293: regs.n = ((WORD)(val)) < 0;
294: regs.x = regs.c = carry!=0;
295: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
296: }}}}}}
297: void op_e078(UWORD opcode)
298: {
299: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
300: ULONG dstreg = (opcode & 7) >> 0;
301: {{ WORD cnt = regs.d[srcreg];
302: { WORD data = regs.d[dstreg];
303: { UWORD val = data;
304: cnt &= 63;
305: { int carry = 0;
306: ULONG cmask = 0x8000;
307: for(;cnt;--cnt){
308: carry=val&1; val = (ULONG)val >> 1;
309: if(carry) val |= cmask;
310: }
311: regs.v = regs.c = 0;
312: regs.z = ((WORD)(val)) == 0;
313: regs.n = ((WORD)(val)) < 0;
314: regs.c = carry!=0;
315: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
316: }}}}}}
317: void op_e080(UWORD opcode)
318: {
319: ULONG srcreg = 8;
320: ULONG dstreg = (opcode & 7) >> 0;
321: {{ ULONG cnt = srcreg;
322: { LONG data = regs.d[dstreg];
323: { ULONG val = data;
324: cnt &= 63;
325: regs.v = 0;
326: { ULONG cmask = 0x80000000;
327: ULONG sign = cmask & val;
328: for(;cnt;--cnt){
329: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
330: }
331: regs.n = sign != 0;
332: regs.z = val == 0;
333: regs.d[dstreg] = (val);
334: }}}}}}
335: void op_e088(UWORD opcode)
336: {
337: ULONG srcreg = 8;
338: ULONG dstreg = (opcode & 7) >> 0;
339: {{ ULONG cnt = srcreg;
340: { LONG data = regs.d[dstreg];
341: { ULONG val = data;
342: cnt &= 63;
343: { int carry = 0;
344: for(;cnt;--cnt){
345: carry=val&1; val >>= 1;
346: }
347: regs.v = regs.c = 0;
348: regs.z = ((LONG)(val)) == 0;
349: regs.n = ((LONG)(val)) < 0;
350: regs.c = regs.x = carry!=0;
351: regs.d[dstreg] = (val);
352: }}}}}}
353: void op_e090(UWORD opcode)
354: {
355: ULONG srcreg = 8;
356: ULONG dstreg = (opcode & 7) >> 0;
357: {{ ULONG cnt = srcreg;
358: { LONG data = regs.d[dstreg];
359: { ULONG val = data;
360: cnt &= 63;
361: { int carry = 0;
362: ULONG cmask = 0x80000000;
363: for(;cnt;--cnt){
364: carry=val&1; val >>= 1;
365: if(regs.x) val |= cmask;
366: regs.x = carry != 0;
367: }
368: regs.v = regs.c = 0;
369: regs.z = ((LONG)(val)) == 0;
370: regs.n = ((LONG)(val)) < 0;
371: regs.x = regs.c = carry!=0;
372: regs.d[dstreg] = (val);
373: }}}}}}
374: void op_e098(UWORD opcode)
375: {
376: ULONG srcreg = 8;
377: ULONG dstreg = (opcode & 7) >> 0;
378: {{ ULONG cnt = srcreg;
379: { LONG data = regs.d[dstreg];
380: { ULONG val = data;
381: cnt &= 63;
382: { int carry = 0;
383: ULONG cmask = 0x80000000;
384: for(;cnt;--cnt){
385: carry=val&1; val = (ULONG)val >> 1;
386: if(carry) val |= cmask;
387: }
388: regs.v = regs.c = 0;
389: regs.z = ((LONG)(val)) == 0;
390: regs.n = ((LONG)(val)) < 0;
391: regs.c = carry!=0;
392: regs.d[dstreg] = (val);
393: }}}}}}
394: void op_e0a0(UWORD opcode)
395: {
396: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
397: ULONG dstreg = (opcode & 7) >> 0;
398: {{ LONG cnt = regs.d[srcreg];
399: { LONG data = regs.d[dstreg];
400: { ULONG val = data;
401: cnt &= 63;
402: regs.v = 0;
403: { ULONG cmask = 0x80000000;
404: ULONG sign = cmask & val;
405: for(;cnt;--cnt){
406: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
407: }
408: regs.n = sign != 0;
409: regs.z = val == 0;
410: regs.d[dstreg] = (val);
411: }}}}}}
412: void op_e0a8(UWORD opcode)
413: {
414: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
415: ULONG dstreg = (opcode & 7) >> 0;
416: {{ LONG cnt = regs.d[srcreg];
417: { LONG data = regs.d[dstreg];
418: { ULONG val = data;
419: cnt &= 63;
420: { int carry = 0;
421: for(;cnt;--cnt){
422: carry=val&1; val >>= 1;
423: }
424: regs.v = regs.c = 0;
425: regs.z = ((LONG)(val)) == 0;
426: regs.n = ((LONG)(val)) < 0;
427: regs.c = regs.x = carry!=0;
428: regs.d[dstreg] = (val);
429: }}}}}}
430: void op_e0b0(UWORD opcode)
431: {
432: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
433: ULONG dstreg = (opcode & 7) >> 0;
434: {{ LONG cnt = regs.d[srcreg];
435: { LONG data = regs.d[dstreg];
436: { ULONG val = data;
437: cnt &= 63;
438: { int carry = 0;
439: ULONG cmask = 0x80000000;
440: for(;cnt;--cnt){
441: carry=val&1; val >>= 1;
442: if(regs.x) val |= cmask;
443: regs.x = carry != 0;
444: }
445: regs.v = regs.c = 0;
446: regs.z = ((LONG)(val)) == 0;
447: regs.n = ((LONG)(val)) < 0;
448: regs.x = regs.c = carry!=0;
449: regs.d[dstreg] = (val);
450: }}}}}}
451: void op_e0b8(UWORD opcode)
452: {
453: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
454: ULONG dstreg = (opcode & 7) >> 0;
455: {{ LONG cnt = regs.d[srcreg];
456: { LONG data = regs.d[dstreg];
457: { ULONG val = data;
458: cnt &= 63;
459: { int carry = 0;
460: ULONG cmask = 0x80000000;
461: for(;cnt;--cnt){
462: carry=val&1; val = (ULONG)val >> 1;
463: if(carry) val |= cmask;
464: }
465: regs.v = regs.c = 0;
466: regs.z = ((LONG)(val)) == 0;
467: regs.n = ((LONG)(val)) < 0;
468: regs.c = carry!=0;
469: regs.d[dstreg] = (val);
470: }}}}}}
471: void op_e0d0(UWORD opcode)
472: {
473: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
474: {{ CPTR dataa = regs.a[srcreg];
475: WORD data = get_word(dataa);
476: regs.v = 0;
477: { UWORD val = data;
478: ULONG cmask = 0x8000;
479: ULONG sign = cmask & val;
480: regs.c=regs.x=val&1; val = (val >> 1) | sign;
481: regs.n = sign != 0;
482: regs.z = val == 0;
483: put_word(dataa,val);
484: }}}}
485: void op_e0d8(UWORD opcode)
486: {
487: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
488: {{ CPTR dataa = regs.a[srcreg];
489: WORD data = get_word(dataa);
490: { regs.a[srcreg] += 2;
491: regs.v = 0;
492: { UWORD val = data;
493: ULONG cmask = 0x8000;
494: ULONG sign = cmask & val;
495: regs.c=regs.x=val&1; val = (val >> 1) | sign;
496: regs.n = sign != 0;
497: regs.z = val == 0;
498: put_word(dataa,val);
499: }}}}}
500: void op_e0e0(UWORD opcode)
501: {
502: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
503: {{ regs.a[srcreg] -= 2;
504: { CPTR dataa = regs.a[srcreg];
505: WORD data = get_word(dataa);
506: regs.v = 0;
507: { UWORD val = data;
508: ULONG cmask = 0x8000;
509: ULONG sign = cmask & val;
510: regs.c=regs.x=val&1; val = (val >> 1) | sign;
511: regs.n = sign != 0;
512: regs.z = val == 0;
513: put_word(dataa,val);
514: }}}}}
515: void op_e0e8(UWORD opcode)
516: {
517: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
518: {{ CPTR dataa = regs.a[srcreg] + (LONG)(WORD)nextiword();
519: WORD data = get_word(dataa);
520: regs.v = 0;
521: { UWORD val = data;
522: ULONG cmask = 0x8000;
523: ULONG sign = cmask & val;
524: regs.c=regs.x=val&1; val = (val >> 1) | sign;
525: regs.n = sign != 0;
526: regs.z = val == 0;
527: put_word(dataa,val);
528: }}}}
529: void op_e0f0(UWORD opcode)
530: {
531: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
532: {{ CPTR dataa = regs.a[srcreg];
533: UWORD datadp = nextiword();
534: dataa += (LONG)(BYTE)(datadp & 0xFF);
535: { ULONG datadpr = datadp & 0x8000 ? regs.a[(datadp & 0x7000) >> 12] : regs.d[(datadp & 0x7000) >> 12];
536: if (!(datadp & 0x800)) datadpr = (LONG)(WORD)datadpr;
537: dataa += datadpr;
538: { WORD data = get_word(dataa);
539: regs.v = 0;
540: { UWORD val = data;
541: ULONG cmask = 0x8000;
542: ULONG sign = cmask & val;
543: regs.c=regs.x=val&1; val = (val >> 1) | sign;
544: regs.n = sign != 0;
545: regs.z = val == 0;
546: put_word(dataa,val);
547: }}}}}}
548: void op_e0f8(UWORD opcode)
549: {
550: {{ CPTR dataa = (LONG)(WORD)nextiword();
551: WORD data = get_word(dataa);
552: regs.v = 0;
553: { UWORD val = data;
554: ULONG cmask = 0x8000;
555: ULONG sign = cmask & val;
556: regs.c=regs.x=val&1; val = (val >> 1) | sign;
557: regs.n = sign != 0;
558: regs.z = val == 0;
559: put_word(dataa,val);
560: }}}}
561: void op_e0f9(UWORD opcode)
562: {
563: {{ CPTR dataa = nextilong();
564: WORD data = get_word(dataa);
565: regs.v = 0;
566: { UWORD val = data;
567: ULONG cmask = 0x8000;
568: ULONG sign = cmask & val;
569: regs.c=regs.x=val&1; val = (val >> 1) | sign;
570: regs.n = sign != 0;
571: regs.z = val == 0;
572: put_word(dataa,val);
573: }}}}
574: void op_e100(UWORD opcode)
575: {
576: ULONG srcreg = 8;
577: ULONG dstreg = (opcode & 7) >> 0;
578: {{ ULONG cnt = srcreg;
579: { BYTE data = regs.d[dstreg];
580: { UBYTE val = data;
581: cnt &= 63;
582: regs.v = 0;
583: { ULONG cmask = 0x80;
584: ULONG sign = cmask & val;
585: for(;cnt;--cnt){
586: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
587: if ((val&cmask)!=sign)regs.v=1;
588: }
589: regs.n = (val&cmask) != 0;
590: regs.z = val == 0;
591: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
592: }}}}}}
593: void op_e108(UWORD opcode)
594: {
595: ULONG srcreg = 8;
596: ULONG dstreg = (opcode & 7) >> 0;
597: {{ ULONG cnt = srcreg;
598: { BYTE data = regs.d[dstreg];
599: { UBYTE val = data;
600: cnt &= 63;
601: { int carry = 0;
602: ULONG cmask = 0x80;
603: for(;cnt;--cnt){
604: carry=val&cmask; val <<= 1;
605: }
606: regs.v = regs.c = 0;
607: regs.z = ((BYTE)(val)) == 0;
608: regs.n = ((BYTE)(val)) < 0;
609: regs.c = regs.x = carry!=0;
610: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
611: }}}}}}
612: void op_e110(UWORD opcode)
613: {
614: ULONG srcreg = 8;
615: ULONG dstreg = (opcode & 7) >> 0;
616: {{ ULONG cnt = srcreg;
617: { BYTE data = regs.d[dstreg];
618: { UBYTE val = data;
619: cnt &= 63;
620: { int carry = 0;
621: ULONG cmask = 0x80;
622: for(;cnt;--cnt){
623: carry=val&cmask; val <<= 1;
624: if(regs.x) val |= 1;
625: regs.x = carry != 0;
626: }
627: regs.v = regs.c = 0;
628: regs.z = ((BYTE)(val)) == 0;
629: regs.n = ((BYTE)(val)) < 0;
630: regs.x = regs.c = carry!=0;
631: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
632: }}}}}}
633: void op_e118(UWORD opcode)
634: {
635: ULONG srcreg = 8;
636: ULONG dstreg = (opcode & 7) >> 0;
637: {{ ULONG cnt = srcreg;
638: { BYTE data = regs.d[dstreg];
639: { UBYTE val = data;
640: cnt &= 63;
641: { int carry = 0;
642: ULONG cmask = 0x80;
643: for(;cnt;--cnt){
644: carry=val&cmask; val <<= 1;
645: if(carry) val |= 1;
646: }
647: regs.v = regs.c = 0;
648: regs.z = ((BYTE)(val)) == 0;
649: regs.n = ((BYTE)(val)) < 0;
650: regs.c = carry!=0;
651: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
652: }}}}}}
653: void op_e120(UWORD opcode)
654: {
655: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
656: ULONG dstreg = (opcode & 7) >> 0;
657: {{ BYTE cnt = regs.d[srcreg];
658: { BYTE data = regs.d[dstreg];
659: { UBYTE val = data;
660: cnt &= 63;
661: regs.v = 0;
662: { ULONG cmask = 0x80;
663: ULONG sign = cmask & val;
664: for(;cnt;--cnt){
665: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
666: if ((val&cmask)!=sign)regs.v=1;
667: }
668: regs.n = (val&cmask) != 0;
669: regs.z = val == 0;
670: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
671: }}}}}}
672: void op_e128(UWORD opcode)
673: {
674: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
675: ULONG dstreg = (opcode & 7) >> 0;
676: {{ BYTE cnt = regs.d[srcreg];
677: { BYTE data = regs.d[dstreg];
678: { UBYTE val = data;
679: cnt &= 63;
680: { int carry = 0;
681: ULONG cmask = 0x80;
682: for(;cnt;--cnt){
683: carry=val&cmask; val <<= 1;
684: }
685: regs.v = regs.c = 0;
686: regs.z = ((BYTE)(val)) == 0;
687: regs.n = ((BYTE)(val)) < 0;
688: regs.c = regs.x = carry!=0;
689: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
690: }}}}}}
691: void op_e130(UWORD opcode)
692: {
693: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
694: ULONG dstreg = (opcode & 7) >> 0;
695: {{ BYTE cnt = regs.d[srcreg];
696: { BYTE data = regs.d[dstreg];
697: { UBYTE val = data;
698: cnt &= 63;
699: { int carry = 0;
700: ULONG cmask = 0x80;
701: for(;cnt;--cnt){
702: carry=val&cmask; val <<= 1;
703: if(regs.x) val |= 1;
704: regs.x = carry != 0;
705: }
706: regs.v = regs.c = 0;
707: regs.z = ((BYTE)(val)) == 0;
708: regs.n = ((BYTE)(val)) < 0;
709: regs.x = regs.c = carry!=0;
710: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
711: }}}}}}
712: void op_e138(UWORD opcode)
713: {
714: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
715: ULONG dstreg = (opcode & 7) >> 0;
716: {{ BYTE cnt = regs.d[srcreg];
717: { BYTE data = regs.d[dstreg];
718: { UBYTE val = data;
719: cnt &= 63;
720: { int carry = 0;
721: ULONG cmask = 0x80;
722: for(;cnt;--cnt){
723: carry=val&cmask; val <<= 1;
724: if(carry) val |= 1;
725: }
726: regs.v = regs.c = 0;
727: regs.z = ((BYTE)(val)) == 0;
728: regs.n = ((BYTE)(val)) < 0;
729: regs.c = carry!=0;
730: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
731: }}}}}}
732: void op_e140(UWORD opcode)
733: {
734: ULONG srcreg = 8;
735: ULONG dstreg = (opcode & 7) >> 0;
736: {{ ULONG cnt = srcreg;
737: { WORD data = regs.d[dstreg];
738: { UWORD val = data;
739: cnt &= 63;
740: regs.v = 0;
741: { ULONG cmask = 0x8000;
742: ULONG sign = cmask & val;
743: for(;cnt;--cnt){
744: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
745: if ((val&cmask)!=sign)regs.v=1;
746: }
747: regs.n = (val&cmask) != 0;
748: regs.z = val == 0;
749: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
750: }}}}}}
751: void op_e148(UWORD opcode)
752: {
753: ULONG srcreg = 8;
754: ULONG dstreg = (opcode & 7) >> 0;
755: {{ ULONG cnt = srcreg;
756: { WORD data = regs.d[dstreg];
757: { UWORD val = data;
758: cnt &= 63;
759: { int carry = 0;
760: ULONG cmask = 0x8000;
761: for(;cnt;--cnt){
762: carry=val&cmask; val <<= 1;
763: }
764: regs.v = regs.c = 0;
765: regs.z = ((WORD)(val)) == 0;
766: regs.n = ((WORD)(val)) < 0;
767: regs.c = regs.x = carry!=0;
768: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
769: }}}}}}
770: void op_e150(UWORD opcode)
771: {
772: ULONG srcreg = 8;
773: ULONG dstreg = (opcode & 7) >> 0;
774: {{ ULONG cnt = srcreg;
775: { WORD data = regs.d[dstreg];
776: { UWORD val = data;
777: cnt &= 63;
778: { int carry = 0;
779: ULONG cmask = 0x8000;
780: for(;cnt;--cnt){
781: carry=val&cmask; val <<= 1;
782: if(regs.x) val |= 1;
783: regs.x = carry != 0;
784: }
785: regs.v = regs.c = 0;
786: regs.z = ((WORD)(val)) == 0;
787: regs.n = ((WORD)(val)) < 0;
788: regs.x = regs.c = carry!=0;
789: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
790: }}}}}}
791: void op_e158(UWORD opcode)
792: {
793: ULONG srcreg = 8;
794: ULONG dstreg = (opcode & 7) >> 0;
795: {{ ULONG cnt = srcreg;
796: { WORD data = regs.d[dstreg];
797: { UWORD val = data;
798: cnt &= 63;
799: { int carry = 0;
800: ULONG cmask = 0x8000;
801: for(;cnt;--cnt){
802: carry=val&cmask; val <<= 1;
803: if(carry) val |= 1;
804: }
805: regs.v = regs.c = 0;
806: regs.z = ((WORD)(val)) == 0;
807: regs.n = ((WORD)(val)) < 0;
808: regs.c = carry!=0;
809: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
810: }}}}}}
811: void op_e160(UWORD opcode)
812: {
813: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
814: ULONG dstreg = (opcode & 7) >> 0;
815: {{ WORD cnt = regs.d[srcreg];
816: { WORD data = regs.d[dstreg];
817: { UWORD val = data;
818: cnt &= 63;
819: regs.v = 0;
820: { ULONG cmask = 0x8000;
821: ULONG sign = cmask & val;
822: for(;cnt;--cnt){
823: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
824: if ((val&cmask)!=sign)regs.v=1;
825: }
826: regs.n = (val&cmask) != 0;
827: regs.z = val == 0;
828: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
829: }}}}}}
830: void op_e168(UWORD opcode)
831: {
832: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
833: ULONG dstreg = (opcode & 7) >> 0;
834: {{ WORD cnt = regs.d[srcreg];
835: { WORD data = regs.d[dstreg];
836: { UWORD val = data;
837: cnt &= 63;
838: { int carry = 0;
839: ULONG cmask = 0x8000;
840: for(;cnt;--cnt){
841: carry=val&cmask; val <<= 1;
842: }
843: regs.v = regs.c = 0;
844: regs.z = ((WORD)(val)) == 0;
845: regs.n = ((WORD)(val)) < 0;
846: regs.c = regs.x = carry!=0;
847: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
848: }}}}}}
849: void op_e170(UWORD opcode)
850: {
851: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
852: ULONG dstreg = (opcode & 7) >> 0;
853: {{ WORD cnt = regs.d[srcreg];
854: { WORD data = regs.d[dstreg];
855: { UWORD val = data;
856: cnt &= 63;
857: { int carry = 0;
858: ULONG cmask = 0x8000;
859: for(;cnt;--cnt){
860: carry=val&cmask; val <<= 1;
861: if(regs.x) val |= 1;
862: regs.x = carry != 0;
863: }
864: regs.v = regs.c = 0;
865: regs.z = ((WORD)(val)) == 0;
866: regs.n = ((WORD)(val)) < 0;
867: regs.x = regs.c = carry!=0;
868: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
869: }}}}}}
870: void op_e178(UWORD opcode)
871: {
872: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
873: ULONG dstreg = (opcode & 7) >> 0;
874: {{ WORD cnt = regs.d[srcreg];
875: { WORD data = regs.d[dstreg];
876: { UWORD val = data;
877: cnt &= 63;
878: { int carry = 0;
879: ULONG cmask = 0x8000;
880: for(;cnt;--cnt){
881: carry=val&cmask; val <<= 1;
882: if(carry) val |= 1;
883: }
884: regs.v = regs.c = 0;
885: regs.z = ((WORD)(val)) == 0;
886: regs.n = ((WORD)(val)) < 0;
887: regs.c = carry!=0;
888: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
889: }}}}}}
890: void op_e180(UWORD opcode)
891: {
892: ULONG srcreg = 8;
893: ULONG dstreg = (opcode & 7) >> 0;
894: {{ ULONG cnt = srcreg;
895: { LONG data = regs.d[dstreg];
896: { ULONG val = data;
897: cnt &= 63;
898: regs.v = 0;
899: { ULONG cmask = 0x80000000;
900: ULONG sign = cmask & val;
901: for(;cnt;--cnt){
902: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
903: if ((val&cmask)!=sign)regs.v=1;
904: }
905: regs.n = (val&cmask) != 0;
906: regs.z = val == 0;
907: regs.d[dstreg] = (val);
908: }}}}}}
909: void op_e188(UWORD opcode)
910: {
911: ULONG srcreg = 8;
912: ULONG dstreg = (opcode & 7) >> 0;
913: {{ ULONG cnt = srcreg;
914: { LONG data = regs.d[dstreg];
915: { ULONG val = data;
916: cnt &= 63;
917: { int carry = 0;
918: ULONG cmask = 0x80000000;
919: for(;cnt;--cnt){
920: carry=val&cmask; val <<= 1;
921: }
922: regs.v = regs.c = 0;
923: regs.z = ((LONG)(val)) == 0;
924: regs.n = ((LONG)(val)) < 0;
925: regs.c = regs.x = carry!=0;
926: regs.d[dstreg] = (val);
927: }}}}}}
928: void op_e190(UWORD opcode)
929: {
930: ULONG srcreg = 8;
931: ULONG dstreg = (opcode & 7) >> 0;
932: {{ ULONG cnt = srcreg;
933: { LONG data = regs.d[dstreg];
934: { ULONG val = data;
935: cnt &= 63;
936: { int carry = 0;
937: ULONG cmask = 0x80000000;
938: for(;cnt;--cnt){
939: carry=val&cmask; val <<= 1;
940: if(regs.x) val |= 1;
941: regs.x = carry != 0;
942: }
943: regs.v = regs.c = 0;
944: regs.z = ((LONG)(val)) == 0;
945: regs.n = ((LONG)(val)) < 0;
946: regs.x = regs.c = carry!=0;
947: regs.d[dstreg] = (val);
948: }}}}}}
949: void op_e198(UWORD opcode)
950: {
951: ULONG srcreg = 8;
952: ULONG dstreg = (opcode & 7) >> 0;
953: {{ ULONG cnt = srcreg;
954: { LONG data = regs.d[dstreg];
955: { ULONG val = data;
956: cnt &= 63;
957: { int carry = 0;
958: ULONG cmask = 0x80000000;
959: for(;cnt;--cnt){
960: carry=val&cmask; val <<= 1;
961: if(carry) val |= 1;
962: }
963: regs.v = regs.c = 0;
964: regs.z = ((LONG)(val)) == 0;
965: regs.n = ((LONG)(val)) < 0;
966: regs.c = carry!=0;
967: regs.d[dstreg] = (val);
968: }}}}}}
969: void op_e1a0(UWORD opcode)
970: {
971: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
972: ULONG dstreg = (opcode & 7) >> 0;
973: {{ LONG cnt = regs.d[srcreg];
974: { LONG data = regs.d[dstreg];
975: { ULONG val = data;
976: cnt &= 63;
977: regs.v = 0;
978: { ULONG cmask = 0x80000000;
979: ULONG sign = cmask & val;
980: for(;cnt;--cnt){
981: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
982: if ((val&cmask)!=sign)regs.v=1;
983: }
984: regs.n = (val&cmask) != 0;
985: regs.z = val == 0;
986: regs.d[dstreg] = (val);
987: }}}}}}
988: void op_e1a8(UWORD opcode)
989: {
990: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
991: ULONG dstreg = (opcode & 7) >> 0;
992: {{ LONG cnt = regs.d[srcreg];
993: { LONG data = regs.d[dstreg];
994: { ULONG val = data;
995: cnt &= 63;
996: { int carry = 0;
997: ULONG cmask = 0x80000000;
998: for(;cnt;--cnt){
999: carry=val&cmask; val <<= 1;
1000: }
1001: regs.v = regs.c = 0;
1002: regs.z = ((LONG)(val)) == 0;
1003: regs.n = ((LONG)(val)) < 0;
1004: regs.c = regs.x = carry!=0;
1005: regs.d[dstreg] = (val);
1006: }}}}}}
1007: void op_e1b0(UWORD opcode)
1008: {
1009: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
1010: ULONG dstreg = (opcode & 7) >> 0;
1011: {{ LONG cnt = regs.d[srcreg];
1012: { LONG data = regs.d[dstreg];
1013: { ULONG val = data;
1014: cnt &= 63;
1015: { int carry = 0;
1016: ULONG cmask = 0x80000000;
1017: for(;cnt;--cnt){
1018: carry=val&cmask; val <<= 1;
1019: if(regs.x) val |= 1;
1020: regs.x = carry != 0;
1021: }
1022: regs.v = regs.c = 0;
1023: regs.z = ((LONG)(val)) == 0;
1024: regs.n = ((LONG)(val)) < 0;
1025: regs.x = regs.c = carry!=0;
1026: regs.d[dstreg] = (val);
1027: }}}}}}
1028: void op_e1b8(UWORD opcode)
1029: {
1030: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
1031: ULONG dstreg = (opcode & 7) >> 0;
1032: {{ LONG cnt = regs.d[srcreg];
1033: { LONG data = regs.d[dstreg];
1034: { ULONG val = data;
1035: cnt &= 63;
1036: { int carry = 0;
1037: ULONG cmask = 0x80000000;
1038: for(;cnt;--cnt){
1039: carry=val&cmask; val <<= 1;
1040: if(carry) val |= 1;
1041: }
1042: regs.v = regs.c = 0;
1043: regs.z = ((LONG)(val)) == 0;
1044: regs.n = ((LONG)(val)) < 0;
1045: regs.c = carry!=0;
1046: regs.d[dstreg] = (val);
1047: }}}}}}
1048: void op_e1d0(UWORD opcode)
1049: {
1050: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1051: {{ CPTR dataa = regs.a[srcreg];
1052: WORD data = get_word(dataa);
1053: regs.v = 0;
1054: { UWORD val = data;
1055: ULONG cmask = 0x8000;
1056: ULONG sign = cmask & val;
1057: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
1058: if ((val&cmask)!=sign)regs.v=1;
1059: regs.n = (val&cmask) != 0;
1060: regs.z = val == 0;
1061: put_word(dataa,val);
1062: }}}}
1063: void op_e1d8(UWORD opcode)
1064: {
1065: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1066: {{ CPTR dataa = regs.a[srcreg];
1067: WORD data = get_word(dataa);
1068: { regs.a[srcreg] += 2;
1069: regs.v = 0;
1070: { UWORD val = data;
1071: ULONG cmask = 0x8000;
1072: ULONG sign = cmask & val;
1073: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
1074: if ((val&cmask)!=sign)regs.v=1;
1075: regs.n = (val&cmask) != 0;
1076: regs.z = val == 0;
1077: put_word(dataa,val);
1078: }}}}}
1079: void op_e1e0(UWORD opcode)
1080: {
1081: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1082: {{ regs.a[srcreg] -= 2;
1083: { CPTR dataa = regs.a[srcreg];
1084: WORD data = get_word(dataa);
1085: regs.v = 0;
1086: { UWORD val = data;
1087: ULONG cmask = 0x8000;
1088: ULONG sign = cmask & val;
1089: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
1090: if ((val&cmask)!=sign)regs.v=1;
1091: regs.n = (val&cmask) != 0;
1092: regs.z = val == 0;
1093: put_word(dataa,val);
1094: }}}}}
1095: void op_e1e8(UWORD opcode)
1096: {
1097: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1098: {{ CPTR dataa = regs.a[srcreg] + (LONG)(WORD)nextiword();
1099: WORD data = get_word(dataa);
1100: regs.v = 0;
1101: { UWORD val = data;
1102: ULONG cmask = 0x8000;
1103: ULONG sign = cmask & val;
1104: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
1105: if ((val&cmask)!=sign)regs.v=1;
1106: regs.n = (val&cmask) != 0;
1107: regs.z = val == 0;
1108: put_word(dataa,val);
1109: }}}}
1110: void op_e1f0(UWORD opcode)
1111: {
1112: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1113: {{ CPTR dataa = regs.a[srcreg];
1114: UWORD datadp = nextiword();
1115: dataa += (LONG)(BYTE)(datadp & 0xFF);
1116: { ULONG datadpr = datadp & 0x8000 ? regs.a[(datadp & 0x7000) >> 12] : regs.d[(datadp & 0x7000) >> 12];
1117: if (!(datadp & 0x800)) datadpr = (LONG)(WORD)datadpr;
1118: dataa += datadpr;
1119: { WORD data = get_word(dataa);
1120: regs.v = 0;
1121: { UWORD val = data;
1122: ULONG cmask = 0x8000;
1123: ULONG sign = cmask & val;
1124: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
1125: if ((val&cmask)!=sign)regs.v=1;
1126: regs.n = (val&cmask) != 0;
1127: regs.z = val == 0;
1128: put_word(dataa,val);
1129: }}}}}}
1130: void op_e1f8(UWORD opcode)
1131: {
1132: {{ CPTR dataa = (LONG)(WORD)nextiword();
1133: WORD data = get_word(dataa);
1134: regs.v = 0;
1135: { UWORD val = data;
1136: ULONG cmask = 0x8000;
1137: ULONG sign = cmask & val;
1138: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
1139: if ((val&cmask)!=sign)regs.v=1;
1140: regs.n = (val&cmask) != 0;
1141: regs.z = val == 0;
1142: put_word(dataa,val);
1143: }}}}
1144: void op_e1f9(UWORD opcode)
1145: {
1146: {{ CPTR dataa = nextilong();
1147: WORD data = get_word(dataa);
1148: regs.v = 0;
1149: { UWORD val = data;
1150: ULONG cmask = 0x8000;
1151: ULONG sign = cmask & val;
1152: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
1153: if ((val&cmask)!=sign)regs.v=1;
1154: regs.n = (val&cmask) != 0;
1155: regs.z = val == 0;
1156: put_word(dataa,val);
1157: }}}}
1158: void op_e200(UWORD opcode)
1159: {
1160: ULONG srcreg = 1;
1161: ULONG dstreg = (opcode & 7) >> 0;
1162: {{ ULONG cnt = srcreg;
1163: { BYTE data = regs.d[dstreg];
1164: { UBYTE val = data;
1165: cnt &= 63;
1166: regs.v = 0;
1167: { ULONG cmask = 0x80;
1168: ULONG sign = cmask & val;
1169: for(;cnt;--cnt){
1170: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
1171: }
1172: regs.n = sign != 0;
1173: regs.z = val == 0;
1174: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1175: }}}}}}
1176: void op_e208(UWORD opcode)
1177: {
1178: ULONG srcreg = 1;
1179: ULONG dstreg = (opcode & 7) >> 0;
1180: {{ ULONG cnt = srcreg;
1181: { BYTE data = regs.d[dstreg];
1182: { UBYTE val = data;
1183: cnt &= 63;
1184: { int carry = 0;
1185: for(;cnt;--cnt){
1186: carry=val&1; val >>= 1;
1187: }
1188: regs.v = regs.c = 0;
1189: regs.z = ((BYTE)(val)) == 0;
1190: regs.n = ((BYTE)(val)) < 0;
1191: regs.c = regs.x = carry!=0;
1192: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1193: }}}}}}
1194: void op_e210(UWORD opcode)
1195: {
1196: ULONG srcreg = 1;
1197: ULONG dstreg = (opcode & 7) >> 0;
1198: {{ ULONG cnt = srcreg;
1199: { BYTE data = regs.d[dstreg];
1200: { UBYTE val = data;
1201: cnt &= 63;
1202: { int carry = 0;
1203: ULONG cmask = 0x80;
1204: for(;cnt;--cnt){
1205: carry=val&1; val >>= 1;
1206: if(regs.x) val |= cmask;
1207: regs.x = carry != 0;
1208: }
1209: regs.v = regs.c = 0;
1210: regs.z = ((BYTE)(val)) == 0;
1211: regs.n = ((BYTE)(val)) < 0;
1212: regs.x = regs.c = carry!=0;
1213: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1214: }}}}}}
1215: void op_e218(UWORD opcode)
1216: {
1217: ULONG srcreg = 1;
1218: ULONG dstreg = (opcode & 7) >> 0;
1219: {{ ULONG cnt = srcreg;
1220: { BYTE data = regs.d[dstreg];
1221: { UBYTE val = data;
1222: cnt &= 63;
1223: { int carry = 0;
1224: ULONG cmask = 0x80;
1225: for(;cnt;--cnt){
1226: carry=val&1; val = (ULONG)val >> 1;
1227: if(carry) val |= cmask;
1228: }
1229: regs.v = regs.c = 0;
1230: regs.z = ((BYTE)(val)) == 0;
1231: regs.n = ((BYTE)(val)) < 0;
1232: regs.c = carry!=0;
1233: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1234: }}}}}}
1235: void op_e240(UWORD opcode)
1236: {
1237: ULONG srcreg = 1;
1238: ULONG dstreg = (opcode & 7) >> 0;
1239: {{ ULONG cnt = srcreg;
1240: { WORD data = regs.d[dstreg];
1241: { UWORD val = data;
1242: cnt &= 63;
1243: regs.v = 0;
1244: { ULONG cmask = 0x8000;
1245: ULONG sign = cmask & val;
1246: for(;cnt;--cnt){
1247: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
1248: }
1249: regs.n = sign != 0;
1250: regs.z = val == 0;
1251: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1252: }}}}}}
1253: void op_e248(UWORD opcode)
1254: {
1255: ULONG srcreg = 1;
1256: ULONG dstreg = (opcode & 7) >> 0;
1257: {{ ULONG cnt = srcreg;
1258: { WORD data = regs.d[dstreg];
1259: { UWORD val = data;
1260: cnt &= 63;
1261: { int carry = 0;
1262: for(;cnt;--cnt){
1263: carry=val&1; val >>= 1;
1264: }
1265: regs.v = regs.c = 0;
1266: regs.z = ((WORD)(val)) == 0;
1267: regs.n = ((WORD)(val)) < 0;
1268: regs.c = regs.x = carry!=0;
1269: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1270: }}}}}}
1271: void op_e250(UWORD opcode)
1272: {
1273: ULONG srcreg = 1;
1274: ULONG dstreg = (opcode & 7) >> 0;
1275: {{ ULONG cnt = srcreg;
1276: { WORD data = regs.d[dstreg];
1277: { UWORD val = data;
1278: cnt &= 63;
1279: { int carry = 0;
1280: ULONG cmask = 0x8000;
1281: for(;cnt;--cnt){
1282: carry=val&1; val >>= 1;
1283: if(regs.x) val |= cmask;
1284: regs.x = carry != 0;
1285: }
1286: regs.v = regs.c = 0;
1287: regs.z = ((WORD)(val)) == 0;
1288: regs.n = ((WORD)(val)) < 0;
1289: regs.x = regs.c = carry!=0;
1290: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1291: }}}}}}
1292: void op_e258(UWORD opcode)
1293: {
1294: ULONG srcreg = 1;
1295: ULONG dstreg = (opcode & 7) >> 0;
1296: {{ ULONG cnt = srcreg;
1297: { WORD data = regs.d[dstreg];
1298: { UWORD val = data;
1299: cnt &= 63;
1300: { int carry = 0;
1301: ULONG cmask = 0x8000;
1302: for(;cnt;--cnt){
1303: carry=val&1; val = (ULONG)val >> 1;
1304: if(carry) val |= cmask;
1305: }
1306: regs.v = regs.c = 0;
1307: regs.z = ((WORD)(val)) == 0;
1308: regs.n = ((WORD)(val)) < 0;
1309: regs.c = carry!=0;
1310: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1311: }}}}}}
1312: void op_e280(UWORD opcode)
1313: {
1314: ULONG srcreg = 1;
1315: ULONG dstreg = (opcode & 7) >> 0;
1316: {{ ULONG cnt = srcreg;
1317: { LONG data = regs.d[dstreg];
1318: { ULONG val = data;
1319: cnt &= 63;
1320: regs.v = 0;
1321: { ULONG cmask = 0x80000000;
1322: ULONG sign = cmask & val;
1323: for(;cnt;--cnt){
1324: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
1325: }
1326: regs.n = sign != 0;
1327: regs.z = val == 0;
1328: regs.d[dstreg] = (val);
1329: }}}}}}
1330: void op_e288(UWORD opcode)
1331: {
1332: ULONG srcreg = 1;
1333: ULONG dstreg = (opcode & 7) >> 0;
1334: {{ ULONG cnt = srcreg;
1335: { LONG data = regs.d[dstreg];
1336: { ULONG val = data;
1337: cnt &= 63;
1338: { int carry = 0;
1339: for(;cnt;--cnt){
1340: carry=val&1; val >>= 1;
1341: }
1342: regs.v = regs.c = 0;
1343: regs.z = ((LONG)(val)) == 0;
1344: regs.n = ((LONG)(val)) < 0;
1345: regs.c = regs.x = carry!=0;
1346: regs.d[dstreg] = (val);
1347: }}}}}}
1348: void op_e290(UWORD opcode)
1349: {
1350: ULONG srcreg = 1;
1351: ULONG dstreg = (opcode & 7) >> 0;
1352: {{ ULONG cnt = srcreg;
1353: { LONG data = regs.d[dstreg];
1354: { ULONG val = data;
1355: cnt &= 63;
1356: { int carry = 0;
1357: ULONG cmask = 0x80000000;
1358: for(;cnt;--cnt){
1359: carry=val&1; val >>= 1;
1360: if(regs.x) val |= cmask;
1361: regs.x = carry != 0;
1362: }
1363: regs.v = regs.c = 0;
1364: regs.z = ((LONG)(val)) == 0;
1365: regs.n = ((LONG)(val)) < 0;
1366: regs.x = regs.c = carry!=0;
1367: regs.d[dstreg] = (val);
1368: }}}}}}
1369: void op_e298(UWORD opcode)
1370: {
1371: ULONG srcreg = 1;
1372: ULONG dstreg = (opcode & 7) >> 0;
1373: {{ ULONG cnt = srcreg;
1374: { LONG data = regs.d[dstreg];
1375: { ULONG val = data;
1376: cnt &= 63;
1377: { int carry = 0;
1378: ULONG cmask = 0x80000000;
1379: for(;cnt;--cnt){
1380: carry=val&1; val = (ULONG)val >> 1;
1381: if(carry) val |= cmask;
1382: }
1383: regs.v = regs.c = 0;
1384: regs.z = ((LONG)(val)) == 0;
1385: regs.n = ((LONG)(val)) < 0;
1386: regs.c = carry!=0;
1387: regs.d[dstreg] = (val);
1388: }}}}}}
1389: void op_e2d0(UWORD opcode)
1390: {
1391: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1392: {{ CPTR dataa = regs.a[srcreg];
1393: WORD data = get_word(dataa);
1394: { UWORD val = data;
1395: int carry = val&1;
1396: carry=val&1; val >>= 1;
1397: regs.v = regs.c = 0;
1398: regs.z = ((WORD)(val)) == 0;
1399: regs.n = ((WORD)(val)) < 0;
1400: regs.c = regs.x = carry!=0;
1401: put_word(dataa,val);
1402: }}}}
1403: void op_e2d8(UWORD opcode)
1404: {
1405: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1406: {{ CPTR dataa = regs.a[srcreg];
1407: WORD data = get_word(dataa);
1408: { regs.a[srcreg] += 2;
1409: { UWORD val = data;
1410: int carry = val&1;
1411: carry=val&1; val >>= 1;
1412: regs.v = regs.c = 0;
1413: regs.z = ((WORD)(val)) == 0;
1414: regs.n = ((WORD)(val)) < 0;
1415: regs.c = regs.x = carry!=0;
1416: put_word(dataa,val);
1417: }}}}}
1418: void op_e2e0(UWORD opcode)
1419: {
1420: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1421: {{ regs.a[srcreg] -= 2;
1422: { CPTR dataa = regs.a[srcreg];
1423: WORD data = get_word(dataa);
1424: { UWORD val = data;
1425: int carry = val&1;
1426: carry=val&1; val >>= 1;
1427: regs.v = regs.c = 0;
1428: regs.z = ((WORD)(val)) == 0;
1429: regs.n = ((WORD)(val)) < 0;
1430: regs.c = regs.x = carry!=0;
1431: put_word(dataa,val);
1432: }}}}}
1433: void op_e2e8(UWORD opcode)
1434: {
1435: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1436: {{ CPTR dataa = regs.a[srcreg] + (LONG)(WORD)nextiword();
1437: WORD data = get_word(dataa);
1438: { UWORD val = data;
1439: int carry = val&1;
1440: carry=val&1; val >>= 1;
1441: regs.v = regs.c = 0;
1442: regs.z = ((WORD)(val)) == 0;
1443: regs.n = ((WORD)(val)) < 0;
1444: regs.c = regs.x = carry!=0;
1445: put_word(dataa,val);
1446: }}}}
1447: void op_e2f0(UWORD opcode)
1448: {
1449: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1450: {{ CPTR dataa = regs.a[srcreg];
1451: UWORD datadp = nextiword();
1452: dataa += (LONG)(BYTE)(datadp & 0xFF);
1453: { ULONG datadpr = datadp & 0x8000 ? regs.a[(datadp & 0x7000) >> 12] : regs.d[(datadp & 0x7000) >> 12];
1454: if (!(datadp & 0x800)) datadpr = (LONG)(WORD)datadpr;
1455: dataa += datadpr;
1456: { WORD data = get_word(dataa);
1457: { UWORD val = data;
1458: int carry = val&1;
1459: carry=val&1; val >>= 1;
1460: regs.v = regs.c = 0;
1461: regs.z = ((WORD)(val)) == 0;
1462: regs.n = ((WORD)(val)) < 0;
1463: regs.c = regs.x = carry!=0;
1464: put_word(dataa,val);
1465: }}}}}}
1466: void op_e2f8(UWORD opcode)
1467: {
1468: {{ CPTR dataa = (LONG)(WORD)nextiword();
1469: WORD data = get_word(dataa);
1470: { UWORD val = data;
1471: int carry = val&1;
1472: carry=val&1; val >>= 1;
1473: regs.v = regs.c = 0;
1474: regs.z = ((WORD)(val)) == 0;
1475: regs.n = ((WORD)(val)) < 0;
1476: regs.c = regs.x = carry!=0;
1477: put_word(dataa,val);
1478: }}}}
1479: void op_e2f9(UWORD opcode)
1480: {
1481: {{ CPTR dataa = nextilong();
1482: WORD data = get_word(dataa);
1483: { UWORD val = data;
1484: int carry = val&1;
1485: carry=val&1; val >>= 1;
1486: regs.v = regs.c = 0;
1487: regs.z = ((WORD)(val)) == 0;
1488: regs.n = ((WORD)(val)) < 0;
1489: regs.c = regs.x = carry!=0;
1490: put_word(dataa,val);
1491: }}}}
1492: void op_e300(UWORD opcode)
1493: {
1494: ULONG srcreg = 1;
1495: ULONG dstreg = (opcode & 7) >> 0;
1496: {{ ULONG cnt = srcreg;
1497: { BYTE data = regs.d[dstreg];
1498: { UBYTE val = data;
1499: cnt &= 63;
1500: regs.v = 0;
1501: { ULONG cmask = 0x80;
1502: ULONG sign = cmask & val;
1503: for(;cnt;--cnt){
1504: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
1505: if ((val&cmask)!=sign)regs.v=1;
1506: }
1507: regs.n = (val&cmask) != 0;
1508: regs.z = val == 0;
1509: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1510: }}}}}}
1511: void op_e308(UWORD opcode)
1512: {
1513: ULONG srcreg = 1;
1514: ULONG dstreg = (opcode & 7) >> 0;
1515: {{ ULONG cnt = srcreg;
1516: { BYTE data = regs.d[dstreg];
1517: { UBYTE val = data;
1518: cnt &= 63;
1519: { int carry = 0;
1520: ULONG cmask = 0x80;
1521: for(;cnt;--cnt){
1522: carry=val&cmask; val <<= 1;
1523: }
1524: regs.v = regs.c = 0;
1525: regs.z = ((BYTE)(val)) == 0;
1526: regs.n = ((BYTE)(val)) < 0;
1527: regs.c = regs.x = carry!=0;
1528: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1529: }}}}}}
1530: void op_e310(UWORD opcode)
1531: {
1532: ULONG srcreg = 1;
1533: ULONG dstreg = (opcode & 7) >> 0;
1534: {{ ULONG cnt = srcreg;
1535: { BYTE data = regs.d[dstreg];
1536: { UBYTE val = data;
1537: cnt &= 63;
1538: { int carry = 0;
1539: ULONG cmask = 0x80;
1540: for(;cnt;--cnt){
1541: carry=val&cmask; val <<= 1;
1542: if(regs.x) val |= 1;
1543: regs.x = carry != 0;
1544: }
1545: regs.v = regs.c = 0;
1546: regs.z = ((BYTE)(val)) == 0;
1547: regs.n = ((BYTE)(val)) < 0;
1548: regs.x = regs.c = carry!=0;
1549: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1550: }}}}}}
1551: void op_e318(UWORD opcode)
1552: {
1553: ULONG srcreg = 1;
1554: ULONG dstreg = (opcode & 7) >> 0;
1555: {{ ULONG cnt = srcreg;
1556: { BYTE data = regs.d[dstreg];
1557: { UBYTE val = data;
1558: cnt &= 63;
1559: { int carry = 0;
1560: ULONG cmask = 0x80;
1561: for(;cnt;--cnt){
1562: carry=val&cmask; val <<= 1;
1563: if(carry) val |= 1;
1564: }
1565: regs.v = regs.c = 0;
1566: regs.z = ((BYTE)(val)) == 0;
1567: regs.n = ((BYTE)(val)) < 0;
1568: regs.c = carry!=0;
1569: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1570: }}}}}}
1571: void op_e340(UWORD opcode)
1572: {
1573: ULONG srcreg = 1;
1574: ULONG dstreg = (opcode & 7) >> 0;
1575: {{ ULONG cnt = srcreg;
1576: { WORD data = regs.d[dstreg];
1577: { UWORD val = data;
1578: cnt &= 63;
1579: regs.v = 0;
1580: { ULONG cmask = 0x8000;
1581: ULONG sign = cmask & val;
1582: for(;cnt;--cnt){
1583: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
1584: if ((val&cmask)!=sign)regs.v=1;
1585: }
1586: regs.n = (val&cmask) != 0;
1587: regs.z = val == 0;
1588: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1589: }}}}}}
1590: void op_e348(UWORD opcode)
1591: {
1592: ULONG srcreg = 1;
1593: ULONG dstreg = (opcode & 7) >> 0;
1594: {{ ULONG cnt = srcreg;
1595: { WORD data = regs.d[dstreg];
1596: { UWORD val = data;
1597: cnt &= 63;
1598: { int carry = 0;
1599: ULONG cmask = 0x8000;
1600: for(;cnt;--cnt){
1601: carry=val&cmask; val <<= 1;
1602: }
1603: regs.v = regs.c = 0;
1604: regs.z = ((WORD)(val)) == 0;
1605: regs.n = ((WORD)(val)) < 0;
1606: regs.c = regs.x = carry!=0;
1607: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1608: }}}}}}
1609: void op_e350(UWORD opcode)
1610: {
1611: ULONG srcreg = 1;
1612: ULONG dstreg = (opcode & 7) >> 0;
1613: {{ ULONG cnt = srcreg;
1614: { WORD data = regs.d[dstreg];
1615: { UWORD val = data;
1616: cnt &= 63;
1617: { int carry = 0;
1618: ULONG cmask = 0x8000;
1619: for(;cnt;--cnt){
1620: carry=val&cmask; val <<= 1;
1621: if(regs.x) val |= 1;
1622: regs.x = carry != 0;
1623: }
1624: regs.v = regs.c = 0;
1625: regs.z = ((WORD)(val)) == 0;
1626: regs.n = ((WORD)(val)) < 0;
1627: regs.x = regs.c = carry!=0;
1628: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1629: }}}}}}
1630: void op_e358(UWORD opcode)
1631: {
1632: ULONG srcreg = 1;
1633: ULONG dstreg = (opcode & 7) >> 0;
1634: {{ ULONG cnt = srcreg;
1635: { WORD data = regs.d[dstreg];
1636: { UWORD val = data;
1637: cnt &= 63;
1638: { int carry = 0;
1639: ULONG cmask = 0x8000;
1640: for(;cnt;--cnt){
1641: carry=val&cmask; val <<= 1;
1642: if(carry) val |= 1;
1643: }
1644: regs.v = regs.c = 0;
1645: regs.z = ((WORD)(val)) == 0;
1646: regs.n = ((WORD)(val)) < 0;
1647: regs.c = carry!=0;
1648: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1649: }}}}}}
1650: void op_e380(UWORD opcode)
1651: {
1652: ULONG srcreg = 1;
1653: ULONG dstreg = (opcode & 7) >> 0;
1654: {{ ULONG cnt = srcreg;
1655: { LONG data = regs.d[dstreg];
1656: { ULONG val = data;
1657: cnt &= 63;
1658: regs.v = 0;
1659: { ULONG cmask = 0x80000000;
1660: ULONG sign = cmask & val;
1661: for(;cnt;--cnt){
1662: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
1663: if ((val&cmask)!=sign)regs.v=1;
1664: }
1665: regs.n = (val&cmask) != 0;
1666: regs.z = val == 0;
1667: regs.d[dstreg] = (val);
1668: }}}}}}
1669: void op_e388(UWORD opcode)
1670: {
1671: ULONG srcreg = 1;
1672: ULONG dstreg = (opcode & 7) >> 0;
1673: {{ ULONG cnt = srcreg;
1674: { LONG data = regs.d[dstreg];
1675: { ULONG val = data;
1676: cnt &= 63;
1677: { int carry = 0;
1678: ULONG cmask = 0x80000000;
1679: for(;cnt;--cnt){
1680: carry=val&cmask; val <<= 1;
1681: }
1682: regs.v = regs.c = 0;
1683: regs.z = ((LONG)(val)) == 0;
1684: regs.n = ((LONG)(val)) < 0;
1685: regs.c = regs.x = carry!=0;
1686: regs.d[dstreg] = (val);
1687: }}}}}}
1688: void op_e390(UWORD opcode)
1689: {
1690: ULONG srcreg = 1;
1691: ULONG dstreg = (opcode & 7) >> 0;
1692: {{ ULONG cnt = srcreg;
1693: { LONG data = regs.d[dstreg];
1694: { ULONG val = data;
1695: cnt &= 63;
1696: { int carry = 0;
1697: ULONG cmask = 0x80000000;
1698: for(;cnt;--cnt){
1699: carry=val&cmask; val <<= 1;
1700: if(regs.x) val |= 1;
1701: regs.x = carry != 0;
1702: }
1703: regs.v = regs.c = 0;
1704: regs.z = ((LONG)(val)) == 0;
1705: regs.n = ((LONG)(val)) < 0;
1706: regs.x = regs.c = carry!=0;
1707: regs.d[dstreg] = (val);
1708: }}}}}}
1709: void op_e398(UWORD opcode)
1710: {
1711: ULONG srcreg = 1;
1712: ULONG dstreg = (opcode & 7) >> 0;
1713: {{ ULONG cnt = srcreg;
1714: { LONG data = regs.d[dstreg];
1715: { ULONG val = data;
1716: cnt &= 63;
1717: { int carry = 0;
1718: ULONG cmask = 0x80000000;
1719: for(;cnt;--cnt){
1720: carry=val&cmask; val <<= 1;
1721: if(carry) val |= 1;
1722: }
1723: regs.v = regs.c = 0;
1724: regs.z = ((LONG)(val)) == 0;
1725: regs.n = ((LONG)(val)) < 0;
1726: regs.c = carry!=0;
1727: regs.d[dstreg] = (val);
1728: }}}}}}
1729: void op_e3d0(UWORD opcode)
1730: {
1731: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1732: {{ CPTR dataa = regs.a[srcreg];
1733: WORD data = get_word(dataa);
1734: { UWORD val = data;
1735: ULONG cmask = 0x8000;
1736: int carry = val&cmask;
1737: val <<= 1;
1738: regs.v = regs.c = 0;
1739: regs.z = ((WORD)(val)) == 0;
1740: regs.n = ((WORD)(val)) < 0;
1741: regs.c = regs.x = carry!=0;
1742: put_word(dataa,val);
1743: }}}}
1744: void op_e3d8(UWORD opcode)
1745: {
1746: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1747: {{ CPTR dataa = regs.a[srcreg];
1748: WORD data = get_word(dataa);
1749: { regs.a[srcreg] += 2;
1750: { UWORD val = data;
1751: ULONG cmask = 0x8000;
1752: int carry = val&cmask;
1753: val <<= 1;
1754: regs.v = regs.c = 0;
1755: regs.z = ((WORD)(val)) == 0;
1756: regs.n = ((WORD)(val)) < 0;
1757: regs.c = regs.x = carry!=0;
1758: put_word(dataa,val);
1759: }}}}}
1760: void op_e3e0(UWORD opcode)
1761: {
1762: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1763: {{ regs.a[srcreg] -= 2;
1764: { CPTR dataa = regs.a[srcreg];
1765: WORD data = get_word(dataa);
1766: { UWORD val = data;
1767: ULONG cmask = 0x8000;
1768: int carry = val&cmask;
1769: val <<= 1;
1770: regs.v = regs.c = 0;
1771: regs.z = ((WORD)(val)) == 0;
1772: regs.n = ((WORD)(val)) < 0;
1773: regs.c = regs.x = carry!=0;
1774: put_word(dataa,val);
1775: }}}}}
1776: void op_e3e8(UWORD opcode)
1777: {
1778: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1779: {{ CPTR dataa = regs.a[srcreg] + (LONG)(WORD)nextiword();
1780: WORD data = get_word(dataa);
1781: { UWORD val = data;
1782: ULONG cmask = 0x8000;
1783: int carry = val&cmask;
1784: val <<= 1;
1785: regs.v = regs.c = 0;
1786: regs.z = ((WORD)(val)) == 0;
1787: regs.n = ((WORD)(val)) < 0;
1788: regs.c = regs.x = carry!=0;
1789: put_word(dataa,val);
1790: }}}}
1791: void op_e3f0(UWORD opcode)
1792: {
1793: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1794: {{ CPTR dataa = regs.a[srcreg];
1795: UWORD datadp = nextiword();
1796: dataa += (LONG)(BYTE)(datadp & 0xFF);
1797: { ULONG datadpr = datadp & 0x8000 ? regs.a[(datadp & 0x7000) >> 12] : regs.d[(datadp & 0x7000) >> 12];
1798: if (!(datadp & 0x800)) datadpr = (LONG)(WORD)datadpr;
1799: dataa += datadpr;
1800: { WORD data = get_word(dataa);
1801: { UWORD val = data;
1802: ULONG cmask = 0x8000;
1803: int carry = val&cmask;
1804: val <<= 1;
1805: regs.v = regs.c = 0;
1806: regs.z = ((WORD)(val)) == 0;
1807: regs.n = ((WORD)(val)) < 0;
1808: regs.c = regs.x = carry!=0;
1809: put_word(dataa,val);
1810: }}}}}}
1811: void op_e3f8(UWORD opcode)
1812: {
1813: {{ CPTR dataa = (LONG)(WORD)nextiword();
1814: WORD data = get_word(dataa);
1815: { UWORD val = data;
1816: ULONG cmask = 0x8000;
1817: int carry = val&cmask;
1818: val <<= 1;
1819: regs.v = regs.c = 0;
1820: regs.z = ((WORD)(val)) == 0;
1821: regs.n = ((WORD)(val)) < 0;
1822: regs.c = regs.x = carry!=0;
1823: put_word(dataa,val);
1824: }}}}
1825: void op_e3f9(UWORD opcode)
1826: {
1827: {{ CPTR dataa = nextilong();
1828: WORD data = get_word(dataa);
1829: { UWORD val = data;
1830: ULONG cmask = 0x8000;
1831: int carry = val&cmask;
1832: val <<= 1;
1833: regs.v = regs.c = 0;
1834: regs.z = ((WORD)(val)) == 0;
1835: regs.n = ((WORD)(val)) < 0;
1836: regs.c = regs.x = carry!=0;
1837: put_word(dataa,val);
1838: }}}}
1839: void op_e400(UWORD opcode)
1840: {
1841: ULONG srcreg = 2;
1842: ULONG dstreg = (opcode & 7) >> 0;
1843: {{ ULONG cnt = srcreg;
1844: { BYTE data = regs.d[dstreg];
1845: { UBYTE val = data;
1846: cnt &= 63;
1847: regs.v = 0;
1848: { ULONG cmask = 0x80;
1849: ULONG sign = cmask & val;
1850: for(;cnt;--cnt){
1851: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
1852: }
1853: regs.n = sign != 0;
1854: regs.z = val == 0;
1855: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1856: }}}}}}
1857: void op_e408(UWORD opcode)
1858: {
1859: ULONG srcreg = 2;
1860: ULONG dstreg = (opcode & 7) >> 0;
1861: {{ ULONG cnt = srcreg;
1862: { BYTE data = regs.d[dstreg];
1863: { UBYTE val = data;
1864: cnt &= 63;
1865: { int carry = 0;
1866: for(;cnt;--cnt){
1867: carry=val&1; val >>= 1;
1868: }
1869: regs.v = regs.c = 0;
1870: regs.z = ((BYTE)(val)) == 0;
1871: regs.n = ((BYTE)(val)) < 0;
1872: regs.c = regs.x = carry!=0;
1873: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1874: }}}}}}
1875: void op_e410(UWORD opcode)
1876: {
1877: ULONG srcreg = 2;
1878: ULONG dstreg = (opcode & 7) >> 0;
1879: {{ ULONG cnt = srcreg;
1880: { BYTE data = regs.d[dstreg];
1881: { UBYTE val = data;
1882: cnt &= 63;
1883: { int carry = 0;
1884: ULONG cmask = 0x80;
1885: for(;cnt;--cnt){
1886: carry=val&1; val >>= 1;
1887: if(regs.x) val |= cmask;
1888: regs.x = carry != 0;
1889: }
1890: regs.v = regs.c = 0;
1891: regs.z = ((BYTE)(val)) == 0;
1892: regs.n = ((BYTE)(val)) < 0;
1893: regs.x = regs.c = carry!=0;
1894: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1895: }}}}}}
1896: void op_e418(UWORD opcode)
1897: {
1898: ULONG srcreg = 2;
1899: ULONG dstreg = (opcode & 7) >> 0;
1900: {{ ULONG cnt = srcreg;
1901: { BYTE data = regs.d[dstreg];
1902: { UBYTE val = data;
1903: cnt &= 63;
1904: { int carry = 0;
1905: ULONG cmask = 0x80;
1906: for(;cnt;--cnt){
1907: carry=val&1; val = (ULONG)val >> 1;
1908: if(carry) val |= cmask;
1909: }
1910: regs.v = regs.c = 0;
1911: regs.z = ((BYTE)(val)) == 0;
1912: regs.n = ((BYTE)(val)) < 0;
1913: regs.c = carry!=0;
1914: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
1915: }}}}}}
1916: void op_e440(UWORD opcode)
1917: {
1918: ULONG srcreg = 2;
1919: ULONG dstreg = (opcode & 7) >> 0;
1920: {{ ULONG cnt = srcreg;
1921: { WORD data = regs.d[dstreg];
1922: { UWORD val = data;
1923: cnt &= 63;
1924: regs.v = 0;
1925: { ULONG cmask = 0x8000;
1926: ULONG sign = cmask & val;
1927: for(;cnt;--cnt){
1928: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
1929: }
1930: regs.n = sign != 0;
1931: regs.z = val == 0;
1932: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1933: }}}}}}
1934: void op_e448(UWORD opcode)
1935: {
1936: ULONG srcreg = 2;
1937: ULONG dstreg = (opcode & 7) >> 0;
1938: {{ ULONG cnt = srcreg;
1939: { WORD data = regs.d[dstreg];
1940: { UWORD val = data;
1941: cnt &= 63;
1942: { int carry = 0;
1943: for(;cnt;--cnt){
1944: carry=val&1; val >>= 1;
1945: }
1946: regs.v = regs.c = 0;
1947: regs.z = ((WORD)(val)) == 0;
1948: regs.n = ((WORD)(val)) < 0;
1949: regs.c = regs.x = carry!=0;
1950: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1951: }}}}}}
1952: void op_e450(UWORD opcode)
1953: {
1954: ULONG srcreg = 2;
1955: ULONG dstreg = (opcode & 7) >> 0;
1956: {{ ULONG cnt = srcreg;
1957: { WORD data = regs.d[dstreg];
1958: { UWORD val = data;
1959: cnt &= 63;
1960: { int carry = 0;
1961: ULONG cmask = 0x8000;
1962: for(;cnt;--cnt){
1963: carry=val&1; val >>= 1;
1964: if(regs.x) val |= cmask;
1965: regs.x = carry != 0;
1966: }
1967: regs.v = regs.c = 0;
1968: regs.z = ((WORD)(val)) == 0;
1969: regs.n = ((WORD)(val)) < 0;
1970: regs.x = regs.c = carry!=0;
1971: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1972: }}}}}}
1973: void op_e458(UWORD opcode)
1974: {
1975: ULONG srcreg = 2;
1976: ULONG dstreg = (opcode & 7) >> 0;
1977: {{ ULONG cnt = srcreg;
1978: { WORD data = regs.d[dstreg];
1979: { UWORD val = data;
1980: cnt &= 63;
1981: { int carry = 0;
1982: ULONG cmask = 0x8000;
1983: for(;cnt;--cnt){
1984: carry=val&1; val = (ULONG)val >> 1;
1985: if(carry) val |= cmask;
1986: }
1987: regs.v = regs.c = 0;
1988: regs.z = ((WORD)(val)) == 0;
1989: regs.n = ((WORD)(val)) < 0;
1990: regs.c = carry!=0;
1991: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
1992: }}}}}}
1993: void op_e480(UWORD opcode)
1994: {
1995: ULONG srcreg = 2;
1996: ULONG dstreg = (opcode & 7) >> 0;
1997: {{ ULONG cnt = srcreg;
1998: { LONG data = regs.d[dstreg];
1999: { ULONG val = data;
2000: cnt &= 63;
2001: regs.v = 0;
2002: { ULONG cmask = 0x80000000;
2003: ULONG sign = cmask & val;
2004: for(;cnt;--cnt){
2005: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
2006: }
2007: regs.n = sign != 0;
2008: regs.z = val == 0;
2009: regs.d[dstreg] = (val);
2010: }}}}}}
2011: void op_e488(UWORD opcode)
2012: {
2013: ULONG srcreg = 2;
2014: ULONG dstreg = (opcode & 7) >> 0;
2015: {{ ULONG cnt = srcreg;
2016: { LONG data = regs.d[dstreg];
2017: { ULONG val = data;
2018: cnt &= 63;
2019: { int carry = 0;
2020: for(;cnt;--cnt){
2021: carry=val&1; val >>= 1;
2022: }
2023: regs.v = regs.c = 0;
2024: regs.z = ((LONG)(val)) == 0;
2025: regs.n = ((LONG)(val)) < 0;
2026: regs.c = regs.x = carry!=0;
2027: regs.d[dstreg] = (val);
2028: }}}}}}
2029: void op_e490(UWORD opcode)
2030: {
2031: ULONG srcreg = 2;
2032: ULONG dstreg = (opcode & 7) >> 0;
2033: {{ ULONG cnt = srcreg;
2034: { LONG data = regs.d[dstreg];
2035: { ULONG val = data;
2036: cnt &= 63;
2037: { int carry = 0;
2038: ULONG cmask = 0x80000000;
2039: for(;cnt;--cnt){
2040: carry=val&1; val >>= 1;
2041: if(regs.x) val |= cmask;
2042: regs.x = carry != 0;
2043: }
2044: regs.v = regs.c = 0;
2045: regs.z = ((LONG)(val)) == 0;
2046: regs.n = ((LONG)(val)) < 0;
2047: regs.x = regs.c = carry!=0;
2048: regs.d[dstreg] = (val);
2049: }}}}}}
2050: void op_e498(UWORD opcode)
2051: {
2052: ULONG srcreg = 2;
2053: ULONG dstreg = (opcode & 7) >> 0;
2054: {{ ULONG cnt = srcreg;
2055: { LONG data = regs.d[dstreg];
2056: { ULONG val = data;
2057: cnt &= 63;
2058: { int carry = 0;
2059: ULONG cmask = 0x80000000;
2060: for(;cnt;--cnt){
2061: carry=val&1; val = (ULONG)val >> 1;
2062: if(carry) val |= cmask;
2063: }
2064: regs.v = regs.c = 0;
2065: regs.z = ((LONG)(val)) == 0;
2066: regs.n = ((LONG)(val)) < 0;
2067: regs.c = carry!=0;
2068: regs.d[dstreg] = (val);
2069: }}}}}}
2070: void op_e4d0(UWORD opcode)
2071: {
2072: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2073: {{ CPTR dataa = regs.a[srcreg];
2074: WORD data = get_word(dataa);
2075: { UWORD val = data;
2076: int carry = val&1;
2077: ULONG cmask = 0x8000;
2078: val >>= 1;
2079: if(regs.x) val |= cmask;
2080: regs.x = carry != 0;
2081: regs.v = regs.c = 0;
2082: regs.z = ((WORD)(val)) == 0;
2083: regs.n = ((WORD)(val)) < 0;
2084: regs.x = regs.c = carry!=0;
2085: put_word(dataa,val);
2086: }}}}
2087: void op_e4d8(UWORD opcode)
2088: {
2089: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2090: {{ CPTR dataa = regs.a[srcreg];
2091: WORD data = get_word(dataa);
2092: { regs.a[srcreg] += 2;
2093: { UWORD val = data;
2094: int carry = val&1;
2095: ULONG cmask = 0x8000;
2096: val >>= 1;
2097: if(regs.x) val |= cmask;
2098: regs.x = carry != 0;
2099: regs.v = regs.c = 0;
2100: regs.z = ((WORD)(val)) == 0;
2101: regs.n = ((WORD)(val)) < 0;
2102: regs.x = regs.c = carry!=0;
2103: put_word(dataa,val);
2104: }}}}}
2105: void op_e4e0(UWORD opcode)
2106: {
2107: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2108: {{ regs.a[srcreg] -= 2;
2109: { CPTR dataa = regs.a[srcreg];
2110: WORD data = get_word(dataa);
2111: { UWORD val = data;
2112: int carry = val&1;
2113: ULONG cmask = 0x8000;
2114: val >>= 1;
2115: if(regs.x) val |= cmask;
2116: regs.x = carry != 0;
2117: regs.v = regs.c = 0;
2118: regs.z = ((WORD)(val)) == 0;
2119: regs.n = ((WORD)(val)) < 0;
2120: regs.x = regs.c = carry!=0;
2121: put_word(dataa,val);
2122: }}}}}
2123: void op_e4e8(UWORD opcode)
2124: {
2125: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2126: {{ CPTR dataa = regs.a[srcreg] + (LONG)(WORD)nextiword();
2127: WORD data = get_word(dataa);
2128: { UWORD val = data;
2129: int carry = val&1;
2130: ULONG cmask = 0x8000;
2131: val >>= 1;
2132: if(regs.x) val |= cmask;
2133: regs.x = carry != 0;
2134: regs.v = regs.c = 0;
2135: regs.z = ((WORD)(val)) == 0;
2136: regs.n = ((WORD)(val)) < 0;
2137: regs.x = regs.c = carry!=0;
2138: put_word(dataa,val);
2139: }}}}
2140: void op_e4f0(UWORD opcode)
2141: {
2142: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2143: {{ CPTR dataa = regs.a[srcreg];
2144: UWORD datadp = nextiword();
2145: dataa += (LONG)(BYTE)(datadp & 0xFF);
2146: { ULONG datadpr = datadp & 0x8000 ? regs.a[(datadp & 0x7000) >> 12] : regs.d[(datadp & 0x7000) >> 12];
2147: if (!(datadp & 0x800)) datadpr = (LONG)(WORD)datadpr;
2148: dataa += datadpr;
2149: { WORD data = get_word(dataa);
2150: { UWORD val = data;
2151: int carry = val&1;
2152: ULONG cmask = 0x8000;
2153: val >>= 1;
2154: if(regs.x) val |= cmask;
2155: regs.x = carry != 0;
2156: regs.v = regs.c = 0;
2157: regs.z = ((WORD)(val)) == 0;
2158: regs.n = ((WORD)(val)) < 0;
2159: regs.x = regs.c = carry!=0;
2160: put_word(dataa,val);
2161: }}}}}}
2162: void op_e4f8(UWORD opcode)
2163: {
2164: {{ CPTR dataa = (LONG)(WORD)nextiword();
2165: WORD data = get_word(dataa);
2166: { UWORD val = data;
2167: int carry = val&1;
2168: ULONG cmask = 0x8000;
2169: val >>= 1;
2170: if(regs.x) val |= cmask;
2171: regs.x = carry != 0;
2172: regs.v = regs.c = 0;
2173: regs.z = ((WORD)(val)) == 0;
2174: regs.n = ((WORD)(val)) < 0;
2175: regs.x = regs.c = carry!=0;
2176: put_word(dataa,val);
2177: }}}}
2178: void op_e4f9(UWORD opcode)
2179: {
2180: {{ CPTR dataa = nextilong();
2181: WORD data = get_word(dataa);
2182: { UWORD val = data;
2183: int carry = val&1;
2184: ULONG cmask = 0x8000;
2185: val >>= 1;
2186: if(regs.x) val |= cmask;
2187: regs.x = carry != 0;
2188: regs.v = regs.c = 0;
2189: regs.z = ((WORD)(val)) == 0;
2190: regs.n = ((WORD)(val)) < 0;
2191: regs.x = regs.c = carry!=0;
2192: put_word(dataa,val);
2193: }}}}
2194: void op_e500(UWORD opcode)
2195: {
2196: ULONG srcreg = 2;
2197: ULONG dstreg = (opcode & 7) >> 0;
2198: {{ ULONG cnt = srcreg;
2199: { BYTE data = regs.d[dstreg];
2200: { UBYTE val = data;
2201: cnt &= 63;
2202: regs.v = 0;
2203: { ULONG cmask = 0x80;
2204: ULONG sign = cmask & val;
2205: for(;cnt;--cnt){
2206: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
2207: if ((val&cmask)!=sign)regs.v=1;
2208: }
2209: regs.n = (val&cmask) != 0;
2210: regs.z = val == 0;
2211: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2212: }}}}}}
2213: void op_e508(UWORD opcode)
2214: {
2215: ULONG srcreg = 2;
2216: ULONG dstreg = (opcode & 7) >> 0;
2217: {{ ULONG cnt = srcreg;
2218: { BYTE data = regs.d[dstreg];
2219: { UBYTE val = data;
2220: cnt &= 63;
2221: { int carry = 0;
2222: ULONG cmask = 0x80;
2223: for(;cnt;--cnt){
2224: carry=val&cmask; val <<= 1;
2225: }
2226: regs.v = regs.c = 0;
2227: regs.z = ((BYTE)(val)) == 0;
2228: regs.n = ((BYTE)(val)) < 0;
2229: regs.c = regs.x = carry!=0;
2230: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2231: }}}}}}
2232: void op_e510(UWORD opcode)
2233: {
2234: ULONG srcreg = 2;
2235: ULONG dstreg = (opcode & 7) >> 0;
2236: {{ ULONG cnt = srcreg;
2237: { BYTE data = regs.d[dstreg];
2238: { UBYTE val = data;
2239: cnt &= 63;
2240: { int carry = 0;
2241: ULONG cmask = 0x80;
2242: for(;cnt;--cnt){
2243: carry=val&cmask; val <<= 1;
2244: if(regs.x) val |= 1;
2245: regs.x = carry != 0;
2246: }
2247: regs.v = regs.c = 0;
2248: regs.z = ((BYTE)(val)) == 0;
2249: regs.n = ((BYTE)(val)) < 0;
2250: regs.x = regs.c = carry!=0;
2251: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2252: }}}}}}
2253: void op_e518(UWORD opcode)
2254: {
2255: ULONG srcreg = 2;
2256: ULONG dstreg = (opcode & 7) >> 0;
2257: {{ ULONG cnt = srcreg;
2258: { BYTE data = regs.d[dstreg];
2259: { UBYTE val = data;
2260: cnt &= 63;
2261: { int carry = 0;
2262: ULONG cmask = 0x80;
2263: for(;cnt;--cnt){
2264: carry=val&cmask; val <<= 1;
2265: if(carry) val |= 1;
2266: }
2267: regs.v = regs.c = 0;
2268: regs.z = ((BYTE)(val)) == 0;
2269: regs.n = ((BYTE)(val)) < 0;
2270: regs.c = carry!=0;
2271: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2272: }}}}}}
2273: void op_e540(UWORD opcode)
2274: {
2275: ULONG srcreg = 2;
2276: ULONG dstreg = (opcode & 7) >> 0;
2277: {{ ULONG cnt = srcreg;
2278: { WORD data = regs.d[dstreg];
2279: { UWORD val = data;
2280: cnt &= 63;
2281: regs.v = 0;
2282: { ULONG cmask = 0x8000;
2283: ULONG sign = cmask & val;
2284: for(;cnt;--cnt){
2285: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
2286: if ((val&cmask)!=sign)regs.v=1;
2287: }
2288: regs.n = (val&cmask) != 0;
2289: regs.z = val == 0;
2290: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
2291: }}}}}}
2292: void op_e548(UWORD opcode)
2293: {
2294: ULONG srcreg = 2;
2295: ULONG dstreg = (opcode & 7) >> 0;
2296: {{ ULONG cnt = srcreg;
2297: { WORD data = regs.d[dstreg];
2298: { UWORD val = data;
2299: cnt &= 63;
2300: { int carry = 0;
2301: ULONG cmask = 0x8000;
2302: for(;cnt;--cnt){
2303: carry=val&cmask; val <<= 1;
2304: }
2305: regs.v = regs.c = 0;
2306: regs.z = ((WORD)(val)) == 0;
2307: regs.n = ((WORD)(val)) < 0;
2308: regs.c = regs.x = carry!=0;
2309: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
2310: }}}}}}
2311: void op_e550(UWORD opcode)
2312: {
2313: ULONG srcreg = 2;
2314: ULONG dstreg = (opcode & 7) >> 0;
2315: {{ ULONG cnt = srcreg;
2316: { WORD data = regs.d[dstreg];
2317: { UWORD val = data;
2318: cnt &= 63;
2319: { int carry = 0;
2320: ULONG cmask = 0x8000;
2321: for(;cnt;--cnt){
2322: carry=val&cmask; val <<= 1;
2323: if(regs.x) val |= 1;
2324: regs.x = carry != 0;
2325: }
2326: regs.v = regs.c = 0;
2327: regs.z = ((WORD)(val)) == 0;
2328: regs.n = ((WORD)(val)) < 0;
2329: regs.x = regs.c = carry!=0;
2330: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
2331: }}}}}}
2332: void op_e558(UWORD opcode)
2333: {
2334: ULONG srcreg = 2;
2335: ULONG dstreg = (opcode & 7) >> 0;
2336: {{ ULONG cnt = srcreg;
2337: { WORD data = regs.d[dstreg];
2338: { UWORD val = data;
2339: cnt &= 63;
2340: { int carry = 0;
2341: ULONG cmask = 0x8000;
2342: for(;cnt;--cnt){
2343: carry=val&cmask; val <<= 1;
2344: if(carry) val |= 1;
2345: }
2346: regs.v = regs.c = 0;
2347: regs.z = ((WORD)(val)) == 0;
2348: regs.n = ((WORD)(val)) < 0;
2349: regs.c = carry!=0;
2350: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
2351: }}}}}}
2352: void op_e580(UWORD opcode)
2353: {
2354: ULONG srcreg = 2;
2355: ULONG dstreg = (opcode & 7) >> 0;
2356: {{ ULONG cnt = srcreg;
2357: { LONG data = regs.d[dstreg];
2358: { ULONG val = data;
2359: cnt &= 63;
2360: regs.v = 0;
2361: { ULONG cmask = 0x80000000;
2362: ULONG sign = cmask & val;
2363: for(;cnt;--cnt){
2364: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
2365: if ((val&cmask)!=sign)regs.v=1;
2366: }
2367: regs.n = (val&cmask) != 0;
2368: regs.z = val == 0;
2369: regs.d[dstreg] = (val);
2370: }}}}}}
2371: void op_e588(UWORD opcode)
2372: {
2373: ULONG srcreg = 2;
2374: ULONG dstreg = (opcode & 7) >> 0;
2375: {{ ULONG cnt = srcreg;
2376: { LONG data = regs.d[dstreg];
2377: { ULONG val = data;
2378: cnt &= 63;
2379: { int carry = 0;
2380: ULONG cmask = 0x80000000;
2381: for(;cnt;--cnt){
2382: carry=val&cmask; val <<= 1;
2383: }
2384: regs.v = regs.c = 0;
2385: regs.z = ((LONG)(val)) == 0;
2386: regs.n = ((LONG)(val)) < 0;
2387: regs.c = regs.x = carry!=0;
2388: regs.d[dstreg] = (val);
2389: }}}}}}
2390: void op_e590(UWORD opcode)
2391: {
2392: ULONG srcreg = 2;
2393: ULONG dstreg = (opcode & 7) >> 0;
2394: {{ ULONG cnt = srcreg;
2395: { LONG data = regs.d[dstreg];
2396: { ULONG val = data;
2397: cnt &= 63;
2398: { int carry = 0;
2399: ULONG cmask = 0x80000000;
2400: for(;cnt;--cnt){
2401: carry=val&cmask; val <<= 1;
2402: if(regs.x) val |= 1;
2403: regs.x = carry != 0;
2404: }
2405: regs.v = regs.c = 0;
2406: regs.z = ((LONG)(val)) == 0;
2407: regs.n = ((LONG)(val)) < 0;
2408: regs.x = regs.c = carry!=0;
2409: regs.d[dstreg] = (val);
2410: }}}}}}
2411: void op_e598(UWORD opcode)
2412: {
2413: ULONG srcreg = 2;
2414: ULONG dstreg = (opcode & 7) >> 0;
2415: {{ ULONG cnt = srcreg;
2416: { LONG data = regs.d[dstreg];
2417: { ULONG val = data;
2418: cnt &= 63;
2419: { int carry = 0;
2420: ULONG cmask = 0x80000000;
2421: for(;cnt;--cnt){
2422: carry=val&cmask; val <<= 1;
2423: if(carry) val |= 1;
2424: }
2425: regs.v = regs.c = 0;
2426: regs.z = ((LONG)(val)) == 0;
2427: regs.n = ((LONG)(val)) < 0;
2428: regs.c = carry!=0;
2429: regs.d[dstreg] = (val);
2430: }}}}}}
2431: void op_e5d0(UWORD opcode)
2432: {
2433: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2434: {{ CPTR dataa = regs.a[srcreg];
2435: WORD data = get_word(dataa);
2436: { UWORD val = data;
2437: ULONG cmask = 0x8000;
2438: int carry = val&cmask;
2439: val <<= 1;
2440: if(regs.x) val |= 1;
2441: regs.x = carry != 0;
2442: regs.v = regs.c = 0;
2443: regs.z = ((WORD)(val)) == 0;
2444: regs.n = ((WORD)(val)) < 0;
2445: regs.x = regs.c = carry!=0;
2446: put_word(dataa,val);
2447: }}}}
2448: void op_e5d8(UWORD opcode)
2449: {
2450: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2451: {{ CPTR dataa = regs.a[srcreg];
2452: WORD data = get_word(dataa);
2453: { regs.a[srcreg] += 2;
2454: { UWORD val = data;
2455: ULONG cmask = 0x8000;
2456: int carry = val&cmask;
2457: val <<= 1;
2458: if(regs.x) val |= 1;
2459: regs.x = carry != 0;
2460: regs.v = regs.c = 0;
2461: regs.z = ((WORD)(val)) == 0;
2462: regs.n = ((WORD)(val)) < 0;
2463: regs.x = regs.c = carry!=0;
2464: put_word(dataa,val);
2465: }}}}}
2466: void op_e5e0(UWORD opcode)
2467: {
2468: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2469: {{ regs.a[srcreg] -= 2;
2470: { CPTR dataa = regs.a[srcreg];
2471: WORD data = get_word(dataa);
2472: { UWORD val = data;
2473: ULONG cmask = 0x8000;
2474: int carry = val&cmask;
2475: val <<= 1;
2476: if(regs.x) val |= 1;
2477: regs.x = carry != 0;
2478: regs.v = regs.c = 0;
2479: regs.z = ((WORD)(val)) == 0;
2480: regs.n = ((WORD)(val)) < 0;
2481: regs.x = regs.c = carry!=0;
2482: put_word(dataa,val);
2483: }}}}}
2484: void op_e5e8(UWORD opcode)
2485: {
2486: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2487: {{ CPTR dataa = regs.a[srcreg] + (LONG)(WORD)nextiword();
2488: WORD data = get_word(dataa);
2489: { UWORD val = data;
2490: ULONG cmask = 0x8000;
2491: int carry = val&cmask;
2492: val <<= 1;
2493: if(regs.x) val |= 1;
2494: regs.x = carry != 0;
2495: regs.v = regs.c = 0;
2496: regs.z = ((WORD)(val)) == 0;
2497: regs.n = ((WORD)(val)) < 0;
2498: regs.x = regs.c = carry!=0;
2499: put_word(dataa,val);
2500: }}}}
2501: void op_e5f0(UWORD opcode)
2502: {
2503: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2504: {{ CPTR dataa = regs.a[srcreg];
2505: UWORD datadp = nextiword();
2506: dataa += (LONG)(BYTE)(datadp & 0xFF);
2507: { ULONG datadpr = datadp & 0x8000 ? regs.a[(datadp & 0x7000) >> 12] : regs.d[(datadp & 0x7000) >> 12];
2508: if (!(datadp & 0x800)) datadpr = (LONG)(WORD)datadpr;
2509: dataa += datadpr;
2510: { WORD data = get_word(dataa);
2511: { UWORD val = data;
2512: ULONG cmask = 0x8000;
2513: int carry = val&cmask;
2514: val <<= 1;
2515: if(regs.x) val |= 1;
2516: regs.x = carry != 0;
2517: regs.v = regs.c = 0;
2518: regs.z = ((WORD)(val)) == 0;
2519: regs.n = ((WORD)(val)) < 0;
2520: regs.x = regs.c = carry!=0;
2521: put_word(dataa,val);
2522: }}}}}}
2523: void op_e5f8(UWORD opcode)
2524: {
2525: {{ CPTR dataa = (LONG)(WORD)nextiword();
2526: WORD data = get_word(dataa);
2527: { UWORD val = data;
2528: ULONG cmask = 0x8000;
2529: int carry = val&cmask;
2530: val <<= 1;
2531: if(regs.x) val |= 1;
2532: regs.x = carry != 0;
2533: regs.v = regs.c = 0;
2534: regs.z = ((WORD)(val)) == 0;
2535: regs.n = ((WORD)(val)) < 0;
2536: regs.x = regs.c = carry!=0;
2537: put_word(dataa,val);
2538: }}}}
2539: void op_e5f9(UWORD opcode)
2540: {
2541: {{ CPTR dataa = nextilong();
2542: WORD data = get_word(dataa);
2543: { UWORD val = data;
2544: ULONG cmask = 0x8000;
2545: int carry = val&cmask;
2546: val <<= 1;
2547: if(regs.x) val |= 1;
2548: regs.x = carry != 0;
2549: regs.v = regs.c = 0;
2550: regs.z = ((WORD)(val)) == 0;
2551: regs.n = ((WORD)(val)) < 0;
2552: regs.x = regs.c = carry!=0;
2553: put_word(dataa,val);
2554: }}}}
2555: void op_e600(UWORD opcode)
2556: {
2557: ULONG srcreg = 3;
2558: ULONG dstreg = (opcode & 7) >> 0;
2559: {{ ULONG cnt = srcreg;
2560: { BYTE data = regs.d[dstreg];
2561: { UBYTE val = data;
2562: cnt &= 63;
2563: regs.v = 0;
2564: { ULONG cmask = 0x80;
2565: ULONG sign = cmask & val;
2566: for(;cnt;--cnt){
2567: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
2568: }
2569: regs.n = sign != 0;
2570: regs.z = val == 0;
2571: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2572: }}}}}}
2573: void op_e608(UWORD opcode)
2574: {
2575: ULONG srcreg = 3;
2576: ULONG dstreg = (opcode & 7) >> 0;
2577: {{ ULONG cnt = srcreg;
2578: { BYTE data = regs.d[dstreg];
2579: { UBYTE val = data;
2580: cnt &= 63;
2581: { int carry = 0;
2582: for(;cnt;--cnt){
2583: carry=val&1; val >>= 1;
2584: }
2585: regs.v = regs.c = 0;
2586: regs.z = ((BYTE)(val)) == 0;
2587: regs.n = ((BYTE)(val)) < 0;
2588: regs.c = regs.x = carry!=0;
2589: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2590: }}}}}}
2591: void op_e610(UWORD opcode)
2592: {
2593: ULONG srcreg = 3;
2594: ULONG dstreg = (opcode & 7) >> 0;
2595: {{ ULONG cnt = srcreg;
2596: { BYTE data = regs.d[dstreg];
2597: { UBYTE val = data;
2598: cnt &= 63;
2599: { int carry = 0;
2600: ULONG cmask = 0x80;
2601: for(;cnt;--cnt){
2602: carry=val&1; val >>= 1;
2603: if(regs.x) val |= cmask;
2604: regs.x = carry != 0;
2605: }
2606: regs.v = regs.c = 0;
2607: regs.z = ((BYTE)(val)) == 0;
2608: regs.n = ((BYTE)(val)) < 0;
2609: regs.x = regs.c = carry!=0;
2610: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2611: }}}}}}
2612: void op_e618(UWORD opcode)
2613: {
2614: ULONG srcreg = 3;
2615: ULONG dstreg = (opcode & 7) >> 0;
2616: {{ ULONG cnt = srcreg;
2617: { BYTE data = regs.d[dstreg];
2618: { UBYTE val = data;
2619: cnt &= 63;
2620: { int carry = 0;
2621: ULONG cmask = 0x80;
2622: for(;cnt;--cnt){
2623: carry=val&1; val = (ULONG)val >> 1;
2624: if(carry) val |= cmask;
2625: }
2626: regs.v = regs.c = 0;
2627: regs.z = ((BYTE)(val)) == 0;
2628: regs.n = ((BYTE)(val)) < 0;
2629: regs.c = carry!=0;
2630: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2631: }}}}}}
2632: void op_e640(UWORD opcode)
2633: {
2634: ULONG srcreg = 3;
2635: ULONG dstreg = (opcode & 7) >> 0;
2636: {{ ULONG cnt = srcreg;
2637: { WORD data = regs.d[dstreg];
2638: { UWORD val = data;
2639: cnt &= 63;
2640: regs.v = 0;
2641: { ULONG cmask = 0x8000;
2642: ULONG sign = cmask & val;
2643: for(;cnt;--cnt){
2644: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
2645: }
2646: regs.n = sign != 0;
2647: regs.z = val == 0;
2648: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
2649: }}}}}}
2650: void op_e648(UWORD opcode)
2651: {
2652: ULONG srcreg = 3;
2653: ULONG dstreg = (opcode & 7) >> 0;
2654: {{ ULONG cnt = srcreg;
2655: { WORD data = regs.d[dstreg];
2656: { UWORD val = data;
2657: cnt &= 63;
2658: { int carry = 0;
2659: for(;cnt;--cnt){
2660: carry=val&1; val >>= 1;
2661: }
2662: regs.v = regs.c = 0;
2663: regs.z = ((WORD)(val)) == 0;
2664: regs.n = ((WORD)(val)) < 0;
2665: regs.c = regs.x = carry!=0;
2666: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
2667: }}}}}}
2668: void op_e650(UWORD opcode)
2669: {
2670: ULONG srcreg = 3;
2671: ULONG dstreg = (opcode & 7) >> 0;
2672: {{ ULONG cnt = srcreg;
2673: { WORD data = regs.d[dstreg];
2674: { UWORD val = data;
2675: cnt &= 63;
2676: { int carry = 0;
2677: ULONG cmask = 0x8000;
2678: for(;cnt;--cnt){
2679: carry=val&1; val >>= 1;
2680: if(regs.x) val |= cmask;
2681: regs.x = carry != 0;
2682: }
2683: regs.v = regs.c = 0;
2684: regs.z = ((WORD)(val)) == 0;
2685: regs.n = ((WORD)(val)) < 0;
2686: regs.x = regs.c = carry!=0;
2687: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
2688: }}}}}}
2689: void op_e658(UWORD opcode)
2690: {
2691: ULONG srcreg = 3;
2692: ULONG dstreg = (opcode & 7) >> 0;
2693: {{ ULONG cnt = srcreg;
2694: { WORD data = regs.d[dstreg];
2695: { UWORD val = data;
2696: cnt &= 63;
2697: { int carry = 0;
2698: ULONG cmask = 0x8000;
2699: for(;cnt;--cnt){
2700: carry=val&1; val = (ULONG)val >> 1;
2701: if(carry) val |= cmask;
2702: }
2703: regs.v = regs.c = 0;
2704: regs.z = ((WORD)(val)) == 0;
2705: regs.n = ((WORD)(val)) < 0;
2706: regs.c = carry!=0;
2707: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
2708: }}}}}}
2709: void op_e680(UWORD opcode)
2710: {
2711: ULONG srcreg = 3;
2712: ULONG dstreg = (opcode & 7) >> 0;
2713: {{ ULONG cnt = srcreg;
2714: { LONG data = regs.d[dstreg];
2715: { ULONG val = data;
2716: cnt &= 63;
2717: regs.v = 0;
2718: { ULONG cmask = 0x80000000;
2719: ULONG sign = cmask & val;
2720: for(;cnt;--cnt){
2721: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
2722: }
2723: regs.n = sign != 0;
2724: regs.z = val == 0;
2725: regs.d[dstreg] = (val);
2726: }}}}}}
2727: void op_e688(UWORD opcode)
2728: {
2729: ULONG srcreg = 3;
2730: ULONG dstreg = (opcode & 7) >> 0;
2731: {{ ULONG cnt = srcreg;
2732: { LONG data = regs.d[dstreg];
2733: { ULONG val = data;
2734: cnt &= 63;
2735: { int carry = 0;
2736: for(;cnt;--cnt){
2737: carry=val&1; val >>= 1;
2738: }
2739: regs.v = regs.c = 0;
2740: regs.z = ((LONG)(val)) == 0;
2741: regs.n = ((LONG)(val)) < 0;
2742: regs.c = regs.x = carry!=0;
2743: regs.d[dstreg] = (val);
2744: }}}}}}
2745: void op_e690(UWORD opcode)
2746: {
2747: ULONG srcreg = 3;
2748: ULONG dstreg = (opcode & 7) >> 0;
2749: {{ ULONG cnt = srcreg;
2750: { LONG data = regs.d[dstreg];
2751: { ULONG val = data;
2752: cnt &= 63;
2753: { int carry = 0;
2754: ULONG cmask = 0x80000000;
2755: for(;cnt;--cnt){
2756: carry=val&1; val >>= 1;
2757: if(regs.x) val |= cmask;
2758: regs.x = carry != 0;
2759: }
2760: regs.v = regs.c = 0;
2761: regs.z = ((LONG)(val)) == 0;
2762: regs.n = ((LONG)(val)) < 0;
2763: regs.x = regs.c = carry!=0;
2764: regs.d[dstreg] = (val);
2765: }}}}}}
2766: void op_e698(UWORD opcode)
2767: {
2768: ULONG srcreg = 3;
2769: ULONG dstreg = (opcode & 7) >> 0;
2770: {{ ULONG cnt = srcreg;
2771: { LONG data = regs.d[dstreg];
2772: { ULONG val = data;
2773: cnt &= 63;
2774: { int carry = 0;
2775: ULONG cmask = 0x80000000;
2776: for(;cnt;--cnt){
2777: carry=val&1; val = (ULONG)val >> 1;
2778: if(carry) val |= cmask;
2779: }
2780: regs.v = regs.c = 0;
2781: regs.z = ((LONG)(val)) == 0;
2782: regs.n = ((LONG)(val)) < 0;
2783: regs.c = carry!=0;
2784: regs.d[dstreg] = (val);
2785: }}}}}}
2786: void op_e6d0(UWORD opcode)
2787: {
2788: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2789: {{ CPTR dataa = regs.a[srcreg];
2790: WORD data = get_word(dataa);
2791: { UWORD val = data;
2792: int carry = val&1;
2793: ULONG cmask = 0x8000;
2794: val >>= 1;
2795: if(carry) val |= cmask;
2796: regs.v = regs.c = 0;
2797: regs.z = ((WORD)(val)) == 0;
2798: regs.n = ((WORD)(val)) < 0;
2799: regs.c = carry!=0;
2800: put_word(dataa,val);
2801: }}}}
2802: void op_e6d8(UWORD opcode)
2803: {
2804: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2805: {{ CPTR dataa = regs.a[srcreg];
2806: WORD data = get_word(dataa);
2807: { regs.a[srcreg] += 2;
2808: { UWORD val = data;
2809: int carry = val&1;
2810: ULONG cmask = 0x8000;
2811: val >>= 1;
2812: if(carry) val |= cmask;
2813: regs.v = regs.c = 0;
2814: regs.z = ((WORD)(val)) == 0;
2815: regs.n = ((WORD)(val)) < 0;
2816: regs.c = carry!=0;
2817: put_word(dataa,val);
2818: }}}}}
2819: void op_e6e0(UWORD opcode)
2820: {
2821: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2822: {{ regs.a[srcreg] -= 2;
2823: { CPTR dataa = regs.a[srcreg];
2824: WORD data = get_word(dataa);
2825: { UWORD val = data;
2826: int carry = val&1;
2827: ULONG cmask = 0x8000;
2828: val >>= 1;
2829: if(carry) val |= cmask;
2830: regs.v = regs.c = 0;
2831: regs.z = ((WORD)(val)) == 0;
2832: regs.n = ((WORD)(val)) < 0;
2833: regs.c = carry!=0;
2834: put_word(dataa,val);
2835: }}}}}
2836: void op_e6e8(UWORD opcode)
2837: {
2838: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2839: {{ CPTR dataa = regs.a[srcreg] + (LONG)(WORD)nextiword();
2840: WORD data = get_word(dataa);
2841: { UWORD val = data;
2842: int carry = val&1;
2843: ULONG cmask = 0x8000;
2844: val >>= 1;
2845: if(carry) val |= cmask;
2846: regs.v = regs.c = 0;
2847: regs.z = ((WORD)(val)) == 0;
2848: regs.n = ((WORD)(val)) < 0;
2849: regs.c = carry!=0;
2850: put_word(dataa,val);
2851: }}}}
2852: void op_e6f0(UWORD opcode)
2853: {
2854: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2855: {{ CPTR dataa = regs.a[srcreg];
2856: UWORD datadp = nextiword();
2857: dataa += (LONG)(BYTE)(datadp & 0xFF);
2858: { ULONG datadpr = datadp & 0x8000 ? regs.a[(datadp & 0x7000) >> 12] : regs.d[(datadp & 0x7000) >> 12];
2859: if (!(datadp & 0x800)) datadpr = (LONG)(WORD)datadpr;
2860: dataa += datadpr;
2861: { WORD data = get_word(dataa);
2862: { UWORD val = data;
2863: int carry = val&1;
2864: ULONG cmask = 0x8000;
2865: val >>= 1;
2866: if(carry) val |= cmask;
2867: regs.v = regs.c = 0;
2868: regs.z = ((WORD)(val)) == 0;
2869: regs.n = ((WORD)(val)) < 0;
2870: regs.c = carry!=0;
2871: put_word(dataa,val);
2872: }}}}}}
2873: void op_e6f8(UWORD opcode)
2874: {
2875: {{ CPTR dataa = (LONG)(WORD)nextiword();
2876: WORD data = get_word(dataa);
2877: { UWORD val = data;
2878: int carry = val&1;
2879: ULONG cmask = 0x8000;
2880: val >>= 1;
2881: if(carry) val |= cmask;
2882: regs.v = regs.c = 0;
2883: regs.z = ((WORD)(val)) == 0;
2884: regs.n = ((WORD)(val)) < 0;
2885: regs.c = carry!=0;
2886: put_word(dataa,val);
2887: }}}}
2888: void op_e6f9(UWORD opcode)
2889: {
2890: {{ CPTR dataa = nextilong();
2891: WORD data = get_word(dataa);
2892: { UWORD val = data;
2893: int carry = val&1;
2894: ULONG cmask = 0x8000;
2895: val >>= 1;
2896: if(carry) val |= cmask;
2897: regs.v = regs.c = 0;
2898: regs.z = ((WORD)(val)) == 0;
2899: regs.n = ((WORD)(val)) < 0;
2900: regs.c = carry!=0;
2901: put_word(dataa,val);
2902: }}}}
2903: void op_e700(UWORD opcode)
2904: {
2905: ULONG srcreg = 3;
2906: ULONG dstreg = (opcode & 7) >> 0;
2907: {{ ULONG cnt = srcreg;
2908: { BYTE data = regs.d[dstreg];
2909: { UBYTE val = data;
2910: cnt &= 63;
2911: regs.v = 0;
2912: { ULONG cmask = 0x80;
2913: ULONG sign = cmask & val;
2914: for(;cnt;--cnt){
2915: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
2916: if ((val&cmask)!=sign)regs.v=1;
2917: }
2918: regs.n = (val&cmask) != 0;
2919: regs.z = val == 0;
2920: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2921: }}}}}}
2922: void op_e708(UWORD opcode)
2923: {
2924: ULONG srcreg = 3;
2925: ULONG dstreg = (opcode & 7) >> 0;
2926: {{ ULONG cnt = srcreg;
2927: { BYTE data = regs.d[dstreg];
2928: { UBYTE val = data;
2929: cnt &= 63;
2930: { int carry = 0;
2931: ULONG cmask = 0x80;
2932: for(;cnt;--cnt){
2933: carry=val&cmask; val <<= 1;
2934: }
2935: regs.v = regs.c = 0;
2936: regs.z = ((BYTE)(val)) == 0;
2937: regs.n = ((BYTE)(val)) < 0;
2938: regs.c = regs.x = carry!=0;
2939: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2940: }}}}}}
2941: void op_e710(UWORD opcode)
2942: {
2943: ULONG srcreg = 3;
2944: ULONG dstreg = (opcode & 7) >> 0;
2945: {{ ULONG cnt = srcreg;
2946: { BYTE data = regs.d[dstreg];
2947: { UBYTE val = data;
2948: cnt &= 63;
2949: { int carry = 0;
2950: ULONG cmask = 0x80;
2951: for(;cnt;--cnt){
2952: carry=val&cmask; val <<= 1;
2953: if(regs.x) val |= 1;
2954: regs.x = carry != 0;
2955: }
2956: regs.v = regs.c = 0;
2957: regs.z = ((BYTE)(val)) == 0;
2958: regs.n = ((BYTE)(val)) < 0;
2959: regs.x = regs.c = carry!=0;
2960: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2961: }}}}}}
2962: void op_e718(UWORD opcode)
2963: {
2964: ULONG srcreg = 3;
2965: ULONG dstreg = (opcode & 7) >> 0;
2966: {{ ULONG cnt = srcreg;
2967: { BYTE data = regs.d[dstreg];
2968: { UBYTE val = data;
2969: cnt &= 63;
2970: { int carry = 0;
2971: ULONG cmask = 0x80;
2972: for(;cnt;--cnt){
2973: carry=val&cmask; val <<= 1;
2974: if(carry) val |= 1;
2975: }
2976: regs.v = regs.c = 0;
2977: regs.z = ((BYTE)(val)) == 0;
2978: regs.n = ((BYTE)(val)) < 0;
2979: regs.c = carry!=0;
2980: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
2981: }}}}}}
2982: void op_e740(UWORD opcode)
2983: {
2984: ULONG srcreg = 3;
2985: ULONG dstreg = (opcode & 7) >> 0;
2986: {{ ULONG cnt = srcreg;
2987: { WORD data = regs.d[dstreg];
2988: { UWORD val = data;
2989: cnt &= 63;
2990: regs.v = 0;
2991: { ULONG cmask = 0x8000;
2992: ULONG sign = cmask & val;
2993: for(;cnt;--cnt){
2994: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
2995: if ((val&cmask)!=sign)regs.v=1;
2996: }
2997: regs.n = (val&cmask) != 0;
2998: regs.z = val == 0;
2999: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3000: }}}}}}
3001: void op_e748(UWORD opcode)
3002: {
3003: ULONG srcreg = 3;
3004: ULONG dstreg = (opcode & 7) >> 0;
3005: {{ ULONG cnt = srcreg;
3006: { WORD data = regs.d[dstreg];
3007: { UWORD val = data;
3008: cnt &= 63;
3009: { int carry = 0;
3010: ULONG cmask = 0x8000;
3011: for(;cnt;--cnt){
3012: carry=val&cmask; val <<= 1;
3013: }
3014: regs.v = regs.c = 0;
3015: regs.z = ((WORD)(val)) == 0;
3016: regs.n = ((WORD)(val)) < 0;
3017: regs.c = regs.x = carry!=0;
3018: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3019: }}}}}}
3020: void op_e750(UWORD opcode)
3021: {
3022: ULONG srcreg = 3;
3023: ULONG dstreg = (opcode & 7) >> 0;
3024: {{ ULONG cnt = srcreg;
3025: { WORD data = regs.d[dstreg];
3026: { UWORD val = data;
3027: cnt &= 63;
3028: { int carry = 0;
3029: ULONG cmask = 0x8000;
3030: for(;cnt;--cnt){
3031: carry=val&cmask; val <<= 1;
3032: if(regs.x) val |= 1;
3033: regs.x = carry != 0;
3034: }
3035: regs.v = regs.c = 0;
3036: regs.z = ((WORD)(val)) == 0;
3037: regs.n = ((WORD)(val)) < 0;
3038: regs.x = regs.c = carry!=0;
3039: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3040: }}}}}}
3041: void op_e758(UWORD opcode)
3042: {
3043: ULONG srcreg = 3;
3044: ULONG dstreg = (opcode & 7) >> 0;
3045: {{ ULONG cnt = srcreg;
3046: { WORD data = regs.d[dstreg];
3047: { UWORD val = data;
3048: cnt &= 63;
3049: { int carry = 0;
3050: ULONG cmask = 0x8000;
3051: for(;cnt;--cnt){
3052: carry=val&cmask; val <<= 1;
3053: if(carry) val |= 1;
3054: }
3055: regs.v = regs.c = 0;
3056: regs.z = ((WORD)(val)) == 0;
3057: regs.n = ((WORD)(val)) < 0;
3058: regs.c = carry!=0;
3059: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3060: }}}}}}
3061: void op_e780(UWORD opcode)
3062: {
3063: ULONG srcreg = 3;
3064: ULONG dstreg = (opcode & 7) >> 0;
3065: {{ ULONG cnt = srcreg;
3066: { LONG data = regs.d[dstreg];
3067: { ULONG val = data;
3068: cnt &= 63;
3069: regs.v = 0;
3070: { ULONG cmask = 0x80000000;
3071: ULONG sign = cmask & val;
3072: for(;cnt;--cnt){
3073: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
3074: if ((val&cmask)!=sign)regs.v=1;
3075: }
3076: regs.n = (val&cmask) != 0;
3077: regs.z = val == 0;
3078: regs.d[dstreg] = (val);
3079: }}}}}}
3080: void op_e788(UWORD opcode)
3081: {
3082: ULONG srcreg = 3;
3083: ULONG dstreg = (opcode & 7) >> 0;
3084: {{ ULONG cnt = srcreg;
3085: { LONG data = regs.d[dstreg];
3086: { ULONG val = data;
3087: cnt &= 63;
3088: { int carry = 0;
3089: ULONG cmask = 0x80000000;
3090: for(;cnt;--cnt){
3091: carry=val&cmask; val <<= 1;
3092: }
3093: regs.v = regs.c = 0;
3094: regs.z = ((LONG)(val)) == 0;
3095: regs.n = ((LONG)(val)) < 0;
3096: regs.c = regs.x = carry!=0;
3097: regs.d[dstreg] = (val);
3098: }}}}}}
3099: void op_e790(UWORD opcode)
3100: {
3101: ULONG srcreg = 3;
3102: ULONG dstreg = (opcode & 7) >> 0;
3103: {{ ULONG cnt = srcreg;
3104: { LONG data = regs.d[dstreg];
3105: { ULONG val = data;
3106: cnt &= 63;
3107: { int carry = 0;
3108: ULONG cmask = 0x80000000;
3109: for(;cnt;--cnt){
3110: carry=val&cmask; val <<= 1;
3111: if(regs.x) val |= 1;
3112: regs.x = carry != 0;
3113: }
3114: regs.v = regs.c = 0;
3115: regs.z = ((LONG)(val)) == 0;
3116: regs.n = ((LONG)(val)) < 0;
3117: regs.x = regs.c = carry!=0;
3118: regs.d[dstreg] = (val);
3119: }}}}}}
3120: void op_e798(UWORD opcode)
3121: {
3122: ULONG srcreg = 3;
3123: ULONG dstreg = (opcode & 7) >> 0;
3124: {{ ULONG cnt = srcreg;
3125: { LONG data = regs.d[dstreg];
3126: { ULONG val = data;
3127: cnt &= 63;
3128: { int carry = 0;
3129: ULONG cmask = 0x80000000;
3130: for(;cnt;--cnt){
3131: carry=val&cmask; val <<= 1;
3132: if(carry) val |= 1;
3133: }
3134: regs.v = regs.c = 0;
3135: regs.z = ((LONG)(val)) == 0;
3136: regs.n = ((LONG)(val)) < 0;
3137: regs.c = carry!=0;
3138: regs.d[dstreg] = (val);
3139: }}}}}}
3140: void op_e7d0(UWORD opcode)
3141: {
3142: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3143: {{ CPTR dataa = regs.a[srcreg];
3144: WORD data = get_word(dataa);
3145: { UWORD val = data;
3146: ULONG cmask = 0x8000;
3147: int carry = val&cmask;
3148: val <<= 1;
3149: if(carry) val |= 1;
3150: regs.v = regs.c = 0;
3151: regs.z = ((WORD)(val)) == 0;
3152: regs.n = ((WORD)(val)) < 0;
3153: regs.c = carry!=0;
3154: put_word(dataa,val);
3155: }}}}
3156: void op_e7d8(UWORD opcode)
3157: {
3158: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3159: {{ CPTR dataa = regs.a[srcreg];
3160: WORD data = get_word(dataa);
3161: { regs.a[srcreg] += 2;
3162: { UWORD val = data;
3163: ULONG cmask = 0x8000;
3164: int carry = val&cmask;
3165: val <<= 1;
3166: if(carry) val |= 1;
3167: regs.v = regs.c = 0;
3168: regs.z = ((WORD)(val)) == 0;
3169: regs.n = ((WORD)(val)) < 0;
3170: regs.c = carry!=0;
3171: put_word(dataa,val);
3172: }}}}}
3173: void op_e7e0(UWORD opcode)
3174: {
3175: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3176: {{ regs.a[srcreg] -= 2;
3177: { CPTR dataa = regs.a[srcreg];
3178: WORD data = get_word(dataa);
3179: { UWORD val = data;
3180: ULONG cmask = 0x8000;
3181: int carry = val&cmask;
3182: val <<= 1;
3183: if(carry) val |= 1;
3184: regs.v = regs.c = 0;
3185: regs.z = ((WORD)(val)) == 0;
3186: regs.n = ((WORD)(val)) < 0;
3187: regs.c = carry!=0;
3188: put_word(dataa,val);
3189: }}}}}
3190: void op_e7e8(UWORD opcode)
3191: {
3192: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3193: {{ CPTR dataa = regs.a[srcreg] + (LONG)(WORD)nextiword();
3194: WORD data = get_word(dataa);
3195: { UWORD val = data;
3196: ULONG cmask = 0x8000;
3197: int carry = val&cmask;
3198: val <<= 1;
3199: if(carry) val |= 1;
3200: regs.v = regs.c = 0;
3201: regs.z = ((WORD)(val)) == 0;
3202: regs.n = ((WORD)(val)) < 0;
3203: regs.c = carry!=0;
3204: put_word(dataa,val);
3205: }}}}
3206: void op_e7f0(UWORD opcode)
3207: {
3208: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3209: {{ CPTR dataa = regs.a[srcreg];
3210: UWORD datadp = nextiword();
3211: dataa += (LONG)(BYTE)(datadp & 0xFF);
3212: { ULONG datadpr = datadp & 0x8000 ? regs.a[(datadp & 0x7000) >> 12] : regs.d[(datadp & 0x7000) >> 12];
3213: if (!(datadp & 0x800)) datadpr = (LONG)(WORD)datadpr;
3214: dataa += datadpr;
3215: { WORD data = get_word(dataa);
3216: { UWORD val = data;
3217: ULONG cmask = 0x8000;
3218: int carry = val&cmask;
3219: val <<= 1;
3220: if(carry) val |= 1;
3221: regs.v = regs.c = 0;
3222: regs.z = ((WORD)(val)) == 0;
3223: regs.n = ((WORD)(val)) < 0;
3224: regs.c = carry!=0;
3225: put_word(dataa,val);
3226: }}}}}}
3227: void op_e7f8(UWORD opcode)
3228: {
3229: {{ CPTR dataa = (LONG)(WORD)nextiword();
3230: WORD data = get_word(dataa);
3231: { UWORD val = data;
3232: ULONG cmask = 0x8000;
3233: int carry = val&cmask;
3234: val <<= 1;
3235: if(carry) val |= 1;
3236: regs.v = regs.c = 0;
3237: regs.z = ((WORD)(val)) == 0;
3238: regs.n = ((WORD)(val)) < 0;
3239: regs.c = carry!=0;
3240: put_word(dataa,val);
3241: }}}}
3242: void op_e7f9(UWORD opcode)
3243: {
3244: {{ CPTR dataa = nextilong();
3245: WORD data = get_word(dataa);
3246: { UWORD val = data;
3247: ULONG cmask = 0x8000;
3248: int carry = val&cmask;
3249: val <<= 1;
3250: if(carry) val |= 1;
3251: regs.v = regs.c = 0;
3252: regs.z = ((WORD)(val)) == 0;
3253: regs.n = ((WORD)(val)) < 0;
3254: regs.c = carry!=0;
3255: put_word(dataa,val);
3256: }}}}
3257: void op_e800(UWORD opcode)
3258: {
3259: ULONG srcreg = 4;
3260: ULONG dstreg = (opcode & 7) >> 0;
3261: {{ ULONG cnt = srcreg;
3262: { BYTE data = regs.d[dstreg];
3263: { UBYTE val = data;
3264: cnt &= 63;
3265: regs.v = 0;
3266: { ULONG cmask = 0x80;
3267: ULONG sign = cmask & val;
3268: for(;cnt;--cnt){
3269: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
3270: }
3271: regs.n = sign != 0;
3272: regs.z = val == 0;
3273: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3274: }}}}}}
3275: void op_e808(UWORD opcode)
3276: {
3277: ULONG srcreg = 4;
3278: ULONG dstreg = (opcode & 7) >> 0;
3279: {{ ULONG cnt = srcreg;
3280: { BYTE data = regs.d[dstreg];
3281: { UBYTE val = data;
3282: cnt &= 63;
3283: { int carry = 0;
3284: for(;cnt;--cnt){
3285: carry=val&1; val >>= 1;
3286: }
3287: regs.v = regs.c = 0;
3288: regs.z = ((BYTE)(val)) == 0;
3289: regs.n = ((BYTE)(val)) < 0;
3290: regs.c = regs.x = carry!=0;
3291: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3292: }}}}}}
3293: void op_e810(UWORD opcode)
3294: {
3295: ULONG srcreg = 4;
3296: ULONG dstreg = (opcode & 7) >> 0;
3297: {{ ULONG cnt = srcreg;
3298: { BYTE data = regs.d[dstreg];
3299: { UBYTE val = data;
3300: cnt &= 63;
3301: { int carry = 0;
3302: ULONG cmask = 0x80;
3303: for(;cnt;--cnt){
3304: carry=val&1; val >>= 1;
3305: if(regs.x) val |= cmask;
3306: regs.x = carry != 0;
3307: }
3308: regs.v = regs.c = 0;
3309: regs.z = ((BYTE)(val)) == 0;
3310: regs.n = ((BYTE)(val)) < 0;
3311: regs.x = regs.c = carry!=0;
3312: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3313: }}}}}}
3314: void op_e818(UWORD opcode)
3315: {
3316: ULONG srcreg = 4;
3317: ULONG dstreg = (opcode & 7) >> 0;
3318: {{ ULONG cnt = srcreg;
3319: { BYTE data = regs.d[dstreg];
3320: { UBYTE val = data;
3321: cnt &= 63;
3322: { int carry = 0;
3323: ULONG cmask = 0x80;
3324: for(;cnt;--cnt){
3325: carry=val&1; val = (ULONG)val >> 1;
3326: if(carry) val |= cmask;
3327: }
3328: regs.v = regs.c = 0;
3329: regs.z = ((BYTE)(val)) == 0;
3330: regs.n = ((BYTE)(val)) < 0;
3331: regs.c = carry!=0;
3332: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3333: }}}}}}
3334: void op_e840(UWORD opcode)
3335: {
3336: ULONG srcreg = 4;
3337: ULONG dstreg = (opcode & 7) >> 0;
3338: {{ ULONG cnt = srcreg;
3339: { WORD data = regs.d[dstreg];
3340: { UWORD val = data;
3341: cnt &= 63;
3342: regs.v = 0;
3343: { ULONG cmask = 0x8000;
3344: ULONG sign = cmask & val;
3345: for(;cnt;--cnt){
3346: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
3347: }
3348: regs.n = sign != 0;
3349: regs.z = val == 0;
3350: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3351: }}}}}}
3352: void op_e848(UWORD opcode)
3353: {
3354: ULONG srcreg = 4;
3355: ULONG dstreg = (opcode & 7) >> 0;
3356: {{ ULONG cnt = srcreg;
3357: { WORD data = regs.d[dstreg];
3358: { UWORD val = data;
3359: cnt &= 63;
3360: { int carry = 0;
3361: for(;cnt;--cnt){
3362: carry=val&1; val >>= 1;
3363: }
3364: regs.v = regs.c = 0;
3365: regs.z = ((WORD)(val)) == 0;
3366: regs.n = ((WORD)(val)) < 0;
3367: regs.c = regs.x = carry!=0;
3368: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3369: }}}}}}
3370: void op_e850(UWORD opcode)
3371: {
3372: ULONG srcreg = 4;
3373: ULONG dstreg = (opcode & 7) >> 0;
3374: {{ ULONG cnt = srcreg;
3375: { WORD data = regs.d[dstreg];
3376: { UWORD val = data;
3377: cnt &= 63;
3378: { int carry = 0;
3379: ULONG cmask = 0x8000;
3380: for(;cnt;--cnt){
3381: carry=val&1; val >>= 1;
3382: if(regs.x) val |= cmask;
3383: regs.x = carry != 0;
3384: }
3385: regs.v = regs.c = 0;
3386: regs.z = ((WORD)(val)) == 0;
3387: regs.n = ((WORD)(val)) < 0;
3388: regs.x = regs.c = carry!=0;
3389: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3390: }}}}}}
3391: void op_e858(UWORD opcode)
3392: {
3393: ULONG srcreg = 4;
3394: ULONG dstreg = (opcode & 7) >> 0;
3395: {{ ULONG cnt = srcreg;
3396: { WORD data = regs.d[dstreg];
3397: { UWORD val = data;
3398: cnt &= 63;
3399: { int carry = 0;
3400: ULONG cmask = 0x8000;
3401: for(;cnt;--cnt){
3402: carry=val&1; val = (ULONG)val >> 1;
3403: if(carry) val |= cmask;
3404: }
3405: regs.v = regs.c = 0;
3406: regs.z = ((WORD)(val)) == 0;
3407: regs.n = ((WORD)(val)) < 0;
3408: regs.c = carry!=0;
3409: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3410: }}}}}}
3411: void op_e880(UWORD opcode)
3412: {
3413: ULONG srcreg = 4;
3414: ULONG dstreg = (opcode & 7) >> 0;
3415: {{ ULONG cnt = srcreg;
3416: { LONG data = regs.d[dstreg];
3417: { ULONG val = data;
3418: cnt &= 63;
3419: regs.v = 0;
3420: { ULONG cmask = 0x80000000;
3421: ULONG sign = cmask & val;
3422: for(;cnt;--cnt){
3423: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
3424: }
3425: regs.n = sign != 0;
3426: regs.z = val == 0;
3427: regs.d[dstreg] = (val);
3428: }}}}}}
3429: void op_e888(UWORD opcode)
3430: {
3431: ULONG srcreg = 4;
3432: ULONG dstreg = (opcode & 7) >> 0;
3433: {{ ULONG cnt = srcreg;
3434: { LONG data = regs.d[dstreg];
3435: { ULONG val = data;
3436: cnt &= 63;
3437: { int carry = 0;
3438: for(;cnt;--cnt){
3439: carry=val&1; val >>= 1;
3440: }
3441: regs.v = regs.c = 0;
3442: regs.z = ((LONG)(val)) == 0;
3443: regs.n = ((LONG)(val)) < 0;
3444: regs.c = regs.x = carry!=0;
3445: regs.d[dstreg] = (val);
3446: }}}}}}
3447: void op_e890(UWORD opcode)
3448: {
3449: ULONG srcreg = 4;
3450: ULONG dstreg = (opcode & 7) >> 0;
3451: {{ ULONG cnt = srcreg;
3452: { LONG data = regs.d[dstreg];
3453: { ULONG val = data;
3454: cnt &= 63;
3455: { int carry = 0;
3456: ULONG cmask = 0x80000000;
3457: for(;cnt;--cnt){
3458: carry=val&1; val >>= 1;
3459: if(regs.x) val |= cmask;
3460: regs.x = carry != 0;
3461: }
3462: regs.v = regs.c = 0;
3463: regs.z = ((LONG)(val)) == 0;
3464: regs.n = ((LONG)(val)) < 0;
3465: regs.x = regs.c = carry!=0;
3466: regs.d[dstreg] = (val);
3467: }}}}}}
3468: void op_e898(UWORD opcode)
3469: {
3470: ULONG srcreg = 4;
3471: ULONG dstreg = (opcode & 7) >> 0;
3472: {{ ULONG cnt = srcreg;
3473: { LONG data = regs.d[dstreg];
3474: { ULONG val = data;
3475: cnt &= 63;
3476: { int carry = 0;
3477: ULONG cmask = 0x80000000;
3478: for(;cnt;--cnt){
3479: carry=val&1; val = (ULONG)val >> 1;
3480: if(carry) val |= cmask;
3481: }
3482: regs.v = regs.c = 0;
3483: regs.z = ((LONG)(val)) == 0;
3484: regs.n = ((LONG)(val)) < 0;
3485: regs.c = carry!=0;
3486: regs.d[dstreg] = (val);
3487: }}}}}}
3488: void op_e900(UWORD opcode)
3489: {
3490: ULONG srcreg = 4;
3491: ULONG dstreg = (opcode & 7) >> 0;
3492: {{ ULONG cnt = srcreg;
3493: { BYTE data = regs.d[dstreg];
3494: { UBYTE val = data;
3495: cnt &= 63;
3496: regs.v = 0;
3497: { ULONG cmask = 0x80;
3498: ULONG sign = cmask & val;
3499: for(;cnt;--cnt){
3500: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
3501: if ((val&cmask)!=sign)regs.v=1;
3502: }
3503: regs.n = (val&cmask) != 0;
3504: regs.z = val == 0;
3505: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3506: }}}}}}
3507: void op_e908(UWORD opcode)
3508: {
3509: ULONG srcreg = 4;
3510: ULONG dstreg = (opcode & 7) >> 0;
3511: {{ ULONG cnt = srcreg;
3512: { BYTE data = regs.d[dstreg];
3513: { UBYTE val = data;
3514: cnt &= 63;
3515: { int carry = 0;
3516: ULONG cmask = 0x80;
3517: for(;cnt;--cnt){
3518: carry=val&cmask; val <<= 1;
3519: }
3520: regs.v = regs.c = 0;
3521: regs.z = ((BYTE)(val)) == 0;
3522: regs.n = ((BYTE)(val)) < 0;
3523: regs.c = regs.x = carry!=0;
3524: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3525: }}}}}}
3526: void op_e910(UWORD opcode)
3527: {
3528: ULONG srcreg = 4;
3529: ULONG dstreg = (opcode & 7) >> 0;
3530: {{ ULONG cnt = srcreg;
3531: { BYTE data = regs.d[dstreg];
3532: { UBYTE val = data;
3533: cnt &= 63;
3534: { int carry = 0;
3535: ULONG cmask = 0x80;
3536: for(;cnt;--cnt){
3537: carry=val&cmask; val <<= 1;
3538: if(regs.x) val |= 1;
3539: regs.x = carry != 0;
3540: }
3541: regs.v = regs.c = 0;
3542: regs.z = ((BYTE)(val)) == 0;
3543: regs.n = ((BYTE)(val)) < 0;
3544: regs.x = regs.c = carry!=0;
3545: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3546: }}}}}}
3547: void op_e918(UWORD opcode)
3548: {
3549: ULONG srcreg = 4;
3550: ULONG dstreg = (opcode & 7) >> 0;
3551: {{ ULONG cnt = srcreg;
3552: { BYTE data = regs.d[dstreg];
3553: { UBYTE val = data;
3554: cnt &= 63;
3555: { int carry = 0;
3556: ULONG cmask = 0x80;
3557: for(;cnt;--cnt){
3558: carry=val&cmask; val <<= 1;
3559: if(carry) val |= 1;
3560: }
3561: regs.v = regs.c = 0;
3562: regs.z = ((BYTE)(val)) == 0;
3563: regs.n = ((BYTE)(val)) < 0;
3564: regs.c = carry!=0;
3565: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3566: }}}}}}
3567: void op_e940(UWORD opcode)
3568: {
3569: ULONG srcreg = 4;
3570: ULONG dstreg = (opcode & 7) >> 0;
3571: {{ ULONG cnt = srcreg;
3572: { WORD data = regs.d[dstreg];
3573: { UWORD val = data;
3574: cnt &= 63;
3575: regs.v = 0;
3576: { ULONG cmask = 0x8000;
3577: ULONG sign = cmask & val;
3578: for(;cnt;--cnt){
3579: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
3580: if ((val&cmask)!=sign)regs.v=1;
3581: }
3582: regs.n = (val&cmask) != 0;
3583: regs.z = val == 0;
3584: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3585: }}}}}}
3586: void op_e948(UWORD opcode)
3587: {
3588: ULONG srcreg = 4;
3589: ULONG dstreg = (opcode & 7) >> 0;
3590: {{ ULONG cnt = srcreg;
3591: { WORD data = regs.d[dstreg];
3592: { UWORD val = data;
3593: cnt &= 63;
3594: { int carry = 0;
3595: ULONG cmask = 0x8000;
3596: for(;cnt;--cnt){
3597: carry=val&cmask; val <<= 1;
3598: }
3599: regs.v = regs.c = 0;
3600: regs.z = ((WORD)(val)) == 0;
3601: regs.n = ((WORD)(val)) < 0;
3602: regs.c = regs.x = carry!=0;
3603: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3604: }}}}}}
3605: void op_e950(UWORD opcode)
3606: {
3607: ULONG srcreg = 4;
3608: ULONG dstreg = (opcode & 7) >> 0;
3609: {{ ULONG cnt = srcreg;
3610: { WORD data = regs.d[dstreg];
3611: { UWORD val = data;
3612: cnt &= 63;
3613: { int carry = 0;
3614: ULONG cmask = 0x8000;
3615: for(;cnt;--cnt){
3616: carry=val&cmask; val <<= 1;
3617: if(regs.x) val |= 1;
3618: regs.x = carry != 0;
3619: }
3620: regs.v = regs.c = 0;
3621: regs.z = ((WORD)(val)) == 0;
3622: regs.n = ((WORD)(val)) < 0;
3623: regs.x = regs.c = carry!=0;
3624: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3625: }}}}}}
3626: void op_e958(UWORD opcode)
3627: {
3628: ULONG srcreg = 4;
3629: ULONG dstreg = (opcode & 7) >> 0;
3630: {{ ULONG cnt = srcreg;
3631: { WORD data = regs.d[dstreg];
3632: { UWORD val = data;
3633: cnt &= 63;
3634: { int carry = 0;
3635: ULONG cmask = 0x8000;
3636: for(;cnt;--cnt){
3637: carry=val&cmask; val <<= 1;
3638: if(carry) val |= 1;
3639: }
3640: regs.v = regs.c = 0;
3641: regs.z = ((WORD)(val)) == 0;
3642: regs.n = ((WORD)(val)) < 0;
3643: regs.c = carry!=0;
3644: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3645: }}}}}}
3646: void op_e980(UWORD opcode)
3647: {
3648: ULONG srcreg = 4;
3649: ULONG dstreg = (opcode & 7) >> 0;
3650: {{ ULONG cnt = srcreg;
3651: { LONG data = regs.d[dstreg];
3652: { ULONG val = data;
3653: cnt &= 63;
3654: regs.v = 0;
3655: { ULONG cmask = 0x80000000;
3656: ULONG sign = cmask & val;
3657: for(;cnt;--cnt){
3658: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
3659: if ((val&cmask)!=sign)regs.v=1;
3660: }
3661: regs.n = (val&cmask) != 0;
3662: regs.z = val == 0;
3663: regs.d[dstreg] = (val);
3664: }}}}}}
3665: void op_e988(UWORD opcode)
3666: {
3667: ULONG srcreg = 4;
3668: ULONG dstreg = (opcode & 7) >> 0;
3669: {{ ULONG cnt = srcreg;
3670: { LONG data = regs.d[dstreg];
3671: { ULONG val = data;
3672: cnt &= 63;
3673: { int carry = 0;
3674: ULONG cmask = 0x80000000;
3675: for(;cnt;--cnt){
3676: carry=val&cmask; val <<= 1;
3677: }
3678: regs.v = regs.c = 0;
3679: regs.z = ((LONG)(val)) == 0;
3680: regs.n = ((LONG)(val)) < 0;
3681: regs.c = regs.x = carry!=0;
3682: regs.d[dstreg] = (val);
3683: }}}}}}
3684: void op_e990(UWORD opcode)
3685: {
3686: ULONG srcreg = 4;
3687: ULONG dstreg = (opcode & 7) >> 0;
3688: {{ ULONG cnt = srcreg;
3689: { LONG data = regs.d[dstreg];
3690: { ULONG val = data;
3691: cnt &= 63;
3692: { int carry = 0;
3693: ULONG cmask = 0x80000000;
3694: for(;cnt;--cnt){
3695: carry=val&cmask; val <<= 1;
3696: if(regs.x) val |= 1;
3697: regs.x = carry != 0;
3698: }
3699: regs.v = regs.c = 0;
3700: regs.z = ((LONG)(val)) == 0;
3701: regs.n = ((LONG)(val)) < 0;
3702: regs.x = regs.c = carry!=0;
3703: regs.d[dstreg] = (val);
3704: }}}}}}
3705: void op_e998(UWORD opcode)
3706: {
3707: ULONG srcreg = 4;
3708: ULONG dstreg = (opcode & 7) >> 0;
3709: {{ ULONG cnt = srcreg;
3710: { LONG data = regs.d[dstreg];
3711: { ULONG val = data;
3712: cnt &= 63;
3713: { int carry = 0;
3714: ULONG cmask = 0x80000000;
3715: for(;cnt;--cnt){
3716: carry=val&cmask; val <<= 1;
3717: if(carry) val |= 1;
3718: }
3719: regs.v = regs.c = 0;
3720: regs.z = ((LONG)(val)) == 0;
3721: regs.n = ((LONG)(val)) < 0;
3722: regs.c = carry!=0;
3723: regs.d[dstreg] = (val);
3724: }}}}}}
3725: void op_ea00(UWORD opcode)
3726: {
3727: ULONG srcreg = 5;
3728: ULONG dstreg = (opcode & 7) >> 0;
3729: {{ ULONG cnt = srcreg;
3730: { BYTE data = regs.d[dstreg];
3731: { UBYTE val = data;
3732: cnt &= 63;
3733: regs.v = 0;
3734: { ULONG cmask = 0x80;
3735: ULONG sign = cmask & val;
3736: for(;cnt;--cnt){
3737: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
3738: }
3739: regs.n = sign != 0;
3740: regs.z = val == 0;
3741: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3742: }}}}}}
3743: void op_ea08(UWORD opcode)
3744: {
3745: ULONG srcreg = 5;
3746: ULONG dstreg = (opcode & 7) >> 0;
3747: {{ ULONG cnt = srcreg;
3748: { BYTE data = regs.d[dstreg];
3749: { UBYTE val = data;
3750: cnt &= 63;
3751: { int carry = 0;
3752: for(;cnt;--cnt){
3753: carry=val&1; val >>= 1;
3754: }
3755: regs.v = regs.c = 0;
3756: regs.z = ((BYTE)(val)) == 0;
3757: regs.n = ((BYTE)(val)) < 0;
3758: regs.c = regs.x = carry!=0;
3759: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3760: }}}}}}
3761: void op_ea10(UWORD opcode)
3762: {
3763: ULONG srcreg = 5;
3764: ULONG dstreg = (opcode & 7) >> 0;
3765: {{ ULONG cnt = srcreg;
3766: { BYTE data = regs.d[dstreg];
3767: { UBYTE val = data;
3768: cnt &= 63;
3769: { int carry = 0;
3770: ULONG cmask = 0x80;
3771: for(;cnt;--cnt){
3772: carry=val&1; val >>= 1;
3773: if(regs.x) val |= cmask;
3774: regs.x = carry != 0;
3775: }
3776: regs.v = regs.c = 0;
3777: regs.z = ((BYTE)(val)) == 0;
3778: regs.n = ((BYTE)(val)) < 0;
3779: regs.x = regs.c = carry!=0;
3780: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3781: }}}}}}
3782: void op_ea18(UWORD opcode)
3783: {
3784: ULONG srcreg = 5;
3785: ULONG dstreg = (opcode & 7) >> 0;
3786: {{ ULONG cnt = srcreg;
3787: { BYTE data = regs.d[dstreg];
3788: { UBYTE val = data;
3789: cnt &= 63;
3790: { int carry = 0;
3791: ULONG cmask = 0x80;
3792: for(;cnt;--cnt){
3793: carry=val&1; val = (ULONG)val >> 1;
3794: if(carry) val |= cmask;
3795: }
3796: regs.v = regs.c = 0;
3797: regs.z = ((BYTE)(val)) == 0;
3798: regs.n = ((BYTE)(val)) < 0;
3799: regs.c = carry!=0;
3800: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3801: }}}}}}
3802: void op_ea40(UWORD opcode)
3803: {
3804: ULONG srcreg = 5;
3805: ULONG dstreg = (opcode & 7) >> 0;
3806: {{ ULONG cnt = srcreg;
3807: { WORD data = regs.d[dstreg];
3808: { UWORD val = data;
3809: cnt &= 63;
3810: regs.v = 0;
3811: { ULONG cmask = 0x8000;
3812: ULONG sign = cmask & val;
3813: for(;cnt;--cnt){
3814: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
3815: }
3816: regs.n = sign != 0;
3817: regs.z = val == 0;
3818: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3819: }}}}}}
3820: void op_ea48(UWORD opcode)
3821: {
3822: ULONG srcreg = 5;
3823: ULONG dstreg = (opcode & 7) >> 0;
3824: {{ ULONG cnt = srcreg;
3825: { WORD data = regs.d[dstreg];
3826: { UWORD val = data;
3827: cnt &= 63;
3828: { int carry = 0;
3829: for(;cnt;--cnt){
3830: carry=val&1; val >>= 1;
3831: }
3832: regs.v = regs.c = 0;
3833: regs.z = ((WORD)(val)) == 0;
3834: regs.n = ((WORD)(val)) < 0;
3835: regs.c = regs.x = carry!=0;
3836: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3837: }}}}}}
3838: void op_ea50(UWORD opcode)
3839: {
3840: ULONG srcreg = 5;
3841: ULONG dstreg = (opcode & 7) >> 0;
3842: {{ ULONG cnt = srcreg;
3843: { WORD data = regs.d[dstreg];
3844: { UWORD val = data;
3845: cnt &= 63;
3846: { int carry = 0;
3847: ULONG cmask = 0x8000;
3848: for(;cnt;--cnt){
3849: carry=val&1; val >>= 1;
3850: if(regs.x) val |= cmask;
3851: regs.x = carry != 0;
3852: }
3853: regs.v = regs.c = 0;
3854: regs.z = ((WORD)(val)) == 0;
3855: regs.n = ((WORD)(val)) < 0;
3856: regs.x = regs.c = carry!=0;
3857: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3858: }}}}}}
3859: void op_ea58(UWORD opcode)
3860: {
3861: ULONG srcreg = 5;
3862: ULONG dstreg = (opcode & 7) >> 0;
3863: {{ ULONG cnt = srcreg;
3864: { WORD data = regs.d[dstreg];
3865: { UWORD val = data;
3866: cnt &= 63;
3867: { int carry = 0;
3868: ULONG cmask = 0x8000;
3869: for(;cnt;--cnt){
3870: carry=val&1; val = (ULONG)val >> 1;
3871: if(carry) val |= cmask;
3872: }
3873: regs.v = regs.c = 0;
3874: regs.z = ((WORD)(val)) == 0;
3875: regs.n = ((WORD)(val)) < 0;
3876: regs.c = carry!=0;
3877: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
3878: }}}}}}
3879: void op_ea80(UWORD opcode)
3880: {
3881: ULONG srcreg = 5;
3882: ULONG dstreg = (opcode & 7) >> 0;
3883: {{ ULONG cnt = srcreg;
3884: { LONG data = regs.d[dstreg];
3885: { ULONG val = data;
3886: cnt &= 63;
3887: regs.v = 0;
3888: { ULONG cmask = 0x80000000;
3889: ULONG sign = cmask & val;
3890: for(;cnt;--cnt){
3891: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
3892: }
3893: regs.n = sign != 0;
3894: regs.z = val == 0;
3895: regs.d[dstreg] = (val);
3896: }}}}}}
3897: void op_ea88(UWORD opcode)
3898: {
3899: ULONG srcreg = 5;
3900: ULONG dstreg = (opcode & 7) >> 0;
3901: {{ ULONG cnt = srcreg;
3902: { LONG data = regs.d[dstreg];
3903: { ULONG val = data;
3904: cnt &= 63;
3905: { int carry = 0;
3906: for(;cnt;--cnt){
3907: carry=val&1; val >>= 1;
3908: }
3909: regs.v = regs.c = 0;
3910: regs.z = ((LONG)(val)) == 0;
3911: regs.n = ((LONG)(val)) < 0;
3912: regs.c = regs.x = carry!=0;
3913: regs.d[dstreg] = (val);
3914: }}}}}}
3915: void op_ea90(UWORD opcode)
3916: {
3917: ULONG srcreg = 5;
3918: ULONG dstreg = (opcode & 7) >> 0;
3919: {{ ULONG cnt = srcreg;
3920: { LONG data = regs.d[dstreg];
3921: { ULONG val = data;
3922: cnt &= 63;
3923: { int carry = 0;
3924: ULONG cmask = 0x80000000;
3925: for(;cnt;--cnt){
3926: carry=val&1; val >>= 1;
3927: if(regs.x) val |= cmask;
3928: regs.x = carry != 0;
3929: }
3930: regs.v = regs.c = 0;
3931: regs.z = ((LONG)(val)) == 0;
3932: regs.n = ((LONG)(val)) < 0;
3933: regs.x = regs.c = carry!=0;
3934: regs.d[dstreg] = (val);
3935: }}}}}}
3936: void op_ea98(UWORD opcode)
3937: {
3938: ULONG srcreg = 5;
3939: ULONG dstreg = (opcode & 7) >> 0;
3940: {{ ULONG cnt = srcreg;
3941: { LONG data = regs.d[dstreg];
3942: { ULONG val = data;
3943: cnt &= 63;
3944: { int carry = 0;
3945: ULONG cmask = 0x80000000;
3946: for(;cnt;--cnt){
3947: carry=val&1; val = (ULONG)val >> 1;
3948: if(carry) val |= cmask;
3949: }
3950: regs.v = regs.c = 0;
3951: regs.z = ((LONG)(val)) == 0;
3952: regs.n = ((LONG)(val)) < 0;
3953: regs.c = carry!=0;
3954: regs.d[dstreg] = (val);
3955: }}}}}}
3956: void op_eb00(UWORD opcode)
3957: {
3958: ULONG srcreg = 5;
3959: ULONG dstreg = (opcode & 7) >> 0;
3960: {{ ULONG cnt = srcreg;
3961: { BYTE data = regs.d[dstreg];
3962: { UBYTE val = data;
3963: cnt &= 63;
3964: regs.v = 0;
3965: { ULONG cmask = 0x80;
3966: ULONG sign = cmask & val;
3967: for(;cnt;--cnt){
3968: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
3969: if ((val&cmask)!=sign)regs.v=1;
3970: }
3971: regs.n = (val&cmask) != 0;
3972: regs.z = val == 0;
3973: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3974: }}}}}}
3975: void op_eb08(UWORD opcode)
3976: {
3977: ULONG srcreg = 5;
3978: ULONG dstreg = (opcode & 7) >> 0;
3979: {{ ULONG cnt = srcreg;
3980: { BYTE data = regs.d[dstreg];
3981: { UBYTE val = data;
3982: cnt &= 63;
3983: { int carry = 0;
3984: ULONG cmask = 0x80;
3985: for(;cnt;--cnt){
3986: carry=val&cmask; val <<= 1;
3987: }
3988: regs.v = regs.c = 0;
3989: regs.z = ((BYTE)(val)) == 0;
3990: regs.n = ((BYTE)(val)) < 0;
3991: regs.c = regs.x = carry!=0;
3992: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
3993: }}}}}}
3994: void op_eb10(UWORD opcode)
3995: {
3996: ULONG srcreg = 5;
3997: ULONG dstreg = (opcode & 7) >> 0;
3998: {{ ULONG cnt = srcreg;
3999: { BYTE data = regs.d[dstreg];
4000: { UBYTE val = data;
4001: cnt &= 63;
4002: { int carry = 0;
4003: ULONG cmask = 0x80;
4004: for(;cnt;--cnt){
4005: carry=val&cmask; val <<= 1;
4006: if(regs.x) val |= 1;
4007: regs.x = carry != 0;
4008: }
4009: regs.v = regs.c = 0;
4010: regs.z = ((BYTE)(val)) == 0;
4011: regs.n = ((BYTE)(val)) < 0;
4012: regs.x = regs.c = carry!=0;
4013: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4014: }}}}}}
4015: void op_eb18(UWORD opcode)
4016: {
4017: ULONG srcreg = 5;
4018: ULONG dstreg = (opcode & 7) >> 0;
4019: {{ ULONG cnt = srcreg;
4020: { BYTE data = regs.d[dstreg];
4021: { UBYTE val = data;
4022: cnt &= 63;
4023: { int carry = 0;
4024: ULONG cmask = 0x80;
4025: for(;cnt;--cnt){
4026: carry=val&cmask; val <<= 1;
4027: if(carry) val |= 1;
4028: }
4029: regs.v = regs.c = 0;
4030: regs.z = ((BYTE)(val)) == 0;
4031: regs.n = ((BYTE)(val)) < 0;
4032: regs.c = carry!=0;
4033: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4034: }}}}}}
4035: void op_eb40(UWORD opcode)
4036: {
4037: ULONG srcreg = 5;
4038: ULONG dstreg = (opcode & 7) >> 0;
4039: {{ ULONG cnt = srcreg;
4040: { WORD data = regs.d[dstreg];
4041: { UWORD val = data;
4042: cnt &= 63;
4043: regs.v = 0;
4044: { ULONG cmask = 0x8000;
4045: ULONG sign = cmask & val;
4046: for(;cnt;--cnt){
4047: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
4048: if ((val&cmask)!=sign)regs.v=1;
4049: }
4050: regs.n = (val&cmask) != 0;
4051: regs.z = val == 0;
4052: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4053: }}}}}}
4054: void op_eb48(UWORD opcode)
4055: {
4056: ULONG srcreg = 5;
4057: ULONG dstreg = (opcode & 7) >> 0;
4058: {{ ULONG cnt = srcreg;
4059: { WORD data = regs.d[dstreg];
4060: { UWORD val = data;
4061: cnt &= 63;
4062: { int carry = 0;
4063: ULONG cmask = 0x8000;
4064: for(;cnt;--cnt){
4065: carry=val&cmask; val <<= 1;
4066: }
4067: regs.v = regs.c = 0;
4068: regs.z = ((WORD)(val)) == 0;
4069: regs.n = ((WORD)(val)) < 0;
4070: regs.c = regs.x = carry!=0;
4071: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4072: }}}}}}
4073: void op_eb50(UWORD opcode)
4074: {
4075: ULONG srcreg = 5;
4076: ULONG dstreg = (opcode & 7) >> 0;
4077: {{ ULONG cnt = srcreg;
4078: { WORD data = regs.d[dstreg];
4079: { UWORD val = data;
4080: cnt &= 63;
4081: { int carry = 0;
4082: ULONG cmask = 0x8000;
4083: for(;cnt;--cnt){
4084: carry=val&cmask; val <<= 1;
4085: if(regs.x) val |= 1;
4086: regs.x = carry != 0;
4087: }
4088: regs.v = regs.c = 0;
4089: regs.z = ((WORD)(val)) == 0;
4090: regs.n = ((WORD)(val)) < 0;
4091: regs.x = regs.c = carry!=0;
4092: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4093: }}}}}}
4094: void op_eb58(UWORD opcode)
4095: {
4096: ULONG srcreg = 5;
4097: ULONG dstreg = (opcode & 7) >> 0;
4098: {{ ULONG cnt = srcreg;
4099: { WORD data = regs.d[dstreg];
4100: { UWORD val = data;
4101: cnt &= 63;
4102: { int carry = 0;
4103: ULONG cmask = 0x8000;
4104: for(;cnt;--cnt){
4105: carry=val&cmask; val <<= 1;
4106: if(carry) val |= 1;
4107: }
4108: regs.v = regs.c = 0;
4109: regs.z = ((WORD)(val)) == 0;
4110: regs.n = ((WORD)(val)) < 0;
4111: regs.c = carry!=0;
4112: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4113: }}}}}}
4114: void op_eb80(UWORD opcode)
4115: {
4116: ULONG srcreg = 5;
4117: ULONG dstreg = (opcode & 7) >> 0;
4118: {{ ULONG cnt = srcreg;
4119: { LONG data = regs.d[dstreg];
4120: { ULONG val = data;
4121: cnt &= 63;
4122: regs.v = 0;
4123: { ULONG cmask = 0x80000000;
4124: ULONG sign = cmask & val;
4125: for(;cnt;--cnt){
4126: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
4127: if ((val&cmask)!=sign)regs.v=1;
4128: }
4129: regs.n = (val&cmask) != 0;
4130: regs.z = val == 0;
4131: regs.d[dstreg] = (val);
4132: }}}}}}
4133: void op_eb88(UWORD opcode)
4134: {
4135: ULONG srcreg = 5;
4136: ULONG dstreg = (opcode & 7) >> 0;
4137: {{ ULONG cnt = srcreg;
4138: { LONG data = regs.d[dstreg];
4139: { ULONG val = data;
4140: cnt &= 63;
4141: { int carry = 0;
4142: ULONG cmask = 0x80000000;
4143: for(;cnt;--cnt){
4144: carry=val&cmask; val <<= 1;
4145: }
4146: regs.v = regs.c = 0;
4147: regs.z = ((LONG)(val)) == 0;
4148: regs.n = ((LONG)(val)) < 0;
4149: regs.c = regs.x = carry!=0;
4150: regs.d[dstreg] = (val);
4151: }}}}}}
4152: void op_eb90(UWORD opcode)
4153: {
4154: ULONG srcreg = 5;
4155: ULONG dstreg = (opcode & 7) >> 0;
4156: {{ ULONG cnt = srcreg;
4157: { LONG data = regs.d[dstreg];
4158: { ULONG val = data;
4159: cnt &= 63;
4160: { int carry = 0;
4161: ULONG cmask = 0x80000000;
4162: for(;cnt;--cnt){
4163: carry=val&cmask; val <<= 1;
4164: if(regs.x) val |= 1;
4165: regs.x = carry != 0;
4166: }
4167: regs.v = regs.c = 0;
4168: regs.z = ((LONG)(val)) == 0;
4169: regs.n = ((LONG)(val)) < 0;
4170: regs.x = regs.c = carry!=0;
4171: regs.d[dstreg] = (val);
4172: }}}}}}
4173: void op_eb98(UWORD opcode)
4174: {
4175: ULONG srcreg = 5;
4176: ULONG dstreg = (opcode & 7) >> 0;
4177: {{ ULONG cnt = srcreg;
4178: { LONG data = regs.d[dstreg];
4179: { ULONG val = data;
4180: cnt &= 63;
4181: { int carry = 0;
4182: ULONG cmask = 0x80000000;
4183: for(;cnt;--cnt){
4184: carry=val&cmask; val <<= 1;
4185: if(carry) val |= 1;
4186: }
4187: regs.v = regs.c = 0;
4188: regs.z = ((LONG)(val)) == 0;
4189: regs.n = ((LONG)(val)) < 0;
4190: regs.c = carry!=0;
4191: regs.d[dstreg] = (val);
4192: }}}}}}
4193: void op_ec00(UWORD opcode)
4194: {
4195: ULONG srcreg = 6;
4196: ULONG dstreg = (opcode & 7) >> 0;
4197: {{ ULONG cnt = srcreg;
4198: { BYTE data = regs.d[dstreg];
4199: { UBYTE val = data;
4200: cnt &= 63;
4201: regs.v = 0;
4202: { ULONG cmask = 0x80;
4203: ULONG sign = cmask & val;
4204: for(;cnt;--cnt){
4205: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
4206: }
4207: regs.n = sign != 0;
4208: regs.z = val == 0;
4209: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4210: }}}}}}
4211: void op_ec08(UWORD opcode)
4212: {
4213: ULONG srcreg = 6;
4214: ULONG dstreg = (opcode & 7) >> 0;
4215: {{ ULONG cnt = srcreg;
4216: { BYTE data = regs.d[dstreg];
4217: { UBYTE val = data;
4218: cnt &= 63;
4219: { int carry = 0;
4220: for(;cnt;--cnt){
4221: carry=val&1; val >>= 1;
4222: }
4223: regs.v = regs.c = 0;
4224: regs.z = ((BYTE)(val)) == 0;
4225: regs.n = ((BYTE)(val)) < 0;
4226: regs.c = regs.x = carry!=0;
4227: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4228: }}}}}}
4229: void op_ec10(UWORD opcode)
4230: {
4231: ULONG srcreg = 6;
4232: ULONG dstreg = (opcode & 7) >> 0;
4233: {{ ULONG cnt = srcreg;
4234: { BYTE data = regs.d[dstreg];
4235: { UBYTE val = data;
4236: cnt &= 63;
4237: { int carry = 0;
4238: ULONG cmask = 0x80;
4239: for(;cnt;--cnt){
4240: carry=val&1; val >>= 1;
4241: if(regs.x) val |= cmask;
4242: regs.x = carry != 0;
4243: }
4244: regs.v = regs.c = 0;
4245: regs.z = ((BYTE)(val)) == 0;
4246: regs.n = ((BYTE)(val)) < 0;
4247: regs.x = regs.c = carry!=0;
4248: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4249: }}}}}}
4250: void op_ec18(UWORD opcode)
4251: {
4252: ULONG srcreg = 6;
4253: ULONG dstreg = (opcode & 7) >> 0;
4254: {{ ULONG cnt = srcreg;
4255: { BYTE data = regs.d[dstreg];
4256: { UBYTE val = data;
4257: cnt &= 63;
4258: { int carry = 0;
4259: ULONG cmask = 0x80;
4260: for(;cnt;--cnt){
4261: carry=val&1; val = (ULONG)val >> 1;
4262: if(carry) val |= cmask;
4263: }
4264: regs.v = regs.c = 0;
4265: regs.z = ((BYTE)(val)) == 0;
4266: regs.n = ((BYTE)(val)) < 0;
4267: regs.c = carry!=0;
4268: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4269: }}}}}}
4270: void op_ec40(UWORD opcode)
4271: {
4272: ULONG srcreg = 6;
4273: ULONG dstreg = (opcode & 7) >> 0;
4274: {{ ULONG cnt = srcreg;
4275: { WORD data = regs.d[dstreg];
4276: { UWORD val = data;
4277: cnt &= 63;
4278: regs.v = 0;
4279: { ULONG cmask = 0x8000;
4280: ULONG sign = cmask & val;
4281: for(;cnt;--cnt){
4282: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
4283: }
4284: regs.n = sign != 0;
4285: regs.z = val == 0;
4286: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4287: }}}}}}
4288: void op_ec48(UWORD opcode)
4289: {
4290: ULONG srcreg = 6;
4291: ULONG dstreg = (opcode & 7) >> 0;
4292: {{ ULONG cnt = srcreg;
4293: { WORD data = regs.d[dstreg];
4294: { UWORD val = data;
4295: cnt &= 63;
4296: { int carry = 0;
4297: for(;cnt;--cnt){
4298: carry=val&1; val >>= 1;
4299: }
4300: regs.v = regs.c = 0;
4301: regs.z = ((WORD)(val)) == 0;
4302: regs.n = ((WORD)(val)) < 0;
4303: regs.c = regs.x = carry!=0;
4304: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4305: }}}}}}
4306: void op_ec50(UWORD opcode)
4307: {
4308: ULONG srcreg = 6;
4309: ULONG dstreg = (opcode & 7) >> 0;
4310: {{ ULONG cnt = srcreg;
4311: { WORD data = regs.d[dstreg];
4312: { UWORD val = data;
4313: cnt &= 63;
4314: { int carry = 0;
4315: ULONG cmask = 0x8000;
4316: for(;cnt;--cnt){
4317: carry=val&1; val >>= 1;
4318: if(regs.x) val |= cmask;
4319: regs.x = carry != 0;
4320: }
4321: regs.v = regs.c = 0;
4322: regs.z = ((WORD)(val)) == 0;
4323: regs.n = ((WORD)(val)) < 0;
4324: regs.x = regs.c = carry!=0;
4325: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4326: }}}}}}
4327: void op_ec58(UWORD opcode)
4328: {
4329: ULONG srcreg = 6;
4330: ULONG dstreg = (opcode & 7) >> 0;
4331: {{ ULONG cnt = srcreg;
4332: { WORD data = regs.d[dstreg];
4333: { UWORD val = data;
4334: cnt &= 63;
4335: { int carry = 0;
4336: ULONG cmask = 0x8000;
4337: for(;cnt;--cnt){
4338: carry=val&1; val = (ULONG)val >> 1;
4339: if(carry) val |= cmask;
4340: }
4341: regs.v = regs.c = 0;
4342: regs.z = ((WORD)(val)) == 0;
4343: regs.n = ((WORD)(val)) < 0;
4344: regs.c = carry!=0;
4345: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4346: }}}}}}
4347: void op_ec80(UWORD opcode)
4348: {
4349: ULONG srcreg = 6;
4350: ULONG dstreg = (opcode & 7) >> 0;
4351: {{ ULONG cnt = srcreg;
4352: { LONG data = regs.d[dstreg];
4353: { ULONG val = data;
4354: cnt &= 63;
4355: regs.v = 0;
4356: { ULONG cmask = 0x80000000;
4357: ULONG sign = cmask & val;
4358: for(;cnt;--cnt){
4359: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
4360: }
4361: regs.n = sign != 0;
4362: regs.z = val == 0;
4363: regs.d[dstreg] = (val);
4364: }}}}}}
4365: void op_ec88(UWORD opcode)
4366: {
4367: ULONG srcreg = 6;
4368: ULONG dstreg = (opcode & 7) >> 0;
4369: {{ ULONG cnt = srcreg;
4370: { LONG data = regs.d[dstreg];
4371: { ULONG val = data;
4372: cnt &= 63;
4373: { int carry = 0;
4374: for(;cnt;--cnt){
4375: carry=val&1; val >>= 1;
4376: }
4377: regs.v = regs.c = 0;
4378: regs.z = ((LONG)(val)) == 0;
4379: regs.n = ((LONG)(val)) < 0;
4380: regs.c = regs.x = carry!=0;
4381: regs.d[dstreg] = (val);
4382: }}}}}}
4383: void op_ec90(UWORD opcode)
4384: {
4385: ULONG srcreg = 6;
4386: ULONG dstreg = (opcode & 7) >> 0;
4387: {{ ULONG cnt = srcreg;
4388: { LONG data = regs.d[dstreg];
4389: { ULONG val = data;
4390: cnt &= 63;
4391: { int carry = 0;
4392: ULONG cmask = 0x80000000;
4393: for(;cnt;--cnt){
4394: carry=val&1; val >>= 1;
4395: if(regs.x) val |= cmask;
4396: regs.x = carry != 0;
4397: }
4398: regs.v = regs.c = 0;
4399: regs.z = ((LONG)(val)) == 0;
4400: regs.n = ((LONG)(val)) < 0;
4401: regs.x = regs.c = carry!=0;
4402: regs.d[dstreg] = (val);
4403: }}}}}}
4404: void op_ec98(UWORD opcode)
4405: {
4406: ULONG srcreg = 6;
4407: ULONG dstreg = (opcode & 7) >> 0;
4408: {{ ULONG cnt = srcreg;
4409: { LONG data = regs.d[dstreg];
4410: { ULONG val = data;
4411: cnt &= 63;
4412: { int carry = 0;
4413: ULONG cmask = 0x80000000;
4414: for(;cnt;--cnt){
4415: carry=val&1; val = (ULONG)val >> 1;
4416: if(carry) val |= cmask;
4417: }
4418: regs.v = regs.c = 0;
4419: regs.z = ((LONG)(val)) == 0;
4420: regs.n = ((LONG)(val)) < 0;
4421: regs.c = carry!=0;
4422: regs.d[dstreg] = (val);
4423: }}}}}}
4424: void op_ed00(UWORD opcode)
4425: {
4426: ULONG srcreg = 6;
4427: ULONG dstreg = (opcode & 7) >> 0;
4428: {{ ULONG cnt = srcreg;
4429: { BYTE data = regs.d[dstreg];
4430: { UBYTE val = data;
4431: cnt &= 63;
4432: regs.v = 0;
4433: { ULONG cmask = 0x80;
4434: ULONG sign = cmask & val;
4435: for(;cnt;--cnt){
4436: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
4437: if ((val&cmask)!=sign)regs.v=1;
4438: }
4439: regs.n = (val&cmask) != 0;
4440: regs.z = val == 0;
4441: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4442: }}}}}}
4443: void op_ed08(UWORD opcode)
4444: {
4445: ULONG srcreg = 6;
4446: ULONG dstreg = (opcode & 7) >> 0;
4447: {{ ULONG cnt = srcreg;
4448: { BYTE data = regs.d[dstreg];
4449: { UBYTE val = data;
4450: cnt &= 63;
4451: { int carry = 0;
4452: ULONG cmask = 0x80;
4453: for(;cnt;--cnt){
4454: carry=val&cmask; val <<= 1;
4455: }
4456: regs.v = regs.c = 0;
4457: regs.z = ((BYTE)(val)) == 0;
4458: regs.n = ((BYTE)(val)) < 0;
4459: regs.c = regs.x = carry!=0;
4460: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4461: }}}}}}
4462: void op_ed10(UWORD opcode)
4463: {
4464: ULONG srcreg = 6;
4465: ULONG dstreg = (opcode & 7) >> 0;
4466: {{ ULONG cnt = srcreg;
4467: { BYTE data = regs.d[dstreg];
4468: { UBYTE val = data;
4469: cnt &= 63;
4470: { int carry = 0;
4471: ULONG cmask = 0x80;
4472: for(;cnt;--cnt){
4473: carry=val&cmask; val <<= 1;
4474: if(regs.x) val |= 1;
4475: regs.x = carry != 0;
4476: }
4477: regs.v = regs.c = 0;
4478: regs.z = ((BYTE)(val)) == 0;
4479: regs.n = ((BYTE)(val)) < 0;
4480: regs.x = regs.c = carry!=0;
4481: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4482: }}}}}}
4483: void op_ed18(UWORD opcode)
4484: {
4485: ULONG srcreg = 6;
4486: ULONG dstreg = (opcode & 7) >> 0;
4487: {{ ULONG cnt = srcreg;
4488: { BYTE data = regs.d[dstreg];
4489: { UBYTE val = data;
4490: cnt &= 63;
4491: { int carry = 0;
4492: ULONG cmask = 0x80;
4493: for(;cnt;--cnt){
4494: carry=val&cmask; val <<= 1;
4495: if(carry) val |= 1;
4496: }
4497: regs.v = regs.c = 0;
4498: regs.z = ((BYTE)(val)) == 0;
4499: regs.n = ((BYTE)(val)) < 0;
4500: regs.c = carry!=0;
4501: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4502: }}}}}}
4503: void op_ed40(UWORD opcode)
4504: {
4505: ULONG srcreg = 6;
4506: ULONG dstreg = (opcode & 7) >> 0;
4507: {{ ULONG cnt = srcreg;
4508: { WORD data = regs.d[dstreg];
4509: { UWORD val = data;
4510: cnt &= 63;
4511: regs.v = 0;
4512: { ULONG cmask = 0x8000;
4513: ULONG sign = cmask & val;
4514: for(;cnt;--cnt){
4515: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
4516: if ((val&cmask)!=sign)regs.v=1;
4517: }
4518: regs.n = (val&cmask) != 0;
4519: regs.z = val == 0;
4520: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4521: }}}}}}
4522: void op_ed48(UWORD opcode)
4523: {
4524: ULONG srcreg = 6;
4525: ULONG dstreg = (opcode & 7) >> 0;
4526: {{ ULONG cnt = srcreg;
4527: { WORD data = regs.d[dstreg];
4528: { UWORD val = data;
4529: cnt &= 63;
4530: { int carry = 0;
4531: ULONG cmask = 0x8000;
4532: for(;cnt;--cnt){
4533: carry=val&cmask; val <<= 1;
4534: }
4535: regs.v = regs.c = 0;
4536: regs.z = ((WORD)(val)) == 0;
4537: regs.n = ((WORD)(val)) < 0;
4538: regs.c = regs.x = carry!=0;
4539: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4540: }}}}}}
4541: void op_ed50(UWORD opcode)
4542: {
4543: ULONG srcreg = 6;
4544: ULONG dstreg = (opcode & 7) >> 0;
4545: {{ ULONG cnt = srcreg;
4546: { WORD data = regs.d[dstreg];
4547: { UWORD val = data;
4548: cnt &= 63;
4549: { int carry = 0;
4550: ULONG cmask = 0x8000;
4551: for(;cnt;--cnt){
4552: carry=val&cmask; val <<= 1;
4553: if(regs.x) val |= 1;
4554: regs.x = carry != 0;
4555: }
4556: regs.v = regs.c = 0;
4557: regs.z = ((WORD)(val)) == 0;
4558: regs.n = ((WORD)(val)) < 0;
4559: regs.x = regs.c = carry!=0;
4560: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4561: }}}}}}
4562: void op_ed58(UWORD opcode)
4563: {
4564: ULONG srcreg = 6;
4565: ULONG dstreg = (opcode & 7) >> 0;
4566: {{ ULONG cnt = srcreg;
4567: { WORD data = regs.d[dstreg];
4568: { UWORD val = data;
4569: cnt &= 63;
4570: { int carry = 0;
4571: ULONG cmask = 0x8000;
4572: for(;cnt;--cnt){
4573: carry=val&cmask; val <<= 1;
4574: if(carry) val |= 1;
4575: }
4576: regs.v = regs.c = 0;
4577: regs.z = ((WORD)(val)) == 0;
4578: regs.n = ((WORD)(val)) < 0;
4579: regs.c = carry!=0;
4580: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4581: }}}}}}
4582: void op_ed80(UWORD opcode)
4583: {
4584: ULONG srcreg = 6;
4585: ULONG dstreg = (opcode & 7) >> 0;
4586: {{ ULONG cnt = srcreg;
4587: { LONG data = regs.d[dstreg];
4588: { ULONG val = data;
4589: cnt &= 63;
4590: regs.v = 0;
4591: { ULONG cmask = 0x80000000;
4592: ULONG sign = cmask & val;
4593: for(;cnt;--cnt){
4594: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
4595: if ((val&cmask)!=sign)regs.v=1;
4596: }
4597: regs.n = (val&cmask) != 0;
4598: regs.z = val == 0;
4599: regs.d[dstreg] = (val);
4600: }}}}}}
4601: void op_ed88(UWORD opcode)
4602: {
4603: ULONG srcreg = 6;
4604: ULONG dstreg = (opcode & 7) >> 0;
4605: {{ ULONG cnt = srcreg;
4606: { LONG data = regs.d[dstreg];
4607: { ULONG val = data;
4608: cnt &= 63;
4609: { int carry = 0;
4610: ULONG cmask = 0x80000000;
4611: for(;cnt;--cnt){
4612: carry=val&cmask; val <<= 1;
4613: }
4614: regs.v = regs.c = 0;
4615: regs.z = ((LONG)(val)) == 0;
4616: regs.n = ((LONG)(val)) < 0;
4617: regs.c = regs.x = carry!=0;
4618: regs.d[dstreg] = (val);
4619: }}}}}}
4620: void op_ed90(UWORD opcode)
4621: {
4622: ULONG srcreg = 6;
4623: ULONG dstreg = (opcode & 7) >> 0;
4624: {{ ULONG cnt = srcreg;
4625: { LONG data = regs.d[dstreg];
4626: { ULONG val = data;
4627: cnt &= 63;
4628: { int carry = 0;
4629: ULONG cmask = 0x80000000;
4630: for(;cnt;--cnt){
4631: carry=val&cmask; val <<= 1;
4632: if(regs.x) val |= 1;
4633: regs.x = carry != 0;
4634: }
4635: regs.v = regs.c = 0;
4636: regs.z = ((LONG)(val)) == 0;
4637: regs.n = ((LONG)(val)) < 0;
4638: regs.x = regs.c = carry!=0;
4639: regs.d[dstreg] = (val);
4640: }}}}}}
4641: void op_ed98(UWORD opcode)
4642: {
4643: ULONG srcreg = 6;
4644: ULONG dstreg = (opcode & 7) >> 0;
4645: {{ ULONG cnt = srcreg;
4646: { LONG data = regs.d[dstreg];
4647: { ULONG val = data;
4648: cnt &= 63;
4649: { int carry = 0;
4650: ULONG cmask = 0x80000000;
4651: for(;cnt;--cnt){
4652: carry=val&cmask; val <<= 1;
4653: if(carry) val |= 1;
4654: }
4655: regs.v = regs.c = 0;
4656: regs.z = ((LONG)(val)) == 0;
4657: regs.n = ((LONG)(val)) < 0;
4658: regs.c = carry!=0;
4659: regs.d[dstreg] = (val);
4660: }}}}}}
4661: void op_ee00(UWORD opcode)
4662: {
4663: ULONG srcreg = 7;
4664: ULONG dstreg = (opcode & 7) >> 0;
4665: {{ ULONG cnt = srcreg;
4666: { BYTE data = regs.d[dstreg];
4667: { UBYTE val = data;
4668: cnt &= 63;
4669: regs.v = 0;
4670: { ULONG cmask = 0x80;
4671: ULONG sign = cmask & val;
4672: for(;cnt;--cnt){
4673: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
4674: }
4675: regs.n = sign != 0;
4676: regs.z = val == 0;
4677: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4678: }}}}}}
4679: void op_ee08(UWORD opcode)
4680: {
4681: ULONG srcreg = 7;
4682: ULONG dstreg = (opcode & 7) >> 0;
4683: {{ ULONG cnt = srcreg;
4684: { BYTE data = regs.d[dstreg];
4685: { UBYTE val = data;
4686: cnt &= 63;
4687: { int carry = 0;
4688: for(;cnt;--cnt){
4689: carry=val&1; val >>= 1;
4690: }
4691: regs.v = regs.c = 0;
4692: regs.z = ((BYTE)(val)) == 0;
4693: regs.n = ((BYTE)(val)) < 0;
4694: regs.c = regs.x = carry!=0;
4695: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4696: }}}}}}
4697: void op_ee10(UWORD opcode)
4698: {
4699: ULONG srcreg = 7;
4700: ULONG dstreg = (opcode & 7) >> 0;
4701: {{ ULONG cnt = srcreg;
4702: { BYTE data = regs.d[dstreg];
4703: { UBYTE val = data;
4704: cnt &= 63;
4705: { int carry = 0;
4706: ULONG cmask = 0x80;
4707: for(;cnt;--cnt){
4708: carry=val&1; val >>= 1;
4709: if(regs.x) val |= cmask;
4710: regs.x = carry != 0;
4711: }
4712: regs.v = regs.c = 0;
4713: regs.z = ((BYTE)(val)) == 0;
4714: regs.n = ((BYTE)(val)) < 0;
4715: regs.x = regs.c = carry!=0;
4716: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4717: }}}}}}
4718: void op_ee18(UWORD opcode)
4719: {
4720: ULONG srcreg = 7;
4721: ULONG dstreg = (opcode & 7) >> 0;
4722: {{ ULONG cnt = srcreg;
4723: { BYTE data = regs.d[dstreg];
4724: { UBYTE val = data;
4725: cnt &= 63;
4726: { int carry = 0;
4727: ULONG cmask = 0x80;
4728: for(;cnt;--cnt){
4729: carry=val&1; val = (ULONG)val >> 1;
4730: if(carry) val |= cmask;
4731: }
4732: regs.v = regs.c = 0;
4733: regs.z = ((BYTE)(val)) == 0;
4734: regs.n = ((BYTE)(val)) < 0;
4735: regs.c = carry!=0;
4736: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4737: }}}}}}
4738: void op_ee40(UWORD opcode)
4739: {
4740: ULONG srcreg = 7;
4741: ULONG dstreg = (opcode & 7) >> 0;
4742: {{ ULONG cnt = srcreg;
4743: { WORD data = regs.d[dstreg];
4744: { UWORD val = data;
4745: cnt &= 63;
4746: regs.v = 0;
4747: { ULONG cmask = 0x8000;
4748: ULONG sign = cmask & val;
4749: for(;cnt;--cnt){
4750: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
4751: }
4752: regs.n = sign != 0;
4753: regs.z = val == 0;
4754: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4755: }}}}}}
4756: void op_ee48(UWORD opcode)
4757: {
4758: ULONG srcreg = 7;
4759: ULONG dstreg = (opcode & 7) >> 0;
4760: {{ ULONG cnt = srcreg;
4761: { WORD data = regs.d[dstreg];
4762: { UWORD val = data;
4763: cnt &= 63;
4764: { int carry = 0;
4765: for(;cnt;--cnt){
4766: carry=val&1; val >>= 1;
4767: }
4768: regs.v = regs.c = 0;
4769: regs.z = ((WORD)(val)) == 0;
4770: regs.n = ((WORD)(val)) < 0;
4771: regs.c = regs.x = carry!=0;
4772: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4773: }}}}}}
4774: void op_ee50(UWORD opcode)
4775: {
4776: ULONG srcreg = 7;
4777: ULONG dstreg = (opcode & 7) >> 0;
4778: {{ ULONG cnt = srcreg;
4779: { WORD data = regs.d[dstreg];
4780: { UWORD val = data;
4781: cnt &= 63;
4782: { int carry = 0;
4783: ULONG cmask = 0x8000;
4784: for(;cnt;--cnt){
4785: carry=val&1; val >>= 1;
4786: if(regs.x) val |= cmask;
4787: regs.x = carry != 0;
4788: }
4789: regs.v = regs.c = 0;
4790: regs.z = ((WORD)(val)) == 0;
4791: regs.n = ((WORD)(val)) < 0;
4792: regs.x = regs.c = carry!=0;
4793: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4794: }}}}}}
4795: void op_ee58(UWORD opcode)
4796: {
4797: ULONG srcreg = 7;
4798: ULONG dstreg = (opcode & 7) >> 0;
4799: {{ ULONG cnt = srcreg;
4800: { WORD data = regs.d[dstreg];
4801: { UWORD val = data;
4802: cnt &= 63;
4803: { int carry = 0;
4804: ULONG cmask = 0x8000;
4805: for(;cnt;--cnt){
4806: carry=val&1; val = (ULONG)val >> 1;
4807: if(carry) val |= cmask;
4808: }
4809: regs.v = regs.c = 0;
4810: regs.z = ((WORD)(val)) == 0;
4811: regs.n = ((WORD)(val)) < 0;
4812: regs.c = carry!=0;
4813: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4814: }}}}}}
4815: void op_ee80(UWORD opcode)
4816: {
4817: ULONG srcreg = 7;
4818: ULONG dstreg = (opcode & 7) >> 0;
4819: {{ ULONG cnt = srcreg;
4820: { LONG data = regs.d[dstreg];
4821: { ULONG val = data;
4822: cnt &= 63;
4823: regs.v = 0;
4824: { ULONG cmask = 0x80000000;
4825: ULONG sign = cmask & val;
4826: for(;cnt;--cnt){
4827: regs.c=regs.x=val&1; val = ((ULONG)val >> 1) | sign;
4828: }
4829: regs.n = sign != 0;
4830: regs.z = val == 0;
4831: regs.d[dstreg] = (val);
4832: }}}}}}
4833: void op_ee88(UWORD opcode)
4834: {
4835: ULONG srcreg = 7;
4836: ULONG dstreg = (opcode & 7) >> 0;
4837: {{ ULONG cnt = srcreg;
4838: { LONG data = regs.d[dstreg];
4839: { ULONG val = data;
4840: cnt &= 63;
4841: { int carry = 0;
4842: for(;cnt;--cnt){
4843: carry=val&1; val >>= 1;
4844: }
4845: regs.v = regs.c = 0;
4846: regs.z = ((LONG)(val)) == 0;
4847: regs.n = ((LONG)(val)) < 0;
4848: regs.c = regs.x = carry!=0;
4849: regs.d[dstreg] = (val);
4850: }}}}}}
4851: void op_ee90(UWORD opcode)
4852: {
4853: ULONG srcreg = 7;
4854: ULONG dstreg = (opcode & 7) >> 0;
4855: {{ ULONG cnt = srcreg;
4856: { LONG data = regs.d[dstreg];
4857: { ULONG val = data;
4858: cnt &= 63;
4859: { int carry = 0;
4860: ULONG cmask = 0x80000000;
4861: for(;cnt;--cnt){
4862: carry=val&1; val >>= 1;
4863: if(regs.x) val |= cmask;
4864: regs.x = carry != 0;
4865: }
4866: regs.v = regs.c = 0;
4867: regs.z = ((LONG)(val)) == 0;
4868: regs.n = ((LONG)(val)) < 0;
4869: regs.x = regs.c = carry!=0;
4870: regs.d[dstreg] = (val);
4871: }}}}}}
4872: void op_ee98(UWORD opcode)
4873: {
4874: ULONG srcreg = 7;
4875: ULONG dstreg = (opcode & 7) >> 0;
4876: {{ ULONG cnt = srcreg;
4877: { LONG data = regs.d[dstreg];
4878: { ULONG val = data;
4879: cnt &= 63;
4880: { int carry = 0;
4881: ULONG cmask = 0x80000000;
4882: for(;cnt;--cnt){
4883: carry=val&1; val = (ULONG)val >> 1;
4884: if(carry) val |= cmask;
4885: }
4886: regs.v = regs.c = 0;
4887: regs.z = ((LONG)(val)) == 0;
4888: regs.n = ((LONG)(val)) < 0;
4889: regs.c = carry!=0;
4890: regs.d[dstreg] = (val);
4891: }}}}}}
4892: void op_ef00(UWORD opcode)
4893: {
4894: ULONG srcreg = 7;
4895: ULONG dstreg = (opcode & 7) >> 0;
4896: {{ ULONG cnt = srcreg;
4897: { BYTE data = regs.d[dstreg];
4898: { UBYTE val = data;
4899: cnt &= 63;
4900: regs.v = 0;
4901: { ULONG cmask = 0x80;
4902: ULONG sign = cmask & val;
4903: for(;cnt;--cnt){
4904: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
4905: if ((val&cmask)!=sign)regs.v=1;
4906: }
4907: regs.n = (val&cmask) != 0;
4908: regs.z = val == 0;
4909: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4910: }}}}}}
4911: void op_ef08(UWORD opcode)
4912: {
4913: ULONG srcreg = 7;
4914: ULONG dstreg = (opcode & 7) >> 0;
4915: {{ ULONG cnt = srcreg;
4916: { BYTE data = regs.d[dstreg];
4917: { UBYTE val = data;
4918: cnt &= 63;
4919: { int carry = 0;
4920: ULONG cmask = 0x80;
4921: for(;cnt;--cnt){
4922: carry=val&cmask; val <<= 1;
4923: }
4924: regs.v = regs.c = 0;
4925: regs.z = ((BYTE)(val)) == 0;
4926: regs.n = ((BYTE)(val)) < 0;
4927: regs.c = regs.x = carry!=0;
4928: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4929: }}}}}}
4930: void op_ef10(UWORD opcode)
4931: {
4932: ULONG srcreg = 7;
4933: ULONG dstreg = (opcode & 7) >> 0;
4934: {{ ULONG cnt = srcreg;
4935: { BYTE data = regs.d[dstreg];
4936: { UBYTE val = data;
4937: cnt &= 63;
4938: { int carry = 0;
4939: ULONG cmask = 0x80;
4940: for(;cnt;--cnt){
4941: carry=val&cmask; val <<= 1;
4942: if(regs.x) val |= 1;
4943: regs.x = carry != 0;
4944: }
4945: regs.v = regs.c = 0;
4946: regs.z = ((BYTE)(val)) == 0;
4947: regs.n = ((BYTE)(val)) < 0;
4948: regs.x = regs.c = carry!=0;
4949: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4950: }}}}}}
4951: void op_ef18(UWORD opcode)
4952: {
4953: ULONG srcreg = 7;
4954: ULONG dstreg = (opcode & 7) >> 0;
4955: {{ ULONG cnt = srcreg;
4956: { BYTE data = regs.d[dstreg];
4957: { UBYTE val = data;
4958: cnt &= 63;
4959: { int carry = 0;
4960: ULONG cmask = 0x80;
4961: for(;cnt;--cnt){
4962: carry=val&cmask; val <<= 1;
4963: if(carry) val |= 1;
4964: }
4965: regs.v = regs.c = 0;
4966: regs.z = ((BYTE)(val)) == 0;
4967: regs.n = ((BYTE)(val)) < 0;
4968: regs.c = carry!=0;
4969: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (val) & 0xff;
4970: }}}}}}
4971: void op_ef40(UWORD opcode)
4972: {
4973: ULONG srcreg = 7;
4974: ULONG dstreg = (opcode & 7) >> 0;
4975: {{ ULONG cnt = srcreg;
4976: { WORD data = regs.d[dstreg];
4977: { UWORD val = data;
4978: cnt &= 63;
4979: regs.v = 0;
4980: { ULONG cmask = 0x8000;
4981: ULONG sign = cmask & val;
4982: for(;cnt;--cnt){
4983: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
4984: if ((val&cmask)!=sign)regs.v=1;
4985: }
4986: regs.n = (val&cmask) != 0;
4987: regs.z = val == 0;
4988: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
4989: }}}}}}
4990: void op_ef48(UWORD opcode)
4991: {
4992: ULONG srcreg = 7;
4993: ULONG dstreg = (opcode & 7) >> 0;
4994: {{ ULONG cnt = srcreg;
4995: { WORD data = regs.d[dstreg];
4996: { UWORD val = data;
4997: cnt &= 63;
4998: { int carry = 0;
4999: ULONG cmask = 0x8000;
5000: for(;cnt;--cnt){
5001: carry=val&cmask; val <<= 1;
5002: }
5003: regs.v = regs.c = 0;
5004: regs.z = ((WORD)(val)) == 0;
5005: regs.n = ((WORD)(val)) < 0;
5006: regs.c = regs.x = carry!=0;
5007: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
5008: }}}}}}
5009: void op_ef50(UWORD opcode)
5010: {
5011: ULONG srcreg = 7;
5012: ULONG dstreg = (opcode & 7) >> 0;
5013: {{ ULONG cnt = srcreg;
5014: { WORD data = regs.d[dstreg];
5015: { UWORD val = data;
5016: cnt &= 63;
5017: { int carry = 0;
5018: ULONG cmask = 0x8000;
5019: for(;cnt;--cnt){
5020: carry=val&cmask; val <<= 1;
5021: if(regs.x) val |= 1;
5022: regs.x = carry != 0;
5023: }
5024: regs.v = regs.c = 0;
5025: regs.z = ((WORD)(val)) == 0;
5026: regs.n = ((WORD)(val)) < 0;
5027: regs.x = regs.c = carry!=0;
5028: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
5029: }}}}}}
5030: void op_ef58(UWORD opcode)
5031: {
5032: ULONG srcreg = 7;
5033: ULONG dstreg = (opcode & 7) >> 0;
5034: {{ ULONG cnt = srcreg;
5035: { WORD data = regs.d[dstreg];
5036: { UWORD val = data;
5037: cnt &= 63;
5038: { int carry = 0;
5039: ULONG cmask = 0x8000;
5040: for(;cnt;--cnt){
5041: carry=val&cmask; val <<= 1;
5042: if(carry) val |= 1;
5043: }
5044: regs.v = regs.c = 0;
5045: regs.z = ((WORD)(val)) == 0;
5046: regs.n = ((WORD)(val)) < 0;
5047: regs.c = carry!=0;
5048: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (val) & 0xffff;
5049: }}}}}}
5050: void op_ef80(UWORD opcode)
5051: {
5052: ULONG srcreg = 7;
5053: ULONG dstreg = (opcode & 7) >> 0;
5054: {{ ULONG cnt = srcreg;
5055: { LONG data = regs.d[dstreg];
5056: { ULONG val = data;
5057: cnt &= 63;
5058: regs.v = 0;
5059: { ULONG cmask = 0x80000000;
5060: ULONG sign = cmask & val;
5061: for(;cnt;--cnt){
5062: regs.c=regs.x=(val&cmask)!=0; val <<= 1;
5063: if ((val&cmask)!=sign)regs.v=1;
5064: }
5065: regs.n = (val&cmask) != 0;
5066: regs.z = val == 0;
5067: regs.d[dstreg] = (val);
5068: }}}}}}
5069: void op_ef88(UWORD opcode)
5070: {
5071: ULONG srcreg = 7;
5072: ULONG dstreg = (opcode & 7) >> 0;
5073: {{ ULONG cnt = srcreg;
5074: { LONG data = regs.d[dstreg];
5075: { ULONG val = data;
5076: cnt &= 63;
5077: { int carry = 0;
5078: ULONG cmask = 0x80000000;
5079: for(;cnt;--cnt){
5080: carry=val&cmask; val <<= 1;
5081: }
5082: regs.v = regs.c = 0;
5083: regs.z = ((LONG)(val)) == 0;
5084: regs.n = ((LONG)(val)) < 0;
5085: regs.c = regs.x = carry!=0;
5086: regs.d[dstreg] = (val);
5087: }}}}}}
5088: void op_ef90(UWORD opcode)
5089: {
5090: ULONG srcreg = 7;
5091: ULONG dstreg = (opcode & 7) >> 0;
5092: {{ ULONG cnt = srcreg;
5093: { LONG data = regs.d[dstreg];
5094: { ULONG val = data;
5095: cnt &= 63;
5096: { int carry = 0;
5097: ULONG cmask = 0x80000000;
5098: for(;cnt;--cnt){
5099: carry=val&cmask; val <<= 1;
5100: if(regs.x) val |= 1;
5101: regs.x = carry != 0;
5102: }
5103: regs.v = regs.c = 0;
5104: regs.z = ((LONG)(val)) == 0;
5105: regs.n = ((LONG)(val)) < 0;
5106: regs.x = regs.c = carry!=0;
5107: regs.d[dstreg] = (val);
5108: }}}}}}
5109: void op_ef98(UWORD opcode)
5110: {
5111: ULONG srcreg = 7;
5112: ULONG dstreg = (opcode & 7) >> 0;
5113: {{ ULONG cnt = srcreg;
5114: { LONG data = regs.d[dstreg];
5115: { ULONG val = data;
5116: cnt &= 63;
5117: { int carry = 0;
5118: ULONG cmask = 0x80000000;
5119: for(;cnt;--cnt){
5120: carry=val&cmask; val <<= 1;
5121: if(carry) val |= 1;
5122: }
5123: regs.v = regs.c = 0;
5124: regs.z = ((LONG)(val)) == 0;
5125: regs.n = ((LONG)(val)) < 0;
5126: regs.c = carry!=0;
5127: regs.d[dstreg] = (val);
5128: }}}}}}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.