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