![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optestxp_gen.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Isaki's NoNo m68k/m88k emulator] / nono / exp / optestxp|
Return to optestxp_gen.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / exp / optestxp |
1.1 root 1: //
2: // nono
3: // Copyright (C) 2023 nono project
4: // Licensed under nono-license.txt
5: //
6:
1.1.1.2 ! root 7: #include "optestxp_subr.h"
1.1 root 8:
9: static std::vector<uint8> values1 = {
10: 0x00,
11: 0x01,
12: 0x0f,
13: 0x10,
14: 0x7f,
15: 0x80,
16: 0xff,
17: };
18: static std::vector<uint8> values2 = {
19: 0x00,
20: 0x01,
21: 0x03,
22: 0x55,
23: 0x7f,
24: 0xaa,
25: 0xff,
26: };
27:
28: static void
29: gentest_add()
30: {
31: init("add", "testrun2");
32:
1.1.1.2 ! root 33: out("testexec_%s:\n", testname);
1.1 root 34: out(" ADD A,D\n");
35: out(" RET\n");
36:
1.1.1.2 ! root 37: out_testset();
1.1 root 38:
39: for (auto dst : values1) {
40: for (auto src : values1) {
41: uint32 res32 = dst + src;
42: uint8 res = res32;
43: hd64180flag inflag;
44: inflag.N = true;
45: hd64180flag flag;
46: flag.Z = (res == 0);
47: flag.S = ((res & 0x80) != 0);
48: flag.C = ((res32 & 0x0100) != 0);
49: flag.PV = vflag_add(dst, src, res);
50: flag.H = hflag_add(dst, src);
51: flag.N = false;
52: out_testdata_run2(dst, inflag, src, res, flag);
53: }
54: }
55: out(" defb 0,0,0,0,0FFH\n");
56: out("\n");
57: }
58:
59: static void
60: gentest_adc()
61: {
62: init("adc", "testrun2");
63:
1.1.1.2 ! root 64: out("testexec_%s:\n", testname);
1.1 root 65: out(" ADC A,D\n");
66: out(" RET\n");
67:
1.1.1.2 ! root 68: out_testset();
1.1 root 69:
70: for (auto dst : values1) {
71: for (auto src : values1) {
72: for (int cin = 0; cin <= 1; cin++) {
73: uint32 res32 = dst + src + cin;
74: uint8 res = res32;
75: hd64180flag inflag;
76: inflag.C = cin;
77: inflag.N = true;
78: hd64180flag flag;
79: flag.Z = (res == 0);
80: flag.S = ((res & 0x80) != 0);
81: flag.C = ((res32 & 0x0100) != 0);
82: flag.PV = vflag_add(dst, src, res);
83: flag.H = hflag_add(dst, src) | hflag_add(src + dst, cin);
84: flag.N = false;
85: out_testdata_run2(dst, inflag, src, res, flag);
86: }
87: }
88: }
89: out(" defb 0,0,0,0,0FFH\n");
90: out("\n");
91: }
92:
93: static void
94: gentest_sub()
95: {
96: init("sub", "testrun2");
97:
1.1.1.2 ! root 98: out("testexec_%s:\n", testname);
1.1 root 99: out(" SUB D\n");
100: out(" RET\n");
101:
1.1.1.2 ! root 102: out_testset();
1.1 root 103:
104: for (auto dst : values1) {
105: for (auto src : values1) {
106: uint32 res32 = dst - src;
107: uint8 res = res32;
108: hd64180flag inflag;
109: inflag.N = false;
110: hd64180flag flag;
111: flag.Z = (res == 0);
112: flag.S = ((res & 0x80) != 0);
113: flag.C = ((res32 & 0x0100) != 0);
114: flag.PV = vflag_sub(dst, src, res);
115: flag.H = hflag_sub(dst, src);
116: flag.N = true;
117: out_testdata_run2(dst, inflag, src, res, flag);
118: }
119: }
120: out(" defb 0,0,0,0,0FFH\n");
121: out("\n");
122: }
123:
124: static void
125: gentest_sbc()
126: {
127: init("sbc", "testrun2");
128:
1.1.1.2 ! root 129: out("testexec_%s:\n", testname);
1.1 root 130: out(" SBC A,D\n");
131: out(" RET\n");
132:
1.1.1.2 ! root 133: out_testset();
1.1 root 134:
135: for (auto dst : values1) {
136: for (auto src : values1) {
137: for (int cin = 0; cin <= 1; cin++) {
138: uint32 res32 = dst - src - cin;
139: uint8 res = res32;
140: hd64180flag inflag;
141: inflag.C = cin;
142: inflag.N = false;
143: hd64180flag flag;
144: flag.Z = (res == 0);
145: flag.S = ((res & 0x80) != 0);
146: flag.C = ((res32 & 0x0100) != 0);
147: flag.PV = vflag_sub(dst, src, res);
148: flag.H = hflag_sub(dst, src) | hflag_sub(dst - src, cin);
149: flag.N = true;
150: out_testdata_run2(dst, inflag, src, res, flag);
151: }
152: }
153: }
154: out(" defb 0,0,0,0,0FFH\n");
155: out("\n");
156: }
157:
158: static void
159: gentest_and()
160: {
161: init("and", "testrun2");
162:
1.1.1.2 ! root 163: out("testexec_%s:\n", testname);
1.1 root 164: out(" AND D\n");
165: out(" RET\n");
166:
1.1.1.2 ! root 167: out_testset();
1.1 root 168:
169: for (auto dst : values2) {
170: for (auto src : values2) {
171: uint32 res32 = dst & src;
172: uint8 res = res32;
173: hd64180flag inflag;
174: inflag.H = false;
175: inflag.N = true;
176: inflag.C = true;
177: hd64180flag flag;
178: flag.Z = (res == 0);
179: flag.S = ((res & 0x80) != 0);
180: flag.C = false;
181: flag.PV = pflag(res);
182: flag.H = true;
183: flag.N = false;
184: out_testdata_run2(dst, inflag, src, res, flag);
185: }
186: }
187: out(" defb 0,0,0,0,0FFH\n");
188: out("\n");
189: }
190:
191: static void
192: gentest_or()
193: {
194: init("or", "testrun2");
195:
1.1.1.2 ! root 196: out("testexec_%s:\n", testname);
1.1 root 197: out(" OR D\n");
198: out(" RET\n");
199:
1.1.1.2 ! root 200: out_testset();
1.1 root 201:
202: for (auto dst : values2) {
203: for (auto src : values2) {
204: uint32 res32 = dst | src;
205: uint8 res = res32;
206: hd64180flag inflag;
207: inflag.H = true;
208: inflag.N = true;
209: inflag.C = true;
210: hd64180flag flag;
211: flag.Z = (res == 0);
212: flag.S = ((res & 0x80) != 0);
213: flag.C = false;
214: flag.PV = pflag(res);
215: flag.H = false;
216: flag.N = false;
217: out_testdata_run2(dst, inflag, src, res, flag);
218: }
219: }
220: out(" defb 0,0,0,0,0FFH\n");
221: out("\n");
222: }
223:
224: static void
225: gentest_xor()
226: {
227: init("xor", "testrun2");
228:
1.1.1.2 ! root 229: out("testexec_%s:\n", testname);
1.1 root 230: out(" XOR D\n");
231: out(" RET\n");
232:
1.1.1.2 ! root 233: out_testset();
1.1 root 234:
235: for (auto dst : values2) {
236: for (auto src : values2) {
237: uint32 res32 = dst ^ src;
238: uint8 res = res32;
239: hd64180flag inflag;
240: inflag.H = true;
241: inflag.N = true;
242: inflag.C = true;
243: hd64180flag flag;
244: flag.Z = (res == 0);
245: flag.S = ((res & 0x80) != 0);
246: flag.C = false;
247: flag.PV = pflag(res);
248: flag.H = false;
249: flag.N = false;
250: out_testdata_run2(dst, inflag, src, res, flag);
251: }
252: }
253: out(" defb 0,0,0,0,0FFH\n");
254: out("\n");
255: }
256:
257: static void
258: gentest_cp()
259: {
260: init("cp", "testrun2");
261:
1.1.1.2 ! root 262: out("testexec_%s:\n", testname);
1.1 root 263: out(" CP D\n");
264: out(" RET\n");
265:
1.1.1.2 ! root 266: out_testset();
1.1 root 267:
268: for (auto dst : values1) {
269: for (auto src : values1) {
270: uint32 res32 = dst - src;
271: uint8 res = res32;
272: hd64180flag inflag;
273: inflag.N = false;
274: hd64180flag flag;
275: flag.Z = (res == 0);
276: flag.S = ((res & 0x80) != 0);
277: flag.C = ((res32 & 0x0100) != 0);
278: flag.PV = vflag_sub(dst, src, res);
279: flag.H = hflag_sub(dst, src);
280: flag.N = true;
281: out_testdata_run2(dst, inflag, src, dst, flag);
282: }
283: }
284: out(" defb 0,0,0,0,0FFH\n");
285: out("\n");
286: }
287:
288: static void
289: gentest_inc()
290: {
291: init("inc", "testrun1");
292:
1.1.1.2 ! root 293: out("testexec_%s:\n", testname);
1.1 root 294: out(" INC A\n");
295: out(" RET\n");
296:
1.1.1.2 ! root 297: out_testset();
1.1 root 298:
299: for (auto dst : values1) {
300: for (int cin = 0; cin <= 1; cin++) {
301: uint32 res32 = dst + 1;
302: uint8 res = res32;
303: hd64180flag inflag;
304: inflag.C = cin;
305: inflag.N = true;
306: hd64180flag flag;
307: flag.Z = (res == 0);
308: flag.S = ((res & 0x80) != 0);
309: flag.C = cin;
310: flag.PV = vflag_add(dst, 1, res);
311: flag.H = hflag_add(dst, 1);
312: flag.N = false;
313: out_testdata_run1(dst, inflag, res, flag);
314: }
315: }
316: out(" defb 0,0,0,0FFH\n");
317: out("\n");
318: }
319:
320: static void
321: gentest_dec()
322: {
323: init("dec", "testrun1");
324:
1.1.1.2 ! root 325: out("testexec_%s:\n", testname);
1.1 root 326: out(" DEC A\n");
327: out(" RET\n");
328:
1.1.1.2 ! root 329: out_testset();
1.1 root 330:
331: for (auto dst : values1) {
332: for (int cin = 0; cin <= 1; cin++) {
333: uint32 res32 = dst - 1;
334: uint8 res = res32;
335: hd64180flag inflag;
336: inflag.C = cin;
337: inflag.N = false;
338: hd64180flag flag;
339: flag.Z = (res == 0);
340: flag.S = ((res & 0x80) != 0);
341: flag.C = cin;
342: flag.PV = vflag_sub(dst, 1, res);
343: flag.H = hflag_sub(dst, 1);
344: flag.N = true;
345: out_testdata_run1(dst, inflag, res, flag);
346: }
347: }
348: out(" defb 0,0,0,0FFH\n");
349: out("\n");
350: }
351:
352: static void
353: gentest_neg()
354: {
355: init("neg", "testrun1");
356:
1.1.1.2 ! root 357: out("testexec_%s:\n", testname);
1.1 root 358: out(" NEG\n");
359: out(" RET\n");
360:
1.1.1.2 ! root 361: out_testset();
1.1 root 362:
363: for (auto dst : values1) {
364: uint32 res32 = 0 - dst;
365: uint8 res = res32;
366: hd64180flag inflag;
367: inflag.N = false;
368: hd64180flag flag;
369: flag.Z = (res == 0);
370: flag.S = ((res & 0x80) != 0);
371: flag.C = ((res32 & 0x100) != 0);
372: flag.PV = vflag_sub(0, dst, res);
373: flag.H = hflag_sub(0, dst);
374: flag.N = true;
375: out_testdata_run1(dst, inflag, res, flag);
376: }
377: out(" defb 0,0,0,0FFH\n");
378: out("\n");
379: }
380:
381: static void
382: gentest_cpl()
383: {
384: init("cpl", "testrun1");
385:
1.1.1.2 ! root 386: out("testexec_%s:\n", testname);
1.1 root 387: out(" CPL\n");
388: out(" RET\n");
389:
1.1.1.2 ! root 390: out_testset();
1.1 root 391:
392: bool fin = false;
393: for (auto dst : values2) {
394: fin = !fin;
395: uint32 res32 = ~dst;
396: uint8 res = res32;
397: hd64180flag inflag;
398: inflag.Z = fin;
399: inflag.S = fin;
400: inflag.C = fin;
401: inflag.PV = fin;
402: inflag.N = false;
403: inflag.H = false;
404: hd64180flag flag;
405: flag.Z = fin;
406: flag.S = fin;
407: flag.C = fin;
408: flag.PV = fin;
409: flag.H = true;
410: flag.N = true;
411: out_testdata_run1(dst, inflag, res, flag);
412: }
413: out(" defb 0,0,0,0FFH\n");
414: out("\n");
415: }
416:
417: static void
418: gentest_rla()
419: {
420: init("rla", "testrun1");
421:
1.1.1.2 ! root 422: out("testexec_%s:\n", testname);
1.1 root 423: out(" RLA\n");
424: out(" RET\n");
425:
1.1.1.2 ! root 426: out_testset();
1.1 root 427:
428: bool fin = false;
429: for (auto dst : values2) {
430: fin = !fin;
431: for (int cin = 0; cin <= 1; cin++) {
432: uint32 res32 = dst << 1;
433: res32 |= cin;
434: uint8 res = res32;
435: hd64180flag inflag;
436: inflag.Z = fin;
437: inflag.S = fin;
438: inflag.C = cin;
439: inflag.PV = fin;
440: inflag.N = true;
441: inflag.H = true;
442: hd64180flag flag;
443: flag.Z = fin;
444: flag.S = fin;
445: flag.C = ((res32 & 0x100) != 0);
446: flag.PV = fin;
447: flag.H = false;
448: flag.N = false;
449: out_testdata_run1(dst, inflag, res, flag);
450: }
451: }
452: out(" defb 0,0,0,0FFH\n");
453: out("\n");
454: }
455:
456: static void
457: gentest_rra()
458: {
459: init("rra", "testrun1");
460:
1.1.1.2 ! root 461: out("testexec_%s:\n", testname);
1.1 root 462: out(" RRA\n");
463: out(" RET\n");
464:
1.1.1.2 ! root 465: out_testset();
1.1 root 466:
467: bool fin = false;
468: for (auto dst : values2) {
469: fin = !fin;
470: for (int cin = 0; cin <= 1; cin++) {
471: uint32 res32 = dst >> 1;
472: res32 |= cin ? 0x80 : 0;
473: uint8 res = res32;
474: hd64180flag inflag;
475: inflag.Z = fin;
476: inflag.S = fin;
477: inflag.C = cin;
478: inflag.PV = fin;
479: inflag.N = true;
480: inflag.H = true;
481: hd64180flag flag;
482: flag.Z = fin;
483: flag.S = fin;
484: flag.C = ((dst & 1) != 0);
485: flag.PV = fin;
486: flag.H = false;
487: flag.N = false;
488: out_testdata_run1(dst, inflag, res, flag);
489: }
490: }
491: out(" defb 0,0,0,0FFH\n");
492: out("\n");
493: }
494:
495: static void
496: gentest_rlca()
497: {
498: init("rlca", "testrun1");
499:
1.1.1.2 ! root 500: out("testexec_%s:\n", testname);
1.1 root 501: out(" RLCA\n");
502: out(" RET\n");
503:
1.1.1.2 ! root 504: out_testset();
1.1 root 505:
506: bool fin = false;
507: for (auto dst : values2) {
508: fin = !fin;
509: uint32 res32 = dst << 1;
510: res32 |= (res32 >> 8);
511: uint8 res = res32;
512: hd64180flag inflag;
513: inflag.Z = fin;
514: inflag.S = fin;
515: inflag.PV = fin;
516: inflag.N = true;
517: inflag.H = true;
518: hd64180flag flag;
519: flag.Z = fin;
520: flag.S = fin;
521: flag.C = ((res32 & 0x100) != 0);
522: flag.PV = fin;
523: flag.H = false;
524: flag.N = false;
525: out_testdata_run1(dst, inflag, res, flag);
526: }
527: out(" defb 0,0,0,0FFH\n");
528: out("\n");
529: }
530:
531: static void
532: gentest_rrca()
533: {
534: init("rrca", "testrun1");
535:
1.1.1.2 ! root 536: out("testexec_%s:\n", testname);
1.1 root 537: out(" RRCA\n");
538: out(" RET\n");
539:
1.1.1.2 ! root 540: out_testset();
1.1 root 541:
542: bool fin = false;
543: for (auto dst : values2) {
544: fin = !fin;
545: uint32 res32 = dst >> 1;
546: res32 |= dst << 7;
547: uint8 res = res32;
548: hd64180flag inflag;
549: inflag.Z = fin;
550: inflag.S = fin;
551: inflag.PV = fin;
552: inflag.N = true;
553: inflag.H = true;
554: hd64180flag flag;
555: flag.Z = fin;
556: flag.S = fin;
557: flag.C = ((dst & 1) != 0);
558: flag.PV = fin;
559: flag.H = false;
560: flag.N = false;
561: out_testdata_run1(dst, inflag, res, flag);
562: }
563: out(" defb 0,0,0,0FFH\n");
564: out("\n");
565: }
566:
567: static void
568: gentest_rl()
569: {
570: init("rl", "testrun1");
571:
1.1.1.2 ! root 572: out("testexec_%s:\n", testname);
1.1 root 573: out(" RL A\n");
574: out(" RET\n");
575:
1.1.1.2 ! root 576: out_testset();
1.1 root 577:
578: for (auto dst : values2) {
579: for (int cin = 0; cin <= 1; cin++) {
580: uint32 res32 = dst << 1;
581: res32 |= cin;
582: uint8 res = res32;
583: hd64180flag inflag;
584: inflag.C = cin;
585: inflag.N = true;
586: inflag.H = true;
587: hd64180flag flag;
588: flag.Z = (res == 0);
589: flag.S = ((res & 0x80) != 0);
590: flag.C = ((res32 & 0x100) != 0);
591: flag.PV = pflag(res);
592: flag.H = false;
593: flag.N = false;
594: out_testdata_run1(dst, inflag, res, flag);
595: }
596: }
597: out(" defb 0,0,0,0FFH\n");
598: out("\n");
599: }
600:
601: static void
602: gentest_rr()
603: {
604: init("rr", "testrun1");
605:
1.1.1.2 ! root 606: out("testexec_%s:\n", testname);
1.1 root 607: out(" RR A\n");
608: out(" RET\n");
609:
1.1.1.2 ! root 610: out_testset();
1.1 root 611:
612: for (auto dst : values2) {
613: for (int cin = 0; cin <= 1; cin++) {
614: uint32 res32 = dst >> 1;
615: res32 |= cin ? 0x80 : 0;
616: uint8 res = res32;
617: hd64180flag inflag;
618: inflag.C = cin;
619: inflag.N = true;
620: inflag.H = true;
621: hd64180flag flag;
622: flag.Z = (res == 0);
623: flag.S = ((res & 0x80) != 0);
624: flag.C = ((dst & 1) != 0);
625: flag.PV = pflag(res);
626: flag.H = false;
627: flag.N = false;
628: out_testdata_run1(dst, inflag, res, flag);
629: }
630: }
631: out(" defb 0,0,0,0FFH\n");
632: out("\n");
633: }
634:
635: static void
636: gentest_rlc()
637: {
638: init("rlc", "testrun1");
639:
1.1.1.2 ! root 640: out("testexec_%s:\n", testname);
1.1 root 641: out(" RLC A\n");
642: out(" RET\n");
643:
1.1.1.2 ! root 644: out_testset();
1.1 root 645:
646: for (auto dst : values2) {
647: uint32 res32 = dst << 1;
648: res32 |= (res32 >> 8);
649: uint8 res = res32;
650: hd64180flag inflag;
651: inflag.N = true;
652: inflag.H = true;
653: hd64180flag flag;
654: flag.Z = (res == 0);
655: flag.S = ((res & 0x80) != 0);
656: flag.C = ((res32 & 0x100) != 0);
657: flag.PV = pflag(res);
658: flag.H = false;
659: flag.N = false;
660: out_testdata_run1(dst, inflag, res, flag);
661: }
662: out(" defb 0,0,0,0FFH\n");
663: out("\n");
664: }
665:
666: static void
667: gentest_rrc()
668: {
669: init("rrc", "testrun1");
670:
1.1.1.2 ! root 671: out("testexec_%s:\n", testname);
1.1 root 672: out(" RRC A\n");
673: out(" RET\n");
674:
1.1.1.2 ! root 675: out_testset();
1.1 root 676:
677: for (auto dst : values2) {
678: uint32 res32 = dst >> 1;
679: res32 |= dst << 7;
680: uint8 res = res32;
681: hd64180flag inflag;
682: inflag.N = true;
683: inflag.H = true;
684: hd64180flag flag;
685: flag.Z = (res == 0);
686: flag.S = ((res & 0x80) != 0);
687: flag.C = ((dst & 1) != 0);
688: flag.PV = pflag(res);
689: flag.H = false;
690: flag.N = false;
691: out_testdata_run1(dst, inflag, res, flag);
692: }
693: out(" defb 0,0,0,0FFH\n");
694: out("\n");
695: }
696:
697: static void
698: gentest_sla()
699: {
700: init("sla", "testrun1");
701:
1.1.1.2 ! root 702: out("testexec_%s:\n", testname);
1.1 root 703: out(" SLA A\n");
704: out(" RET\n");
705:
1.1.1.2 ! root 706: out_testset();
1.1 root 707:
708: for (auto dst : values2) {
709: uint32 res32 = dst << 1;
710: uint8 res = res32;
711: hd64180flag inflag;
712: inflag.N = true;
713: inflag.H = true;
714: hd64180flag flag;
715: flag.Z = (res == 0);
716: flag.S = ((res & 0x80) != 0);
717: flag.C = ((res32 & 0x100) != 0);
718: flag.PV = pflag(res);
719: flag.H = false;
720: flag.N = false;
721: out_testdata_run1(dst, inflag, res, flag);
722: }
723: out(" defb 0,0,0,0FFH\n");
724: out("\n");
725: }
726:
727: static void
728: gentest_sra()
729: {
730: init("sra", "testrun1");
731:
1.1.1.2 ! root 732: out("testexec_%s:\n", testname);
1.1 root 733: out(" SRA A\n");
734: out(" RET\n");
735:
1.1.1.2 ! root 736: out_testset();
1.1 root 737:
738: for (auto dst : values2) {
739: uint32 res32 = dst >> 1;
740: res32 |= (dst & 0x80);
741: uint8 res = res32;
742: hd64180flag inflag;
743: inflag.N = true;
744: inflag.H = true;
745: hd64180flag flag;
746: flag.Z = (res == 0);
747: flag.S = ((res & 0x80) != 0);
748: flag.C = ((dst & 1) != 0);
749: flag.PV = pflag(res);
750: flag.H = false;
751: flag.N = false;
752: out_testdata_run1(dst, inflag, res, flag);
753: }
754: out(" defb 0,0,0,0FFH\n");
755: out("\n");
756: }
757:
758: static void
759: gentest_srl()
760: {
761: init("srl", "testrun1");
762:
1.1.1.2 ! root 763: out("testexec_%s:\n", testname);
1.1 root 764: out(" SRL A\n");
765: out(" RET\n");
766:
1.1.1.2 ! root 767: out_testset();
1.1 root 768:
769: for (auto dst : values2) {
770: uint32 res32 = dst >> 1;
771: uint8 res = res32;
772: hd64180flag inflag;
773: inflag.N = true;
774: inflag.H = true;
775: hd64180flag flag;
776: flag.Z = (res == 0);
777: flag.S = ((res & 0x80) != 0);
778: flag.C = ((dst & 1) != 0);
779: flag.PV = pflag(res);
780: flag.H = false;
781: flag.N = false;
782: out_testdata_run1(dst, inflag, res, flag);
783: }
784: out(" defb 0,0,0,0FFH\n");
785: out("\n");
786: }
787:
788: int
789: main(int ac, char *av[])
790: {
791: out(" org 0100H\n");
792: out(" JP main\n");
793: out("\n");
794:
795: gentest_add();
796: gentest_adc();
797: gentest_sub();
798: gentest_sbc();
799: gentest_and();
800: gentest_or();
801: gentest_xor();
802: gentest_cp();
803:
804: gentest_inc();
805: gentest_dec();
806: gentest_neg();
807: gentest_cpl();
808:
809: gentest_rla();
810: gentest_rra();
811: gentest_rlca();
812: gentest_rrca();
813:
814: gentest_rl();
815: gentest_rr();
816: gentest_rlc();
817: gentest_rrc();
818: gentest_sla();
819: gentest_sra();
820: gentest_srl();
821:
822: out("main:\n");
823: for (auto name : testlist) {
824: out(" CALL test_%s\n", name.c_str());
825: }
826: out(" RET\n");
1.1.1.2 ! root 827:
! 828: return 0;
1.1 root 829: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.