FEFunction.java
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18: package xeij;
19:
20: import java.lang.*;
21:
22: public class FEFunction {
23:
24: public static final boolean FPK_DEBUG_TRACE = false;
25:
26: public static final int FPK_CLOCK = 80;
27:
28: public static final boolean FPK_FPCP_NAN = true;
29:
30: public static boolean fpkOn;
31:
32:
33:
34:
35:
36: public static boolean fpkRejectFloatOn;
37:
38: public static void fpkInit () {
39: fpkOn = Settings.sgsGetOnOff ("fefunc");
40: fpkRejectFloatOn = Settings.sgsGetOnOff ("rejectfloat");
41: }
42:
43:
44:
45: public static final int[] fpkRndTable = new int[55];
46: public static int fpkRndPointer = -1;
47:
48:
49:
50: public static void fpkRndInit (int t) {
51: for (int i = 0; i < 55; i++) {
52: t = (char) t * 15625 + 1;
53: fpkRndTable[i] = t << 16 | (char) t;
54: }
55: fpkRndPointer = 54;
56: fpkRndShuffle ();
57: fpkRndShuffle ();
58: fpkRndShuffle ();
59: }
60:
61:
62:
63: public static void fpkRndShuffle () {
64: for (int i = 0; i < 24; i++) {
65: fpkRndTable[i] -= fpkRndTable[i + 31];
66: }
67: for (int i = 24; i < 55; i++) {
68: fpkRndTable[i] -= fpkRndTable[i - 24];
69: }
70: }
71:
72:
73:
74: public static int fpkRndLong () {
75: int i = fpkRndPointer;
76: if (i < 0) {
77: fpkRndInit (111);
78: i = fpkRndPointer;
79: }
80: if (i == 54) {
81: fpkRndShuffle ();
82: i = 0;
83: } else {
84: i++;
85: }
86: fpkRndPointer = i;
87: return fpkRndTable[i];
88: }
89:
90:
91:
92: public static final short[] fpkRandTable = new short[55];
93: public static int fpkRandPointer = -1;
94:
95:
96:
97: public static void fpkRandInit (int t) {
98: for (int i = 0; i < 55; i++) {
99: t = (char) t * 15625 + 1;
100: fpkRandTable[i] = (short) t;
101: }
102: fpkRandPointer = 54;
103: fpkRandShuffle ();
104: }
105:
106:
107:
108: public static void fpkRandShuffle () {
109: for (int i = 0; i < 24; i++) {
110: fpkRandTable[i] -= fpkRandTable[i + 31];
111: }
112: for (int i = 24; i < 55; i++) {
113: fpkRandTable[i] -= fpkRandTable[i - 24];
114: }
115: }
116:
117:
118:
119: public static short fpkRandShort () {
120: int i = fpkRandPointer;
121: if (i < 0) {
122: fpkRandInit (51);
123: i = fpkRandPointer;
124: }
125: if (i == 54) {
126: fpkRandShuffle ();
127: i = 0;
128: } else {
129: i++;
130: }
131: fpkRandPointer = i;
132: return fpkRandTable[i];
133: }
134:
135:
136:
137:
138:
139:
140:
141: public static final double[] FPK_TEN_P16QR = {
142:
143: 1.0e+0,
144: 1.0e+1,
145: 1.0e+2,
146: 1.0e+3,
147: 1.0e+4,
148: 1.0e+5,
149: 1.0e+6,
150: 1.0e+7,
151: 1.0e+8,
152: 1.0e+9,
153: 1.0e+10,
154: 1.0e+11,
155: 1.0e+12,
156: 1.0e+13,
157: 1.0e+14,
158: 1.0e+15,
159: 1.0e+0,
160: 1.0e+16,
161: 1.0e+32,
162: 1.0e+48,
163: 1.0e+64,
164: 1.0e+80,
165: 1.0e+96,
166: 1.0e+112,
167: 1.0e+128,
168: 1.0e+144,
169: 1.0e+160,
170: 1.0e+176,
171: 1.0e+192,
172: 1.0e+208,
173: 1.0e+224,
174: 1.0e+240,
175: 1.0e+0,
176: 1.0e+256,
177: };
178: public static final double[] FPK_TEN_M16QR = {
179:
180: 1.0e-0,
181: 1.0e-1,
182: 1.0e-2,
183: 1.0e-3,
184: 1.0e-4,
185: 1.0e-5,
186: 1.0e-6,
187: 1.0e-7,
188: 1.0e-8,
189: 1.0e-9,
190: 1.0e-10,
191: 1.0e-11,
192: 1.0e-12,
193: 1.0e-13,
194: 1.0e-14,
195: 1.0e-15,
196: 1.0e-0,
197: 1.0e-16,
198: 1.0e-32,
199: 1.0e-48,
200: 1.0e-64,
201: 1.0e-80,
202: 1.0e-96,
203: 1.0e-112,
204: 1.0e-128,
205: 1.0e-144,
206: 1.0e-160,
207: 1.0e-176,
208: 1.0e-192,
209: 1.0e-208,
210: 1.0e-224,
211: 1.0e-240,
212: 1.0e-0,
213: 1.0e-256,
214: };
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230: public static void fpkLMUL () {
231: long xl = (long) XEiJ.regRn[0];
232: long yl = (long) XEiJ.regRn[1];
233: long zl = xl * yl;
234: int zi = (int) zl;
235: if ((long) zi != zl) {
236: XEiJ.regRn[0] = zi;
237: XEiJ.regCCR = XEiJ.REG_CCR_V | XEiJ.REG_CCR_C;
238: } else {
239: XEiJ.regRn[0] = zi;
240: XEiJ.regCCR = 0;
241: }
242: }
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262: public static void fpkLDIV () {
263: long xl = (long) XEiJ.regRn[0];
264: long yl = (long) XEiJ.regRn[1];
265: if (yl == 0L) {
266:
267: XEiJ.regCCR = XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C;
268: } else {
269: long zl = xl / yl;
270: int zi = (int) zl;
271: if ((long) zi != zl) {
272: XEiJ.regRn[0] = 0x7fffffff;
273: XEiJ.regCCR = XEiJ.REG_CCR_V | XEiJ.REG_CCR_C;
274: } else {
275: XEiJ.regRn[0] = zi;
276: XEiJ.regCCR = 0;
277: }
278: }
279: }
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298: public static void fpkLMOD () {
299: long xl = (long) XEiJ.regRn[0];
300: long yl = (long) XEiJ.regRn[1];
301: if (yl == 0L) {
302:
303: XEiJ.regCCR = XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C;
304: } else {
305: long zl = xl % yl;
306: int zi = (int) zl;
307: XEiJ.regRn[0] = zi;
308: XEiJ.regCCR = 0;
309: }
310: }
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323: public static void fpkUMUL () {
324: long xl = 0xffffffffL & (long) XEiJ.regRn[0];
325: long yl = 0xffffffffL & (long) XEiJ.regRn[1];
326: long zl = xl * yl;
327: int zi = (int) zl;
328: if ((0xffffffffL & (long) zi) != zl) {
329: XEiJ.regRn[0] = zi;
330: XEiJ.regCCR = XEiJ.REG_CCR_V | XEiJ.REG_CCR_C;
331: } else {
332: XEiJ.regRn[0] = zi;
333: XEiJ.regCCR = 0;
334: }
335: }
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350: public static void fpkUDIV () {
351: long xl = 0xffffffffL & (long) XEiJ.regRn[0];
352: long yl = 0xffffffffL & (long) XEiJ.regRn[1];
353: if (yl == 0L) {
354:
355: XEiJ.regCCR = XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C;
356: } else {
357: long zl = xl / yl;
358: int zi = (int) zl;
359: XEiJ.regRn[0] = zi;
360: XEiJ.regCCR = 0;
361: }
362: }
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377: public static void fpkUMOD () {
378: long xl = 0xffffffffL & (long) XEiJ.regRn[0];
379: long yl = 0xffffffffL & (long) XEiJ.regRn[1];
380: if (yl == 0L) {
381:
382: XEiJ.regCCR = XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C;
383: } else {
384: long zl = xl % yl;
385: int zi = (int) zl;
386: XEiJ.regRn[0] = zi;
387: XEiJ.regCCR = 0;
388: }
389: }
390:
391:
392:
393:
394:
395:
396:
397: public static void fpkIMUL () {
398: long xl = 0xffffffffL & (long) XEiJ.regRn[0];
399: long yl = 0xffffffffL & (long) XEiJ.regRn[1];
400: long zl = xl * yl;
401: XEiJ.regRn[0] = (int) (zl >>> 32);
402: XEiJ.regRn[1] = (int) zl;
403: }
404:
405:
406:
407:
408:
409:
410:
411:
412:
413: public static void fpkIDIV () {
414: long xl = 0xffffffffL & (long) XEiJ.regRn[0];
415: long yl = 0xffffffffL & (long) XEiJ.regRn[1];
416: if (yl == 0L) {
417:
418: XEiJ.regCCR = XEiJ.REG_CCR_C;
419: } else {
420: long zl = xl / yl;
421: XEiJ.regRn[0] = (int) zl;
422: XEiJ.regRn[1] = (int) (xl - yl * zl);
423: XEiJ.regCCR = 0;
424: }
425: }
426:
427:
428:
429:
430:
431:
432: public static void fpkRANDOMIZE () {
433: fpkRndInit (XEiJ.regRn[0]);
434: XEiJ.regRn[0] = 0;
435: }
436:
437:
438:
439:
440:
441:
442: public static void fpkSRAND () {
443: fpkRandInit (XEiJ.regRn[0]);
444: XEiJ.regRn[0] = 0;
445: }
446:
447:
448:
449:
450:
451: public static void fpkRAND () {
452: XEiJ.regRn[0] = fpkRandShort () & 0x7fff;
453: }
454:
455:
456:
457:
458:
459:
460: public static void fpkLTOD () {
461:
462: long l = Double.doubleToLongBits ((double) XEiJ.regRn[0]);
463: XEiJ.regRn[0] = (int) (l >>> 32);
464: XEiJ.regRn[1] = (int) l;
465: }
466:
467:
468:
469:
470:
471:
472:
473: public static void fpkDTOL () {
474:
475: double d = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
476: XEiJ.regRn[0] = (int) d;
477: XEiJ.regCCR = (double) Integer.MIN_VALUE - 1.0 < d && d < (double) Integer.MAX_VALUE + 1.0 ? 0 : XEiJ.REG_CCR_C;
478: }
479:
480:
481:
482:
483:
484:
485: public static void fpkLTOF () {
486:
487: XEiJ.regRn[0] = Float.floatToIntBits ((float) XEiJ.regRn[0]);
488: }
489:
490:
491:
492:
493:
494:
495:
496: public static void fpkFTOL () {
497:
498: float f = Float.intBitsToFloat (XEiJ.regRn[0]);
499: XEiJ.regRn[0] = (int) f;
500: XEiJ.regCCR = (float) Integer.MIN_VALUE - 1.0F < f && f < (float) Integer.MAX_VALUE + 1.0F ? 0 : XEiJ.REG_CCR_C;
501: }
502:
503:
504:
505:
506:
507:
508:
509:
510:
511:
512: public static void fpkFTOD () {
513:
514: long l = Double.doubleToLongBits ((double) Float.intBitsToFloat (XEiJ.regRn[0]));
515: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
516: l = 0x7fffffffffffffffL;
517: }
518: XEiJ.regRn[0] = (int) (l >>> 32);
519: XEiJ.regRn[1] = (int) l;
520: }
521:
522:
523:
524:
525:
526:
527:
528:
529:
530:
531:
532:
533: public static void fpkDTOF () {
534:
535: double d = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
536: int h = Float.floatToIntBits ((float) d);
537: if (FPK_FPCP_NAN && h == 0x7fc00000) {
538: h = 0x7fffffff;
539: }
540: XEiJ.regRn[0] = h;
541: XEiJ.regCCR = (Double.isNaN (d) || Double.isInfinite (d) ||
542: Math.abs (d) < (double) Float.MAX_VALUE + 0.5 * (double) Math.ulp (Float.MAX_VALUE) ? 0 : XEiJ.REG_CCR_C);
543: }
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554: public static void fpkDTST () {
555: if (true) {
556: long l = (long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1];
557: XEiJ.regCCR = l << 1 == 0L ? XEiJ.REG_CCR_Z : 0L <= l ? 0 : XEiJ.REG_CCR_N;
558: } else {
559:
560: double d = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
561: XEiJ.regCCR = d < 0.0 ? XEiJ.REG_CCR_N : d == 0.0 ? XEiJ.REG_CCR_Z : 0;
562: }
563: }
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577: public static void fpkDCMP () {
578:
579: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
580: double yd = Double.longBitsToDouble ((long) XEiJ.regRn[2] << 32 | 0xffffffffL & XEiJ.regRn[3]);
581: XEiJ.regCCR = xd < yd ? XEiJ.REG_CCR_N | XEiJ.REG_CCR_C : xd == yd ? XEiJ.REG_CCR_Z : 0;
582: }
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
596: public static void fpkDNEG () {
597:
598: long l = Double.doubleToLongBits (-Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]));
599: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
600: l = 0x7fffffffffffffffL;
601: }
602: XEiJ.regRn[0] = (int) (l >>> 32);
603: XEiJ.regRn[1] = (int) l;
604: }
605:
606:
607:
608:
609:
610:
611:
612:
613:
614:
615:
616:
617:
618: public static void fpkDADD () {
619:
620: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
621: double yd = Double.longBitsToDouble ((long) XEiJ.regRn[2] << 32 | 0xffffffffL & XEiJ.regRn[3]);
622: double zd = xd + yd;
623: long l = Double.doubleToLongBits (zd);
624: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
625: l = 0x7fffffffffffffffL;
626: }
627: XEiJ.regRn[0] = (int) (l >>> 32);
628: XEiJ.regRn[1] = (int) l;
629: XEiJ.regCCR = (Double.isNaN (xd) || Double.isNaN (yd) ? 0 :
630: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
631: Double.isInfinite (xd) || Double.isInfinite (yd) ? 0 :
632: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
633: 0);
634: }
635:
636:
637:
638:
639:
640:
641:
642:
643:
644:
645: public static void fpkDSUB () {
646:
647: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
648: double yd = Double.longBitsToDouble ((long) XEiJ.regRn[2] << 32 | 0xffffffffL & XEiJ.regRn[3]);
649: double zd = xd - yd;
650: long l = Double.doubleToLongBits (zd);
651: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
652: l = 0x7fffffffffffffffL;
653: }
654: XEiJ.regRn[0] = (int) (l >>> 32);
655: XEiJ.regRn[1] = (int) l;
656: XEiJ.regCCR = (Double.isNaN (xd) || Double.isNaN (yd) ? 0 :
657: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
658: Double.isInfinite (xd) || Double.isInfinite (yd) ? 0 :
659: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
660: 0);
661: }
662:
663:
664:
665:
666:
667:
668:
669:
670:
671:
672:
673:
674: public static void fpkDMUL () {
675:
676: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
677: double yd = Double.longBitsToDouble ((long) XEiJ.regRn[2] << 32 | 0xffffffffL & XEiJ.regRn[3]);
678: double zd = xd * yd;
679: long l = Double.doubleToLongBits (zd);
680: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
681: l = 0x7fffffffffffffffL;
682: }
683: XEiJ.regRn[0] = (int) (l >>> 32);
684: XEiJ.regRn[1] = (int) l;
685: XEiJ.regCCR = (Double.isNaN (xd) || Double.isNaN (yd) ? 0 :
686: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
687: Double.isInfinite (xd) || Double.isInfinite (yd) ? 0 :
688: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
689: 0);
690: }
691:
692:
693:
694:
695:
696:
697:
698:
699: public static void fpkDDIV () {
700:
701: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
702: double yd = Double.longBitsToDouble ((long) XEiJ.regRn[2] << 32 | 0xffffffffL & XEiJ.regRn[3]);
703: double zd = xd / yd;
704: long l = Double.doubleToLongBits (zd);
705: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
706: l = 0x7fffffffffffffffL;
707: }
708: XEiJ.regRn[0] = (int) (l >>> 32);
709: XEiJ.regRn[1] = (int) l;
710: XEiJ.regCCR = (Double.isNaN (xd) || Double.isNaN (yd) ? 0 :
711: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
712: Double.isInfinite (xd) || Double.isInfinite (yd) ? 0 :
713: yd == 0.0 ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
714: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
715: 0);
716: }
717:
718:
719:
720:
721:
722:
723:
724:
725:
726:
727: public static void fpkDMOD () {
728:
729: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
730: double yd = Double.longBitsToDouble ((long) XEiJ.regRn[2] << 32 | 0xffffffffL & XEiJ.regRn[3]);
731: double zd = xd % yd;
732: long l = Double.doubleToLongBits (zd);
733: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
734: l = 0x7fffffffffffffffL;
735: }
736: XEiJ.regRn[0] = (int) (l >>> 32);
737: XEiJ.regRn[1] = (int) l;
738: XEiJ.regCCR = (Double.isNaN (xd) || Double.isNaN (yd) ? 0 :
739: yd == 0.0 ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
740: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
741: Double.isInfinite (xd) || Double.isInfinite (yd) ? 0 :
742: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
743: 0);
744: }
745:
746:
747:
748:
749:
750:
751: public static void fpkDABS () {
752:
753: long l = Double.doubleToLongBits (Math.abs (Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1])));
754: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
755: l = 0x7fffffffffffffffL;
756: }
757: XEiJ.regRn[0] = (int) (l >>> 32);
758: XEiJ.regRn[1] = (int) l;
759: }
760:
761:
762:
763:
764:
765:
766:
767:
768: public static void fpkDCEIL () {
769:
770: long l = Double.doubleToLongBits (Math.ceil (Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1])));
771: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
772: l = 0x7fffffffffffffffL;
773: }
774: XEiJ.regRn[0] = (int) (l >>> 32);
775: XEiJ.regRn[1] = (int) l;
776: }
777:
778:
779:
780:
781:
782:
783:
784:
785: public static void fpkDFIX () {
786:
787: double d = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
788: long l = Double.doubleToLongBits (0.0 <= d ? Math.floor (d) : Math.ceil (d));
789: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
790: l = 0x7fffffffffffffffL;
791: }
792: XEiJ.regRn[0] = (int) (l >>> 32);
793: XEiJ.regRn[1] = (int) l;
794: }
795:
796:
797:
798:
799:
800:
801:
802:
803: public static void fpkDFLOOR () {
804:
805: long l = Double.doubleToLongBits (Math.floor (Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1])));
806: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
807: l = 0x7fffffffffffffffL;
808: }
809: XEiJ.regRn[0] = (int) (l >>> 32);
810: XEiJ.regRn[1] = (int) l;
811: }
812:
813:
814:
815:
816:
817:
818:
819:
820:
821:
822:
823:
824:
825: public static void fpkDFRAC () {
826:
827: long l = (long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1];
828: double d = Double.longBitsToDouble (l);
829: l = (Double.isNaN (d) ? Double.doubleToLongBits (Double.NaN) :
830: Double.isInfinite (d) ? l & 0x8000000000000000L :
831: Double.doubleToLongBits (0L <= l ? d - Math.floor (d) : -(-d - Math.floor (-d))));
832: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
833: l = 0x7fffffffffffffffL;
834: }
835: XEiJ.regRn[0] = (int) (l >>> 32);
836: XEiJ.regRn[1] = (int) l;
837: }
838:
839:
840:
841:
842:
843:
844:
845:
846:
847:
848: public static void fpkDSGN () {
849:
850: long l = Double.doubleToLongBits (Math.signum (Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1])));
851: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
852: l = 0x7fffffffffffffffL;
853: }
854: XEiJ.regRn[0] = (int) (l >>> 32);
855: XEiJ.regRn[1] = (int) l;
856: }
857:
858:
859:
860:
861:
862:
863:
864:
865:
866: public static void fpkSIN () {
867:
868: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
869: double zd = Math.sin (xd);
870: long l = Double.doubleToLongBits (zd);
871: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
872: l = 0x7fffffffffffffffL;
873: }
874: XEiJ.regRn[0] = (int) (l >>> 32);
875: XEiJ.regRn[1] = (int) l;
876: XEiJ.regCCR = !Double.isNaN (xd) && Double.isNaN (zd) ? XEiJ.REG_CCR_C : 0;
877: }
878:
879:
880:
881:
882:
883:
884:
885:
886:
887: public static void fpkCOS () {
888:
889: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
890: double zd = Math.cos (xd);
891: long l = Double.doubleToLongBits (zd);
892: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
893: l = 0x7fffffffffffffffL;
894: }
895: XEiJ.regRn[0] = (int) (l >>> 32);
896: XEiJ.regRn[1] = (int) l;
897: XEiJ.regCCR = !Double.isNaN (xd) && Double.isNaN (zd) ? XEiJ.REG_CCR_C : 0;
898: }
899:
900:
901:
902:
903:
904:
905:
906:
907:
908: public static void fpkTAN () {
909:
910: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
911: double zd = Math.tan (xd);
912: long l = Double.doubleToLongBits (zd);
913: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
914: l = 0x7fffffffffffffffL;
915: }
916: XEiJ.regRn[0] = (int) (l >>> 32);
917: XEiJ.regRn[1] = (int) l;
918: XEiJ.regCCR = !Double.isNaN (xd) && Double.isNaN (zd) ? XEiJ.REG_CCR_C : 0;
919: }
920:
921:
922:
923:
924:
925:
926:
927:
928: public static void fpkATAN () {
929:
930: long l = Double.doubleToLongBits (Math.atan (Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1])));
931: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
932: l = 0x7fffffffffffffffL;
933: }
934: XEiJ.regRn[0] = (int) (l >>> 32);
935: XEiJ.regRn[1] = (int) l;
936: }
937:
938:
939:
940:
941:
942:
943:
944:
945:
946:
947: public static void fpkLOG () {
948:
949: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
950: double zd = Math.log (xd);
951: long l = Double.doubleToLongBits (zd);
952: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
953: l = 0x7fffffffffffffffL;
954: }
955: XEiJ.regRn[0] = (int) (l >>> 32);
956: XEiJ.regRn[1] = (int) l;
957: XEiJ.regCCR = (Double.isNaN (xd) ? 0 :
958: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
959: Double.isInfinite (xd) ? 0 :
960: Double.isInfinite (zd) ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
961: 0);
962: }
963:
964:
965:
966:
967:
968:
969:
970: public static void fpkEXP () {
971:
972: int xh = XEiJ.regRn[0];
973: long l = Double.doubleToLongBits (Math.exp (Double.longBitsToDouble ((long) xh << 32 | 0xffffffffL & XEiJ.regRn[1])));
974: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
975: l = 0x7fffffffffffffffL;
976: }
977: int zh = (int) (l >>> 32);
978: XEiJ.regRn[0] = zh;
979: XEiJ.regRn[1] = (int) l;
980: XEiJ.regCCR = (zh & 0x7ff00000) == 0x7ff00000 && (xh & 0x7ff00000) != 0x7ff00000 ? XEiJ.REG_CCR_C : 0;
981: }
982:
983:
984:
985:
986:
987:
988:
989:
990:
991:
992:
993:
994: public static void fpkSQR () {
995:
996: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
997: long l = Double.doubleToLongBits (Math.sqrt (xd));
998: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
999: l = 0x7fffffffffffffffL;
1000: }
1001: XEiJ.regRn[0] = (int) (l >>> 32);
1002: XEiJ.regRn[1] = (int) l;
1003: XEiJ.regCCR = xd < 0.0 ? XEiJ.REG_CCR_C : 0;
1004: }
1005:
1006:
1007:
1008:
1009:
1010: public static void fpkPI () {
1011: if (true) {
1012: XEiJ.regRn[0] = 0x400921fb;
1013: XEiJ.regRn[1] = 0x54442d18;
1014: } else {
1015:
1016: long l = Double.doubleToLongBits (Math.PI);
1017: XEiJ.regRn[0] = (int) (l >>> 32);
1018: XEiJ.regRn[1] = (int) l;
1019: }
1020: }
1021:
1022:
1023:
1024:
1025:
1026:
1027:
1028:
1029:
1030:
1031:
1032:
1033:
1034: public static void fpkNPI () {
1035:
1036: int xh = XEiJ.regRn[0];
1037:
1038:
1039: long l = Double.doubleToLongBits (new QFP (Double.longBitsToDouble ((long) xh << 32 | 0xffffffffL & XEiJ.regRn[1])).mul (QFP.QFP_PI).getd ());
1040: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1041: l = 0x7fffffffffffffffL;
1042: }
1043: int zh = (int) (l >>> 32);
1044: XEiJ.regRn[0] = zh;
1045: XEiJ.regRn[1] = (int) l;
1046: XEiJ.regCCR = (zh & 0x7ff00000) == 0x7ff00000 && (xh & 0x7ff00000) != 0x7ff00000 ? XEiJ.REG_CCR_C : 0;
1047: }
1048:
1049:
1050:
1051:
1052:
1053:
1054:
1055:
1056:
1057:
1058:
1059:
1060: public static void fpkPOWER () {
1061:
1062: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
1063: double yd = Double.longBitsToDouble ((long) XEiJ.regRn[2] << 32 | 0xffffffffL & XEiJ.regRn[3]);
1064: double zd = Math.pow (xd, yd);
1065: long l = Double.doubleToLongBits (zd);
1066: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1067: l = 0x7fffffffffffffffL;
1068: }
1069: XEiJ.regRn[0] = (int) (l >>> 32);
1070: XEiJ.regRn[1] = (int) l;
1071: XEiJ.regCCR = (Double.isNaN (xd) || Double.isNaN (yd) ? 0 :
1072: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
1073: Double.isInfinite (xd) || Double.isInfinite (yd) ? 0 :
1074: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
1075: 0);
1076: }
1077:
1078:
1079:
1080:
1081:
1082: public static void fpkRND () {
1083: long l = 0xffffffffL & fpkRndLong ();
1084: l |= (0x001fffffL & fpkRndLong ()) << 32;
1085:
1086:
1087:
1088: int o = Long.numberOfLeadingZeros (l) - 11;
1089: l = (long) (0x3fe - o) << 52 | 0x000fffffffffffffL & l << o;
1090: XEiJ.regRn[0] = (int) (l >>> 32);
1091: XEiJ.regRn[1] = (int) l;
1092: }
1093:
1094:
1095:
1096:
1097:
1098:
1099:
1100:
1101:
1102:
1103:
1104:
1105:
1106:
1107:
1108:
1109:
1110:
1111: public static void fpkSINH () {
1112:
1113: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
1114: double zd = Math.sinh (xd);
1115: long l = Double.doubleToLongBits (zd);
1116: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1117: l = 0x7fffffffffffffffL;
1118: }
1119: XEiJ.regRn[0] = (int) (l >>> 32);
1120: XEiJ.regRn[1] = (int) l;
1121: XEiJ.regCCR = (Double.isNaN (xd) ? 0 :
1122: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
1123: Double.isInfinite (xd) ? 0 :
1124: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
1125: 0);
1126: }
1127:
1128:
1129:
1130:
1131:
1132:
1133:
1134:
1135:
1136: public static void fpkCOSH () {
1137:
1138: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
1139: double zd = Math.cosh (xd);
1140: long l = Double.doubleToLongBits (zd);
1141: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1142: l = 0x7fffffffffffffffL;
1143: }
1144: XEiJ.regRn[0] = (int) (l >>> 32);
1145: XEiJ.regRn[1] = (int) l;
1146: XEiJ.regCCR = (Double.isNaN (xd) ? 0 :
1147: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
1148: Double.isInfinite (xd) ? 0 :
1149: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
1150: 0);
1151: }
1152:
1153:
1154:
1155:
1156:
1157:
1158: public static void fpkTANH () {
1159:
1160: long l = Double.doubleToLongBits (Math.tanh (Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1])));
1161: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1162: l = 0x7fffffffffffffffL;
1163: }
1164: XEiJ.regRn[0] = (int) (l >>> 32);
1165: XEiJ.regRn[1] = (int) l;
1166: }
1167:
1168:
1169:
1170:
1171:
1172:
1173:
1174: public static void fpkATANH () {
1175:
1176: double d = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
1177: if (true) {
1178: QFP.fpsr = 0;
1179: d = new QFP (d).atanh ().getd ();
1180: XEiJ.regCCR = (QFP.fpsr & (QFP.QFP_OE | QFP.QFP_DZ)) != 0 ? XEiJ.REG_CCR_C : 0;
1181: } else {
1182: double s = Math.signum (d);
1183: double a = Math.abs (d);
1184: if (a < 1.0) {
1185: d = s * (Math.log1p (a) - Math.log1p (-a)) * 0.5;
1186: XEiJ.regCCR = 0;
1187: } else if (a == 1.0) {
1188: d = s * Double.POSITIVE_INFINITY;
1189: XEiJ.regCCR = XEiJ.REG_CCR_C;
1190: } else {
1191: d = Double.NaN;
1192: XEiJ.regCCR = XEiJ.REG_CCR_C;
1193: }
1194: }
1195: long l = Double.doubleToLongBits (d);
1196: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1197: l = 0x7fffffffffffffffL;
1198: }
1199: XEiJ.regRn[0] = (int) (l >>> 32);
1200: XEiJ.regRn[1] = (int) l;
1201: }
1202:
1203:
1204:
1205:
1206:
1207:
1208:
1209: public static void fpkASIN () {
1210:
1211: double d = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
1212: if (d < -1.0 || 1.0 < d) {
1213: d = Double.NaN;
1214: XEiJ.regCCR = XEiJ.REG_CCR_C;
1215: } else {
1216: d = Math.asin (d);
1217: XEiJ.regCCR = 0;
1218: }
1219: long l = Double.doubleToLongBits (d);
1220: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1221: l = 0x7fffffffffffffffL;
1222: }
1223: XEiJ.regRn[0] = (int) (l >>> 32);
1224: XEiJ.regRn[1] = (int) l;
1225: }
1226:
1227:
1228:
1229:
1230:
1231:
1232:
1233: public static void fpkACOS () {
1234:
1235: double d = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
1236: if (d < -1.0 || 1.0 < d) {
1237: d = Double.NaN;
1238: XEiJ.regCCR = XEiJ.REG_CCR_C;
1239: } else {
1240: d = Math.acos (d);
1241: XEiJ.regCCR = 0;
1242: }
1243: long l = Double.doubleToLongBits (d);
1244: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1245: l = 0x7fffffffffffffffL;
1246: }
1247: XEiJ.regRn[0] = (int) (l >>> 32);
1248: XEiJ.regRn[1] = (int) l;
1249: }
1250:
1251:
1252:
1253:
1254:
1255:
1256:
1257: public static void fpkLOG10 () {
1258:
1259: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
1260: double zd = Math.log10 (xd);
1261: long l = Double.doubleToLongBits (zd);
1262: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1263: l = 0x7fffffffffffffffL;
1264: }
1265: XEiJ.regRn[0] = (int) (l >>> 32);
1266: XEiJ.regRn[1] = (int) l;
1267: XEiJ.regCCR = (Double.isNaN (xd) ? 0 :
1268: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
1269: Double.isInfinite (xd) ? 0 :
1270: Double.isInfinite (zd) ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
1271: 0);
1272: }
1273:
1274:
1275:
1276:
1277:
1278:
1279:
1280: public static void fpkLOG2 () {
1281:
1282: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
1283: double zd = Math.log (xd) / 0.69314718055994530941723212146;
1284: long l = Double.doubleToLongBits (zd);
1285: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1286: l = 0x7fffffffffffffffL;
1287: }
1288: XEiJ.regRn[0] = (int) (l >>> 32);
1289: XEiJ.regRn[1] = (int) l;
1290: XEiJ.regCCR = (Double.isNaN (xd) ? 0 :
1291: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
1292: Double.isInfinite (xd) ? 0 :
1293: Double.isInfinite (zd) ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
1294: 0);
1295: }
1296:
1297:
1298:
1299:
1300:
1301:
1302:
1303: public static void fpkDFREXP () {
1304: int h = XEiJ.regRn[0];
1305: if (h << 1 == 0 && XEiJ.regRn[1] == 0) {
1306: XEiJ.regRn[0] = 0;
1307: XEiJ.regRn[2] = 0;
1308: } else {
1309: XEiJ.regRn[0] = (h & 0x800fffff) | 0x3ff00000;
1310: XEiJ.regRn[2] = (h >>> 20 & 0x7ff) - 0x3ff;
1311: }
1312: }
1313:
1314:
1315:
1316:
1317:
1318:
1319:
1320:
1321: public static void fpkDLDEXP () {
1322: int h = XEiJ.regRn[0];
1323: if (h << 1 == 0 && XEiJ.regRn[1] == 0) {
1324: XEiJ.regRn[0] = 0;
1325: XEiJ.regCCR = 0;
1326: } else {
1327: int t = (h >>> 20 & 0x7ff) + XEiJ.regRn[2];
1328: if ((t & ~0x7ff) != 0) {
1329: XEiJ.regCCR = XEiJ.REG_CCR_C;
1330: } else {
1331: XEiJ.regRn[0] = (h & 0x800fffff) | t << 20;
1332: XEiJ.regCCR = 0;
1333: }
1334: }
1335: }
1336:
1337:
1338:
1339:
1340:
1341:
1342: public static void fpkDADDONE () {
1343:
1344: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
1345: double zd = xd + 1.0;
1346: long l = Double.doubleToLongBits (zd);
1347: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1348: l = 0x7fffffffffffffffL;
1349: }
1350: XEiJ.regRn[0] = (int) (l >>> 32);
1351: XEiJ.regRn[1] = (int) l;
1352: XEiJ.regCCR = Double.isInfinite (zd) && !Double.isInfinite (xd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C : 0;
1353: }
1354:
1355:
1356:
1357:
1358:
1359:
1360: public static void fpkDSUBONE () {
1361:
1362: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
1363: double zd = xd - 1.0;
1364: long l = Double.doubleToLongBits (zd);
1365: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1366: l = 0x7fffffffffffffffL;
1367: }
1368: XEiJ.regRn[0] = (int) (l >>> 32);
1369: XEiJ.regRn[1] = (int) l;
1370: XEiJ.regCCR = Double.isInfinite (zd) && !Double.isInfinite (xd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C : 0;
1371: }
1372:
1373:
1374:
1375:
1376:
1377:
1378:
1379:
1380:
1381:
1382:
1383:
1384:
1385:
1386:
1387:
1388:
1389:
1390:
1391:
1392:
1393:
1394: public static void fpkDDIVTWO () {
1395:
1396: double xd = Double.longBitsToDouble ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
1397: double zd = xd * 0.5;
1398: long l = Double.doubleToLongBits (zd);
1399: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
1400: l = 0x7fffffffffffffffL;
1401: }
1402: XEiJ.regRn[0] = (int) (l >>> 32);
1403: XEiJ.regRn[1] = (int) l;
1404: XEiJ.regCCR = zd == 0.0 && xd != 0.0 ? XEiJ.REG_CCR_C : 0;
1405: }
1406:
1407:
1408:
1409:
1410:
1411:
1412: public static void fpkDIEECNV () {
1413: }
1414:
1415:
1416:
1417:
1418:
1419:
1420: public static void fpkIEEDCNV () {
1421: }
1422:
1423:
1424:
1425:
1426:
1427:
1428:
1429: public static void fpkFTST () {
1430: if (true) {
1431: int h = XEiJ.regRn[0];
1432: XEiJ.regCCR = h << 1 == 0 ? XEiJ.REG_CCR_Z : 0 <= h ? 0 : XEiJ.REG_CCR_N;
1433: } else {
1434:
1435: float f = Float.intBitsToFloat (XEiJ.regRn[0]);
1436: XEiJ.regCCR = f < 0.0F ? XEiJ.REG_CCR_N : f == 0.0F ? XEiJ.REG_CCR_Z : 0;
1437: }
1438: }
1439:
1440:
1441:
1442:
1443:
1444:
1445:
1446:
1447: public static void fpkFCMP () {
1448:
1449: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1450: float yf = Float.intBitsToFloat (XEiJ.regRn[1]);
1451: XEiJ.regCCR = xf < yf ? XEiJ.REG_CCR_N | XEiJ.REG_CCR_C : xf == yf ? XEiJ.REG_CCR_Z : 0;
1452: }
1453:
1454:
1455:
1456:
1457:
1458:
1459: public static void fpkFNEG () {
1460:
1461: int h = Float.floatToIntBits (-Float.intBitsToFloat (XEiJ.regRn[0]));
1462: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1463: h = 0x7fffffff;
1464: }
1465: XEiJ.regRn[0] = h;
1466: }
1467:
1468:
1469:
1470:
1471:
1472:
1473:
1474:
1475: public static void fpkFADD () {
1476:
1477: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1478: float yf = Float.intBitsToFloat (XEiJ.regRn[1]);
1479: float zf = xf + yf;
1480: int h = Float.floatToIntBits (zf);
1481: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1482: h = 0x7fffffff;
1483: }
1484: XEiJ.regRn[0] = h;
1485: XEiJ.regCCR = (Float.isNaN (xf) || Float.isNaN (yf) ? 0 :
1486: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
1487: Float.isInfinite (xf) || Float.isInfinite (yf) ? 0 :
1488: Float.isInfinite (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
1489: 0);
1490: }
1491:
1492:
1493:
1494:
1495:
1496:
1497:
1498:
1499: public static void fpkFSUB () {
1500:
1501: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1502: float yf = Float.intBitsToFloat (XEiJ.regRn[1]);
1503: float zf = xf - yf;
1504: int h = Float.floatToIntBits (zf);
1505: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1506: h = 0x7fffffff;
1507: }
1508: XEiJ.regRn[0] = h;
1509: XEiJ.regCCR = (Float.isNaN (xf) || Float.isNaN (yf) ? 0 :
1510: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
1511: Float.isInfinite (xf) || Float.isInfinite (yf) ? 0 :
1512: Float.isInfinite (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
1513: 0);
1514: }
1515:
1516:
1517:
1518:
1519:
1520:
1521:
1522:
1523: public static void fpkFMUL () {
1524:
1525: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1526: float yf = Float.intBitsToFloat (XEiJ.regRn[1]);
1527: float zf = xf * yf;
1528: int h = Float.floatToIntBits (zf);
1529: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1530: h = 0x7fffffff;
1531: }
1532: XEiJ.regRn[0] = h;
1533: XEiJ.regCCR = (Float.isNaN (xf) || Float.isNaN (yf) ? 0 :
1534: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
1535: Float.isInfinite (xf) || Float.isInfinite (yf) ? 0 :
1536: Float.isInfinite (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
1537: 0);
1538: }
1539:
1540:
1541:
1542:
1543:
1544:
1545:
1546:
1547: public static void fpkFDIV () {
1548:
1549: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1550: float yf = Float.intBitsToFloat (XEiJ.regRn[1]);
1551: float zf = xf / yf;
1552: int h = Float.floatToIntBits (zf);
1553: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1554: h = 0x7fffffff;
1555: }
1556: XEiJ.regRn[0] = h;
1557: XEiJ.regCCR = (Float.isNaN (xf) || Float.isNaN (yf) ? 0 :
1558: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
1559: Float.isInfinite (xf) || Float.isInfinite (yf) ? 0 :
1560: yf == 0.0F ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
1561: Float.isInfinite (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
1562: 0);
1563: }
1564:
1565:
1566:
1567:
1568:
1569:
1570:
1571:
1572: public static void fpkFMOD () {
1573:
1574: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1575: float yf = Float.intBitsToFloat (XEiJ.regRn[1]);
1576: float zf = xf % yf;
1577: int h = Float.floatToIntBits (zf);
1578: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1579: h = 0x7fffffff;
1580: }
1581: XEiJ.regRn[0] = h;
1582: XEiJ.regCCR = (Float.isNaN (xf) || Float.isNaN (yf) ? 0 :
1583: yf == 0.0F ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
1584: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
1585: Float.isInfinite (xf) || Float.isInfinite (yf) ? 0 :
1586: Float.isInfinite (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
1587: 0);
1588: }
1589:
1590:
1591:
1592:
1593:
1594:
1595: public static void fpkFABS () {
1596:
1597: int h = Float.floatToIntBits (Math.abs (Float.intBitsToFloat (XEiJ.regRn[0])));
1598: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1599: h = 0x7fffffff;
1600: }
1601: XEiJ.regRn[0] = h;
1602: }
1603:
1604:
1605:
1606:
1607:
1608:
1609: public static void fpkFCEIL () {
1610:
1611: int h = Float.floatToIntBits ((float) Math.ceil ((double) Float.intBitsToFloat (XEiJ.regRn[0])));
1612: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1613: h = 0x7fffffff;
1614: }
1615: XEiJ.regRn[0] = h;
1616: }
1617:
1618:
1619:
1620:
1621:
1622:
1623: public static void fpkFFIX () {
1624:
1625: float f = Float.intBitsToFloat (XEiJ.regRn[0]);
1626: int h = Float.floatToIntBits (0.0 <= f ? (float) Math.floor ((double) f) : (float) Math.ceil ((double) f));
1627: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1628: h = 0x7fffffff;
1629: }
1630: XEiJ.regRn[0] = h;
1631: }
1632:
1633:
1634:
1635:
1636:
1637:
1638: public static void fpkFFLOOR () {
1639:
1640: int h = Float.floatToIntBits ((float) Math.floor ((double) Float.intBitsToFloat (XEiJ.regRn[0])));
1641: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1642: h = 0x7fffffff;
1643: }
1644: XEiJ.regRn[0] = h;
1645: }
1646:
1647:
1648:
1649:
1650:
1651:
1652: public static void fpkFFRAC () {
1653:
1654: int h = XEiJ.regRn[0];
1655: float f = Float.intBitsToFloat (h);
1656: h = (Float.isNaN (f) ? Float.floatToIntBits (Float.NaN) :
1657: Float.isInfinite (f) ? h & 0x80000000 :
1658: Float.floatToIntBits (0 <= h ? f - (float) Math.floor ((double) f) : -(-f - (float) Math.floor ((double) -f))));
1659: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1660: h = 0x7fffffff;
1661: }
1662: XEiJ.regRn[0] = h;
1663: }
1664:
1665:
1666:
1667:
1668:
1669:
1670: public static void fpkFSGN () {
1671:
1672: int h = Float.floatToIntBits (Math.signum (Float.intBitsToFloat (XEiJ.regRn[0])));
1673: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1674: h = 0x7fffffff;
1675: }
1676: XEiJ.regRn[0] = h;
1677: }
1678:
1679:
1680:
1681:
1682:
1683:
1684:
1685: public static void fpkFSIN () {
1686:
1687: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1688: float zf = (float) Math.sin ((double) xf);
1689: int h = Float.floatToIntBits (zf);
1690: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1691: h = 0x7fffffff;
1692: }
1693: XEiJ.regRn[0] = h;
1694: XEiJ.regCCR = !Float.isNaN (xf) && Float.isNaN (zf) ? XEiJ.REG_CCR_C : 0;
1695: }
1696:
1697:
1698:
1699:
1700:
1701:
1702:
1703: public static void fpkFCOS () {
1704:
1705: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1706: float zf = (float) Math.cos ((double) xf);
1707: int h = Float.floatToIntBits (zf);
1708: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1709: h = 0x7fffffff;
1710: }
1711: XEiJ.regRn[0] = h;
1712: XEiJ.regCCR = !Float.isNaN (xf) && Float.isNaN (zf) ? XEiJ.REG_CCR_C : 0;
1713: }
1714:
1715:
1716:
1717:
1718:
1719:
1720:
1721: public static void fpkFTAN () {
1722:
1723: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1724: float zf = (float) Math.tan ((double) xf);
1725: int h = Float.floatToIntBits (zf);
1726: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1727: h = 0x7fffffff;
1728: }
1729: XEiJ.regRn[0] = h;
1730: XEiJ.regCCR = !Float.isNaN (xf) && Float.isNaN (zf) ? XEiJ.REG_CCR_C : 0;
1731: }
1732:
1733:
1734:
1735:
1736:
1737:
1738: public static void fpkFATAN () {
1739:
1740: int h = Float.floatToIntBits ((float) Math.atan ((double) Float.intBitsToFloat (XEiJ.regRn[0])));
1741: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1742: h = 0x7fffffff;
1743: }
1744: XEiJ.regRn[0] = h;
1745: }
1746:
1747:
1748:
1749:
1750:
1751:
1752:
1753: public static void fpkFLOG () {
1754:
1755: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1756: float zf = (float) Math.log ((double) xf);
1757: int h = Float.floatToIntBits (zf);
1758: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1759: h = 0x7fffffff;
1760: }
1761: XEiJ.regRn[0] = h;
1762: XEiJ.regCCR = (Float.isNaN (xf) ? 0 :
1763: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
1764: Float.isInfinite (xf) ? 0 :
1765: Float.isNaN (zf) ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
1766: 0);
1767: }
1768:
1769:
1770:
1771:
1772:
1773:
1774:
1775: public static void fpkFEXP () {
1776:
1777: int xh = XEiJ.regRn[0];
1778: int zh = Float.floatToIntBits ((float) Math.exp ((double) Float.intBitsToFloat (xh)));
1779: if (FPK_FPCP_NAN && zh == 0x7fc00000) {
1780: zh = 0x7fffffff;
1781: }
1782: XEiJ.regRn[0] = zh;
1783: XEiJ.regCCR = (zh & 0x7fc00000) == 0x7fc00000 && (xh & 0x7fc00000) != 0x7fc00000 ? XEiJ.REG_CCR_C : 0;
1784: }
1785:
1786:
1787:
1788:
1789:
1790:
1791:
1792: public static void fpkFSQR () {
1793:
1794: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1795: int h = Float.floatToIntBits ((float) Math.sqrt ((double) xf));
1796: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1797: h = 0x7fffffff;
1798: }
1799: XEiJ.regRn[0] = h;
1800: XEiJ.regCCR = xf < 0.0F ? XEiJ.REG_CCR_C : 0;
1801: }
1802:
1803:
1804:
1805:
1806:
1807: public static void fpkFPI () {
1808:
1809: if (true) {
1810: XEiJ.regRn[0] = 0x40490fdb;
1811: } else {
1812: XEiJ.regRn[0] = Float.floatToIntBits ((float) Math.PI);
1813: }
1814: }
1815:
1816:
1817:
1818:
1819:
1820:
1821:
1822: public static void fpkFNPI () {
1823:
1824: int xh = XEiJ.regRn[0];
1825:
1826: int zh = Float.floatToIntBits ((float) ((double) Float.intBitsToFloat (xh) * Math.PI));
1827: if (FPK_FPCP_NAN && zh == 0x7fc00000) {
1828: zh = 0x7fffffff;
1829: }
1830: XEiJ.regRn[0] = zh;
1831: XEiJ.regCCR = (zh & 0x7fc00000) == 0x7fc00000 && (xh & 0x7fc00000) != 0x7fc00000 ? XEiJ.REG_CCR_C : 0;
1832: }
1833:
1834:
1835:
1836:
1837:
1838:
1839:
1840:
1841: public static void fpkFPOWER () {
1842:
1843: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1844: float yf = Float.intBitsToFloat (XEiJ.regRn[1]);
1845: float zf = (float) Math.pow ((double) xf, (double) yf);
1846: int zh = Float.floatToIntBits (zf);
1847: if (FPK_FPCP_NAN && zh == 0x7fc00000) {
1848: zh = 0x7fffffff;
1849: }
1850: XEiJ.regRn[0] = zh;
1851: XEiJ.regCCR = (Float.isNaN (xf) || Float.isNaN (yf) ? 0 :
1852: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
1853: Float.isInfinite (xf) || Float.isInfinite (yf) ? 0 :
1854: Float.isNaN (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
1855: 0);
1856: }
1857:
1858:
1859:
1860:
1861:
1862: public static void fpkFRND () {
1863:
1864: long l = 0xffffffffL & fpkRndLong ();
1865: l |= (0x001fffffL & fpkRndLong ()) << 32;
1866:
1867:
1868:
1869: int o = Long.numberOfLeadingZeros (l) - 11;
1870: l = ((long) (1022 - 1 - o) << 52) + (l << o);
1871: XEiJ.regRn[0] = Float.floatToIntBits ((float) Double.longBitsToDouble (l));
1872: }
1873:
1874:
1875:
1876:
1877:
1878:
1879:
1880: public static void fpkFSINH () {
1881:
1882: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1883: float zf = (float) Math.sinh ((double) xf);
1884: int zh = Float.floatToIntBits (zf);
1885: if (FPK_FPCP_NAN && zh == 0x7fc00000) {
1886: zh = 0x7fffffff;
1887: }
1888: XEiJ.regRn[0] = zh;
1889: XEiJ.regCCR = (Float.isNaN (xf) ? 0 :
1890: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
1891: Float.isInfinite (xf) ? 0 :
1892: Float.isNaN (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
1893: 0);
1894: }
1895:
1896:
1897:
1898:
1899:
1900:
1901:
1902: public static void fpkFCOSH () {
1903:
1904: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
1905: float zf = (float) Math.cosh ((double) xf);
1906: int zh = Float.floatToIntBits (zf);
1907: if (FPK_FPCP_NAN && zh == 0x7fc00000) {
1908: zh = 0x7fffffff;
1909: }
1910: XEiJ.regRn[0] = zh;
1911: XEiJ.regCCR = (Float.isNaN (xf) ? 0 :
1912: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
1913: Float.isInfinite (xf) ? 0 :
1914: Float.isNaN (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
1915: 0);
1916: }
1917:
1918:
1919:
1920:
1921:
1922:
1923: public static void fpkFTANH () {
1924:
1925: int h = Float.floatToIntBits ((float) Math.tanh ((double) Float.intBitsToFloat (XEiJ.regRn[0])));
1926: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1927: h = 0x7fffffff;
1928: }
1929: XEiJ.regRn[0] = h;
1930: }
1931:
1932:
1933:
1934:
1935:
1936:
1937:
1938: public static void fpkFATANH () {
1939:
1940: double d = (double) Float.intBitsToFloat (XEiJ.regRn[0]);
1941: double s = Math.signum (d);
1942: double a = Math.abs (d);
1943: if (a < 1.0) {
1944: d = s * (Math.log1p (a) - Math.log1p (-a)) * 0.5;
1945: XEiJ.regCCR = 0;
1946: } else if (a == 1.0) {
1947: d = s * Double.POSITIVE_INFINITY;
1948: XEiJ.regCCR = XEiJ.REG_CCR_C;
1949: } else {
1950: d = Double.NaN;
1951: XEiJ.regCCR = XEiJ.REG_CCR_C;
1952: }
1953: int h = Float.floatToIntBits ((float) d);
1954: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1955: h = 0x7fffffff;
1956: }
1957: XEiJ.regRn[0] = h;
1958: }
1959:
1960:
1961:
1962:
1963:
1964:
1965:
1966: public static void fpkFASIN () {
1967:
1968: double d = (double) Float.intBitsToFloat (XEiJ.regRn[0]);
1969: if (d < -1.0 || 1.0 < d) {
1970: d = Double.NaN;
1971: XEiJ.regCCR = XEiJ.REG_CCR_C;
1972: } else {
1973: d = Math.asin (d);
1974: XEiJ.regCCR = 0;
1975: }
1976: int h = Float.floatToIntBits ((float) d);
1977: if (FPK_FPCP_NAN && h == 0x7fc00000) {
1978: h = 0x7fffffff;
1979: }
1980: XEiJ.regRn[0] = h;
1981: }
1982:
1983:
1984:
1985:
1986:
1987:
1988:
1989: public static void fpkFACOS () {
1990:
1991: double d = (double) Float.intBitsToFloat (XEiJ.regRn[0]);
1992: if (d < -1.0 || 1.0 < d) {
1993: d = Double.NaN;
1994: XEiJ.regCCR = XEiJ.REG_CCR_C;
1995: } else {
1996: d = Math.acos (d);
1997: XEiJ.regCCR = 0;
1998: }
1999: int h = Float.floatToIntBits ((float) d);
2000: if (FPK_FPCP_NAN && h == 0x7fc00000) {
2001: h = 0x7fffffff;
2002: }
2003: XEiJ.regRn[0] = h;
2004: }
2005:
2006:
2007:
2008:
2009:
2010:
2011:
2012: public static void fpkFLOG10 () {
2013:
2014: double xd = (double) Float.intBitsToFloat (XEiJ.regRn[0]);
2015: double zd = Math.log10 (xd);
2016: int h = Float.floatToIntBits ((float) zd);
2017: if (FPK_FPCP_NAN && h == 0x7fc00000) {
2018: h = 0x7fffffff;
2019: }
2020: XEiJ.regRn[0] = h;
2021: XEiJ.regCCR = (Double.isNaN (xd) ? 0 :
2022: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
2023: Double.isInfinite (xd) ? 0 :
2024: Double.isInfinite (zd) ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
2025: 0);
2026: }
2027:
2028:
2029:
2030:
2031:
2032:
2033:
2034: public static void fpkFLOG2 () {
2035:
2036: double xd = (double) Float.intBitsToFloat (XEiJ.regRn[0]);
2037: double zd = Math.log (xd) / 0.69314718055994530941723212146;
2038: int h = Float.floatToIntBits ((float) zd);
2039: if (FPK_FPCP_NAN && h == 0x7fc00000) {
2040: h = 0x7fffffff;
2041: }
2042: XEiJ.regRn[0] = h;
2043: XEiJ.regCCR = (Double.isNaN (xd) ? 0 :
2044: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
2045: Double.isInfinite (xd) ? 0 :
2046: Double.isInfinite (zd) ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
2047: 0);
2048: }
2049:
2050:
2051:
2052:
2053:
2054:
2055:
2056: public static void fpkFFREXP () {
2057: int h = XEiJ.regRn[0];
2058: if (h << 1 == 0) {
2059: XEiJ.regRn[0] = 0;
2060: XEiJ.regRn[1] = 0;
2061: } else {
2062: XEiJ.regRn[0] = (h & 0x807fffff) | 0x3f800000;
2063: XEiJ.regRn[1] = (h >>> 23 & 255) - 0x7f;
2064: }
2065: }
2066:
2067:
2068:
2069:
2070:
2071:
2072:
2073:
2074: public static void fpkFLDEXP () {
2075: int h = XEiJ.regRn[0];
2076: if (h << 1 == 0) {
2077: XEiJ.regRn[0] = 0;
2078: XEiJ.regCCR = 0;
2079: } else {
2080: int t = (h >>> 23 & 255) + XEiJ.regRn[2];
2081: if ((t & ~0xff) != 0) {
2082: XEiJ.regCCR = XEiJ.REG_CCR_C;
2083: } else {
2084: XEiJ.regRn[0] = (h & 0x807fffff) | t << 23;
2085: XEiJ.regCCR = 0;
2086: }
2087: }
2088: }
2089:
2090:
2091:
2092:
2093:
2094:
2095: public static void fpkFADDONE () {
2096:
2097: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
2098: float zf = xf + 1.0F;
2099: int h = Float.floatToIntBits (zf);
2100: if (FPK_FPCP_NAN && h == 0x7fc00000) {
2101: h = 0x7fffffff;
2102: }
2103: XEiJ.regRn[0] = h;
2104: XEiJ.regCCR = Double.isInfinite (zf) && !Float.isInfinite (xf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C : 0;
2105: }
2106:
2107:
2108:
2109:
2110:
2111:
2112: public static void fpkFSUBONE () {
2113:
2114: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
2115: float zf = xf - 1.0F;
2116: int h = Float.floatToIntBits (zf);
2117: if (FPK_FPCP_NAN && h == 0x7fc00000) {
2118: h = 0x7fffffff;
2119: }
2120: XEiJ.regRn[0] = h;
2121: XEiJ.regCCR = Double.isInfinite (zf) && !Float.isInfinite (xf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C : 0;
2122: }
2123:
2124:
2125:
2126:
2127:
2128:
2129:
2130: public static void fpkFDIVTWO () {
2131:
2132: float xf = Float.intBitsToFloat (XEiJ.regRn[0]);
2133: float zf = xf * 0.5F;
2134: int h = Float.floatToIntBits (zf);
2135: if (FPK_FPCP_NAN && h == 0x7fc00000) {
2136: h = 0x7fffffff;
2137: }
2138: XEiJ.regRn[0] = h;
2139: XEiJ.regCCR = zf == 0.0F && xf != 0.0F ? XEiJ.REG_CCR_C : 0;
2140: }
2141:
2142:
2143:
2144:
2145:
2146:
2147: public static void fpkFIEECNV () {
2148: }
2149:
2150:
2151:
2152:
2153:
2154:
2155: public static void fpkIEEFCNV () {
2156: }
2157:
2158:
2159:
2160:
2161:
2162:
2163: public static void fpkFEVARG () {
2164: XEiJ.regRn[0] = 'I' << 24 | 'E' << 16 | 'E' << 8 | 'E';
2165: XEiJ.regRn[1] = 'X' << 24 | 'E' << 16 | 'i' << 8 | 'J';
2166: }
2167:
2168:
2169:
2170:
2171:
2172:
2173:
2174:
2175:
2176:
2177: public static void fpkFEVECS () {
2178: XEiJ.regRn[0] = -1;
2179: }
2180:
2181:
2182:
2183:
2184:
2185:
2186:
2187:
2188:
2189:
2190:
2191:
2192: public static void fpkSTOL () throws M68kException {
2193: int a = XEiJ.regRn[8];
2194: int c = XEiJ.busRbz (a);
2195: while (c == ' ' || c == '\t') {
2196: c = XEiJ.busRbz (++a);
2197: }
2198: int n = '7';
2199: if (c == '-') {
2200: n = '8';
2201: c = XEiJ.busRbz (++a);
2202: } else if (c == '+') {
2203: c = XEiJ.busRbz (++a);
2204: }
2205: if (!('0' <= c && c <= '9')) {
2206: XEiJ.regRn[8] = a;
2207: XEiJ.regCCR = XEiJ.REG_CCR_N | XEiJ.REG_CCR_C;
2208: return;
2209: }
2210: int x = c - '0';
2211: for (c = XEiJ.busRbz (++a); '0' <= c && c <= '9'; c = XEiJ.busRbz (++a)) {
2212: if (214748364 < x || x == 214748364 && n < c) {
2213: XEiJ.regRn[8] = a;
2214: XEiJ.regCCR = XEiJ.REG_CCR_V | XEiJ.REG_CCR_C;
2215: return;
2216: }
2217: x = x * 10 + (c - '0');
2218: }
2219: if (n != '7') {
2220: x = -x;
2221: }
2222: XEiJ.regRn[0] = x;
2223: XEiJ.regRn[8] = a;
2224: XEiJ.regCCR = 0;
2225: }
2226:
2227:
2228:
2229:
2230:
2231:
2232:
2233:
2234: public static void fpkLTOS () throws M68kException {
2235: int x = XEiJ.regRn[0];
2236: int a = XEiJ.regRn[8];
2237: if (x < 0) {
2238: XEiJ.busWb (a++, '-');
2239: x = -x;
2240: }
2241: long t = XEiJ.fmtBcd12 (0xffffffffL & x);
2242: XEiJ.regRn[8] = a += Math.max (1, 67 - Long.numberOfLeadingZeros (t) >> 2);
2243: XEiJ.busWb (a, 0);
2244: do {
2245: XEiJ.busWb (--a, '0' | (int) t & 15);
2246: } while ((t >>>= 4) != 0L);
2247: }
2248:
2249:
2250:
2251:
2252:
2253:
2254:
2255:
2256:
2257: public static void fpkSTOH () throws M68kException {
2258: int a = XEiJ.regRn[8];
2259: int c = XEiJ.busRbz (a);
2260: if (!('0' <= c && c <= '9' || 'A' <= c && c <= 'F' || 'a' <= c && c <= 'f')) {
2261: XEiJ.regRn[8] = a;
2262: XEiJ.regCCR = XEiJ.REG_CCR_N | XEiJ.REG_CCR_C;
2263: return;
2264: }
2265: int x = c <= '9' ? c - '0' : c <= 'F' ? c - ('A' - 10) : c - ('a' - 10);
2266: for (c = XEiJ.busRbz (++a); '0' <= c && c <= '9' || 'A' <= c && c <= 'F' || 'a' <= c && c <= 'f'; c = XEiJ.busRbz (++a)) {
2267: if (0x0fffffff < x) {
2268: XEiJ.regRn[8] = a;
2269: XEiJ.regCCR = XEiJ.REG_CCR_V | XEiJ.REG_CCR_C;
2270: return;
2271: }
2272: x = x << 4 | (c <= '9' ? c - '0' : c <= 'F' ? c - ('A' - 10) : c - ('a' - 10));
2273: }
2274: XEiJ.regRn[0] = x;
2275: XEiJ.regRn[8] = a;
2276: XEiJ.regCCR = 0;
2277: }
2278:
2279:
2280:
2281:
2282:
2283:
2284:
2285:
2286: public static void fpkHTOS () throws M68kException {
2287: int x = XEiJ.regRn[0];
2288: int a = XEiJ.regRn[8] += Math.max (1, 35 - Integer.numberOfLeadingZeros (x) >> 2);
2289: XEiJ.busWb (a, 0);
2290: do {
2291: int t = x & 15;
2292:
2293:
2294:
2295:
2296:
2297:
2298:
2299: XEiJ.busWb (--a, (9 - t >> 4 & 7 | 48) + t);
2300: } while ((x >>>= 4) != 0);
2301: }
2302:
2303:
2304:
2305:
2306:
2307:
2308:
2309:
2310:
2311: public static void fpkSTOO () throws M68kException {
2312: int a = XEiJ.regRn[8];
2313: int c = XEiJ.busRbz (a);
2314: if (!('0' <= c && c <= '7')) {
2315: XEiJ.regRn[8] = a;
2316: XEiJ.regCCR = XEiJ.REG_CCR_N | XEiJ.REG_CCR_C;
2317: return;
2318: }
2319: int x = c - '0';
2320: for (c = XEiJ.busRbz (++a); '0' <= c && c <= '7'; c = XEiJ.busRbz (++a)) {
2321: if (0x1fffffff < x) {
2322: XEiJ.regRn[8] = a;
2323: XEiJ.regCCR = XEiJ.REG_CCR_V | XEiJ.REG_CCR_C;
2324: return;
2325: }
2326: x = x << 3 | c & 7;
2327: }
2328: XEiJ.regRn[0] = x;
2329: XEiJ.regRn[8] = a;
2330: XEiJ.regCCR = 0;
2331: }
2332:
2333:
2334:
2335:
2336:
2337:
2338:
2339:
2340: public static void fpkOTOS () throws M68kException {
2341: int x = XEiJ.regRn[0];
2342:
2343:
2344: int a = XEiJ.regRn[8] += Math.max (1, (34 - Integer.numberOfLeadingZeros (x)) * 43 >>> 7);
2345: XEiJ.busWb (a, 0);
2346: do {
2347: XEiJ.busWb (--a, '0' | x & 7);
2348: } while ((x >>>= 3) != 0);
2349: }
2350:
2351:
2352:
2353:
2354:
2355:
2356:
2357:
2358:
2359: public static void fpkSTOB () throws M68kException {
2360: int a = XEiJ.regRn[8];
2361: int c = XEiJ.busRbz (a);
2362: if (!('0' <= c && c <= '1')) {
2363: XEiJ.regRn[8] = a;
2364: XEiJ.regCCR = XEiJ.REG_CCR_N | XEiJ.REG_CCR_C;
2365: return;
2366: }
2367: int x = c - '0';
2368: for (c = XEiJ.busRbz (++a); '0' <= c && c <= '1'; c = XEiJ.busRbz (++a)) {
2369: if (x < 0) {
2370: XEiJ.regRn[8] = a;
2371: XEiJ.regCCR = XEiJ.REG_CCR_V | XEiJ.REG_CCR_C;
2372: return;
2373: }
2374: x = x << 1 | c & 1;
2375: }
2376: XEiJ.regRn[0] = x;
2377: XEiJ.regRn[8] = a;
2378: XEiJ.regCCR = 0;
2379: }
2380:
2381:
2382:
2383:
2384:
2385:
2386:
2387:
2388: public static void fpkBTOS () throws M68kException {
2389: int x = XEiJ.regRn[0];
2390: int a = XEiJ.regRn[8] += Math.max (1, 32 - Integer.numberOfLeadingZeros (x));
2391: XEiJ.busWb (a, 0);
2392: do {
2393: XEiJ.busWb (--a, '0' | x & 1);
2394: } while ((x >>>= 1) != 0);
2395: }
2396:
2397:
2398:
2399:
2400:
2401:
2402:
2403:
2404:
2405: public static void fpkIUSING () throws M68kException {
2406: int x = XEiJ.regRn[0];
2407: int n = 0;
2408: if (x < 0) {
2409: n = 1;
2410: x = -x;
2411: }
2412: long t = XEiJ.fmtBcd12 (0xffffffffL & x);
2413: int l = n + Math.max (1, 67 - Long.numberOfLeadingZeros (t) >> 2);
2414: int a = XEiJ.regRn[8];
2415: for (int i = (XEiJ.regRn[1] & 255) - l; i > 0; i--) {
2416: XEiJ.busWb (a++, ' ');
2417: }
2418: XEiJ.regRn[8] = a += l;
2419: XEiJ.busWb (a, 0);
2420: do {
2421: XEiJ.busWb (--a, '0' | (int) t & 15);
2422: } while ((t >>>= 4) != 0L);
2423: if (n != 0) {
2424: XEiJ.busWb (--a, '-');
2425: }
2426: }
2427:
2428:
2429:
2430:
2431:
2432:
2433:
2434:
2435:
2436:
2437:
2438:
2439:
2440:
2441:
2442: public static void fpkVAL () throws M68kException {
2443: int a = XEiJ.regRn[8];
2444:
2445: int c = XEiJ.busRbs (a++);
2446: while (c == ' ' || c == '\t') {
2447: c = XEiJ.busRbs (a++);
2448: }
2449: if (c == '&') {
2450: c = XEiJ.busRbs (a++) & 0xdf;
2451: XEiJ.regRn[8] = a;
2452: if (c == 'B') {
2453: fpkSTOB ();
2454: fpkLTOD ();
2455: } else if (c == 'O') {
2456: fpkSTOO ();
2457: fpkLTOD ();
2458: } else if (c == 'H') {
2459: fpkSTOH ();
2460: fpkLTOD ();
2461: } else {
2462: XEiJ.regCCR = XEiJ.REG_CCR_N | XEiJ.REG_CCR_C;
2463: }
2464: } else {
2465: fpkSTOD ();
2466: }
2467: }
2468:
2469:
2470:
2471:
2472:
2473:
2474:
2475:
2476:
2477:
2478:
2479:
2480:
2481:
2482:
2483:
2484:
2485:
2486:
2487:
2488:
2489:
2490:
2491:
2492:
2493:
2494:
2495:
2496:
2497:
2498:
2499:
2500:
2501:
2502:
2503:
2504:
2505:
2506:
2507:
2508:
2509:
2510:
2511:
2512:
2513:
2514:
2515:
2516:
2517:
2518:
2519:
2520:
2521:
2522:
2523:
2524:
2525:
2526:
2527:
2528:
2529:
2530:
2531:
2532:
2533: public static void fpkUSING () throws M68kException {
2534: fpkUSINGSub ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
2535: }
2536: public static void fpkUSINGSub (long l) throws M68kException {
2537: int attr = XEiJ.regRn[4];
2538: int len1 = ((attr & (16 + 8)) == 16 ? 1 : 0) + Math.max (0, XEiJ.regRn[2]);
2539: int len2 = Math.max (-1, XEiJ.regRn[3]);
2540: int a = XEiJ.regRn[8];
2541: boolean exp = (attr & 8) != 0;
2542: int spc = (attr & 1) != 0 ? '*' : ' ';
2543: int yen = (attr & 2) != 0 ? '\\' : 0;
2544: int cmm = !exp && (attr & 4) != 0 ? ',' : 0;
2545:
2546: int sgn1 = 0;
2547: int sgn2 = 0;
2548: if (l < 0L) {
2549: if ((attr & 32 + 64) == 0) {
2550: sgn1 = '-';
2551: } else {
2552: sgn2 = '-';
2553: }
2554: l &= 0x7fffffffffffffffL;
2555: } else {
2556: if ((attr & 16) != 0) {
2557: sgn1 = '+';
2558: } else if ((attr & 16 + 32) == 32) {
2559: sgn2 = '+';
2560: } else if ((attr & 16 + 32 + 64) == 64) {
2561: sgn2 = ' ';
2562: }
2563: }
2564: double x = Double.longBitsToDouble (l);
2565: int e = (int) (l >>> 52) - 1023;
2566: l &= 0x000fffffffffffffL;
2567:
2568: if (e == -1023) {
2569: if (l == 0L) {
2570: for (int i = len1 - ((sgn1 != 0 ? 1 : 0) +
2571: (yen != 0 ? 1 : 0) +
2572: 1
2573: ); 0 < i; i--) {
2574: XEiJ.busWb (a++, spc);
2575: }
2576: if (sgn1 != 0) {
2577: XEiJ.busWb (a++, sgn1);
2578: }
2579: if (yen != 0) {
2580: XEiJ.busWb (a++, yen);
2581: }
2582: if (0 < len1) {
2583: XEiJ.busWb (a++, '0');
2584: }
2585: if (0 <= len2) {
2586: XEiJ.busWb (a++, '.');
2587: for (; 0 < len2; len2--) {
2588: XEiJ.busWb (a++, '0');
2589: }
2590: }
2591: XEiJ.busWb (a, '\0');
2592: return;
2593: }
2594: e -= Long.numberOfLeadingZeros (l) - 12;
2595: } else if (e == 1024) {
2596: for (int i = len1 + 1 + len2 + (exp ? 5 : 0) -
2597: ((sgn1 != 0 ? 1 : 0) +
2598: (yen != 0 ? 1 : 0) +
2599: 4
2600: ); 0 < i; i--) {
2601: XEiJ.busWb (a++, spc);
2602: }
2603: if (sgn1 != 0) {
2604: XEiJ.busWb (a++, sgn1);
2605: }
2606: if (yen != 0) {
2607: XEiJ.busWb (a++, yen);
2608: }
2609: XEiJ.busWb (a++, '#');
2610: if (l == 0L) {
2611: XEiJ.busWb (a++, 'I');
2612: XEiJ.busWb (a++, 'N');
2613: XEiJ.busWb (a++, 'F');
2614: } else {
2615: XEiJ.busWb (a++, 'N');
2616: XEiJ.busWb (a++, 'A');
2617: XEiJ.busWb (a++, 'N');
2618: }
2619: XEiJ.busWb (a, '\0');
2620: return;
2621: }
2622:
2623:
2624: e = (int) Math.floor ((double) e * 0.30102999566398119521373889472);
2625:
2626:
2627:
2628:
2629: if (0 < e) {
2630: x *= FPK_TEN_M16QR[e & 15];
2631: if (16 <= e) {
2632: x *= FPK_TEN_M16QR[16 + (e >> 4 & 15)];
2633: if (256 <= e) {
2634: x *= FPK_TEN_M16QR[33];
2635: }
2636: }
2637: } else if (e < 0) {
2638: x *= FPK_TEN_P16QR[-e & 15];
2639: if (e <= -16) {
2640: x *= FPK_TEN_P16QR[16 + (-e >> 4 & 15)];
2641: if (e <= -256) {
2642: x *= FPK_TEN_P16QR[33];
2643: }
2644: }
2645: }
2646:
2647:
2648: int[] w = new int[18];
2649: {
2650: int d = (int) x;
2651: int t = XEiJ.FMT_BCD4[d];
2652: w[0] = t >> 4;
2653: w[1] = t & 15;
2654: for (int i = 2; i < 18; i += 4) {
2655:
2656:
2657:
2658: double xh = x * 0x8000001p0;
2659: xh += x - xh;
2660: x = (xh - (double) d) * 10000.0 + (x - xh) * 10000.0;
2661: d = (int) x;
2662: t = XEiJ.FMT_BCD4[d];
2663: w[i ] = t >> 12;
2664: w[i + 1] = t >> 8 & 15;
2665: w[i + 2] = t >> 4 & 15;
2666: w[i + 3] = t & 15;
2667: }
2668: }
2669:
2670:
2671: int h = w[0] != 0 ? 0 : w[1] != 0 ? 1 : 2;
2672:
2673: int o = h + 14;
2674: if (5 <= w[o]) {
2675: int i = o;
2676: while (10 <= ++w[--i]) {
2677: w[i] = 0;
2678: }
2679: if (i < h) {
2680: h--;
2681: o--;
2682: }
2683: }
2684:
2685:
2686: e -= h - 1;
2687:
2688: int ee = !exp ? e : Math.max (0, sgn1 != 0 || sgn2 != 0 ? len1 : len1 - 1) - 1;
2689:
2690:
2691:
2692: int s = h + ee + 1 + Math.max (0, len2);
2693: if (s < o) {
2694: o = s;
2695: if (0 <= o && 5 <= w[o]) {
2696: int i = o;
2697: while (10 <= ++w[--i]) {
2698: w[i] = 0;
2699: }
2700: if (i < h) {
2701: h--;
2702: if (!exp) {
2703: ee++;
2704: } else {
2705: e++;
2706: o--;
2707: }
2708: }
2709: }
2710: }
2711:
2712: if (0 <= ee) {
2713: for (int i = len1 - ((sgn1 != 0 ? 1 : 0) +
2714: (yen != 0 ? 1 : 0) +
2715: (cmm != 0 ? ee / 3 : 0) +
2716: ee + 1
2717: ); 0 < i; i--) {
2718: XEiJ.busWb (a++, spc);
2719: }
2720: if (sgn1 != 0) {
2721: XEiJ.busWb (a++, sgn1);
2722: }
2723: if (yen != 0) {
2724: XEiJ.busWb (a++, yen);
2725: }
2726: for (int i = ee; 0 <= i; i--) {
2727: XEiJ.busWb (a++, h < o ? '0' + w[h] : '0');
2728: h++;
2729: if (cmm != 0 && 0 < i && i % 3 == 0) {
2730: XEiJ.busWb (a++, cmm);
2731: }
2732: }
2733: if (0 <= len2) {
2734: XEiJ.busWb (a++, '.');
2735: for (; 0 < len2; len2--) {
2736: XEiJ.busWb (a++, h < o ? '0' + w[h] : '0');
2737: h++;
2738: }
2739: }
2740: } else {
2741: for (int i = len1 - ((sgn1 != 0 ? 1 : 0) +
2742: (yen != 0 ? 1 : 0) +
2743: 1
2744: ); 0 < i; i--) {
2745: XEiJ.busWb (a++, spc);
2746: }
2747: if (sgn1 != 0) {
2748: XEiJ.busWb (a++, sgn1);
2749: }
2750: if (yen != 0) {
2751: XEiJ.busWb (a++, yen);
2752: }
2753: if (0 < len1) {
2754: XEiJ.busWb (a++, '0');
2755: }
2756: if (0 <= len2) {
2757: XEiJ.busWb (a++, '.');
2758: for (int i = -1 - ee; 0 < len2 && 0 < i; len2--, i--) {
2759: XEiJ.busWb (a++, '0');
2760: }
2761: for (; 0 < len2; len2--) {
2762: XEiJ.busWb (a++, h < o ? '0' + w[h] : '0');
2763: h++;
2764: }
2765: }
2766: }
2767: if (exp) {
2768: e -= ee;
2769: XEiJ.busWb (a++, 'E');
2770: if (0 <= e) {
2771: XEiJ.busWb (a++, '+');
2772: } else {
2773: XEiJ.busWb (a++, '-');
2774: e = -e;
2775: }
2776: e = XEiJ.FMT_BCD4[e];
2777: XEiJ.busWb (a++, '0' + (e >> 8 ));
2778: XEiJ.busWb (a++, '0' + (e >> 4 & 15));
2779: XEiJ.busWb (a++, '0' + (e & 15));
2780: }
2781: if (sgn2 != 0) {
2782: XEiJ.busWb (a++, sgn2);
2783: }
2784: XEiJ.busWb (a, '\0');
2785: }
2786:
2787:
2788:
2789:
2790:
2791:
2792:
2793:
2794:
2795:
2796:
2797:
2798:
2799:
2800:
2801:
2802:
2803:
2804:
2805:
2806:
2807:
2808:
2809:
2810:
2811: public static void fpkSTOD () throws M68kException {
2812: long l = Double.doubleToLongBits (fpkSTODSub ());
2813: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
2814: l = 0x7fffffffffffffffL;
2815: }
2816: XEiJ.regRn[0] = (int) (l >> 32);
2817: XEiJ.regRn[1] = (int) l;
2818: }
2819: public static double fpkSTODSub () throws M68kException {
2820: int a = XEiJ.regRn[8];
2821:
2822: int c = XEiJ.busRbs (a);
2823: while (c == ' ' || c == '\t') {
2824: c = XEiJ.busRbs (++a);
2825: }
2826:
2827: double s = 1.0;
2828: if (c == '+') {
2829: c = XEiJ.busRbs (++a);
2830: } else if (c == '-') {
2831: s = -s;
2832: c = XEiJ.busRbs (++a);
2833: }
2834:
2835: if (c == '#') {
2836: c = XEiJ.busRbs (a + 1);
2837: if (c == 'N' || c == 'I') {
2838: c = c << 8 | XEiJ.busRbz (a + 2);
2839: if (c == ('N' << 8 | 'A') || c == ('I' << 8 | 'N')) {
2840: c = c << 8 | XEiJ.busRbz (a + 3);
2841: if (c == ('N' << 16 | 'A' << 8 | 'N') || c == ('I' << 16 | 'N' << 8 | 'F')) {
2842: XEiJ.regRn[2] = 0;
2843: XEiJ.regRn[3] = 0;
2844: XEiJ.regRn[8] = a + 4;
2845: XEiJ.regCCR = 0;
2846: return c == ('N' << 16 | 'A' << 8 | 'N') ? Double.NaN : s * Double.POSITIVE_INFINITY;
2847: }
2848: }
2849: }
2850: XEiJ.regRn[8] = a;
2851: XEiJ.regCCR = XEiJ.REG_CCR_N | XEiJ.REG_CCR_C;
2852: return 0.0;
2853: }
2854:
2855:
2856:
2857: long u = 0L;
2858: int n = 0;
2859: int e = 1;
2860: if (c == '.') {
2861: e = 0;
2862: c = XEiJ.busRbs (++a);
2863: }
2864: if (c < '0' || '9' < c) {
2865: XEiJ.regRn[8] = a;
2866: XEiJ.regCCR = XEiJ.REG_CCR_N | XEiJ.REG_CCR_C;
2867: return 0.0;
2868: }
2869: double x = 0.0;
2870: do {
2871: if (0 < n || '0' < c) {
2872: n++;
2873: }
2874: if (e <= 0 && n <= 18) {
2875: e--;
2876: }
2877: if (0 < n && n <= 18) {
2878: u = u * 10L + (long) (c - '0');
2879: }
2880: c = XEiJ.busRbs (++a);
2881: if (0 < e && c == '.') {
2882: e = 0;
2883: c = XEiJ.busRbs (++a);
2884: }
2885: } while ('0' <= c && c <= '9');
2886: if (0 < e) {
2887: e = 18 < n ? n - 18 : 0;
2888: }
2889:
2890:
2891:
2892:
2893:
2894:
2895: if (c == 'E' || c == 'e') {
2896: c = XEiJ.busRbs (++a);
2897: int t = 1;
2898: if (c == '+') {
2899: c = XEiJ.busRbs (++a);
2900: } else if (c == '-') {
2901: t = -t;
2902: c = XEiJ.busRbs (++a);
2903: }
2904: if (c < '0' || '9' < c) {
2905: XEiJ.regRn[8] = a;
2906: XEiJ.regCCR = XEiJ.REG_CCR_N | XEiJ.REG_CCR_C;
2907: return 0.0;
2908: }
2909: while (c == '0') {
2910: c = XEiJ.busRbs (++a);
2911: }
2912: int p = 0;
2913: for (int j = 0; '0' <= c && c <= '9' && j < 9; j++) {
2914: p = p * 10 + (c - '0');
2915: c = XEiJ.busRbs (++a);
2916: }
2917: e += t * p;
2918: }
2919:
2920:
2921:
2922: if (e < -350) {
2923: XEiJ.regRn[2] = 65535;
2924: XEiJ.regRn[3] = 0;
2925: XEiJ.regRn[8] = a;
2926: XEiJ.regCCR = 0;
2927: return s < 0.0 ? -0.0 : 0.0;
2928: }
2929: if (350 < e) {
2930: XEiJ.regRn[2] = 0;
2931: XEiJ.regRn[3] = 0;
2932: XEiJ.regRn[8] = a;
2933: XEiJ.regCCR = XEiJ.REG_CCR_V | XEiJ.REG_CCR_C;
2934: return s * Double.POSITIVE_INFINITY;
2935: }
2936: if (true) {
2937: QFP xx = new QFP (s < 0.0 ? -u : u);
2938: if (0 < e) {
2939: xx.mul (QFP.QFP_TEN_P16QR[e & 15]);
2940: if (16 <= e) {
2941: xx.mul (QFP.QFP_TEN_P16QR[16 + (e >> 4 & 15)]);
2942: if (256 <= e) {
2943: xx.mul (QFP.QFP_TEN_P16QR[33]);
2944: }
2945: }
2946: } else if (e < 0) {
2947: xx.mul (QFP.QFP_TEN_M16QR[-e & 15]);
2948: if (e <= -16) {
2949: xx.mul (QFP.QFP_TEN_M16QR[16 + (-e >> 4 & 15)]);
2950: if (e <= -256) {
2951: xx.mul (QFP.QFP_TEN_M16QR[33]);
2952: }
2953: }
2954: }
2955: x = xx.getd ();
2956: } else {
2957: x = s * (double) u;
2958: if (0 < e) {
2959: x *= FPK_TEN_P16QR[e & 15];
2960: if (16 <= e) {
2961: x *= FPK_TEN_P16QR[16 + (e >> 4 & 15)];
2962: if (256 <= e) {
2963: x *= FPK_TEN_P16QR[33];
2964: }
2965: }
2966: } else if (e < 0) {
2967: x /= FPK_TEN_P16QR[-e & 15];
2968: if (e <= -16) {
2969: x /= FPK_TEN_P16QR[16 + (-e >> 4 & 15)];
2970: if (e <= -256) {
2971: x /= FPK_TEN_P16QR[33];
2972: }
2973: }
2974: }
2975: }
2976: if (Double.isInfinite (x)) {
2977: XEiJ.regRn[8] = a;
2978: XEiJ.regCCR = XEiJ.REG_CCR_V | XEiJ.REG_CCR_C;
2979: return x;
2980: }
2981:
2982: if (x == (double) ((int) x)) {
2983: XEiJ.regRn[2] = 65535;
2984: XEiJ.regRn[3] = (int) x;
2985: } else {
2986: XEiJ.regRn[2] = 0;
2987: XEiJ.regRn[3] = 0;
2988: }
2989: XEiJ.regRn[8] = a;
2990: XEiJ.regCCR = 0;
2991: return x;
2992: }
2993:
2994:
2995:
2996:
2997:
2998:
2999:
3000:
3001:
3002:
3003:
3004:
3005:
3006:
3007:
3008: public static void fpkDTOS () throws M68kException {
3009: fpkDTOSSub ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
3010: }
3011: public static void fpkDTOSSub (long l) throws M68kException {
3012: final int len3 = 14;
3013: int a = XEiJ.regRn[8];
3014:
3015:
3016: if (l < 0L) {
3017: XEiJ.busWb (a++, '-');
3018: l &= 0x7fffffffffffffffL;
3019: }
3020: double x = Double.longBitsToDouble (l);
3021: int e = (int) (l >>> 52) - 1023;
3022: l &= 0x000fffffffffffffL;
3023: if (e == -1023) {
3024: if (l == 0L) {
3025: XEiJ.busWb (a++, '0');
3026: XEiJ.busWb (a, '\0');
3027: XEiJ.regRn[8] = a;
3028: return;
3029: }
3030: e -= Long.numberOfLeadingZeros (l) - 12;
3031: } else if (e == 1024) {
3032: XEiJ.busWb (a++, '#');
3033: if (l == 0L) {
3034: XEiJ.busWb (a++, 'I');
3035: XEiJ.busWb (a++, 'N');
3036: XEiJ.busWb (a++, 'F');
3037: } else {
3038: XEiJ.busWb (a++, 'N');
3039: XEiJ.busWb (a++, 'A');
3040: XEiJ.busWb (a++, 'N');
3041: }
3042: XEiJ.busWb (a, '\0');
3043: XEiJ.regRn[8] = a;
3044: return;
3045: }
3046:
3047:
3048: e = (int) Math.floor ((double) e * 0.30102999566398119521373889472);
3049:
3050:
3051:
3052:
3053: if (0 < e) {
3054: x *= FPK_TEN_M16QR[e & 15];
3055: if (16 <= e) {
3056: x *= FPK_TEN_M16QR[16 + (e >> 4 & 15)];
3057: if (256 <= e) {
3058: x *= FPK_TEN_M16QR[33];
3059: }
3060: }
3061: } else if (e < 0) {
3062: x *= FPK_TEN_P16QR[-e & 15];
3063: if (e <= -16) {
3064: x *= FPK_TEN_P16QR[16 + (-e >> 4 & 15)];
3065: if (e <= -256) {
3066: x *= FPK_TEN_P16QR[33];
3067: }
3068: }
3069: }
3070:
3071:
3072: int[] w = new int[18];
3073: {
3074: int d = (int) x;
3075: int t = XEiJ.FMT_BCD4[d];
3076: w[0] = t >> 4;
3077: w[1] = t & 15;
3078: for (int i = 2; i < 18; i += 4) {
3079:
3080:
3081:
3082: double xh = x * 0x8000001p0;
3083: xh += x - xh;
3084: x = (xh - (double) d) * 10000.0 + (x - xh) * 10000.0;
3085: d = (int) x;
3086: t = XEiJ.FMT_BCD4[d];
3087: w[i ] = t >> 12;
3088: w[i + 1] = t >> 8 & 15;
3089: w[i + 2] = t >> 4 & 15;
3090: w[i + 3] = t & 15;
3091: }
3092: }
3093:
3094:
3095: int h = w[0] != 0 ? 0 : w[1] != 0 ? 1 : 2;
3096:
3097: int o = h + 14;
3098: if (5 <= w[o]) {
3099: int i = o;
3100: while (10 <= ++w[--i]) {
3101: w[i] = 0;
3102: }
3103: if (i < h) {
3104: h--;
3105: o--;
3106: }
3107: }
3108:
3109:
3110: e -= h - 1;
3111:
3112:
3113: while (w[o - 1] == 0) {
3114: o--;
3115: }
3116:
3117: if (0 <= e && e < len3) {
3118: for (; 0 <= e && h < o; e--) {
3119: XEiJ.busWb (a++, '0' + w[h++]);
3120: }
3121: for (; 0 <= e; e--) {
3122: XEiJ.busWb (a++, '0');
3123: }
3124: if (h < o) {
3125: XEiJ.busWb (a++, '.');
3126: do {
3127: XEiJ.busWb (a++, '0' + w[h++]);
3128: } while (h < o);
3129: }
3130: } else if (-4 <= e && e < 0) {
3131: XEiJ.busWb (a++, '0');
3132: XEiJ.busWb (a++, '.');
3133: while (++e < 0) {
3134: XEiJ.busWb (a++, '0');
3135: }
3136: do {
3137: XEiJ.busWb (a++, '0' + w[h++]);
3138: } while (h < o);
3139: } else {
3140: XEiJ.busWb (a++, '0' + w[h++]);
3141: if (h < o) {
3142: XEiJ.busWb (a++, '.');
3143: do {
3144: XEiJ.busWb (a++, '0' + w[h++]);
3145: } while (h < o);
3146: }
3147: XEiJ.busWb (a++, 'E');
3148: if (0 <= e) {
3149: XEiJ.busWb (a++, '+');
3150: } else {
3151: XEiJ.busWb (a++, '-');
3152: e = -e;
3153: }
3154: e = XEiJ.FMT_BCD4[e];
3155: XEiJ.busWb (a++, '0' + (e >> 8 ));
3156: XEiJ.busWb (a++, '0' + (e >> 4 & 15));
3157: XEiJ.busWb (a++, '0' + (e & 15));
3158: }
3159: XEiJ.busWb (a, '\0');
3160: XEiJ.regRn[8] = a;
3161: }
3162:
3163:
3164:
3165:
3166:
3167:
3168:
3169:
3170:
3171:
3172:
3173:
3174:
3175:
3176:
3177:
3178:
3179:
3180:
3181:
3182:
3183:
3184:
3185:
3186:
3187:
3188:
3189:
3190:
3191:
3192:
3193:
3194:
3195: public static void fpkECVT () throws M68kException {
3196: fpkECVTSub ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
3197: }
3198: public static void fpkECVTSub (long l) throws M68kException {
3199: int len3 = XEiJ.regRn[2];
3200: int a = XEiJ.regRn[8];
3201: if (len3 <= 0) {
3202: XEiJ.busWb (a, '\0');
3203: return;
3204: }
3205: int b = a + len3;
3206:
3207:
3208: if (0L <= l) {
3209: XEiJ.regRn[1] = 0;
3210: } else {
3211: XEiJ.regRn[1] = 1;
3212: l &= 0x7fffffffffffffffL;
3213: }
3214: double x = Double.longBitsToDouble (l);
3215: int e = (int) (l >>> 52) - 1023;
3216: l &= 0x000fffffffffffffL;
3217: if (e == -1023) {
3218: if (l == 0L) {
3219:
3220: while (a < b) {
3221: XEiJ.busWb (a++, '0');
3222: }
3223: XEiJ.busWb (a, '\0');
3224: XEiJ.regRn[0] = 1;
3225: return;
3226: }
3227: e -= Long.numberOfLeadingZeros (l) - 12;
3228: } else if (e == 1024) {
3229: for (int s = l != 0L ? '#' | 'N' << 8 | 'A' << 16 | 'N' << 24 : '#' | 'I' << 8 | 'N' << 16 | 'F' << 24; a < b && s != 0; s >>>= 8) {
3230: XEiJ.busWb (a++, s);
3231: }
3232: while (a < b) {
3233: XEiJ.busWb (a++, '\0');
3234: }
3235: XEiJ.busWb (a, '\0');
3236: XEiJ.regRn[0] = 4;
3237: return;
3238: }
3239:
3240:
3241: e = (int) Math.floor ((double) e * 0.30102999566398119521373889472);
3242:
3243:
3244:
3245:
3246: if (0 < e) {
3247: x *= FPK_TEN_M16QR[e & 15];
3248: if (16 <= e) {
3249: x *= FPK_TEN_M16QR[16 + (e >> 4 & 15)];
3250: if (256 <= e) {
3251: x *= FPK_TEN_M16QR[33];
3252: }
3253: }
3254: } else if (e < 0) {
3255: x *= FPK_TEN_P16QR[-e & 15];
3256: if (e <= -16) {
3257: x *= FPK_TEN_P16QR[16 + (-e >> 4 & 15)];
3258: if (e <= -256) {
3259: x *= FPK_TEN_P16QR[33];
3260: }
3261: }
3262: }
3263:
3264:
3265: int[] w = new int[18];
3266: {
3267: int d = (int) x;
3268: int t = XEiJ.FMT_BCD4[d];
3269: w[0] = t >> 4;
3270: w[1] = t & 15;
3271: for (int i = 2; i < 18; i += 4) {
3272:
3273:
3274:
3275: double xh = x * 0x8000001p0;
3276: xh += x - xh;
3277: x = (xh - (double) d) * 10000.0 + (x - xh) * 10000.0;
3278: d = (int) x;
3279: t = XEiJ.FMT_BCD4[d];
3280: w[i ] = t >> 12;
3281: w[i + 1] = t >> 8 & 15;
3282: w[i + 2] = t >> 4 & 15;
3283: w[i + 3] = t & 15;
3284: }
3285: }
3286:
3287:
3288: int h = w[0] != 0 ? 0 : w[1] != 0 ? 1 : 2;
3289:
3290: int o = h + 14;
3291: if (5 <= w[o]) {
3292: int i = o;
3293: while (10 <= ++w[--i]) {
3294: w[i] = 0;
3295: }
3296: if (i < h) {
3297: h--;
3298: o--;
3299: }
3300: }
3301:
3302:
3303: e -= h - 1;
3304:
3305:
3306:
3307: int s = h + len3;
3308: if (s < o) {
3309: o = s;
3310: if (0 <= o && 5 <= w[o]) {
3311: int i = o;
3312: while (10 <= ++w[--i]) {
3313: w[i] = 0;
3314: }
3315: if (i < h) {
3316: h--;
3317: o--;
3318: e++;
3319: }
3320: }
3321: }
3322:
3323: while (a < b && h < o) {
3324: XEiJ.busWb (a++, '0' + w[h++]);
3325: }
3326: while (a < b) {
3327: XEiJ.busWb (a++, '0');
3328: }
3329: XEiJ.busWb (a, '\0');
3330: XEiJ.regRn[0] = e + 1;
3331: }
3332:
3333:
3334:
3335:
3336:
3337:
3338:
3339:
3340:
3341:
3342:
3343:
3344:
3345:
3346:
3347:
3348:
3349:
3350:
3351:
3352:
3353:
3354:
3355:
3356:
3357:
3358:
3359:
3360:
3361:
3362:
3363:
3364:
3365:
3366:
3367:
3368:
3369:
3370:
3371:
3372:
3373: public static void fpkFCVT () throws M68kException {
3374: fpkFCVTSub ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
3375: }
3376: public static void fpkFCVTSub (long l) throws M68kException {
3377: int len2 = Math.max (0, XEiJ.regRn[2]);
3378: int a = XEiJ.regRn[8];
3379:
3380:
3381: if (0L <= l) {
3382: XEiJ.regRn[1] = 0;
3383: } else {
3384: XEiJ.regRn[1] = 1;
3385: l &= 0x7fffffffffffffffL;
3386: }
3387: double x = Double.longBitsToDouble (l);
3388: int e = (int) (l >>> 52) - 1023;
3389: l &= 0x000fffffffffffffL;
3390: if (e == -1023) {
3391: if (l == 0L) {
3392:
3393: while (len2-- > 0) {
3394: XEiJ.busWb (a++, '0');
3395: }
3396: XEiJ.busWb (a, '\0');
3397: XEiJ.regRn[0] = 0;
3398: return;
3399: }
3400: e -= Long.numberOfLeadingZeros (l) - 12;
3401: } else if (e == 1024) {
3402: XEiJ.busWb (a++, '#');
3403: if (l == 0L) {
3404: XEiJ.busWb (a++, 'I');
3405: XEiJ.busWb (a++, 'N');
3406: XEiJ.busWb (a++, 'F');
3407: } else {
3408: XEiJ.busWb (a++, 'N');
3409: XEiJ.busWb (a++, 'A');
3410: XEiJ.busWb (a++, 'N');
3411: }
3412: XEiJ.busWb (a, '\0');
3413: XEiJ.regRn[0] = 4;
3414: return;
3415: }
3416:
3417:
3418: e = (int) Math.floor ((double) e * 0.30102999566398119521373889472);
3419:
3420:
3421:
3422:
3423: if (0 < e) {
3424: x *= FPK_TEN_M16QR[e & 15];
3425: if (16 <= e) {
3426: x *= FPK_TEN_M16QR[16 + (e >> 4 & 15)];
3427: if (256 <= e) {
3428: x *= FPK_TEN_M16QR[33];
3429: }
3430: }
3431: } else if (e < 0) {
3432: x *= FPK_TEN_P16QR[-e & 15];
3433: if (e <= -16) {
3434: x *= FPK_TEN_P16QR[16 + (-e >> 4 & 15)];
3435: if (e <= -256) {
3436: x *= FPK_TEN_P16QR[33];
3437: }
3438: }
3439: }
3440:
3441:
3442: int[] w = new int[18];
3443: {
3444: int d = (int) x;
3445: int t = XEiJ.FMT_BCD4[d];
3446: w[0] = t >> 4;
3447: w[1] = t & 15;
3448: for (int i = 2; i < 18; i += 4) {
3449:
3450:
3451:
3452: double xh = x * 0x8000001p0;
3453: xh += x - xh;
3454: x = (xh - (double) d) * 10000.0 + (x - xh) * 10000.0;
3455: d = (int) x;
3456: t = XEiJ.FMT_BCD4[d];
3457: w[i ] = t >> 12;
3458: w[i + 1] = t >> 8 & 15;
3459: w[i + 2] = t >> 4 & 15;
3460: w[i + 3] = t & 15;
3461: }
3462: }
3463:
3464:
3465: int h = w[0] != 0 ? 0 : w[1] != 0 ? 1 : 2;
3466:
3467: int o = h + 14;
3468: if (5 <= w[o]) {
3469: int i = o;
3470: while (10 <= ++w[--i]) {
3471: w[i] = 0;
3472: }
3473: if (i < h) {
3474: h--;
3475: o--;
3476: }
3477: }
3478:
3479:
3480: e -= h - 1;
3481:
3482:
3483:
3484: int s = h + e + 1 + len2;
3485: if (s < o) {
3486: o = s;
3487: if (0 <= o && 5 <= w[o]) {
3488: int i = o;
3489: while (10 <= ++w[--i]) {
3490: w[i] = 0;
3491: }
3492: if (i < h) {
3493: h--;
3494: o--;
3495: e++;
3496: }
3497: }
3498: }
3499:
3500: while (h < o) {
3501: XEiJ.busWb (a++, '0' + w[h++]);
3502: }
3503: while (h++ < s) {
3504: XEiJ.busWb (a++, '0');
3505: }
3506: XEiJ.busWb (a, '\0');
3507: XEiJ.regRn[0] = e + 1;
3508: }
3509:
3510:
3511:
3512:
3513:
3514:
3515:
3516:
3517:
3518:
3519:
3520:
3521:
3522:
3523:
3524:
3525:
3526:
3527:
3528:
3529:
3530:
3531:
3532:
3533:
3534:
3535:
3536:
3537:
3538:
3539:
3540:
3541:
3542:
3543:
3544:
3545:
3546:
3547:
3548:
3549:
3550:
3551:
3552:
3553:
3554:
3555:
3556:
3557: public static void fpkGCVT () throws M68kException {
3558: fpkGCVTSub ((long) XEiJ.regRn[0] << 32 | 0xffffffffL & XEiJ.regRn[1]);
3559: }
3560: public static void fpkGCVTSub (long l) throws M68kException {
3561: int len3 = XEiJ.regRn[2];
3562: int a = XEiJ.regRn[8];
3563: if (len3 <= 0) {
3564: XEiJ.busWb (a, '\0');
3565: return;
3566: }
3567:
3568:
3569: if (l < 0L) {
3570: XEiJ.busWb (a++, '-');
3571: l &= 0x7fffffffffffffffL;
3572: }
3573: double x = Double.longBitsToDouble (l);
3574: int e = (int) (l >>> 52) - 1023;
3575: l &= 0x000fffffffffffffL;
3576: if (e == -1023) {
3577: if (l == 0L) {
3578: XEiJ.busWb (a++, '0');
3579: XEiJ.busWb (a++, '.');
3580: XEiJ.busWb (a, '\0');
3581: XEiJ.regRn[8] = a;
3582: return;
3583: }
3584: e -= Long.numberOfLeadingZeros (l) - 12;
3585: } else if (e == 1024) {
3586: XEiJ.busWb (a++, '#');
3587: if (l == 0L) {
3588: XEiJ.busWb (a++, 'I');
3589: XEiJ.busWb (a++, 'N');
3590: XEiJ.busWb (a++, 'F');
3591: } else {
3592: XEiJ.busWb (a++, 'N');
3593: XEiJ.busWb (a++, 'A');
3594: XEiJ.busWb (a++, 'N');
3595: }
3596: XEiJ.busWb (a, '\0');
3597: XEiJ.regRn[8] = a;
3598: return;
3599: }
3600:
3601:
3602: e = (int) Math.floor ((double) e * 0.30102999566398119521373889472);
3603:
3604:
3605:
3606:
3607: if (0 < e) {
3608: x *= FPK_TEN_M16QR[e & 15];
3609: if (16 <= e) {
3610: x *= FPK_TEN_M16QR[16 + (e >> 4 & 15)];
3611: if (256 <= e) {
3612: x *= FPK_TEN_M16QR[33];
3613: }
3614: }
3615: } else if (e < 0) {
3616: x *= FPK_TEN_P16QR[-e & 15];
3617: if (e <= -16) {
3618: x *= FPK_TEN_P16QR[16 + (-e >> 4 & 15)];
3619: if (e <= -256) {
3620: x *= FPK_TEN_P16QR[33];
3621: }
3622: }
3623: }
3624:
3625:
3626: int[] w = new int[18];
3627: {
3628: int d = (int) x;
3629: int t = XEiJ.FMT_BCD4[d];
3630: w[0] = t >> 4;
3631: w[1] = t & 15;
3632: for (int i = 2; i < 18; i += 4) {
3633:
3634:
3635:
3636: double xh = x * 0x8000001p0;
3637: xh += x - xh;
3638: x = (xh - (double) d) * 10000.0 + (x - xh) * 10000.0;
3639: d = (int) x;
3640: t = XEiJ.FMT_BCD4[d];
3641: w[i ] = t >> 12;
3642: w[i + 1] = t >> 8 & 15;
3643: w[i + 2] = t >> 4 & 15;
3644: w[i + 3] = t & 15;
3645: }
3646: }
3647:
3648:
3649: int h = w[0] != 0 ? 0 : w[1] != 0 ? 1 : 2;
3650:
3651: int o = h + 14;
3652: if (5 <= w[o]) {
3653: int i = o;
3654: while (10 <= ++w[--i]) {
3655: w[i] = 0;
3656: }
3657: if (i < h) {
3658: h--;
3659: o--;
3660: }
3661: }
3662:
3663:
3664: e -= h - 1;
3665:
3666:
3667:
3668: int s = h + len3;
3669: if (s < o) {
3670: o = s;
3671: if (0 <= o && 5 <= w[o]) {
3672: int i = o;
3673: while (10 <= ++w[--i]) {
3674: w[i] = 0;
3675: }
3676: if (i < h) {
3677: h--;
3678: o--;
3679: e++;
3680: }
3681: }
3682: }
3683:
3684:
3685: while (w[o - 1] == 0) {
3686: o--;
3687: }
3688:
3689: if (0 <= e && e < len3) {
3690: for (; 0 <= e && h < o; e--) {
3691: XEiJ.busWb (a++, '0' + w[h++]);
3692: }
3693: for (; 0 <= e; e--) {
3694: XEiJ.busWb (a++, '0');
3695: }
3696: XEiJ.busWb (a++, '.');
3697: while (h < o) {
3698: XEiJ.busWb (a++, '0' + w[h++]);
3699: }
3700: } else if (-4 <= e && e < 0) {
3701: XEiJ.busWb (a++, '0');
3702: XEiJ.busWb (a++, '.');
3703: while (++e < 0) {
3704: XEiJ.busWb (a++, '0');
3705: }
3706: while (h < o) {
3707: XEiJ.busWb (a++, '0' + w[h++]);
3708: }
3709: } else {
3710: XEiJ.busWb (a++, '0' + w[h++]);
3711: XEiJ.busWb (a++, '.');
3712: while (h < o) {
3713: XEiJ.busWb (a++, '0' + w[h++]);
3714: }
3715: XEiJ.busWb (a++, 'E');
3716: if (0 <= e) {
3717: XEiJ.busWb (a++, '+');
3718: } else {
3719: XEiJ.busWb (a++, '-');
3720: e = -e;
3721: }
3722: e = XEiJ.FMT_BCD4[e];
3723: XEiJ.busWb (a++, '0' + (e >> 8 ));
3724: XEiJ.busWb (a++, '0' + (e >> 4 & 15));
3725: XEiJ.busWb (a++, '0' + (e & 15));
3726: }
3727: XEiJ.busWb (a, '\0');
3728: XEiJ.regRn[8] = a;
3729: }
3730:
3731:
3732:
3733:
3734:
3735:
3736:
3737:
3738:
3739:
3740:
3741: public static void fpkFVAL () throws M68kException {
3742: int a = XEiJ.regRn[8];
3743:
3744: int c = XEiJ.busRbs (a++);
3745: while (c == ' ' || c == '\t') {
3746: c = XEiJ.busRbs (a++);
3747: }
3748: if (c == '&') {
3749: c = XEiJ.busRbs (a++) & 0xdf;
3750: XEiJ.regRn[8] = a;
3751: if (c == 'B') {
3752: fpkSTOB ();
3753: fpkLTOF ();
3754: } else if (c == 'O') {
3755: fpkSTOO ();
3756: fpkLTOF ();
3757: } else if (c == 'H') {
3758: fpkSTOH ();
3759: fpkLTOF ();
3760: } else {
3761: XEiJ.regCCR = XEiJ.REG_CCR_N | XEiJ.REG_CCR_C;
3762: }
3763: } else {
3764: fpkSTOF ();
3765: }
3766: }
3767:
3768:
3769:
3770:
3771:
3772:
3773:
3774:
3775:
3776:
3777:
3778:
3779:
3780:
3781:
3782:
3783:
3784:
3785: public static void fpkFUSING () throws M68kException {
3786: fpkUSINGSub (Double.doubleToLongBits ((double) Float.intBitsToFloat (XEiJ.regRn[0])));
3787: }
3788:
3789:
3790:
3791:
3792:
3793:
3794:
3795:
3796:
3797:
3798:
3799: public static void fpkSTOF () throws M68kException {
3800: int h = Float.floatToIntBits ((float) fpkSTODSub ());
3801: if (FPK_FPCP_NAN && h == 0x7fc00000) {
3802: h = 0x7fffffff;
3803: }
3804: XEiJ.regRn[0] = h;
3805: }
3806:
3807:
3808:
3809:
3810:
3811:
3812:
3813:
3814: public static void fpkFTOS () throws M68kException {
3815: fpkDTOSSub (Double.doubleToLongBits ((double) Float.intBitsToFloat (XEiJ.regRn[0])));
3816: }
3817:
3818:
3819:
3820:
3821:
3822:
3823:
3824:
3825:
3826:
3827:
3828: public static void fpkFECVT () throws M68kException {
3829: fpkECVTSub (Double.doubleToLongBits ((double) Float.intBitsToFloat (XEiJ.regRn[0])));
3830: }
3831:
3832:
3833:
3834:
3835:
3836:
3837:
3838:
3839:
3840:
3841: public static void fpkFFCVT () throws M68kException {
3842: fpkFCVTSub (Double.doubleToLongBits ((double) Float.intBitsToFloat (XEiJ.regRn[0])));
3843: }
3844:
3845:
3846:
3847:
3848:
3849:
3850:
3851:
3852:
3853: public static void fpkFGCVT () throws M68kException {
3854: fpkGCVTSub (Double.doubleToLongBits ((double) Float.intBitsToFloat (XEiJ.regRn[0])));
3855: }
3856:
3857:
3858:
3859:
3860:
3861:
3862:
3863:
3864: public static void fpkCLMUL () throws M68kException {
3865: int a7 = XEiJ.regRn[15];
3866: long l = (long) XEiJ.busRls (a7) * (long) XEiJ.busRls (a7 + 4);
3867: int h = (int) l;
3868: XEiJ.busWl (a7, h);
3869: XEiJ.regCCR = (long) h == l ? 0 : XEiJ.REG_CCR_C;
3870: }
3871:
3872:
3873:
3874:
3875:
3876:
3877:
3878:
3879: public static void fpkCLDIV () throws M68kException {
3880: int a7 = XEiJ.regRn[15];
3881: int h = XEiJ.busRls (a7 + 4);
3882: if (h == 0) {
3883:
3884: XEiJ.regCCR = XEiJ.REG_CCR_C;
3885: } else {
3886: XEiJ.busWl (a7, XEiJ.busRls (a7) / h);
3887: XEiJ.regCCR = 0;
3888: }
3889: }
3890:
3891:
3892:
3893:
3894:
3895:
3896:
3897:
3898: public static void fpkCLMOD () throws M68kException {
3899: int a7 = XEiJ.regRn[15];
3900: int h = XEiJ.busRls (a7 + 4);
3901: if (h == 0) {
3902:
3903: XEiJ.regCCR = XEiJ.REG_CCR_C;
3904: } else {
3905: XEiJ.busWl (a7, XEiJ.busRls (a7) % h);
3906: XEiJ.regCCR = 0;
3907: }
3908: }
3909:
3910:
3911:
3912:
3913:
3914:
3915:
3916:
3917: public static void fpkCUMUL () throws M68kException {
3918: int a7 = XEiJ.regRn[15];
3919: long l = (0xffffffffL & XEiJ.busRls (a7)) * (0xffffffffL & XEiJ.busRls (a7 + 4));
3920: int h = (int) l;
3921: XEiJ.busWl (a7, h);
3922: XEiJ.regCCR = (0xffffffffL & h) == l ? 0 : XEiJ.REG_CCR_C;
3923: }
3924:
3925:
3926:
3927:
3928:
3929:
3930:
3931:
3932: public static void fpkCUDIV () throws M68kException {
3933: int a7 = XEiJ.regRn[15];
3934: int h = XEiJ.busRls (a7 + 4);
3935: if (h == 0) {
3936:
3937: XEiJ.regCCR = XEiJ.REG_CCR_C;
3938: } else {
3939: XEiJ.busWl (a7, (int) ((0xffffffffL & XEiJ.busRls (a7)) / (0xffffffffL & h)));
3940: XEiJ.regCCR = 0;
3941: }
3942: }
3943:
3944:
3945:
3946:
3947:
3948:
3949:
3950:
3951: public static void fpkCUMOD () throws M68kException {
3952: int a7 = XEiJ.regRn[15];
3953: int h = XEiJ.busRls (a7 + 4);
3954: if (h == 0) {
3955:
3956: XEiJ.regCCR = XEiJ.REG_CCR_C;
3957: } else {
3958: XEiJ.busWl (a7, (int) ((0xffffffffL & XEiJ.busRls (a7)) % (0xffffffffL & h)));
3959: XEiJ.regCCR = 0;
3960: }
3961: }
3962:
3963:
3964:
3965:
3966:
3967:
3968: public static void fpkCLTOD () throws M68kException {
3969:
3970: int a7 = XEiJ.regRn[15];
3971: long l = Double.doubleToLongBits ((double) XEiJ.busRls (a7));
3972: XEiJ.busWl (a7, (int) (l >>> 32));
3973: XEiJ.busWl (a7 + 4, (int) l);
3974: }
3975:
3976:
3977:
3978:
3979:
3980:
3981:
3982: public static void fpkCDTOL () throws M68kException {
3983:
3984: int a7 = XEiJ.regRn[15];
3985: double d = Double.longBitsToDouble ((long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4));
3986: XEiJ.busWl (a7, (int) d);
3987: XEiJ.regCCR = (double) Integer.MIN_VALUE - 1.0 < d && d < (double) Integer.MAX_VALUE + 1.0 ? 0 : XEiJ.REG_CCR_C;
3988: }
3989:
3990:
3991:
3992:
3993:
3994:
3995: public static void fpkCLTOF () throws M68kException {
3996:
3997: int a7 = XEiJ.regRn[15];
3998: XEiJ.busWl (a7, Float.floatToIntBits ((float) XEiJ.busRls (a7)));
3999: }
4000:
4001:
4002:
4003:
4004:
4005:
4006:
4007: public static void fpkCFTOL () throws M68kException {
4008:
4009: int a7 = XEiJ.regRn[15];
4010: float f = Float.intBitsToFloat (XEiJ.busRls (a7));
4011: XEiJ.busWl (a7, (int) f);
4012: XEiJ.regCCR = (float) Integer.MIN_VALUE - 1.0F < f && f < (float) Integer.MAX_VALUE + 1.0F ? 0 : XEiJ.REG_CCR_C;
4013: }
4014:
4015:
4016:
4017:
4018:
4019:
4020: public static void fpkCFTOD () throws M68kException {
4021:
4022: int a7 = XEiJ.regRn[15];
4023: long l = Double.doubleToLongBits ((double) Float.intBitsToFloat (XEiJ.busRls (a7)));
4024: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
4025: l = 0x7fffffffffffffffL;
4026: }
4027: XEiJ.busWl (a7, (int) (l >>> 32));
4028: XEiJ.busWl (a7 + 4, (int) l);
4029: }
4030:
4031:
4032:
4033:
4034:
4035:
4036:
4037: public static void fpkCDTOF () throws M68kException {
4038:
4039: int a7 = XEiJ.regRn[15];
4040: double d = Double.longBitsToDouble ((long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4));
4041: int h = Float.floatToIntBits ((float) d);
4042: if (FPK_FPCP_NAN && h == 0x7fc00000) {
4043: h = 0x7fffffff;
4044: }
4045: XEiJ.busWl (a7, h);
4046: XEiJ.regCCR = (Double.isNaN (d) || Double.isInfinite (d) ||
4047: Math.abs (d) < (double) Float.MAX_VALUE + 0.5 * (double) Math.ulp (Float.MAX_VALUE) ? 0 : XEiJ.REG_CCR_C);
4048: }
4049:
4050:
4051:
4052:
4053:
4054:
4055:
4056:
4057: public static void fpkCDCMP () throws M68kException {
4058:
4059: int a7 = XEiJ.regRn[15];
4060: double xd = Double.longBitsToDouble ((long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4));
4061: double yd = Double.longBitsToDouble ((long) XEiJ.busRls (a7 + 8) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 12));
4062: XEiJ.regCCR = xd < yd ? XEiJ.REG_CCR_N | XEiJ.REG_CCR_C : xd == yd ? XEiJ.REG_CCR_Z : 0;
4063: }
4064:
4065:
4066:
4067:
4068:
4069:
4070:
4071:
4072: public static void fpkCDADD () throws M68kException {
4073:
4074: int a7 = XEiJ.regRn[15];
4075: double xd = Double.longBitsToDouble ((long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4));
4076: double yd = Double.longBitsToDouble ((long) XEiJ.busRls (a7 + 8) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 12));
4077: double zd = xd + yd;
4078: long l = Double.doubleToLongBits (zd);
4079: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
4080: l = 0x7fffffffffffffffL;
4081: }
4082: XEiJ.busWl (a7, (int) (l >>> 32));
4083: XEiJ.busWl (a7 + 4, (int) l);
4084: XEiJ.regCCR = (Double.isNaN (xd) || Double.isNaN (yd) ? 0 :
4085: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
4086: Double.isInfinite (xd) || Double.isInfinite (yd) ? 0 :
4087: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
4088: 0);
4089: }
4090:
4091:
4092:
4093:
4094:
4095:
4096:
4097:
4098: public static void fpkCDSUB () throws M68kException {
4099:
4100: int a7 = XEiJ.regRn[15];
4101: double xd = Double.longBitsToDouble ((long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4));
4102: double yd = Double.longBitsToDouble ((long) XEiJ.busRls (a7 + 8) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 12));
4103: double zd = xd - yd;
4104: long l = Double.doubleToLongBits (zd);
4105: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
4106: l = 0x7fffffffffffffffL;
4107: }
4108: XEiJ.busWl (a7, (int) (l >>> 32));
4109: XEiJ.busWl (a7 + 4, (int) l);
4110: XEiJ.regCCR = (Double.isNaN (xd) || Double.isNaN (yd) ? 0 :
4111: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
4112: Double.isInfinite (xd) || Double.isInfinite (yd) ? 0 :
4113: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
4114: 0);
4115: }
4116:
4117:
4118:
4119:
4120:
4121:
4122:
4123:
4124: public static void fpkCDMUL () throws M68kException {
4125:
4126: int a7 = XEiJ.regRn[15];
4127: double xd = Double.longBitsToDouble ((long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4));
4128: double yd = Double.longBitsToDouble ((long) XEiJ.busRls (a7 + 8) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 12));
4129: double zd = xd * yd;
4130: long l = Double.doubleToLongBits (zd);
4131: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
4132: l = 0x7fffffffffffffffL;
4133: }
4134: XEiJ.busWl (a7, (int) (l >>> 32));
4135: XEiJ.busWl (a7 + 4, (int) l);
4136: XEiJ.regCCR = (Double.isNaN (xd) || Double.isNaN (yd) ? 0 :
4137: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
4138: Double.isInfinite (xd) || Double.isInfinite (yd) ? 0 :
4139: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
4140: 0);
4141: }
4142:
4143:
4144:
4145:
4146:
4147:
4148:
4149:
4150: public static void fpkCDDIV () throws M68kException {
4151:
4152: int a7 = XEiJ.regRn[15];
4153: double xd = Double.longBitsToDouble ((long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4));
4154: double yd = Double.longBitsToDouble ((long) XEiJ.busRls (a7 + 8) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 12));
4155: double zd = xd / yd;
4156: long l = Double.doubleToLongBits (zd);
4157: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
4158: l = 0x7fffffffffffffffL;
4159: }
4160: XEiJ.busWl (a7, (int) (l >>> 32));
4161: XEiJ.busWl (a7 + 4, (int) l);
4162: XEiJ.regCCR = (Double.isNaN (xd) || Double.isNaN (yd) ? 0 :
4163: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
4164: Double.isInfinite (xd) || Double.isInfinite (yd) ? 0 :
4165: yd == 0.0 ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
4166: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
4167: 0);
4168: }
4169:
4170:
4171:
4172:
4173:
4174:
4175:
4176:
4177: public static void fpkCDMOD () throws M68kException {
4178:
4179: int a7 = XEiJ.regRn[15];
4180: double xd = Double.longBitsToDouble ((long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4));
4181: double yd = Double.longBitsToDouble ((long) XEiJ.busRls (a7 + 8) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 12));
4182: double zd = xd % yd;
4183: long l = Double.doubleToLongBits (zd);
4184: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
4185: l = 0x7fffffffffffffffL;
4186: }
4187: XEiJ.busWl (a7, (int) (l >>> 32));
4188: XEiJ.busWl (a7 + 4, (int) l);
4189: XEiJ.regCCR = (Double.isNaN (xd) || Double.isNaN (yd) ? 0 :
4190: yd == 0.0 ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
4191: Double.isNaN (zd) ? XEiJ.REG_CCR_C :
4192: Double.isInfinite (xd) || Double.isInfinite (yd) ? 0 :
4193: Double.isInfinite (zd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
4194: 0);
4195: }
4196:
4197:
4198:
4199:
4200:
4201:
4202:
4203:
4204: public static void fpkCFCMP () throws M68kException {
4205:
4206: int a7 = XEiJ.regRn[15];
4207: float xf = Float.intBitsToFloat (XEiJ.busRls (a7));
4208: float yf = Float.intBitsToFloat (XEiJ.busRls (a7 + 4));
4209: XEiJ.regCCR = xf < yf ? XEiJ.REG_CCR_N | XEiJ.REG_CCR_C : xf == yf ? XEiJ.REG_CCR_Z : 0;
4210: }
4211:
4212:
4213:
4214:
4215:
4216:
4217:
4218:
4219: public static void fpkCFADD () throws M68kException {
4220:
4221: int a7 = XEiJ.regRn[15];
4222: float xf = Float.intBitsToFloat (XEiJ.busRls (a7));
4223: float yf = Float.intBitsToFloat (XEiJ.busRls (a7 + 4));
4224: float zf = xf + yf;
4225: int h = Float.floatToIntBits (zf);
4226: if (FPK_FPCP_NAN && h == 0x7fc00000) {
4227: h = 0x7fffffff;
4228: }
4229: XEiJ.busWl (a7, h);
4230: XEiJ.regCCR = (Float.isNaN (xf) || Float.isNaN (yf) ? 0 :
4231: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
4232: Float.isInfinite (xf) || Float.isInfinite (yf) ? 0 :
4233: Float.isInfinite (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
4234: 0);
4235: }
4236:
4237:
4238:
4239:
4240:
4241:
4242:
4243:
4244: public static void fpkCFSUB () throws M68kException {
4245:
4246: int a7 = XEiJ.regRn[15];
4247: float xf = Float.intBitsToFloat (XEiJ.busRls (a7));
4248: float yf = Float.intBitsToFloat (XEiJ.busRls (a7 + 4));
4249: float zf = xf - yf;
4250: int h = Float.floatToIntBits (zf);
4251: if (FPK_FPCP_NAN && h == 0x7fc00000) {
4252: h = 0x7fffffff;
4253: }
4254: XEiJ.busWl (a7, h);
4255: XEiJ.regCCR = (Float.isNaN (xf) || Float.isNaN (yf) ? 0 :
4256: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
4257: Float.isInfinite (xf) || Float.isInfinite (yf) ? 0 :
4258: Float.isInfinite (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
4259: 0);
4260: }
4261:
4262:
4263:
4264:
4265:
4266:
4267:
4268:
4269: public static void fpkCFMUL () throws M68kException {
4270:
4271: int a7 = XEiJ.regRn[15];
4272: float xf = Float.intBitsToFloat (XEiJ.busRls (a7));
4273: float yf = Float.intBitsToFloat (XEiJ.busRls (a7 + 4));
4274: float zf = xf * yf;
4275: int h = Float.floatToIntBits (zf);
4276: if (FPK_FPCP_NAN && h == 0x7fc00000) {
4277: h = 0x7fffffff;
4278: }
4279: XEiJ.busWl (a7, h);
4280: XEiJ.regCCR = (Float.isNaN (xf) || Float.isNaN (yf) ? 0 :
4281: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
4282: Float.isInfinite (xf) || Float.isInfinite (yf) ? 0 :
4283: Float.isInfinite (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
4284: 0);
4285: }
4286:
4287:
4288:
4289:
4290:
4291:
4292:
4293:
4294: public static void fpkCFDIV () throws M68kException {
4295:
4296: int a7 = XEiJ.regRn[15];
4297: float xf = Float.intBitsToFloat (XEiJ.busRls (a7));
4298: float yf = Float.intBitsToFloat (XEiJ.busRls (a7 + 4));
4299: float zf = xf / yf;
4300: int h = Float.floatToIntBits (zf);
4301: if (FPK_FPCP_NAN && h == 0x7fc00000) {
4302: h = 0x7fffffff;
4303: }
4304: XEiJ.busWl (a7, h);
4305: XEiJ.regCCR = (Float.isNaN (xf) || Float.isNaN (yf) ? 0 :
4306: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
4307: Float.isInfinite (xf) || Float.isInfinite (yf) ? 0 :
4308: yf == 0.0F ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
4309: Float.isInfinite (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
4310: 0);
4311: }
4312:
4313:
4314:
4315:
4316:
4317:
4318:
4319:
4320: public static void fpkCFMOD () throws M68kException {
4321:
4322: int a7 = XEiJ.regRn[15];
4323: float xf = Float.intBitsToFloat (XEiJ.busRls (a7));
4324: float yf = Float.intBitsToFloat (XEiJ.busRls (a7 + 4));
4325: float zf = xf % yf;
4326: int h = Float.floatToIntBits (zf);
4327: if (FPK_FPCP_NAN && h == 0x7fc00000) {
4328: h = 0x7fffffff;
4329: }
4330: XEiJ.busWl (a7, h);
4331: XEiJ.regCCR = (Float.isNaN (xf) || Float.isNaN (yf) ? 0 :
4332: yf == 0.0F ? XEiJ.REG_CCR_Z | XEiJ.REG_CCR_C :
4333: Float.isNaN (zf) ? XEiJ.REG_CCR_C :
4334: Float.isInfinite (xf) || Float.isInfinite (yf) ? 0 :
4335: Float.isInfinite (zf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C :
4336: 0);
4337: }
4338:
4339:
4340:
4341:
4342:
4343:
4344:
4345: public static void fpkCDTST () throws M68kException {
4346: if (true) {
4347: int a7 = XEiJ.regRn[15];
4348: long l = (long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4);
4349: XEiJ.regCCR = l << 1 == 0L ? XEiJ.REG_CCR_Z : 0L <= l ? 0 : XEiJ.REG_CCR_N;
4350: } else {
4351:
4352: int a7 = XEiJ.regRn[15];
4353: double d = Double.longBitsToDouble ((long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4));
4354: XEiJ.regCCR = d < 0.0 ? XEiJ.REG_CCR_N : d == 0.0 ? XEiJ.REG_CCR_Z : 0;
4355: }
4356: }
4357:
4358:
4359:
4360:
4361:
4362:
4363:
4364: public static void fpkCFTST () throws M68kException {
4365:
4366: if (true) {
4367: int h = XEiJ.busRls (XEiJ.regRn[15]);
4368: XEiJ.regCCR = h << 1 == 0 ? XEiJ.REG_CCR_Z : 0 <= h ? 0 : XEiJ.REG_CCR_N;
4369: } else {
4370:
4371: float f = Float.intBitsToFloat (XEiJ.busRls (XEiJ.regRn[15]));
4372: XEiJ.regCCR = f < 0.0F ? XEiJ.REG_CCR_N : f == 0.0F ? XEiJ.REG_CCR_Z : 0;
4373: }
4374: }
4375:
4376:
4377:
4378:
4379:
4380:
4381: public static void fpkCDINC () throws M68kException {
4382:
4383: int a7 = XEiJ.regRn[15];
4384: double xd = Double.longBitsToDouble ((long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4));
4385: double zd = xd + 1.0;
4386: long l = Double.doubleToLongBits (zd);
4387: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
4388: l = 0x7fffffffffffffffL;
4389: }
4390: XEiJ.busWl (a7, (int) (l >>> 32));
4391: XEiJ.busWl (a7 + 4, (int) l);
4392: XEiJ.regCCR = Double.isInfinite (zd) && !Double.isInfinite (xd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C : 0;
4393: }
4394:
4395:
4396:
4397:
4398:
4399:
4400: public static void fpkCFINC () throws M68kException {
4401:
4402: int a7 = XEiJ.regRn[15];
4403: float xf = Float.intBitsToFloat (XEiJ.busRls (a7));
4404: float zf = xf + 1.0F;
4405: int h = Float.floatToIntBits (zf);
4406: if (FPK_FPCP_NAN && h == 0x7fc00000) {
4407: h = 0x7fffffff;
4408: }
4409: XEiJ.busWl (a7, h);
4410: XEiJ.regCCR = Double.isInfinite (zf) && !Float.isInfinite (xf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C : 0;
4411: }
4412:
4413:
4414:
4415:
4416:
4417:
4418: public static void fpkCDDEC () throws M68kException {
4419:
4420: int a7 = XEiJ.regRn[15];
4421: double xd = Double.longBitsToDouble ((long) XEiJ.busRls (a7) << 32 | 0xffffffffL & XEiJ.busRls (a7 + 4));
4422: double zd = xd - 1.0;
4423: long l = Double.doubleToLongBits (zd);
4424: if (FPK_FPCP_NAN && l == 0x7ff8000000000000L) {
4425: l = 0x7fffffffffffffffL;
4426: }
4427: XEiJ.busWl (a7, (int) (l >>> 32));
4428: XEiJ.busWl (a7 + 4, (int) l);
4429: XEiJ.regCCR = Double.isInfinite (zd) && !Double.isInfinite (xd) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C : 0;
4430: }
4431:
4432:
4433:
4434:
4435:
4436:
4437: public static void fpkCFDEC () throws M68kException {
4438:
4439: int a7 = XEiJ.regRn[15];
4440: float xf = Float.intBitsToFloat (XEiJ.busRls (a7));
4441: float zf = xf - 1.0F;
4442: int h = Float.floatToIntBits (zf);
4443: if (FPK_FPCP_NAN && h == 0x7fc00000) {
4444: h = 0x7fffffff;
4445: }
4446: XEiJ.busWl (a7, h);
4447: XEiJ.regCCR = Double.isInfinite (zf) && !Float.isInfinite (xf) ? XEiJ.REG_CCR_V | XEiJ.REG_CCR_C : 0;
4448: }
4449:
4450: }
4451:
4452:
4453: