CoCalc -- uop.cpp

GitHub Repository: alexbevi/BizHawk
Path: blob/master/libsnes/bsnes/snes/smp/core/uop.cpp
² views
1
const int uoptable[256][16] = {
2

3
//   case 0x00: return op_nop();
4
//   void SMPcore::op_nop() {
5
{
6
  1, // op_io();
7
  2, // //!!NEXT
8
},
9
//   case 0x01: return op_jst();
10
//   void SMPcore::op_jst() {
11
{
12
  3, // dp = 0xffde - ((opcode >> 4) << 1);
13
  4, // rd.l = op_read(dp++);
14
  5, // rd.h = op_read(dp++);
15
  1, // op_io();
16
  1, // op_io();
17
  1, // op_io();
18
  6, // op_writesp(regs.pc.h);
19
  7, // op_writesp(regs.pc.l);
20
  8, // regs.pc = rd;
21
  2, // //!!NEXT
22
},
23
//   case 0x02: return op_set_bit();
24
//   void SMPcore::op_set_bit() {
25
{
26
  9, // dp = op_readpc();
27
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
28
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
29
  2, // //!!NEXT
30
},
31
//   case 0x03: return op_branch_bit();
32
//   void SMPcore::op_branch_bit() {
33
{
34
  9, // dp = op_readpc();
35
  12, // sp = op_readdp(dp);
36
  13, // rd = op_readpc();
37
  1, // op_io();
38
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
39
  1, // op_io();
40
  1, // op_io();
41
  15, // regs.pc += (int8)rd;
42
  2, // //!!NEXT
43
},
44
//   case 0x04: return op_read_dp<&SMPcore::op_or>(regs.a);
45
//   void SMPcore::op_read_dp(uint8 &r) {
46
{
47
  9, // dp = op_readpc();
48
  16, // rd = op_readdp(dp);
49
  17, // regs.a = op_or(regs.a, rd);
50
  2, // //!!NEXT
51
},
52
//   case 0x05: return op_read_addr<&SMPcore::op_or>(regs.a);
53
//   void SMPcore::op_read_addr(uint8 &r) {
54
{
55
  18, // dp.l = op_readpc();
56
  19, // dp.h = op_readpc();
57
  20, // rd = op_read(dp);
58
  17, // regs.a = op_or(regs.a, rd);
59
  2, // //!!NEXT
60
},
61
//   case 0x06: return op_read_ix<&SMPcore::op_or>();
62
//   void SMPcore::op_read_ix() {
63
{
64
  1, // op_io();
65
  21, // rd = op_readdp(regs.x);
66
  17, // regs.a = op_or(regs.a, rd);
67
  2, // //!!NEXT
68
},
69
//   case 0x07: return op_read_idpx<&SMPcore::op_or>();
70
//   void SMPcore::op_read_idpx() {
71
{
72
  22, // dp = op_readpc() + regs.x;
73
  1, // op_io();
74
  23, // sp.l = op_readdp(dp++);
75
  24, // sp.h = op_readdp(dp++);
76
  25, // rd = op_read(sp);
77
  17, // regs.a = op_or(regs.a, rd);
78
  2, // //!!NEXT
79
},
80
//   case 0x08: return op_read_const<&SMPcore::op_or>(regs.a);
81
//   void SMPcore::op_read_const(uint8 &r) {
82
{
83
  13, // rd = op_readpc();
84
  17, // regs.a = op_or(regs.a, rd);
85
  2, // //!!NEXT
86
},
87
//   case 0x09: return op_write_dp_dp<&SMPcore::op_or>();
88
//   void SMPcore::op_write_dp_dp() {
89
{
90
  26, // sp = op_readpc();
91
  27, // rd = op_readdp(sp);
92
  9, // dp = op_readpc();
93
  28, // wr = op_readdp(dp);
94
  29, // wr = op_or(wr, rd);
95
  30, // op_writedp(dp, wr);
96
  2, // //!!NEXT
97
},
98
//   case 0x0a: return op_set_addr_bit();
99
//   void SMPcore::op_set_addr_bit() {
100
{
101
  18, // dp.l = op_readpc();
102
  19, // dp.h = op_readpc();
103
  31, // bit = dp >> 13;
104
  32, // dp &= 0x1fff;
105
  20, // rd = op_read(dp);
106
  1, // op_io();
107
  33, // regs.p.c |= (rd & (1 << bit)) ^ 0;
108
  2, // //!!NEXT
109
},
110
//   case 0x0b: return op_adjust_dp<&SMPcore::op_asl>();
111
//   void SMPcore::op_adjust_dp() {
112
{
113
  9, // dp = op_readpc();
114
  16, // rd = op_readdp(dp);
115
  34, // rd = op_asl(rd);
116
  35, // op_writedp(dp, rd);
117
  2, // //!!NEXT
118
},
119
//   case 0x0c: return op_adjust_addr<&SMPcore::op_asl>();
120
//   void SMPcore::op_adjust_addr() {
121
{
122
  18, // dp.l = op_readpc();
123
  19, // dp.h = op_readpc();
124
  20, // rd = op_read(dp);
125
  34, // rd = op_asl(rd);
126
  36, // op_write(dp, rd);
127
  2, // //!!NEXT
128
},
129
//   case 0x0d: return op_push(regs.p);
130
//   void SMPcore::op_push(uint8 r) {
131
{
132
  1, // op_io();
133
  1, // op_io();
134
  37, // op_writesp(regs.p);
135
  2, // //!!NEXT
136
},
137
//   case 0x0e: return op_test_addr(1);
138
//   void SMPcore::op_test_addr(bool set) {
139
{
140
  18, // dp.l = op_readpc();
141
  19, // dp.h = op_readpc();
142
  20, // rd = op_read(dp);
143
  38, // regs.p.n = (regs.a - rd) & 0x80;
144
  39, // regs.p.z = (regs.a - rd) == 0;
145
  40, // op_read(dp);
146
  41, // op_write(dp, rd | regs.a);
147
  2, // //!!NEXT
148
},
149
//   case 0x0f: return op_brk();
150
//   void SMPcore::op_brk() {
151
{
152
  42, // rd.l = op_read(0xffde);
153
  43, // rd.h = op_read(0xffdf);
154
  1, // op_io();
155
  1, // op_io();
156
  6, // op_writesp(regs.pc.h);
157
  7, // op_writesp(regs.pc.l);
158
  37, // op_writesp(regs.p);
159
  8, // regs.pc = rd;
160
  44, // regs.p.b = 1;
161
  45, // regs.p.i = 0;
162
  2, // //!!NEXT
163
},
164
//   case 0x10: return op_branch(regs.p.n == 0);
165
//   void SMPcore::op_branch(bool condition) {
166
{
167
  13, // rd = op_readpc();
168
  46, // if(regs.p.n != 0) return;
169
  1, // op_io();
170
  1, // op_io();
171
  15, // regs.pc += (int8)rd;
172
  2, // //!!NEXT
173
},
174
//   case 0x11: return op_jst();
175
//   void SMPcore::op_jst() {
176
{
177
  3, // dp = 0xffde - ((opcode >> 4) << 1);
178
  4, // rd.l = op_read(dp++);
179
  5, // rd.h = op_read(dp++);
180
  1, // op_io();
181
  1, // op_io();
182
  1, // op_io();
183
  6, // op_writesp(regs.pc.h);
184
  7, // op_writesp(regs.pc.l);
185
  8, // regs.pc = rd;
186
  2, // //!!NEXT
187
},
188
//   case 0x12: return op_set_bit();
189
//   void SMPcore::op_set_bit() {
190
{
191
  9, // dp = op_readpc();
192
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
193
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
194
  2, // //!!NEXT
195
},
196
//   case 0x13: return op_branch_bit();
197
//   void SMPcore::op_branch_bit() {
198
{
199
  9, // dp = op_readpc();
200
  12, // sp = op_readdp(dp);
201
  13, // rd = op_readpc();
202
  1, // op_io();
203
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
204
  1, // op_io();
205
  1, // op_io();
206
  15, // regs.pc += (int8)rd;
207
  2, // //!!NEXT
208
},
209
//   case 0x14: return op_read_dpi<&SMPcore::op_or>(regs.a, regs.x);
210
//   void SMPcore::op_read_dpi(uint8 &r, uint8 &i) {
211
{
212
  9, // dp = op_readpc();
213
  1, // op_io();
214
  47, // rd = op_readdp(dp + regs.x);
215
  17, // regs.a = op_or(regs.a, rd);
216
  2, // //!!NEXT
217
},
218
//   case 0x15: return op_read_addri<&SMPcore::op_or>(regs.x);
219
//   void SMPcore::op_read_addri(uint8 &r) {
220
{
221
  18, // dp.l = op_readpc();
222
  19, // dp.h = op_readpc();
223
  1, // op_io();
224
  48, // rd = op_read(dp + regs.x);
225
  17, // regs.a = op_or(regs.a, rd);
226
  2, // //!!NEXT
227
},
228
//   case 0x16: return op_read_addri<&SMPcore::op_or>(regs.y);
229
//   void SMPcore::op_read_addri(uint8 &r) {
230
{
231
  18, // dp.l = op_readpc();
232
  19, // dp.h = op_readpc();
233
  1, // op_io();
234
  49, // rd = op_read(dp + regs.y);
235
  17, // regs.a = op_or(regs.a, rd);
236
  2, // //!!NEXT
237
},
238
//   case 0x17: return op_read_idpy<&SMPcore::op_or>();
239
//   void SMPcore::op_read_idpy() {
240
{
241
  9, // dp = op_readpc();
242
  1, // op_io();
243
  23, // sp.l = op_readdp(dp++);
244
  24, // sp.h = op_readdp(dp++);
245
  50, // rd = op_read(sp + regs.y);
246
  17, // regs.a = op_or(regs.a, rd);
247
  2, // //!!NEXT
248
},
249
//   case 0x18: return op_write_dp_const<&SMPcore::op_or>();
250
//   void SMPcore::op_write_dp_const() {
251
{
252
  13, // rd = op_readpc();
253
  9, // dp = op_readpc();
254
  28, // wr = op_readdp(dp);
255
  29, // wr = op_or(wr, rd);
256
  30, // op_writedp(dp, wr);
257
  2, // //!!NEXT
258
},
259
//   case 0x19: return op_write_ix_iy<&SMPcore::op_or>();
260
//   void SMPcore::op_write_ix_iy() {
261
{
262
  1, // op_io();
263
  51, // rd = op_readdp(regs.y);
264
  52, // wr = op_readdp(regs.x);
265
  29, // wr = op_or(wr, rd);
266
  53, // op_writedp(regs.x, wr);
267
  2, // //!!NEXT
268
},
269
//   case 0x1a: return op_adjust_dpw(-1);
270
//   void SMPcore::op_adjust_dpw(signed n) {
271
{
272
  9, // dp = op_readpc();
273
  54, // rd.w = op_readdp(dp) - 1;
274
  55, // op_writedp(dp++, rd.l);
275
  56, // rd.h += op_readdp(dp);
276
  57, // op_writedp(dp++, rd.h);
277
  58, // regs.p.n = rd & 0x8000;
278
  59, // regs.p.z = rd == 0;
279
  2, // //!!NEXT
280
},
281
//   case 0x1b: return op_adjust_dpx<&SMPcore::op_asl>();
282
//   void SMPcore::op_adjust_dpx() {
283
{
284
  9, // dp = op_readpc();
285
  1, // op_io();
286
  47, // rd = op_readdp(dp + regs.x);
287
  34, // rd = op_asl(rd);
288
  60, // op_writedp(dp + regs.x, rd);
289
  2, // //!!NEXT
290
},
291
//   case 0x1c: return op_adjust<&SMPcore::op_asl>(regs.a);
292
//   void SMPcore::op_adjust(uint8 &r) {
293
{
294
  1, // op_io();
295
  61, // regs.a = op_asl(regs.a);
296
  2, // //!!NEXT
297
},
298
//   case 0x1d: return op_adjust<&SMPcore::op_dec>(regs.x);
299
//   void SMPcore::op_adjust(uint8 &r) {
300
{
301
  1, // op_io();
302
  62, // regs.x = op_dec(regs.x);
303
  2, // //!!NEXT
304
},
305
//   case 0x1e: return op_read_addr<&SMPcore::op_cmp>(regs.x);
306
//   void SMPcore::op_read_addr(uint8 &r) {
307
{
308
  18, // dp.l = op_readpc();
309
  19, // dp.h = op_readpc();
310
  20, // rd = op_read(dp);
311
  63, // regs.x = op_cmp(regs.x, rd);
312
  2, // //!!NEXT
313
},
314
//   case 0x1f: return op_jmp_iaddrx();
315
//   void SMPcore::op_jmp_iaddrx() {
316
{
317
  18, // dp.l = op_readpc();
318
  19, // dp.h = op_readpc();
319
  1, // op_io();
320
  64, // dp += regs.x;
321
  4, // rd.l = op_read(dp++);
322
  5, // rd.h = op_read(dp++);
323
  8, // regs.pc = rd;
324
  2, // //!!NEXT
325
},
326
//   case 0x20: return op_set_flag(regs.p.p, 0);
327
//   void SMPcore::op_set_flag(bool &flag, bool data) {
328
{
329
  1, // op_io();
330
  65, // regs.p.p = 0;
331
  2, // //!!NEXT
332
},
333
//   case 0x21: return op_jst();
334
//   void SMPcore::op_jst() {
335
{
336
  3, // dp = 0xffde - ((opcode >> 4) << 1);
337
  4, // rd.l = op_read(dp++);
338
  5, // rd.h = op_read(dp++);
339
  1, // op_io();
340
  1, // op_io();
341
  1, // op_io();
342
  6, // op_writesp(regs.pc.h);
343
  7, // op_writesp(regs.pc.l);
344
  8, // regs.pc = rd;
345
  2, // //!!NEXT
346
},
347
//   case 0x22: return op_set_bit();
348
//   void SMPcore::op_set_bit() {
349
{
350
  9, // dp = op_readpc();
351
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
352
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
353
  2, // //!!NEXT
354
},
355
//   case 0x23: return op_branch_bit();
356
//   void SMPcore::op_branch_bit() {
357
{
358
  9, // dp = op_readpc();
359
  12, // sp = op_readdp(dp);
360
  13, // rd = op_readpc();
361
  1, // op_io();
362
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
363
  1, // op_io();
364
  1, // op_io();
365
  15, // regs.pc += (int8)rd;
366
  2, // //!!NEXT
367
},
368
//   case 0x24: return op_read_dp<&SMPcore::op_and>(regs.a);
369
//   void SMPcore::op_read_dp(uint8 &r) {
370
{
371
  9, // dp = op_readpc();
372
  16, // rd = op_readdp(dp);
373
  66, // regs.a = op_and(regs.a, rd);
374
  2, // //!!NEXT
375
},
376
//   case 0x25: return op_read_addr<&SMPcore::op_and>(regs.a);
377
//   void SMPcore::op_read_addr(uint8 &r) {
378
{
379
  18, // dp.l = op_readpc();
380
  19, // dp.h = op_readpc();
381
  20, // rd = op_read(dp);
382
  66, // regs.a = op_and(regs.a, rd);
383
  2, // //!!NEXT
384
},
385
//   case 0x26: return op_read_ix<&SMPcore::op_and>();
386
//   void SMPcore::op_read_ix() {
387
{
388
  1, // op_io();
389
  21, // rd = op_readdp(regs.x);
390
  66, // regs.a = op_and(regs.a, rd);
391
  2, // //!!NEXT
392
},
393
//   case 0x27: return op_read_idpx<&SMPcore::op_and>();
394
//   void SMPcore::op_read_idpx() {
395
{
396
  22, // dp = op_readpc() + regs.x;
397
  1, // op_io();
398
  23, // sp.l = op_readdp(dp++);
399
  24, // sp.h = op_readdp(dp++);
400
  25, // rd = op_read(sp);
401
  66, // regs.a = op_and(regs.a, rd);
402
  2, // //!!NEXT
403
},
404
//   case 0x28: return op_read_const<&SMPcore::op_and>(regs.a);
405
//   void SMPcore::op_read_const(uint8 &r) {
406
{
407
  13, // rd = op_readpc();
408
  66, // regs.a = op_and(regs.a, rd);
409
  2, // //!!NEXT
410
},
411
//   case 0x29: return op_write_dp_dp<&SMPcore::op_and>();
412
//   void SMPcore::op_write_dp_dp() {
413
{
414
  26, // sp = op_readpc();
415
  27, // rd = op_readdp(sp);
416
  9, // dp = op_readpc();
417
  28, // wr = op_readdp(dp);
418
  67, // wr = op_and(wr, rd);
419
  30, // op_writedp(dp, wr);
420
  2, // //!!NEXT
421
},
422
//   case 0x2a: return op_set_addr_bit();
423
//   void SMPcore::op_set_addr_bit() {
424
{
425
  18, // dp.l = op_readpc();
426
  19, // dp.h = op_readpc();
427
  31, // bit = dp >> 13;
428
  32, // dp &= 0x1fff;
429
  20, // rd = op_read(dp);
430
  1, // op_io();
431
  68, // regs.p.c |= (rd & (1 << bit)) ^ 1;
432
  2, // //!!NEXT
433
},
434
//   case 0x2b: return op_adjust_dp<&SMPcore::op_rol>();
435
//   void SMPcore::op_adjust_dp() {
436
{
437
  9, // dp = op_readpc();
438
  16, // rd = op_readdp(dp);
439
  69, // rd = op_rol(rd);
440
  35, // op_writedp(dp, rd);
441
  2, // //!!NEXT
442
},
443
//   case 0x2c: return op_adjust_addr<&SMPcore::op_rol>();
444
//   void SMPcore::op_adjust_addr() {
445
{
446
  18, // dp.l = op_readpc();
447
  19, // dp.h = op_readpc();
448
  20, // rd = op_read(dp);
449
  69, // rd = op_rol(rd);
450
  36, // op_write(dp, rd);
451
  2, // //!!NEXT
452
},
453
//   case 0x2d: return op_push(regs.a);
454
//   void SMPcore::op_push(uint8 r) {
455
{
456
  1, // op_io();
457
  1, // op_io();
458
  70, // op_writesp(regs.a);
459
  2, // //!!NEXT
460
},
461
//   case 0x2e: return op_bne_dp();
462
//   void SMPcore::op_bne_dp() {
463
{
464
  9, // dp = op_readpc();
465
  12, // sp = op_readdp(dp);
466
  13, // rd = op_readpc();
467
  1, // op_io();
468
  71, // if(regs.a == sp) return;
469
  1, // op_io();
470
  1, // op_io();
471
  15, // regs.pc += (int8)rd;
472
  2, // //!!NEXT
473
},
474
//   case 0x2f: return op_branch(true);
475
//   void SMPcore::op_branch(bool condition) {
476
{
477
  13, // rd = op_readpc();
478
  1, // op_io();
479
  1, // op_io();
480
  15, // regs.pc += (int8)rd;
481
  2, // //!!NEXT
482
},
483
//   case 0x30: return op_branch(regs.p.n == 1);
484
//   void SMPcore::op_branch(bool condition) {
485
{
486
  13, // rd = op_readpc();
487
  72, // if(regs.p.n != 1) return;
488
  1, // op_io();
489
  1, // op_io();
490
  15, // regs.pc += (int8)rd;
491
  2, // //!!NEXT
492
},
493
//   case 0x31: return op_jst();
494
//   void SMPcore::op_jst() {
495
{
496
  3, // dp = 0xffde - ((opcode >> 4) << 1);
497
  4, // rd.l = op_read(dp++);
498
  5, // rd.h = op_read(dp++);
499
  1, // op_io();
500
  1, // op_io();
501
  1, // op_io();
502
  6, // op_writesp(regs.pc.h);
503
  7, // op_writesp(regs.pc.l);
504
  8, // regs.pc = rd;
505
  2, // //!!NEXT
506
},
507
//   case 0x32: return op_set_bit();
508
//   void SMPcore::op_set_bit() {
509
{
510
  9, // dp = op_readpc();
511
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
512
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
513
  2, // //!!NEXT
514
},
515
//   case 0x33: return op_branch_bit();
516
//   void SMPcore::op_branch_bit() {
517
{
518
  9, // dp = op_readpc();
519
  12, // sp = op_readdp(dp);
520
  13, // rd = op_readpc();
521
  1, // op_io();
522
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
523
  1, // op_io();
524
  1, // op_io();
525
  15, // regs.pc += (int8)rd;
526
  2, // //!!NEXT
527
},
528
//   case 0x34: return op_read_dpi<&SMPcore::op_and>(regs.a, regs.x);
529
//   void SMPcore::op_read_dpi(uint8 &r, uint8 &i) {
530
{
531
  9, // dp = op_readpc();
532
  1, // op_io();
533
  47, // rd = op_readdp(dp + regs.x);
534
  66, // regs.a = op_and(regs.a, rd);
535
  2, // //!!NEXT
536
},
537
//   case 0x35: return op_read_addri<&SMPcore::op_and>(regs.x);
538
//   void SMPcore::op_read_addri(uint8 &r) {
539
{
540
  18, // dp.l = op_readpc();
541
  19, // dp.h = op_readpc();
542
  1, // op_io();
543
  48, // rd = op_read(dp + regs.x);
544
  66, // regs.a = op_and(regs.a, rd);
545
  2, // //!!NEXT
546
},
547
//   case 0x36: return op_read_addri<&SMPcore::op_and>(regs.y);
548
//   void SMPcore::op_read_addri(uint8 &r) {
549
{
550
  18, // dp.l = op_readpc();
551
  19, // dp.h = op_readpc();
552
  1, // op_io();
553
  49, // rd = op_read(dp + regs.y);
554
  66, // regs.a = op_and(regs.a, rd);
555
  2, // //!!NEXT
556
},
557
//   case 0x37: return op_read_idpy<&SMPcore::op_and>();
558
//   void SMPcore::op_read_idpy() {
559
{
560
  9, // dp = op_readpc();
561
  1, // op_io();
562
  23, // sp.l = op_readdp(dp++);
563
  24, // sp.h = op_readdp(dp++);
564
  50, // rd = op_read(sp + regs.y);
565
  66, // regs.a = op_and(regs.a, rd);
566
  2, // //!!NEXT
567
},
568
//   case 0x38: return op_write_dp_const<&SMPcore::op_and>();
569
//   void SMPcore::op_write_dp_const() {
570
{
571
  13, // rd = op_readpc();
572
  9, // dp = op_readpc();
573
  28, // wr = op_readdp(dp);
574
  67, // wr = op_and(wr, rd);
575
  30, // op_writedp(dp, wr);
576
  2, // //!!NEXT
577
},
578
//   case 0x39: return op_write_ix_iy<&SMPcore::op_and>();
579
//   void SMPcore::op_write_ix_iy() {
580
{
581
  1, // op_io();
582
  51, // rd = op_readdp(regs.y);
583
  52, // wr = op_readdp(regs.x);
584
  67, // wr = op_and(wr, rd);
585
  53, // op_writedp(regs.x, wr);
586
  2, // //!!NEXT
587
},
588
//   case 0x3a: return op_adjust_dpw(+1);
589
//   void SMPcore::op_adjust_dpw(signed n) {
590
{
591
  9, // dp = op_readpc();
592
  73, // rd.w = op_readdp(dp) + 1;
593
  55, // op_writedp(dp++, rd.l);
594
  56, // rd.h += op_readdp(dp);
595
  57, // op_writedp(dp++, rd.h);
596
  58, // regs.p.n = rd & 0x8000;
597
  59, // regs.p.z = rd == 0;
598
  2, // //!!NEXT
599
},
600
//   case 0x3b: return op_adjust_dpx<&SMPcore::op_rol>();
601
//   void SMPcore::op_adjust_dpx() {
602
{
603
  9, // dp = op_readpc();
604
  1, // op_io();
605
  47, // rd = op_readdp(dp + regs.x);
606
  69, // rd = op_rol(rd);
607
  60, // op_writedp(dp + regs.x, rd);
608
  2, // //!!NEXT
609
},
610
//   case 0x3c: return op_adjust<&SMPcore::op_rol>(regs.a);
611
//   void SMPcore::op_adjust(uint8 &r) {
612
{
613
  1, // op_io();
614
  74, // regs.a = op_rol(regs.a);
615
  2, // //!!NEXT
616
},
617
//   case 0x3d: return op_adjust<&SMPcore::op_inc>(regs.x);
618
//   void SMPcore::op_adjust(uint8 &r) {
619
{
620
  1, // op_io();
621
  75, // regs.x = op_inc(regs.x);
622
  2, // //!!NEXT
623
},
624
//   case 0x3e: return op_read_dp<&SMPcore::op_cmp>(regs.x);
625
//   void SMPcore::op_read_dp(uint8 &r) {
626
{
627
  9, // dp = op_readpc();
628
  16, // rd = op_readdp(dp);
629
  63, // regs.x = op_cmp(regs.x, rd);
630
  2, // //!!NEXT
631
},
632
//   case 0x3f: return op_jsr_addr();
633
//   void SMPcore::op_jsr_addr() {
634
{
635
  76, // rd.l = op_readpc();
636
  77, // rd.h = op_readpc();
637
  1, // op_io();
638
  1, // op_io();
639
  1, // op_io();
640
  6, // op_writesp(regs.pc.h);
641
  7, // op_writesp(regs.pc.l);
642
  8, // regs.pc = rd;
643
  2, // //!!NEXT
644
},
645
//   case 0x40: return op_set_flag(regs.p.p, 1);
646
//   void SMPcore::op_set_flag(bool &flag, bool data) {
647
{
648
  1, // op_io();
649
  78, // regs.p.p = 1;
650
  2, // //!!NEXT
651
},
652
//   case 0x41: return op_jst();
653
//   void SMPcore::op_jst() {
654
{
655
  3, // dp = 0xffde - ((opcode >> 4) << 1);
656
  4, // rd.l = op_read(dp++);
657
  5, // rd.h = op_read(dp++);
658
  1, // op_io();
659
  1, // op_io();
660
  1, // op_io();
661
  6, // op_writesp(regs.pc.h);
662
  7, // op_writesp(regs.pc.l);
663
  8, // regs.pc = rd;
664
  2, // //!!NEXT
665
},
666
//   case 0x42: return op_set_bit();
667
//   void SMPcore::op_set_bit() {
668
{
669
  9, // dp = op_readpc();
670
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
671
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
672
  2, // //!!NEXT
673
},
674
//   case 0x43: return op_branch_bit();
675
//   void SMPcore::op_branch_bit() {
676
{
677
  9, // dp = op_readpc();
678
  12, // sp = op_readdp(dp);
679
  13, // rd = op_readpc();
680
  1, // op_io();
681
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
682
  1, // op_io();
683
  1, // op_io();
684
  15, // regs.pc += (int8)rd;
685
  2, // //!!NEXT
686
},
687
//   case 0x44: return op_read_dp<&SMPcore::op_eor>(regs.a);
688
//   void SMPcore::op_read_dp(uint8 &r) {
689
{
690
  9, // dp = op_readpc();
691
  16, // rd = op_readdp(dp);
692
  79, // regs.a = op_eor(regs.a, rd);
693
  2, // //!!NEXT
694
},
695
//   case 0x45: return op_read_addr<&SMPcore::op_eor>(regs.a);
696
//   void SMPcore::op_read_addr(uint8 &r) {
697
{
698
  18, // dp.l = op_readpc();
699
  19, // dp.h = op_readpc();
700
  20, // rd = op_read(dp);
701
  79, // regs.a = op_eor(regs.a, rd);
702
  2, // //!!NEXT
703
},
704
//   case 0x46: return op_read_ix<&SMPcore::op_eor>();
705
//   void SMPcore::op_read_ix() {
706
{
707
  1, // op_io();
708
  21, // rd = op_readdp(regs.x);
709
  79, // regs.a = op_eor(regs.a, rd);
710
  2, // //!!NEXT
711
},
712
//   case 0x47: return op_read_idpx<&SMPcore::op_eor>();
713
//   void SMPcore::op_read_idpx() {
714
{
715
  22, // dp = op_readpc() + regs.x;
716
  1, // op_io();
717
  23, // sp.l = op_readdp(dp++);
718
  24, // sp.h = op_readdp(dp++);
719
  25, // rd = op_read(sp);
720
  79, // regs.a = op_eor(regs.a, rd);
721
  2, // //!!NEXT
722
},
723
//   case 0x48: return op_read_const<&SMPcore::op_eor>(regs.a);
724
//   void SMPcore::op_read_const(uint8 &r) {
725
{
726
  13, // rd = op_readpc();
727
  79, // regs.a = op_eor(regs.a, rd);
728
  2, // //!!NEXT
729
},
730
//   case 0x49: return op_write_dp_dp<&SMPcore::op_eor>();
731
//   void SMPcore::op_write_dp_dp() {
732
{
733
  26, // sp = op_readpc();
734
  27, // rd = op_readdp(sp);
735
  9, // dp = op_readpc();
736
  28, // wr = op_readdp(dp);
737
  80, // wr = op_eor(wr, rd);
738
  30, // op_writedp(dp, wr);
739
  2, // //!!NEXT
740
},
741
//   case 0x4a: return op_set_addr_bit();
742
//   void SMPcore::op_set_addr_bit() {
743
{
744
  18, // dp.l = op_readpc();
745
  19, // dp.h = op_readpc();
746
  31, // bit = dp >> 13;
747
  32, // dp &= 0x1fff;
748
  20, // rd = op_read(dp);
749
  81, // regs.p.c &= (rd & (1 << bit)) ^ 0;
750
  2, // //!!NEXT
751
},
752
//   case 0x4b: return op_adjust_dp<&SMPcore::op_lsr>();
753
//   void SMPcore::op_adjust_dp() {
754
{
755
  9, // dp = op_readpc();
756
  16, // rd = op_readdp(dp);
757
  82, // rd = op_lsr(rd);
758
  35, // op_writedp(dp, rd);
759
  2, // //!!NEXT
760
},
761
//   case 0x4c: return op_adjust_addr<&SMPcore::op_lsr>();
762
//   void SMPcore::op_adjust_addr() {
763
{
764
  18, // dp.l = op_readpc();
765
  19, // dp.h = op_readpc();
766
  20, // rd = op_read(dp);
767
  82, // rd = op_lsr(rd);
768
  36, // op_write(dp, rd);
769
  2, // //!!NEXT
770
},
771
//   case 0x4d: return op_push(regs.x);
772
//   void SMPcore::op_push(uint8 r) {
773
{
774
  1, // op_io();
775
  1, // op_io();
776
  83, // op_writesp(regs.x);
777
  2, // //!!NEXT
778
},
779
//   case 0x4e: return op_test_addr(0);
780
//   void SMPcore::op_test_addr(bool set) {
781
{
782
  18, // dp.l = op_readpc();
783
  19, // dp.h = op_readpc();
784
  20, // rd = op_read(dp);
785
  38, // regs.p.n = (regs.a - rd) & 0x80;
786
  39, // regs.p.z = (regs.a - rd) == 0;
787
  40, // op_read(dp);
788
  84, // op_write(dp, rd & ~regs.a);
789
  2, // //!!NEXT
790
},
791
//   case 0x4f: return op_jsp_dp();
792
//   void SMPcore::op_jsp_dp() {
793
{
794
  13, // rd = op_readpc();
795
  1, // op_io();
796
  1, // op_io();
797
  6, // op_writesp(regs.pc.h);
798
  7, // op_writesp(regs.pc.l);
799
  85, // regs.pc = 0xff00 | rd;
800
  2, // //!!NEXT
801
},
802
//   case 0x50: return op_branch(regs.p.v == 0);
803
//   void SMPcore::op_branch(bool condition) {
804
{
805
  13, // rd = op_readpc();
806
  86, // if(regs.p.v != 0) return;
807
  1, // op_io();
808
  1, // op_io();
809
  15, // regs.pc += (int8)rd;
810
  2, // //!!NEXT
811
},
812
//   case 0x51: return op_jst();
813
//   void SMPcore::op_jst() {
814
{
815
  3, // dp = 0xffde - ((opcode >> 4) << 1);
816
  4, // rd.l = op_read(dp++);
817
  5, // rd.h = op_read(dp++);
818
  1, // op_io();
819
  1, // op_io();
820
  1, // op_io();
821
  6, // op_writesp(regs.pc.h);
822
  7, // op_writesp(regs.pc.l);
823
  8, // regs.pc = rd;
824
  2, // //!!NEXT
825
},
826
//   case 0x52: return op_set_bit();
827
//   void SMPcore::op_set_bit() {
828
{
829
  9, // dp = op_readpc();
830
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
831
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
832
  2, // //!!NEXT
833
},
834
//   case 0x53: return op_branch_bit();
835
//   void SMPcore::op_branch_bit() {
836
{
837
  9, // dp = op_readpc();
838
  12, // sp = op_readdp(dp);
839
  13, // rd = op_readpc();
840
  1, // op_io();
841
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
842
  1, // op_io();
843
  1, // op_io();
844
  15, // regs.pc += (int8)rd;
845
  2, // //!!NEXT
846
},
847
//   case 0x54: return op_read_dpi<&SMPcore::op_eor>(regs.a, regs.x);
848
//   void SMPcore::op_read_dpi(uint8 &r, uint8 &i) {
849
{
850
  9, // dp = op_readpc();
851
  1, // op_io();
852
  47, // rd = op_readdp(dp + regs.x);
853
  79, // regs.a = op_eor(regs.a, rd);
854
  2, // //!!NEXT
855
},
856
//   case 0x55: return op_read_addri<&SMPcore::op_eor>(regs.x);
857
//   void SMPcore::op_read_addri(uint8 &r) {
858
{
859
  18, // dp.l = op_readpc();
860
  19, // dp.h = op_readpc();
861
  1, // op_io();
862
  48, // rd = op_read(dp + regs.x);
863
  79, // regs.a = op_eor(regs.a, rd);
864
  2, // //!!NEXT
865
},
866
//   case 0x56: return op_read_addri<&SMPcore::op_eor>(regs.y);
867
//   void SMPcore::op_read_addri(uint8 &r) {
868
{
869
  18, // dp.l = op_readpc();
870
  19, // dp.h = op_readpc();
871
  1, // op_io();
872
  49, // rd = op_read(dp + regs.y);
873
  79, // regs.a = op_eor(regs.a, rd);
874
  2, // //!!NEXT
875
},
876
//   case 0x57: return op_read_idpy<&SMPcore::op_eor>();
877
//   void SMPcore::op_read_idpy() {
878
{
879
  9, // dp = op_readpc();
880
  1, // op_io();
881
  23, // sp.l = op_readdp(dp++);
882
  24, // sp.h = op_readdp(dp++);
883
  50, // rd = op_read(sp + regs.y);
884
  79, // regs.a = op_eor(regs.a, rd);
885
  2, // //!!NEXT
886
},
887
//   case 0x58: return op_write_dp_const<&SMPcore::op_eor>();
888
//   void SMPcore::op_write_dp_const() {
889
{
890
  13, // rd = op_readpc();
891
  9, // dp = op_readpc();
892
  28, // wr = op_readdp(dp);
893
  80, // wr = op_eor(wr, rd);
894
  30, // op_writedp(dp, wr);
895
  2, // //!!NEXT
896
},
897
//   case 0x59: return op_write_ix_iy<&SMPcore::op_eor>();
898
//   void SMPcore::op_write_ix_iy() {
899
{
900
  1, // op_io();
901
  51, // rd = op_readdp(regs.y);
902
  52, // wr = op_readdp(regs.x);
903
  80, // wr = op_eor(wr, rd);
904
  53, // op_writedp(regs.x, wr);
905
  2, // //!!NEXT
906
},
907
//   case 0x5a: return op_read_dpw<&SMPcore::op_cpw>();
908
//   void SMPcore::op_read_dpw() {
909
{
910
  9, // dp = op_readpc();
911
  87, // rd.l = op_readdp(dp++);
912
  88, // rd.h = op_readdp(dp++);
913
  89, // regs.ya = op_cpw(regs.ya, rd);
914
  2, // //!!NEXT
915
},
916
//   case 0x5b: return op_adjust_dpx<&SMPcore::op_lsr>();
917
//   void SMPcore::op_adjust_dpx() {
918
{
919
  9, // dp = op_readpc();
920
  1, // op_io();
921
  47, // rd = op_readdp(dp + regs.x);
922
  82, // rd = op_lsr(rd);
923
  60, // op_writedp(dp + regs.x, rd);
924
  2, // //!!NEXT
925
},
926
//   case 0x5c: return op_adjust<&SMPcore::op_lsr>(regs.a);
927
//   void SMPcore::op_adjust(uint8 &r) {
928
{
929
  1, // op_io();
930
  90, // regs.a = op_lsr(regs.a);
931
  2, // //!!NEXT
932
},
933
//   case 0x5d: return op_transfer(regs.a, regs.x);
934
//   void SMPcore::op_transfer(uint8 &from, uint8 &to) {
935
{
936
  1, // op_io();
937
  91, // regs.x = regs.a;
938
  92, // regs.p.n = (regs.x & 0x80);
939
  93, // regs.p.z = (regs.x == 0);
940
  2, // //!!NEXT
941
},
942
//   case 0x5e: return op_read_addr<&SMPcore::op_cmp>(regs.y);
943
//   void SMPcore::op_read_addr(uint8 &r) {
944
{
945
  18, // dp.l = op_readpc();
946
  19, // dp.h = op_readpc();
947
  20, // rd = op_read(dp);
948
  94, // regs.y = op_cmp(regs.y, rd);
949
  2, // //!!NEXT
950
},
951
//   case 0x5f: return op_jmp_addr();
952
//   void SMPcore::op_jmp_addr() {
953
{
954
  76, // rd.l = op_readpc();
955
  77, // rd.h = op_readpc();
956
  8, // regs.pc = rd;
957
  2, // //!!NEXT
958
},
959
//   case 0x60: return op_set_flag(regs.p.c, 0);
960
//   void SMPcore::op_set_flag(bool &flag, bool data) {
961
{
962
  1, // op_io();
963
  95, // regs.p.c = 0;
964
  2, // //!!NEXT
965
},
966
//   case 0x61: return op_jst();
967
//   void SMPcore::op_jst() {
968
{
969
  3, // dp = 0xffde - ((opcode >> 4) << 1);
970
  4, // rd.l = op_read(dp++);
971
  5, // rd.h = op_read(dp++);
972
  1, // op_io();
973
  1, // op_io();
974
  1, // op_io();
975
  6, // op_writesp(regs.pc.h);
976
  7, // op_writesp(regs.pc.l);
977
  8, // regs.pc = rd;
978
  2, // //!!NEXT
979
},
980
//   case 0x62: return op_set_bit();
981
//   void SMPcore::op_set_bit() {
982
{
983
  9, // dp = op_readpc();
984
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
985
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
986
  2, // //!!NEXT
987
},
988
//   case 0x63: return op_branch_bit();
989
//   void SMPcore::op_branch_bit() {
990
{
991
  9, // dp = op_readpc();
992
  12, // sp = op_readdp(dp);
993
  13, // rd = op_readpc();
994
  1, // op_io();
995
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
996
  1, // op_io();
997
  1, // op_io();
998
  15, // regs.pc += (int8)rd;
999
  2, // //!!NEXT
1000
},
1001
//   case 0x64: return op_read_dp<&SMPcore::op_cmp>(regs.a);
1002
//   void SMPcore::op_read_dp(uint8 &r) {
1003
{
1004
  9, // dp = op_readpc();
1005
  16, // rd = op_readdp(dp);
1006
  96, // regs.a = op_cmp(regs.a, rd);
1007
  2, // //!!NEXT
1008
},
1009
//   case 0x65: return op_read_addr<&SMPcore::op_cmp>(regs.a);
1010
//   void SMPcore::op_read_addr(uint8 &r) {
1011
{
1012
  18, // dp.l = op_readpc();
1013
  19, // dp.h = op_readpc();
1014
  20, // rd = op_read(dp);
1015
  96, // regs.a = op_cmp(regs.a, rd);
1016
  2, // //!!NEXT
1017
},
1018
//   case 0x66: return op_read_ix<&SMPcore::op_cmp>();
1019
//   void SMPcore::op_read_ix() {
1020
{
1021
  1, // op_io();
1022
  21, // rd = op_readdp(regs.x);
1023
  96, // regs.a = op_cmp(regs.a, rd);
1024
  2, // //!!NEXT
1025
},
1026
//   case 0x67: return op_read_idpx<&SMPcore::op_cmp>();
1027
//   void SMPcore::op_read_idpx() {
1028
{
1029
  22, // dp = op_readpc() + regs.x;
1030
  1, // op_io();
1031
  23, // sp.l = op_readdp(dp++);
1032
  24, // sp.h = op_readdp(dp++);
1033
  25, // rd = op_read(sp);
1034
  96, // regs.a = op_cmp(regs.a, rd);
1035
  2, // //!!NEXT
1036
},
1037
//   case 0x68: return op_read_const<&SMPcore::op_cmp>(regs.a);
1038
//   void SMPcore::op_read_const(uint8 &r) {
1039
{
1040
  13, // rd = op_readpc();
1041
  96, // regs.a = op_cmp(regs.a, rd);
1042
  2, // //!!NEXT
1043
},
1044
//   case 0x69: return op_write_dp_dp<&SMPcore::op_cmp>();
1045
//   void SMPcore::op_write_dp_dp() {
1046
{
1047
  26, // sp = op_readpc();
1048
  27, // rd = op_readdp(sp);
1049
  9, // dp = op_readpc();
1050
  28, // wr = op_readdp(dp);
1051
  97, // wr = op_cmp(wr, rd);
1052
  1, // op_io();
1053
  2, // //!!NEXT
1054
},
1055
//   case 0x6a: return op_set_addr_bit();
1056
//   void SMPcore::op_set_addr_bit() {
1057
{
1058
  18, // dp.l = op_readpc();
1059
  19, // dp.h = op_readpc();
1060
  31, // bit = dp >> 13;
1061
  32, // dp &= 0x1fff;
1062
  20, // rd = op_read(dp);
1063
  98, // regs.p.c &= (rd & (1 << bit)) ^ 1;
1064
  2, // //!!NEXT
1065
},
1066
//   case 0x6b: return op_adjust_dp<&SMPcore::op_ror>();
1067
//   void SMPcore::op_adjust_dp() {
1068
{
1069
  9, // dp = op_readpc();
1070
  16, // rd = op_readdp(dp);
1071
  99, // rd = op_ror(rd);
1072
  35, // op_writedp(dp, rd);
1073
  2, // //!!NEXT
1074
},
1075
//   case 0x6c: return op_adjust_addr<&SMPcore::op_ror>();
1076
//   void SMPcore::op_adjust_addr() {
1077
{
1078
  18, // dp.l = op_readpc();
1079
  19, // dp.h = op_readpc();
1080
  20, // rd = op_read(dp);
1081
  99, // rd = op_ror(rd);
1082
  36, // op_write(dp, rd);
1083
  2, // //!!NEXT
1084
},
1085
//   case 0x6d: return op_push(regs.y);
1086
//   void SMPcore::op_push(uint8 r) {
1087
{
1088
  1, // op_io();
1089
  1, // op_io();
1090
  100, // op_writesp(regs.y);
1091
  2, // //!!NEXT
1092
},
1093
//   case 0x6e: return op_bne_dpdec();
1094
//   void SMPcore::op_bne_dpdec() {
1095
{
1096
  9, // dp = op_readpc();
1097
  28, // wr = op_readdp(dp);
1098
  101, // op_writedp(dp, --wr);
1099
  13, // rd = op_readpc();
1100
  102, // if(wr == 0) return;
1101
  1, // op_io();
1102
  1, // op_io();
1103
  15, // regs.pc += (int8)rd;
1104
  2, // //!!NEXT
1105
},
1106
//   case 0x6f: return op_rts();
1107
//   void SMPcore::op_rts() {
1108
{
1109
  103, // rd.l = op_readsp();
1110
  104, // rd.h = op_readsp();
1111
  1, // op_io();
1112
  1, // op_io();
1113
  8, // regs.pc = rd;
1114
  2, // //!!NEXT
1115
},
1116
//   case 0x70: return op_branch(regs.p.v == 1);
1117
//   void SMPcore::op_branch(bool condition) {
1118
{
1119
  13, // rd = op_readpc();
1120
  105, // if(regs.p.v != 1) return;
1121
  1, // op_io();
1122
  1, // op_io();
1123
  15, // regs.pc += (int8)rd;
1124
  2, // //!!NEXT
1125
},
1126
//   case 0x71: return op_jst();
1127
//   void SMPcore::op_jst() {
1128
{
1129
  3, // dp = 0xffde - ((opcode >> 4) << 1);
1130
  4, // rd.l = op_read(dp++);
1131
  5, // rd.h = op_read(dp++);
1132
  1, // op_io();
1133
  1, // op_io();
1134
  1, // op_io();
1135
  6, // op_writesp(regs.pc.h);
1136
  7, // op_writesp(regs.pc.l);
1137
  8, // regs.pc = rd;
1138
  2, // //!!NEXT
1139
},
1140
//   case 0x72: return op_set_bit();
1141
//   void SMPcore::op_set_bit() {
1142
{
1143
  9, // dp = op_readpc();
1144
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
1145
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
1146
  2, // //!!NEXT
1147
},
1148
//   case 0x73: return op_branch_bit();
1149
//   void SMPcore::op_branch_bit() {
1150
{
1151
  9, // dp = op_readpc();
1152
  12, // sp = op_readdp(dp);
1153
  13, // rd = op_readpc();
1154
  1, // op_io();
1155
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
1156
  1, // op_io();
1157
  1, // op_io();
1158
  15, // regs.pc += (int8)rd;
1159
  2, // //!!NEXT
1160
},
1161
//   case 0x74: return op_read_dpi<&SMPcore::op_cmp>(regs.a, regs.x);
1162
//   void SMPcore::op_read_dpi(uint8 &r, uint8 &i) {
1163
{
1164
  9, // dp = op_readpc();
1165
  1, // op_io();
1166
  47, // rd = op_readdp(dp + regs.x);
1167
  96, // regs.a = op_cmp(regs.a, rd);
1168
  2, // //!!NEXT
1169
},
1170
//   case 0x75: return op_read_addri<&SMPcore::op_cmp>(regs.x);
1171
//   void SMPcore::op_read_addri(uint8 &r) {
1172
{
1173
  18, // dp.l = op_readpc();
1174
  19, // dp.h = op_readpc();
1175
  1, // op_io();
1176
  48, // rd = op_read(dp + regs.x);
1177
  96, // regs.a = op_cmp(regs.a, rd);
1178
  2, // //!!NEXT
1179
},
1180
//   case 0x76: return op_read_addri<&SMPcore::op_cmp>(regs.y);
1181
//   void SMPcore::op_read_addri(uint8 &r) {
1182
{
1183
  18, // dp.l = op_readpc();
1184
  19, // dp.h = op_readpc();
1185
  1, // op_io();
1186
  49, // rd = op_read(dp + regs.y);
1187
  96, // regs.a = op_cmp(regs.a, rd);
1188
  2, // //!!NEXT
1189
},
1190
//   case 0x77: return op_read_idpy<&SMPcore::op_cmp>();
1191
//   void SMPcore::op_read_idpy() {
1192
{
1193
  9, // dp = op_readpc();
1194
  1, // op_io();
1195
  23, // sp.l = op_readdp(dp++);
1196
  24, // sp.h = op_readdp(dp++);
1197
  50, // rd = op_read(sp + regs.y);
1198
  96, // regs.a = op_cmp(regs.a, rd);
1199
  2, // //!!NEXT
1200
},
1201
//   case 0x78: return op_write_dp_const<&SMPcore::op_cmp>();
1202
//   void SMPcore::op_write_dp_const() {
1203
{
1204
  13, // rd = op_readpc();
1205
  9, // dp = op_readpc();
1206
  28, // wr = op_readdp(dp);
1207
  97, // wr = op_cmp(wr, rd);
1208
  1, // op_io();
1209
  2, // //!!NEXT
1210
},
1211
//   case 0x79: return op_write_ix_iy<&SMPcore::op_cmp>();
1212
//   void SMPcore::op_write_ix_iy() {
1213
{
1214
  1, // op_io();
1215
  51, // rd = op_readdp(regs.y);
1216
  52, // wr = op_readdp(regs.x);
1217
  97, // wr = op_cmp(wr, rd);
1218
  1, // op_io();
1219
  2, // //!!NEXT
1220
},
1221
//   case 0x7a: return op_read_dpw<&SMPcore::op_adw>();
1222
//   void SMPcore::op_read_dpw() {
1223
{
1224
  9, // dp = op_readpc();
1225
  87, // rd.l = op_readdp(dp++);
1226
  1, // op_io();
1227
  88, // rd.h = op_readdp(dp++);
1228
  106, // regs.ya = op_adw(regs.ya, rd);
1229
  2, // //!!NEXT
1230
},
1231
//   case 0x7b: return op_adjust_dpx<&SMPcore::op_ror>();
1232
//   void SMPcore::op_adjust_dpx() {
1233
{
1234
  9, // dp = op_readpc();
1235
  1, // op_io();
1236
  47, // rd = op_readdp(dp + regs.x);
1237
  99, // rd = op_ror(rd);
1238
  60, // op_writedp(dp + regs.x, rd);
1239
  2, // //!!NEXT
1240
},
1241
//   case 0x7c: return op_adjust<&SMPcore::op_ror>(regs.a);
1242
//   void SMPcore::op_adjust(uint8 &r) {
1243
{
1244
  1, // op_io();
1245
  107, // regs.a = op_ror(regs.a);
1246
  2, // //!!NEXT
1247
},
1248
//   case 0x7d: return op_transfer(regs.x, regs.a);
1249
//   void SMPcore::op_transfer(uint8 &from, uint8 &to) {
1250
{
1251
  1, // op_io();
1252
  108, // regs.a = regs.x;
1253
  109, // regs.p.n = (regs.a & 0x80);
1254
  110, // regs.p.z = (regs.a == 0);
1255
  2, // //!!NEXT
1256
},
1257
//   case 0x7e: return op_read_dp<&SMPcore::op_cmp>(regs.y);
1258
//   void SMPcore::op_read_dp(uint8 &r) {
1259
{
1260
  9, // dp = op_readpc();
1261
  16, // rd = op_readdp(dp);
1262
  94, // regs.y = op_cmp(regs.y, rd);
1263
  2, // //!!NEXT
1264
},
1265
//   case 0x7f: return op_rti();
1266
//   void SMPcore::op_rti() {
1267
{
1268
  111, // regs.p = op_readsp();
1269
  103, // rd.l = op_readsp();
1270
  104, // rd.h = op_readsp();
1271
  1, // op_io();
1272
  1, // op_io();
1273
  8, // regs.pc = rd;
1274
  2, // //!!NEXT
1275
},
1276
//   case 0x80: return op_set_flag(regs.p.c, 1);
1277
//   void SMPcore::op_set_flag(bool &flag, bool data) {
1278
{
1279
  1, // op_io();
1280
  112, // regs.p.c = 1;
1281
  2, // //!!NEXT
1282
},
1283
//   case 0x81: return op_jst();
1284
//   void SMPcore::op_jst() {
1285
{
1286
  3, // dp = 0xffde - ((opcode >> 4) << 1);
1287
  4, // rd.l = op_read(dp++);
1288
  5, // rd.h = op_read(dp++);
1289
  1, // op_io();
1290
  1, // op_io();
1291
  1, // op_io();
1292
  6, // op_writesp(regs.pc.h);
1293
  7, // op_writesp(regs.pc.l);
1294
  8, // regs.pc = rd;
1295
  2, // //!!NEXT
1296
},
1297
//   case 0x82: return op_set_bit();
1298
//   void SMPcore::op_set_bit() {
1299
{
1300
  9, // dp = op_readpc();
1301
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
1302
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
1303
  2, // //!!NEXT
1304
},
1305
//   case 0x83: return op_branch_bit();
1306
//   void SMPcore::op_branch_bit() {
1307
{
1308
  9, // dp = op_readpc();
1309
  12, // sp = op_readdp(dp);
1310
  13, // rd = op_readpc();
1311
  1, // op_io();
1312
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
1313
  1, // op_io();
1314
  1, // op_io();
1315
  15, // regs.pc += (int8)rd;
1316
  2, // //!!NEXT
1317
},
1318
//   case 0x84: return op_read_dp<&SMPcore::op_adc>(regs.a);
1319
//   void SMPcore::op_read_dp(uint8 &r) {
1320
{
1321
  9, // dp = op_readpc();
1322
  16, // rd = op_readdp(dp);
1323
  113, // regs.a = op_adc(regs.a, rd);
1324
  2, // //!!NEXT
1325
},
1326
//   case 0x85: return op_read_addr<&SMPcore::op_adc>(regs.a);
1327
//   void SMPcore::op_read_addr(uint8 &r) {
1328
{
1329
  18, // dp.l = op_readpc();
1330
  19, // dp.h = op_readpc();
1331
  20, // rd = op_read(dp);
1332
  113, // regs.a = op_adc(regs.a, rd);
1333
  2, // //!!NEXT
1334
},
1335
//   case 0x86: return op_read_ix<&SMPcore::op_adc>();
1336
//   void SMPcore::op_read_ix() {
1337
{
1338
  1, // op_io();
1339
  21, // rd = op_readdp(regs.x);
1340
  113, // regs.a = op_adc(regs.a, rd);
1341
  2, // //!!NEXT
1342
},
1343
//   case 0x87: return op_read_idpx<&SMPcore::op_adc>();
1344
//   void SMPcore::op_read_idpx() {
1345
{
1346
  22, // dp = op_readpc() + regs.x;
1347
  1, // op_io();
1348
  23, // sp.l = op_readdp(dp++);
1349
  24, // sp.h = op_readdp(dp++);
1350
  25, // rd = op_read(sp);
1351
  113, // regs.a = op_adc(regs.a, rd);
1352
  2, // //!!NEXT
1353
},
1354
//   case 0x88: return op_read_const<&SMPcore::op_adc>(regs.a);
1355
//   void SMPcore::op_read_const(uint8 &r) {
1356
{
1357
  13, // rd = op_readpc();
1358
  113, // regs.a = op_adc(regs.a, rd);
1359
  2, // //!!NEXT
1360
},
1361
//   case 0x89: return op_write_dp_dp<&SMPcore::op_adc>();
1362
//   void SMPcore::op_write_dp_dp() {
1363
{
1364
  26, // sp = op_readpc();
1365
  27, // rd = op_readdp(sp);
1366
  9, // dp = op_readpc();
1367
  28, // wr = op_readdp(dp);
1368
  114, // wr = op_adc(wr, rd);
1369
  30, // op_writedp(dp, wr);
1370
  2, // //!!NEXT
1371
},
1372
//   case 0x8a: return op_set_addr_bit();
1373
//   void SMPcore::op_set_addr_bit() {
1374
{
1375
  18, // dp.l = op_readpc();
1376
  19, // dp.h = op_readpc();
1377
  31, // bit = dp >> 13;
1378
  32, // dp &= 0x1fff;
1379
  20, // rd = op_read(dp);
1380
  1, // op_io();
1381
  115, // regs.p.c ^= (bool)(rd & (1 << bit));
1382
  2, // //!!NEXT
1383
},
1384
//   case 0x8b: return op_adjust_dp<&SMPcore::op_dec>();
1385
//   void SMPcore::op_adjust_dp() {
1386
{
1387
  9, // dp = op_readpc();
1388
  16, // rd = op_readdp(dp);
1389
  116, // rd = op_dec(rd);
1390
  35, // op_writedp(dp, rd);
1391
  2, // //!!NEXT
1392
},
1393
//   case 0x8c: return op_adjust_addr<&SMPcore::op_dec>();
1394
//   void SMPcore::op_adjust_addr() {
1395
{
1396
  18, // dp.l = op_readpc();
1397
  19, // dp.h = op_readpc();
1398
  20, // rd = op_read(dp);
1399
  116, // rd = op_dec(rd);
1400
  36, // op_write(dp, rd);
1401
  2, // //!!NEXT
1402
},
1403
//   case 0x8d: return op_read_const<&SMPcore::op_ld>(regs.y);
1404
//   void SMPcore::op_read_const(uint8 &r) {
1405
{
1406
  13, // rd = op_readpc();
1407
  117, // regs.y = op_ld(regs.y, rd);
1408
  2, // //!!NEXT
1409
},
1410
//   case 0x8e: return op_plp();
1411
//   void SMPcore::op_plp() {
1412
{
1413
  1, // op_io();
1414
  1, // op_io();
1415
  111, // regs.p = op_readsp();
1416
  2, // //!!NEXT
1417
},
1418
//   case 0x8f: return op_write_dp_const<&SMPcore::op_st>();
1419
//   void SMPcore::op_write_dp_const() {
1420
{
1421
  13, // rd = op_readpc();
1422
  9, // dp = op_readpc();
1423
  28, // wr = op_readdp(dp);
1424
  118, // wr = op_st(wr, rd);
1425
  30, // op_writedp(dp, wr);
1426
  2, // //!!NEXT
1427
},
1428
//   case 0x90: return op_branch(regs.p.c == 0);
1429
//   void SMPcore::op_branch(bool condition) {
1430
{
1431
  13, // rd = op_readpc();
1432
  119, // if(regs.p.c != 0) return;
1433
  1, // op_io();
1434
  1, // op_io();
1435
  15, // regs.pc += (int8)rd;
1436
  2, // //!!NEXT
1437
},
1438
//   case 0x91: return op_jst();
1439
//   void SMPcore::op_jst() {
1440
{
1441
  3, // dp = 0xffde - ((opcode >> 4) << 1);
1442
  4, // rd.l = op_read(dp++);
1443
  5, // rd.h = op_read(dp++);
1444
  1, // op_io();
1445
  1, // op_io();
1446
  1, // op_io();
1447
  6, // op_writesp(regs.pc.h);
1448
  7, // op_writesp(regs.pc.l);
1449
  8, // regs.pc = rd;
1450
  2, // //!!NEXT
1451
},
1452
//   case 0x92: return op_set_bit();
1453
//   void SMPcore::op_set_bit() {
1454
{
1455
  9, // dp = op_readpc();
1456
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
1457
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
1458
  2, // //!!NEXT
1459
},
1460
//   case 0x93: return op_branch_bit();
1461
//   void SMPcore::op_branch_bit() {
1462
{
1463
  9, // dp = op_readpc();
1464
  12, // sp = op_readdp(dp);
1465
  13, // rd = op_readpc();
1466
  1, // op_io();
1467
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
1468
  1, // op_io();
1469
  1, // op_io();
1470
  15, // regs.pc += (int8)rd;
1471
  2, // //!!NEXT
1472
},
1473
//   case 0x94: return op_read_dpi<&SMPcore::op_adc>(regs.a, regs.x);
1474
//   void SMPcore::op_read_dpi(uint8 &r, uint8 &i) {
1475
{
1476
  9, // dp = op_readpc();
1477
  1, // op_io();
1478
  47, // rd = op_readdp(dp + regs.x);
1479
  113, // regs.a = op_adc(regs.a, rd);
1480
  2, // //!!NEXT
1481
},
1482
//   case 0x95: return op_read_addri<&SMPcore::op_adc>(regs.x);
1483
//   void SMPcore::op_read_addri(uint8 &r) {
1484
{
1485
  18, // dp.l = op_readpc();
1486
  19, // dp.h = op_readpc();
1487
  1, // op_io();
1488
  48, // rd = op_read(dp + regs.x);
1489
  113, // regs.a = op_adc(regs.a, rd);
1490
  2, // //!!NEXT
1491
},
1492
//   case 0x96: return op_read_addri<&SMPcore::op_adc>(regs.y);
1493
//   void SMPcore::op_read_addri(uint8 &r) {
1494
{
1495
  18, // dp.l = op_readpc();
1496
  19, // dp.h = op_readpc();
1497
  1, // op_io();
1498
  49, // rd = op_read(dp + regs.y);
1499
  113, // regs.a = op_adc(regs.a, rd);
1500
  2, // //!!NEXT
1501
},
1502
//   case 0x97: return op_read_idpy<&SMPcore::op_adc>();
1503
//   void SMPcore::op_read_idpy() {
1504
{
1505
  9, // dp = op_readpc();
1506
  1, // op_io();
1507
  23, // sp.l = op_readdp(dp++);
1508
  24, // sp.h = op_readdp(dp++);
1509
  50, // rd = op_read(sp + regs.y);
1510
  113, // regs.a = op_adc(regs.a, rd);
1511
  2, // //!!NEXT
1512
},
1513
//   case 0x98: return op_write_dp_const<&SMPcore::op_adc>();
1514
//   void SMPcore::op_write_dp_const() {
1515
{
1516
  13, // rd = op_readpc();
1517
  9, // dp = op_readpc();
1518
  28, // wr = op_readdp(dp);
1519
  114, // wr = op_adc(wr, rd);
1520
  30, // op_writedp(dp, wr);
1521
  2, // //!!NEXT
1522
},
1523
//   case 0x99: return op_write_ix_iy<&SMPcore::op_adc>();
1524
//   void SMPcore::op_write_ix_iy() {
1525
{
1526
  1, // op_io();
1527
  51, // rd = op_readdp(regs.y);
1528
  52, // wr = op_readdp(regs.x);
1529
  114, // wr = op_adc(wr, rd);
1530
  53, // op_writedp(regs.x, wr);
1531
  2, // //!!NEXT
1532
},
1533
//   case 0x9a: return op_read_dpw<&SMPcore::op_sbw>();
1534
//   void SMPcore::op_read_dpw() {
1535
{
1536
  9, // dp = op_readpc();
1537
  87, // rd.l = op_readdp(dp++);
1538
  1, // op_io();
1539
  88, // rd.h = op_readdp(dp++);
1540
  120, // regs.ya = op_sbw(regs.ya, rd);
1541
  2, // //!!NEXT
1542
},
1543
//   case 0x9b: return op_adjust_dpx<&SMPcore::op_dec>();
1544
//   void SMPcore::op_adjust_dpx() {
1545
{
1546
  9, // dp = op_readpc();
1547
  1, // op_io();
1548
  47, // rd = op_readdp(dp + regs.x);
1549
  116, // rd = op_dec(rd);
1550
  60, // op_writedp(dp + regs.x, rd);
1551
  2, // //!!NEXT
1552
},
1553
//   case 0x9c: return op_adjust<&SMPcore::op_dec>(regs.a);
1554
//   void SMPcore::op_adjust(uint8 &r) {
1555
{
1556
  1, // op_io();
1557
  121, // regs.a = op_dec(regs.a);
1558
  2, // //!!NEXT
1559
},
1560
//   case 0x9d: return op_transfer(regs.s, regs.x);
1561
//   void SMPcore::op_transfer(uint8 &from, uint8 &to) {
1562
{
1563
  1, // op_io();
1564
  122, // regs.x = regs.s;
1565
  92, // regs.p.n = (regs.x & 0x80);
1566
  93, // regs.p.z = (regs.x == 0);
1567
  2, // //!!NEXT
1568
},
1569
//   case 0x9e: return op_div_ya_x();
1570
//   void SMPcore::op_div_ya_x() {
1571
{
1572
  1, // op_io();
1573
  1, // op_io();
1574
  1, // op_io();
1575
  1, // op_io();
1576
  1, // op_io();
1577
  1, // op_io();
1578
  1, // op_io();
1579
  1, // op_io();
1580
  1, // op_io();
1581
  1, // op_io();
1582
  1, // op_io();
1583
  //ya = regs.ya;
1584
  ////overflow set if quotient >= 256
1585
  //regs.p.v = (regs.y >= regs.x);
1586
  //regs.p.h = ((regs.y & 15) >= (regs.x & 15));
1587
  //if(regs.y < (regs.x << 1)) {
1588
  ////if quotient is <= 511 (will fit into 9-bit result)
1589
  //regs.a = ya / regs.x;
1590
  //regs.y = ya % regs.x;
1591
  //} else {
1592
  ////otherwise, the quotient won't fit into regs.p.v + regs.a
1593
  ////this emulates the odd behavior of the S-SMP in this case
1594
  //regs.a = 255    - (ya - (regs.x << 9)) / (256 - regs.x);
1595
  //regs.y = regs.x + (ya - (regs.x << 9)) % (256 - regs.x);
1596
  //}
1597
  ////result is set based on a (quotient) only
1598
  //regs.p.n = (regs.a & 0x80);
1599
  //regs.p.z = (regs.a == 0);
1600
  123, // //!!MULTI0
1601
  2, // //!!NEXT
1602
},
1603
//   case 0x9f: return op_xcn();
1604
//   void SMPcore::op_xcn() {
1605
{
1606
  1, // op_io();
1607
  1, // op_io();
1608
  1, // op_io();
1609
  1, // op_io();
1610
  124, // regs.a = (regs.a >> 4) | (regs.a << 4);
1611
  125, // regs.p.n = regs.a & 0x80;
1612
  126, // regs.p.z = regs.a == 0;
1613
  2, // //!!NEXT
1614
},
1615
//   case 0xa0: return op_set_flag(regs.p.i, 1);
1616
//   void SMPcore::op_set_flag(bool &flag, bool data) {
1617
{
1618
  1, // op_io();
1619
  1, // op_io();
1620
  127, // regs.p.i = 1;
1621
  2, // //!!NEXT
1622
},
1623
//   case 0xa1: return op_jst();
1624
//   void SMPcore::op_jst() {
1625
{
1626
  3, // dp = 0xffde - ((opcode >> 4) << 1);
1627
  4, // rd.l = op_read(dp++);
1628
  5, // rd.h = op_read(dp++);
1629
  1, // op_io();
1630
  1, // op_io();
1631
  1, // op_io();
1632
  6, // op_writesp(regs.pc.h);
1633
  7, // op_writesp(regs.pc.l);
1634
  8, // regs.pc = rd;
1635
  2, // //!!NEXT
1636
},
1637
//   case 0xa2: return op_set_bit();
1638
//   void SMPcore::op_set_bit() {
1639
{
1640
  9, // dp = op_readpc();
1641
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
1642
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
1643
  2, // //!!NEXT
1644
},
1645
//   case 0xa3: return op_branch_bit();
1646
//   void SMPcore::op_branch_bit() {
1647
{
1648
  9, // dp = op_readpc();
1649
  12, // sp = op_readdp(dp);
1650
  13, // rd = op_readpc();
1651
  1, // op_io();
1652
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
1653
  1, // op_io();
1654
  1, // op_io();
1655
  15, // regs.pc += (int8)rd;
1656
  2, // //!!NEXT
1657
},
1658
//   case 0xa4: return op_read_dp<&SMPcore::op_sbc>(regs.a);
1659
//   void SMPcore::op_read_dp(uint8 &r) {
1660
{
1661
  9, // dp = op_readpc();
1662
  16, // rd = op_readdp(dp);
1663
  128, // regs.a = op_sbc(regs.a, rd);
1664
  2, // //!!NEXT
1665
},
1666
//   case 0xa5: return op_read_addr<&SMPcore::op_sbc>(regs.a);
1667
//   void SMPcore::op_read_addr(uint8 &r) {
1668
{
1669
  18, // dp.l = op_readpc();
1670
  19, // dp.h = op_readpc();
1671
  20, // rd = op_read(dp);
1672
  128, // regs.a = op_sbc(regs.a, rd);
1673
  2, // //!!NEXT
1674
},
1675
//   case 0xa6: return op_read_ix<&SMPcore::op_sbc>();
1676
//   void SMPcore::op_read_ix() {
1677
{
1678
  1, // op_io();
1679
  21, // rd = op_readdp(regs.x);
1680
  128, // regs.a = op_sbc(regs.a, rd);
1681
  2, // //!!NEXT
1682
},
1683
//   case 0xa7: return op_read_idpx<&SMPcore::op_sbc>();
1684
//   void SMPcore::op_read_idpx() {
1685
{
1686
  22, // dp = op_readpc() + regs.x;
1687
  1, // op_io();
1688
  23, // sp.l = op_readdp(dp++);
1689
  24, // sp.h = op_readdp(dp++);
1690
  25, // rd = op_read(sp);
1691
  128, // regs.a = op_sbc(regs.a, rd);
1692
  2, // //!!NEXT
1693
},
1694
//   case 0xa8: return op_read_const<&SMPcore::op_sbc>(regs.a);
1695
//   void SMPcore::op_read_const(uint8 &r) {
1696
{
1697
  13, // rd = op_readpc();
1698
  128, // regs.a = op_sbc(regs.a, rd);
1699
  2, // //!!NEXT
1700
},
1701
//   case 0xa9: return op_write_dp_dp<&SMPcore::op_sbc>();
1702
//   void SMPcore::op_write_dp_dp() {
1703
{
1704
  26, // sp = op_readpc();
1705
  27, // rd = op_readdp(sp);
1706
  9, // dp = op_readpc();
1707
  28, // wr = op_readdp(dp);
1708
  129, // wr = op_sbc(wr, rd);
1709
  30, // op_writedp(dp, wr);
1710
  2, // //!!NEXT
1711
},
1712
//   case 0xaa: return op_set_addr_bit();
1713
//   void SMPcore::op_set_addr_bit() {
1714
{
1715
  18, // dp.l = op_readpc();
1716
  19, // dp.h = op_readpc();
1717
  31, // bit = dp >> 13;
1718
  32, // dp &= 0x1fff;
1719
  20, // rd = op_read(dp);
1720
  130, // regs.p.c  = (rd & (1 << bit));
1721
  2, // //!!NEXT
1722
},
1723
//   case 0xab: return op_adjust_dp<&SMPcore::op_inc>();
1724
//   void SMPcore::op_adjust_dp() {
1725
{
1726
  9, // dp = op_readpc();
1727
  16, // rd = op_readdp(dp);
1728
  131, // rd = op_inc(rd);
1729
  35, // op_writedp(dp, rd);
1730
  2, // //!!NEXT
1731
},
1732
//   case 0xac: return op_adjust_addr<&SMPcore::op_inc>();
1733
//   void SMPcore::op_adjust_addr() {
1734
{
1735
  18, // dp.l = op_readpc();
1736
  19, // dp.h = op_readpc();
1737
  20, // rd = op_read(dp);
1738
  131, // rd = op_inc(rd);
1739
  36, // op_write(dp, rd);
1740
  2, // //!!NEXT
1741
},
1742
//   case 0xad: return op_read_const<&SMPcore::op_cmp>(regs.y);
1743
//   void SMPcore::op_read_const(uint8 &r) {
1744
{
1745
  13, // rd = op_readpc();
1746
  94, // regs.y = op_cmp(regs.y, rd);
1747
  2, // //!!NEXT
1748
},
1749
//   case 0xae: return op_pull(regs.a);
1750
//   void SMPcore::op_pull(uint8 &r) {
1751
{
1752
  1, // op_io();
1753
  1, // op_io();
1754
  132, // regs.a = op_readsp();
1755
  2, // //!!NEXT
1756
},
1757
//   case 0xaf: return op_sta_ixinc();
1758
//   void SMPcore::op_sta_ixinc() {
1759
{
1760
  1, // op_io();
1761
  1, // op_io();
1762
  133, // op_writedp(regs.x++, regs.a);
1763
  2, // //!!NEXT
1764
},
1765
//   case 0xb0: return op_branch(regs.p.c == 1);
1766
//   void SMPcore::op_branch(bool condition) {
1767
{
1768
  13, // rd = op_readpc();
1769
  134, // if(regs.p.c != 1) return;
1770
  1, // op_io();
1771
  1, // op_io();
1772
  15, // regs.pc += (int8)rd;
1773
  2, // //!!NEXT
1774
},
1775
//   case 0xb1: return op_jst();
1776
//   void SMPcore::op_jst() {
1777
{
1778
  3, // dp = 0xffde - ((opcode >> 4) << 1);
1779
  4, // rd.l = op_read(dp++);
1780
  5, // rd.h = op_read(dp++);
1781
  1, // op_io();
1782
  1, // op_io();
1783
  1, // op_io();
1784
  6, // op_writesp(regs.pc.h);
1785
  7, // op_writesp(regs.pc.l);
1786
  8, // regs.pc = rd;
1787
  2, // //!!NEXT
1788
},
1789
//   case 0xb2: return op_set_bit();
1790
//   void SMPcore::op_set_bit() {
1791
{
1792
  9, // dp = op_readpc();
1793
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
1794
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
1795
  2, // //!!NEXT
1796
},
1797
//   case 0xb3: return op_branch_bit();
1798
//   void SMPcore::op_branch_bit() {
1799
{
1800
  9, // dp = op_readpc();
1801
  12, // sp = op_readdp(dp);
1802
  13, // rd = op_readpc();
1803
  1, // op_io();
1804
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
1805
  1, // op_io();
1806
  1, // op_io();
1807
  15, // regs.pc += (int8)rd;
1808
  2, // //!!NEXT
1809
},
1810
//   case 0xb4: return op_read_dpi<&SMPcore::op_sbc>(regs.a, regs.x);
1811
//   void SMPcore::op_read_dpi(uint8 &r, uint8 &i) {
1812
{
1813
  9, // dp = op_readpc();
1814
  1, // op_io();
1815
  47, // rd = op_readdp(dp + regs.x);
1816
  128, // regs.a = op_sbc(regs.a, rd);
1817
  2, // //!!NEXT
1818
},
1819
//   case 0xb5: return op_read_addri<&SMPcore::op_sbc>(regs.x);
1820
//   void SMPcore::op_read_addri(uint8 &r) {
1821
{
1822
  18, // dp.l = op_readpc();
1823
  19, // dp.h = op_readpc();
1824
  1, // op_io();
1825
  48, // rd = op_read(dp + regs.x);
1826
  128, // regs.a = op_sbc(regs.a, rd);
1827
  2, // //!!NEXT
1828
},
1829
//   case 0xb6: return op_read_addri<&SMPcore::op_sbc>(regs.y);
1830
//   void SMPcore::op_read_addri(uint8 &r) {
1831
{
1832
  18, // dp.l = op_readpc();
1833
  19, // dp.h = op_readpc();
1834
  1, // op_io();
1835
  49, // rd = op_read(dp + regs.y);
1836
  128, // regs.a = op_sbc(regs.a, rd);
1837
  2, // //!!NEXT
1838
},
1839
//   case 0xb7: return op_read_idpy<&SMPcore::op_sbc>();
1840
//   void SMPcore::op_read_idpy() {
1841
{
1842
  9, // dp = op_readpc();
1843
  1, // op_io();
1844
  23, // sp.l = op_readdp(dp++);
1845
  24, // sp.h = op_readdp(dp++);
1846
  50, // rd = op_read(sp + regs.y);
1847
  128, // regs.a = op_sbc(regs.a, rd);
1848
  2, // //!!NEXT
1849
},
1850
//   case 0xb8: return op_write_dp_const<&SMPcore::op_sbc>();
1851
//   void SMPcore::op_write_dp_const() {
1852
{
1853
  13, // rd = op_readpc();
1854
  9, // dp = op_readpc();
1855
  28, // wr = op_readdp(dp);
1856
  129, // wr = op_sbc(wr, rd);
1857
  30, // op_writedp(dp, wr);
1858
  2, // //!!NEXT
1859
},
1860
//   case 0xb9: return op_write_ix_iy<&SMPcore::op_sbc>();
1861
//   void SMPcore::op_write_ix_iy() {
1862
{
1863
  1, // op_io();
1864
  51, // rd = op_readdp(regs.y);
1865
  52, // wr = op_readdp(regs.x);
1866
  129, // wr = op_sbc(wr, rd);
1867
  53, // op_writedp(regs.x, wr);
1868
  2, // //!!NEXT
1869
},
1870
//   case 0xba: return op_read_dpw<&SMPcore::op_ldw>();
1871
//   void SMPcore::op_read_dpw() {
1872
{
1873
  9, // dp = op_readpc();
1874
  87, // rd.l = op_readdp(dp++);
1875
  1, // op_io();
1876
  88, // rd.h = op_readdp(dp++);
1877
  135, // regs.ya = op_ldw(regs.ya, rd);
1878
  2, // //!!NEXT
1879
},
1880
//   case 0xbb: return op_adjust_dpx<&SMPcore::op_inc>();
1881
//   void SMPcore::op_adjust_dpx() {
1882
{
1883
  9, // dp = op_readpc();
1884
  1, // op_io();
1885
  47, // rd = op_readdp(dp + regs.x);
1886
  131, // rd = op_inc(rd);
1887
  60, // op_writedp(dp + regs.x, rd);
1888
  2, // //!!NEXT
1889
},
1890
//   case 0xbc: return op_adjust<&SMPcore::op_inc>(regs.a);
1891
//   void SMPcore::op_adjust(uint8 &r) {
1892
{
1893
  1, // op_io();
1894
  136, // regs.a = op_inc(regs.a);
1895
  2, // //!!NEXT
1896
},
1897
//   case 0xbd: return op_transfer(regs.x, regs.s);
1898
//   void SMPcore::op_transfer(uint8 &from, uint8 &to) {
1899
{
1900
  1, // op_io();
1901
  137, // regs.s = regs.x;
1902
  2, // //!!NEXT
1903
},
1904
//   case 0xbe: return op_das();
1905
//   void SMPcore::op_das() {
1906
{
1907
  1, // op_io();
1908
  1, // op_io();
1909
  //if(!regs.p.c || (regs.a) > 0x99) {
1910
  //regs.a -= 0x60;
1911
  //regs.p.c = 0;
1912
  //}
1913
  //if(!regs.p.h || (regs.a & 15) > 0x09) {
1914
  //regs.a -= 0x06;
1915
  //}
1916
  //regs.p.n = (regs.a & 0x80);
1917
  //regs.p.z = (regs.a == 0);
1918
  138, // //!!MULTI1
1919
  2, // //!!NEXT
1920
},
1921
//   case 0xbf: return op_lda_ixinc();
1922
//   void SMPcore::op_lda_ixinc() {
1923
{
1924
  1, // op_io();
1925
  139, // regs.a = op_readdp(regs.x++);
1926
  1, // op_io();
1927
  125, // regs.p.n = regs.a & 0x80;
1928
  126, // regs.p.z = regs.a == 0;
1929
  2, // //!!NEXT
1930
},
1931
//   case 0xc0: return op_set_flag(regs.p.i, 0);
1932
//   void SMPcore::op_set_flag(bool &flag, bool data) {
1933
{
1934
  1, // op_io();
1935
  1, // op_io();
1936
  45, // regs.p.i = 0;
1937
  2, // //!!NEXT
1938
},
1939
//   case 0xc1: return op_jst();
1940
//   void SMPcore::op_jst() {
1941
{
1942
  3, // dp = 0xffde - ((opcode >> 4) << 1);
1943
  4, // rd.l = op_read(dp++);
1944
  5, // rd.h = op_read(dp++);
1945
  1, // op_io();
1946
  1, // op_io();
1947
  1, // op_io();
1948
  6, // op_writesp(regs.pc.h);
1949
  7, // op_writesp(regs.pc.l);
1950
  8, // regs.pc = rd;
1951
  2, // //!!NEXT
1952
},
1953
//   case 0xc2: return op_set_bit();
1954
//   void SMPcore::op_set_bit() {
1955
{
1956
  9, // dp = op_readpc();
1957
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
1958
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
1959
  2, // //!!NEXT
1960
},
1961
//   case 0xc3: return op_branch_bit();
1962
//   void SMPcore::op_branch_bit() {
1963
{
1964
  9, // dp = op_readpc();
1965
  12, // sp = op_readdp(dp);
1966
  13, // rd = op_readpc();
1967
  1, // op_io();
1968
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
1969
  1, // op_io();
1970
  1, // op_io();
1971
  15, // regs.pc += (int8)rd;
1972
  2, // //!!NEXT
1973
},
1974
//   case 0xc4: return op_write_dp(regs.a);
1975
//   void SMPcore::op_write_dp(uint8 &r) {
1976
{
1977
  9, // dp = op_readpc();
1978
  140, // op_readdp(dp);
1979
  141, // op_writedp(dp, regs.a);
1980
  2, // //!!NEXT
1981
},
1982
//   case 0xc5: return op_write_addr(regs.a);
1983
//   void SMPcore::op_write_addr(uint8 &r) {
1984
{
1985
  18, // dp.l = op_readpc();
1986
  19, // dp.h = op_readpc();
1987
  40, // op_read(dp);
1988
  142, // op_write(dp, regs.a);
1989
  2, // //!!NEXT
1990
},
1991
//   case 0xc6: return op_sta_ix();
1992
//   void SMPcore::op_sta_ix() {
1993
{
1994
  1, // op_io();
1995
  143, // op_readdp(regs.x);
1996
  144, // op_writedp(regs.x, regs.a);
1997
  2, // //!!NEXT
1998
},
1999
//   case 0xc7: return op_sta_idpx();
2000
//   void SMPcore::op_sta_idpx() {
2001
{
2002
  145, // sp = op_readpc() + regs.x;
2003
  1, // op_io();
2004
  146, // dp.l = op_readdp(sp++);
2005
  147, // dp.h = op_readdp(sp++);
2006
  40, // op_read(dp);
2007
  142, // op_write(dp, regs.a);
2008
  2, // //!!NEXT
2009
},
2010
//   case 0xc8: return op_read_const<&SMPcore::op_cmp>(regs.x);
2011
//   void SMPcore::op_read_const(uint8 &r) {
2012
{
2013
  13, // rd = op_readpc();
2014
  63, // regs.x = op_cmp(regs.x, rd);
2015
  2, // //!!NEXT
2016
},
2017
//   case 0xc9: return op_write_addr(regs.x);
2018
//   void SMPcore::op_write_addr(uint8 &r) {
2019
{
2020
  18, // dp.l = op_readpc();
2021
  19, // dp.h = op_readpc();
2022
  40, // op_read(dp);
2023
  148, // op_write(dp, regs.x);
2024
  2, // //!!NEXT
2025
},
2026
//   case 0xca: return op_set_addr_bit();
2027
//   void SMPcore::op_set_addr_bit() {
2028
{
2029
  18, // dp.l = op_readpc();
2030
  19, // dp.h = op_readpc();
2031
  31, // bit = dp >> 13;
2032
  32, // dp &= 0x1fff;
2033
  20, // rd = op_read(dp);
2034
  1, // op_io();
2035
  149, // rd = (rd & ~(1 << bit)) | (regs.p.c << bit);
2036
  36, // op_write(dp, rd);
2037
  2, // //!!NEXT
2038
},
2039
//   case 0xcb: return op_write_dp(regs.y);
2040
//   void SMPcore::op_write_dp(uint8 &r) {
2041
{
2042
  9, // dp = op_readpc();
2043
  140, // op_readdp(dp);
2044
  150, // op_writedp(dp, regs.y);
2045
  2, // //!!NEXT
2046
},
2047
//   case 0xcc: return op_write_addr(regs.y);
2048
//   void SMPcore::op_write_addr(uint8 &r) {
2049
{
2050
  18, // dp.l = op_readpc();
2051
  19, // dp.h = op_readpc();
2052
  40, // op_read(dp);
2053
  151, // op_write(dp, regs.y);
2054
  2, // //!!NEXT
2055
},
2056
//   case 0xcd: return op_read_const<&SMPcore::op_ld>(regs.x);
2057
//   void SMPcore::op_read_const(uint8 &r) {
2058
{
2059
  13, // rd = op_readpc();
2060
  152, // regs.x = op_ld(regs.x, rd);
2061
  2, // //!!NEXT
2062
},
2063
//   case 0xce: return op_pull(regs.x);
2064
//   void SMPcore::op_pull(uint8 &r) {
2065
{
2066
  1, // op_io();
2067
  1, // op_io();
2068
  153, // regs.x = op_readsp();
2069
  2, // //!!NEXT
2070
},
2071
//   case 0xcf: return op_mul_ya();
2072
//   void SMPcore::op_mul_ya() {
2073
{
2074
  1, // op_io();
2075
  1, // op_io();
2076
  1, // op_io();
2077
  1, // op_io();
2078
  1, // op_io();
2079
  1, // op_io();
2080
  1, // op_io();
2081
  1, // op_io();
2082
  //ya = regs.y * regs.a;
2083
  //regs.a = ya;
2084
  //regs.y = ya >> 8;
2085
  ////result is set based on y (high-byte) only
2086
  //regs.p.n = (regs.y & 0x80);
2087
  //regs.p.z = (regs.y == 0);
2088
  154, // //!!MULTI2
2089
  2, // //!!NEXT
2090
},
2091
//   case 0xd0: return op_branch(regs.p.z == 0);
2092
//   void SMPcore::op_branch(bool condition) {
2093
{
2094
  13, // rd = op_readpc();
2095
  155, // if(regs.p.z != 0) return;
2096
  1, // op_io();
2097
  1, // op_io();
2098
  15, // regs.pc += (int8)rd;
2099
  2, // //!!NEXT
2100
},
2101
//   case 0xd1: return op_jst();
2102
//   void SMPcore::op_jst() {
2103
{
2104
  3, // dp = 0xffde - ((opcode >> 4) << 1);
2105
  4, // rd.l = op_read(dp++);
2106
  5, // rd.h = op_read(dp++);
2107
  1, // op_io();
2108
  1, // op_io();
2109
  1, // op_io();
2110
  6, // op_writesp(regs.pc.h);
2111
  7, // op_writesp(regs.pc.l);
2112
  8, // regs.pc = rd;
2113
  2, // //!!NEXT
2114
},
2115
//   case 0xd2: return op_set_bit();
2116
//   void SMPcore::op_set_bit() {
2117
{
2118
  9, // dp = op_readpc();
2119
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
2120
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
2121
  2, // //!!NEXT
2122
},
2123
//   case 0xd3: return op_branch_bit();
2124
//   void SMPcore::op_branch_bit() {
2125
{
2126
  9, // dp = op_readpc();
2127
  12, // sp = op_readdp(dp);
2128
  13, // rd = op_readpc();
2129
  1, // op_io();
2130
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
2131
  1, // op_io();
2132
  1, // op_io();
2133
  15, // regs.pc += (int8)rd;
2134
  2, // //!!NEXT
2135
},
2136
//   case 0xd4: return op_write_dpi(regs.a, regs.x);
2137
//   void SMPcore::op_write_dpi(uint8 &r, uint8 &i) {
2138
{
2139
  22, // dp = op_readpc() + regs.x;
2140
  1, // op_io();
2141
  140, // op_readdp(dp);
2142
  141, // op_writedp(dp, regs.a);
2143
  2, // //!!NEXT
2144
},
2145
//   case 0xd5: return op_write_addri(regs.x);
2146
//   void SMPcore::op_write_addri(uint8 &i) {
2147
{
2148
  18, // dp.l = op_readpc();
2149
  19, // dp.h = op_readpc();
2150
  1, // op_io();
2151
  64, // dp += regs.x;
2152
  40, // op_read(dp);
2153
  142, // op_write(dp, regs.a);
2154
  2, // //!!NEXT
2155
},
2156
//   case 0xd6: return op_write_addri(regs.y);
2157
//   void SMPcore::op_write_addri(uint8 &i) {
2158
{
2159
  18, // dp.l = op_readpc();
2160
  19, // dp.h = op_readpc();
2161
  1, // op_io();
2162
  156, // dp += regs.y;
2163
  40, // op_read(dp);
2164
  142, // op_write(dp, regs.a);
2165
  2, // //!!NEXT
2166
},
2167
//   case 0xd7: return op_sta_idpy();
2168
//   void SMPcore::op_sta_idpy() {
2169
{
2170
  26, // sp = op_readpc();
2171
  146, // dp.l = op_readdp(sp++);
2172
  147, // dp.h = op_readdp(sp++);
2173
  1, // op_io();
2174
  156, // dp += regs.y;
2175
  40, // op_read(dp);
2176
  142, // op_write(dp, regs.a);
2177
  2, // //!!NEXT
2178
},
2179
//   case 0xd8: return op_write_dp(regs.x);
2180
//   void SMPcore::op_write_dp(uint8 &r) {
2181
{
2182
  9, // dp = op_readpc();
2183
  140, // op_readdp(dp);
2184
  157, // op_writedp(dp, regs.x);
2185
  2, // //!!NEXT
2186
},
2187
//   case 0xd9: return op_write_dpi(regs.x, regs.y);
2188
//   void SMPcore::op_write_dpi(uint8 &r, uint8 &i) {
2189
{
2190
  158, // dp = op_readpc() + regs.y;
2191
  1, // op_io();
2192
  140, // op_readdp(dp);
2193
  157, // op_writedp(dp, regs.x);
2194
  2, // //!!NEXT
2195
},
2196
//   case 0xda: return op_stw_dp();
2197
//   void SMPcore::op_stw_dp() {
2198
{
2199
  9, // dp = op_readpc();
2200
  140, // op_readdp(dp);
2201
  159, // op_writedp(dp++, regs.a);
2202
  160, // op_writedp(dp++, regs.y);
2203
  2, // //!!NEXT
2204
},
2205
//   case 0xdb: return op_write_dpi(regs.y, regs.x);
2206
//   void SMPcore::op_write_dpi(uint8 &r, uint8 &i) {
2207
{
2208
  22, // dp = op_readpc() + regs.x;
2209
  1, // op_io();
2210
  140, // op_readdp(dp);
2211
  150, // op_writedp(dp, regs.y);
2212
  2, // //!!NEXT
2213
},
2214
//   case 0xdc: return op_adjust<&SMPcore::op_dec>(regs.y);
2215
//   void SMPcore::op_adjust(uint8 &r) {
2216
{
2217
  1, // op_io();
2218
  161, // regs.y = op_dec(regs.y);
2219
  2, // //!!NEXT
2220
},
2221
//   case 0xdd: return op_transfer(regs.y, regs.a);
2222
//   void SMPcore::op_transfer(uint8 &from, uint8 &to) {
2223
{
2224
  1, // op_io();
2225
  162, // regs.a = regs.y;
2226
  109, // regs.p.n = (regs.a & 0x80);
2227
  110, // regs.p.z = (regs.a == 0);
2228
  2, // //!!NEXT
2229
},
2230
//   case 0xde: return op_bne_dpx();
2231
//   void SMPcore::op_bne_dpx() {
2232
{
2233
  9, // dp = op_readpc();
2234
  1, // op_io();
2235
  163, // sp = op_readdp(dp + regs.x);
2236
  13, // rd = op_readpc();
2237
  1, // op_io();
2238
  71, // if(regs.a == sp) return;
2239
  1, // op_io();
2240
  1, // op_io();
2241
  15, // regs.pc += (int8)rd;
2242
  2, // //!!NEXT
2243
},
2244
//   case 0xdf: return op_daa();
2245
//   void SMPcore::op_daa() {
2246
{
2247
  1, // op_io();
2248
  1, // op_io();
2249
  //if(regs.p.c || (regs.a) > 0x99) {
2250
  //regs.a += 0x60;
2251
  //regs.p.c = 1;
2252
  //}
2253
  //if(regs.p.h || (regs.a & 15) > 0x09) {
2254
  //regs.a += 0x06;
2255
  //}
2256
  //regs.p.n = (regs.a & 0x80);
2257
  //regs.p.z = (regs.a == 0);
2258
  164, // //!!MULTI3
2259
  2, // //!!NEXT
2260
},
2261
//   case 0xe0: return op_clv();
2262
//   void SMPcore::op_clv() {
2263
{
2264
  1, // op_io();
2265
  165, // regs.p.v = 0;
2266
  166, // regs.p.h = 0;
2267
  2, // //!!NEXT
2268
},
2269
//   case 0xe1: return op_jst();
2270
//   void SMPcore::op_jst() {
2271
{
2272
  3, // dp = 0xffde - ((opcode >> 4) << 1);
2273
  4, // rd.l = op_read(dp++);
2274
  5, // rd.h = op_read(dp++);
2275
  1, // op_io();
2276
  1, // op_io();
2277
  1, // op_io();
2278
  6, // op_writesp(regs.pc.h);
2279
  7, // op_writesp(regs.pc.l);
2280
  8, // regs.pc = rd;
2281
  2, // //!!NEXT
2282
},
2283
//   case 0xe2: return op_set_bit();
2284
//   void SMPcore::op_set_bit() {
2285
{
2286
  9, // dp = op_readpc();
2287
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
2288
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
2289
  2, // //!!NEXT
2290
},
2291
//   case 0xe3: return op_branch_bit();
2292
//   void SMPcore::op_branch_bit() {
2293
{
2294
  9, // dp = op_readpc();
2295
  12, // sp = op_readdp(dp);
2296
  13, // rd = op_readpc();
2297
  1, // op_io();
2298
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
2299
  1, // op_io();
2300
  1, // op_io();
2301
  15, // regs.pc += (int8)rd;
2302
  2, // //!!NEXT
2303
},
2304
//   case 0xe4: return op_read_dp<&SMPcore::op_ld>(regs.a);
2305
//   void SMPcore::op_read_dp(uint8 &r) {
2306
{
2307
  9, // dp = op_readpc();
2308
  16, // rd = op_readdp(dp);
2309
  167, // regs.a = op_ld(regs.a, rd);
2310
  2, // //!!NEXT
2311
},
2312
//   case 0xe5: return op_read_addr<&SMPcore::op_ld>(regs.a);
2313
//   void SMPcore::op_read_addr(uint8 &r) {
2314
{
2315
  18, // dp.l = op_readpc();
2316
  19, // dp.h = op_readpc();
2317
  20, // rd = op_read(dp);
2318
  167, // regs.a = op_ld(regs.a, rd);
2319
  2, // //!!NEXT
2320
},
2321
//   case 0xe6: return op_read_ix<&SMPcore::op_ld>();
2322
//   void SMPcore::op_read_ix() {
2323
{
2324
  1, // op_io();
2325
  21, // rd = op_readdp(regs.x);
2326
  167, // regs.a = op_ld(regs.a, rd);
2327
  2, // //!!NEXT
2328
},
2329
//   case 0xe7: return op_read_idpx<&SMPcore::op_ld>();
2330
//   void SMPcore::op_read_idpx() {
2331
{
2332
  22, // dp = op_readpc() + regs.x;
2333
  1, // op_io();
2334
  23, // sp.l = op_readdp(dp++);
2335
  24, // sp.h = op_readdp(dp++);
2336
  25, // rd = op_read(sp);
2337
  167, // regs.a = op_ld(regs.a, rd);
2338
  2, // //!!NEXT
2339
},
2340
//   case 0xe8: return op_read_const<&SMPcore::op_ld>(regs.a);
2341
//   void SMPcore::op_read_const(uint8 &r) {
2342
{
2343
  13, // rd = op_readpc();
2344
  167, // regs.a = op_ld(regs.a, rd);
2345
  2, // //!!NEXT
2346
},
2347
//   case 0xe9: return op_read_addr<&SMPcore::op_ld>(regs.x);
2348
//   void SMPcore::op_read_addr(uint8 &r) {
2349
{
2350
  18, // dp.l = op_readpc();
2351
  19, // dp.h = op_readpc();
2352
  20, // rd = op_read(dp);
2353
  152, // regs.x = op_ld(regs.x, rd);
2354
  2, // //!!NEXT
2355
},
2356
//   case 0xea: return op_set_addr_bit();
2357
//   void SMPcore::op_set_addr_bit() {
2358
{
2359
  18, // dp.l = op_readpc();
2360
  19, // dp.h = op_readpc();
2361
  31, // bit = dp >> 13;
2362
  32, // dp &= 0x1fff;
2363
  20, // rd = op_read(dp);
2364
  168, // rd ^= 1 << bit;
2365
  36, // op_write(dp, rd);
2366
  2, // //!!NEXT
2367
},
2368
//   case 0xeb: return op_read_dp<&SMPcore::op_ld>(regs.y);
2369
//   void SMPcore::op_read_dp(uint8 &r) {
2370
{
2371
  9, // dp = op_readpc();
2372
  16, // rd = op_readdp(dp);
2373
  117, // regs.y = op_ld(regs.y, rd);
2374
  2, // //!!NEXT
2375
},
2376
//   case 0xec: return op_read_addr<&SMPcore::op_ld>(regs.y);
2377
//   void SMPcore::op_read_addr(uint8 &r) {
2378
{
2379
  18, // dp.l = op_readpc();
2380
  19, // dp.h = op_readpc();
2381
  20, // rd = op_read(dp);
2382
  117, // regs.y = op_ld(regs.y, rd);
2383
  2, // //!!NEXT
2384
},
2385
//   case 0xed: return op_cmc();
2386
//   void SMPcore::op_cmc() {
2387
{
2388
  1, // op_io();
2389
  1, // op_io();
2390
  169, // regs.p.c = !regs.p.c;
2391
  2, // //!!NEXT
2392
},
2393
//   case 0xee: return op_pull(regs.y);
2394
//   void SMPcore::op_pull(uint8 &r) {
2395
{
2396
  1, // op_io();
2397
  1, // op_io();
2398
  170, // regs.y = op_readsp();
2399
  2, // //!!NEXT
2400
},
2401
//   case 0xef: return op_wait();
2402
//   void SMPcore::op_wait() {
2403
{
2404
  1, // op_io();
2405
  1, // op_io();
2406
  171, // //!!REPEAT
2407
},
2408
//   case 0xf0: return op_branch(regs.p.z == 1);
2409
//   void SMPcore::op_branch(bool condition) {
2410
{
2411
  13, // rd = op_readpc();
2412
  172, // if(regs.p.z != 1) return;
2413
  1, // op_io();
2414
  1, // op_io();
2415
  15, // regs.pc += (int8)rd;
2416
  2, // //!!NEXT
2417
},
2418
//   case 0xf1: return op_jst();
2419
//   void SMPcore::op_jst() {
2420
{
2421
  3, // dp = 0xffde - ((opcode >> 4) << 1);
2422
  4, // rd.l = op_read(dp++);
2423
  5, // rd.h = op_read(dp++);
2424
  1, // op_io();
2425
  1, // op_io();
2426
  1, // op_io();
2427
  6, // op_writesp(regs.pc.h);
2428
  7, // op_writesp(regs.pc.l);
2429
  8, // regs.pc = rd;
2430
  2, // //!!NEXT
2431
},
2432
//   case 0xf2: return op_set_bit();
2433
//   void SMPcore::op_set_bit() {
2434
{
2435
  9, // dp = op_readpc();
2436
  10, // rd = op_readdp(dp) & ~(1 << (opcode >> 5));
2437
  11, // op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
2438
  2, // //!!NEXT
2439
},
2440
//   case 0xf3: return op_branch_bit();
2441
//   void SMPcore::op_branch_bit() {
2442
{
2443
  9, // dp = op_readpc();
2444
  12, // sp = op_readdp(dp);
2445
  13, // rd = op_readpc();
2446
  1, // op_io();
2447
  14, // if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) return;
2448
  1, // op_io();
2449
  1, // op_io();
2450
  15, // regs.pc += (int8)rd;
2451
  2, // //!!NEXT
2452
},
2453
//   case 0xf4: return op_read_dpi<&SMPcore::op_ld>(regs.a, regs.x);
2454
//   void SMPcore::op_read_dpi(uint8 &r, uint8 &i) {
2455
{
2456
  9, // dp = op_readpc();
2457
  1, // op_io();
2458
  47, // rd = op_readdp(dp + regs.x);
2459
  167, // regs.a = op_ld(regs.a, rd);
2460
  2, // //!!NEXT
2461
},
2462
//   case 0xf5: return op_read_addri<&SMPcore::op_ld>(regs.x);
2463
//   void SMPcore::op_read_addri(uint8 &r) {
2464
{
2465
  18, // dp.l = op_readpc();
2466
  19, // dp.h = op_readpc();
2467
  1, // op_io();
2468
  48, // rd = op_read(dp + regs.x);
2469
  167, // regs.a = op_ld(regs.a, rd);
2470
  2, // //!!NEXT
2471
},
2472
//   case 0xf6: return op_read_addri<&SMPcore::op_ld>(regs.y);
2473
//   void SMPcore::op_read_addri(uint8 &r) {
2474
{
2475
  18, // dp.l = op_readpc();
2476
  19, // dp.h = op_readpc();
2477
  1, // op_io();
2478
  49, // rd = op_read(dp + regs.y);
2479
  167, // regs.a = op_ld(regs.a, rd);
2480
  2, // //!!NEXT
2481
},
2482
//   case 0xf7: return op_read_idpy<&SMPcore::op_ld>();
2483
//   void SMPcore::op_read_idpy() {
2484
{
2485
  9, // dp = op_readpc();
2486
  1, // op_io();
2487
  23, // sp.l = op_readdp(dp++);
2488
  24, // sp.h = op_readdp(dp++);
2489
  50, // rd = op_read(sp + regs.y);
2490
  167, // regs.a = op_ld(regs.a, rd);
2491
  2, // //!!NEXT
2492
},
2493
//   case 0xf8: return op_read_dp<&SMPcore::op_ld>(regs.x);
2494
//   void SMPcore::op_read_dp(uint8 &r) {
2495
{
2496
  9, // dp = op_readpc();
2497
  16, // rd = op_readdp(dp);
2498
  152, // regs.x = op_ld(regs.x, rd);
2499
  2, // //!!NEXT
2500
},
2501
//   case 0xf9: return op_read_dpi<&SMPcore::op_ld>(regs.x, regs.y);
2502
//   void SMPcore::op_read_dpi(uint8 &r, uint8 &i) {
2503
{
2504
  9, // dp = op_readpc();
2505
  1, // op_io();
2506
  173, // rd = op_readdp(dp + regs.y);
2507
  152, // regs.x = op_ld(regs.x, rd);
2508
  2, // //!!NEXT
2509
},
2510
//   case 0xfa: return op_write_dp_dp<&SMPcore::op_st>();
2511
//   void SMPcore::op_write_dp_dp() {
2512
{
2513
  26, // sp = op_readpc();
2514
  27, // rd = op_readdp(sp);
2515
  9, // dp = op_readpc();
2516
  118, // wr = op_st(wr, rd);
2517
  30, // op_writedp(dp, wr);
2518
  2, // //!!NEXT
2519
},
2520
//   case 0xfb: return op_read_dpi<&SMPcore::op_ld>(regs.y, regs.x);
2521
//   void SMPcore::op_read_dpi(uint8 &r, uint8 &i) {
2522
{
2523
  9, // dp = op_readpc();
2524
  1, // op_io();
2525
  47, // rd = op_readdp(dp + regs.x);
2526
  117, // regs.y = op_ld(regs.y, rd);
2527
  2, // //!!NEXT
2528
},
2529
//   case 0xfc: return op_adjust<&SMPcore::op_inc>(regs.y);
2530
//   void SMPcore::op_adjust(uint8 &r) {
2531
{
2532
  1, // op_io();
2533
  174, // regs.y = op_inc(regs.y);
2534
  2, // //!!NEXT
2535
},
2536
//   case 0xfd: return op_transfer(regs.a, regs.y);
2537
//   void SMPcore::op_transfer(uint8 &from, uint8 &to) {
2538
{
2539
  1, // op_io();
2540
  175, // regs.y = regs.a;
2541
  176, // regs.p.n = (regs.y & 0x80);
2542
  177, // regs.p.z = (regs.y == 0);
2543
  2, // //!!NEXT
2544
},
2545
//   case 0xfe: return op_bne_ydec();
2546
//   void SMPcore::op_bne_ydec() {
2547
{
2548
  13, // rd = op_readpc();
2549
  1, // op_io();
2550
  1, // op_io();
2551
  178, // if(--regs.y == 0) return;
2552
  1, // op_io();
2553
  1, // op_io();
2554
  15, // regs.pc += (int8)rd;
2555
  2, // //!!NEXT
2556
},
2557
//   case 0xff: return op_wait();
2558
//   void SMPcore::op_wait() {
2559
{
2560
  1, // op_io();
2561
  1, // op_io();
2562
  171, // //!!REPEAT
2563
},
2564

2565
}; // const int uoptable[][] = {
2566

2567

2568

2569

2570
void SMPcore::op_step()
2571
{
2572
  switch (uoptable[opcode][uindex])
2573
  {
2574
    case 1:
2575
      op_io();
2576
      break;
2577
    case 2:
2578
      op_next();//!!NEXT
2579
      break;
2580
    case 3:
2581
      dp = 0xffde - ((opcode >> 4) << 1);
2582
      break;
2583
    case 4:
2584
      rd.l = op_read(dp++);
2585
      break;
2586
    case 5:
2587
      rd.h = op_read(dp++);
2588
      break;
2589
    case 6:
2590
      op_writesp(regs.pc.h);
2591
      break;
2592
    case 7:
2593
      op_writesp(regs.pc.l);
2594
      break;
2595
    case 8:
2596
      regs.pc = rd;
2597
      break;
2598
    case 9:
2599
      dp = op_readpc();
2600
      break;
2601
    case 10:
2602
      rd = op_readdp(dp) & ~(1 << (opcode >> 5));
2603
      break;
2604
    case 11:
2605
      op_writedp(dp, rd | (!(opcode & 0x10) << (opcode >> 5)));
2606
      break;
2607
    case 12:
2608
      sp = op_readdp(dp);
2609
      break;
2610
    case 13:
2611
      rd = op_readpc();
2612
      break;
2613
    case 14:
2614
      if((bool)(sp & (1 << (opcode >> 5))) == (bool)(opcode & 0x10)) op_next();
2615
      break;
2616
    case 15:
2617
      regs.pc += (int8)rd;
2618
      break;
2619
    case 16:
2620
      rd = op_readdp(dp);
2621
      break;
2622
    case 17:
2623
      regs.a = op_or(regs.a, rd);
2624
      break;
2625
    case 18:
2626
      dp.l = op_readpc();
2627
      break;
2628
    case 19:
2629
      dp.h = op_readpc();
2630
      break;
2631
    case 20:
2632
      rd = op_read(dp);
2633
      break;
2634
    case 21:
2635
      rd = op_readdp(regs.x);
2636
      break;
2637
    case 22:
2638
      dp = op_readpc() + regs.x;
2639
      break;
2640
    case 23:
2641
      sp.l = op_readdp(dp++);
2642
      break;
2643
    case 24:
2644
      sp.h = op_readdp(dp++);
2645
      break;
2646
    case 25:
2647
      rd = op_read(sp);
2648
      break;
2649
    case 26:
2650
      sp = op_readpc();
2651
      break;
2652
    case 27:
2653
      rd = op_readdp(sp);
2654
      break;
2655
    case 28:
2656
      wr = op_readdp(dp);
2657
      break;
2658
    case 29:
2659
      wr = op_or(wr, rd);
2660
      break;
2661
    case 30:
2662
      op_writedp(dp, wr);
2663
      break;
2664
    case 31:
2665
      bit = dp >> 13;
2666
      break;
2667
    case 32:
2668
      dp &= 0x1fff;
2669
      break;
2670
    case 33:
2671
      regs.p.c |= (rd & (1 << bit)) ^ 0;
2672
      break;
2673
    case 34:
2674
      rd = op_asl(rd);
2675
      break;
2676
    case 35:
2677
      op_writedp(dp, rd);
2678
      break;
2679
    case 36:
2680
      op_write(dp, rd);
2681
      break;
2682
    case 37:
2683
      op_writesp(regs.p);
2684
      break;
2685
    case 38:
2686
      regs.p.n = (regs.a - rd) & 0x80;
2687
      break;
2688
    case 39:
2689
      regs.p.z = (regs.a - rd) == 0;
2690
      break;
2691
    case 40:
2692
      op_read(dp);
2693
      break;
2694
    case 41:
2695
      op_write(dp, rd | regs.a);
2696
      break;
2697
    case 42:
2698
      rd.l = op_read(0xffde);
2699
      break;
2700
    case 43:
2701
      rd.h = op_read(0xffdf);
2702
      break;
2703
    case 44:
2704
      regs.p.b = 1;
2705
      break;
2706
    case 45:
2707
      regs.p.i = 0;
2708
      break;
2709
    case 46:
2710
      if(regs.p.n != 0) op_next();
2711
      break;
2712
    case 47:
2713
      rd = op_readdp(dp + regs.x);
2714
      break;
2715
    case 48:
2716
      rd = op_read(dp + regs.x);
2717
      break;
2718
    case 49:
2719
      rd = op_read(dp + regs.y);
2720
      break;
2721
    case 50:
2722
      rd = op_read(sp + regs.y);
2723
      break;
2724
    case 51:
2725
      rd = op_readdp(regs.y);
2726
      break;
2727
    case 52:
2728
      wr = op_readdp(regs.x);
2729
      break;
2730
    case 53:
2731
      op_writedp(regs.x, wr);
2732
      break;
2733
    case 54:
2734
      rd.w = op_readdp(dp) - 1;
2735
      break;
2736
    case 55:
2737
      op_writedp(dp++, rd.l);
2738
      break;
2739
    case 56:
2740
      rd.h += op_readdp(dp);
2741
      break;
2742
    case 57:
2743
      op_writedp(dp++, rd.h);
2744
      break;
2745
    case 58:
2746
      regs.p.n = rd & 0x8000;
2747
      break;
2748
    case 59:
2749
      regs.p.z = rd == 0;
2750
      break;
2751
    case 60:
2752
      op_writedp(dp + regs.x, rd);
2753
      break;
2754
    case 61:
2755
      regs.a = op_asl(regs.a);
2756
      break;
2757
    case 62:
2758
      regs.x = op_dec(regs.x);
2759
      break;
2760
    case 63:
2761
      regs.x = op_cmp(regs.x, rd);
2762
      break;
2763
    case 64:
2764
      dp += regs.x;
2765
      break;
2766
    case 65:
2767
      regs.p.p = 0;
2768
      break;
2769
    case 66:
2770
      regs.a = op_and(regs.a, rd);
2771
      break;
2772
    case 67:
2773
      wr = op_and(wr, rd);
2774
      break;
2775
    case 68:
2776
      regs.p.c |= (rd & (1 << bit)) ^ 1;
2777
      break;
2778
    case 69:
2779
      rd = op_rol(rd);
2780
      break;
2781
    case 70:
2782
      op_writesp(regs.a);
2783
      break;
2784
    case 71:
2785
      if(regs.a == sp) op_next();
2786
      break;
2787
    case 72:
2788
      if(regs.p.n != 1) op_next();
2789
      break;
2790
    case 73:
2791
      rd.w = op_readdp(dp) + 1;
2792
      break;
2793
    case 74:
2794
      regs.a = op_rol(regs.a);
2795
      break;
2796
    case 75:
2797
      regs.x = op_inc(regs.x);
2798
      break;
2799
    case 76:
2800
      rd.l = op_readpc();
2801
      break;
2802
    case 77:
2803
      rd.h = op_readpc();
2804
      break;
2805
    case 78:
2806
      regs.p.p = 1;
2807
      break;
2808
    case 79:
2809
      regs.a = op_eor(regs.a, rd);
2810
      break;
2811
    case 80:
2812
      wr = op_eor(wr, rd);
2813
      break;
2814
    case 81:
2815
      regs.p.c &= (rd & (1 << bit)) ^ 0;
2816
      break;
2817
    case 82:
2818
      rd = op_lsr(rd);
2819
      break;
2820
    case 83:
2821
      op_writesp(regs.x);
2822
      break;
2823
    case 84:
2824
      op_write(dp, rd & ~regs.a);
2825
      break;
2826
    case 85:
2827
      regs.pc = 0xff00 | rd;
2828
      break;
2829
    case 86:
2830
      if(regs.p.v != 0) op_next();
2831
      break;
2832
    case 87:
2833
      rd.l = op_readdp(dp++);
2834
      break;
2835
    case 88:
2836
      rd.h = op_readdp(dp++);
2837
      break;
2838
    case 89:
2839
      regs.ya = op_cpw(regs.ya, rd);
2840
      break;
2841
    case 90:
2842
      regs.a = op_lsr(regs.a);
2843
      break;
2844
    case 91:
2845
      regs.x = regs.a;
2846
      break;
2847
    case 92:
2848
      regs.p.n = (regs.x & 0x80);
2849
      break;
2850
    case 93:
2851
      regs.p.z = (regs.x == 0);
2852
      break;
2853
    case 94:
2854
      regs.y = op_cmp(regs.y, rd);
2855
      break;
2856
    case 95:
2857
      regs.p.c = 0;
2858
      break;
2859
    case 96:
2860
      regs.a = op_cmp(regs.a, rd);
2861
      break;
2862
    case 97:
2863
      wr = op_cmp(wr, rd);
2864
      break;
2865
    case 98:
2866
      regs.p.c &= (rd & (1 << bit)) ^ 1;
2867
      break;
2868
    case 99:
2869
      rd = op_ror(rd);
2870
      break;
2871
    case 100:
2872
      op_writesp(regs.y);
2873
      break;
2874
    case 101:
2875
      op_writedp(dp, --wr);
2876
      break;
2877
    case 102:
2878
      if(wr == 0) op_next();
2879
      break;
2880
    case 103:
2881
      rd.l = op_readsp();
2882
      break;
2883
    case 104:
2884
      rd.h = op_readsp();
2885
      break;
2886
    case 105:
2887
      if(regs.p.v != 1) op_next();
2888
      break;
2889
    case 106:
2890
      regs.ya = op_adw(regs.ya, rd);
2891
      break;
2892
    case 107:
2893
      regs.a = op_ror(regs.a);
2894
      break;
2895
    case 108:
2896
      regs.a = regs.x;
2897
      break;
2898
    case 109:
2899
      regs.p.n = (regs.a & 0x80);
2900
      break;
2901
    case 110:
2902
      regs.p.z = (regs.a == 0);
2903
      break;
2904
    case 111:
2905
      regs.p = op_readsp();
2906
      break;
2907
    case 112:
2908
      regs.p.c = 1;
2909
      break;
2910
    case 113:
2911
      regs.a = op_adc(regs.a, rd);
2912
      break;
2913
    case 114:
2914
      wr = op_adc(wr, rd);
2915
      break;
2916
    case 115:
2917
      regs.p.c ^= (bool)(rd & (1 << bit));
2918
      break;
2919
    case 116:
2920
      rd = op_dec(rd);
2921
      break;
2922
    case 117:
2923
      regs.y = op_ld(regs.y, rd);
2924
      break;
2925
    case 118:
2926
      wr = op_st(wr, rd);
2927
      break;
2928
    case 119:
2929
      if(regs.p.c != 0) op_next();
2930
      break;
2931
    case 120:
2932
      regs.ya = op_sbw(regs.ya, rd);
2933
      break;
2934
    case 121:
2935
      regs.a = op_dec(regs.a);
2936
      break;
2937
    case 122:
2938
      regs.x = regs.s;
2939
      break;
2940
    case 123:
2941
      //!!MULTI0
2942
	  ya = regs.ya;
2943
      //overflow set if quotient >= 256
2944
      regs.p.v = (regs.y >= regs.x);
2945
      regs.p.h = ((regs.y & 15) >= (regs.x & 15));
2946
      if(regs.y < (regs.x << 1)) {
2947
        //if quotient is <= 511 (will fit into 9-bit result)
2948
        regs.a = ya / regs.x;
2949
        regs.y = ya % regs.x;
2950
      } else {
2951
        //otherwise, the quotient won't fit into regs.p.v + regs.a
2952
        //this emulates the odd behavior of the S-SMP in this case
2953
        regs.a = 255    - (ya - (regs.x << 9)) / (256 - regs.x);
2954
        regs.y = regs.x + (ya - (regs.x << 9)) % (256 - regs.x);
2955
      }
2956
      //result is set based on a (quotient) only
2957
      regs.p.n = (regs.a & 0x80);
2958
      regs.p.z = (regs.a == 0);
2959
      break;
2960
    case 124:
2961
      regs.a = (regs.a >> 4) | (regs.a << 4);
2962
      break;
2963
    case 125:
2964
      regs.p.n = regs.a & 0x80;
2965
      break;
2966
    case 126:
2967
      regs.p.z = regs.a == 0;
2968
      break;
2969
    case 127:
2970
      regs.p.i = 1;
2971
      break;
2972
    case 128:
2973
      regs.a = op_sbc(regs.a, rd);
2974
      break;
2975
    case 129:
2976
      wr = op_sbc(wr, rd);
2977
      break;
2978
    case 130:
2979
      regs.p.c  = (rd & (1 << bit));
2980
      break;
2981
    case 131:
2982
      rd = op_inc(rd);
2983
      break;
2984
    case 132:
2985
      regs.a = op_readsp();
2986
      break;
2987
    case 133:
2988
      op_writedp(regs.x++, regs.a);
2989
      break;
2990
    case 134:
2991
      if(regs.p.c != 1) op_next();
2992
      break;
2993
    case 135:
2994
      regs.ya = op_ldw(regs.ya, rd);
2995
      break;
2996
    case 136:
2997
      regs.a = op_inc(regs.a);
2998
      break;
2999
    case 137:
3000
      regs.s = regs.x;
3001
      break;
3002
    case 138:
3003
      //!!MULTI1
3004
	  if(!regs.p.c || (regs.a) > 0x99) {
3005
        regs.a -= 0x60;
3006
        regs.p.c = 0;
3007
      }
3008
      if(!regs.p.h || (regs.a & 15) > 0x09) {
3009
        regs.a -= 0x06;
3010
      }
3011
      regs.p.n = (regs.a & 0x80);
3012
      regs.p.z = (regs.a == 0);
3013
      break;
3014
    case 139:
3015
      regs.a = op_readdp(regs.x++);
3016
      break;
3017
    case 140:
3018
      op_readdp(dp);
3019
      break;
3020
    case 141:
3021
      op_writedp(dp, regs.a);
3022
      break;
3023
    case 142:
3024
      op_write(dp, regs.a);
3025
      break;
3026
    case 143:
3027
      op_readdp(regs.x);
3028
      break;
3029
    case 144:
3030
      op_writedp(regs.x, regs.a);
3031
      break;
3032
    case 145:
3033
      sp = op_readpc() + regs.x;
3034
      break;
3035
    case 146:
3036
      dp.l = op_readdp(sp++);
3037
      break;
3038
    case 147:
3039
      dp.h = op_readdp(sp++);
3040
      break;
3041
    case 148:
3042
      op_write(dp, regs.x);
3043
      break;
3044
    case 149:
3045
      rd = (rd & ~(1 << bit)) | (regs.p.c << bit);
3046
      break;
3047
    case 150:
3048
      op_writedp(dp, regs.y);
3049
      break;
3050
    case 151:
3051
      op_write(dp, regs.y);
3052
      break;
3053
    case 152:
3054
      regs.x = op_ld(regs.x, rd);
3055
      break;
3056
    case 153:
3057
      regs.x = op_readsp();
3058
      break;
3059
    case 154:
3060
      //!!MULTI2
3061
      ya = regs.y * regs.a;
3062
      regs.a = ya;
3063
      regs.y = ya >> 8;
3064
      //result is set based on y (high-byte) only
3065
      regs.p.n = (regs.y & 0x80);
3066
      regs.p.z = (regs.y == 0);
3067
      break;
3068
    case 155:
3069
      if(regs.p.z != 0) op_next();
3070
      break;
3071
    case 156:
3072
      dp += regs.y;
3073
      break;
3074
    case 157:
3075
      op_writedp(dp, regs.x);
3076
      break;
3077
    case 158:
3078
      dp = op_readpc() + regs.y;
3079
      break;
3080
    case 159:
3081
      op_writedp(dp++, regs.a);
3082
      break;
3083
    case 160:
3084
      op_writedp(dp++, regs.y);
3085
      break;
3086
    case 161:
3087
      regs.y = op_dec(regs.y);
3088
      break;
3089
    case 162:
3090
      regs.a = regs.y;
3091
      break;
3092
    case 163:
3093
      sp = op_readdp(dp + regs.x);
3094
      break;
3095
    case 164:
3096
      //!!MULTI3
3097
	  if(regs.p.c || (regs.a) > 0x99) {
3098
        regs.a += 0x60;
3099
        regs.p.c = 1;
3100
      }
3101
      if(regs.p.h || (regs.a & 15) > 0x09) {
3102
        regs.a += 0x06;
3103
      }
3104
      regs.p.n = (regs.a & 0x80);
3105
      regs.p.z = (regs.a == 0);
3106
      break;
3107
    case 165:
3108
      regs.p.v = 0;
3109
      break;
3110
    case 166:
3111
      regs.p.h = 0;
3112
      break;
3113
    case 167:
3114
      regs.a = op_ld(regs.a, rd);
3115
      break;
3116
    case 168:
3117
      rd ^= 1 << bit;
3118
      break;
3119
    case 169:
3120
      regs.p.c = !regs.p.c;
3121
      break;
3122
    case 170:
3123
      regs.y = op_readsp();
3124
      break;
3125
    case 171:
3126
      uindex = -1; //!!REPEAT
3127
      break;
3128
    case 172:
3129
      if(regs.p.z != 1) op_next();
3130
      break;
3131
    case 173:
3132
      rd = op_readdp(dp + regs.y);
3133
      break;
3134
    case 174:
3135
      regs.y = op_inc(regs.y);
3136
      break;
3137
    case 175:
3138
      regs.y = regs.a;
3139
      break;
3140
    case 176:
3141
      regs.p.n = (regs.y & 0x80);
3142
      break;
3143
    case 177:
3144
      regs.p.z = (regs.y == 0);
3145
      break;
3146
    case 178:
3147
      if(--regs.y == 0) op_next();
3148
      break;
3149
  }
3150
  uindex++;
3151
}
3152

3153
Product

Resources

Company
