ExpressionEvaluator.java
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62: package xeij;
63:
64: import java.lang.*;
65: import java.util.*;
66:
67: public class ExpressionEvaluator extends EFPBox {
68:
69:
70:
71: public static final String[] EVX_HELP_MESSAGE_JA = new String[] {
72: ("コマンド\n" +
73: " d<サイズ> <開始アドレス>,<終了アドレス¹>\n" +
74: " メモリダンプ\n" +
75: " f<サイズ> <開始アドレス>,<終了アドレス¹>,<データ>,…\n" +
76: " メモリ充填\n" +
77: " g <開始アドレス> 実行\n" +
78: " h ヘルプ\n" +
79: " i 停止\n" +
80: " l <開始アドレス>,<終了アドレス¹>\n" +
81: " 逆アセンブル\n" +
82: " ll ラベル一覧\n" +
83: " me<サイズ> <開始アドレス>,<データ>,…\n" +
84: " メモリ編集\n" +
85: " ms<サイズ> <開始アドレス>,<終了アドレス¹>,<データ>,…\n" +
86: " メモリ検索\n" +
87: " p <式>,… 計算と表示\n" +
88: " r ステップアンティルリターン\n" +
89: " s <回数> ステップ\n" +
90: " t <回数> トレース\n" +
91: " tx <回数> レジスタ表示付きトレース\n" +
92: " txf <回数> 浮動小数点レジスタ表示付きトレース\n" +
93: " x レジスタ一覧\n" +
94: " xf 浮動小数点レジスタ一覧\n" +
95: " <式> 計算\n" +
96: " <コマンド>;… 逐次実行\n" +
97: " ¹終了アドレスは範囲に含まれる\n"),
98: ("サイズ\n" +
99: " b バイト (8bit)\n" +
100: " w ワード (16bit)\n" +
101: " l ロング (32bit)\n" +
102: " q クワッド (64bit)\n" +
103: " s 単精度 (32bit)\n" +
104: " d 倍精度 (64bit)\n" +
105: " x 拡張精度 (80/96bit)\n" +
106: " t 三倍精度 (96bit)\n" +
107: " p パック10進数 (96bit)\n"),
108: ("浮動小数点数\n" +
109: " 1.0e+2 10進数\n" +
110: " 0b1.1001p+6 2進数\n" +
111: " 0o1.44p+6 8進数\n" +
112: " 0x1.9p+6 $64 16進数\n" +
113: " Infinity NaN 無限大, 非数\n" +
114: "数学定数\n" +
115: " Apery Catalan E Eular Pi\n" +
116: "文字コード\n" +
117: " 'A'\n" +
118: "文字列\n" +
119: " \"ABC\"\n"),
120: ("汎用レジスタ\n" +
121: " d0 … d7 r0 … r7 データレジスタ\n" +
122: " a0 … a7 r8 … r15 sp アドレスレジスタ\n" +
123: "浮動小数点レジスタ\n" +
124: " fp0 … fp7\n" +
125: "制御レジスタ\n" +
126: " pc sr ccr sfc dfc cacr tc itt0 itt1 dtt0 dtt1 buscr\n" +
127: " usp vbr caar ssp msp isp urp srp pcr fpiar fpsr fpcr\n" +
128: "変数\n" +
129: " foo 浮動小数点変数\n" +
130: " foo$ 文字列変数\n" +
131: "アドレスとファンクションコード\n" +
132: " <アドレス> 現在のアドレス空間\n" +
133: " <物理アドレス>@0 物理アドレス空間\n" +
134: " <論理アドレス>@1 ユーザデータ空間\n" +
135: " <論理アドレス>@2 ユーザコード空間\n" +
136: " <論理アドレス>@5 スーパーバイザデータ空間\n" +
137: " <論理アドレス>@6 スーパーバイザコード空間\n"),
138: ("演算子\n" +
139: " <汎用レジスタ>.<サイズ> 汎用レジスタアクセス\n" +
140: " [<アドレス>].<サイズ> メモリアクセス\n" +
141: " x.<サイズ> キャスト\n" +
142: " x(y) 関数呼び出し\n" +
143: " x++ ++x x-- --x インクリメント, デクリメント\n" +
144: " +x -x ~x !x 符号, ビットNOT, 論理NOT\n" +
145: " x**y x*y x/y x%y 累乗, 乗除算\n" +
146: " x+y x-y 加減算, 連結\n" +
147: " x<<y x>>y x>>>y シフト\n" +
148: " x<y x<=y x>y x>=y 比較\n" +
149: " x==y x!=y 等価\n" +
150: " x&y x^y x|y x&&y x||y ビットAND, XOR, OR, 論理AND, OR\n" +
151: " x?y:z 条件\n" +
152: " x=y x**=y x*=y x/=y x%=y x+=y x-=y\n" +
153: " x<<=y x>>=y x>>>=y x&=y x^=y x|=y\n" +
154: " 代入, 複合代入\n" +
155: " x,y 逐次評価\n"),
156: ("関数\n" +
157: " abs acos acosh acot acoth acsc acsch agi agm\n" +
158: " asc asec asech asin asinh atan atan2 atanh\n" +
159: " bin$ cbrt ceil chr$ cmp cmp0 cmp1 cmp1abs cmpabs\n" +
160: " cos cosh cot coth csc csch cub dec deg div2 div3 divpi divrz\n" +
161: " exp exp10 exp2 exp2m1 expm1 floor frac getexp getman\n" +
162: " hex$ ieeerem inc iseven isinf isint isnan isodd isone iszero\n" +
163: " lgamma log log10 log1p log2 max min mul2 mul3 mulpi\n" +
164: " oct$ pow quo rad random rcp rint rmode round rprec\n" +
165: " sec sech sgn sin sinh sqrt squ str$ tan tanh tgamma trunc ulp val\n"),
166: };
167: public static final String[] EVX_HELP_MESSAGE_EN = new String[] {
168: ("command\n" +
169: " d<size> <start-address>,<end-address¹>\n" +
170: " memory dump\n" +
171: " f<size> <start-address>,<end-address¹>,<data>,…\n" +
172: " memory fill\n" +
173: " g <start-address> run\n" +
174: " h help\n" +
175: " i stop\n" +
176: " l <start-address>,<end-address¹>\n" +
177: " disassemble\n" +
178: " ll label list\n" +
179: " me<size> <start-address>,<data>,…\n" +
180: " memory edit\n" +
181: " ms<size> <start-address>,<end-address¹>,<data>,…\n" +
182: " memory search\n" +
183: " p <expression>,… calculate and print\n" +
184: " r step until return\n" +
185: " s <number-of-times> step\n" +
186: " t <number-of-times> trace\n" +
187: " tx <number-of-times> trace with register list\n" +
188: " txf <number-of-times> trace with floating point register list\n" +
189: " x register list\n" +
190: " xf floating point register list\n" +
191: " <式> calculate\n" +
192: " <コマンド>;… sequential execution\n" +
193: " ¹the end address is within the range\n"),
194: ("size\n" +
195: " b byte (8bit)\n" +
196: " w word (16bit)\n" +
197: " l long (32bit)\n" +
198: " q quad (64bit)\n" +
199: " s single-precision (32bit)\n" +
200: " d double-precision (64bit)\n" +
201: " x extended-precision (80/96bit)\n" +
202: " t triple-precision (96bit)\n" +
203: " p packed decimal (96bit)\n"),
204: ("floating point number\n" +
205: " 1.0e+2 decimal number\n" +
206: " 0b1.1001p+6 binary number\n" +
207: " 0o1.44p+6 octal number\n" +
208: " 0x1.9p+6 $64 hexadecimal number\n" +
209: " Infinity NaN infinity, not a number\n" +
210: "mathematical constant\n" +
211: " Apery Catalan E Eular Pi\n" +
212: "character code\n" +
213: " 'A'\n" +
214: "string\n" +
215: " \"ABC\"\n"),
216: ("general register\n" +
217: " d0 … d7 r0 … r7 data register\n" +
218: " a0 … a7 r8 … r15 sp address register\n" +
219: "floating point register\n" +
220: " fp0 … fp7\n" +
221: "control register\n" +
222: " pc sr ccr sfc dfc cacr tc itt0 itt1 dtt0 dtt1 buscr\n" +
223: " usp vbr caar ssp msp isp urp srp pcr fpiar fpsr fpcr\n" +
224: "variable\n" +
225: " foo floating point variable\n" +
226: " foo$ string variable\n" +
227: "address space\n" +
228: " <address> current address space\n" +
229: " <physical-address>@0 physical address space\n" +
230: " <logical-address>@1 user data space\n" +
231: " <logical-address>@2 user code space\n" +
232: " <logical-address>@5 supervisor data space\n" +
233: " <logical-address>@6 supervisor code space\n"),
234: ("operator\n" +
235: " <genral-register>.<size>\n" +
236: " general register access\n" +
237: " [<address>].<size> memory access\n" +
238: " x.<size> cast\n" +
239: " x(y) function call\n" +
240: " x++ ++x x-- --x increment, decrement\n" +
241: " +x -x ~x !x signum, bitwise NOT, logical NOT\n" +
242: " x**y x*y x/y x%y exponentiation, multiplication and division\n" +
243: " x+y x-y addition and subtraction, concatenation\n" +
244: " x<<y x>>y x>>>y shift\n" +
245: " x<y x<=y x>y x>=y comparison\n" +
246: " x==y x!=y equality\n" +
247: " x&y x^y x|y x&&y x||y bitwise AND, XOR, OR, logical AND, OR\n" +
248: " x?y:z conditional\n" +
249: " x=y x**=y x*=y x/=y x%=y x+=y x-=y\n" +
250: " x<<=y x>>=y x>>>=y x&=y x^=y x|=y\n" +
251: " assignment, compound assignment\n" +
252: " x,y sequantial evaluation\n"),
253: ("function\n" +
254: " abs acos acosh acot acoth acsc acsch agi agm\n" +
255: " asc asec asech asin asinh atan atan2 atanh\n" +
256: " bin$ cbrt ceil chr$ cmp cmp0 cmp1 cmp1abs cmpabs\n" +
257: " cos cosh cot coth csc csch cub dec deg div2 div3 divpi divrz\n" +
258: " exp exp10 exp2 exp2m1 expm1 floor frac getexp getman\n" +
259: " hex$ ieeerem inc iseven isinf isint isnan isodd isone iszero\n" +
260: " lgamma log log10 log1p log2 max min mul2 mul3 mulpi\n" +
261: " oct$ pow quo rad random rcp rint rmode round rprec\n" +
262: " sec sech sgn sin sinh sqrt squ str$ tan tanh tgamma trunc ulp val\n"),
263: };
264:
265:
266:
267:
268:
269: protected HashMap<String,ExpressionElement> evxVariableMap;
270:
271:
272:
273:
274: public ExpressionEvaluator () {
275: evxVariableMap = new HashMap<String,ExpressionElement> ();
276: }
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295: protected static final int EVM_EXPRESSION = 1;
296: protected static final int EVM_COMMAND = 2;
297: protected static final int EVM_ASSEMBLER = 3;
298:
299:
300:
301:
302:
303: protected HashMap<Integer,Integer> evxLocalLabelCount;
304: protected HashMap<Integer,Integer> evxLocalLabelMap;
305:
306:
307:
308:
309:
310:
311: protected static final int EPY_PRIORITY_PRIMITIVE = 21;
312: protected static final int EPY_PRIORITY_FUNCTION = 20;
313: protected static final int EPY_PRIORITY_AT = 19;
314: protected static final int EPY_PRIORITY_POSTFIX = 18;
315: protected static final int EPY_PRIORITY_PREFIX = 17;
316: protected static final int EPY_PRIORITY_EXPONENTIATION = 16;
317: protected static final int EPY_PRIORITY_MULTIPLICATION = 15;
318: protected static final int EPY_PRIORITY_ADDITION = 14;
319: protected static final int EPY_PRIORITY_SHIFT = 13;
320: protected static final int EPY_PRIORITY_COMPARISON = 12;
321: protected static final int EPY_PRIORITY_EQUALITY = 11;
322: protected static final int EPY_PRIORITY_BITWISE_AND = 10;
323: protected static final int EPY_PRIORITY_BITWISE_XOR = 9;
324: protected static final int EPY_PRIORITY_BITWISE_OR = 8;
325: protected static final int EPY_PRIORITY_LOGICAL_AND = 7;
326: protected static final int EPY_PRIORITY_LOGICAL_OR = 6;
327: protected static final int EPY_PRIORITY_CONDITIONAL = 5;
328: protected static final int EPY_PRIORITY_ASSIGNMENT = 4;
329: protected static final int EPY_PRIORITY_COLON = 3;
330: protected static final int EPY_PRIORITY_COMMA = 2;
331: protected static final int EPY_PRIORITY_COMMAND = 1;
332: protected static final int EPY_PRIORITY_SEPARATOR = 0;
333:
334:
335:
336:
337: public static final String[] EVX_FLOAT_CONTROL_NAME_ARRAY = (
338: "fpiar," +
339: "fpsr," +
340: "fpcr," +
341: "").split (",");
342:
343:
344:
345:
346: public static final String[] EVX_CACHE_NAME_ARRAY = (
347: "nc," +
348: "dc," +
349: "ic," +
350: "bc," +
351: "").split (",");
352:
353:
354:
355:
356: public static final String[] EVX_CONTROL_CODE_MPU_NAME_ARRAY = (
357: "0000 -12346 SFC," +
358: "0001 -12346 DFC," +
359: "0002 --2346 CACR," +
360: "0003 ----46 TC," +
361: "0004 ----46 ITT0," +
362: "0004 ----4- IACR0," +
363: "0005 ----46 ITT1," +
364: "0005 ----4- IACR1," +
365: "0006 ----46 DTT0," +
366: "0006 ----4- DACR0," +
367: "0007 ----46 DTT1," +
368: "0007 ----4- DACR1," +
369: "0008 -----6 BUSCR," +
370: "0800 -12346 USP," +
371: "0801 -12346 VBR," +
372: "0802 --23-- CAAR," +
373: "0803 --234- MSP," +
374: "0804 --2346 ISP," +
375: "0805 ----4- MMUSR," +
376: "0806 ----46 URP," +
377: "0807 ----46 SRP," +
378: "0808 -----6 PCR," +
379: "").split (",");
380: protected static final HashMap<String,Integer> EVX_CONTROL_NAME_TO_MPU_CODE = new HashMap<String,Integer> ();
381: protected static final HashMap<Integer,String> EVX_CONTROL_MPU_CODE_TO_NAME = new HashMap<Integer,String> ();
382: static {
383: for (String codeMPUName : EVX_CONTROL_CODE_MPU_NAME_ARRAY) {
384: int mpuCode = Integer.parseInt (codeMPUName.substring (0, 4), 16);
385: for (int i = 5; i <= 10; i++) {
386: int c = codeMPUName.charAt (i);
387: if (c != '-') {
388: mpuCode |= 1 << 16 << (c & 15);
389: }
390: }
391: String name = codeMPUName.substring (12).toLowerCase ();
392: EVX_CONTROL_NAME_TO_MPU_CODE.put (name, mpuCode);
393: EVX_CONTROL_MPU_CODE_TO_NAME.put (mpuCode, name);
394: }
395: }
396:
397:
398:
399:
400:
401:
402: protected enum ElementType {
403:
404:
405:
406:
407:
408:
409: ETY_UNDEF {
410: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
411: return sb.append ("undefined");
412: }
413: },
414:
415:
416:
417:
418: ETY_VOID {
419: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
420: return sb;
421: }
422: },
423:
424:
425:
426:
427:
428:
429:
430: ETY_VARIABLE_FLOAT {
431: @Override protected void etyEval (ExpressionElement elem, int mode) {
432: elem.exlFloatValue.sete (elem.exlParamX.exlFloatValue);
433: }
434: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
435: return sb.append (elem.exlStringValue);
436: }
437: },
438:
439:
440:
441:
442:
443:
444:
445: ETY_VARIABLE_STRING {
446: @Override protected void etyEval (ExpressionElement elem, int mode) {
447: elem.exlStringValue = elem.exlParamX.exlStringValue;
448: }
449: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
450: return sb.append (elem.exlStringValue);
451: }
452: },
453:
454:
455:
456:
457:
458: ETY_FLOAT {
459: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
460: return sb.append (elem.exlFloatValue.toString ());
461: }
462: },
463:
464:
465:
466:
467: ETY_STRING {
468: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
469: String str = elem.exlStringValue;
470: sb.append ('"');
471: for (int i = 0, l = str.length (); i < l; i++) {
472: char c = str.charAt (i);
473: if (c == '\b') {
474: sb.append ("\\b");
475: } else if (c == '\f') {
476: sb.append ("\\f");
477: } else if (c == '\t') {
478: sb.append ("\\t");
479: } else if (c == '\n') {
480: sb.append ("\\n");
481: } else if (c == '\r') {
482: sb.append ("\\r");
483: } else if (0x00 <= c && c <= 0x1f) {
484: String.format ("\\x%02x", c);
485: } else if (c == '"') {
486: sb.append ("\\\"");
487: } else if (c == '\\') {
488: sb.append ("\\\\");
489: } else {
490: sb.append (c);
491: }
492: }
493: return sb.append ('"');
494: }
495: },
496:
497:
498:
499:
500:
501: ETY_MATH_APERY {
502: @Override protected void etyEval (ExpressionElement elem, int mode) {
503: elem.exlFloatValue.setapery ();
504: }
505: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
506: return sb.append ("Apery");
507: }
508: },
509:
510: ETY_MATH_CATALAN {
511: @Override protected void etyEval (ExpressionElement elem, int mode) {
512: elem.exlFloatValue.setcatalan ();
513: }
514: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
515: return sb.append ("Catalan");
516: }
517: },
518:
519: ETY_MATH_NAPIER {
520: @Override protected void etyEval (ExpressionElement elem, int mode) {
521: elem.exlFloatValue.setnapier ();
522: }
523: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
524: return sb.append ("E");
525: }
526: },
527:
528: ETY_MATH_EULER {
529: @Override protected void etyEval (ExpressionElement elem, int mode) {
530: elem.exlFloatValue.seteuler ();
531: }
532: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
533: return sb.append ("Euler");
534: }
535: },
536:
537: ETY_MATH_PI {
538: @Override protected void etyEval (ExpressionElement elem, int mode) {
539: elem.exlFloatValue.setpi ();
540: }
541: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
542: return sb.append ("Pi");
543: }
544: },
545:
546:
547:
548:
549: ETY_INTEGER_REGISTER {
550: @Override protected void etyEval (ExpressionElement elem, int mode) {
551: elem.exlFloatValue.seti (XEiJ.regRn[elem.exlSubscript]);
552: }
553: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
554: if (elem.exlSubscript <= 7) {
555: return sb.append ('d').append (elem.exlSubscript);
556: } else if (elem.exlSubscript <= 14) {
557: return sb.append ('a').append (elem.exlSubscript - 8);
558: } else {
559: return sb.append ("sp");
560: }
561: }
562: },
563:
564:
565:
566:
567: ETY_FLOATING_POINT_REGISTER {
568: @Override protected void etyEval (ExpressionElement elem, int mode) {
569: elem.exlFloatValue.sete (elem.exlGetFPn (elem.exlSubscript));
570: }
571: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
572: return sb.append ("fp").append (elem.exlSubscript);
573: }
574: },
575:
576:
577:
578: ETY_PC {
579: @Override protected void etyEval (ExpressionElement elem, int mode) {
580: elem.exlFloatValue.seti (elem.exlReadPC ());
581: }
582: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
583: return sb.append (elem.exlStringValue);
584: }
585: },
586: ETY_CCR {
587: @Override protected void etyEval (ExpressionElement elem, int mode) {
588: elem.exlFloatValue.seti (elem.exlReadCCR ());
589: }
590: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
591: return sb.append (elem.exlStringValue);
592: }
593: },
594: ETY_SR {
595: @Override protected void etyEval (ExpressionElement elem, int mode) {
596: elem.exlFloatValue.seti (elem.exlReadSR ());
597: }
598: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
599: return sb.append (elem.exlStringValue);
600: }
601: },
602: ETY_FLOAT_CONTROL_REGISTER {
603: @Override protected void etyEval (ExpressionElement elem, int mode) {
604: elem.exlFloatValue.seti (elem.exlReadFloatControlRegister (elem.exlSubscript));
605: }
606: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
607: return sb.append (elem.exlStringValue);
608: }
609: },
610: ETY_CONTROL_REGISTER {
611: @Override protected void etyEval (ExpressionElement elem, int mode) {
612: elem.exlFloatValue.seti (elem.exlReadControlRegister (elem.exlSubscript));
613: }
614: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
615: return sb.append (elem.exlStringValue);
616: }
617: },
618:
619:
620:
621:
622:
623:
624: ETY_ZERO_REGISTER {
625: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
626: return sb.append (elem.exlStringValue);
627: }
628: },
629:
630:
631:
632: ETY_ZERO_PC {
633: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
634: return sb.append (elem.exlStringValue);
635: }
636: },
637:
638:
639:
640: ETY_OPTIONAL_PC {
641: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
642: return sb.append (elem.exlStringValue);
643: }
644: },
645:
646:
647:
648:
649: ETY_CACHE_SELECTION {
650: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
651: return sb.append (elem.exlStringValue);
652: }
653: },
654:
655:
656:
657:
658:
659:
660:
661:
662:
663: ETY_FUNCTION_ABS {
664: @Override protected int etyPriority () {
665: return EPY_PRIORITY_FUNCTION;
666: }
667: @Override protected void etyEval (ExpressionElement elem, int mode) {
668: elem.exlFloatValue.abs (elem.exlParamX.exlEval (mode).exlFloatValue);
669: }
670: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
671: return elem.exlAppendFunctionTo (sb, "abs");
672: }
673: },
674:
675: ETY_FUNCTION_ACOS {
676: @Override protected int etyPriority () {
677: return EPY_PRIORITY_FUNCTION;
678: }
679: @Override protected void etyEval (ExpressionElement elem, int mode) {
680: elem.exlFloatValue.acos (elem.exlParamX.exlEval (mode).exlFloatValue);
681: }
682: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
683: return elem.exlAppendFunctionTo (sb, "acos");
684: }
685: },
686:
687: ETY_FUNCTION_ACOSH {
688: @Override protected int etyPriority () {
689: return EPY_PRIORITY_FUNCTION;
690: }
691: @Override protected void etyEval (ExpressionElement elem, int mode) {
692: elem.exlFloatValue.acosh (elem.exlParamX.exlEval (mode).exlFloatValue);
693: }
694: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
695: return elem.exlAppendFunctionTo (sb, "acosh");
696: }
697: },
698:
699: ETY_FUNCTION_ACOT {
700: @Override protected int etyPriority () {
701: return EPY_PRIORITY_FUNCTION;
702: }
703: @Override protected void etyEval (ExpressionElement elem, int mode) {
704: elem.exlFloatValue.acot (elem.exlParamX.exlEval (mode).exlFloatValue);
705: }
706: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
707: return elem.exlAppendFunctionTo (sb, "acot");
708: }
709: },
710:
711: ETY_FUNCTION_ACOTH {
712: @Override protected int etyPriority () {
713: return EPY_PRIORITY_FUNCTION;
714: }
715: @Override protected void etyEval (ExpressionElement elem, int mode) {
716: elem.exlFloatValue.acoth (elem.exlParamX.exlEval (mode).exlFloatValue);
717: }
718: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
719: return elem.exlAppendFunctionTo (sb, "acoth");
720: }
721: },
722:
723: ETY_FUNCTION_ACSC {
724: @Override protected int etyPriority () {
725: return EPY_PRIORITY_FUNCTION;
726: }
727: @Override protected void etyEval (ExpressionElement elem, int mode) {
728: elem.exlFloatValue.acsc (elem.exlParamX.exlEval (mode).exlFloatValue);
729: }
730: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
731: return elem.exlAppendFunctionTo (sb, "acsc");
732: }
733: },
734:
735: ETY_FUNCTION_ACSCH {
736: @Override protected int etyPriority () {
737: return EPY_PRIORITY_FUNCTION;
738: }
739: @Override protected void etyEval (ExpressionElement elem, int mode) {
740: elem.exlFloatValue.acsch (elem.exlParamX.exlEval (mode).exlFloatValue);
741: }
742: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
743: return elem.exlAppendFunctionTo (sb, "acsch");
744: }
745: },
746:
747: ETY_FUNCTION_AGI {
748: @Override protected int etyPriority () {
749: return EPY_PRIORITY_FUNCTION;
750: }
751: @Override protected void etyEval (ExpressionElement elem, int mode) {
752: elem.exlFloatValue.agi (elem.exlParamX.exlEval (mode).exlFloatValue,
753: elem.exlParamY.exlEval (mode).exlFloatValue);
754: }
755: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
756: return elem.exlAppendFunctionTo (sb, "agi");
757: }
758: },
759:
760: ETY_FUNCTION_AGM {
761: @Override protected int etyPriority () {
762: return EPY_PRIORITY_FUNCTION;
763: }
764: @Override protected void etyEval (ExpressionElement elem, int mode) {
765: elem.exlFloatValue.agi (elem.exlParamX.exlEval (mode).exlFloatValue,
766: elem.exlParamY.exlEval (mode).exlFloatValue);
767: }
768: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
769: return elem.exlAppendFunctionTo (sb, "agm");
770: }
771: },
772:
773: ETY_FUNCTION_ASC {
774: @Override protected int etyPriority () {
775: return EPY_PRIORITY_FUNCTION;
776: }
777: @Override protected void etyEval (ExpressionElement elem, int mode) {
778: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlStringValue.charAt (0));
779: }
780: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
781: return elem.exlAppendFunctionTo (sb, "asc");
782: }
783: },
784:
785: ETY_FUNCTION_ASEC {
786: @Override protected int etyPriority () {
787: return EPY_PRIORITY_FUNCTION;
788: }
789: @Override protected void etyEval (ExpressionElement elem, int mode) {
790: elem.exlFloatValue.asec (elem.exlParamX.exlEval (mode).exlFloatValue);
791: }
792: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
793: return elem.exlAppendFunctionTo (sb, "asec");
794: }
795: },
796:
797: ETY_FUNCTION_ASECH {
798: @Override protected int etyPriority () {
799: return EPY_PRIORITY_FUNCTION;
800: }
801: @Override protected void etyEval (ExpressionElement elem, int mode) {
802: elem.exlFloatValue.asech (elem.exlParamX.exlEval (mode).exlFloatValue);
803: }
804: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
805: return elem.exlAppendFunctionTo (sb, "asech");
806: }
807: },
808:
809: ETY_FUNCTION_ASIN {
810: @Override protected int etyPriority () {
811: return EPY_PRIORITY_FUNCTION;
812: }
813: @Override protected void etyEval (ExpressionElement elem, int mode) {
814: elem.exlFloatValue.asin (elem.exlParamX.exlEval (mode).exlFloatValue);
815: }
816: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
817: return elem.exlAppendFunctionTo (sb, "asin");
818: }
819: },
820:
821: ETY_FUNCTION_ASINH {
822: @Override protected int etyPriority () {
823: return EPY_PRIORITY_FUNCTION;
824: }
825: @Override protected void etyEval (ExpressionElement elem, int mode) {
826: elem.exlFloatValue.asinh (elem.exlParamX.exlEval (mode).exlFloatValue);
827: }
828: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
829: return elem.exlAppendFunctionTo (sb, "asinh");
830: }
831: },
832:
833: ETY_FUNCTION_ATAN {
834: @Override protected int etyPriority () {
835: return EPY_PRIORITY_FUNCTION;
836: }
837: @Override protected void etyEval (ExpressionElement elem, int mode) {
838: elem.exlFloatValue.atan (elem.exlParamX.exlEval (mode).exlFloatValue);
839: }
840: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
841: return elem.exlAppendFunctionTo (sb, "atan");
842: }
843: },
844:
845: ETY_FUNCTION_ATAN2 {
846: @Override protected int etyPriority () {
847: return EPY_PRIORITY_FUNCTION;
848: }
849: @Override protected void etyEval (ExpressionElement elem, int mode) {
850: elem.exlFloatValue.atan2 (elem.exlParamX.exlEval (mode).exlFloatValue,
851: elem.exlParamY.exlEval (mode).exlFloatValue);
852: }
853: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
854: return elem.exlAppendFunctionTo (sb, "atan2");
855: }
856: },
857:
858: ETY_FUNCTION_ATANH {
859: @Override protected int etyPriority () {
860: return EPY_PRIORITY_FUNCTION;
861: }
862: @Override protected void etyEval (ExpressionElement elem, int mode) {
863: elem.exlFloatValue.atanh (elem.exlParamX.exlEval (mode).exlFloatValue);
864: }
865: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
866: return elem.exlAppendFunctionTo (sb, "atanh");
867: }
868: },
869:
870: ETY_FUNCTION_BIN_DOLLAR {
871: @Override protected int etyPriority () {
872: return EPY_PRIORITY_FUNCTION;
873: }
874: @Override protected void etyEval (ExpressionElement elem, int mode) {
875: long x = elem.exlParamX.exlEval (mode).exlFloatValue.getl ();
876: int m = Math.max (0, 63 - Long.numberOfLeadingZeros (x));
877: char[] w = new char[64];
878: for (int k = m; 0 <= k; k--) {
879: int t = (int) (x >>> k) & 1;
880: w[m - k] = (char) (48 + t);
881: }
882: elem.exlStringValue = String.valueOf (w, 0, m + 1);
883: }
884: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
885: return elem.exlAppendFunctionTo (sb, "bin$");
886: }
887: },
888:
889: ETY_FUNCTION_CBRT {
890: @Override protected int etyPriority () {
891: return EPY_PRIORITY_FUNCTION;
892: }
893: @Override protected void etyEval (ExpressionElement elem, int mode) {
894: elem.exlFloatValue.cbrt (elem.exlParamX.exlEval (mode).exlFloatValue);
895: }
896: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
897: return elem.exlAppendFunctionTo (sb, "cbrt");
898: }
899: },
900:
901: ETY_FUNCTION_CEIL {
902: @Override protected int etyPriority () {
903: return EPY_PRIORITY_FUNCTION;
904: }
905: @Override protected void etyEval (ExpressionElement elem, int mode) {
906: elem.exlFloatValue.ceil (elem.exlParamX.exlEval (mode).exlFloatValue);
907: }
908: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
909: return elem.exlAppendFunctionTo (sb, "ceil");
910: }
911: },
912:
913: ETY_FUNCTION_CHR_DOLLAR {
914: @Override protected int etyPriority () {
915: return EPY_PRIORITY_FUNCTION;
916: }
917: @Override protected void etyEval (ExpressionElement elem, int mode) {
918: elem.exlStringValue = String.valueOf ((char) elem.exlParamX.exlEval (mode).exlFloatValue.getl ());
919: }
920: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
921: return elem.exlAppendFunctionTo (sb, "chr$");
922: }
923: },
924:
925: ETY_FUNCTION_CMP {
926: @Override protected int etyPriority () {
927: return EPY_PRIORITY_FUNCTION;
928: }
929: @Override protected void etyEval (ExpressionElement elem, int mode) {
930: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.cmp (elem.exlParamY.exlEval (mode).exlFloatValue));
931: }
932: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
933: return elem.exlAppendFunctionTo (sb, "cmp");
934: }
935: },
936:
937: ETY_FUNCTION_CMP0 {
938: @Override protected int etyPriority () {
939: return EPY_PRIORITY_FUNCTION;
940: }
941: @Override protected void etyEval (ExpressionElement elem, int mode) {
942: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.cmp0 ());
943: }
944: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
945: return elem.exlAppendFunctionTo (sb, "cmp0");
946: }
947: },
948:
949: ETY_FUNCTION_CMP1 {
950: @Override protected int etyPriority () {
951: return EPY_PRIORITY_FUNCTION;
952: }
953: @Override protected void etyEval (ExpressionElement elem, int mode) {
954: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.cmp1 ());
955: }
956: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
957: return elem.exlAppendFunctionTo (sb, "cmp1");
958: }
959: },
960:
961: ETY_FUNCTION_CMP1ABS {
962: @Override protected int etyPriority () {
963: return EPY_PRIORITY_FUNCTION;
964: }
965: @Override protected void etyEval (ExpressionElement elem, int mode) {
966: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.cmp1abs ());
967: }
968: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
969: return elem.exlAppendFunctionTo (sb, "cmp1abs");
970: }
971: },
972:
973: ETY_FUNCTION_CMPABS {
974: @Override protected int etyPriority () {
975: return EPY_PRIORITY_FUNCTION;
976: }
977: @Override protected void etyEval (ExpressionElement elem, int mode) {
978: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.cmpabs (elem.exlParamY.exlEval (mode).exlFloatValue));
979: }
980: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
981: return elem.exlAppendFunctionTo (sb, "cmpabs");
982: }
983: },
984:
985: ETY_FUNCTION_COS {
986: @Override protected int etyPriority () {
987: return EPY_PRIORITY_FUNCTION;
988: }
989: @Override protected void etyEval (ExpressionElement elem, int mode) {
990: elem.exlFloatValue.cos (elem.exlParamX.exlEval (mode).exlFloatValue);
991: }
992: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
993: return elem.exlAppendFunctionTo (sb, "cos");
994: }
995: },
996:
997: ETY_FUNCTION_COSH {
998: @Override protected int etyPriority () {
999: return EPY_PRIORITY_FUNCTION;
1000: }
1001: @Override protected void etyEval (ExpressionElement elem, int mode) {
1002: elem.exlFloatValue.cosh (elem.exlParamX.exlEval (mode).exlFloatValue);
1003: }
1004: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1005: return elem.exlAppendFunctionTo (sb, "cosh");
1006: }
1007: },
1008:
1009: ETY_FUNCTION_COT {
1010: @Override protected int etyPriority () {
1011: return EPY_PRIORITY_FUNCTION;
1012: }
1013: @Override protected void etyEval (ExpressionElement elem, int mode) {
1014: elem.exlFloatValue.cot (elem.exlParamX.exlEval (mode).exlFloatValue);
1015: }
1016: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1017: return elem.exlAppendFunctionTo (sb, "cot");
1018: }
1019: },
1020:
1021: ETY_FUNCTION_COTH {
1022: @Override protected int etyPriority () {
1023: return EPY_PRIORITY_FUNCTION;
1024: }
1025: @Override protected void etyEval (ExpressionElement elem, int mode) {
1026: elem.exlFloatValue.coth (elem.exlParamX.exlEval (mode).exlFloatValue);
1027: }
1028: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1029: return elem.exlAppendFunctionTo (sb, "coth");
1030: }
1031: },
1032:
1033: ETY_FUNCTION_CSC {
1034: @Override protected int etyPriority () {
1035: return EPY_PRIORITY_FUNCTION;
1036: }
1037: @Override protected void etyEval (ExpressionElement elem, int mode) {
1038: elem.exlFloatValue.csc (elem.exlParamX.exlEval (mode).exlFloatValue);
1039: }
1040: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1041: return elem.exlAppendFunctionTo (sb, "csc");
1042: }
1043: },
1044:
1045: ETY_FUNCTION_CSCH {
1046: @Override protected int etyPriority () {
1047: return EPY_PRIORITY_FUNCTION;
1048: }
1049: @Override protected void etyEval (ExpressionElement elem, int mode) {
1050: elem.exlFloatValue.csch (elem.exlParamX.exlEval (mode).exlFloatValue);
1051: }
1052: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1053: return elem.exlAppendFunctionTo (sb, "csch");
1054: }
1055: },
1056:
1057: ETY_FUNCTION_CUB {
1058: @Override protected int etyPriority () {
1059: return EPY_PRIORITY_FUNCTION;
1060: }
1061: @Override protected void etyEval (ExpressionElement elem, int mode) {
1062: elem.exlFloatValue.cub (elem.exlParamX.exlEval (mode).exlFloatValue);
1063: }
1064: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1065: return elem.exlAppendFunctionTo (sb, "cub");
1066: }
1067: },
1068:
1069: ETY_FUNCTION_DEC {
1070: @Override protected int etyPriority () {
1071: return EPY_PRIORITY_FUNCTION;
1072: }
1073: @Override protected void etyEval (ExpressionElement elem, int mode) {
1074: elem.exlFloatValue.dec (elem.exlParamX.exlEval (mode).exlFloatValue);
1075: }
1076: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1077: return elem.exlAppendFunctionTo (sb, "dec");
1078: }
1079: },
1080:
1081: ETY_FUNCTION_DEG {
1082: @Override protected int etyPriority () {
1083: return EPY_PRIORITY_FUNCTION;
1084: }
1085: @Override protected void etyEval (ExpressionElement elem, int mode) {
1086: elem.exlFloatValue.deg (elem.exlParamX.exlEval (mode).exlFloatValue);
1087: }
1088: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1089: return elem.exlAppendFunctionTo (sb, "deg");
1090: }
1091: },
1092:
1093: ETY_FUNCTION_DIV2 {
1094: @Override protected int etyPriority () {
1095: return EPY_PRIORITY_FUNCTION;
1096: }
1097: @Override protected void etyEval (ExpressionElement elem, int mode) {
1098: elem.exlFloatValue.div2 (elem.exlParamX.exlEval (mode).exlFloatValue);
1099: }
1100: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1101: return elem.exlAppendFunctionTo (sb, "div2");
1102: }
1103: },
1104:
1105: ETY_FUNCTION_DIV3 {
1106: @Override protected int etyPriority () {
1107: return EPY_PRIORITY_FUNCTION;
1108: }
1109: @Override protected void etyEval (ExpressionElement elem, int mode) {
1110: elem.exlFloatValue.div3 (elem.exlParamX.exlEval (mode).exlFloatValue);
1111: }
1112: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1113: return elem.exlAppendFunctionTo (sb, "div3");
1114: }
1115: },
1116:
1117: ETY_FUNCTION_DIVPI {
1118: @Override protected int etyPriority () {
1119: return EPY_PRIORITY_FUNCTION;
1120: }
1121: @Override protected void etyEval (ExpressionElement elem, int mode) {
1122: elem.exlFloatValue.divpi (elem.exlParamX.exlEval (mode).exlFloatValue);
1123: }
1124: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1125: return elem.exlAppendFunctionTo (sb, "divpi");
1126: }
1127: },
1128:
1129: ETY_FUNCTION_DIVRZ {
1130: @Override protected int etyPriority () {
1131: return EPY_PRIORITY_FUNCTION;
1132: }
1133: @Override protected void etyEval (ExpressionElement elem, int mode) {
1134: elem.exlFloatValue.divrz (elem.exlParamX.exlEval (mode).exlFloatValue,
1135: elem.exlParamY.exlEval (mode).exlFloatValue);
1136: }
1137: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1138: return elem.exlAppendFunctionTo (sb, "divrz");
1139: }
1140: },
1141:
1142: ETY_FUNCTION_EXP {
1143: @Override protected int etyPriority () {
1144: return EPY_PRIORITY_FUNCTION;
1145: }
1146: @Override protected void etyEval (ExpressionElement elem, int mode) {
1147: elem.exlFloatValue.exp (elem.exlParamX.exlEval (mode).exlFloatValue);
1148: }
1149: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1150: return elem.exlAppendFunctionTo (sb, "exp");
1151: }
1152: },
1153:
1154: ETY_FUNCTION_EXP10 {
1155: @Override protected int etyPriority () {
1156: return EPY_PRIORITY_FUNCTION;
1157: }
1158: @Override protected void etyEval (ExpressionElement elem, int mode) {
1159: elem.exlFloatValue.exp10 (elem.exlParamX.exlEval (mode).exlFloatValue);
1160: }
1161: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1162: return elem.exlAppendFunctionTo (sb, "exp10");
1163: }
1164: },
1165:
1166: ETY_FUNCTION_EXP2 {
1167: @Override protected int etyPriority () {
1168: return EPY_PRIORITY_FUNCTION;
1169: }
1170: @Override protected void etyEval (ExpressionElement elem, int mode) {
1171: elem.exlFloatValue.exp2 (elem.exlParamX.exlEval (mode).exlFloatValue);
1172: }
1173: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1174: return elem.exlAppendFunctionTo (sb, "exp2");
1175: }
1176: },
1177:
1178: ETY_FUNCTION_EXP2M1 {
1179: @Override protected int etyPriority () {
1180: return EPY_PRIORITY_FUNCTION;
1181: }
1182: @Override protected void etyEval (ExpressionElement elem, int mode) {
1183: elem.exlFloatValue.exp2m1 (elem.exlParamX.exlEval (mode).exlFloatValue);
1184: }
1185: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1186: return elem.exlAppendFunctionTo (sb, "exp2m1");
1187: }
1188: },
1189:
1190: ETY_FUNCTION_EXPM1 {
1191: @Override protected int etyPriority () {
1192: return EPY_PRIORITY_FUNCTION;
1193: }
1194: @Override protected void etyEval (ExpressionElement elem, int mode) {
1195: elem.exlFloatValue.expm1 (elem.exlParamX.exlEval (mode).exlFloatValue);
1196: }
1197: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1198: return elem.exlAppendFunctionTo (sb, "expm1");
1199: }
1200: },
1201:
1202: ETY_FUNCTION_FLOOR {
1203: @Override protected int etyPriority () {
1204: return EPY_PRIORITY_FUNCTION;
1205: }
1206: @Override protected void etyEval (ExpressionElement elem, int mode) {
1207: elem.exlFloatValue.floor (elem.exlParamX.exlEval (mode).exlFloatValue);
1208: }
1209: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1210: return elem.exlAppendFunctionTo (sb, "floor");
1211: }
1212: },
1213:
1214: ETY_FUNCTION_FRAC {
1215: @Override protected int etyPriority () {
1216: return EPY_PRIORITY_FUNCTION;
1217: }
1218: @Override protected void etyEval (ExpressionElement elem, int mode) {
1219: elem.exlFloatValue.frac (elem.exlParamX.exlEval (mode).exlFloatValue);
1220: }
1221: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1222: return elem.exlAppendFunctionTo (sb, "frac");
1223: }
1224: },
1225:
1226: ETY_FUNCTION_GETEXP {
1227: @Override protected int etyPriority () {
1228: return EPY_PRIORITY_FUNCTION;
1229: }
1230: @Override protected void etyEval (ExpressionElement elem, int mode) {
1231: elem.exlFloatValue.getexp (elem.exlParamX.exlEval (mode).exlFloatValue);
1232: }
1233: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1234: return elem.exlAppendFunctionTo (sb, "getexp");
1235: }
1236: },
1237:
1238: ETY_FUNCTION_GETMAN {
1239: @Override protected int etyPriority () {
1240: return EPY_PRIORITY_FUNCTION;
1241: }
1242: @Override protected void etyEval (ExpressionElement elem, int mode) {
1243: elem.exlFloatValue.getman (elem.exlParamX.exlEval (mode).exlFloatValue);
1244: }
1245: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1246: return elem.exlAppendFunctionTo (sb, "getman");
1247: }
1248: },
1249:
1250: ETY_FUNCTION_HEX_DOLLAR {
1251: @Override protected int etyPriority () {
1252: return EPY_PRIORITY_FUNCTION;
1253: }
1254: @Override protected void etyEval (ExpressionElement elem, int mode) {
1255: long x = elem.exlParamX.exlEval (mode).exlFloatValue.getl ();
1256: int m = Math.max (0, 63 - Long.numberOfLeadingZeros (x) >> 2);
1257: char[] w = new char[16];
1258: for (int k = m; 0 <= k; k--) {
1259: int t = (int) (x >>> (k << 2)) & 15;
1260: w[m - k] = (char) ((9 - t >> 4 & 7) + 48 + t);
1261:
1262: }
1263: elem.exlStringValue = String.valueOf (w, 0, m + 1);
1264: }
1265: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1266: return elem.exlAppendFunctionTo (sb, "hex$");
1267: }
1268: },
1269:
1270: ETY_FUNCTION_IEEEREM {
1271: @Override protected int etyPriority () {
1272: return EPY_PRIORITY_FUNCTION;
1273: }
1274: @Override protected void etyEval (ExpressionElement elem, int mode) {
1275: elem.exlFloatValue.ieeerem (elem.exlParamX.exlEval (mode).exlFloatValue,
1276: elem.exlParamY.exlEval (mode).exlFloatValue);
1277: }
1278: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1279: return elem.exlAppendFunctionTo (sb, "ieeerem");
1280: }
1281: },
1282:
1283: ETY_FUNCTION_INC {
1284: @Override protected int etyPriority () {
1285: return EPY_PRIORITY_FUNCTION;
1286: }
1287: @Override protected void etyEval (ExpressionElement elem, int mode) {
1288: elem.exlFloatValue.inc (elem.exlParamX.exlEval (mode).exlFloatValue);
1289: }
1290: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1291: return elem.exlAppendFunctionTo (sb, "inc");
1292: }
1293: },
1294:
1295: ETY_FUNCTION_ISEVEN {
1296: @Override protected int etyPriority () {
1297: return EPY_PRIORITY_FUNCTION;
1298: }
1299: @Override protected void etyEval (ExpressionElement elem, int mode) {
1300: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.iseven () ? 1 : 0);
1301: }
1302: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1303: return elem.exlAppendFunctionTo (sb, "iseven");
1304: }
1305: },
1306:
1307: ETY_FUNCTION_ISINF {
1308: @Override protected int etyPriority () {
1309: return EPY_PRIORITY_FUNCTION;
1310: }
1311: @Override protected void etyEval (ExpressionElement elem, int mode) {
1312: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.isinf () ? 1 : 0);
1313: }
1314: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1315: return elem.exlAppendFunctionTo (sb, "isinf");
1316: }
1317: },
1318:
1319: ETY_FUNCTION_ISINT {
1320: @Override protected int etyPriority () {
1321: return EPY_PRIORITY_FUNCTION;
1322: }
1323: @Override protected void etyEval (ExpressionElement elem, int mode) {
1324: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.isint () ? 1 : 0);
1325: }
1326: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1327: return elem.exlAppendFunctionTo (sb, "isint");
1328: }
1329: },
1330:
1331: ETY_FUNCTION_ISNAN {
1332: @Override protected int etyPriority () {
1333: return EPY_PRIORITY_FUNCTION;
1334: }
1335: @Override protected void etyEval (ExpressionElement elem, int mode) {
1336: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.isnan () ? 1 : 0);
1337: }
1338: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1339: return elem.exlAppendFunctionTo (sb, "isnan");
1340: }
1341: },
1342:
1343: ETY_FUNCTION_ISODD {
1344: @Override protected int etyPriority () {
1345: return EPY_PRIORITY_FUNCTION;
1346: }
1347: @Override protected void etyEval (ExpressionElement elem, int mode) {
1348: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.isodd () ? 1 : 0);
1349: }
1350: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1351: return elem.exlAppendFunctionTo (sb, "isodd");
1352: }
1353: },
1354:
1355: ETY_FUNCTION_ISONE {
1356: @Override protected int etyPriority () {
1357: return EPY_PRIORITY_FUNCTION;
1358: }
1359: @Override protected void etyEval (ExpressionElement elem, int mode) {
1360: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.isone () ? 1 : 0);
1361: }
1362: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1363: return elem.exlAppendFunctionTo (sb, "isone");
1364: }
1365: },
1366:
1367: ETY_FUNCTION_ISZERO {
1368: @Override protected int etyPriority () {
1369: return EPY_PRIORITY_FUNCTION;
1370: }
1371: @Override protected void etyEval (ExpressionElement elem, int mode) {
1372: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.iszero () ? 1 : 0);
1373: }
1374: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1375: return elem.exlAppendFunctionTo (sb, "iszero");
1376: }
1377: },
1378:
1379: ETY_FUNCTION_LGAMMA {
1380: @Override protected int etyPriority () {
1381: return EPY_PRIORITY_FUNCTION;
1382: }
1383: @Override protected void etyEval (ExpressionElement elem, int mode) {
1384: elem.exlFloatValue.lgamma (elem.exlParamX.exlEval (mode).exlFloatValue);
1385: }
1386: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1387: return elem.exlAppendFunctionTo (sb, "lgamma");
1388: }
1389: },
1390:
1391: ETY_FUNCTION_LOG {
1392: @Override protected int etyPriority () {
1393: return EPY_PRIORITY_FUNCTION;
1394: }
1395: @Override protected void etyEval (ExpressionElement elem, int mode) {
1396: elem.exlFloatValue.log (elem.exlParamX.exlEval (mode).exlFloatValue);
1397: }
1398: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1399: return elem.exlAppendFunctionTo (sb, "log");
1400: }
1401: },
1402:
1403: ETY_FUNCTION_LOG10 {
1404: @Override protected int etyPriority () {
1405: return EPY_PRIORITY_FUNCTION;
1406: }
1407: @Override protected void etyEval (ExpressionElement elem, int mode) {
1408: elem.exlFloatValue.log10 (elem.exlParamX.exlEval (mode).exlFloatValue);
1409: }
1410: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1411: return elem.exlAppendFunctionTo (sb, "log10");
1412: }
1413: },
1414:
1415: ETY_FUNCTION_LOG1P {
1416: @Override protected int etyPriority () {
1417: return EPY_PRIORITY_FUNCTION;
1418: }
1419: @Override protected void etyEval (ExpressionElement elem, int mode) {
1420: elem.exlFloatValue.log1p (elem.exlParamX.exlEval (mode).exlFloatValue);
1421: }
1422: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1423: return elem.exlAppendFunctionTo (sb, "log1p");
1424: }
1425: },
1426:
1427: ETY_FUNCTION_LOG2 {
1428: @Override protected int etyPriority () {
1429: return EPY_PRIORITY_FUNCTION;
1430: }
1431: @Override protected void etyEval (ExpressionElement elem, int mode) {
1432: elem.exlFloatValue.log2 (elem.exlParamX.exlEval (mode).exlFloatValue);
1433: }
1434: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1435: return elem.exlAppendFunctionTo (sb, "log2");
1436: }
1437: },
1438:
1439: ETY_FUNCTION_MAX {
1440: @Override protected int etyPriority () {
1441: return EPY_PRIORITY_FUNCTION;
1442: }
1443: @Override protected void etyEval (ExpressionElement elem, int mode) {
1444: elem.exlFloatValue.max (elem.exlParamX.exlEval (mode).exlFloatValue,
1445: elem.exlParamY.exlEval (mode).exlFloatValue);
1446: }
1447: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1448: return elem.exlAppendFunctionTo (sb, "max");
1449: }
1450: },
1451:
1452: ETY_FUNCTION_MIN {
1453: @Override protected int etyPriority () {
1454: return EPY_PRIORITY_FUNCTION;
1455: }
1456: @Override protected void etyEval (ExpressionElement elem, int mode) {
1457: elem.exlFloatValue.min (elem.exlParamX.exlEval (mode).exlFloatValue,
1458: elem.exlParamY.exlEval (mode).exlFloatValue);
1459: }
1460: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1461: return elem.exlAppendFunctionTo (sb, "min");
1462: }
1463: },
1464:
1465: ETY_FUNCTION_MUL2 {
1466: @Override protected int etyPriority () {
1467: return EPY_PRIORITY_FUNCTION;
1468: }
1469: @Override protected void etyEval (ExpressionElement elem, int mode) {
1470: elem.exlFloatValue.mul2 (elem.exlParamX.exlEval (mode).exlFloatValue);
1471: }
1472: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1473: return elem.exlAppendFunctionTo (sb, "mul2");
1474: }
1475: },
1476:
1477: ETY_FUNCTION_MUL3 {
1478: @Override protected int etyPriority () {
1479: return EPY_PRIORITY_FUNCTION;
1480: }
1481: @Override protected void etyEval (ExpressionElement elem, int mode) {
1482: elem.exlFloatValue.mul3 (elem.exlParamX.exlEval (mode).exlFloatValue);
1483: }
1484: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1485: return elem.exlAppendFunctionTo (sb, "mul3");
1486: }
1487: },
1488:
1489: ETY_FUNCTION_MULPI {
1490: @Override protected int etyPriority () {
1491: return EPY_PRIORITY_FUNCTION;
1492: }
1493: @Override protected void etyEval (ExpressionElement elem, int mode) {
1494: elem.exlFloatValue.mulpi (elem.exlParamX.exlEval (mode).exlFloatValue);
1495: }
1496: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1497: return elem.exlAppendFunctionTo (sb, "mulpi");
1498: }
1499: },
1500:
1501: ETY_FUNCTION_OCT_DOLLAR {
1502: @Override protected int etyPriority () {
1503: return EPY_PRIORITY_FUNCTION;
1504: }
1505: @Override protected void etyEval (ExpressionElement elem, int mode) {
1506: long x = elem.exlParamX.exlEval (mode).exlFloatValue.getl ();
1507: int m = Math.max (0, (63 - Long.numberOfLeadingZeros (x)) / 3);
1508: char[] w = new char[22];
1509: for (int k = m; 0 <= k; k--) {
1510: int t = (int) (x >>> k * 3) & 7;
1511: w[m - k] = (char) (48 + t);
1512: }
1513: elem.exlStringValue = String.valueOf (w, 0, m + 1);
1514: }
1515: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1516: return elem.exlAppendFunctionTo (sb, "oct$");
1517: }
1518: },
1519:
1520: ETY_FUNCTION_POW {
1521: @Override protected int etyPriority () {
1522: return EPY_PRIORITY_FUNCTION;
1523: }
1524: @Override protected void etyEval (ExpressionElement elem, int mode) {
1525: elem.exlFloatValue.pow (elem.exlParamX.exlEval (mode).exlFloatValue,
1526: elem.exlParamY.exlEval (mode).exlFloatValue);
1527: }
1528: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1529: return elem.exlAppendFunctionTo (sb, "pow");
1530: }
1531: },
1532:
1533: ETY_FUNCTION_QUO {
1534: @Override protected int etyPriority () {
1535: return EPY_PRIORITY_FUNCTION;
1536: }
1537: @Override protected void etyEval (ExpressionElement elem, int mode) {
1538: elem.exlFloatValue.quo (elem.exlParamX.exlEval (mode).exlFloatValue,
1539: elem.exlParamY.exlEval (mode).exlFloatValue);
1540: }
1541: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1542: return elem.exlAppendFunctionTo (sb, "quo");
1543: }
1544: },
1545:
1546: ETY_FUNCTION_RAD {
1547: @Override protected int etyPriority () {
1548: return EPY_PRIORITY_FUNCTION;
1549: }
1550: @Override protected void etyEval (ExpressionElement elem, int mode) {
1551: elem.exlFloatValue.rad (elem.exlParamX.exlEval (mode).exlFloatValue);
1552: }
1553: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1554: return elem.exlAppendFunctionTo (sb, "rad");
1555: }
1556: },
1557:
1558: ETY_FUNCTION_RANDOM {
1559: @Override protected int etyPriority () {
1560: return EPY_PRIORITY_FUNCTION;
1561: }
1562: @Override protected void etyEval (ExpressionElement elem, int mode) {
1563: elem.exlFloatValue.random ();
1564: }
1565: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1566: return elem.exlAppendFunctionTo (sb, "random");
1567: }
1568: },
1569:
1570: ETY_FUNCTION_RCP {
1571: @Override protected int etyPriority () {
1572: return EPY_PRIORITY_FUNCTION;
1573: }
1574: @Override protected void etyEval (ExpressionElement elem, int mode) {
1575: elem.exlFloatValue.rcp (elem.exlParamX.exlEval (mode).exlFloatValue);
1576: }
1577: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1578: return elem.exlAppendFunctionTo (sb, "rcp");
1579: }
1580: },
1581:
1582: ETY_FUNCTION_RINT {
1583: @Override protected int etyPriority () {
1584: return EPY_PRIORITY_FUNCTION;
1585: }
1586: @Override protected void etyEval (ExpressionElement elem, int mode) {
1587: elem.exlFloatValue.rint (elem.exlParamX.exlEval (mode).exlFloatValue);
1588: }
1589: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1590: return elem.exlAppendFunctionTo (sb, "rint");
1591: }
1592: },
1593:
1594: ETY_FUNCTION_RMODE {
1595: @Override protected int etyPriority () {
1596: return EPY_PRIORITY_FUNCTION;
1597: }
1598: @Override protected void etyEval (ExpressionElement elem, int mode) {
1599: elem.exlSetRoundingMode (elem.exlParamX.exlEval (mode).exlFloatValue.geti ());
1600: elem.exlFloatValue.setnan ();
1601: }
1602: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1603: return elem.exlAppendFunctionTo (sb, "rmode");
1604: }
1605: },
1606:
1607: ETY_FUNCTION_ROUND {
1608: @Override protected int etyPriority () {
1609: return EPY_PRIORITY_FUNCTION;
1610: }
1611: @Override protected void etyEval (ExpressionElement elem, int mode) {
1612: elem.exlFloatValue.round (elem.exlParamX.exlEval (mode).exlFloatValue);
1613: }
1614: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1615: return elem.exlAppendFunctionTo (sb, "round");
1616: }
1617: },
1618:
1619: ETY_FUNCTION_RPREC {
1620: @Override protected int etyPriority () {
1621: return EPY_PRIORITY_FUNCTION;
1622: }
1623: @Override protected void etyEval (ExpressionElement elem, int mode) {
1624: elem.exlSetRoundingPrec (elem.exlParamX.exlEval (mode).exlFloatValue.geti ());
1625: elem.exlFloatValue.setnan ();
1626: }
1627: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1628: return elem.exlAppendFunctionTo (sb, "rprec");
1629: }
1630: },
1631:
1632: ETY_FUNCTION_SEC {
1633: @Override protected int etyPriority () {
1634: return EPY_PRIORITY_FUNCTION;
1635: }
1636: @Override protected void etyEval (ExpressionElement elem, int mode) {
1637: elem.exlFloatValue.sec (elem.exlParamX.exlEval (mode).exlFloatValue);
1638: }
1639: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1640: return elem.exlAppendFunctionTo (sb, "sec");
1641: }
1642: },
1643:
1644: ETY_FUNCTION_SECH {
1645: @Override protected int etyPriority () {
1646: return EPY_PRIORITY_FUNCTION;
1647: }
1648: @Override protected void etyEval (ExpressionElement elem, int mode) {
1649: elem.exlFloatValue.sech (elem.exlParamX.exlEval (mode).exlFloatValue);
1650: }
1651: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1652: return elem.exlAppendFunctionTo (sb, "sech");
1653: }
1654: },
1655:
1656: ETY_FUNCTION_SGN {
1657: @Override protected int etyPriority () {
1658: return EPY_PRIORITY_FUNCTION;
1659: }
1660: @Override protected void etyEval (ExpressionElement elem, int mode) {
1661: elem.exlFloatValue.sgn (elem.exlParamX.exlEval (mode).exlFloatValue);
1662: }
1663: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1664: return elem.exlAppendFunctionTo (sb, "sgn");
1665: }
1666: },
1667:
1668: ETY_FUNCTION_SIN {
1669: @Override protected int etyPriority () {
1670: return EPY_PRIORITY_FUNCTION;
1671: }
1672: @Override protected void etyEval (ExpressionElement elem, int mode) {
1673: elem.exlFloatValue.sin (elem.exlParamX.exlEval (mode).exlFloatValue);
1674: }
1675: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1676: return elem.exlAppendFunctionTo (sb, "sin");
1677: }
1678: },
1679:
1680: ETY_FUNCTION_SINH {
1681: @Override protected int etyPriority () {
1682: return EPY_PRIORITY_FUNCTION;
1683: }
1684: @Override protected void etyEval (ExpressionElement elem, int mode) {
1685: elem.exlFloatValue.sinh (elem.exlParamX.exlEval (mode).exlFloatValue);
1686: }
1687: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1688: return elem.exlAppendFunctionTo (sb, "sinh");
1689: }
1690: },
1691:
1692: ETY_FUNCTION_SQRT {
1693: @Override protected int etyPriority () {
1694: return EPY_PRIORITY_FUNCTION;
1695: }
1696: @Override protected void etyEval (ExpressionElement elem, int mode) {
1697: elem.exlFloatValue.sqrt (elem.exlParamX.exlEval (mode).exlFloatValue);
1698: }
1699: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1700: return elem.exlAppendFunctionTo (sb, "sqrt");
1701: }
1702: },
1703:
1704: ETY_FUNCTION_SQU {
1705: @Override protected int etyPriority () {
1706: return EPY_PRIORITY_FUNCTION;
1707: }
1708: @Override protected void etyEval (ExpressionElement elem, int mode) {
1709: elem.exlFloatValue.squ (elem.exlParamX.exlEval (mode).exlFloatValue);
1710: }
1711: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1712: return elem.exlAppendFunctionTo (sb, "squ");
1713: }
1714: },
1715:
1716: ETY_FUNCTION_STR_DOLLAR {
1717: @Override protected int etyPriority () {
1718: return EPY_PRIORITY_FUNCTION;
1719: }
1720: @Override protected void etyEval (ExpressionElement elem, int mode) {
1721: elem.exlStringValue = elem.exlParamX.exlEval (mode).exlFloatValue.toString ();
1722: }
1723: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1724: return elem.exlAppendFunctionTo (sb, "str$");
1725: }
1726: },
1727:
1728: ETY_FUNCTION_TAN {
1729: @Override protected int etyPriority () {
1730: return EPY_PRIORITY_FUNCTION;
1731: }
1732: @Override protected void etyEval (ExpressionElement elem, int mode) {
1733: elem.exlFloatValue.tan (elem.exlParamX.exlEval (mode).exlFloatValue);
1734: }
1735: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1736: return elem.exlAppendFunctionTo (sb, "tan");
1737: }
1738: },
1739:
1740: ETY_FUNCTION_TANH {
1741: @Override protected int etyPriority () {
1742: return EPY_PRIORITY_FUNCTION;
1743: }
1744: @Override protected void etyEval (ExpressionElement elem, int mode) {
1745: elem.exlFloatValue.tanh (elem.exlParamX.exlEval (mode).exlFloatValue);
1746: }
1747: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1748: return elem.exlAppendFunctionTo (sb, "tanh");
1749: }
1750: },
1751:
1752: ETY_FUNCTION_TGAMMA {
1753: @Override protected int etyPriority () {
1754: return EPY_PRIORITY_FUNCTION;
1755: }
1756: @Override protected void etyEval (ExpressionElement elem, int mode) {
1757: elem.exlFloatValue.tgamma (elem.exlParamX.exlEval (mode).exlFloatValue);
1758: }
1759: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1760: return elem.exlAppendFunctionTo (sb, "tgamma");
1761: }
1762: },
1763:
1764: ETY_FUNCTION_TRUNC {
1765: @Override protected int etyPriority () {
1766: return EPY_PRIORITY_FUNCTION;
1767: }
1768: @Override protected void etyEval (ExpressionElement elem, int mode) {
1769: elem.exlFloatValue.trunc (elem.exlParamX.exlEval (mode).exlFloatValue);
1770: }
1771: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1772: return elem.exlAppendFunctionTo (sb, "trunc");
1773: }
1774: },
1775:
1776: ETY_FUNCTION_ULP {
1777: @Override protected int etyPriority () {
1778: return EPY_PRIORITY_FUNCTION;
1779: }
1780: @Override protected void etyEval (ExpressionElement elem, int mode) {
1781: elem.exlFloatValue.ulp (elem.exlParamX.exlEval (mode).exlFloatValue);
1782: }
1783: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1784: return elem.exlAppendFunctionTo (sb, "ulp");
1785: }
1786: },
1787:
1788: ETY_FUNCTION_VAL {
1789: @Override protected int etyPriority () {
1790: return EPY_PRIORITY_FUNCTION;
1791: }
1792: @Override protected void etyEval (ExpressionElement elem, int mode) {
1793: elem.exlFloatValue.parse (elem.exlParamX.exlEval (mode).exlStringValue);
1794: }
1795: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1796: return elem.exlAppendFunctionTo (sb, "val");
1797: }
1798: },
1799:
1800:
1801:
1802: ETY_SQUARE_BRACKET {
1803: @Override protected int etyPriority () {
1804: return EPY_PRIORITY_FUNCTION;
1805: }
1806: @Override protected void etyEval (ExpressionElement elem, int mode) {
1807: int a, f;
1808: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
1809: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
1810: f = elem.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
1811: } else {
1812: a = elem.exlParamX.exlEval (mode).exlFloatValue.geti ();
1813: f = -1;
1814: }
1815: elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f));
1816: }
1817: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1818: return elem.exlParamX.exlAppendTo (sb.append ('[')).append (']');
1819: }
1820: },
1821:
1822:
1823: ETY_OPERATOR_AT {
1824: @Override protected int etyPriority () {
1825: return EPY_PRIORITY_AT;
1826: }
1827: @Override protected void etyEval (ExpressionElement elem, int mode) {
1828:
1829: elem.exlFloatValue.sete (elem.exlParamX.exlEval (mode).exlFloatValue);
1830: elem.exlParamY.exlEval (mode);
1831: }
1832: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
1833: return elem.exlAppendBinaryOperatorTo (sb, "@");
1834: }
1835: },
1836:
1837:
1838: ETY_OPERATOR_POSTINCREMENT {
1839: @Override protected int etyPriority () {
1840: return EPY_PRIORITY_POSTFIX;
1841: }
1842: @Override protected void etyEval (ExpressionElement elem, int mode) {
1843: switch (elem.exlParamX.exlType) {
1844: case ETY_VARIABLE_FLOAT:
1845: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue);
1846: elem.exlParamX.exlParamX.exlFloatValue.inc ();
1847: break;
1848: case ETY_INTEGER_REGISTER:
1849: {
1850: int n = elem.exlParamX.exlSubscript;
1851: int x = elem.exlReadRegLong (n);
1852: elem.exlFloatValue.seti (x);
1853: elem.exlWriteRegLong (n, x + 1);
1854: }
1855: break;
1856: case ETY_FLOATING_POINT_REGISTER:
1857: {
1858: int n = elem.exlParamX.exlSubscript;
1859: EFP x = elem.exlGetFPn (n);
1860: elem.exlFloatValue.sete (x);
1861: x.inc ();
1862: }
1863: break;
1864: case ETY_PC:
1865: {
1866: int x = elem.exlReadPC ();
1867: elem.exlFloatValue.seti (x);
1868: elem.exlWritePC (x + 1);
1869: }
1870: break;
1871: case ETY_CCR:
1872: {
1873: int x = elem.exlReadCCR ();
1874: elem.exlFloatValue.seti (x);
1875: elem.exlWriteCCR (x + 1);
1876: }
1877: break;
1878: case ETY_SR:
1879: {
1880: int x = elem.exlReadSR ();
1881: elem.exlFloatValue.seti (x);
1882: elem.exlWriteSR (x + 1);
1883: }
1884: break;
1885: case ETY_FLOAT_CONTROL_REGISTER:
1886: {
1887: int n = elem.exlParamX.exlSubscript;
1888: int x = elem.exlReadFloatControlRegister (n);
1889: elem.exlFloatValue.seti (x);
1890: elem.exlWriteFloatControlRegister (n, x + 1);
1891: }
1892: break;
1893: case ETY_CONTROL_REGISTER:
1894: {
1895: int n = elem.exlParamX.exlSubscript;
1896: int x = elem.exlReadControlRegister (n);
1897: elem.exlFloatValue.seti (x);
1898: elem.exlWriteControlRegister (n, x + 1);
1899: }
1900: break;
1901: case ETY_SQUARE_BRACKET:
1902: {
1903: int a, f;
1904: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
1905: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
1906: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
1907: } else {
1908: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
1909: f = -1;
1910: }
1911: int x = MC68060.mmuPeekByteSign (a, f);
1912: elem.exlFloatValue.seti (x);
1913: MC68060.mmuPokeByte (a, x + 1, f);
1914: }
1915: break;
1916: case ETY_OPERATOR_SIZE_BYTE:
1917: switch (elem.exlParamX.exlParamX.exlType) {
1918: case ETY_INTEGER_REGISTER:
1919: {
1920: int n = elem.exlParamX.exlParamX.exlSubscript;
1921: int x = elem.exlReadRegByte (n);
1922: elem.exlFloatValue.seti (x);
1923: elem.exlWriteRegByte (n, x + 1);
1924: }
1925: break;
1926: case ETY_SQUARE_BRACKET:
1927: {
1928: int a, f;
1929: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
1930: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
1931: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
1932: } else {
1933: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
1934: f = -1;
1935: }
1936: int x = MC68060.mmuPeekByteSign (a, f);
1937: elem.exlFloatValue.seti (x);
1938: MC68060.mmuPokeByte (a, x + 1, f);
1939: }
1940: break;
1941: default:
1942: elem.exlFloatValue.setnan ();
1943: }
1944: break;
1945: case ETY_OPERATOR_SIZE_WORD:
1946: switch (elem.exlParamX.exlParamX.exlType) {
1947: case ETY_INTEGER_REGISTER:
1948: {
1949: int n = elem.exlParamX.exlParamX.exlSubscript;
1950: int x = elem.exlReadRegWord (n);
1951: elem.exlFloatValue.seti (x);
1952: elem.exlWriteRegWord (n, x + 1);
1953: }
1954: break;
1955: case ETY_SQUARE_BRACKET:
1956: {
1957: int a, f;
1958: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
1959: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
1960: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
1961: } else {
1962: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
1963: f = -1;
1964: }
1965: int x = MC68060.mmuPeekWordSign (a, f);
1966: elem.exlFloatValue.seti (x);
1967: MC68060.mmuPokeWord (a, x + 1, f);
1968: }
1969: break;
1970: default:
1971: elem.exlFloatValue.setnan ();
1972: }
1973: break;
1974: case ETY_OPERATOR_SIZE_LONG:
1975: switch (elem.exlParamX.exlParamX.exlType) {
1976: case ETY_INTEGER_REGISTER:
1977: {
1978: int n = elem.exlParamX.exlParamX.exlSubscript;
1979: int x = elem.exlReadRegLong (n);
1980: elem.exlFloatValue.seti (x);
1981: elem.exlWriteRegLong (n, x + 1);
1982: }
1983: break;
1984: case ETY_SQUARE_BRACKET:
1985: {
1986: int a, f;
1987: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
1988: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
1989: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
1990: } else {
1991: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
1992: f = -1;
1993: }
1994: int x = MC68060.mmuPeekLong (a, f);
1995: elem.exlFloatValue.seti (x);
1996: MC68060.mmuPokeLong (a, x + 1, f);
1997: }
1998: break;
1999: default:
2000: elem.exlFloatValue.setnan ();
2001: }
2002: break;
2003: case ETY_OPERATOR_SIZE_QUAD:
2004: switch (elem.exlParamX.exlParamX.exlType) {
2005: case ETY_SQUARE_BRACKET:
2006: {
2007: int a, f;
2008: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2009: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2010: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2011: } else {
2012: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2013: f = -1;
2014: }
2015: long x = MC68060.mmuPeekQuad (a, f);
2016: elem.exlFloatValue.setl (x);
2017: MC68060.mmuPokeQuad (a, x + 1L, f);
2018: }
2019: break;
2020: default:
2021: elem.exlFloatValue.setnan ();
2022: }
2023: break;
2024: case ETY_OPERATOR_SIZE_SINGLE:
2025: switch (elem.exlParamX.exlParamX.exlType) {
2026: case ETY_INTEGER_REGISTER:
2027: {
2028: int n = elem.exlParamX.exlParamX.exlSubscript;
2029: float x = Float.intBitsToFloat (elem.exlReadRegLong (n));
2030: elem.exlFloatValue.setf (x);
2031: elem.exlWriteRegLong (n, Float.floatToIntBits (x + 1.0F));
2032: }
2033: break;
2034: case ETY_SQUARE_BRACKET:
2035: {
2036: int a, f;
2037: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2038: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2039: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2040: } else {
2041: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2042: f = -1;
2043: }
2044: float x = Float.intBitsToFloat (MC68060.mmuPeekLong (a, f));
2045: elem.exlFloatValue.setf (x);
2046: MC68060.mmuPokeLong (a, Float.floatToIntBits (x + 1.0F), f);
2047: }
2048: break;
2049: default:
2050: elem.exlFloatValue.setnan ();
2051: }
2052: break;
2053: case ETY_OPERATOR_SIZE_DOUBLE:
2054: switch (elem.exlParamX.exlParamX.exlType) {
2055: case ETY_SQUARE_BRACKET:
2056: {
2057: int a, f;
2058: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2059: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2060: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2061: } else {
2062: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2063: f = -1;
2064: }
2065: double x = Double.longBitsToDouble (MC68060.mmuPeekQuad (a, f));
2066: elem.exlFloatValue.setd (x);
2067: MC68060.mmuPokeQuad (a, Double.doubleToLongBits (x + 1.0), f);
2068: }
2069: break;
2070: default:
2071: elem.exlFloatValue.setnan ();
2072: }
2073: break;
2074: case ETY_OPERATOR_SIZE_EXTENDED:
2075: switch (elem.exlParamX.exlParamX.exlType) {
2076: case ETY_SQUARE_BRACKET:
2077: {
2078: int a, f;
2079: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2080: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2081: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2082: } else {
2083: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2084: f = -1;
2085: }
2086: byte[] b = new byte[12];
2087: MC68060.mmuPeekExtended (a, b, f);
2088: EFP x = XEiJ.fpuBox.new EFP ();
2089: elem.exlFloatValue.sete (x.setx012 (b, 0));
2090: x.inc ().getx012 (b, 0);
2091: MC68060.mmuPokeExtended (a, b, f);
2092: }
2093: break;
2094: default:
2095: elem.exlFloatValue.setnan ();
2096: }
2097: break;
2098: case ETY_OPERATOR_SIZE_TRIPLE:
2099: switch (elem.exlParamX.exlParamX.exlType) {
2100: case ETY_SQUARE_BRACKET:
2101: {
2102: int a, f;
2103: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2104: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2105: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2106: } else {
2107: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2108: f = -1;
2109: }
2110: byte[] b = new byte[12];
2111: MC68060.mmuPeekExtended (a, b, f);
2112: EFP x = XEiJ.fpuBox.new EFP ();
2113: elem.exlFloatValue.sete (x.sety012 (b, 0));
2114: x.inc ().gety012 (b, 0);
2115: MC68060.mmuPokeExtended (a, b, f);
2116: }
2117: break;
2118: default:
2119: elem.exlFloatValue.setnan ();
2120: }
2121: break;
2122: case ETY_OPERATOR_SIZE_PACKED:
2123: switch (elem.exlParamX.exlParamX.exlType) {
2124: case ETY_SQUARE_BRACKET:
2125: {
2126: int a, f;
2127: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2128: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2129: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2130: } else {
2131: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2132: f = -1;
2133: }
2134: byte[] b = new byte[12];
2135: MC68060.mmuPeekExtended (a, b, f);
2136: EFP x = XEiJ.fpuBox.new EFP ();
2137: elem.exlFloatValue.sete (x.setp012 (b, 0));
2138: x.inc ().getp012 (b, 0);
2139: MC68060.mmuPokeExtended (a, b, f);
2140: }
2141: break;
2142: default:
2143: elem.exlFloatValue.setnan ();
2144: }
2145: break;
2146: default:
2147: elem.exlFloatValue.setnan ();
2148: }
2149: }
2150: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
2151: return elem.exlAppendPostfixOperatorTo (sb, "++");
2152: }
2153: },
2154:
2155: ETY_OPERATOR_POSTDECREMENT {
2156: @Override protected int etyPriority () {
2157: return EPY_PRIORITY_POSTFIX;
2158: }
2159: @Override protected void etyEval (ExpressionElement elem, int mode) {
2160: switch (elem.exlParamX.exlType) {
2161: case ETY_VARIABLE_FLOAT:
2162: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue);
2163: elem.exlParamX.exlParamX.exlFloatValue.dec ();
2164: break;
2165: case ETY_INTEGER_REGISTER:
2166: {
2167: int n = elem.exlParamX.exlSubscript;
2168: int x = elem.exlReadRegLong (n);
2169: elem.exlFloatValue.seti (x);
2170: elem.exlWriteRegLong (n, x - 1);
2171: }
2172: break;
2173: case ETY_FLOATING_POINT_REGISTER:
2174: {
2175: int n = elem.exlParamX.exlSubscript;
2176: EFP x = elem.exlGetFPn (n);
2177: elem.exlFloatValue.sete (x);
2178: x.dec ();
2179: }
2180: break;
2181: case ETY_PC:
2182: {
2183: int x = elem.exlReadPC ();
2184: elem.exlFloatValue.seti (x);
2185: elem.exlWritePC (x - 1);
2186: }
2187: break;
2188: case ETY_CCR:
2189: {
2190: int x = elem.exlReadCCR ();
2191: elem.exlFloatValue.seti (x);
2192: elem.exlWriteCCR (x - 1);
2193: }
2194: break;
2195: case ETY_SR:
2196: {
2197: int x = elem.exlReadSR ();
2198: elem.exlFloatValue.seti (x);
2199: elem.exlWriteSR (x - 1);
2200: }
2201: break;
2202: case ETY_FLOAT_CONTROL_REGISTER:
2203: {
2204: int n = elem.exlParamX.exlSubscript;
2205: int x = elem.exlReadFloatControlRegister (n);
2206: elem.exlFloatValue.seti (x);
2207: elem.exlWriteFloatControlRegister (n, x - 1);
2208: }
2209: break;
2210: case ETY_CONTROL_REGISTER:
2211: {
2212: int n = elem.exlParamX.exlSubscript;
2213: int x = elem.exlReadControlRegister (n);
2214: elem.exlFloatValue.seti (x);
2215: elem.exlWriteControlRegister (n, x - 1);
2216: }
2217: break;
2218: case ETY_SQUARE_BRACKET:
2219: {
2220: int a, f;
2221: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2222: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2223: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2224: } else {
2225: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2226: f = -1;
2227: }
2228: int x = MC68060.mmuPeekByteSign (a, f);
2229: elem.exlFloatValue.seti (x);
2230: MC68060.mmuPokeByte (a, x - 1, f);
2231: }
2232: break;
2233: case ETY_OPERATOR_SIZE_BYTE:
2234: switch (elem.exlParamX.exlParamX.exlType) {
2235: case ETY_INTEGER_REGISTER:
2236: {
2237: int n = elem.exlParamX.exlParamX.exlSubscript;
2238: int x = elem.exlReadRegByte (n);
2239: elem.exlFloatValue.seti (x);
2240: elem.exlWriteRegByte (n, x - 1);
2241: }
2242: break;
2243: case ETY_SQUARE_BRACKET:
2244: {
2245: int a, f;
2246: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2247: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2248: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2249: } else {
2250: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2251: f = -1;
2252: }
2253: int x = MC68060.mmuPeekByteSign (a, f);
2254: elem.exlFloatValue.seti (x);
2255: MC68060.mmuPokeByte (a, x - 1, f);
2256: }
2257: break;
2258: default:
2259: elem.exlFloatValue.setnan ();
2260: }
2261: break;
2262: case ETY_OPERATOR_SIZE_WORD:
2263: switch (elem.exlParamX.exlParamX.exlType) {
2264: case ETY_INTEGER_REGISTER:
2265: {
2266: int n = elem.exlParamX.exlParamX.exlSubscript;
2267: int x = elem.exlReadRegWord (n);
2268: elem.exlFloatValue.seti (x);
2269: elem.exlWriteRegWord (n, x - 1);
2270: }
2271: break;
2272: case ETY_SQUARE_BRACKET:
2273: {
2274: int a, f;
2275: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2276: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2277: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2278: } else {
2279: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2280: f = -1;
2281: }
2282: int x = MC68060.mmuPeekWordSign (a, f);
2283: elem.exlFloatValue.seti (x);
2284: MC68060.mmuPokeWord (a, x - 1, f);
2285: }
2286: break;
2287: default:
2288: elem.exlFloatValue.setnan ();
2289: }
2290: break;
2291: case ETY_OPERATOR_SIZE_LONG:
2292: switch (elem.exlParamX.exlParamX.exlType) {
2293: case ETY_INTEGER_REGISTER:
2294: {
2295: int n = elem.exlParamX.exlParamX.exlSubscript;
2296: int x = elem.exlReadRegLong (n);
2297: elem.exlFloatValue.seti (x);
2298: elem.exlWriteRegLong (n, x - 1);
2299: }
2300: break;
2301: case ETY_SQUARE_BRACKET:
2302: {
2303: int a, f;
2304: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2305: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2306: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2307: } else {
2308: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2309: f = -1;
2310: }
2311: int x = MC68060.mmuPeekLong (a, f);
2312: elem.exlFloatValue.seti (x);
2313: MC68060.mmuPokeLong (a, x - 1, f);
2314: }
2315: break;
2316: default:
2317: elem.exlFloatValue.setnan ();
2318: }
2319: break;
2320: case ETY_OPERATOR_SIZE_QUAD:
2321: switch (elem.exlParamX.exlParamX.exlType) {
2322: case ETY_SQUARE_BRACKET:
2323: {
2324: int a, f;
2325: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2326: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2327: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2328: } else {
2329: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2330: f = -1;
2331: }
2332: long x = MC68060.mmuPeekQuad (a, f);
2333: elem.exlFloatValue.setl (x);
2334: MC68060.mmuPokeQuad (a, x - 1L, f);
2335: }
2336: break;
2337: default:
2338: elem.exlFloatValue.setnan ();
2339: }
2340: break;
2341: case ETY_OPERATOR_SIZE_SINGLE:
2342: switch (elem.exlParamX.exlParamX.exlType) {
2343: case ETY_INTEGER_REGISTER:
2344: {
2345: int n = elem.exlParamX.exlParamX.exlSubscript;
2346: float x = Float.intBitsToFloat (elem.exlReadRegLong (n));
2347: elem.exlFloatValue.setf (x);
2348: elem.exlWriteRegLong (n, Float.floatToIntBits (x - 1.0F));
2349: }
2350: break;
2351: case ETY_SQUARE_BRACKET:
2352: {
2353: int a, f;
2354: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2355: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2356: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2357: } else {
2358: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2359: f = -1;
2360: }
2361: float x = Float.intBitsToFloat (MC68060.mmuPeekLong (a, f));
2362: elem.exlFloatValue.setf (x);
2363: MC68060.mmuPokeLong (a, Float.floatToIntBits (x - 1.0F), f);
2364: }
2365: break;
2366: default:
2367: elem.exlFloatValue.setnan ();
2368: }
2369: break;
2370: case ETY_OPERATOR_SIZE_DOUBLE:
2371: switch (elem.exlParamX.exlParamX.exlType) {
2372: case ETY_SQUARE_BRACKET:
2373: {
2374: int a, f;
2375: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2376: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2377: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2378: } else {
2379: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2380: f = -1;
2381: }
2382: double x = Double.longBitsToDouble (MC68060.mmuPeekQuad (a, f));
2383: elem.exlFloatValue.setd (x);
2384: MC68060.mmuPokeQuad (a, Double.doubleToLongBits (x - 1.0), f);
2385: }
2386: break;
2387: default:
2388: elem.exlFloatValue.setnan ();
2389: }
2390: break;
2391: case ETY_OPERATOR_SIZE_EXTENDED:
2392: switch (elem.exlParamX.exlParamX.exlType) {
2393: case ETY_SQUARE_BRACKET:
2394: {
2395: int a, f;
2396: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2397: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2398: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2399: } else {
2400: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2401: f = -1;
2402: }
2403: byte[] b = new byte[12];
2404: MC68060.mmuPeekExtended (a, b, f);
2405: EFP x = XEiJ.fpuBox.new EFP ();
2406: elem.exlFloatValue.sete (x.setx012 (b, 0));
2407: x.dec ().getx012 (b, 0);
2408: MC68060.mmuPokeExtended (a, b, f);
2409: }
2410: break;
2411: default:
2412: elem.exlFloatValue.setnan ();
2413: }
2414: break;
2415: case ETY_OPERATOR_SIZE_TRIPLE:
2416: switch (elem.exlParamX.exlParamX.exlType) {
2417: case ETY_SQUARE_BRACKET:
2418: {
2419: int a, f;
2420: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2421: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2422: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2423: } else {
2424: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2425: f = -1;
2426: }
2427: byte[] b = new byte[12];
2428: MC68060.mmuPeekExtended (a, b, f);
2429: EFP x = XEiJ.fpuBox.new EFP ();
2430: elem.exlFloatValue.sete (x.sety012 (b, 0));
2431: x.dec ().gety012 (b, 0);
2432: MC68060.mmuPokeExtended (a, b, f);
2433: }
2434: break;
2435: default:
2436: elem.exlFloatValue.setnan ();
2437: }
2438: break;
2439: case ETY_OPERATOR_SIZE_PACKED:
2440: switch (elem.exlParamX.exlParamX.exlType) {
2441: case ETY_SQUARE_BRACKET:
2442: {
2443: int a, f;
2444: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2445: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2446: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2447: } else {
2448: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2449: f = -1;
2450: }
2451: byte[] b = new byte[12];
2452: MC68060.mmuPeekExtended (a, b, f);
2453: EFP x = XEiJ.fpuBox.new EFP ();
2454: elem.exlFloatValue.sete (x.setp012 (b, 0));
2455: x.dec ().getp012 (b, 0);
2456: MC68060.mmuPokeExtended (a, b, f);
2457: }
2458: break;
2459: default:
2460: elem.exlFloatValue.setnan ();
2461: }
2462: break;
2463: default:
2464: elem.exlFloatValue.setnan ();
2465: }
2466: }
2467: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
2468: return elem.exlAppendPostfixOperatorTo (sb, "--");
2469: }
2470: },
2471:
2472: ETY_OPERATOR_SIZE_BYTE {
2473: @Override protected int etyPriority () {
2474: return EPY_PRIORITY_POSTFIX;
2475: }
2476: @Override protected void etyEval (ExpressionElement elem, int mode) {
2477: switch (elem.exlParamX.exlType) {
2478: case ETY_SQUARE_BRACKET:
2479: {
2480: int a, f;
2481: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2482: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2483: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2484: } else {
2485: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2486: f = -1;
2487: }
2488: elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f));
2489: }
2490: break;
2491: default:
2492: elem.exlFloatValue.seti ((byte) elem.exlParamX.exlEval (mode).exlFloatValue.geti ());
2493: }
2494: }
2495: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
2496: return elem.exlAppendPostfixOperatorTo (sb, ".b");
2497: }
2498: },
2499:
2500: ETY_OPERATOR_SIZE_WORD {
2501: @Override protected int etyPriority () {
2502: return EPY_PRIORITY_POSTFIX;
2503: }
2504: @Override protected void etyEval (ExpressionElement elem, int mode) {
2505: switch (elem.exlParamX.exlType) {
2506: case ETY_SQUARE_BRACKET:
2507: {
2508: int a, f;
2509: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2510: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2511: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2512: } else {
2513: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2514: f = -1;
2515: }
2516: elem.exlFloatValue.seti (MC68060.mmuPeekWordSign (a, f));
2517: }
2518: break;
2519: default:
2520: elem.exlFloatValue.seti ((short) elem.exlParamX.exlEval (mode).exlFloatValue.geti ());
2521: }
2522: }
2523: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
2524: return elem.exlAppendPostfixOperatorTo (sb, ".w");
2525: }
2526: },
2527:
2528: ETY_OPERATOR_SIZE_LONG {
2529: @Override protected int etyPriority () {
2530: return EPY_PRIORITY_POSTFIX;
2531: }
2532: @Override protected void etyEval (ExpressionElement elem, int mode) {
2533: switch (elem.exlParamX.exlType) {
2534: case ETY_SQUARE_BRACKET:
2535: {
2536: int a, f;
2537: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2538: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2539: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2540: } else {
2541: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2542: f = -1;
2543: }
2544: elem.exlFloatValue.seti (MC68060.mmuPeekLong (a, f));
2545: }
2546: break;
2547: default:
2548: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.geti ());
2549: }
2550: }
2551: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
2552: return elem.exlAppendPostfixOperatorTo (sb, ".l");
2553: }
2554: },
2555:
2556: ETY_OPERATOR_SIZE_QUAD {
2557: @Override protected int etyPriority () {
2558: return EPY_PRIORITY_POSTFIX;
2559: }
2560: @Override protected void etyEval (ExpressionElement elem, int mode) {
2561: switch (elem.exlParamX.exlType) {
2562: case ETY_SQUARE_BRACKET:
2563: {
2564: int a, f;
2565: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2566: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2567: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2568: } else {
2569: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2570: f = -1;
2571: }
2572: elem.exlFloatValue.setl (MC68060.mmuPeekQuad (a, f));
2573: }
2574: break;
2575: default:
2576: elem.exlFloatValue.setl (elem.exlParamX.exlEval (mode).exlFloatValue.getl ());
2577: }
2578: }
2579: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
2580: return elem.exlAppendPostfixOperatorTo (sb, ".q");
2581: }
2582: },
2583:
2584: ETY_OPERATOR_SIZE_SINGLE {
2585: @Override protected int etyPriority () {
2586: return EPY_PRIORITY_POSTFIX;
2587: }
2588: @Override protected void etyEval (ExpressionElement elem, int mode) {
2589: switch (elem.exlParamX.exlType) {
2590: case ETY_SQUARE_BRACKET:
2591: {
2592: int a, f;
2593: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2594: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2595: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2596: } else {
2597: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2598: f = -1;
2599: }
2600: elem.exlFloatValue.setf0 (MC68060.mmuPeekLong (a, f));
2601: }
2602: break;
2603: default:
2604: elem.exlFloatValue.sete (elem.exlParamX.exlEval (mode).exlFloatValue).roundf ();
2605: }
2606: }
2607: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
2608: return elem.exlAppendPostfixOperatorTo (sb, ".s");
2609: }
2610: },
2611:
2612: ETY_OPERATOR_SIZE_DOUBLE {
2613: @Override protected int etyPriority () {
2614: return EPY_PRIORITY_POSTFIX;
2615: }
2616: @Override protected void etyEval (ExpressionElement elem, int mode) {
2617: switch (elem.exlParamX.exlType) {
2618: case ETY_SQUARE_BRACKET:
2619: {
2620: int a, f;
2621: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2622: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2623: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2624: } else {
2625: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2626: f = -1;
2627: }
2628: elem.exlFloatValue.setd01 (MC68060.mmuPeekQuad (a, f));
2629: }
2630: break;
2631: default:
2632: elem.exlFloatValue.sete (elem.exlParamX.exlEval (mode).exlFloatValue).roundd ();
2633: }
2634: }
2635: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
2636: return elem.exlAppendPostfixOperatorTo (sb, ".d");
2637: }
2638: },
2639:
2640: ETY_OPERATOR_SIZE_EXTENDED {
2641: @Override protected int etyPriority () {
2642: return EPY_PRIORITY_POSTFIX;
2643: }
2644: @Override protected void etyEval (ExpressionElement elem, int mode) {
2645: switch (elem.exlParamX.exlType) {
2646: case ETY_SQUARE_BRACKET:
2647: {
2648: int a, f;
2649: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2650: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2651: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2652: } else {
2653: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2654: f = -1;
2655: }
2656: byte[] b = new byte[12];
2657: MC68060.mmuPeekExtended (a, b, f);
2658: elem.exlFloatValue.setx012 (b, 0);
2659: }
2660: break;
2661: default:
2662: elem.exlFloatValue.sete (elem.exlParamX.exlEval (mode).exlFloatValue).roundx ();
2663: }
2664: }
2665: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
2666: return elem.exlAppendPostfixOperatorTo (sb, ".x");
2667: }
2668: },
2669:
2670: ETY_OPERATOR_SIZE_TRIPLE {
2671: @Override protected int etyPriority () {
2672: return EPY_PRIORITY_POSTFIX;
2673: }
2674: @Override protected void etyEval (ExpressionElement elem, int mode) {
2675: switch (elem.exlParamX.exlType) {
2676: case ETY_SQUARE_BRACKET:
2677: {
2678: int a, f;
2679: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2680: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2681: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2682: } else {
2683: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2684: f = -1;
2685: }
2686: byte[] b = new byte[12];
2687: MC68060.mmuPeekExtended (a, b, f);
2688: elem.exlFloatValue.sety012 (b, 0);
2689: }
2690: break;
2691: default:
2692: elem.exlFloatValue.sete (elem.exlParamX.exlEval (mode).exlFloatValue).roundy ();
2693: }
2694: }
2695: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
2696: return elem.exlAppendPostfixOperatorTo (sb, ".t");
2697: }
2698: },
2699:
2700: ETY_OPERATOR_SIZE_PACKED {
2701: @Override protected int etyPriority () {
2702: return EPY_PRIORITY_POSTFIX;
2703: }
2704: @Override protected void etyEval (ExpressionElement elem, int mode) {
2705: switch (elem.exlParamX.exlType) {
2706: case ETY_SQUARE_BRACKET:
2707: {
2708: int a, f;
2709: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2710: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2711: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2712: } else {
2713: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2714: f = -1;
2715: }
2716: byte[] b = new byte[12];
2717: MC68060.mmuPeekExtended (a, b, f);
2718: elem.exlFloatValue.setp012 (b, 0);
2719: }
2720: break;
2721: default:
2722: elem.exlFloatValue.setnan ();
2723: }
2724: }
2725: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
2726: return elem.exlAppendPostfixOperatorTo (sb, ".p");
2727: }
2728: },
2729:
2730:
2731: ETY_OPERATOR_PREINCREMENT {
2732: @Override protected int etyPriority () {
2733: return EPY_PRIORITY_PREFIX;
2734: }
2735: @Override protected void etyEval (ExpressionElement elem, int mode) {
2736: switch (elem.exlParamX.exlType) {
2737: case ETY_VARIABLE_FLOAT:
2738: elem.exlParamX.exlParamX.exlFloatValue.inc ();
2739: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue);
2740: break;
2741: case ETY_INTEGER_REGISTER:
2742: {
2743: int n = elem.exlParamX.exlSubscript;
2744: int x = elem.exlReadRegLong (n) + 1;
2745: elem.exlWriteRegLong (n, x);
2746: elem.exlFloatValue.seti (x);
2747: }
2748: break;
2749: case ETY_FLOATING_POINT_REGISTER:
2750: elem.exlFloatValue.sete (elem.exlGetFPn (elem.exlParamX.exlSubscript).inc ());
2751: break;
2752: case ETY_PC:
2753: {
2754: int x = elem.exlReadPC () + 1;
2755: elem.exlFloatValue.seti (x);
2756: elem.exlWritePC (x);
2757: }
2758: break;
2759: case ETY_CCR:
2760: {
2761: int x = elem.exlReadCCR () + 1;
2762: elem.exlFloatValue.seti (x);
2763: elem.exlWriteCCR (x);
2764: }
2765: break;
2766: case ETY_SR:
2767: {
2768: int x = elem.exlReadSR () + 1;
2769: elem.exlFloatValue.seti (x);
2770: elem.exlWriteSR (x);
2771: }
2772: break;
2773: case ETY_FLOAT_CONTROL_REGISTER:
2774: {
2775: int n = elem.exlParamX.exlSubscript;
2776: int x = elem.exlReadFloatControlRegister (n) + 1;
2777: elem.exlFloatValue.seti (x);
2778: elem.exlWriteFloatControlRegister (n, x);
2779: }
2780: break;
2781: case ETY_CONTROL_REGISTER:
2782: {
2783: int n = elem.exlParamX.exlSubscript;
2784: int x = elem.exlReadControlRegister (n) + 1;
2785: elem.exlWriteControlRegister (n, x);
2786: elem.exlFloatValue.seti (x);
2787: }
2788: break;
2789: case ETY_SQUARE_BRACKET:
2790: {
2791: int a, f;
2792: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2793: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2794: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2795: } else {
2796: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2797: f = -1;
2798: }
2799: int x = MC68060.mmuPeekByteSign (a, f) + 1;
2800: MC68060.mmuPokeByte (a, x, f);
2801: elem.exlFloatValue.seti (x);
2802: }
2803: break;
2804: case ETY_OPERATOR_SIZE_BYTE:
2805: switch (elem.exlParamX.exlParamX.exlType) {
2806: case ETY_INTEGER_REGISTER:
2807: {
2808: int n = elem.exlParamX.exlParamX.exlSubscript;
2809: int x = elem.exlReadRegByte (n) + 1;
2810: elem.exlWriteRegByte (n, x);
2811: elem.exlFloatValue.seti (x);
2812: }
2813: break;
2814: case ETY_SQUARE_BRACKET:
2815: {
2816: int a, f;
2817: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2818: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2819: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2820: } else {
2821: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2822: f = -1;
2823: }
2824: int x = MC68060.mmuPeekByteSign (a, f) + 1;
2825: MC68060.mmuPokeByte (a, x, f);
2826: elem.exlFloatValue.seti (x);
2827: }
2828: break;
2829: default:
2830: elem.exlFloatValue.setnan ();
2831: }
2832: break;
2833: case ETY_OPERATOR_SIZE_WORD:
2834: switch (elem.exlParamX.exlParamX.exlType) {
2835: case ETY_INTEGER_REGISTER:
2836: {
2837: int n = elem.exlParamX.exlParamX.exlSubscript;
2838: int x = elem.exlReadRegWord (n) + 1;
2839: elem.exlWriteRegWord (n, x);
2840: elem.exlFloatValue.seti (x);
2841: }
2842: break;
2843: case ETY_SQUARE_BRACKET:
2844: {
2845: int a, f;
2846: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2847: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2848: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2849: } else {
2850: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2851: f = -1;
2852: }
2853: int x = MC68060.mmuPeekWordSign (a, f) + 1;
2854: MC68060.mmuPokeWord (a, x, f);
2855: elem.exlFloatValue.seti (x);
2856: }
2857: break;
2858: default:
2859: elem.exlFloatValue.setnan ();
2860: }
2861: break;
2862: case ETY_OPERATOR_SIZE_LONG:
2863: switch (elem.exlParamX.exlParamX.exlType) {
2864: case ETY_INTEGER_REGISTER:
2865: {
2866: int n = elem.exlParamX.exlParamX.exlSubscript;
2867: int x = elem.exlReadRegLong (n) + 1;
2868: elem.exlWriteRegLong (n, x);
2869: elem.exlFloatValue.seti (x);
2870: }
2871: break;
2872: case ETY_SQUARE_BRACKET:
2873: {
2874: int a, f;
2875: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2876: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2877: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2878: } else {
2879: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2880: f = -1;
2881: }
2882: int x = MC68060.mmuPeekLong (a, f) + 1;
2883: MC68060.mmuPokeLong (a, x, f);
2884: elem.exlFloatValue.seti (x);
2885: }
2886: break;
2887: default:
2888: elem.exlFloatValue.setnan ();
2889: }
2890: break;
2891: case ETY_OPERATOR_SIZE_QUAD:
2892: switch (elem.exlParamX.exlParamX.exlType) {
2893: case ETY_SQUARE_BRACKET:
2894: {
2895: int a, f;
2896: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2897: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2898: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2899: } else {
2900: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2901: f = -1;
2902: }
2903: long x = MC68060.mmuPeekQuad (a, f) + 1L;
2904: MC68060.mmuPokeQuad (a, x, f);
2905: elem.exlFloatValue.setl (x);
2906: }
2907: break;
2908: default:
2909: elem.exlFloatValue.setnan ();
2910: }
2911: break;
2912: case ETY_OPERATOR_SIZE_SINGLE:
2913: switch (elem.exlParamX.exlParamX.exlType) {
2914: case ETY_INTEGER_REGISTER:
2915: {
2916: int n = elem.exlParamX.exlParamX.exlSubscript;
2917: float x = Float.intBitsToFloat (elem.exlReadRegLong (n)) + 1.0F;
2918: elem.exlWriteRegLong (n, Float.floatToIntBits (x));
2919: elem.exlFloatValue.setf (x);
2920: }
2921: break;
2922: case ETY_SQUARE_BRACKET:
2923: {
2924: int a, f;
2925: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2926: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2927: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2928: } else {
2929: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2930: f = -1;
2931: }
2932: float x = Float.intBitsToFloat (MC68060.mmuPeekLong (a, f)) + 1.0F;
2933: MC68060.mmuPokeLong (a, Float.floatToIntBits (x), f);
2934: elem.exlFloatValue.setf (x);
2935: }
2936: break;
2937: default:
2938: elem.exlFloatValue.setnan ();
2939: }
2940: break;
2941: case ETY_OPERATOR_SIZE_DOUBLE:
2942: switch (elem.exlParamX.exlParamX.exlType) {
2943: case ETY_SQUARE_BRACKET:
2944: {
2945: int a, f;
2946: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2947: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2948: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2949: } else {
2950: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2951: f = -1;
2952: }
2953: double x = Double.longBitsToDouble (MC68060.mmuPeekQuad (a, f)) + 1.0;
2954: MC68060.mmuPokeQuad (a, Double.doubleToLongBits (x), f);
2955: elem.exlFloatValue.setd (x);
2956: }
2957: break;
2958: default:
2959: elem.exlFloatValue.setnan ();
2960: }
2961: break;
2962: case ETY_OPERATOR_SIZE_EXTENDED:
2963: switch (elem.exlParamX.exlParamX.exlType) {
2964: case ETY_SQUARE_BRACKET:
2965: {
2966: int a, f;
2967: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2968: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2969: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2970: } else {
2971: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2972: f = -1;
2973: }
2974: byte[] b = new byte[12];
2975: MC68060.mmuPeekExtended (a, b, f);
2976: elem.exlFloatValue.setx012 (b, 0).inc ().getx012 (b, 0);
2977: MC68060.mmuPokeExtended (a, b, f);
2978: }
2979: break;
2980: default:
2981: elem.exlFloatValue.setnan ();
2982: }
2983: break;
2984: case ETY_OPERATOR_SIZE_TRIPLE:
2985: switch (elem.exlParamX.exlParamX.exlType) {
2986: case ETY_SQUARE_BRACKET:
2987: {
2988: int a, f;
2989: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
2990: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2991: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
2992: } else {
2993: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
2994: f = -1;
2995: }
2996: byte[] b = new byte[12];
2997: MC68060.mmuPeekExtended (a, b, f);
2998: elem.exlFloatValue.sety012 (b, 0).inc ().gety012 (b, 0);
2999: MC68060.mmuPokeExtended (a, b, f);
3000: }
3001: break;
3002: default:
3003: elem.exlFloatValue.setnan ();
3004: }
3005: break;
3006: case ETY_OPERATOR_SIZE_PACKED:
3007: switch (elem.exlParamX.exlParamX.exlType) {
3008: case ETY_SQUARE_BRACKET:
3009: {
3010: int a, f;
3011: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3012: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3013: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3014: } else {
3015: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3016: f = -1;
3017: }
3018: byte[] b = new byte[12];
3019: MC68060.mmuPeekExtended (a, b, f);
3020: elem.exlFloatValue.setp012 (b, 0).inc ().getp012 (b, 0);
3021: MC68060.mmuPokeExtended (a, b, f);
3022: }
3023: break;
3024: default:
3025: elem.exlFloatValue.setnan ();
3026: }
3027: break;
3028: default:
3029: elem.exlFloatValue.setnan ();
3030: }
3031: }
3032: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3033: return elem.exlAppendPrefixOperatorTo (sb, "++");
3034: }
3035: },
3036:
3037: ETY_OPERATOR_PREDECREMENT {
3038: @Override protected int etyPriority () {
3039: return EPY_PRIORITY_PREFIX;
3040: }
3041: @Override protected void etyEval (ExpressionElement elem, int mode) {
3042: switch (elem.exlParamX.exlType) {
3043: case ETY_VARIABLE_FLOAT:
3044: elem.exlParamX.exlParamX.exlFloatValue.dec ();
3045: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue);
3046: break;
3047: case ETY_INTEGER_REGISTER:
3048: {
3049: int n = elem.exlParamX.exlSubscript;
3050: int x = elem.exlReadRegLong (n) - 1;
3051: elem.exlWriteRegLong (n, x);
3052: elem.exlFloatValue.seti (x);
3053: }
3054: break;
3055: case ETY_FLOATING_POINT_REGISTER:
3056: elem.exlFloatValue.sete (elem.exlGetFPn (elem.exlParamX.exlSubscript).dec ());
3057: break;
3058: case ETY_PC:
3059: {
3060: int x = elem.exlReadPC () - 1;
3061: elem.exlFloatValue.seti (x);
3062: elem.exlWritePC (x);
3063: }
3064: break;
3065: case ETY_CCR:
3066: {
3067: int x = elem.exlReadCCR () - 1;
3068: elem.exlFloatValue.seti (x);
3069: elem.exlWriteCCR (x);
3070: }
3071: break;
3072: case ETY_SR:
3073: {
3074: int x = elem.exlReadSR () - 1;
3075: elem.exlFloatValue.seti (x);
3076: elem.exlWriteSR (x);
3077: }
3078: break;
3079: case ETY_FLOAT_CONTROL_REGISTER:
3080: {
3081: int n = elem.exlParamX.exlSubscript;
3082: int x = elem.exlReadFloatControlRegister (n) - 1;
3083: elem.exlFloatValue.seti (x);
3084: elem.exlWriteFloatControlRegister (n, x);
3085: }
3086: break;
3087: case ETY_CONTROL_REGISTER:
3088: {
3089: int n = elem.exlParamX.exlSubscript;
3090: int x = elem.exlReadControlRegister (n) - 1;
3091: elem.exlWriteControlRegister (n, x);
3092: elem.exlFloatValue.seti (x);
3093: }
3094: break;
3095: case ETY_SQUARE_BRACKET:
3096: {
3097: int a, f;
3098: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3099: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3100: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3101: } else {
3102: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3103: f = -1;
3104: }
3105: int x = MC68060.mmuPeekByteSign (a, f) - 1;
3106: MC68060.mmuPokeByte (a, x, f);
3107: elem.exlFloatValue.seti (x);
3108: }
3109: break;
3110: case ETY_OPERATOR_SIZE_BYTE:
3111: switch (elem.exlParamX.exlParamX.exlType) {
3112: case ETY_INTEGER_REGISTER:
3113: {
3114: int n = elem.exlParamX.exlParamX.exlSubscript;
3115: int x = elem.exlReadRegByte (n) - 1;
3116: elem.exlWriteRegByte (n, x);
3117: elem.exlFloatValue.seti (x);
3118: }
3119: break;
3120: case ETY_SQUARE_BRACKET:
3121: {
3122: int a, f;
3123: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3124: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3125: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3126: } else {
3127: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3128: f = -1;
3129: }
3130: int x = MC68060.mmuPeekByteSign (a, f) - 1;
3131: MC68060.mmuPokeByte (a, x, f);
3132: elem.exlFloatValue.seti (x);
3133: }
3134: break;
3135: default:
3136: elem.exlFloatValue.setnan ();
3137: }
3138: break;
3139: case ETY_OPERATOR_SIZE_WORD:
3140: switch (elem.exlParamX.exlParamX.exlType) {
3141: case ETY_INTEGER_REGISTER:
3142: {
3143: int n = elem.exlParamX.exlParamX.exlSubscript;
3144: int x = elem.exlReadRegWord (n) - 1;
3145: elem.exlWriteRegWord (n, x);
3146: elem.exlFloatValue.seti (x);
3147: }
3148: break;
3149: case ETY_SQUARE_BRACKET:
3150: {
3151: int a, f;
3152: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3153: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3154: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3155: } else {
3156: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3157: f = -1;
3158: }
3159: int x = MC68060.mmuPeekWordSign (a, f) - 1;
3160: MC68060.mmuPokeWord (a, x, f);
3161: elem.exlFloatValue.seti (x);
3162: }
3163: break;
3164: default:
3165: elem.exlFloatValue.setnan ();
3166: }
3167: break;
3168: case ETY_OPERATOR_SIZE_LONG:
3169: switch (elem.exlParamX.exlParamX.exlType) {
3170: case ETY_INTEGER_REGISTER:
3171: {
3172: int n = elem.exlParamX.exlParamX.exlSubscript;
3173: int x = elem.exlReadRegLong (n) - 1;
3174: elem.exlWriteRegLong (n, x);
3175: elem.exlFloatValue.seti (x);
3176: }
3177: break;
3178: case ETY_SQUARE_BRACKET:
3179: {
3180: int a, f;
3181: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3182: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3183: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3184: } else {
3185: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3186: f = -1;
3187: }
3188: int x = MC68060.mmuPeekLong (a, f) - 1;
3189: MC68060.mmuPokeLong (a, x, f);
3190: elem.exlFloatValue.seti (x);
3191: }
3192: break;
3193: default:
3194: elem.exlFloatValue.setnan ();
3195: }
3196: break;
3197: case ETY_OPERATOR_SIZE_QUAD:
3198: switch (elem.exlParamX.exlParamX.exlType) {
3199: case ETY_SQUARE_BRACKET:
3200: {
3201: int a, f;
3202: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3203: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3204: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3205: } else {
3206: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3207: f = -1;
3208: }
3209: long x = MC68060.mmuPeekQuad (a, f) - 1L;
3210: MC68060.mmuPokeQuad (a, x, f);
3211: elem.exlFloatValue.setl (x);
3212: }
3213: break;
3214: default:
3215: elem.exlFloatValue.setnan ();
3216: }
3217: break;
3218: case ETY_OPERATOR_SIZE_SINGLE:
3219: switch (elem.exlParamX.exlParamX.exlType) {
3220: case ETY_INTEGER_REGISTER:
3221: {
3222: int n = elem.exlParamX.exlParamX.exlSubscript;
3223: float x = Float.intBitsToFloat (elem.exlReadRegLong (n)) - 1.0F;
3224: elem.exlWriteRegLong (n, Float.floatToIntBits (x));
3225: elem.exlFloatValue.setf (x);
3226: }
3227: break;
3228: case ETY_SQUARE_BRACKET:
3229: {
3230: int a, f;
3231: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3232: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3233: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3234: } else {
3235: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3236: f = -1;
3237: }
3238: float x = Float.intBitsToFloat (MC68060.mmuPeekLong (a, f)) - 1.0F;
3239: MC68060.mmuPokeLong (a, Float.floatToIntBits (x), f);
3240: elem.exlFloatValue.setf (x);
3241: }
3242: break;
3243: default:
3244: elem.exlFloatValue.setnan ();
3245: }
3246: break;
3247: case ETY_OPERATOR_SIZE_DOUBLE:
3248: switch (elem.exlParamX.exlParamX.exlType) {
3249: case ETY_SQUARE_BRACKET:
3250: {
3251: int a, f;
3252: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3253: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3254: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3255: } else {
3256: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3257: f = -1;
3258: }
3259: double x = Double.longBitsToDouble (MC68060.mmuPeekQuad (a, f)) - 1.0;
3260: MC68060.mmuPokeQuad (a, Double.doubleToLongBits (x), f);
3261: elem.exlFloatValue.setd (x);
3262: }
3263: break;
3264: default:
3265: elem.exlFloatValue.setnan ();
3266: }
3267: break;
3268: case ETY_OPERATOR_SIZE_EXTENDED:
3269: switch (elem.exlParamX.exlParamX.exlType) {
3270: case ETY_SQUARE_BRACKET:
3271: {
3272: int a, f;
3273: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3274: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3275: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3276: } else {
3277: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3278: f = -1;
3279: }
3280: byte[] b = new byte[12];
3281: MC68060.mmuPeekExtended (a, b, f);
3282: elem.exlFloatValue.setx012 (b, 0).dec ().getx012 (b, 0);
3283: MC68060.mmuPokeExtended (a, b, f);
3284: }
3285: break;
3286: default:
3287: elem.exlFloatValue.setnan ();
3288: }
3289: break;
3290: case ETY_OPERATOR_SIZE_TRIPLE:
3291: switch (elem.exlParamX.exlParamX.exlType) {
3292: case ETY_SQUARE_BRACKET:
3293: {
3294: int a, f;
3295: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3296: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3297: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3298: } else {
3299: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3300: f = -1;
3301: }
3302: byte[] b = new byte[12];
3303: MC68060.mmuPeekExtended (a, b, f);
3304: elem.exlFloatValue.sety012 (b, 0).dec ().gety012 (b, 0);
3305: MC68060.mmuPokeExtended (a, b, f);
3306: }
3307: break;
3308: default:
3309: elem.exlFloatValue.setnan ();
3310: }
3311: break;
3312: case ETY_OPERATOR_SIZE_PACKED:
3313: switch (elem.exlParamX.exlParamX.exlType) {
3314: case ETY_SQUARE_BRACKET:
3315: {
3316: int a, f;
3317: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3318: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3319: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3320: } else {
3321: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3322: f = -1;
3323: }
3324: byte[] b = new byte[12];
3325: MC68060.mmuPeekExtended (a, b, f);
3326: elem.exlFloatValue.setp012 (b, 0).dec ().getp012 (b, 0);
3327: MC68060.mmuPokeExtended (a, b, f);
3328: }
3329: break;
3330: default:
3331: elem.exlFloatValue.setnan ();
3332: }
3333: break;
3334: default:
3335: elem.exlFloatValue.setnan ();
3336: }
3337: }
3338: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3339: return elem.exlAppendPrefixOperatorTo (sb, "--");
3340: }
3341: },
3342:
3343: ETY_OPERATOR_NOTHING {
3344: @Override protected int etyPriority () {
3345: return EPY_PRIORITY_PREFIX;
3346: }
3347: @Override protected void etyEval (ExpressionElement elem, int mode) {
3348: elem.exlFloatValue.sete (elem.exlParamX.exlEval (mode).exlFloatValue);
3349: }
3350: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3351: return elem.exlAppendPrefixOperatorTo (sb, "+");
3352: }
3353: },
3354:
3355: ETY_OPERATOR_NEGATION {
3356: @Override protected int etyPriority () {
3357: return EPY_PRIORITY_PREFIX;
3358: }
3359: @Override protected void etyEval (ExpressionElement elem, int mode) {
3360: elem.exlFloatValue.neg (elem.exlParamX.exlEval (mode).exlFloatValue);
3361: }
3362: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3363: return elem.exlAppendPrefixOperatorTo (sb, "-");
3364: }
3365: },
3366:
3367: ETY_OPERATOR_BITWISE_NOT {
3368: @Override protected int etyPriority () {
3369: return EPY_PRIORITY_PREFIX;
3370: }
3371: @Override protected void etyEval (ExpressionElement elem, int mode) {
3372: elem.exlFloatValue.setl (~elem.exlParamX.exlEval (mode).exlFloatValue.getl ());
3373: }
3374: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3375: return elem.exlAppendPrefixOperatorTo (sb, "~");
3376: }
3377: },
3378:
3379: ETY_OPERATOR_LOGICAL_NOT {
3380: @Override protected int etyPriority () {
3381: return EPY_PRIORITY_PREFIX;
3382: }
3383: @Override protected void etyEval (ExpressionElement elem, int mode) {
3384: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.iszero () ? 1 : 0);
3385: }
3386: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3387: return elem.exlAppendPrefixOperatorTo (sb, "!");
3388: }
3389: },
3390:
3391:
3392: ETY_OPERATOR_POWER {
3393: @Override protected int etyPriority () {
3394: return EPY_PRIORITY_EXPONENTIATION;
3395: }
3396: @Override protected void etyEval (ExpressionElement elem, int mode) {
3397: elem.exlFloatValue.pow (elem.exlParamX.exlEval (mode).exlFloatValue, elem.exlParamY.exlEval (mode).exlFloatValue);
3398: }
3399: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3400: return elem.exlAppendBinaryOperatorTo (sb, "**");
3401: }
3402: },
3403:
3404:
3405: ETY_OPERATOR_MULTIPLICATION {
3406: @Override protected int etyPriority () {
3407: return EPY_PRIORITY_MULTIPLICATION;
3408: }
3409: @Override protected void etyEval (ExpressionElement elem, int mode) {
3410: elem.exlFloatValue.mul (elem.exlParamX.exlEval (mode).exlFloatValue, elem.exlParamY.exlEval (mode).exlFloatValue);
3411: }
3412: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3413: return elem.exlAppendBinaryOperatorTo (sb, "*");
3414: }
3415: },
3416:
3417: ETY_OPERATOR_DIVISION {
3418: @Override protected int etyPriority () {
3419: return EPY_PRIORITY_MULTIPLICATION;
3420: }
3421: @Override protected void etyEval (ExpressionElement elem, int mode) {
3422: elem.exlFloatValue.div (elem.exlParamX.exlEval (mode).exlFloatValue, elem.exlParamY.exlEval (mode).exlFloatValue);
3423: }
3424: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3425: return elem.exlAppendBinaryOperatorTo (sb, "/");
3426: }
3427: },
3428:
3429: ETY_OPERATOR_MODULUS {
3430: @Override protected int etyPriority () {
3431: return EPY_PRIORITY_MULTIPLICATION;
3432: }
3433: @Override protected void etyEval (ExpressionElement elem, int mode) {
3434: elem.exlFloatValue.rem (elem.exlParamX.exlEval (mode).exlFloatValue, elem.exlParamY.exlEval (mode).exlFloatValue);
3435: }
3436: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3437: return elem.exlAppendBinaryOperatorTo (sb, "%");
3438: }
3439: },
3440:
3441:
3442: ETY_OPERATOR_ADDITION_FLOAT_FLOAT {
3443: @Override protected int etyPriority () {
3444: return EPY_PRIORITY_ADDITION;
3445: }
3446: @Override protected void etyEval (ExpressionElement elem, int mode) {
3447: elem.exlFloatValue.add (elem.exlParamX.exlEval (mode).exlFloatValue, elem.exlParamY.exlEval (mode).exlFloatValue);
3448: }
3449: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3450: return elem.exlAppendBinaryOperatorTo (sb, "+");
3451: }
3452: },
3453:
3454: ETY_OPERATOR_ADDITION_FLOAT_STRING {
3455: @Override protected int etyPriority () {
3456: return EPY_PRIORITY_ADDITION;
3457: }
3458: @Override protected void etyEval (ExpressionElement elem, int mode) {
3459: elem.exlStringValue = elem.exlParamX.exlEval (mode).exlFloatValue.toString () + elem.exlParamY.exlEval (mode).exlStringValue;
3460: }
3461: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3462: return elem.exlAppendBinaryOperatorTo (sb, "+");
3463: }
3464: },
3465:
3466: ETY_OPERATOR_ADDITION_STRING_FLOAT {
3467: @Override protected int etyPriority () {
3468: return EPY_PRIORITY_ADDITION;
3469: }
3470: @Override protected void etyEval (ExpressionElement elem, int mode) {
3471: elem.exlStringValue = elem.exlParamX.exlEval (mode).exlStringValue + elem.exlParamY.exlEval (mode).exlFloatValue.toString ();
3472: }
3473: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3474: return elem.exlAppendBinaryOperatorTo (sb, "+");
3475: }
3476: },
3477:
3478: ETY_OPERATOR_ADDITION_STRING_STRING {
3479: @Override protected int etyPriority () {
3480: return EPY_PRIORITY_ADDITION;
3481: }
3482: @Override protected void etyEval (ExpressionElement elem, int mode) {
3483: elem.exlStringValue = elem.exlParamX.exlEval (mode).exlStringValue + elem.exlParamY.exlEval (mode).exlStringValue;
3484: }
3485: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3486: return elem.exlAppendBinaryOperatorTo (sb, "+");
3487: }
3488: },
3489:
3490: ETY_OPERATOR_SUBTRACTION {
3491: @Override protected int etyPriority () {
3492: return EPY_PRIORITY_ADDITION;
3493: }
3494: @Override protected void etyEval (ExpressionElement elem, int mode) {
3495: elem.exlFloatValue.sub (elem.exlParamX.exlEval (mode).exlFloatValue, elem.exlParamY.exlEval (mode).exlFloatValue);
3496: }
3497: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3498: return elem.exlAppendBinaryOperatorTo (sb, "-");
3499: }
3500: },
3501:
3502:
3503: ETY_OPERATOR_LEFT_SHIFT {
3504: @Override protected int etyPriority () {
3505: return EPY_PRIORITY_SHIFT;
3506: }
3507: @Override protected void etyEval (ExpressionElement elem, int mode) {
3508: elem.exlFloatValue.setl (elem.exlParamX.exlEval (mode).exlFloatValue.getl () << elem.exlParamY.exlEval (mode).exlFloatValue.geti ());
3509: }
3510: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3511: return elem.exlAppendBinaryOperatorTo (sb, "<<");
3512: }
3513: },
3514:
3515: ETY_OPERATOR_RIGHT_SHIFT {
3516: @Override protected int etyPriority () {
3517: return EPY_PRIORITY_SHIFT;
3518: }
3519: @Override protected void etyEval (ExpressionElement elem, int mode) {
3520: elem.exlFloatValue.setl (elem.exlParamX.exlEval (mode).exlFloatValue.getl () >> elem.exlParamY.exlEval (mode).exlFloatValue.geti ());
3521: }
3522: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3523: return elem.exlAppendBinaryOperatorTo (sb, ">>");
3524: }
3525: },
3526:
3527: ETY_OPERATOR_UNSIGNED_RIGHT_SHIFT {
3528: @Override protected int etyPriority () {
3529: return EPY_PRIORITY_SHIFT;
3530: }
3531: @Override protected void etyEval (ExpressionElement elem, int mode) {
3532: elem.exlFloatValue.setl (elem.exlParamX.exlEval (mode).exlFloatValue.getl () >>> elem.exlParamY.exlEval (mode).exlFloatValue.geti ());
3533: }
3534: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3535: return elem.exlAppendBinaryOperatorTo (sb, ">>>");
3536: }
3537: },
3538:
3539:
3540: ETY_OPERATOR_LESS_THAN {
3541: @Override protected int etyPriority () {
3542: return EPY_PRIORITY_COMPARISON;
3543: }
3544: @Override protected void etyEval (ExpressionElement elem, int mode) {
3545: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.lt (elem.exlParamY.exlEval (mode).exlFloatValue) ? 1 : 0);
3546: }
3547: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3548: return elem.exlAppendBinaryOperatorTo (sb, "<");
3549: }
3550: },
3551:
3552: ETY_OPERATOR_LESS_OR_EQUAL {
3553: @Override protected int etyPriority () {
3554: return EPY_PRIORITY_COMPARISON;
3555: }
3556: @Override protected void etyEval (ExpressionElement elem, int mode) {
3557: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.le (elem.exlParamY.exlEval (mode).exlFloatValue) ? 1 : 0);
3558: }
3559: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3560: return elem.exlAppendBinaryOperatorTo (sb, "<=");
3561: }
3562: },
3563:
3564: ETY_OPERATOR_GREATER_THAN {
3565: @Override protected int etyPriority () {
3566: return EPY_PRIORITY_COMPARISON;
3567: }
3568: @Override protected void etyEval (ExpressionElement elem, int mode) {
3569: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.gt (elem.exlParamY.exlEval (mode).exlFloatValue) ? 1 : 0);
3570: }
3571: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3572: return elem.exlAppendBinaryOperatorTo (sb, ">");
3573: }
3574: },
3575:
3576: ETY_OPERATOR_GREATER_OR_EQUAL {
3577: @Override protected int etyPriority () {
3578: return EPY_PRIORITY_COMPARISON;
3579: }
3580: @Override protected void etyEval (ExpressionElement elem, int mode) {
3581: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.ge (elem.exlParamY.exlEval (mode).exlFloatValue) ? 1 : 0);
3582: }
3583: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3584: return elem.exlAppendBinaryOperatorTo (sb, ">=");
3585: }
3586: },
3587:
3588:
3589: ETY_OPERATOR_EQUAL {
3590: @Override protected int etyPriority () {
3591: return EPY_PRIORITY_EQUALITY;
3592: }
3593: @Override protected void etyEval (ExpressionElement elem, int mode) {
3594: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.eq (elem.exlParamY.exlEval (mode).exlFloatValue) ? 1 : 0);
3595: }
3596: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3597: return elem.exlAppendBinaryOperatorTo (sb, "==");
3598: }
3599: },
3600:
3601: ETY_OPERATOR_NOT_EQUAL {
3602: @Override protected int etyPriority () {
3603: return EPY_PRIORITY_EQUALITY;
3604: }
3605: @Override protected void etyEval (ExpressionElement elem, int mode) {
3606: elem.exlFloatValue.seti (elem.exlParamX.exlEval (mode).exlFloatValue.ne (elem.exlParamY.exlEval (mode).exlFloatValue) ? 1 : 0);
3607: }
3608: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3609: return elem.exlAppendBinaryOperatorTo (sb, "!=");
3610: }
3611: },
3612:
3613:
3614: ETY_OPERATOR_BITWISE_AND {
3615: @Override protected int etyPriority () {
3616: return EPY_PRIORITY_BITWISE_AND;
3617: }
3618: @Override protected void etyEval (ExpressionElement elem, int mode) {
3619: elem.exlFloatValue.setl (elem.exlParamX.exlEval (mode).exlFloatValue.getl () &
3620: elem.exlParamY.exlEval (mode).exlFloatValue.getl ());
3621: }
3622: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3623: return elem.exlAppendBinaryOperatorTo (sb, "&");
3624: }
3625: },
3626:
3627:
3628: ETY_OPERATOR_BITWISE_XOR {
3629: @Override protected int etyPriority () {
3630: return EPY_PRIORITY_BITWISE_XOR;
3631: }
3632: @Override protected void etyEval (ExpressionElement elem, int mode) {
3633: elem.exlFloatValue.setl (elem.exlParamX.exlEval (mode).exlFloatValue.getl () ^
3634: elem.exlParamY.exlEval (mode).exlFloatValue.getl ());
3635: }
3636: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3637: return elem.exlAppendBinaryOperatorTo (sb, "^");
3638: }
3639: },
3640:
3641:
3642: ETY_OPERATOR_BITWISE_OR {
3643: @Override protected int etyPriority () {
3644: return EPY_PRIORITY_BITWISE_OR;
3645: }
3646: @Override protected void etyEval (ExpressionElement elem, int mode) {
3647: elem.exlFloatValue.setl (elem.exlParamX.exlEval (mode).exlFloatValue.getl () |
3648: elem.exlParamY.exlEval (mode).exlFloatValue.getl ());
3649: }
3650: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3651: return elem.exlAppendBinaryOperatorTo (sb, "|");
3652: }
3653: },
3654:
3655:
3656: ETY_OPERATOR_LOGICAL_AND {
3657: @Override protected int etyPriority () {
3658: return EPY_PRIORITY_LOGICAL_AND;
3659: }
3660: @Override protected void etyEval (ExpressionElement elem, int mode) {
3661: elem.exlFloatValue.seti (!elem.exlParamX.exlEval (mode).exlFloatValue.iszero () &&
3662: !elem.exlParamY.exlEval (mode).exlFloatValue.iszero () ? 1 : 0);
3663: }
3664: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3665: return elem.exlAppendBinaryOperatorTo (sb, "&&");
3666: }
3667: },
3668:
3669:
3670: ETY_OPERATOR_LOGICAL_OR {
3671: @Override protected int etyPriority () {
3672: return EPY_PRIORITY_LOGICAL_OR;
3673: }
3674: @Override protected void etyEval (ExpressionElement elem, int mode) {
3675: elem.exlFloatValue.seti (!elem.exlParamX.exlEval (mode).exlFloatValue.iszero () ||
3676: !elem.exlParamY.exlEval (mode).exlFloatValue.iszero () ? 1 : 0);
3677: }
3678: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3679: return elem.exlAppendBinaryOperatorTo (sb, "||");
3680: }
3681: },
3682:
3683:
3684: ETY_OPERATOR_CONDITIONAL_FLOAT {
3685: @Override protected int etyPriority () {
3686: return EPY_PRIORITY_CONDITIONAL;
3687: }
3688: @Override protected void etyEval (ExpressionElement elem, int mode) {
3689: elem.exlFloatValue.sete (!elem.exlParamX.exlEval (mode).exlFloatValue.iszero () ?
3690: elem.exlParamY.exlEval (mode).exlFloatValue :
3691: elem.exlParamZ.exlEval (mode).exlFloatValue);
3692: }
3693: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3694: return elem.exlAppendConditionalOperatorTo (sb, "?", ":");
3695: }
3696: },
3697:
3698: ETY_OPERATOR_CONDITIONAL_STRING {
3699: @Override protected int etyPriority () {
3700: return EPY_PRIORITY_CONDITIONAL;
3701: }
3702: @Override protected void etyEval (ExpressionElement elem, int mode) {
3703: elem.exlStringValue = (!elem.exlParamX.exlEval (mode).exlFloatValue.iszero () ?
3704: elem.exlParamY.exlEval (mode).exlStringValue :
3705: elem.exlParamZ.exlEval (mode).exlStringValue);
3706: }
3707: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
3708: return elem.exlAppendConditionalOperatorTo (sb, "?", ":");
3709: }
3710: },
3711:
3712:
3713: ETY_OPERATOR_ASSIGNMENT {
3714: @Override protected int etyPriority () {
3715: return EPY_PRIORITY_ASSIGNMENT;
3716: }
3717: @Override protected void etyEval (ExpressionElement elem, int mode) {
3718: switch (elem.exlParamX.exlType) {
3719: case ETY_VARIABLE_FLOAT:
3720: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.sete (elem.exlParamY.exlEval (mode).exlFloatValue));
3721: break;
3722: case ETY_INTEGER_REGISTER:
3723: {
3724: int y = (int) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3725: elem.exlFloatValue.seti (y);
3726: elem.exlWriteRegLong (elem.exlParamX.exlSubscript, y);
3727: }
3728: break;
3729: case ETY_FLOATING_POINT_REGISTER:
3730: {
3731: EFP y = elem.exlParamY.exlEval (mode).exlFloatValue;
3732: elem.exlFloatValue.sete (y);
3733: elem.exlGetFPn (elem.exlParamX.exlSubscript).sete (y);
3734: }
3735: break;
3736: case ETY_PC:
3737: {
3738: int y = (int) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3739: elem.exlFloatValue.seti (y);
3740: elem.exlWritePC (y);
3741: }
3742: break;
3743: case ETY_CCR:
3744: {
3745: int y = (int) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3746: elem.exlFloatValue.seti (y);
3747: elem.exlWriteCCR (y);
3748: }
3749: break;
3750: case ETY_SR:
3751: {
3752: int y = (int) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3753: elem.exlFloatValue.seti (y);
3754: elem.exlWriteSR (y);
3755: }
3756: break;
3757: case ETY_FLOAT_CONTROL_REGISTER:
3758: {
3759: int n = elem.exlParamX.exlSubscript;
3760: int y = (int) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3761: elem.exlFloatValue.seti (y);
3762: elem.exlWriteFloatControlRegister (n, y);
3763: }
3764: break;
3765: case ETY_CONTROL_REGISTER:
3766: {
3767: int n = elem.exlParamX.exlSubscript;
3768: int y = (int) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3769: elem.exlFloatValue.seti (y);
3770: elem.exlWriteControlRegister (n, y);
3771: }
3772: break;
3773: case ETY_SQUARE_BRACKET:
3774: {
3775: int a, f;
3776: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3777: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3778: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3779: } else {
3780: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3781: f = -1;
3782: }
3783: if (elem.exlParamY.exlValueType == ElementType.ETY_FLOAT) {
3784: int y = (byte) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3785: elem.exlFloatValue.seti (y);
3786: MC68060.mmuPokeByte (a, y, f);
3787: } else {
3788: MC68060.mmuPokeStringZ (a, elem.exlStringValue = elem.exlParamY.exlEval (mode).exlStringValue, f);
3789: }
3790: }
3791: break;
3792: case ETY_OPERATOR_SIZE_BYTE:
3793: switch (elem.exlParamX.exlParamX.exlType) {
3794: case ETY_INTEGER_REGISTER:
3795: {
3796: int y = (byte) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3797: elem.exlWriteRegByte (elem.exlParamX.exlParamX.exlSubscript, y);
3798: elem.exlFloatValue.seti (y);
3799: }
3800: break;
3801: case ETY_SQUARE_BRACKET:
3802: {
3803: int a, f;
3804: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3805: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3806: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3807: } else {
3808: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3809: f = -1;
3810: }
3811: int y = (byte) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3812: MC68060.mmuPokeByte (a, y, f);
3813: elem.exlFloatValue.seti (y);
3814: }
3815: break;
3816: default:
3817: elem.exlFloatValue.setnan ();
3818: }
3819: break;
3820: case ETY_OPERATOR_SIZE_WORD:
3821: switch (elem.exlParamX.exlParamX.exlType) {
3822: case ETY_INTEGER_REGISTER:
3823: {
3824: int y = (short) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3825: elem.exlWriteRegWord (elem.exlParamX.exlParamX.exlSubscript, y);
3826: elem.exlFloatValue.seti (y);
3827: }
3828: break;
3829: case ETY_SQUARE_BRACKET:
3830: {
3831: int a, f;
3832: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3833: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3834: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3835: } else {
3836: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3837: f = -1;
3838: }
3839: int y = (short) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3840: MC68060.mmuPokeWord (a, y, f);
3841: elem.exlFloatValue.seti (y);
3842: }
3843: break;
3844: default:
3845: elem.exlFloatValue.setnan ();
3846: }
3847: break;
3848: case ETY_OPERATOR_SIZE_LONG:
3849: switch (elem.exlParamX.exlParamX.exlType) {
3850: case ETY_INTEGER_REGISTER:
3851: {
3852: int y = (int) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3853: elem.exlWriteRegLong (elem.exlParamX.exlParamX.exlSubscript, y);
3854: elem.exlFloatValue.seti (y);
3855: }
3856: break;
3857: case ETY_SQUARE_BRACKET:
3858: {
3859: int a, f;
3860: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3861: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3862: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3863: } else {
3864: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3865: f = -1;
3866: }
3867: int y = (int) elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3868: MC68060.mmuPokeLong (a, y, f);
3869: elem.exlFloatValue.seti (y);
3870: }
3871: break;
3872: default:
3873: elem.exlFloatValue.setnan ();
3874: }
3875: break;
3876: case ETY_OPERATOR_SIZE_QUAD:
3877: switch (elem.exlParamX.exlParamX.exlType) {
3878: case ETY_SQUARE_BRACKET:
3879: {
3880: int a, f;
3881: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3882: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3883: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3884: } else {
3885: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3886: f = -1;
3887: }
3888: long y = elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
3889: MC68060.mmuPokeQuad (a, y, f);
3890: elem.exlFloatValue.setl (y);
3891: }
3892: break;
3893: default:
3894: elem.exlFloatValue.setnan ();
3895: }
3896: break;
3897: case ETY_OPERATOR_SIZE_SINGLE:
3898: switch (elem.exlParamX.exlParamX.exlType) {
3899: case ETY_INTEGER_REGISTER:
3900: {
3901: int y = elem.exlParamY.exlEval (mode).exlFloatValue.getf0 ();
3902: elem.exlWriteRegLong (elem.exlParamX.exlParamX.exlSubscript, y);
3903: elem.exlFloatValue.setf0 (y);
3904: }
3905: break;
3906: case ETY_SQUARE_BRACKET:
3907: {
3908: int a, f;
3909: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3910: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3911: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3912: } else {
3913: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3914: f = -1;
3915: }
3916: int y = elem.exlParamY.exlEval (mode).exlFloatValue.getf0 ();
3917: MC68060.mmuPokeLong (a, y, f);
3918: elem.exlFloatValue.setf0 (y);
3919: }
3920: break;
3921: default:
3922: elem.exlFloatValue.setnan ();
3923: }
3924: break;
3925: case ETY_OPERATOR_SIZE_DOUBLE:
3926: switch (elem.exlParamX.exlParamX.exlType) {
3927: case ETY_SQUARE_BRACKET:
3928: {
3929: int a, f;
3930: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3931: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3932: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3933: } else {
3934: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3935: f = -1;
3936: }
3937: long y = elem.exlParamY.exlEval (mode).exlFloatValue.getd01 ();
3938: MC68060.mmuPokeQuad (a, y, f);
3939: elem.exlFloatValue.setd01 (y);
3940: }
3941: break;
3942: default:
3943: elem.exlFloatValue.setnan ();
3944: }
3945: break;
3946: case ETY_OPERATOR_SIZE_EXTENDED:
3947: switch (elem.exlParamX.exlParamX.exlType) {
3948: case ETY_SQUARE_BRACKET:
3949: {
3950: int a, f;
3951: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3952: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3953: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3954: } else {
3955: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3956: f = -1;
3957: }
3958: byte[] b = new byte[12];
3959: elem.exlParamY.exlEval (mode).exlFloatValue.getx012 (b, 0);
3960: MC68060.mmuPokeExtended (a, b, f);
3961: elem.exlFloatValue.setx012 (b, 0);
3962: }
3963: break;
3964: default:
3965: elem.exlFloatValue.setnan ();
3966: }
3967: break;
3968: case ETY_OPERATOR_SIZE_TRIPLE:
3969: switch (elem.exlParamX.exlParamX.exlType) {
3970: case ETY_SQUARE_BRACKET:
3971: {
3972: int a, f;
3973: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3974: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3975: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3976: } else {
3977: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3978: f = -1;
3979: }
3980: byte[] b = new byte[12];
3981: elem.exlParamY.exlEval (mode).exlFloatValue.gety012 (b, 0);
3982: MC68060.mmuPokeExtended (a, b, f);
3983: elem.exlFloatValue.sety012 (b, 0);
3984: }
3985: break;
3986: default:
3987: elem.exlFloatValue.setnan ();
3988: }
3989: break;
3990: case ETY_OPERATOR_SIZE_PACKED:
3991: switch (elem.exlParamX.exlParamX.exlType) {
3992: case ETY_SQUARE_BRACKET:
3993: {
3994: int a, f;
3995: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
3996: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
3997: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
3998: } else {
3999: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4000: f = -1;
4001: }
4002: byte[] b = new byte[12];
4003: elem.exlParamY.exlEval (mode).exlFloatValue.getp012 (b, 0);
4004: MC68060.mmuPokeExtended (a, b, f);
4005: elem.exlFloatValue.setp012 (b, 0);
4006: }
4007: break;
4008: default:
4009: elem.exlFloatValue.setnan ();
4010: }
4011: break;
4012: default:
4013: elem.exlFloatValue.setnan ();
4014: }
4015: }
4016: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
4017: return elem.exlAppendAssignmentOperatorTo (sb, "=");
4018: }
4019: },
4020:
4021: ETY_OPERATOR_SELF_POWER {
4022: @Override protected int etyPriority () {
4023: return EPY_PRIORITY_ASSIGNMENT;
4024: }
4025: @Override protected void etyEval (ExpressionElement elem, int mode) {
4026: int n, a, f;
4027: EFPBox.EFP y = elem.exlParamY.exlEval (mode).exlFloatValue;
4028: switch (elem.exlParamX.exlType) {
4029: case ETY_VARIABLE_FLOAT:
4030: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.pow (y));
4031: break;
4032: case ETY_INTEGER_REGISTER:
4033: n = elem.exlParamX.exlSubscript;
4034: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).pow (y).geti ());
4035: break;
4036: case ETY_FLOATING_POINT_REGISTER:
4037: elem.exlFloatValue.sete (elem.exlGetFPn (elem.exlParamX.exlSubscript).pow (y));
4038: break;
4039: case ETY_PC:
4040: elem.exlWritePC (elem.exlFloatValue.seti (elem.exlReadPC ()).pow (y).geti ());
4041: break;
4042: case ETY_CCR:
4043: elem.exlWriteCCR (elem.exlFloatValue.seti (elem.exlReadCCR ()).pow (y).geti ());
4044: break;
4045: case ETY_SR:
4046: elem.exlWriteSR (elem.exlFloatValue.seti (elem.exlReadSR ()).pow (y).geti ());
4047: break;
4048: case ETY_FLOAT_CONTROL_REGISTER:
4049: n = elem.exlParamX.exlSubscript;
4050: elem.exlWriteFloatControlRegister (n, elem.exlFloatValue.seti (elem.exlReadFloatControlRegister (n)).pow (y).geti ());
4051: break;
4052: case ETY_CONTROL_REGISTER:
4053: n = elem.exlParamX.exlSubscript;
4054: elem.exlWriteControlRegister (n, elem.exlFloatValue.seti (elem.exlReadControlRegister (n)).pow (y).geti ());
4055: break;
4056: case ETY_SQUARE_BRACKET:
4057: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4058: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4059: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4060: } else {
4061: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4062: f = -1;
4063: }
4064: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).pow (y).geti (), f);
4065: break;
4066: case ETY_OPERATOR_SIZE_BYTE:
4067: case ETY_OPERATOR_SIZE_WORD:
4068: case ETY_OPERATOR_SIZE_LONG:
4069: case ETY_OPERATOR_SIZE_QUAD:
4070: case ETY_OPERATOR_SIZE_SINGLE:
4071: case ETY_OPERATOR_SIZE_DOUBLE:
4072: case ETY_OPERATOR_SIZE_EXTENDED:
4073: case ETY_OPERATOR_SIZE_TRIPLE:
4074: case ETY_OPERATOR_SIZE_PACKED:
4075: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
4076: n = elem.exlParamX.exlParamX.exlSubscript;
4077: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4078: elem.exlWriteRegByte (n, elem.exlFloatValue.seti (elem.exlReadRegByte (n)).pow (y).geti ());
4079: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4080: elem.exlWriteRegWord (n, elem.exlFloatValue.seti (elem.exlReadRegWord (n)).pow (y).geti ());
4081: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4082: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).pow (y).geti ());
4083: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4084: elem.exlWriteRegLong (n, elem.exlFloatValue.setf0 (elem.exlReadRegLong (n)).pow (y).getf0 ());
4085: } else {
4086: elem.exlFloatValue.setnan ();
4087: }
4088: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
4089: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4090: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4091: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4092: } else {
4093: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4094: f = -1;
4095: }
4096: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4097: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).pow (y).geti (), f);
4098: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4099: MC68060.mmuPokeWord (a, elem.exlFloatValue.seti (MC68060.mmuPeekWordSign (a, f)).pow (y).geti (), f);
4100: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4101: MC68060.mmuPokeLong (a, elem.exlFloatValue.seti (MC68060.mmuPeekLong (a, f)).pow (y).geti (), f);
4102: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
4103: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setl (MC68060.mmuPeekQuad (a, f)).pow (y).getl (), f);
4104: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4105: MC68060.mmuPokeLong (a, elem.exlFloatValue.setf0 (MC68060.mmuPeekLong (a, f)).pow (y).getf0 (), f);
4106: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
4107: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setd01 (MC68060.mmuPeekQuad (a, f)).pow (y).getd01 (), f);
4108: } else {
4109: byte[] b = new byte[12];
4110: MC68060.mmuPeekExtended (a, b, f);
4111: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
4112: elem.exlFloatValue.setx012 (b, 0).pow (y).getx012 (b, 0);
4113: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
4114: elem.exlFloatValue.sety012 (b, 0).pow (y).gety012 (b, 0);
4115: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
4116: elem.exlFloatValue.setp012 (b, 0).pow (y).getp012 (b, 0);
4117: } else {
4118: elem.exlFloatValue.setnan ();
4119: }
4120: MC68060.mmuPokeExtended (a, b, f);
4121: }
4122: } else {
4123: elem.exlFloatValue.setnan ();
4124: }
4125: break;
4126: default:
4127: elem.exlFloatValue.setnan ();
4128: }
4129: }
4130: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
4131: return elem.exlAppendAssignmentOperatorTo (sb, "**=");
4132: }
4133: },
4134:
4135: ETY_OPERATOR_SELF_MULTIPLICATION {
4136: @Override protected int etyPriority () {
4137: return EPY_PRIORITY_ASSIGNMENT;
4138: }
4139: @Override protected void etyEval (ExpressionElement elem, int mode) {
4140: int n, a, f;
4141: EFPBox.EFP y = elem.exlParamY.exlEval (mode).exlFloatValue;
4142: switch (elem.exlParamX.exlType) {
4143: case ETY_VARIABLE_FLOAT:
4144: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.mul (y));
4145: break;
4146: case ETY_INTEGER_REGISTER:
4147: n = elem.exlParamX.exlSubscript;
4148: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).mul (y).geti ());
4149: break;
4150: case ETY_FLOATING_POINT_REGISTER:
4151: elem.exlFloatValue.sete (elem.exlGetFPn (elem.exlParamX.exlSubscript).mul (y));
4152: break;
4153: case ETY_PC:
4154: elem.exlWritePC (elem.exlFloatValue.seti (elem.exlReadPC ()).mul (y).geti ());
4155: break;
4156: case ETY_CCR:
4157: elem.exlWriteCCR (elem.exlFloatValue.seti (elem.exlReadCCR ()).mul (y).geti ());
4158: break;
4159: case ETY_SR:
4160: elem.exlWriteSR (elem.exlFloatValue.seti (elem.exlReadSR ()).mul (y).geti ());
4161: break;
4162: case ETY_FLOAT_CONTROL_REGISTER:
4163: n = elem.exlParamX.exlSubscript;
4164: elem.exlWriteFloatControlRegister (n, elem.exlFloatValue.seti (elem.exlReadFloatControlRegister (n)).mul (y).geti ());
4165: break;
4166: case ETY_CONTROL_REGISTER:
4167: n = elem.exlParamX.exlSubscript;
4168: elem.exlWriteControlRegister (n, elem.exlFloatValue.seti (elem.exlReadControlRegister (n)).mul (y).geti ());
4169: break;
4170: case ETY_SQUARE_BRACKET:
4171: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4172: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4173: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4174: } else {
4175: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4176: f = -1;
4177: }
4178: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).mul (y).geti (), f);
4179: break;
4180: case ETY_OPERATOR_SIZE_BYTE:
4181: case ETY_OPERATOR_SIZE_WORD:
4182: case ETY_OPERATOR_SIZE_LONG:
4183: case ETY_OPERATOR_SIZE_QUAD:
4184: case ETY_OPERATOR_SIZE_SINGLE:
4185: case ETY_OPERATOR_SIZE_DOUBLE:
4186: case ETY_OPERATOR_SIZE_EXTENDED:
4187: case ETY_OPERATOR_SIZE_TRIPLE:
4188: case ETY_OPERATOR_SIZE_PACKED:
4189: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
4190: n = elem.exlParamX.exlParamX.exlSubscript;
4191: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4192: elem.exlWriteRegByte (n, elem.exlFloatValue.seti (elem.exlReadRegByte (n)).mul (y).geti ());
4193: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4194: elem.exlWriteRegWord (n, elem.exlFloatValue.seti (elem.exlReadRegWord (n)).mul (y).geti ());
4195: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4196: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).mul (y).geti ());
4197: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4198: elem.exlWriteRegLong (n, elem.exlFloatValue.setf0 (elem.exlReadRegLong (n)).mul (y).getf0 ());
4199: } else {
4200: elem.exlFloatValue.setnan ();
4201: }
4202: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
4203: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4204: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4205: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4206: } else {
4207: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4208: f = -1;
4209: }
4210: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4211: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).mul (y).geti (), f);
4212: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4213: MC68060.mmuPokeWord (a, elem.exlFloatValue.seti (MC68060.mmuPeekWordSign (a, f)).mul (y).geti (), f);
4214: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4215: MC68060.mmuPokeLong (a, elem.exlFloatValue.seti (MC68060.mmuPeekLong (a, f)).mul (y).geti (), f);
4216: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
4217: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setl (MC68060.mmuPeekQuad (a, f)).mul (y).getl (), f);
4218: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4219: MC68060.mmuPokeLong (a, elem.exlFloatValue.setf0 (MC68060.mmuPeekLong (a, f)).mul (y).getf0 (), f);
4220: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
4221: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setd01 (MC68060.mmuPeekQuad (a, f)).mul (y).getd01 (), f);
4222: } else {
4223: byte[] b = new byte[12];
4224: MC68060.mmuPeekExtended (a, b, f);
4225: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
4226: elem.exlFloatValue.setx012 (b, 0).mul (y).getx012 (b, 0);
4227: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
4228: elem.exlFloatValue.sety012 (b, 0).mul (y).gety012 (b, 0);
4229: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
4230: elem.exlFloatValue.setp012 (b, 0).mul (y).getp012 (b, 0);
4231: } else {
4232: elem.exlFloatValue.setnan ();
4233: }
4234: MC68060.mmuPokeExtended (a, b, f);
4235: }
4236: } else {
4237: elem.exlFloatValue.setnan ();
4238: }
4239: break;
4240: default:
4241: elem.exlFloatValue.setnan ();
4242: }
4243: }
4244: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
4245: return elem.exlAppendAssignmentOperatorTo (sb, "*=");
4246: }
4247: },
4248:
4249: ETY_OPERATOR_SELF_DIVISION {
4250: @Override protected int etyPriority () {
4251: return EPY_PRIORITY_ASSIGNMENT;
4252: }
4253: @Override protected void etyEval (ExpressionElement elem, int mode) {
4254: int n, a, f;
4255: EFPBox.EFP y = elem.exlParamY.exlEval (mode).exlFloatValue;
4256: switch (elem.exlParamX.exlType) {
4257: case ETY_VARIABLE_FLOAT:
4258: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.div (y));
4259: break;
4260: case ETY_INTEGER_REGISTER:
4261: n = elem.exlParamX.exlSubscript;
4262: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).div (y).geti ());
4263: break;
4264: case ETY_FLOATING_POINT_REGISTER:
4265: elem.exlFloatValue.sete (elem.exlGetFPn (elem.exlParamX.exlSubscript).div (y));
4266: break;
4267: case ETY_PC:
4268: elem.exlWritePC (elem.exlFloatValue.seti (elem.exlReadPC ()).div (y).geti ());
4269: break;
4270: case ETY_CCR:
4271: elem.exlWriteCCR (elem.exlFloatValue.seti (elem.exlReadCCR ()).div (y).geti ());
4272: break;
4273: case ETY_SR:
4274: elem.exlWriteSR (elem.exlFloatValue.seti (elem.exlReadSR ()).div (y).geti ());
4275: break;
4276: case ETY_FLOAT_CONTROL_REGISTER:
4277: n = elem.exlParamX.exlSubscript;
4278: elem.exlWriteFloatControlRegister (n, elem.exlFloatValue.seti (elem.exlReadFloatControlRegister (n)).div (y).geti ());
4279: break;
4280: case ETY_CONTROL_REGISTER:
4281: n = elem.exlParamX.exlSubscript;
4282: elem.exlWriteControlRegister (n, elem.exlFloatValue.seti (elem.exlReadControlRegister (n)).div (y).geti ());
4283: break;
4284: case ETY_SQUARE_BRACKET:
4285: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4286: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4287: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4288: } else {
4289: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4290: f = -1;
4291: }
4292: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).div (y).geti (), f);
4293: break;
4294: case ETY_OPERATOR_SIZE_BYTE:
4295: case ETY_OPERATOR_SIZE_WORD:
4296: case ETY_OPERATOR_SIZE_LONG:
4297: case ETY_OPERATOR_SIZE_QUAD:
4298: case ETY_OPERATOR_SIZE_SINGLE:
4299: case ETY_OPERATOR_SIZE_DOUBLE:
4300: case ETY_OPERATOR_SIZE_EXTENDED:
4301: case ETY_OPERATOR_SIZE_TRIPLE:
4302: case ETY_OPERATOR_SIZE_PACKED:
4303: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
4304: n = elem.exlParamX.exlParamX.exlSubscript;
4305: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4306: elem.exlWriteRegByte (n, elem.exlFloatValue.seti (elem.exlReadRegByte (n)).div (y).geti ());
4307: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4308: elem.exlWriteRegWord (n, elem.exlFloatValue.seti (elem.exlReadRegWord (n)).div (y).geti ());
4309: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4310: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).div (y).geti ());
4311: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4312: elem.exlWriteRegLong (n, elem.exlFloatValue.setf0 (elem.exlReadRegLong (n)).div (y).getf0 ());
4313: } else {
4314: elem.exlFloatValue.setnan ();
4315: }
4316: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
4317: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4318: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4319: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4320: } else {
4321: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4322: f = -1;
4323: }
4324: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4325: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).div (y).geti (), f);
4326: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4327: MC68060.mmuPokeWord (a, elem.exlFloatValue.seti (MC68060.mmuPeekWordSign (a, f)).div (y).geti (), f);
4328: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4329: MC68060.mmuPokeLong (a, elem.exlFloatValue.seti (MC68060.mmuPeekLong (a, f)).div (y).geti (), f);
4330: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
4331: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setl (MC68060.mmuPeekQuad (a, f)).div (y).getl (), f);
4332: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4333: MC68060.mmuPokeLong (a, elem.exlFloatValue.setf0 (MC68060.mmuPeekLong (a, f)).div (y).getf0 (), f);
4334: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
4335: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setd01 (MC68060.mmuPeekQuad (a, f)).div (y).getd01 (), f);
4336: } else {
4337: byte[] b = new byte[12];
4338: MC68060.mmuPeekExtended (a, b, f);
4339: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
4340: elem.exlFloatValue.setx012 (b, 0).div (y).getx012 (b, 0);
4341: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
4342: elem.exlFloatValue.sety012 (b, 0).div (y).gety012 (b, 0);
4343: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
4344: elem.exlFloatValue.setp012 (b, 0).div (y).getp012 (b, 0);
4345: } else {
4346: elem.exlFloatValue.setnan ();
4347: }
4348: MC68060.mmuPokeExtended (a, b, f);
4349: }
4350: } else {
4351: elem.exlFloatValue.setnan ();
4352: }
4353: break;
4354: default:
4355: elem.exlFloatValue.setnan ();
4356: }
4357: }
4358: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
4359: return elem.exlAppendAssignmentOperatorTo (sb, "/=");
4360: }
4361: },
4362:
4363: ETY_OPERATOR_SELF_MODULUS {
4364: @Override protected int etyPriority () {
4365: return EPY_PRIORITY_ASSIGNMENT;
4366: }
4367: @Override protected void etyEval (ExpressionElement elem, int mode) {
4368: int n, a, f;
4369: EFPBox.EFP y = elem.exlParamY.exlEval (mode).exlFloatValue;
4370: switch (elem.exlParamX.exlType) {
4371: case ETY_VARIABLE_FLOAT:
4372: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.rem (y));
4373: break;
4374: case ETY_INTEGER_REGISTER:
4375: n = elem.exlParamX.exlSubscript;
4376: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).rem (y).geti ());
4377: break;
4378: case ETY_FLOATING_POINT_REGISTER:
4379: elem.exlFloatValue.sete (elem.exlGetFPn (elem.exlParamX.exlSubscript).rem (y));
4380: break;
4381: case ETY_PC:
4382: elem.exlWritePC (elem.exlFloatValue.seti (elem.exlReadPC ()).rem (y).geti ());
4383: break;
4384: case ETY_CCR:
4385: elem.exlWriteCCR (elem.exlFloatValue.seti (elem.exlReadCCR ()).rem (y).geti ());
4386: break;
4387: case ETY_SR:
4388: elem.exlWriteSR (elem.exlFloatValue.seti (elem.exlReadSR ()).rem (y).geti ());
4389: break;
4390: case ETY_FLOAT_CONTROL_REGISTER:
4391: n = elem.exlParamX.exlSubscript;
4392: elem.exlWriteFloatControlRegister (n, elem.exlFloatValue.seti (elem.exlReadFloatControlRegister (n)).rem (y).geti ());
4393: break;
4394: case ETY_CONTROL_REGISTER:
4395: n = elem.exlParamX.exlSubscript;
4396: elem.exlWriteControlRegister (n, elem.exlFloatValue.seti (elem.exlReadControlRegister (n)).rem (y).geti ());
4397: break;
4398: case ETY_SQUARE_BRACKET:
4399: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4400: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4401: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4402: } else {
4403: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4404: f = -1;
4405: }
4406: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).rem (y).geti (), f);
4407: break;
4408: case ETY_OPERATOR_SIZE_BYTE:
4409: case ETY_OPERATOR_SIZE_WORD:
4410: case ETY_OPERATOR_SIZE_LONG:
4411: case ETY_OPERATOR_SIZE_QUAD:
4412: case ETY_OPERATOR_SIZE_SINGLE:
4413: case ETY_OPERATOR_SIZE_DOUBLE:
4414: case ETY_OPERATOR_SIZE_EXTENDED:
4415: case ETY_OPERATOR_SIZE_TRIPLE:
4416: case ETY_OPERATOR_SIZE_PACKED:
4417: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
4418: n = elem.exlParamX.exlParamX.exlSubscript;
4419: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4420: elem.exlWriteRegByte (n, elem.exlFloatValue.seti (elem.exlReadRegByte (n)).rem (y).geti ());
4421: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4422: elem.exlWriteRegWord (n, elem.exlFloatValue.seti (elem.exlReadRegWord (n)).rem (y).geti ());
4423: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4424: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).rem (y).geti ());
4425: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4426: elem.exlWriteRegLong (n, elem.exlFloatValue.setf0 (elem.exlReadRegLong (n)).rem (y).getf0 ());
4427: } else {
4428: elem.exlFloatValue.setnan ();
4429: }
4430: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
4431: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4432: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4433: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4434: } else {
4435: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4436: f = -1;
4437: }
4438: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4439: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).rem (y).geti (), f);
4440: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4441: MC68060.mmuPokeWord (a, elem.exlFloatValue.seti (MC68060.mmuPeekWordSign (a, f)).rem (y).geti (), f);
4442: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4443: MC68060.mmuPokeLong (a, elem.exlFloatValue.seti (MC68060.mmuPeekLong (a, f)).rem (y).geti (), f);
4444: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
4445: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setl (MC68060.mmuPeekQuad (a, f)).rem (y).getl (), f);
4446: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4447: MC68060.mmuPokeLong (a, elem.exlFloatValue.setf0 (MC68060.mmuPeekLong (a, f)).rem (y).getf0 (), f);
4448: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
4449: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setd01 (MC68060.mmuPeekQuad (a, f)).rem (y).getd01 (), f);
4450: } else {
4451: byte[] b = new byte[12];
4452: MC68060.mmuPeekExtended (a, b, f);
4453: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
4454: elem.exlFloatValue.setx012 (b, 0).rem (y).getx012 (b, 0);
4455: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
4456: elem.exlFloatValue.sety012 (b, 0).rem (y).gety012 (b, 0);
4457: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
4458: elem.exlFloatValue.setp012 (b, 0).rem (y).getp012 (b, 0);
4459: } else {
4460: elem.exlFloatValue.setnan ();
4461: }
4462: MC68060.mmuPokeExtended (a, b, f);
4463: }
4464: } else {
4465: elem.exlFloatValue.setnan ();
4466: }
4467: break;
4468: default:
4469: elem.exlFloatValue.setnan ();
4470: }
4471: }
4472: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
4473: return elem.exlAppendAssignmentOperatorTo (sb, "%=");
4474: }
4475: },
4476:
4477: ETY_OPERATOR_SELF_ADDITION {
4478: @Override protected int etyPriority () {
4479: return EPY_PRIORITY_ASSIGNMENT;
4480: }
4481: @Override protected void etyEval (ExpressionElement elem, int mode) {
4482: int n, a, f;
4483: EFPBox.EFP y = elem.exlParamY.exlEval (mode).exlFloatValue;
4484: switch (elem.exlParamX.exlType) {
4485: case ETY_VARIABLE_FLOAT:
4486: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.add (y));
4487: break;
4488: case ETY_INTEGER_REGISTER:
4489: n = elem.exlParamX.exlSubscript;
4490: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).add (y).geti ());
4491: break;
4492: case ETY_FLOATING_POINT_REGISTER:
4493: elem.exlFloatValue.sete (elem.exlGetFPn (elem.exlParamX.exlSubscript).add (y));
4494: break;
4495: case ETY_PC:
4496: elem.exlWritePC (elem.exlFloatValue.seti (elem.exlReadPC ()).add (y).geti ());
4497: break;
4498: case ETY_CCR:
4499: elem.exlWriteCCR (elem.exlFloatValue.seti (elem.exlReadCCR ()).add (y).geti ());
4500: break;
4501: case ETY_SR:
4502: elem.exlWriteSR (elem.exlFloatValue.seti (elem.exlReadSR ()).add (y).geti ());
4503: break;
4504: case ETY_FLOAT_CONTROL_REGISTER:
4505: n = elem.exlParamX.exlSubscript;
4506: elem.exlWriteFloatControlRegister (n, elem.exlFloatValue.seti (elem.exlReadFloatControlRegister (n)).add (y).geti ());
4507: break;
4508: case ETY_CONTROL_REGISTER:
4509: n = elem.exlParamX.exlSubscript;
4510: elem.exlWriteControlRegister (n, elem.exlFloatValue.seti (elem.exlReadControlRegister (n)).add (y).geti ());
4511: break;
4512: case ETY_SQUARE_BRACKET:
4513: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4514: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4515: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4516: } else {
4517: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4518: f = -1;
4519: }
4520: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).add (y).geti (), f);
4521: break;
4522: case ETY_OPERATOR_SIZE_BYTE:
4523: case ETY_OPERATOR_SIZE_WORD:
4524: case ETY_OPERATOR_SIZE_LONG:
4525: case ETY_OPERATOR_SIZE_QUAD:
4526: case ETY_OPERATOR_SIZE_SINGLE:
4527: case ETY_OPERATOR_SIZE_DOUBLE:
4528: case ETY_OPERATOR_SIZE_EXTENDED:
4529: case ETY_OPERATOR_SIZE_TRIPLE:
4530: case ETY_OPERATOR_SIZE_PACKED:
4531: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
4532: n = elem.exlParamX.exlParamX.exlSubscript;
4533: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4534: elem.exlWriteRegByte (n, elem.exlFloatValue.seti (elem.exlReadRegByte (n)).add (y).geti ());
4535: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4536: elem.exlWriteRegWord (n, elem.exlFloatValue.seti (elem.exlReadRegWord (n)).add (y).geti ());
4537: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4538: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).add (y).geti ());
4539: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4540: elem.exlWriteRegLong (n, elem.exlFloatValue.setf0 (elem.exlReadRegLong (n)).add (y).getf0 ());
4541: } else {
4542: elem.exlFloatValue.setnan ();
4543: }
4544: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
4545: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4546: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4547: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4548: } else {
4549: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4550: f = -1;
4551: }
4552: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4553: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).add (y).geti (), f);
4554: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4555: MC68060.mmuPokeWord (a, elem.exlFloatValue.seti (MC68060.mmuPeekWordSign (a, f)).add (y).geti (), f);
4556: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4557: MC68060.mmuPokeLong (a, elem.exlFloatValue.seti (MC68060.mmuPeekLong (a, f)).add (y).geti (), f);
4558: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
4559: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setl (MC68060.mmuPeekQuad (a, f)).add (y).getl (), f);
4560: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4561: MC68060.mmuPokeLong (a, elem.exlFloatValue.setf0 (MC68060.mmuPeekLong (a, f)).add (y).getf0 (), f);
4562: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
4563: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setd01 (MC68060.mmuPeekQuad (a, f)).add (y).getd01 (), f);
4564: } else {
4565: byte[] b = new byte[12];
4566: MC68060.mmuPeekExtended (a, b, f);
4567: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
4568: elem.exlFloatValue.setx012 (b, 0).add (y).getx012 (b, 0);
4569: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
4570: elem.exlFloatValue.sety012 (b, 0).add (y).gety012 (b, 0);
4571: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
4572: elem.exlFloatValue.setp012 (b, 0).add (y).getp012 (b, 0);
4573: } else {
4574: elem.exlFloatValue.setnan ();
4575: }
4576: MC68060.mmuPokeExtended (a, b, f);
4577: }
4578: } else {
4579: elem.exlFloatValue.setnan ();
4580: }
4581: break;
4582: default:
4583: elem.exlFloatValue.setnan ();
4584: }
4585: }
4586: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
4587: return elem.exlAppendAssignmentOperatorTo (sb, "+=");
4588: }
4589: },
4590:
4591: ETY_OPERATOR_SELF_SUBTRACTION {
4592: @Override protected int etyPriority () {
4593: return EPY_PRIORITY_ASSIGNMENT;
4594: }
4595: @Override protected void etyEval (ExpressionElement elem, int mode) {
4596: int n, a, f;
4597: EFPBox.EFP y = elem.exlParamY.exlEval (mode).exlFloatValue;
4598: switch (elem.exlParamX.exlType) {
4599: case ETY_VARIABLE_FLOAT:
4600: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.sub (y));
4601: break;
4602: case ETY_INTEGER_REGISTER:
4603: n = elem.exlParamX.exlSubscript;
4604: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).sub (y).geti ());
4605: break;
4606: case ETY_FLOATING_POINT_REGISTER:
4607: elem.exlFloatValue.sete (elem.exlGetFPn (elem.exlParamX.exlSubscript).sub (y));
4608: break;
4609: case ETY_PC:
4610: elem.exlWritePC (elem.exlFloatValue.seti (elem.exlReadPC ()).sub (y).geti ());
4611: break;
4612: case ETY_CCR:
4613: elem.exlWriteCCR (elem.exlFloatValue.seti (elem.exlReadCCR ()).sub (y).geti ());
4614: break;
4615: case ETY_SR:
4616: elem.exlWriteSR (elem.exlFloatValue.seti (elem.exlReadSR ()).sub (y).geti ());
4617: break;
4618: case ETY_FLOAT_CONTROL_REGISTER:
4619: n = elem.exlParamX.exlSubscript;
4620: elem.exlWriteFloatControlRegister (n, elem.exlFloatValue.seti (elem.exlReadFloatControlRegister (n)).sub (y).geti ());
4621: break;
4622: case ETY_CONTROL_REGISTER:
4623: n = elem.exlParamX.exlSubscript;
4624: elem.exlWriteControlRegister (n, elem.exlFloatValue.seti (elem.exlReadControlRegister (n)).sub (y).geti ());
4625: break;
4626: case ETY_SQUARE_BRACKET:
4627: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4628: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4629: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4630: } else {
4631: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4632: f = -1;
4633: }
4634: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).sub (y).geti (), f);
4635: break;
4636: case ETY_OPERATOR_SIZE_BYTE:
4637: case ETY_OPERATOR_SIZE_WORD:
4638: case ETY_OPERATOR_SIZE_LONG:
4639: case ETY_OPERATOR_SIZE_QUAD:
4640: case ETY_OPERATOR_SIZE_SINGLE:
4641: case ETY_OPERATOR_SIZE_DOUBLE:
4642: case ETY_OPERATOR_SIZE_EXTENDED:
4643: case ETY_OPERATOR_SIZE_TRIPLE:
4644: case ETY_OPERATOR_SIZE_PACKED:
4645: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
4646: n = elem.exlParamX.exlParamX.exlSubscript;
4647: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4648: elem.exlWriteRegByte (n, elem.exlFloatValue.seti (elem.exlReadRegByte (n)).sub (y).geti ());
4649: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4650: elem.exlWriteRegWord (n, elem.exlFloatValue.seti (elem.exlReadRegWord (n)).sub (y).geti ());
4651: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4652: elem.exlWriteRegLong (n, elem.exlFloatValue.seti (elem.exlReadRegLong (n)).sub (y).geti ());
4653: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4654: elem.exlWriteRegLong (n, elem.exlFloatValue.setf0 (elem.exlReadRegLong (n)).sub (y).getf0 ());
4655: } else {
4656: elem.exlFloatValue.setnan ();
4657: }
4658: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
4659: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4660: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4661: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4662: } else {
4663: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4664: f = -1;
4665: }
4666: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4667: MC68060.mmuPokeByte (a, elem.exlFloatValue.seti (MC68060.mmuPeekByteSign (a, f)).sub (y).geti (), f);
4668: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4669: MC68060.mmuPokeWord (a, elem.exlFloatValue.seti (MC68060.mmuPeekWordSign (a, f)).sub (y).geti (), f);
4670: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4671: MC68060.mmuPokeLong (a, elem.exlFloatValue.seti (MC68060.mmuPeekLong (a, f)).sub (y).geti (), f);
4672: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
4673: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setl (MC68060.mmuPeekQuad (a, f)).sub (y).getl (), f);
4674: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4675: MC68060.mmuPokeLong (a, elem.exlFloatValue.setf0 (MC68060.mmuPeekLong (a, f)).sub (y).getf0 (), f);
4676: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
4677: MC68060.mmuPokeQuad (a, elem.exlFloatValue.setd01 (MC68060.mmuPeekQuad (a, f)).sub (y).getd01 (), f);
4678: } else {
4679: byte[] b = new byte[12];
4680: MC68060.mmuPeekExtended (a, b, f);
4681: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
4682: elem.exlFloatValue.setx012 (b, 0).sub (y).getx012 (b, 0);
4683: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
4684: elem.exlFloatValue.sety012 (b, 0).sub (y).gety012 (b, 0);
4685: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
4686: elem.exlFloatValue.setp012 (b, 0).sub (y).getp012 (b, 0);
4687: } else {
4688: elem.exlFloatValue.setnan ();
4689: }
4690: MC68060.mmuPokeExtended (a, b, f);
4691: }
4692: } else {
4693: elem.exlFloatValue.setnan ();
4694: }
4695: break;
4696: default:
4697: elem.exlFloatValue.setnan ();
4698: }
4699: }
4700: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
4701: return elem.exlAppendAssignmentOperatorTo (sb, "-=");
4702: }
4703: },
4704:
4705: ETY_OPERATOR_SELF_LEFT_SHIFT {
4706: @Override protected int etyPriority () {
4707: return EPY_PRIORITY_ASSIGNMENT;
4708: }
4709: @Override protected void etyEval (ExpressionElement elem, int mode) {
4710: int n, a, f;
4711: int y = elem.exlParamY.exlEval (mode).exlFloatValue.geti ();
4712: switch (elem.exlParamX.exlType) {
4713: case ETY_VARIABLE_FLOAT:
4714: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.setl (elem.exlParamX.exlParamX.exlFloatValue.getl () << y));
4715: break;
4716: case ETY_INTEGER_REGISTER:
4717: n = elem.exlParamX.exlSubscript;
4718: {
4719: int x = (int) ((long) elem.exlReadRegLong (n) << y);
4720: elem.exlFloatValue.seti (x);
4721: elem.exlWriteRegLong (n, x);
4722: }
4723: break;
4724: case ETY_FLOATING_POINT_REGISTER:
4725: n = elem.exlParamX.exlSubscript;
4726: elem.exlSetFPn (n, elem.exlFloatValue.setl (elem.exlGetFPn (n).getl () << y));
4727: break;
4728: case ETY_PC:
4729: {
4730: int x = (int) ((long) elem.exlReadPC () << y);
4731: elem.exlFloatValue.seti (x);
4732: elem.exlWritePC (x);
4733: }
4734: break;
4735: case ETY_CCR:
4736: {
4737: int x = (int) ((long) elem.exlReadCCR () << y);
4738: elem.exlFloatValue.seti (x);
4739: elem.exlWriteCCR (x);
4740: }
4741: break;
4742: case ETY_SR:
4743: {
4744: int x = (int) ((long) elem.exlReadSR () << y);
4745: elem.exlFloatValue.seti (x);
4746: elem.exlWriteSR (x);
4747: }
4748: break;
4749: case ETY_FLOAT_CONTROL_REGISTER:
4750: n = elem.exlParamX.exlSubscript;
4751: {
4752: int x = (int) ((long) elem.exlReadFloatControlRegister (n) << y);
4753: elem.exlFloatValue.seti (x);
4754: elem.exlWriteFloatControlRegister (n, x);
4755: }
4756: break;
4757: case ETY_CONTROL_REGISTER:
4758: n = elem.exlParamX.exlSubscript;
4759: {
4760: int x = (int) ((long) elem.exlReadControlRegister (n) << y);
4761: elem.exlFloatValue.seti (x);
4762: elem.exlWriteControlRegister (n, x);
4763: }
4764: break;
4765: case ETY_SQUARE_BRACKET:
4766: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4767: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4768: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4769: } else {
4770: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4771: f = -1;
4772: }
4773: {
4774: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) << y);
4775: elem.exlFloatValue.seti (x);
4776: MC68060.mmuPokeByte (a, x, f);
4777: }
4778: break;
4779: case ETY_OPERATOR_SIZE_BYTE:
4780: case ETY_OPERATOR_SIZE_WORD:
4781: case ETY_OPERATOR_SIZE_LONG:
4782: case ETY_OPERATOR_SIZE_QUAD:
4783: case ETY_OPERATOR_SIZE_SINGLE:
4784: case ETY_OPERATOR_SIZE_DOUBLE:
4785: case ETY_OPERATOR_SIZE_EXTENDED:
4786: case ETY_OPERATOR_SIZE_TRIPLE:
4787: case ETY_OPERATOR_SIZE_PACKED:
4788: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
4789: n = elem.exlParamX.exlParamX.exlSubscript;
4790: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4791: int x = (byte) ((long) elem.exlReadRegByte (n) << y);
4792: elem.exlFloatValue.seti (x);
4793: elem.exlWriteRegByte (n, x);
4794: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4795: int x = (short) ((long) elem.exlReadRegWord (n) << y);
4796: elem.exlFloatValue.seti (x);
4797: elem.exlWriteRegWord (n, x);
4798: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4799: int x = (int) ((long) elem.exlReadRegLong (n) << y);
4800: elem.exlFloatValue.seti (x);
4801: elem.exlWriteRegLong (n, x);
4802: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4803: float x = (float) ((long) Float.intBitsToFloat (elem.exlReadRegLong (n)) << y);
4804: elem.exlFloatValue.setf (x);
4805: elem.exlWriteRegLong (n, Float.floatToIntBits (x));
4806: } else {
4807: elem.exlFloatValue.setnan ();
4808: }
4809: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
4810: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4811: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4812: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4813: } else {
4814: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4815: f = -1;
4816: }
4817: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4818: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) << y);
4819: elem.exlFloatValue.seti (x);
4820: MC68060.mmuPokeByte (a, x, f);
4821: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4822: int x = (short) ((long) MC68060.mmuPeekWordSign (a, f) << y);
4823: elem.exlFloatValue.seti (x);
4824: MC68060.mmuPokeWord (a, x, f);
4825: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4826: int x = (int) ((long) MC68060.mmuPeekLong (a, f) << y);
4827: elem.exlFloatValue.seti (x);
4828: MC68060.mmuPokeLong (a, x, f);
4829: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
4830: long x = MC68060.mmuPeekQuad (a, f) << y;
4831: elem.exlFloatValue.setl (x);
4832: MC68060.mmuPokeQuad (a, x, f);
4833: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4834: float x = (float) ((long) Float.intBitsToFloat (MC68060.mmuPeekLong (a, f)) << y);
4835: elem.exlFloatValue.setf (x);
4836: MC68060.mmuPokeLong (a, Float.floatToIntBits (x), f);
4837: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
4838: double x = (double) ((long) Double.longBitsToDouble (MC68060.mmuPeekQuad (a, f)) << y);
4839: elem.exlFloatValue.setd (x);
4840: MC68060.mmuPokeQuad (a, Double.doubleToLongBits (x), f);
4841: } else {
4842: byte[] b = new byte[12];
4843: MC68060.mmuPeekExtended (a, b, f);
4844: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
4845: elem.exlFloatValue.setl (elem.exlFloatValue.setx012 (b, 0).getl () << y).getx012 (b, 0);
4846: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
4847: elem.exlFloatValue.setl (elem.exlFloatValue.sety012 (b, 0).getl () << y).gety012 (b, 0);
4848: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
4849: elem.exlFloatValue.setl (elem.exlFloatValue.setp012 (b, 0).getl () << y).getp012 (b, 0);
4850: } else {
4851: elem.exlFloatValue.setnan ();
4852: }
4853: MC68060.mmuPokeExtended (a, b, f);
4854: }
4855: } else {
4856: elem.exlFloatValue.setnan ();
4857: }
4858: break;
4859: default:
4860: elem.exlFloatValue.setnan ();
4861: }
4862: }
4863: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
4864: return elem.exlAppendAssignmentOperatorTo (sb, "<<=");
4865: }
4866: },
4867:
4868: ETY_OPERATOR_SELF_RIGHT_SHIFT {
4869: @Override protected int etyPriority () {
4870: return EPY_PRIORITY_ASSIGNMENT;
4871: }
4872: @Override protected void etyEval (ExpressionElement elem, int mode) {
4873: int n, a, f;
4874: int y = elem.exlParamY.exlEval (mode).exlFloatValue.geti ();
4875: switch (elem.exlParamX.exlType) {
4876: case ETY_VARIABLE_FLOAT:
4877: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.setl (elem.exlParamX.exlParamX.exlFloatValue.getl () >> y));
4878: break;
4879: case ETY_INTEGER_REGISTER:
4880: n = elem.exlParamX.exlSubscript;
4881: {
4882: int x = (int) ((long) elem.exlReadRegLong (n) >> y);
4883: elem.exlFloatValue.seti (x);
4884: elem.exlWriteRegLong (n, x);
4885: }
4886: break;
4887: case ETY_FLOATING_POINT_REGISTER:
4888: n = elem.exlParamX.exlSubscript;
4889: elem.exlSetFPn (n, elem.exlFloatValue.setl (elem.exlGetFPn (n).getl () >> y));
4890: break;
4891: case ETY_PC:
4892: {
4893: int x = (int) ((long) elem.exlReadPC () >> y);
4894: elem.exlFloatValue.seti (x);
4895: elem.exlWritePC (x);
4896: }
4897: break;
4898: case ETY_CCR:
4899: {
4900: int x = (int) ((long) elem.exlReadCCR () >> y);
4901: elem.exlFloatValue.seti (x);
4902: elem.exlWriteCCR (x);
4903: }
4904: break;
4905: case ETY_SR:
4906: {
4907: int x = (int) ((long) elem.exlReadSR () >> y);
4908: elem.exlFloatValue.seti (x);
4909: elem.exlWriteSR (x);
4910: }
4911: break;
4912: case ETY_FLOAT_CONTROL_REGISTER:
4913: n = elem.exlParamX.exlSubscript;
4914: {
4915: int x = (int) ((long) elem.exlReadFloatControlRegister (n) >> y);
4916: elem.exlFloatValue.seti (x);
4917: elem.exlWriteFloatControlRegister (n, x);
4918: }
4919: break;
4920: case ETY_CONTROL_REGISTER:
4921: n = elem.exlParamX.exlSubscript;
4922: {
4923: int x = (int) ((long) elem.exlReadControlRegister (n) >> y);
4924: elem.exlFloatValue.seti (x);
4925: elem.exlWriteControlRegister (n, x);
4926: }
4927: break;
4928: case ETY_SQUARE_BRACKET:
4929: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4930: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4931: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4932: } else {
4933: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4934: f = -1;
4935: }
4936: {
4937: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) >> y);
4938: elem.exlFloatValue.seti (x);
4939: MC68060.mmuPokeByte (a, x, f);
4940: }
4941: break;
4942: case ETY_OPERATOR_SIZE_BYTE:
4943: case ETY_OPERATOR_SIZE_WORD:
4944: case ETY_OPERATOR_SIZE_LONG:
4945: case ETY_OPERATOR_SIZE_QUAD:
4946: case ETY_OPERATOR_SIZE_SINGLE:
4947: case ETY_OPERATOR_SIZE_DOUBLE:
4948: case ETY_OPERATOR_SIZE_EXTENDED:
4949: case ETY_OPERATOR_SIZE_TRIPLE:
4950: case ETY_OPERATOR_SIZE_PACKED:
4951: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
4952: n = elem.exlParamX.exlParamX.exlSubscript;
4953: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4954: int x = (byte) ((long) elem.exlReadRegByte (n) >> y);
4955: elem.exlFloatValue.seti (x);
4956: elem.exlWriteRegByte (n, x);
4957: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4958: int x = (short) ((long) elem.exlReadRegWord (n) >> y);
4959: elem.exlFloatValue.seti (x);
4960: elem.exlWriteRegWord (n, x);
4961: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4962: int x = (int) ((long) elem.exlReadRegLong (n) >> y);
4963: elem.exlFloatValue.seti (x);
4964: elem.exlWriteRegLong (n, x);
4965: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4966: float x = (float) ((long) Float.intBitsToFloat (elem.exlReadRegLong (n)) >> y);
4967: elem.exlFloatValue.setf (x);
4968: elem.exlWriteRegLong (n, Float.floatToIntBits (x));
4969: } else {
4970: elem.exlFloatValue.setnan ();
4971: }
4972: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
4973: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
4974: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4975: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
4976: } else {
4977: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
4978: f = -1;
4979: }
4980: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
4981: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) >> y);
4982: elem.exlFloatValue.seti (x);
4983: MC68060.mmuPokeByte (a, x, f);
4984: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
4985: int x = (short) ((long) MC68060.mmuPeekWordSign (a, f) >> y);
4986: elem.exlFloatValue.seti (x);
4987: MC68060.mmuPokeWord (a, x, f);
4988: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
4989: int x = (int) ((long) MC68060.mmuPeekLong (a, f) >> y);
4990: elem.exlFloatValue.seti (x);
4991: MC68060.mmuPokeLong (a, x, f);
4992: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
4993: long x = MC68060.mmuPeekQuad (a, f) >> y;
4994: elem.exlFloatValue.setl (x);
4995: MC68060.mmuPokeQuad (a, x, f);
4996: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
4997: float x = (float) ((long) Float.intBitsToFloat (MC68060.mmuPeekLong (a, f)) >> y);
4998: elem.exlFloatValue.setf (x);
4999: MC68060.mmuPokeLong (a, Float.floatToIntBits (x), f);
5000: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
5001: double x = (double) ((long) Double.longBitsToDouble (MC68060.mmuPeekQuad (a, f)) >> y);
5002: elem.exlFloatValue.setd (x);
5003: MC68060.mmuPokeQuad (a, Double.doubleToLongBits (x), f);
5004: } else {
5005: byte[] b = new byte[12];
5006: MC68060.mmuPeekExtended (a, b, f);
5007: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
5008: elem.exlFloatValue.setl (elem.exlFloatValue.setx012 (b, 0).getl () >> y).getx012 (b, 0);
5009: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
5010: elem.exlFloatValue.setl (elem.exlFloatValue.sety012 (b, 0).getl () >> y).gety012 (b, 0);
5011: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
5012: elem.exlFloatValue.setl (elem.exlFloatValue.setp012 (b, 0).getl () >> y).getp012 (b, 0);
5013: } else {
5014: elem.exlFloatValue.setnan ();
5015: }
5016: MC68060.mmuPokeExtended (a, b, f);
5017: }
5018: } else {
5019: elem.exlFloatValue.setnan ();
5020: }
5021: break;
5022: default:
5023: elem.exlFloatValue.setnan ();
5024: }
5025: }
5026: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5027: return elem.exlAppendAssignmentOperatorTo (sb, ">>=");
5028: }
5029: },
5030:
5031: ETY_OPERATOR_SELF_UNSIGNED_RIGHT_SHIFT {
5032: @Override protected int etyPriority () {
5033: return EPY_PRIORITY_ASSIGNMENT;
5034: }
5035: @Override protected void etyEval (ExpressionElement elem, int mode) {
5036: int n, a, f;
5037: int y = elem.exlParamY.exlEval (mode).exlFloatValue.geti ();
5038: switch (elem.exlParamX.exlType) {
5039: case ETY_VARIABLE_FLOAT:
5040: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.setl (elem.exlParamX.exlParamX.exlFloatValue.getl () >>> y));
5041: break;
5042: case ETY_INTEGER_REGISTER:
5043: n = elem.exlParamX.exlSubscript;
5044: {
5045: int x = (int) ((long) elem.exlReadRegLong (n) >>> y);
5046: elem.exlFloatValue.seti (x);
5047: elem.exlWriteRegLong (n, x);
5048: }
5049: break;
5050: case ETY_FLOATING_POINT_REGISTER:
5051: n = elem.exlParamX.exlSubscript;
5052: elem.exlSetFPn (n, elem.exlFloatValue.setl (elem.exlGetFPn (n).getl () >>> y));
5053: break;
5054: case ETY_PC:
5055: {
5056: int x = (int) ((long) elem.exlReadPC () >>> y);
5057: elem.exlFloatValue.seti (x);
5058: elem.exlWritePC (x);
5059: }
5060: break;
5061: case ETY_CCR:
5062: {
5063: int x = (int) ((long) elem.exlReadCCR () >>> y);
5064: elem.exlFloatValue.seti (x);
5065: elem.exlWriteCCR (x);
5066: }
5067: break;
5068: case ETY_SR:
5069: {
5070: int x = (int) ((long) elem.exlReadSR () >>> y);
5071: elem.exlFloatValue.seti (x);
5072: elem.exlWriteSR (x);
5073: }
5074: break;
5075: case ETY_FLOAT_CONTROL_REGISTER:
5076: n = elem.exlParamX.exlSubscript;
5077: {
5078: int x = (int) ((long) elem.exlReadFloatControlRegister (n) >>> y);
5079: elem.exlFloatValue.seti (x);
5080: elem.exlWriteFloatControlRegister (n, x);
5081: }
5082: break;
5083: case ETY_CONTROL_REGISTER:
5084: n = elem.exlParamX.exlSubscript;
5085: {
5086: int x = (int) ((long) elem.exlReadControlRegister (n) >>> y);
5087: elem.exlFloatValue.seti (x);
5088: elem.exlWriteControlRegister (n, x);
5089: }
5090: break;
5091: case ETY_SQUARE_BRACKET:
5092: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
5093: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5094: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
5095: } else {
5096: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5097: f = -1;
5098: }
5099: {
5100: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) >>> y);
5101: elem.exlFloatValue.seti (x);
5102: MC68060.mmuPokeByte (a, x, f);
5103: }
5104: break;
5105: case ETY_OPERATOR_SIZE_BYTE:
5106: case ETY_OPERATOR_SIZE_WORD:
5107: case ETY_OPERATOR_SIZE_LONG:
5108: case ETY_OPERATOR_SIZE_QUAD:
5109: case ETY_OPERATOR_SIZE_SINGLE:
5110: case ETY_OPERATOR_SIZE_DOUBLE:
5111: case ETY_OPERATOR_SIZE_EXTENDED:
5112: case ETY_OPERATOR_SIZE_TRIPLE:
5113: case ETY_OPERATOR_SIZE_PACKED:
5114: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
5115: n = elem.exlParamX.exlParamX.exlSubscript;
5116: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
5117: int x = (byte) ((long) elem.exlReadRegByte (n) >>> y);
5118: elem.exlFloatValue.seti (x);
5119: elem.exlWriteRegByte (n, x);
5120: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
5121: int x = (short) ((long) elem.exlReadRegWord (n) >>> y);
5122: elem.exlFloatValue.seti (x);
5123: elem.exlWriteRegWord (n, x);
5124: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
5125: int x = (int) ((long) elem.exlReadRegLong (n) >>> y);
5126: elem.exlFloatValue.seti (x);
5127: elem.exlWriteRegLong (n, x);
5128: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
5129: float x = (float) ((long) Float.intBitsToFloat (elem.exlReadRegLong (n)) >>> y);
5130: elem.exlFloatValue.setf (x);
5131: elem.exlWriteRegLong (n, Float.floatToIntBits (x));
5132: } else {
5133: elem.exlFloatValue.setnan ();
5134: }
5135: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
5136: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
5137: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5138: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
5139: } else {
5140: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5141: f = -1;
5142: }
5143: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
5144: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) >>> y);
5145: elem.exlFloatValue.seti (x);
5146: MC68060.mmuPokeByte (a, x, f);
5147: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
5148: int x = (short) ((long) MC68060.mmuPeekWordSign (a, f) >>> y);
5149: elem.exlFloatValue.seti (x);
5150: MC68060.mmuPokeWord (a, x, f);
5151: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
5152: int x = (int) ((long) MC68060.mmuPeekLong (a, f) >>> y);
5153: elem.exlFloatValue.seti (x);
5154: MC68060.mmuPokeLong (a, x, f);
5155: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
5156: long x = MC68060.mmuPeekQuad (a, f) >>> y;
5157: elem.exlFloatValue.setl (x);
5158: MC68060.mmuPokeQuad (a, x, f);
5159: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
5160: float x = (float) ((long) Float.intBitsToFloat (MC68060.mmuPeekLong (a, f)) >>> y);
5161: elem.exlFloatValue.setf (x);
5162: MC68060.mmuPokeLong (a, Float.floatToIntBits (x), f);
5163: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
5164: double x = (double) ((long) Double.longBitsToDouble (MC68060.mmuPeekQuad (a, f)) >>> y);
5165: elem.exlFloatValue.setd (x);
5166: MC68060.mmuPokeQuad (a, Double.doubleToLongBits (x), f);
5167: } else {
5168: byte[] b = new byte[12];
5169: MC68060.mmuPeekExtended (a, b, f);
5170: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
5171: elem.exlFloatValue.setl (elem.exlFloatValue.setx012 (b, 0).getl () >>> y).getx012 (b, 0);
5172: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
5173: elem.exlFloatValue.setl (elem.exlFloatValue.sety012 (b, 0).getl () >>> y).gety012 (b, 0);
5174: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
5175: elem.exlFloatValue.setl (elem.exlFloatValue.setp012 (b, 0).getl () >>> y).getp012 (b, 0);
5176: } else {
5177: elem.exlFloatValue.setnan ();
5178: }
5179: MC68060.mmuPokeExtended (a, b, f);
5180: }
5181: } else {
5182: elem.exlFloatValue.setnan ();
5183: }
5184: break;
5185: default:
5186: elem.exlFloatValue.setnan ();
5187: }
5188: }
5189: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5190: return elem.exlAppendAssignmentOperatorTo (sb, ">>>=");
5191: }
5192: },
5193:
5194: ETY_OPERATOR_SELF_BITWISE_AND {
5195: @Override protected int etyPriority () {
5196: return EPY_PRIORITY_ASSIGNMENT;
5197: }
5198: @Override protected void etyEval (ExpressionElement elem, int mode) {
5199: int n, a, f;
5200: long y = elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
5201: switch (elem.exlParamX.exlType) {
5202: case ETY_VARIABLE_FLOAT:
5203: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.setl (elem.exlParamX.exlParamX.exlFloatValue.getl () & y));
5204: break;
5205: case ETY_INTEGER_REGISTER:
5206: n = elem.exlParamX.exlSubscript;
5207: {
5208: int x = (int) ((long) elem.exlReadRegLong (n) & y);
5209: elem.exlFloatValue.seti (x);
5210: elem.exlWriteRegLong (n, x);
5211: }
5212: break;
5213: case ETY_FLOATING_POINT_REGISTER:
5214: n = elem.exlParamX.exlSubscript;
5215: elem.exlSetFPn (n, elem.exlFloatValue.setl (elem.exlGetFPn (n).getl () & y));
5216: break;
5217: case ETY_PC:
5218: {
5219: int x = (int) ((long) elem.exlReadPC () & y);
5220: elem.exlFloatValue.seti (x);
5221: elem.exlWritePC (x);
5222: }
5223: break;
5224: case ETY_CCR:
5225: {
5226: int x = (int) ((long) elem.exlReadCCR () & y);
5227: elem.exlFloatValue.seti (x);
5228: elem.exlWriteCCR (x);
5229: }
5230: break;
5231: case ETY_SR:
5232: {
5233: int x = (int) ((long) elem.exlReadSR () & y);
5234: elem.exlFloatValue.seti (x);
5235: elem.exlWriteSR (x);
5236: }
5237: break;
5238: case ETY_FLOAT_CONTROL_REGISTER:
5239: n = elem.exlParamX.exlSubscript;
5240: {
5241: int x = (int) ((long) elem.exlReadFloatControlRegister (n) & y);
5242: elem.exlFloatValue.seti (x);
5243: elem.exlWriteFloatControlRegister (n, x);
5244: }
5245: break;
5246: case ETY_CONTROL_REGISTER:
5247: n = elem.exlParamX.exlSubscript;
5248: {
5249: int x = (int) ((long) elem.exlReadControlRegister (n) & y);
5250: elem.exlFloatValue.seti (x);
5251: elem.exlWriteControlRegister (n, x);
5252: }
5253: break;
5254: case ETY_SQUARE_BRACKET:
5255: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
5256: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5257: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
5258: } else {
5259: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5260: f = -1;
5261: }
5262: {
5263: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) & y);
5264: elem.exlFloatValue.seti (x);
5265: MC68060.mmuPokeByte (a, x, f);
5266: }
5267: break;
5268: case ETY_OPERATOR_SIZE_BYTE:
5269: case ETY_OPERATOR_SIZE_WORD:
5270: case ETY_OPERATOR_SIZE_LONG:
5271: case ETY_OPERATOR_SIZE_QUAD:
5272: case ETY_OPERATOR_SIZE_SINGLE:
5273: case ETY_OPERATOR_SIZE_DOUBLE:
5274: case ETY_OPERATOR_SIZE_EXTENDED:
5275: case ETY_OPERATOR_SIZE_TRIPLE:
5276: case ETY_OPERATOR_SIZE_PACKED:
5277: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
5278: n = elem.exlParamX.exlParamX.exlSubscript;
5279: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
5280: int x = (byte) ((long) elem.exlReadRegByte (n) & y);
5281: elem.exlFloatValue.seti (x);
5282: elem.exlWriteRegByte (n, x);
5283: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
5284: int x = (short) ((long) elem.exlReadRegWord (n) & y);
5285: elem.exlFloatValue.seti (x);
5286: elem.exlWriteRegWord (n, x);
5287: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
5288: int x = (int) ((long) elem.exlReadRegLong (n) & y);
5289: elem.exlFloatValue.seti (x);
5290: elem.exlWriteRegLong (n, x);
5291: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
5292: float x = (float) ((long) Float.intBitsToFloat (elem.exlReadRegLong (n)) & y);
5293: elem.exlFloatValue.setf (x);
5294: elem.exlWriteRegLong (n, Float.floatToIntBits (x));
5295: } else {
5296: elem.exlFloatValue.setnan ();
5297: }
5298: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
5299: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
5300: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5301: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
5302: } else {
5303: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5304: f = -1;
5305: }
5306: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
5307: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) & y);
5308: elem.exlFloatValue.seti (x);
5309: MC68060.mmuPokeByte (a, x, f);
5310: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
5311: int x = (short) ((long) MC68060.mmuPeekWordSign (a, f) & y);
5312: elem.exlFloatValue.seti (x);
5313: MC68060.mmuPokeWord (a, x, f);
5314: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
5315: int x = (int) ((long) MC68060.mmuPeekLong (a, f) & y);
5316: elem.exlFloatValue.seti (x);
5317: MC68060.mmuPokeLong (a, x, f);
5318: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
5319: long x = MC68060.mmuPeekQuad (a, f) & y;
5320: elem.exlFloatValue.setl (x);
5321: MC68060.mmuPokeQuad (a, x, f);
5322: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
5323: float x = (float) ((long) Float.intBitsToFloat (MC68060.mmuPeekLong (a, f)) & y);
5324: elem.exlFloatValue.setf (x);
5325: MC68060.mmuPokeLong (a, Float.floatToIntBits (x), f);
5326: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
5327: double x = (double) ((long) Double.longBitsToDouble (MC68060.mmuPeekQuad (a, f)) & y);
5328: elem.exlFloatValue.setd (x);
5329: MC68060.mmuPokeQuad (a, Double.doubleToLongBits (x), f);
5330: } else {
5331: byte[] b = new byte[12];
5332: MC68060.mmuPeekExtended (a, b, f);
5333: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
5334: elem.exlFloatValue.setl (elem.exlFloatValue.setx012 (b, 0).getl () & y).getx012 (b, 0);
5335: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
5336: elem.exlFloatValue.setl (elem.exlFloatValue.sety012 (b, 0).getl () & y).gety012 (b, 0);
5337: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
5338: elem.exlFloatValue.setl (elem.exlFloatValue.setp012 (b, 0).getl () & y).getp012 (b, 0);
5339: } else {
5340: elem.exlFloatValue.setnan ();
5341: }
5342: MC68060.mmuPokeExtended (a, b, f);
5343: }
5344: } else {
5345: elem.exlFloatValue.setnan ();
5346: }
5347: break;
5348: default:
5349: elem.exlFloatValue.setnan ();
5350: }
5351: }
5352: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5353: return elem.exlAppendAssignmentOperatorTo (sb, "&=");
5354: }
5355: },
5356:
5357: ETY_OPERATOR_SELF_BITWISE_XOR {
5358: @Override protected int etyPriority () {
5359: return EPY_PRIORITY_ASSIGNMENT;
5360: }
5361: @Override protected void etyEval (ExpressionElement elem, int mode) {
5362: int n, a, f;
5363: long y = elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
5364: switch (elem.exlParamX.exlType) {
5365: case ETY_VARIABLE_FLOAT:
5366: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.setl (elem.exlParamX.exlParamX.exlFloatValue.getl () ^ y));
5367: break;
5368: case ETY_INTEGER_REGISTER:
5369: n = elem.exlParamX.exlSubscript;
5370: {
5371: int x = (int) ((long) elem.exlReadRegLong (n) ^ y);
5372: elem.exlFloatValue.seti (x);
5373: elem.exlWriteRegLong (n, x);
5374: }
5375: break;
5376: case ETY_FLOATING_POINT_REGISTER:
5377: n = elem.exlParamX.exlSubscript;
5378: elem.exlSetFPn (n, elem.exlFloatValue.setl (elem.exlGetFPn (n).getl () ^ y));
5379: break;
5380: case ETY_PC:
5381: {
5382: int x = (int) ((long) elem.exlReadPC () ^ y);
5383: elem.exlFloatValue.seti (x);
5384: elem.exlWritePC (x);
5385: }
5386: break;
5387: case ETY_CCR:
5388: {
5389: int x = (int) ((long) elem.exlReadCCR () ^ y);
5390: elem.exlFloatValue.seti (x);
5391: elem.exlWriteCCR (x);
5392: }
5393: break;
5394: case ETY_SR:
5395: {
5396: int x = (int) ((long) elem.exlReadSR () ^ y);
5397: elem.exlFloatValue.seti (x);
5398: elem.exlWriteSR (x);
5399: }
5400: break;
5401: case ETY_FLOAT_CONTROL_REGISTER:
5402: n = elem.exlParamX.exlSubscript;
5403: {
5404: int x = (int) ((long) elem.exlReadFloatControlRegister (n) ^ y);
5405: elem.exlFloatValue.seti (x);
5406: elem.exlWriteFloatControlRegister (n, x);
5407: }
5408: break;
5409: case ETY_CONTROL_REGISTER:
5410: n = elem.exlParamX.exlSubscript;
5411: {
5412: int x = (int) ((long) elem.exlReadControlRegister (n) ^ y);
5413: elem.exlFloatValue.seti (x);
5414: elem.exlWriteControlRegister (n, x);
5415: }
5416: break;
5417: case ETY_SQUARE_BRACKET:
5418: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
5419: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5420: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
5421: } else {
5422: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5423: f = -1;
5424: }
5425: {
5426: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) ^ y);
5427: elem.exlFloatValue.seti (x);
5428: MC68060.mmuPokeByte (a, x, f);
5429: }
5430: break;
5431: case ETY_OPERATOR_SIZE_BYTE:
5432: case ETY_OPERATOR_SIZE_WORD:
5433: case ETY_OPERATOR_SIZE_LONG:
5434: case ETY_OPERATOR_SIZE_QUAD:
5435: case ETY_OPERATOR_SIZE_SINGLE:
5436: case ETY_OPERATOR_SIZE_DOUBLE:
5437: case ETY_OPERATOR_SIZE_EXTENDED:
5438: case ETY_OPERATOR_SIZE_TRIPLE:
5439: case ETY_OPERATOR_SIZE_PACKED:
5440: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
5441: n = elem.exlParamX.exlParamX.exlSubscript;
5442: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
5443: int x = (byte) ((long) elem.exlReadRegByte (n) ^ y);
5444: elem.exlFloatValue.seti (x);
5445: elem.exlWriteRegByte (n, x);
5446: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
5447: int x = (short) ((long) elem.exlReadRegWord (n) ^ y);
5448: elem.exlFloatValue.seti (x);
5449: elem.exlWriteRegWord (n, x);
5450: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
5451: int x = (int) ((long) elem.exlReadRegLong (n) ^ y);
5452: elem.exlFloatValue.seti (x);
5453: elem.exlWriteRegLong (n, x);
5454: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
5455: float x = (float) ((long) Float.intBitsToFloat (elem.exlReadRegLong (n)) ^ y);
5456: elem.exlFloatValue.setf (x);
5457: elem.exlWriteRegLong (n, Float.floatToIntBits (x));
5458: } else {
5459: elem.exlFloatValue.setnan ();
5460: }
5461: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
5462: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
5463: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5464: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
5465: } else {
5466: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5467: f = -1;
5468: }
5469: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
5470: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) ^ y);
5471: elem.exlFloatValue.seti (x);
5472: MC68060.mmuPokeByte (a, x, f);
5473: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
5474: int x = (short) ((long) MC68060.mmuPeekWordSign (a, f) ^ y);
5475: elem.exlFloatValue.seti (x);
5476: MC68060.mmuPokeWord (a, x, f);
5477: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
5478: int x = (int) ((long) MC68060.mmuPeekLong (a, f) ^ y);
5479: elem.exlFloatValue.seti (x);
5480: MC68060.mmuPokeLong (a, x, f);
5481: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
5482: long x = MC68060.mmuPeekQuad (a, f) ^ y;
5483: elem.exlFloatValue.setl (x);
5484: MC68060.mmuPokeQuad (a, x, f);
5485: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
5486: float x = (float) ((long) Float.intBitsToFloat (MC68060.mmuPeekLong (a, f)) ^ y);
5487: elem.exlFloatValue.setf (x);
5488: MC68060.mmuPokeLong (a, Float.floatToIntBits (x), f);
5489: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
5490: double x = (double) ((long) Double.longBitsToDouble (MC68060.mmuPeekQuad (a, f)) ^ y);
5491: elem.exlFloatValue.setd (x);
5492: MC68060.mmuPokeQuad (a, Double.doubleToLongBits (x), f);
5493: } else {
5494: byte[] b = new byte[12];
5495: MC68060.mmuPeekExtended (a, b, f);
5496: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
5497: elem.exlFloatValue.setl (elem.exlFloatValue.setx012 (b, 0).getl () ^ y).getx012 (b, 0);
5498: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
5499: elem.exlFloatValue.setl (elem.exlFloatValue.sety012 (b, 0).getl () ^ y).gety012 (b, 0);
5500: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
5501: elem.exlFloatValue.setl (elem.exlFloatValue.setp012 (b, 0).getl () ^ y).getp012 (b, 0);
5502: } else {
5503: elem.exlFloatValue.setnan ();
5504: }
5505: MC68060.mmuPokeExtended (a, b, f);
5506: }
5507: } else {
5508: elem.exlFloatValue.setnan ();
5509: }
5510: break;
5511: default:
5512: elem.exlFloatValue.setnan ();
5513: }
5514: }
5515: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5516: return elem.exlAppendAssignmentOperatorTo (sb, "^=");
5517: }
5518: },
5519:
5520: ETY_OPERATOR_SELF_BITWISE_OR {
5521: @Override protected int etyPriority () {
5522: return EPY_PRIORITY_ASSIGNMENT;
5523: }
5524: @Override protected void etyEval (ExpressionElement elem, int mode) {
5525: int n, a, f;
5526: long y = elem.exlParamY.exlEval (mode).exlFloatValue.getl ();
5527: switch (elem.exlParamX.exlType) {
5528: case ETY_VARIABLE_FLOAT:
5529: elem.exlFloatValue.sete (elem.exlParamX.exlParamX.exlFloatValue.setl (elem.exlParamX.exlParamX.exlFloatValue.getl () | y));
5530: break;
5531: case ETY_INTEGER_REGISTER:
5532: n = elem.exlParamX.exlSubscript;
5533: {
5534: int x = (int) ((long) elem.exlReadRegLong (n) | y);
5535: elem.exlFloatValue.seti (x);
5536: elem.exlWriteRegLong (n, x);
5537: }
5538: break;
5539: case ETY_FLOATING_POINT_REGISTER:
5540: n = elem.exlParamX.exlSubscript;
5541: elem.exlSetFPn (n, elem.exlFloatValue.setl (elem.exlGetFPn (n).getl () | y));
5542: break;
5543: case ETY_PC:
5544: {
5545: int x = (int) ((long) elem.exlReadPC () | y);
5546: elem.exlFloatValue.seti (x);
5547: elem.exlWritePC (x);
5548: }
5549: break;
5550: case ETY_CCR:
5551: {
5552: int x = (int) ((long) elem.exlReadCCR () | y);
5553: elem.exlFloatValue.seti (x);
5554: elem.exlWriteCCR (x);
5555: }
5556: break;
5557: case ETY_SR:
5558: {
5559: int x = (int) ((long) elem.exlReadSR () | y);
5560: elem.exlFloatValue.seti (x);
5561: elem.exlWriteSR (x);
5562: }
5563: break;
5564: case ETY_FLOAT_CONTROL_REGISTER:
5565: n = elem.exlParamX.exlSubscript;
5566: {
5567: int x = (int) ((long) elem.exlReadFloatControlRegister (n) | y);
5568: elem.exlFloatValue.seti (x);
5569: elem.exlWriteFloatControlRegister (n, x);
5570: }
5571: break;
5572: case ETY_CONTROL_REGISTER:
5573: n = elem.exlParamX.exlSubscript;
5574: {
5575: int x = (int) ((long) elem.exlReadControlRegister (n) | y);
5576: elem.exlFloatValue.seti (x);
5577: elem.exlWriteControlRegister (n, x);
5578: }
5579: break;
5580: case ETY_SQUARE_BRACKET:
5581: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
5582: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5583: f = elem.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
5584: } else {
5585: a = elem.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5586: f = -1;
5587: }
5588: {
5589: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) | y);
5590: elem.exlFloatValue.seti (x);
5591: MC68060.mmuPokeByte (a, x, f);
5592: }
5593: break;
5594: case ETY_OPERATOR_SIZE_BYTE:
5595: case ETY_OPERATOR_SIZE_WORD:
5596: case ETY_OPERATOR_SIZE_LONG:
5597: case ETY_OPERATOR_SIZE_QUAD:
5598: case ETY_OPERATOR_SIZE_SINGLE:
5599: case ETY_OPERATOR_SIZE_DOUBLE:
5600: case ETY_OPERATOR_SIZE_EXTENDED:
5601: case ETY_OPERATOR_SIZE_TRIPLE:
5602: case ETY_OPERATOR_SIZE_PACKED:
5603: if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) {
5604: n = elem.exlParamX.exlParamX.exlSubscript;
5605: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
5606: int x = (byte) ((long) elem.exlReadRegByte (n) | y);
5607: elem.exlFloatValue.seti (x);
5608: elem.exlWriteRegByte (n, x);
5609: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
5610: int x = (short) ((long) elem.exlReadRegWord (n) | y);
5611: elem.exlFloatValue.seti (x);
5612: elem.exlWriteRegWord (n, x);
5613: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
5614: int x = (int) ((long) elem.exlReadRegLong (n) | y);
5615: elem.exlFloatValue.seti (x);
5616: elem.exlWriteRegLong (n, x);
5617: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
5618: float x = (float) ((long) Float.intBitsToFloat (elem.exlReadRegLong (n)) | y);
5619: elem.exlFloatValue.setf (x);
5620: elem.exlWriteRegLong (n, Float.floatToIntBits (x));
5621: } else {
5622: elem.exlFloatValue.setnan ();
5623: }
5624: } else if (elem.exlParamX.exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET) {
5625: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_AT) {
5626: a = elem.exlParamX.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5627: f = elem.exlParamX.exlParamX.exlParamX.exlParamY.exlEval (mode).exlFloatValue.geti ();
5628: } else {
5629: a = elem.exlParamX.exlParamX.exlParamX.exlEval (mode).exlFloatValue.geti ();
5630: f = -1;
5631: }
5632: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE) {
5633: int x = (byte) ((long) MC68060.mmuPeekByteSign (a, f) | y);
5634: elem.exlFloatValue.seti (x);
5635: MC68060.mmuPokeByte (a, x, f);
5636: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_WORD) {
5637: int x = (short) ((long) MC68060.mmuPeekWordSign (a, f) | y);
5638: elem.exlFloatValue.seti (x);
5639: MC68060.mmuPokeWord (a, x, f);
5640: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) {
5641: int x = (int) ((long) MC68060.mmuPeekLong (a, f) | y);
5642: elem.exlFloatValue.seti (x);
5643: MC68060.mmuPokeLong (a, x, f);
5644: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD) {
5645: long x = MC68060.mmuPeekQuad (a, f) | y;
5646: elem.exlFloatValue.setl (x);
5647: MC68060.mmuPokeQuad (a, x, f);
5648: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) {
5649: float x = (float) ((long) Float.intBitsToFloat (MC68060.mmuPeekLong (a, f)) | y);
5650: elem.exlFloatValue.setf (x);
5651: MC68060.mmuPokeLong (a, Float.floatToIntBits (x), f);
5652: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE) {
5653: double x = (double) ((long) Double.longBitsToDouble (MC68060.mmuPeekQuad (a, f)) | y);
5654: elem.exlFloatValue.setd (x);
5655: MC68060.mmuPokeQuad (a, Double.doubleToLongBits (x), f);
5656: } else {
5657: byte[] b = new byte[12];
5658: MC68060.mmuPeekExtended (a, b, f);
5659: if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED) {
5660: elem.exlFloatValue.setl (elem.exlFloatValue.setx012 (b, 0).getl () | y).getx012 (b, 0);
5661: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE) {
5662: elem.exlFloatValue.setl (elem.exlFloatValue.sety012 (b, 0).getl () | y).gety012 (b, 0);
5663: } else if (elem.exlParamX.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) {
5664: elem.exlFloatValue.setl (elem.exlFloatValue.setp012 (b, 0).getl () | y).getp012 (b, 0);
5665: } else {
5666: elem.exlFloatValue.setnan ();
5667: }
5668: MC68060.mmuPokeExtended (a, b, f);
5669: }
5670: } else {
5671: elem.exlFloatValue.setnan ();
5672: }
5673: break;
5674: default:
5675: elem.exlFloatValue.setnan ();
5676: }
5677: }
5678: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5679: return elem.exlAppendAssignmentOperatorTo (sb, "|=");
5680: }
5681: },
5682:
5683:
5684: ETY_OPERATOR_ASSIGN_STRING_TO_VARIABLE {
5685: @Override protected int etyPriority () {
5686: return EPY_PRIORITY_ASSIGNMENT;
5687: }
5688: @Override protected void etyEval (ExpressionElement elem, int mode) {
5689: elem.exlStringValue = elem.exlParamX.exlParamX.exlStringValue = elem.exlParamY.exlEval (mode).exlStringValue;
5690: }
5691: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5692: return elem.exlAppendAssignmentOperatorTo (sb, "=");
5693: }
5694: },
5695:
5696: ETY_OPERATOR_CONCAT_STRING_TO_VARIABLE {
5697: @Override protected int etyPriority () {
5698: return EPY_PRIORITY_ASSIGNMENT;
5699: }
5700: @Override protected void etyEval (ExpressionElement elem, int mode) {
5701: elem.exlStringValue = elem.exlParamX.exlParamX.exlStringValue += elem.exlParamY.exlEval (mode).exlStringValue;
5702: }
5703: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5704: return elem.exlAppendAssignmentOperatorTo (sb, "+=");
5705: }
5706: },
5707:
5708: ETY_OPERATOR_ASSIGN_STRING_TO_MEMORY {
5709: @Override protected int etyPriority () {
5710: return EPY_PRIORITY_ASSIGNMENT;
5711: }
5712: @Override protected void etyEval (ExpressionElement elem, int mode) {
5713: ExpressionElement valueA = elem.exlParamX.exlParamX.exlEval (mode);
5714: ExpressionElement valueY = elem.exlParamY.exlEval (mode);
5715: int a = valueA.exlFloatValue.geti ();
5716: int f = valueA.exlType == ElementType.ETY_OPERATOR_AT ? valueA.exlParamY.exlFloatValue.geti () : -1;
5717: elem.exlStringValue = MC68060.mmuPokeStringZ (a, valueY.exlStringValue, f);
5718: }
5719: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5720: return elem.exlAppendAssignmentOperatorTo (sb, "=");
5721: }
5722: },
5723:
5724: ETY_OPERATOR_CONCAT_STRING_TO_MEMORY {
5725: @Override protected int etyPriority () {
5726: return EPY_PRIORITY_ASSIGNMENT;
5727: }
5728: @Override protected void etyEval (ExpressionElement elem, int mode) {
5729: ExpressionElement valueA = elem.exlParamX.exlParamX.exlEval (mode);
5730: ExpressionElement valueY = elem.exlParamY.exlEval (mode);
5731: int a = valueA.exlFloatValue.geti ();
5732: int f = valueA.exlType == ElementType.ETY_OPERATOR_AT ? valueA.exlParamY.exlFloatValue.geti () : -1;
5733: elem.exlStringValue = MC68060.mmuPokeStringZ (a, MC68060.mmuPeekStringZ (a, f) + valueY.exlStringValue, f);
5734: }
5735: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5736: return elem.exlAppendAssignmentOperatorTo (sb, "+=");
5737: }
5738: },
5739:
5740:
5741: ETY_OPERATOR_COLON {
5742: @Override protected int etyPriority () {
5743: return EPY_PRIORITY_COLON;
5744: }
5745: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5746: return elem.exlAppendBinaryOperatorTo (sb, ":");
5747: }
5748: },
5749:
5750:
5751: ETY_OPERATOR_COMMA {
5752: @Override protected int etyPriority () {
5753: return EPY_PRIORITY_COMMA;
5754: }
5755: @Override protected void etyEval (ExpressionElement elem, int mode) {
5756: elem.exlParamX.exlEval (mode);
5757: elem.exlParamY.exlEval (mode);
5758: if (elem.exlParamY.exlType == ElementType.ETY_FLOAT) {
5759:
5760: elem.exlFloatValue.sete (elem.exlParamY.exlFloatValue);
5761: } else if (elem.exlParamY.exlType == ElementType.ETY_STRING) {
5762:
5763: elem.exlStringValue = elem.exlParamY.exlStringValue;
5764: }
5765: }
5766: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5767: return elem.exlAppendBinaryOperatorTo (sb, ",");
5768: }
5769: },
5770:
5771:
5772:
5773:
5774:
5775: ETY_COMMAND_ASSEMBLE {
5776: @Override protected int etyPriority () {
5777: return EPY_PRIORITY_COMMAND;
5778: }
5779: @Override protected void etyEval (ExpressionElement elem, int mode) {
5780: if (DebugConsole.dgtAssemblePC == 0) {
5781: DebugConsole.dgtAssemblePC = XEiJ.regPC;
5782: }
5783: if (elem.exlParamX != null) {
5784: ExpressionElement[] paramList = elem.exlParamX.exlEvalCommaList (mode);
5785: if (0 < paramList.length) {
5786: ExpressionElement param = paramList[0];
5787: if (param.exlType == ElementType.ETY_OPERATOR_AT) {
5788: DebugConsole.dgtAssemblePC = param.exlParamX.exlFloatValue.geti ();
5789: DebugConsole.dgtAssembleFC = param.exlParamY.exlFloatValue.geti ();
5790: } else if (param.exlValueType == ElementType.ETY_FLOAT) {
5791: DebugConsole.dgtAssemblePC = param.exlFloatValue.geti ();
5792: DebugConsole.dgtAssembleFC = XEiJ.regSRS == 0 ? 2 : 6;
5793: }
5794: }
5795: }
5796:
5797: DebugConsole.dgtMakeAssemblerPrompt ();
5798:
5799: DebugConsole.dgtPrint (Multilingual.mlnJapanese ?
5800: "[ . で終了]\n" :
5801: "[enter . to exit]\n");
5802: DebugConsole.dgtInputMode = DebugConsole.DGT_INPUT_MODE_ASSEMBLER;
5803: DebugConsole.dgtPrintPrompt ();
5804: }
5805: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
5806: sb.append ("a");
5807: if (elem.exlParamX != null) {
5808: elem.exlParamX.exlAppendTo (sb.append (' '));
5809: }
5810: return sb;
5811: }
5812: },
5813:
5814:
5815:
5816:
5817: ETY_COMMAND_DUMP {
5818: @Override protected int etyPriority () {
5819: return EPY_PRIORITY_COMMAND;
5820: }
5821: @Override protected void etyEval (ExpressionElement elem, int mode) {
5822: int size = elem.exlSubscript;
5823:
5824: String header;
5825: int lineLength;
5826: int groupLength;
5827: EFPBox.EFP tempF = null;
5828:
5829:
5830:
5831:
5832:
5833:
5834:
5835:
5836:
5837:
5838:
5839:
5840:
5841:
5842:
5843:
5844: switch (size) {
5845: case 'b':
5846: header = " address +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F |0123456789ABCDEF|\n";
5847: lineLength = 16;
5848: groupLength = 1;
5849: break;
5850: case 'w':
5851: header = " address +0+1 +2+3 +4+5 +6+7 +8+9 +A+B +C+D +E+F |0123456789ABCDEF|\n";
5852: lineLength = 16;
5853: groupLength = 2;
5854: break;
5855: case 'l':
5856: header = " address +0+1+2+3 +4+5+6+7 +8+9+A+B +C+D+E+F |0123456789ABCDEF|\n";
5857: lineLength = 16;
5858: groupLength = 4;
5859: break;
5860: case 'q':
5861: header = " address +0+1+2+3+4+5+6+7 +8+9+A+B+C+D+E+F |0123456789ABCDEF|\n";
5862: lineLength = 16;
5863: groupLength = 8;
5864: break;
5865: case 's':
5866: header = " address +0+1+2+3\n";
5867: lineLength = 4;
5868: groupLength = 4;
5869: tempF = XEiJ.fpuBox.new EFP ();
5870: break;
5871: case 'd':
5872: header = " address +0+1+2+3+4+5+6+7\n";
5873: lineLength = 8;
5874: groupLength = 8;
5875: tempF = XEiJ.fpuBox.new EFP ();
5876: break;
5877: case 'x':
5878: case 't':
5879: case 'p':
5880: header = " address +0+1+2+3+4+5+6+7+8+9+A+B\n";
5881: lineLength = 12;
5882: groupLength = 12;
5883: tempF = XEiJ.fpuBox.new EFP ();
5884: break;
5885: default:
5886: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
5887: "サイズが間違っています" :
5888: "wrong size");
5889: return;
5890: }
5891:
5892: ExpressionElement[] paramArray = elem.exlParamX == null ? null : elem.exlParamX.exlEvalCommaList (mode);
5893:
5894: int startAddress;
5895: int functionCode;
5896: int straddleChar;
5897: if (paramArray == null || paramArray.length < 1) {
5898:
5899: startAddress = DebugConsole.dgtDumpAddress;
5900: functionCode = DebugConsole.dgtDumpFunctionCode;
5901: straddleChar = DebugConsole.dgtDumpStraddleChar;
5902: } else {
5903: ExpressionElement param0 = paramArray[0];
5904: if (param0.exlValueType != ElementType.ETY_FLOAT) {
5905: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
5906: "開始アドレスが間違っています" :
5907: "wrong start address");
5908: return;
5909: }
5910: if (param0.exlType == ElementType.ETY_OPERATOR_AT) {
5911: startAddress = param0.exlParamX.exlFloatValue.geti32 ();
5912: functionCode = param0.exlParamY.exlFloatValue.geti32 () & 7;
5913: } else {
5914: startAddress = param0.exlFloatValue.geti32 ();
5915: functionCode = XEiJ.regSRS == 0 ? 1 : 5;
5916: }
5917: straddleChar = 0;
5918: }
5919:
5920: int endAddress;
5921: if (paramArray == null || paramArray.length < 2) {
5922: endAddress = startAddress + lineLength * 16 - 1;
5923: } else {
5924: ExpressionElement param1 = paramArray[1];
5925: if (param1.exlValueType != ElementType.ETY_FLOAT) {
5926: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
5927: "終了アドレスが間違っています" :
5928: "wrong end address");
5929: return;
5930: }
5931: endAddress = param1.exlFloatValue.geti32 ();
5932: }
5933: if ((endAddress - startAddress) < 0) {
5934: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
5935: "アドレスが間違っています" :
5936: "wrong address");
5937: return;
5938: }
5939:
5940: int byteCount = lineLength + (tempF == null ? 1 : 0);
5941: byte[] byteArray = new byte[byteCount];
5942:
5943: StringBuilder sb = new StringBuilder ();
5944: sb.append (header);
5945:
5946: for (int a = startAddress; a <= endAddress; a += lineLength) {
5947:
5948: XEiJ.fmtHex8 (sb, a);
5949:
5950: for (int i = 0; i < byteCount; i++) {
5951: if (a + i <= endAddress) {
5952: byteArray[i] = MC68060.mmuPeekByteSign (a + i, functionCode);
5953: } else {
5954: byteArray[i] = 0;
5955: }
5956: }
5957:
5958: for (int i = 0; i < lineLength; i++) {
5959: if (i % (groupLength * 4) == 0) {
5960: sb.append (" ");
5961: } else if (i % groupLength == 0) {
5962: sb.append (" ");
5963: }
5964: if (a + i <= endAddress) {
5965: XEiJ.fmtHex2 (sb, byteArray[i]);
5966: } else {
5967: sb.append (" ");
5968: }
5969: }
5970: sb.append (" ");
5971: if (tempF == null) {
5972:
5973: int iStart;
5974: if (straddleChar == 0) {
5975: sb.append ('|');
5976: iStart = 0;
5977: } else {
5978: sb.append ((char) straddleChar);
5979: iStart = 1;
5980: }
5981: straddleChar = 0;
5982: for (int i = iStart; i < lineLength; i++) {
5983: int h = byteArray[i] & 255;
5984: int l = i + 1 < lineLength ? byteArray[i + 1] & 255 : 0;
5985: int c;
5986: if (((0x81 <= h && h <= 0x9f) || (0xe0 <= h && h <= 0xef)) &&
5987: ((0x40 <= l && l <= 0x7e) || (0x80 <= l && l <= 0xfc))) {
5988: c = CharacterCode.chrSJISToChar[h << 8 | l];
5989: if (c == 0) {
5990: c = a + i <= endAddress ? '※' : ' ';
5991: }
5992: i++;
5993: if (i == lineLength) {
5994: straddleChar = c;
5995: }
5996: } else {
5997: c = CharacterCode.chrSJISToChar[h];
5998: if (c < 0x20 || c == 0x7f) {
5999: c = a + i <= endAddress ? '.' : ' ';
6000: }
6001: }
6002: sb.append ((char) c);
6003: }
6004: if (straddleChar == 0) {
6005: sb.append ('|');
6006: }
6007: } else {
6008:
6009: switch (size) {
6010: case 's':
6011: sb.append (tempF.setf0 (byteArray, 0).toString ());
6012: break;
6013: case 'd':
6014: sb.append (tempF.setd01 (byteArray, 0).toString ());
6015: break;
6016: case 'x':
6017: sb.append (tempF.setx012 (byteArray, 0).toString ());
6018: break;
6019: case 't':
6020: sb.append (tempF.sety012 (byteArray, 0).toString ());
6021: break;
6022: case 'p':
6023: sb.append (tempF.setp012 (byteArray, 0).toString ());
6024: break;
6025: }
6026: straddleChar = 0;
6027: }
6028: sb.append ('\n');
6029: }
6030: DebugConsole.dgtPrint (sb.toString ());
6031:
6032: DebugConsole.dgtDumpAddress = endAddress + 1;
6033: DebugConsole.dgtDumpFunctionCode = functionCode;
6034: DebugConsole.dgtDumpStraddleChar = straddleChar;
6035: }
6036: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6037: return sb.append ("d").append ((char) elem.exlSubscript);
6038: }
6039: },
6040:
6041:
6042:
6043:
6044: ETY_COMMAND_FILL {
6045: @Override protected int etyPriority () {
6046: return EPY_PRIORITY_COMMAND;
6047: }
6048: @Override protected void etyEval (ExpressionElement elem, int mode) {
6049: int size = elem.exlSubscript;
6050:
6051: ExpressionElement[] paramArray = elem.exlParamX.exlEvalCommaList (mode);
6052:
6053: int startAddress;
6054: int functionCode;
6055: ExpressionElement param0 = paramArray[0];
6056: if (param0.exlValueType != ElementType.ETY_FLOAT) {
6057: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6058: "開始アドレスが間違っています" :
6059: "wrong start address");
6060: return;
6061: }
6062: if (param0.exlType == ElementType.ETY_OPERATOR_AT) {
6063: startAddress = param0.exlParamX.exlFloatValue.geti32 ();
6064: functionCode = param0.exlParamY.exlFloatValue.geti32 () & 7;
6065: } else {
6066: startAddress = param0.exlFloatValue.geti32 ();
6067: functionCode = XEiJ.regSRS == 0 ? 1 : 5;
6068: }
6069:
6070: int endAddress;
6071: ExpressionElement param1 = paramArray[1];
6072: if (param1.exlValueType != ElementType.ETY_FLOAT) {
6073: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6074: "終了アドレスが間違っています" :
6075: "wrong end address");
6076: return;
6077: }
6078: endAddress = param1.exlFloatValue.geti32 ();
6079:
6080: int dataCount = paramArray.length - 2;
6081: int byteCount;
6082: byte[] byteArray;
6083: if (dataCount == 1 &&
6084: size == 'b' &&
6085: paramArray[2].exlValueType == ElementType.ETY_STRING) {
6086:
6087: String s = paramArray[2].exlStringValue;
6088: byteArray = new byte[2 * s.length ()];
6089: byteCount = ByteArray.byaWstr (byteArray, 0, s);
6090: } else {
6091:
6092: EFPBox.EFP[] dataArray = new EFPBox.EFP[dataCount];
6093: for (int i = 0; i < dataCount; i++) {
6094: ExpressionElement param = paramArray[2 + i];
6095: if (param.exlValueType != ElementType.ETY_FLOAT) {
6096: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6097: "データが間違っています" :
6098: "wrong data");
6099: return;
6100: }
6101: dataArray[i] = param.exlFloatValue;
6102: }
6103:
6104: switch (size) {
6105: case 'b':
6106: byteCount = 1 * dataCount;
6107: byteArray = new byte[byteCount];
6108: for (int i = 0; i < dataCount; i++) {
6109: byteArray[i] = (byte) dataArray[i].geti32 ();
6110: }
6111: break;
6112: case 'w':
6113: byteCount = 2 * dataCount;
6114: byteArray = new byte[byteCount];
6115: for (int i = 0; i < dataCount; i++) {
6116: int t = dataArray[i].geti32 ();
6117: byteArray[2 * i] = (byte) (t >> 8);
6118: byteArray[2 * i + 1] = (byte) t;
6119: }
6120: break;
6121: case 'l':
6122: byteCount = 4 * dataCount;
6123: byteArray = new byte[byteCount];
6124: for (int i = 0; i < dataCount; i++) {
6125: int t = dataArray[i].geti32 ();
6126: byteArray[4 * i] = (byte) (t >> 24);
6127: byteArray[4 * i + 1] = (byte) (t >> 16);
6128: byteArray[4 * i + 2] = (byte) (t >> 8);
6129: byteArray[4 * i + 3] = (byte) t;
6130: }
6131: break;
6132: case 'q':
6133: byteCount = 8 * dataCount;
6134: byteArray = new byte[byteCount];
6135: for (int i = 0; i < dataCount; i++) {
6136: long t = dataArray[i].geti64 ();
6137: byteArray[8 * i] = (byte) (t >> 56);
6138: byteArray[8 * i + 1] = (byte) (t >> 48);
6139: byteArray[8 * i + 2] = (byte) (t >> 40);
6140: byteArray[8 * i + 3] = (byte) (t >> 32);
6141: byteArray[8 * i + 4] = (byte) (t >> 24);
6142: byteArray[8 * i + 5] = (byte) (t >> 16);
6143: byteArray[8 * i + 6] = (byte) (t >> 8);
6144: byteArray[8 * i + 7] = (byte) t;
6145: }
6146: break;
6147: case 's':
6148: byteCount = 4 * dataCount;
6149: byteArray = new byte[byteCount];
6150: for (int i = 0; i < dataCount; i++) {
6151: dataArray[i].getf0 (byteArray, 4 * i);
6152: }
6153: break;
6154: case 'd':
6155: byteCount = 8 * dataCount;
6156: byteArray = new byte[byteCount];
6157: for (int i = 0; i < dataCount; i++) {
6158: dataArray[i].getd01 (byteArray, 8 * i);
6159: }
6160: break;
6161: case 'x':
6162: byteCount = 12 * dataCount;
6163: byteArray = new byte[byteCount];
6164: for (int i = 0; i < dataCount; i++) {
6165: dataArray[i].getx012 (byteArray, 12 * i);
6166: }
6167: break;
6168: case 't':
6169: byteCount = 12 * dataCount;
6170: byteArray = new byte[byteCount];
6171: for (int i = 0; i < dataCount; i++) {
6172: dataArray[i].gety012 (byteArray, 12 * i);
6173: }
6174: break;
6175: case 'p':
6176: byteCount = 12 * dataCount;
6177: byteArray = new byte[byteCount];
6178: for (int i = 0; i < dataCount; i++) {
6179: dataArray[i].getp012 (byteArray, 12 * i);
6180: }
6181: break;
6182: default:
6183: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6184: "サイズが間違っています" :
6185: "wrong size");
6186: return;
6187: }
6188: }
6189:
6190: for (int a = startAddress; a <= endAddress; a += byteCount) {
6191: for (int i = 0; i < byteCount; i++) {
6192: if (a + i <= endAddress) {
6193: MC68060.mmuPokeByte (a + i, byteArray[i], functionCode);
6194: }
6195: }
6196: }
6197: }
6198: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6199: return sb.append ("f").append ((char) elem.exlSubscript);
6200: }
6201: },
6202:
6203:
6204:
6205: ETY_COMMAND_RUN {
6206: @Override protected int etyPriority () {
6207: return EPY_PRIORITY_COMMAND;
6208: }
6209: @Override protected void etyEval (ExpressionElement elem, int mode) {
6210: if (XEiJ.mpuTask != null) {
6211: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6212: "MPU が動作しています" :
6213: "MPU is running");
6214: return;
6215: }
6216: if (elem.exlParamX != null) {
6217:
6218: ExpressionElement[] paramArray = elem.exlParamX.exlEvalCommaList (mode);
6219: if (0 < paramArray.length) {
6220: ExpressionElement param0 = paramArray[0];
6221: if (param0.exlValueType == ElementType.ETY_FLOAT) {
6222:
6223: XEiJ.regPC = param0.exlFloatValue.geti32 ();
6224: }
6225: }
6226: }
6227: XEiJ.mpuStart ();
6228: }
6229: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6230: sb.append ("g");
6231: if (elem.exlParamX != null) {
6232: elem.exlParamX.exlAppendTo (sb.append (' '));
6233: }
6234: return sb;
6235: }
6236: },
6237:
6238:
6239:
6240: ETY_COMMAND_HELP {
6241: @Override protected int etyPriority () {
6242: return EPY_PRIORITY_COMMAND;
6243: }
6244: @Override protected void etyEval (ExpressionElement elem, int mode) {
6245: DebugConsole.dgtPageList = new LinkedList<String> (
6246: Arrays.asList (Multilingual.mlnJapanese ? EVX_HELP_MESSAGE_JA : EVX_HELP_MESSAGE_EN));
6247: DebugConsole.dgtPrintPage ();
6248: }
6249: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6250: return sb.append ("h");
6251: }
6252: },
6253:
6254:
6255:
6256: ETY_COMMAND_STOP {
6257: @Override protected int etyPriority () {
6258: return EPY_PRIORITY_COMMAND;
6259: }
6260: @Override protected void etyEval (ExpressionElement elem, int mode) {
6261: if (XEiJ.mpuTask == null) {
6262: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6263: "MPU は停止しています" :
6264: "MPU is not running");
6265: return;
6266: }
6267: if (RootPointerList.RTL_ON) {
6268: if (RootPointerList.rtlCurrentSupervisorTaskIsStoppable ||
6269: RootPointerList.rtlCurrentUserTaskIsStoppable) {
6270: DebugConsole.dgtRequestRegs = 5;
6271: XEiJ.mpuStop (null);
6272: }
6273: } else {
6274: DebugConsole.dgtRequestRegs = 5;
6275: XEiJ.mpuStop (null);
6276: }
6277: }
6278: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6279: return sb.append ("i");
6280: }
6281: },
6282:
6283:
6284:
6285: ETY_COMMAND_LIST {
6286: @Override protected int etyPriority () {
6287: return EPY_PRIORITY_COMMAND;
6288: }
6289: @Override protected void etyEval (ExpressionElement elem, int mode) {
6290: if (DebugConsole.dgtDisassemblePC == 0) {
6291: DebugConsole.dgtDisassemblePC = XEiJ.regPC;
6292: DebugConsole.dgtDisassembleLastTail = XEiJ.regPC + 31 & -32;
6293: }
6294: int headAddress = DebugConsole.dgtDisassemblePC;
6295: int tailAddress = DebugConsole.dgtDisassembleLastTail + 32;
6296: if (elem.exlParamX != null) {
6297: ExpressionElement[] list = elem.exlParamX.exlEvalCommaList (mode);
6298: if (0 < list.length) {
6299: ExpressionElement param = list[0];
6300: if (param.exlType == ElementType.ETY_OPERATOR_AT) {
6301: headAddress = DebugConsole.dgtDisassemblePC = param.exlParamX.exlFloatValue.geti32 ();
6302: tailAddress = headAddress + 63 & -32;
6303: DebugConsole.dgtDisassembleFC = param.exlParamY.exlFloatValue.geti32 ();
6304: } else if (param.exlValueType == ElementType.ETY_FLOAT) {
6305: headAddress = DebugConsole.dgtDisassemblePC = param.exlFloatValue.geti32 ();
6306: tailAddress = headAddress + 63 & -32;
6307: DebugConsole.dgtDisassembleFC = XEiJ.regSRS == 0 ? 2 : 6;
6308: }
6309: if (1 < list.length) {
6310: param = list[1];
6311: if (param.exlType == ElementType.ETY_OPERATOR_AT) {
6312: tailAddress = param.exlParamX.exlFloatValue.geti32 ();
6313: } else if (param.exlValueType == ElementType.ETY_FLOAT) {
6314: tailAddress = param.exlFloatValue.geti32 ();
6315: }
6316: if (Integer.compareUnsigned (tailAddress, headAddress) < 0) {
6317: tailAddress = headAddress;
6318: }
6319: tailAddress = tailAddress + 2 & -2;
6320: }
6321: }
6322: }
6323: int supervisor = DebugConsole.dgtDisassembleFC & 4;
6324:
6325:
6326: boolean prevBranchFlag = false;
6327:
6328: StringBuilder sb = new StringBuilder ();
6329: int itemAddress = headAddress;
6330: int itemEndAddress;
6331: do {
6332:
6333: if (prevBranchFlag) {
6334: sb.append ('\n');
6335:
6336: int l = sb.length ();
6337: LabeledAddress.lblSearch (sb, itemAddress);
6338: if (l < sb.length ()) {
6339: sb.append ('\n');
6340: }
6341: }
6342:
6343: String code = Disassembler.disDisassemble (new StringBuilder (), itemAddress, supervisor).toString ();
6344: itemEndAddress = Disassembler.disPC;
6345:
6346: int lineAddress = itemAddress;
6347: int lineEndAddress = Math.min (lineAddress + 10, itemEndAddress);
6348:
6349: XEiJ.fmtHex8 (sb, lineAddress).append (" ");
6350:
6351: for (int a = lineAddress; a < lineEndAddress; a += 2) {
6352: XEiJ.fmtHex4 (sb, MC68060.mmuPeekWordZeroCode (a, supervisor));
6353: }
6354: sb.append (XEiJ.DBG_SPACES, 0, 2 * Math.max (0, lineAddress + 10 - lineEndAddress) + 2);
6355:
6356: sb.append (code).append (XEiJ.DBG_SPACES, 0, Math.max (1, 68 - 32 - code.length ()));
6357:
6358: for (int a = lineAddress; a < lineEndAddress; a++) {
6359: int h = MC68060.mmuPeekByteZeroCode (a, supervisor);
6360: int c;
6361: if (0x81 <= h && h <= 0x9f || 0xe0 <= h && h <= 0xef) {
6362: int l = MC68060.mmuPeekByteZeroCode (a + 1, supervisor);
6363: if (0x40 <= l && l != 0x7f && l <= 0xfc) {
6364: c = CharacterCode.chrSJISToChar[h << 8 | l];
6365: if (c == 0) {
6366: c = '※';
6367: }
6368: a++;
6369: } else {
6370: c = '.';
6371: }
6372: } else {
6373: c = CharacterCode.chrSJISToChar[h];
6374: if (c < 0x20 || c == 0x7f) {
6375: c = '.';
6376: }
6377: }
6378: sb.append ((char) c);
6379: }
6380: sb.append ('\n');
6381:
6382: while (lineEndAddress < itemEndAddress) {
6383: lineAddress = lineEndAddress;
6384: lineEndAddress = Math.min (lineAddress + 10, itemEndAddress);
6385:
6386: XEiJ.fmtHex8 (sb, lineAddress).append (" ");
6387:
6388: for (int a = lineAddress; a < lineEndAddress; a += 2) {
6389: XEiJ.fmtHex4 (sb, MC68060.mmuPeekWordZeroCode (a, supervisor));
6390: }
6391: sb.append (XEiJ.DBG_SPACES, 0, 2 * Math.max (0, lineAddress + 10 - lineEndAddress) + (2 + 68 - 32));
6392:
6393: for (int a = lineAddress; a < lineEndAddress; a++) {
6394: int h = MC68060.mmuPeekByteZeroCode (a, supervisor);
6395: int c;
6396: if (0x81 <= h && h <= 0x9f || 0xe0 <= h && h <= 0xef) {
6397: int l = MC68060.mmuPeekByteZeroCode (a + 1, supervisor);
6398: if (0x40 <= l && l != 0x7f && l <= 0xfc) {
6399: c = CharacterCode.chrSJISToChar[h << 8 | l];
6400: if (c == 0) {
6401: c = '※';
6402: }
6403: a++;
6404: } else {
6405: c = '.';
6406: }
6407: } else {
6408: c = CharacterCode.chrSJISToChar[h];
6409: if (c < 0x20 || c == 0x7f) {
6410: c = '.';
6411: }
6412: }
6413: sb.append ((char) c);
6414: }
6415: sb.append ('\n');
6416: }
6417:
6418: prevBranchFlag = (Disassembler.disStatus & Disassembler.DIS_ALWAYS_BRANCH) != 0;
6419: itemAddress = itemEndAddress;
6420: } while (itemAddress - headAddress < tailAddress - headAddress);
6421: DebugConsole.dgtPrint (sb.toString ());
6422: DebugConsole.dgtDisassemblePC = itemEndAddress;
6423: DebugConsole.dgtDisassembleLastTail = tailAddress;
6424: }
6425: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6426: sb.append ("l");
6427: if (elem.exlParamX != null) {
6428: elem.exlParamX.exlAppendTo (sb.append (' '));
6429: }
6430: return sb;
6431: }
6432: },
6433:
6434:
6435:
6436: ETY_COMMAND_LABEL_LIST {
6437: @Override protected int etyPriority () {
6438: return EPY_PRIORITY_COMMAND;
6439: }
6440: @Override protected void etyEval (ExpressionElement elem, int mode) {
6441: DebugConsole.dgtPrint (LabeledAddress.lblDump ());
6442: }
6443: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6444: return sb.append ("ll");
6445: }
6446: },
6447:
6448:
6449:
6450: ETY_COMMAND_MEMORY_EDIT {
6451: @Override protected int etyPriority () {
6452: return EPY_PRIORITY_COMMAND;
6453: }
6454: @Override protected void etyEval (ExpressionElement elem, int mode) {
6455: int size = elem.exlSubscript;
6456:
6457: ExpressionElement[] paramArray = elem.exlParamX.exlEvalCommaList (mode);
6458:
6459: int startAddress;
6460: int functionCode;
6461: ExpressionElement param0 = paramArray[0];
6462: if (param0.exlValueType != ElementType.ETY_FLOAT) {
6463: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6464: "開始アドレスが間違っています" :
6465: "wrong start address");
6466: return;
6467: }
6468: if (param0.exlType == ElementType.ETY_OPERATOR_AT) {
6469: startAddress = param0.exlParamX.exlFloatValue.geti32 ();
6470: functionCode = param0.exlParamY.exlFloatValue.geti32 () & 7;
6471: } else {
6472: startAddress = param0.exlFloatValue.geti32 ();
6473: functionCode = XEiJ.regSRS == 0 ? 1 : 5;
6474: }
6475:
6476: int dataCount = paramArray.length - 1;
6477: int byteCount;
6478: byte[] byteArray;
6479: if (dataCount == 1 &&
6480: size == 'b' &&
6481: paramArray[1].exlValueType == ElementType.ETY_STRING) {
6482:
6483: String s = paramArray[1].exlStringValue;
6484: byteArray = new byte[2 * s.length ()];
6485: byteCount = ByteArray.byaWstr (byteArray, 0, s);
6486: } else {
6487:
6488: EFPBox.EFP[] dataArray = new EFPBox.EFP[dataCount];
6489: for (int i = 0; i < dataCount; i++) {
6490: ExpressionElement param = paramArray[1 + i];
6491: if (param.exlValueType != ElementType.ETY_FLOAT) {
6492: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6493: "データが間違っています" :
6494: "wrong data");
6495: return;
6496: }
6497: dataArray[i] = param.exlFloatValue;
6498: }
6499:
6500: switch (size) {
6501: case 'b':
6502: byteCount = 1 * dataCount;
6503: byteArray = new byte[byteCount];
6504: for (int i = 0; i < dataCount; i++) {
6505: byteArray[i] = (byte) dataArray[i].geti32 ();
6506: }
6507: break;
6508: case 'w':
6509: byteCount = 2 * dataCount;
6510: byteArray = new byte[byteCount];
6511: for (int i = 0; i < dataCount; i++) {
6512: int t = dataArray[i].geti32 ();
6513: byteArray[2 * i] = (byte) (t >> 8);
6514: byteArray[2 * i + 1] = (byte) t;
6515: }
6516: break;
6517: case 'l':
6518: byteCount = 4 * dataCount;
6519: byteArray = new byte[byteCount];
6520: for (int i = 0; i < dataCount; i++) {
6521: int t = dataArray[i].geti32 ();
6522: byteArray[4 * i] = (byte) (t >> 24);
6523: byteArray[4 * i + 1] = (byte) (t >> 16);
6524: byteArray[4 * i + 2] = (byte) (t >> 8);
6525: byteArray[4 * i + 3] = (byte) t;
6526: }
6527: break;
6528: case 'q':
6529: byteCount = 8 * dataCount;
6530: byteArray = new byte[byteCount];
6531: for (int i = 0; i < dataCount; i++) {
6532: long t = dataArray[i].geti64 ();
6533: byteArray[8 * i] = (byte) (t >> 56);
6534: byteArray[8 * i + 1] = (byte) (t >> 48);
6535: byteArray[8 * i + 2] = (byte) (t >> 40);
6536: byteArray[8 * i + 3] = (byte) (t >> 32);
6537: byteArray[8 * i + 4] = (byte) (t >> 24);
6538: byteArray[8 * i + 5] = (byte) (t >> 16);
6539: byteArray[8 * i + 6] = (byte) (t >> 8);
6540: byteArray[8 * i + 7] = (byte) t;
6541: }
6542: break;
6543: case 's':
6544: byteCount = 4 * dataCount;
6545: byteArray = new byte[byteCount];
6546: for (int i = 0; i < dataCount; i++) {
6547: dataArray[i].getf0 (byteArray, 4 * i);
6548: }
6549: break;
6550: case 'd':
6551: byteCount = 8 * dataCount;
6552: byteArray = new byte[byteCount];
6553: for (int i = 0; i < dataCount; i++) {
6554: dataArray[i].getd01 (byteArray, 8 * i);
6555: }
6556: break;
6557: case 'x':
6558: byteCount = 12 * dataCount;
6559: byteArray = new byte[byteCount];
6560: for (int i = 0; i < dataCount; i++) {
6561: dataArray[i].getx012 (byteArray, 12 * i);
6562: }
6563: break;
6564: case 't':
6565: byteCount = 12 * dataCount;
6566: byteArray = new byte[byteCount];
6567: for (int i = 0; i < dataCount; i++) {
6568: dataArray[i].gety012 (byteArray, 12 * i);
6569: }
6570: break;
6571: case 'p':
6572: byteCount = 12 * dataCount;
6573: byteArray = new byte[byteCount];
6574: for (int i = 0; i < dataCount; i++) {
6575: dataArray[i].getp012 (byteArray, 12 * i);
6576: }
6577: break;
6578: default:
6579: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6580: "サイズが間違っています" :
6581: "wrong size");
6582: return;
6583: }
6584: }
6585:
6586: for (int i = 0; i < byteCount; i++) {
6587: MC68060.mmuPokeByte (startAddress + i, byteArray[i], functionCode);
6588: }
6589: }
6590: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6591: return sb.append ("me").append ((char) elem.exlSubscript);
6592: }
6593: },
6594:
6595:
6596:
6597:
6598: ETY_COMMAND_MEMORY_SEARCH {
6599: @Override protected int etyPriority () {
6600: return EPY_PRIORITY_COMMAND;
6601: }
6602: @Override protected void etyEval (ExpressionElement elem, int mode) {
6603: int size = elem.exlSubscript;
6604:
6605: ExpressionElement[] paramArray = elem.exlParamX.exlEvalCommaList (mode);
6606:
6607: int startAddress;
6608: int functionCode;
6609: ExpressionElement param0 = paramArray[0];
6610: if (param0.exlValueType != ElementType.ETY_FLOAT) {
6611: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6612: "開始アドレスが間違っています" :
6613: "wrong start address");
6614: return;
6615: }
6616: if (param0.exlType == ElementType.ETY_OPERATOR_AT) {
6617: startAddress = param0.exlParamX.exlFloatValue.geti32 ();
6618: functionCode = param0.exlParamY.exlFloatValue.geti32 () & 7;
6619: } else {
6620: startAddress = param0.exlFloatValue.geti32 ();
6621: functionCode = XEiJ.regSRS == 0 ? 1 : 5;
6622: }
6623:
6624: int endAddress;
6625: ExpressionElement param1 = paramArray[1];
6626: if (param1.exlType == ElementType.ETY_FLOAT) {
6627: endAddress = param1.exlFloatValue.geti32 ();
6628: } else {
6629: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6630: "終了アドレスが間違っています" :
6631: "wrong end address");
6632: return;
6633: }
6634:
6635: int dataCount = paramArray.length - 2;
6636: int byteCount;
6637: byte[] byteArray;
6638: if (dataCount == 1 &&
6639: size == 'b' &&
6640: paramArray[2].exlValueType == ElementType.ETY_STRING) {
6641:
6642: String s = paramArray[2].exlStringValue;
6643: byteArray = new byte[2 * s.length ()];
6644: byteCount = ByteArray.byaWstr (byteArray, 0, s);
6645: } else {
6646:
6647: EFPBox.EFP[] dataArray = new EFPBox.EFP[dataCount];
6648: for (int i = 0; i < dataCount; i++) {
6649: ExpressionElement param = paramArray[2 + i];
6650: if (param.exlValueType != ElementType.ETY_FLOAT) {
6651: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6652: "データが間違っています" :
6653: "wrong data");
6654: return;
6655: }
6656: dataArray[i] = param.exlFloatValue;
6657: }
6658:
6659: switch (size) {
6660: case 'b':
6661: byteCount = 1 * dataCount;
6662: byteArray = new byte[byteCount];
6663: for (int i = 0; i < dataCount; i++) {
6664: byteArray[i] = (byte) dataArray[i].geti32 ();
6665: }
6666: break;
6667: case 'w':
6668: byteCount = 2 * dataCount;
6669: byteArray = new byte[byteCount];
6670: for (int i = 0; i < dataCount; i++) {
6671: int t = dataArray[i].geti32 ();
6672: byteArray[2 * i] = (byte) (t >> 8);
6673: byteArray[2 * i + 1] = (byte) t;
6674: }
6675: break;
6676: case 'l':
6677: byteCount = 4 * dataCount;
6678: byteArray = new byte[byteCount];
6679: for (int i = 0; i < dataCount; i++) {
6680: int t = dataArray[i].geti32 ();
6681: byteArray[4 * i] = (byte) (t >> 24);
6682: byteArray[4 * i + 1] = (byte) (t >> 16);
6683: byteArray[4 * i + 2] = (byte) (t >> 8);
6684: byteArray[4 * i + 3] = (byte) t;
6685: }
6686: break;
6687: case 'q':
6688: byteCount = 8 * dataCount;
6689: byteArray = new byte[byteCount];
6690: for (int i = 0; i < dataCount; i++) {
6691: long t = dataArray[i].geti64 ();
6692: byteArray[8 * i] = (byte) (t >> 56);
6693: byteArray[8 * i + 1] = (byte) (t >> 48);
6694: byteArray[8 * i + 2] = (byte) (t >> 40);
6695: byteArray[8 * i + 3] = (byte) (t >> 32);
6696: byteArray[8 * i + 4] = (byte) (t >> 24);
6697: byteArray[8 * i + 5] = (byte) (t >> 16);
6698: byteArray[8 * i + 6] = (byte) (t >> 8);
6699: byteArray[8 * i + 7] = (byte) t;
6700: }
6701: break;
6702: case 's':
6703: byteCount = 4 * dataCount;
6704: byteArray = new byte[byteCount];
6705: for (int i = 0; i < dataCount; i++) {
6706: dataArray[i].getf0 (byteArray, 4 * i);
6707: }
6708: break;
6709: case 'd':
6710: byteCount = 8 * dataCount;
6711: byteArray = new byte[byteCount];
6712: for (int i = 0; i < dataCount; i++) {
6713: dataArray[i].getd01 (byteArray, 8 * i);
6714: }
6715: break;
6716: case 'x':
6717: byteCount = 12 * dataCount;
6718: byteArray = new byte[byteCount];
6719: for (int i = 0; i < dataCount; i++) {
6720: dataArray[i].getx012 (byteArray, 12 * i);
6721: }
6722: break;
6723: case 't':
6724: byteCount = 12 * dataCount;
6725: byteArray = new byte[byteCount];
6726: for (int i = 0; i < dataCount; i++) {
6727: dataArray[i].gety012 (byteArray, 12 * i);
6728: }
6729: break;
6730: case 'p':
6731: byteCount = 12 * dataCount;
6732: byteArray = new byte[byteCount];
6733: for (int i = 0; i < dataCount; i++) {
6734: dataArray[i].getp012 (byteArray, 12 * i);
6735: }
6736: break;
6737: default:
6738: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6739: "サイズが間違っています" :
6740: "wrong size");
6741: return;
6742: }
6743: }
6744: if (byteCount <= 0) {
6745: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6746: "データがありません" :
6747: "no data");
6748: return;
6749: }
6750:
6751: StringBuilder sb = new StringBuilder ();
6752: int count = 0;
6753: for_a:
6754: for (int a = startAddress; a <= endAddress + 1 - byteCount; a++) {
6755: for (int i = 0; i < byteCount; i++) {
6756: if (MC68060.mmuPeekByteSign (a + i, functionCode) != byteArray[i]) {
6757: continue for_a;
6758: }
6759: }
6760: XEiJ.fmtHex8 (sb, a);
6761: sb.append ('\n');
6762: count++;
6763: if (count == 1000) {
6764: break;
6765: }
6766: }
6767: DebugConsole.dgtPrint (sb.toString ());
6768: if (count == 0) {
6769: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6770: "見つかりません" :
6771: "not found");
6772: } else if (count < 1000) {
6773: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6774: count + "個見つかりました" :
6775: count + " found");
6776: } else {
6777: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6778: count + "個以上見つかりました" :
6779: count + " or more found");
6780: }
6781: }
6782: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6783: return sb.append ("ms").append ((char) elem.exlSubscript);
6784: }
6785: },
6786:
6787:
6788:
6789: ETY_COMMAND_PRINT {
6790: @Override protected int etyPriority () {
6791: return EPY_PRIORITY_COMMAND;
6792: }
6793: @Override protected void etyEval (ExpressionElement elem, int mode) {
6794: if (elem.exlParamX != null) {
6795: for (ExpressionElement param : elem.exlParamX.exlEvalCommaList (mode)) {
6796: param.exlPrint ();
6797: }
6798: }
6799: DebugConsole.dgtPrintChar ('\n');
6800: }
6801: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6802: sb.append ("p");
6803: if (elem.exlParamX != null) {
6804: elem.exlParamX.exlAppendTo (sb.append (' '));
6805: }
6806: return sb;
6807: }
6808: },
6809:
6810:
6811:
6812: ETY_COMMAND_RETURN {
6813: @Override protected int etyPriority () {
6814: return EPY_PRIORITY_COMMAND;
6815: }
6816: @Override protected void etyEval (ExpressionElement elem, int mode) {
6817: if (XEiJ.mpuTask == null) {
6818: DebugConsole.dgtRequestRegs = 5;
6819: XEiJ.mpuStepUntilReturn ();
6820: }
6821: }
6822: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6823: return sb.append ("r");
6824: }
6825: },
6826:
6827:
6828:
6829: ETY_COMMAND_STEP {
6830: @Override protected int etyPriority () {
6831: return EPY_PRIORITY_COMMAND;
6832: }
6833: @Override protected void etyEval (ExpressionElement elem, int mode) {
6834: if (XEiJ.mpuTask != null) {
6835: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6836: "MPU が動作しています" :
6837: "MPU is running");
6838: return;
6839: }
6840: int n = 1;
6841: if (elem.exlParamX != null) {
6842: ExpressionElement[] list = elem.exlParamX.exlEvalCommaList (mode);
6843: if (0 < list.length) {
6844: ExpressionElement param = list[0];
6845: if (param.exlValueType == ElementType.ETY_FLOAT) {
6846: n = Math.max (1, Math.min (1000, param.exlFloatValue.geti ()));
6847: }
6848: }
6849: }
6850: DebugConsole.dgtRequestRegs = 5;
6851: XEiJ.mpuStep (n);
6852: }
6853: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6854: return sb.append ("s");
6855: }
6856: },
6857:
6858:
6859:
6860: ETY_COMMAND_TRACE {
6861: @Override protected int etyPriority () {
6862: return EPY_PRIORITY_COMMAND;
6863: }
6864: @Override protected void etyEval (ExpressionElement elem, int mode) {
6865: if (XEiJ.mpuTask != null) {
6866: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6867: "MPU が動作しています" :
6868: "MPU is running");
6869: return;
6870: }
6871: int n = 1;
6872: if (elem.exlParamX != null) {
6873: ExpressionElement[] list = elem.exlParamX.exlEvalCommaList (mode);
6874: if (0 < list.length) {
6875: ExpressionElement param = list[0];
6876: if (param.exlValueType == ElementType.ETY_FLOAT) {
6877: n = Math.max (1, Math.min (1000, param.exlFloatValue.geti ()));
6878: }
6879: }
6880: }
6881: DebugConsole.dgtRequestRegs = 5;
6882: XEiJ.mpuAdvance (n);
6883: }
6884: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6885: return sb.append ("t");
6886: }
6887: },
6888:
6889:
6890:
6891: ETY_COMMAND_TRACE_REGS {
6892: @Override protected int etyPriority () {
6893: return EPY_PRIORITY_COMMAND;
6894: }
6895: @Override protected void etyEval (ExpressionElement elem, int mode) {
6896: if (XEiJ.mpuTask != null) {
6897: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6898: "MPU が動作しています" :
6899: "MPU is running");
6900: return;
6901: }
6902: int n = 1;
6903: if (elem.exlParamX != null) {
6904: ExpressionElement[] list = elem.exlParamX.exlEvalCommaList (mode);
6905: if (0 < list.length) {
6906: ExpressionElement param = list[0];
6907: if (param.exlValueType == ElementType.ETY_FLOAT) {
6908: n = Math.max (1, Math.min (1000, param.exlFloatValue.geti ()));
6909: }
6910: }
6911: }
6912: for (int i = 0; i < n; i++) {
6913: DebugConsole.dgtRequestRegs = i < n - 1 ? 1 : 5;
6914: XEiJ.mpuAdvance (1);
6915:
6916: while (DebugConsole.dgtRequestRegs != 0) {
6917: try {
6918: Thread.sleep (1L);
6919: } catch (InterruptedException ie) {
6920: }
6921: }
6922: }
6923: }
6924: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6925: return sb.append ("tx");
6926: }
6927: },
6928:
6929:
6930:
6931: ETY_COMMAND_TRACE_FLOAT_REGS {
6932: @Override protected int etyPriority () {
6933: return EPY_PRIORITY_COMMAND;
6934: }
6935: @Override protected void etyEval (ExpressionElement elem, int mode) {
6936: if (XEiJ.mpuTask != null) {
6937: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
6938: "MPU が動作しています" :
6939: "MPU is running");
6940: return;
6941: }
6942: int n = 1;
6943: if (elem.exlParamX != null) {
6944: ExpressionElement[] list = elem.exlParamX.exlEvalCommaList (mode);
6945: if (0 < list.length) {
6946: ExpressionElement param = list[0];
6947: if (param.exlValueType == ElementType.ETY_FLOAT) {
6948: n = Math.max (1, Math.min (1000, param.exlFloatValue.geti ()));
6949: }
6950: }
6951: }
6952: for (int i = 0; i < n; i++) {
6953: DebugConsole.dgtRequestRegs = i < n - 1 ? 3 : 7;
6954: XEiJ.mpuAdvance (1);
6955:
6956: while (DebugConsole.dgtRequestRegs != 0) {
6957: try {
6958: Thread.sleep (1L);
6959: } catch (InterruptedException ie) {
6960: }
6961: }
6962: }
6963: }
6964: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
6965: return sb.append ("txf");
6966: }
6967: },
6968:
6969:
6970:
6971: ETY_COMMAND_REGS {
6972: @Override protected int etyPriority () {
6973: return EPY_PRIORITY_COMMAND;
6974: }
6975: @Override protected void etyEval (ExpressionElement elem, int mode) {
6976: StringBuilder sb = new StringBuilder ();
6977:
6978: int pc = XEiJ.regPC;
6979: int srs = XEiJ.regSRS;
6980:
6981:
6982:
6983:
6984:
6985:
6986: XEiJ.fmtHex8 (sb.append ("PC:"), pc);
6987: XEiJ.fmtHex8 (sb.append (" USP:"), srs != 0 ? XEiJ.mpuUSP : XEiJ.regRn[15]);
6988: if (XEiJ.currentMPU < Model.MPU_MC68020) {
6989: XEiJ.fmtHex8 (sb.append (" SSP:"), srs != 0 ? XEiJ.regRn[15] : XEiJ.mpuISP);
6990: XEiJ.fmtHex4 (sb.append (" SR:"), XEiJ.regSRT1 | srs | XEiJ.regSRI | XEiJ.regCCR);
6991: } else if (XEiJ.currentMPU < Model.MPU_MC68LC040) {
6992: XEiJ.fmtHex8 (sb.append (" ISP:"), srs == 0 || XEiJ.regSRM != 0 ? XEiJ.mpuISP : XEiJ.regRn[15]);
6993: XEiJ.fmtHex8 (sb.append (" MSP:"), srs == 0 || XEiJ.regSRM == 0 ? XEiJ.mpuMSP : XEiJ.regRn[15]);
6994: XEiJ.fmtHex4 (sb.append (" SR:"), XEiJ.regSRT1 | XEiJ.regSRT0 | srs | XEiJ.regSRM | XEiJ.regSRI | XEiJ.regCCR);
6995: } else {
6996: XEiJ.fmtHex8 (sb.append (" SSP:"), srs != 0 ? XEiJ.regRn[15] : XEiJ.mpuISP);
6997: XEiJ.fmtHex4 (sb.append (" SR:"), XEiJ.regSRT1 | srs | XEiJ.regSRM | XEiJ.regSRI | XEiJ.regCCR);
6998: }
6999: sb.append (" X:").append (XEiJ.REG_CCRXMAP[XEiJ.regCCR]);
7000: sb.append (" N:").append (XEiJ.REG_CCRNMAP[XEiJ.regCCR]);
7001: sb.append (" Z:").append (XEiJ.REG_CCRZMAP[XEiJ.regCCR]);
7002: sb.append (" V:").append (XEiJ.REG_CCRVMAP[XEiJ.regCCR]);
7003: sb.append (" C:").append (XEiJ.REG_CCRCMAP[XEiJ.regCCR]);
7004: sb.append ('\n');
7005:
7006:
7007:
7008:
7009: sb.append ("HI:").append (XEiJ.MPU_CCCMAP[ 2 << 5 | XEiJ.regCCR]);
7010: sb.append (" LS:").append (XEiJ.MPU_CCCMAP[ 3 << 5 | XEiJ.regCCR]);
7011: sb.append (" CC(HS):").append (XEiJ.MPU_CCCMAP[ 4 << 5 | XEiJ.regCCR]);
7012: sb.append (" CS(LO):").append (XEiJ.MPU_CCCMAP[ 5 << 5 | XEiJ.regCCR]);
7013: sb.append (" NE:").append (XEiJ.MPU_CCCMAP[ 6 << 5 | XEiJ.regCCR]);
7014: sb.append (" EQ:").append (XEiJ.MPU_CCCMAP[ 7 << 5 | XEiJ.regCCR]);
7015: sb.append (" VC:").append (XEiJ.MPU_CCCMAP[ 8 << 5 | XEiJ.regCCR]);
7016: sb.append (" VS:").append (XEiJ.MPU_CCCMAP[ 9 << 5 | XEiJ.regCCR]);
7017: sb.append (" PL:").append (XEiJ.MPU_CCCMAP[10 << 5 | XEiJ.regCCR]);
7018: sb.append (" MI:").append (XEiJ.MPU_CCCMAP[11 << 5 | XEiJ.regCCR]);
7019: sb.append (" GE:").append (XEiJ.MPU_CCCMAP[12 << 5 | XEiJ.regCCR]);
7020: sb.append (" LT:").append (XEiJ.MPU_CCCMAP[13 << 5 | XEiJ.regCCR]);
7021: sb.append (" GT:").append (XEiJ.MPU_CCCMAP[14 << 5 | XEiJ.regCCR]);
7022: sb.append (" LE:").append (XEiJ.MPU_CCCMAP[15 << 5 | XEiJ.regCCR]);
7023: sb.append ('\n');
7024:
7025:
7026:
7027:
7028:
7029: XEiJ.fmtHex8 (sb.append ("D0:") , XEiJ.regRn[ 0]);
7030: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[ 1]);
7031: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[ 2]);
7032: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[ 3]);
7033: XEiJ.fmtHex8 (sb.append (" D4:"), XEiJ.regRn[ 4]);
7034: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[ 5]);
7035: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[ 6]);
7036: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[ 7]);
7037: sb.append ('\n');
7038: XEiJ.fmtHex8 (sb.append ("A0:") , XEiJ.regRn[ 8]);
7039: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[ 9]);
7040: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[10]);
7041: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[11]);
7042: XEiJ.fmtHex8 (sb.append (" A4:"), XEiJ.regRn[12]);
7043: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[13]);
7044: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[14]);
7045: XEiJ.fmtHex8 (sb.append (' ') , XEiJ.regRn[15]);
7046: sb.append ('\n');
7047: if (Model.MPU_MC68020 <= XEiJ.currentMPU) {
7048:
7049:
7050:
7051:
7052: sb.append ("SFC:").append ((char) ('0' + XEiJ.mpuSFC));
7053: sb.append (" DFC:").append ((char) ('0' + XEiJ.mpuDFC));
7054: XEiJ.fmtHex8 (sb.append (" VBR:"), XEiJ.mpuVBR);
7055: XEiJ.fmtHex8 (sb.append (" CACR:"), XEiJ.mpuCACR);
7056: if (Model.MPU_MC68LC040 <= XEiJ.currentMPU) {
7057: XEiJ.fmtHex8 (sb.append (" TCR:"), MC68060.mmuTCR);
7058: XEiJ.fmtHex8 (sb.append (" URP:"), MC68060.mmuURP);
7059: XEiJ.fmtHex8 (sb.append (" SRP:"), MC68060.mmuSRP);
7060: }
7061: sb.append ('\n');
7062:
7063:
7064:
7065:
7066: if (Model.MPU_MC68LC040 <= XEiJ.currentMPU) {
7067: XEiJ.fmtHex8 (sb.append ("ITT0:"), MC68060.mmuITT0);
7068: XEiJ.fmtHex8 (sb.append (" ITT1:"), MC68060.mmuITT1);
7069: XEiJ.fmtHex8 (sb.append (" DTT0:"), MC68060.mmuDTT0);
7070: XEiJ.fmtHex8 (sb.append (" DTT1:"), MC68060.mmuDTT1);
7071: XEiJ.fmtHex8 (sb.append (" PCR:"), XEiJ.mpuPCR);
7072: sb.append ('\n');
7073: }
7074: }
7075:
7076:
7077: {
7078: int l = sb.length ();
7079: LabeledAddress.lblSearch (sb, pc);
7080: if (l < sb.length ()) {
7081: sb.append ('\n');
7082: }
7083: }
7084:
7085: String code = Disassembler.disDisassemble (new StringBuilder (), pc, srs).toString ();
7086:
7087: XEiJ.fmtHex8 (sb, pc).append (" ");
7088:
7089: for (int a = pc; a < Disassembler.disPC; a += 2) {
7090: XEiJ.fmtHex4 (sb, MC68060.mmuPeekWordZeroCode (a, srs));
7091: }
7092: for (int a = Disassembler.disPC; a < pc + 10; a += 2) {
7093: sb.append (" ");
7094: }
7095:
7096: sb.append (" ").append (code).append ('\n');
7097: DebugConsole.dgtPrint (sb.toString ());
7098: }
7099: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7100: return sb.append ("x");
7101: }
7102: },
7103:
7104:
7105:
7106: ETY_COMMAND_FLOAT_REGS {
7107: @Override protected int etyPriority () {
7108: return EPY_PRIORITY_COMMAND;
7109: }
7110: @Override protected void etyEval (ExpressionElement elem, int mode) {
7111: if (XEiJ.currentMPU < Model.MPU_MC68020) {
7112: DebugConsole.dgtPrintln (Multilingual.mlnJapanese ?
7113: "浮動小数点レジスタはありません" :
7114: "no floating point register exists");
7115: return;
7116: }
7117: StringBuilder sb = new StringBuilder ();
7118:
7119:
7120:
7121:
7122: XEiJ.fmtHex8 (sb.append ("FPCR:"), XEiJ.fpuBox.epbFpcr);
7123: XEiJ.fmtHex8 (sb.append (" FPSR:"), XEiJ.fpuBox.epbFpsr);
7124: sb.append (" M:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 27 & 1)));
7125: sb.append (" Z:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 26 & 1)));
7126: sb.append (" I:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 25 & 1)));
7127: sb.append (" N:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 24 & 1)));
7128: sb.append (" B:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 15 & 1)));
7129: sb.append (" S:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 14 & 1)));
7130: sb.append (" E:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 13 & 1)));
7131: sb.append (" O:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 12 & 1)));
7132: sb.append (" U:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 11 & 1)));
7133: sb.append (" D:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 10 & 1)));
7134: sb.append (" X:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 9 & 1)));
7135: sb.append (" P:").append ((char) ('0' + (XEiJ.fpuBox.epbFpsr >> 8 & 1)));
7136: sb.append ('\n');
7137:
7138:
7139:
7140:
7141:
7142:
7143:
7144: for (int n = 0; n <= 7; n++) {
7145: String s = XEiJ.fpuFPn[n].toString ();
7146: sb.append ("FP").append (n).append (':').append (s);
7147: if ((n & 1) == 0) {
7148: sb.append (XEiJ.DBG_SPACES, 0, Math.max (0, 36 - s.length ()));
7149: } else {
7150: sb.append ('\n');
7151: }
7152: }
7153: DebugConsole.dgtPrint (sb.toString ());
7154: }
7155: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7156: return sb.append ("xf");
7157: }
7158: },
7159:
7160:
7161:
7162:
7163:
7164:
7165: ETY_LINE {
7166: @Override protected int etyPriority () {
7167: return EPY_PRIORITY_COMMAND;
7168: }
7169: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7170: if (elem.exlParamX != null) {
7171:
7172: elem.exlParamX.exlAppendTo (sb);
7173: }
7174: if (elem.exlParamX != null || elem.exlStringValue != null) {
7175:
7176: sb.append (' ');
7177: }
7178: if (elem.exlStringValue != null) {
7179:
7180: sb.append (elem.exlStringValue);
7181: if (0 <= elem.exlSubscript) {
7182:
7183: sb.append ('.').append ((char) elem.exlSubscript);
7184: }
7185: if (elem.exlParamY != null) {
7186:
7187: sb.append (' ');
7188:
7189: elem.exlParamY.exlAppendTo (sb);
7190: }
7191: }
7192: return sb;
7193: }
7194: },
7195:
7196:
7197:
7198:
7199:
7200:
7201:
7202:
7203:
7204:
7205:
7206:
7207:
7208:
7209:
7210:
7211:
7212:
7213:
7214:
7215:
7216:
7217:
7218: ETY_SEPARATOR {
7219: @Override protected int etyPriority () {
7220: return EPY_PRIORITY_SEPARATOR;
7221: }
7222: @Override protected void etyEval (ExpressionElement elem, int mode) {
7223: elem.exlParamX.exlEval (mode);
7224: elem.exlParamY.exlEval (mode);
7225: if (elem.exlParamY.exlType == ElementType.ETY_FLOAT) {
7226:
7227: elem.exlFloatValue.sete (elem.exlParamY.exlFloatValue);
7228: } else if (elem.exlParamY.exlType == ElementType.ETY_STRING) {
7229:
7230: elem.exlStringValue = elem.exlParamY.exlStringValue;
7231: }
7232: }
7233: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7234: return elem.exlAppendBinaryOperatorTo (sb, ";");
7235: }
7236: },
7237:
7238:
7239:
7240: ETY_TOKEN_EXCLAMATION_MARK,
7241:
7242: ETY_TOKEN_NUMBER_SIGN,
7243:
7244: ETY_TOKEN_PERCENT_SIGN,
7245:
7246:
7247: ETY_TOKEN_LEFT_PARENTHESIS,
7248: ETY_TOKEN_RIGHT_PARENTHESIS,
7249: ETY_TOKEN_ASTERISK,
7250: ETY_TOKEN_PLUS_SIGN,
7251: ETY_TOKEN_PLUS_PLUS,
7252: ETY_TOKEN_COMMA,
7253: ETY_TOKEN_HYPHEN_MINUS,
7254: ETY_TOKEN_MINUS_MINUS,
7255: ETY_TOKEN_FULL_STOP,
7256: ETY_TOKEN_SOLIDUS,
7257:
7258: ETY_TOKEN_COLON,
7259: ETY_TOKEN_SEMICOLON,
7260:
7261:
7262:
7263: ETY_TOKEN_QUESTION_MARK,
7264:
7265:
7266: ETY_TOKEN_LEFT_SQUARE_BRACKET,
7267:
7268: ETY_TOKEN_RIGHT_SQUARE_BRACKET,
7269:
7270:
7271:
7272:
7273: ETY_TOKEN_LEFT_CURLY_BRACKET,
7274:
7275: ETY_TOKEN_RIGHT_CURLY_BRACKET,
7276: ETY_TOKEN_TILDE,
7277:
7278:
7279:
7280:
7281:
7282:
7283:
7284: ETY_SIZE {
7285: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7286: return elem.exlParamX.exlAppendTo (sb).append ('.').append ((char) elem.exlSubscript);
7287: }
7288: },
7289:
7290:
7291:
7292:
7293: ETY_SCALE_FACTOR {
7294: @Override protected int etyPriority () {
7295: return EPY_PRIORITY_MULTIPLICATION;
7296: }
7297: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7298: return elem.exlAppendBinaryOperatorTo (sb, "*");
7299: }
7300: },
7301:
7302:
7303:
7304:
7305:
7306: ETY_K_FACTOR {
7307: @Override protected int etyPriority () {
7308: return EPY_PRIORITY_POSTFIX;
7309: }
7310: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7311: return elem.exlParamY.exlAppendTo (elem.exlParamX.exlAppendTo (sb).append ('{')).append ('}');
7312: }
7313: },
7314:
7315:
7316:
7317:
7318:
7319:
7320: ETY_BIT_FIELD {
7321: @Override protected int etyPriority () {
7322: return EPY_PRIORITY_POSTFIX;
7323: }
7324: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7325: return elem.exlParamZ.exlAppendTo (elem.exlParamY.exlAppendTo (elem.exlParamX.exlAppendTo (sb).append ('{')).append (':')).append ('}');
7326: }
7327: },
7328:
7329:
7330:
7331:
7332: ETY_REGISTER_INDIRECT {
7333: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7334: int r = elem.exlSubscript;
7335: sb.append ('(');
7336: if (r < 8) {
7337: sb.append ('d').append (r);
7338: } else if (r < 15) {
7339: sb.append ('a').append (r - 8);
7340: } else {
7341: sb.append ("sp");
7342: }
7343: return sb.append (')');
7344: }
7345: },
7346:
7347:
7348:
7349:
7350: ETY_POSTINCREMENT {
7351: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7352: int r = elem.exlSubscript;
7353: sb.append ('(');
7354: if (r < 7) {
7355: sb.append ('a').append (r);
7356: } else {
7357: sb.append ("sp");
7358: }
7359: return sb.append (")+");
7360: }
7361: },
7362:
7363:
7364:
7365:
7366: ETY_PREDECREMENT {
7367: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7368: int r = elem.exlSubscript;
7369: sb.append ("-(");
7370: if (r < 7) {
7371: sb.append ('a').append (r);
7372: } else {
7373: sb.append ("sp");
7374: }
7375: return sb.append (')');
7376: }
7377: },
7378:
7379:
7380:
7381:
7382: ETY_IMMEDIATE {
7383: @Override protected int etyPriority () {
7384: return EPY_PRIORITY_PREFIX;
7385: }
7386: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7387: return elem.exlAppendPrefixOperatorTo (sb, "#");
7388: }
7389: },
7390:
7391:
7392:
7393:
7394: ETY_DATA_REGISTER_PAIR {
7395: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7396: int subscript = elem.exlSubscript;
7397: int h = subscript >> 3;
7398: int l = subscript & 7;
7399: return sb.append ('d').append (h).append (":d").append (l);
7400: }
7401: },
7402:
7403:
7404:
7405:
7406: ETY_REGISTER_INDIRECT_PAIR {
7407: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7408: int subscript = elem.exlSubscript;
7409: int r = subscript >> 4;
7410: int s = subscript & 15;
7411: sb.append ('(');
7412: if (r < 8) {
7413: sb.append ('d').append (r);
7414: } else if (r < 15) {
7415: sb.append ('a').append (r - 8);
7416: } else {
7417: sb.append ("sp");
7418: }
7419: sb.append ("):(");
7420: if (s < 8) {
7421: sb.append ('d').append (s);
7422: } else if (s < 15) {
7423: sb.append ('a').append (s - 8);
7424: } else {
7425: sb.append ("sp");
7426: }
7427: return sb.append (')');
7428: }
7429: },
7430:
7431:
7432:
7433:
7434:
7435:
7436:
7437:
7438:
7439:
7440: ETY_INTEGER_REGISTER_LIST {
7441: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7442: int m = elem.exlSubscript;
7443: m = (m & 0x8000) << 2 | (m & 0x7f00) << 1 | (m & 0x00ff);
7444: boolean s = false;
7445: while (m != 0) {
7446: int i = Integer.numberOfTrailingZeros (m);
7447: m += 1 << i;
7448: int j = Integer.numberOfTrailingZeros (m);
7449: m -= 1 << j;
7450: j--;
7451: if (s) {
7452: sb.append ('/');
7453: }
7454: if (i <= 7) {
7455: sb.append ('d').append (i);
7456: } else if (i <= 16) {
7457: sb.append ('a').append (i - 9);
7458: } else {
7459: sb.append ("sp");
7460: }
7461: if (i < j) {
7462: sb.append ('-');
7463: if (j <= 7) {
7464: sb.append ('d').append (j);
7465: } else if (j <= 16) {
7466: sb.append ('a').append (j - 9);
7467: } else {
7468: sb.append ("sp");
7469: }
7470: }
7471: s = true;
7472: }
7473: return sb;
7474: }
7475: },
7476:
7477:
7478:
7479:
7480:
7481:
7482:
7483: ETY_FLOATING_POINT_REGISTER_LIST {
7484: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7485: int m = elem.exlSubscript;
7486: boolean s = false;
7487: while (m != 0) {
7488: int i = Integer.numberOfTrailingZeros (m);
7489: m += 1 << i;
7490: int j = Integer.numberOfTrailingZeros (m);
7491: m -= 1 << j;
7492: j--;
7493: if (s) {
7494: sb.append ('/');
7495: }
7496: sb.append ("fp").append (i);
7497: if (i < j) {
7498: sb.append ("-fp").append (j);
7499: }
7500: s = true;
7501: }
7502: return sb;
7503: }
7504: },
7505:
7506:
7507:
7508:
7509:
7510:
7511:
7512: ETY_FLOATING_POINT_CONTROL_REGISTER_LIST {
7513: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7514: int subscript = elem.exlSubscript;
7515: return sb.append (subscript == 1 ? "fpiar" :
7516: subscript == 2 ? "fpsr" :
7517: subscript == 3 ? "fpiar/fpsr" :
7518: subscript == 4 ? "fpcr" :
7519: subscript == 5 ? "fpiar/fpcr" :
7520: subscript == 6 ? "fpsr/fpcr" :
7521: subscript == 7 ? "fpiar/fpsr/fpcr" :
7522: "");
7523: }
7524: },
7525:
7526:
7527:
7528:
7529: ETY_LABEL_DEFINITION {
7530: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7531: return sb.append (elem.exlStringValue).append (':');
7532: }
7533: },
7534:
7535:
7536:
7537:
7538:
7539:
7540:
7541: ETY_LOCAL_LABEL_DEFINITION {
7542: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7543: if (elem.exlSubscript == 0) {
7544: sb.append ("@@");
7545: } else {
7546: sb.append (elem.exlSubscript);
7547: }
7548: return sb.append (':');
7549: }
7550: },
7551:
7552:
7553:
7554:
7555:
7556:
7557:
7558:
7559:
7560:
7561:
7562:
7563:
7564:
7565:
7566:
7567: ETY_LOCAL_LABEL_REFERENCE {
7568: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7569: int number = (char) elem.exlSubscript;
7570: int offset = elem.exlSubscript >> 16;
7571: if (number == 0) {
7572: for (int i = offset < 0 ? ~offset : offset; 0 <= i; i--) {
7573: sb.append ('@');
7574: }
7575: } else {
7576: sb.append (number);
7577: }
7578: return sb.append (offset < 0 ? 'B' : 'F');
7579: }
7580: },
7581:
7582:
7583:
7584:
7585: ETY_MNEMONIC {
7586: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7587: return sb.append (elem.exlStringValue);
7588: }
7589: },
7590:
7591:
7592:
7593:
7594:
7595: ETY_PARENTHESIS {
7596: @Override protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7597: return elem.exlParamX.exlAppendTo (sb.append ('(')).append (')');
7598: }
7599: },
7600:
7601:
7602: ETY_DUMMY;
7603:
7604: protected void etyEval (ExpressionElement elem, int mode) {
7605: }
7606:
7607: protected StringBuilder etyAppendTo (StringBuilder sb, ExpressionElement elem) {
7608: sb.append (name ()).append ('(');
7609: if (elem.exlParamX != null) {
7610: sb.append (elem.exlParamX.toString ());
7611: if (elem.exlParamY != null) {
7612: sb.append (',').append (elem.exlParamY.toString ());
7613: if (elem.exlParamZ != null) {
7614: sb.append (',').append (elem.exlParamZ.toString ());
7615: }
7616: }
7617: }
7618: return sb.append (')');
7619: }
7620:
7621: protected int etyPriority () {
7622: return EPY_PRIORITY_PRIMITIVE;
7623: }
7624:
7625: };
7626:
7627:
7628:
7629:
7630:
7631:
7632: protected class ExpressionElement {
7633:
7634:
7635:
7636:
7637: protected ElementType exlType;
7638: protected int exlSubscript;
7639: protected ElementType exlValueType;
7640: protected EFP exlFloatValue;
7641: protected String exlStringValue;
7642: protected String exlSource;
7643: protected int exlOffset;
7644: protected int exlLength;
7645: protected ExpressionElement exlParamX;
7646: protected ExpressionElement exlParamY;
7647: protected ExpressionElement exlParamZ;
7648:
7649:
7650:
7651:
7652: protected ExpressionElement (ElementType type, int subscript,
7653: ElementType valueType, EFP floatValue, String stringValue,
7654: String source, int offset, int length) {
7655: exlType = type;
7656: exlSubscript = subscript;
7657: exlValueType = valueType;
7658: exlFloatValue = floatValue == null ? new EFP () : new EFP (floatValue);
7659: exlStringValue = stringValue == null ? "" : stringValue;
7660: exlSource = source;
7661: exlOffset = offset;
7662: exlLength = length;
7663: exlParamX = null;
7664: exlParamY = null;
7665: exlParamZ = null;
7666: }
7667: protected ExpressionElement (ElementType type, int subscript,
7668: ElementType valueType, EFP floatValue, String stringValue,
7669: String source, int offset, int length,
7670: ExpressionElement paramX, ExpressionElement paramY, ExpressionElement paramZ) {
7671: exlType = type;
7672: exlSubscript = subscript;
7673: exlValueType = valueType;
7674: exlFloatValue = floatValue == null ? new EFP () : new EFP (floatValue);
7675: exlStringValue = stringValue == null ? "" : stringValue;
7676: exlSource = source;
7677: exlOffset = offset;
7678: exlLength = length;
7679: exlParamX = paramX;
7680: exlParamY = paramY;
7681: exlParamZ = paramZ;
7682: }
7683:
7684:
7685:
7686:
7687: protected ExpressionElement exlCopy () {
7688: ExpressionElement elem = new ExpressionElement (exlType, exlSubscript,
7689: exlValueType, new EFP (exlFloatValue), exlStringValue,
7690: exlSource, exlOffset, exlLength);
7691: if (exlParamX != null) {
7692: if (exlType == ElementType.ETY_VARIABLE_FLOAT ||
7693: exlType == ElementType.ETY_VARIABLE_STRING) {
7694: elem.exlParamX = exlParamX;
7695: } else {
7696: elem.exlParamX = exlParamX.exlCopy ();
7697: }
7698: }
7699: if (exlParamY != null) {
7700: elem.exlParamY = exlParamY.exlCopy ();
7701: }
7702: if (exlParamZ != null) {
7703: elem.exlParamZ = exlParamZ.exlCopy ();
7704: }
7705: return elem;
7706: }
7707:
7708:
7709:
7710:
7711: protected void exlSetRoundingPrec (int prec) {
7712: if (0 <= prec && prec <= 4) {
7713: epbRoundingPrec = prec;
7714: }
7715: }
7716:
7717:
7718:
7719:
7720: protected void exlSetRoundingMode (int mode) {
7721: if (0 <= mode && mode <= 3) {
7722: epbRoundingMode = mode;
7723: }
7724: }
7725:
7726:
7727:
7728:
7729: protected int exlReadRegByte (int n) {
7730: if (0 <= n && n <= 15) {
7731: return (byte) XEiJ.regRn[n];
7732: }
7733: return 0;
7734: }
7735:
7736: protected int exlReadRegWord (int n) {
7737: if (0 <= n && n <= 15) {
7738: return (short) XEiJ.regRn[n];
7739: }
7740: return 0;
7741: }
7742:
7743: protected int exlReadRegLong (int n) {
7744: if (0 <= n && n <= 15) {
7745: return XEiJ.regRn[n];
7746: }
7747: return 0;
7748: }
7749:
7750: protected void exlWriteRegByte (int n, int x) {
7751: if (0 <= n && n <= 15) {
7752: XEiJ.regRn[n] = XEiJ.regRn[n] & ~255 | x & 255;
7753: }
7754: }
7755:
7756: protected void exlWriteRegWord (int n, int x) {
7757: if (0 <= n && n <= 15) {
7758: XEiJ.regRn[n] = XEiJ.regRn[n] & ~65535 | x & 65535;
7759: }
7760: }
7761:
7762: protected void exlWriteRegLong (int n, int x) {
7763: if (0 <= n && n <= 15) {
7764: XEiJ.regRn[n] = x;
7765: }
7766: }
7767:
7768:
7769:
7770:
7771: protected EFP exlGetFPn (int n) {
7772: return ExpressionEvaluator.this.epbFPn[n];
7773: }
7774: protected void exlSetFPn (int n, EFPBox.EFP x) {
7775: ExpressionEvaluator.this.epbFPn[n].sete (x);
7776: }
7777:
7778:
7779:
7780:
7781: protected int exlReadPC () {
7782: return XEiJ.regPC;
7783: }
7784:
7785: protected int exlWritePC (int x) {
7786: return XEiJ.regPC = x;
7787: }
7788:
7789: protected int exlReadCCR () {
7790: return XEiJ.regCCR;
7791: }
7792:
7793: protected int exlWriteCCR (int x) {
7794: return XEiJ.regCCR = x &= XEiJ.REG_CCR_MASK;
7795: }
7796:
7797: protected int exlReadSR () {
7798: return XEiJ.regSRT1 | XEiJ.regSRT0 | XEiJ.regSRS | XEiJ.regSRM | XEiJ.regSRI | XEiJ.regCCR;
7799: }
7800:
7801: protected int exlWriteSR (int x) {
7802: XEiJ.regSRT1 = x & XEiJ.REG_SR_T1;
7803: XEiJ.regSRT0 = x & XEiJ.REG_SR_T0;
7804:
7805: XEiJ.regSRM = x & XEiJ.REG_SR_M;
7806: XEiJ.regSRI = x & XEiJ.REG_SR_I;
7807: XEiJ.regCCR = x & XEiJ.REG_CCR_MASK;
7808: return x &= XEiJ.REG_SR_T1 | XEiJ.REG_SR_T0 | XEiJ.REG_SR_M | XEiJ.REG_SR_I | XEiJ.REG_CCR_MASK;
7809: }
7810:
7811: protected int exlReadFloatControlRegister (int n) {
7812: switch (n & 7) {
7813: case 1:
7814: return XEiJ.fpuBox.epbFpiar;
7815: case 2:
7816: return XEiJ.fpuBox.epbFpsr;
7817: case 4:
7818: return XEiJ.fpuBox.epbFpcr;
7819: }
7820: return 0;
7821: }
7822:
7823: protected int exlWriteFloatControlRegister (int n, int x) {
7824: switch (n & 7) {
7825: case 1:
7826: return XEiJ.fpuBox.epbFpiar = x;
7827: case 2:
7828: return XEiJ.fpuBox.epbFpsr = x;
7829: case 4:
7830: return XEiJ.fpuBox.epbFpcr = x;
7831: }
7832: return x;
7833: }
7834:
7835: protected int exlReadControlRegister (int n) {
7836: switch ((char) n) {
7837: case 0x0000:
7838: return XEiJ.mpuSFC;
7839: case 0x0001:
7840: return XEiJ.mpuDFC;
7841: case 0x0002:
7842: return XEiJ.mpuCACR;
7843: case 0x0003:
7844: return MC68060.mmuTCR;
7845: case 0x0004:
7846: return MC68060.mmuITT0;
7847: case 0x0005:
7848: return MC68060.mmuITT1;
7849: case 0x0006:
7850: return MC68060.mmuDTT0;
7851: case 0x0007:
7852: return MC68060.mmuDTT1;
7853: case 0x0008:
7854: return XEiJ.mpuBUSCR;
7855: case 0x0800:
7856: return XEiJ.regSRS != 0 ? XEiJ.mpuUSP : XEiJ.regRn[15];
7857: case 0x0801:
7858: return XEiJ.mpuVBR;
7859: case 0x0802:
7860: return XEiJ.mpuCAAR;
7861: case 0x0803:
7862: return XEiJ.regSRS == 0 || XEiJ.regSRM == 0 ? XEiJ.mpuMSP : XEiJ.regRn[15];
7863: case 0x0804:
7864: return XEiJ.regSRS == 0 || XEiJ.regSRM != 0 ? XEiJ.mpuISP : XEiJ.regRn[15];
7865: case 0x0805:
7866: return 0;
7867: case 0x0806:
7868: return MC68060.mmuURP;
7869: case 0x0807:
7870: return MC68060.mmuSRP;
7871: case 0x0808:
7872: return XEiJ.mpuPCR;
7873: }
7874: return 0;
7875: }
7876:
7877: protected int exlWriteControlRegister (int n, int x) {
7878: switch ((char) n) {
7879: case 0x0000:
7880: return XEiJ.mpuSFC = x & 0x00000007;
7881: case 0x0001:
7882: return XEiJ.mpuDFC = x & 0x00000007;
7883: case 0x0002:
7884: return XEiJ.mpuCACR = x & (XEiJ.currentMPU < Model.MPU_MC68LC040 ? 0x00003f1f : 0xf8e0e000);
7885: case 0x0003:
7886: return MC68060.mmuTCR = x;
7887: case 0x0004:
7888: return MC68060.mmuITT0 = x;
7889: case 0x0005:
7890: return MC68060.mmuITT1 = x;
7891: case 0x0006:
7892: return MC68060.mmuDTT0 = x;
7893: case 0x0007:
7894: return MC68060.mmuDTT1 = x;
7895: case 0x0008:
7896: return XEiJ.mpuBUSCR = x & 0xf0000000;
7897: case 0x0800:
7898: return XEiJ.regSRS == 0 ? (XEiJ.regRn[15] = x) : (XEiJ.mpuUSP = x);
7899: case 0x0801:
7900: return XEiJ.mpuVBR = x & -4;
7901: case 0x0802:
7902: return XEiJ.mpuCAAR = x;
7903: case 0x0803:
7904: return XEiJ.regSRS == 0 || XEiJ.regSRM == 0 ? (XEiJ.mpuMSP = x) : (XEiJ.regRn[15] = x);
7905: case 0x0804:
7906: return XEiJ.regSRS == 0 || XEiJ.regSRM != 0 ? (XEiJ.mpuISP = x) : (XEiJ.regRn[15] = x);
7907: case 0x0805:
7908: return 0;
7909: case 0x0806:
7910: return MC68060.mmuURP = x;
7911: case 0x0807:
7912: return MC68060.mmuSRP = x;
7913: case 0x0808:
7914: return XEiJ.mpuPCR = 0x04300500 | XEiJ.MPU_060_REV << 8 | x & 0x00000083;
7915: }
7916: return x;
7917: }
7918:
7919:
7920:
7921:
7922:
7923:
7924: protected boolean exlIsFloatSubstituend () {
7925: return (exlType == ElementType.ETY_VARIABLE_FLOAT ||
7926:
7927: exlType == ElementType.ETY_INTEGER_REGISTER ||
7928: exlType == ElementType.ETY_FLOATING_POINT_REGISTER ||
7929: exlType == ElementType.ETY_PC ||
7930: exlType == ElementType.ETY_CCR ||
7931: exlType == ElementType.ETY_SR ||
7932: exlType == ElementType.ETY_FLOAT_CONTROL_REGISTER ||
7933: exlType == ElementType.ETY_CONTROL_REGISTER ||
7934: exlType == ElementType.ETY_SQUARE_BRACKET ||
7935: ((exlType == ElementType.ETY_OPERATOR_SIZE_BYTE ||
7936: exlType == ElementType.ETY_OPERATOR_SIZE_WORD ||
7937: exlType == ElementType.ETY_OPERATOR_SIZE_LONG ||
7938: exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE) &&
7939: (exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER ||
7940: exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET)) ||
7941: ((exlType == ElementType.ETY_OPERATOR_SIZE_QUAD ||
7942: exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE ||
7943: exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED ||
7944: exlType == ElementType.ETY_OPERATOR_SIZE_TRIPLE ||
7945: exlType == ElementType.ETY_OPERATOR_SIZE_PACKED) &&
7946: exlParamX.exlType == ElementType.ETY_SQUARE_BRACKET));
7947: }
7948:
7949:
7950:
7951:
7952:
7953: protected ExpressionElement exlEval (int mode) {
7954: exlType.etyEval (this, mode);
7955: return this;
7956: }
7957:
7958:
7959:
7960:
7961: protected int exlLengthOfCommaList () {
7962: return exlType == ElementType.ETY_OPERATOR_COMMA ? exlParamX.exlLengthOfCommaList () + 1 : 1;
7963: }
7964:
7965:
7966:
7967:
7968: protected ExpressionElement[] exlEvalCommaList (int mode) {
7969: return exlEvalCommaListSub (new ArrayList<ExpressionElement> (), mode).toArray (new ExpressionElement[0]);
7970: }
7971: protected ArrayList<ExpressionElement> exlEvalCommaListSub (ArrayList<ExpressionElement> list, int mode) {
7972: if (exlType == ElementType.ETY_OPERATOR_COMMA) {
7973: exlParamX.exlEvalCommaListSub (list, mode);
7974: list.add (exlParamY.exlEval (mode));
7975: } else {
7976: list.add (exlEval (mode));
7977: }
7978: return list;
7979: }
7980:
7981:
7982:
7983:
7984: protected LinkedList<ExpressionElement> exlToCommaList () {
7985: LinkedList<ExpressionElement> list = new LinkedList<ExpressionElement> ();
7986: ExpressionElement element = this;
7987: while (element.exlType == ElementType.ETY_OPERATOR_COMMA) {
7988: list.addFirst (element.exlParamY);
7989: element = element.exlParamX;
7990: }
7991: list.addFirst (element);
7992: return list;
7993: }
7994:
7995:
7996:
7997:
7998: protected LinkedList<ExpressionElement> exlToSeparatorList () {
7999: LinkedList<ExpressionElement> list = new LinkedList<ExpressionElement> ();
8000: ExpressionElement element = this;
8001: while (element.exlType == ElementType.ETY_SEPARATOR) {
8002: list.addFirst (element.exlParamY);
8003: element = element.exlParamX;
8004: }
8005: list.addFirst (element);
8006: return list;
8007: }
8008:
8009:
8010:
8011: protected void exlPrint () {
8012: switch (exlValueType) {
8013: case ETY_FLOAT:
8014: DebugConsole.dgtPrint (exlFloatValue.toString ());
8015: break;
8016: case ETY_STRING:
8017: DebugConsole.dgtPrint (exlStringValue);
8018: break;
8019: }
8020: }
8021:
8022:
8023:
8024:
8025: protected StringBuilder exlAppendTo (StringBuilder sb) {
8026: return exlType.etyAppendTo (sb, this);
8027: }
8028:
8029:
8030:
8031:
8032: protected StringBuilder exlAppendFunctionTo (StringBuilder sb, String funcName) {
8033: sb.append (funcName).append ('(');
8034: if (exlParamX != null) {
8035: exlParamX.exlAppendTo (sb);
8036: if (exlParamY != null) {
8037: exlParamY.exlAppendTo (sb.append (','));
8038: if (exlParamZ != null) {
8039: exlParamZ.exlAppendTo (sb.append (','));
8040: }
8041: }
8042: }
8043: return sb.append (')');
8044: }
8045:
8046:
8047:
8048:
8049:
8050: protected StringBuilder exlAppendPostfixOperatorTo (StringBuilder sb, String text) {
8051: if (exlParamX.exlType.etyPriority () <= exlType.etyPriority ()) {
8052: exlParamX.exlAppendTo (sb.append ('(')).append (')');
8053: } else {
8054: exlParamX.exlAppendTo (sb);
8055: }
8056: return sb.append (text);
8057: }
8058:
8059:
8060:
8061:
8062:
8063: protected StringBuilder exlAppendPrefixOperatorTo (StringBuilder sb, String text) {
8064: sb.append (text);
8065: if (exlParamX.exlType.etyPriority () <= exlType.etyPriority ()) {
8066: exlParamX.exlAppendTo (sb.append ('(')).append (')');
8067: } else {
8068: exlParamX.exlAppendTo (sb);
8069: }
8070: return sb;
8071: }
8072:
8073:
8074:
8075:
8076:
8077:
8078:
8079: protected StringBuilder exlAppendBinaryOperatorTo (StringBuilder sb, String text) {
8080: if (exlParamX.exlType.etyPriority () < exlType.etyPriority ()) {
8081: exlParamX.exlAppendTo (sb.append ('(')).append (')');
8082: } else {
8083: exlParamX.exlAppendTo (sb);
8084: }
8085: sb.append (text);
8086: if (exlParamY.exlType.etyPriority () <= exlType.etyPriority ()) {
8087: exlParamY.exlAppendTo (sb.append ('(')).append (')');
8088: } else {
8089: exlParamY.exlAppendTo (sb);
8090: }
8091: return sb;
8092: }
8093:
8094:
8095:
8096:
8097:
8098:
8099:
8100: protected StringBuilder exlAppendConditionalOperatorTo (StringBuilder sb, String text1, String text2) {
8101: if (exlParamX.exlType.etyPriority () <= exlType.etyPriority ()) {
8102: exlParamX.exlAppendTo (sb.append ('(')).append (')');
8103: } else {
8104: exlParamX.exlAppendTo (sb);
8105: }
8106: return exlParamZ.exlAppendTo (exlParamY.exlAppendTo (sb.append (text1)).append (text2));
8107: }
8108:
8109:
8110:
8111:
8112:
8113:
8114:
8115: protected StringBuilder exlAppendAssignmentOperatorTo (StringBuilder sb, String text) {
8116: if (exlParamX.exlType.etyPriority () <= exlType.etyPriority ()) {
8117: exlParamX.exlAppendTo (sb.append ('(')).append (')');
8118: } else {
8119: exlParamX.exlAppendTo (sb);
8120: }
8121: sb.append (text);
8122: if (exlParamY.exlType.etyPriority () < exlType.etyPriority ()) {
8123: exlParamY.exlAppendTo (sb.append ('(')).append (')');
8124: } else {
8125: exlParamY.exlAppendTo (sb);
8126: }
8127: return sb;
8128: }
8129:
8130:
8131:
8132:
8133: @Override public String toString () {
8134: return exlAppendTo (new StringBuilder ()).toString ();
8135: }
8136:
8137:
8138: }
8139:
8140:
8141:
8142:
8143:
8144: protected static void evxPrintError (String message, String source, int offset, int length) {
8145: StringBuilder sb = new StringBuilder ();
8146: sb.append (message).append ('\n');
8147: if (source != null) {
8148: if (offset == -1) {
8149: offset = source.length ();
8150: }
8151: int head = Math.max (0, offset - 20);
8152: int tail = Math.min (source.length (), offset + length + 20);
8153: sb.append (source.substring (head, tail)).append ('\n');
8154: for (int i = head; i < offset; i++) {
8155: sb.append (' ');
8156: }
8157: for (int i = 0; i < length; i++) {
8158: sb.append ('^');
8159: }
8160: DebugConsole.dgtPrintln (sb.toString ());
8161: }
8162: }
8163:
8164:
8165:
8166:
8167:
8168: protected ExpressionElement evxParse (String source, int mode) {
8169:
8170:
8171:
8172:
8173: LinkedList<ExpressionElement> tokenList = new LinkedList<ExpressionElement> ();
8174: ExpressionElement lastToken = null;
8175: char[] a = source.toCharArray ();
8176: int field = 0;
8177: int l = a.length;
8178: int p = 0;
8179: int c = p < l ? a[p++] : -1;
8180: while (0 <= c) {
8181:
8182: while (c == ' ' || c == '\b' || c == '\t' || c == '\n' || c == '\f' || c == '\r') {
8183: if (c == '\n' || c == '\r') {
8184:
8185: if (!(lastToken != null && lastToken.exlType == ElementType.ETY_TOKEN_SEMICOLON)) {
8186: tokenList.add (new ExpressionElement (ElementType.ETY_TOKEN_SEMICOLON, 0,
8187: ElementType.ETY_UNDEF, null, "",
8188: source, p - 1, 1));
8189: }
8190: lastToken = null;
8191: }
8192: c = p < l ? a[p++] : -1;
8193: }
8194: if (c < 0) {
8195: break;
8196: }
8197: int p0 = p - 1;
8198: ElementType type = ElementType.ETY_FLOAT;
8199: int subscript = 0;
8200: ElementType valueType = ElementType.ETY_UNDEF;
8201: EFP floatValue = null;
8202: String stringValue = "";
8203: token:
8204: {
8205:
8206: if (mode == EVM_ASSEMBLER) {
8207: int q = p;
8208: int d = c;
8209: if (lastToken == null) {
8210:
8211: int number = -1;
8212: if (d == '@') {
8213: d = q < l ? a[q++] : -1;
8214: if (d == '@') {
8215: d = q < l ? a[q++] : -1;
8216: }
8217: } else if ('1' <= d && d <= '9') {
8218: number = d - '0';
8219: d = q < l ? a[q++] : -1;
8220: for (int i = 2; i <= 4 && '0' <= d && d <= '9'; i++) {
8221: number = number * 10 + (d - '0');
8222: d = q < l ? a[q++] : -1;
8223: }
8224: }
8225: if (d == '$' || d == '@' ||
8226: '0' <= d && d <= '9' || 'A' <= d && d <= 'Z' || 'a' <= d && d <= 'z') {
8227: number = -1;
8228: }
8229: if (0 <= number) {
8230: p = q;
8231: c = d;
8232: while (c == ':') {
8233: c = p < l ? a[p++] : -1;
8234: }
8235: type = ElementType.ETY_LOCAL_LABEL_DEFINITION;
8236: subscript = number;
8237: break token;
8238: }
8239: } else {
8240:
8241: int number = -1;
8242: int offset = 0;
8243: if (d == '@') {
8244: number = 0;
8245: d = q < l ? a[q++] : -1;
8246: for (int i = 2; i <= 256 && d == '@'; i++) {
8247: offset++;
8248: d = q < l ? a[q++] : -1;
8249: }
8250: } else if ('1' <= d && d <= '9') {
8251: number = d - '0';
8252: d = q < l ? a[q++] : -1;
8253: for (int i = 2; i <= 4 && '0' <= d && d <= '9'; i++) {
8254: number = number * 10 + (d - '0');
8255: d = q < l ? a[q++] : -1;
8256: }
8257: }
8258: if (0 <= number) {
8259: if (d == 'B' || d == 'b') {
8260: d = q < l ? a[q++] : -1;
8261: offset = ~offset;
8262: } else if (d == 'F' || d == 'f') {
8263: d = q < l ? a[q++] : -1;
8264: } else {
8265: number = -1;
8266: }
8267: }
8268: if (0 <= number) {
8269: if (d == '$' || d == '@' ||
8270: '0' <= d && d <= '9' || 'A' <= d && d <= 'Z' || 'a' <= d && d <= 'z') {
8271: number = -1;
8272: }
8273: }
8274: if (0 <= number) {
8275: p = q;
8276: c = d;
8277: type = ElementType.ETY_LOCAL_LABEL_REFERENCE;
8278: subscript = offset << 16 | number;
8279: break token;
8280: }
8281: }
8282: }
8283:
8284:
8285:
8286: number:
8287: {
8288: int d = p < l ? a[p] : -1;
8289: int radix;
8290: int check = 1;
8291: if (c == '0') {
8292: if (d == 'X' || d == 'x') {
8293: p++;
8294: radix = 16;
8295: } else if (d == 'O' || d == 'o') {
8296: p++;
8297: radix = 8;
8298: } else if (d == 'B' || d == 'b') {
8299: p++;
8300: radix = 2;
8301: } else {
8302: radix = 10;
8303: check = 0;
8304: }
8305: } else if ('1' <= c && c <= '9') {
8306: radix = 10;
8307: check = 0;
8308: } else if (c == '$' &&
8309: (('0' <= d && d <= '9') || ('A' <= d && d <= 'F') || ('a' <= d && d <= 'f') || d == '_')) {
8310: radix = 16;
8311: } else if (c == '@' &&
8312: (('0' <= d && d <= '7') || d == '_')) {
8313: radix = 8;
8314: } else if (c == '%' &&
8315: (('0' <= d && d <= '1') || d == '_')) {
8316: radix = 2;
8317: } else {
8318: break number;
8319: }
8320:
8321: c = p < l ? a[p++] : -1;
8322: while ((radix <= 10 ?
8323: '0' <= c && c < '0' + radix :
8324: '0' <= c && c <= '9' || 'A' <= c && c <= 'F' || 'a' <= c && c <= 'f') ||
8325: c == '_') {
8326: if (c != '_') {
8327: check &= ~1;
8328: }
8329: c = p < l ? a[p++] : -1;
8330: }
8331:
8332: if (c == '.') {
8333: d = p < l ? a[p] : -1;
8334: if ((radix <= 10 ?
8335: '0' <= d && d < '0' + radix :
8336: '0' <= d && d <= '9' || 'A' <= d && d <= 'F' || 'a' <= d && d <= 'f') ||
8337: d == '_' ||
8338: (radix == 10 ? d == 'E' || d == 'e' : d == 'P' || d == 'p')) {
8339: check |= 2;
8340: c = p < l ? a[p++] : -1;
8341: while ((radix <= 10 ?
8342: '0' <= c && c < '0' + radix :
8343: '0' <= c && c <= '9' || 'A' <= c && c <= 'F' || 'a' <= c && c <= 'f') ||
8344: c == '_') {
8345: if (c != '_') {
8346: check &= ~2;
8347: }
8348: c = p < l ? a[p++] : -1;
8349: }
8350: }
8351: }
8352:
8353: if (radix == 10 ?
8354: c == 'E' || c == 'e' :
8355: c == 'P' || c == 'p') {
8356: check |= 4;
8357: c = p < l ? a[p++] : -1;
8358: if (c == '+' || c == '-') {
8359: c = p < l ? a[p++] : -1;
8360: }
8361: while ('0' <= c && c <= '9') {
8362: check &= ~4;
8363: c = p < l ? a[p++] : -1;
8364: }
8365: }
8366:
8367: while ('A' <= c && c <= 'Z' || 'a' <= c & c <= 'z') {
8368: check |= 8;
8369: c = p < l ? a[p++] : -1;
8370: }
8371: if (check != 0) {
8372: evxPrintError ((check & 1) != 0 ? (Multilingual.mlnJapanese ?
8373: "整数部に数字がありません" :
8374: "no figure appears at the integer part") :
8375: (check & 2) != 0 ? (Multilingual.mlnJapanese ?
8376: "小数部に数字がありません" :
8377: "no figure appears at the fractional part") :
8378: (check & 4) != 0 ? (Multilingual.mlnJapanese ?
8379: "指数部に数字がありません" :
8380: "no figure appears at the exponential part") :
8381: (check & 8) != 0 ? (Multilingual.mlnJapanese ?
8382: "浮動小数点数に不明な接尾辞が続いています" :
8383: "floating point number followed by an unknown postfix") :
8384: "",
8385: source, p0, p - p0);
8386: return null;
8387: }
8388: type = ElementType.ETY_FLOAT;
8389: floatValue = new EFP (String.valueOf (a, p0, p - p0));
8390: break token;
8391: }
8392:
8393:
8394:
8395: if (c == '\'') {
8396: c = p < l ? a[p++] : -1;
8397: if (c < 0) {
8398: evxPrintError (Multilingual.mlnJapanese ?
8399: "'...' が閉じていません" :
8400: "'...' is not closed",
8401: source, p0, p - p0);
8402: return null;
8403: }
8404: type = ElementType.ETY_FLOAT;
8405: floatValue = new EFP ((char) c);
8406: c = p < l ? a[p++] : -1;
8407: if (c != '\'') {
8408: evxPrintError (Multilingual.mlnJapanese ?
8409: "'...' が閉じていません" :
8410: "'...' is not closed",
8411: source, p0, p - p0);
8412: return null;
8413: }
8414: c = p < l ? a[p++] : -1;
8415: break token;
8416: }
8417:
8418:
8419:
8420: if (c == '"') {
8421: StringBuilder sb = new StringBuilder ();
8422: c = p < l ? a[p++] : -1;
8423: while (0 <= c && c != '"' && c != '\n') {
8424: if (c == '\\') {
8425: c = p < l ? a[p++] : -1;
8426: if (c == '\n') {
8427: c = p < l ? a[p++] : -1;
8428: continue;
8429: }
8430: if ('0' <= c && c <= '3') {
8431: c -= '0';
8432: int d = p < l ? a[p] : -1;
8433: if ('0' <= d && d <= '7') {
8434: p++;
8435: c = (c << 3) + (d - '0');
8436: d = p < l ? a[p] : -1;
8437: if ('0' <= d && d <= '7') {
8438: p++;
8439: c = (c << 3) + (d - '0');
8440: }
8441: }
8442: } else if ('4' <= c && c <= '7') {
8443: c -= '0';
8444: int d = p < l ? a[p] : -1;
8445: if ('0' <= d && d <= '7') {
8446: p++;
8447: c = (c << 3) + (d - '0');
8448: }
8449: } else if (c == 'b') {
8450: c = '\b';
8451: } else if (c == 'f') {
8452: c = '\f';
8453: } else if (c == 'n') {
8454: c = '\n';
8455: } else if (c == 'r') {
8456: c = '\r';
8457: } else if (c == 't') {
8458: c = '\t';
8459: } else if (c == 'x') {
8460: c = 0;
8461: for (int i = 0; i < 2; i++) {
8462: int d = p < l ? a[p++] : -1;
8463: if ('0' <= d && d <= '9' || 'A' <= d && d <= 'F' || 'a' <= d && d <= 'f') {
8464: evxPrintError (Multilingual.mlnJapanese ?
8465: "\\x?? が途切れています" :
8466: "unfinished \\x??",
8467: source, p - i - 3, i + 2);
8468: return null;
8469: }
8470: c = (c << 4) + (d <= '9' ? d - '0' : (d | 0x20) - ('a' - 10));
8471: }
8472: } else if (c == 'u') {
8473: c = 0;
8474: for (int i = 0; i < 4; i++) {
8475: int d = p < l ? a[p++] : -1;
8476: if ('0' <= d && d <= '9' || 'A' <= d && d <= 'F' || 'a' <= d && d <= 'f') {
8477: evxPrintError (Multilingual.mlnJapanese ?
8478: "\\u???? が途切れています" :
8479: "unfinished \\u????",
8480: source, p - i - 3, i + 2);
8481: return null;
8482: }
8483: c = (c << 4) + (d <= '9' ? d - '0' : (d | 0x20) - ('a' - 10));
8484: }
8485: } else if (c == '\"') {
8486: } else if (c == '\'') {
8487: } else if (c == '\\') {
8488: } else {
8489: evxPrintError (Multilingual.mlnJapanese ?
8490: "不明なエスケープシーケンスです" :
8491: "unknown escape sequence",
8492: source, p - 3, 2);
8493: return null;
8494: }
8495: }
8496: sb.append ((char) c);
8497: c = p < l ? a[p++] : -1;
8498: }
8499: if (c != '"') {
8500: evxPrintError (Multilingual.mlnJapanese ?
8501: "\"...\" が閉じていません" :
8502: "\"...\" is not closed",
8503: source, p0, p - p0);
8504: return null;
8505: }
8506: c = p < l ? a[p++] : -1;
8507: type = ElementType.ETY_STRING;
8508: stringValue = sb.toString ();
8509: break token;
8510: }
8511:
8512:
8513:
8514: if ('A' <= c && c <= 'Z' || 'a' <= c & c <= 'z' || c == '_') {
8515: c = p < l ? a[p++] : -1;
8516: while ('A' <= c && c <= 'Z' || 'a' <= c & c <= 'z' || c == '_' || '0' <= c && c <= '9' || c == '$') {
8517: c = p < l ? a[p++] : -1;
8518: }
8519: String identifier = String.valueOf (a, p0, (c < 0 ? p : p - 1) - p0);
8520: String lowerIdentifier = identifier.toLowerCase ();
8521: stringValue = lowerIdentifier;
8522: if (mode == EVM_COMMAND) {
8523: if (lastToken == null) {
8524:
8525: switch (lowerIdentifier) {
8526: case "d":
8527: type = ElementType.ETY_COMMAND_DUMP;
8528: subscript = 'b';
8529: break token;
8530: case "db":
8531: case "dw":
8532: case "dl":
8533: case "dq":
8534: case "ds":
8535: case "dd":
8536: case "dx":
8537: case "dt":
8538: case "dp":
8539: type = ElementType.ETY_COMMAND_DUMP;
8540: subscript = lowerIdentifier.charAt (1);
8541: break token;
8542: case "f":
8543: type = ElementType.ETY_COMMAND_FILL;
8544: subscript = 'b';
8545: break token;
8546: case "fb":
8547: case "fw":
8548: case "fl":
8549: case "fq":
8550: case "fs":
8551: case "fd":
8552: case "fx":
8553: case "ft":
8554: case "fp":
8555: type = ElementType.ETY_COMMAND_FILL;
8556: subscript = lowerIdentifier.charAt (1);
8557: break token;
8558: case "g":
8559: type = ElementType.ETY_COMMAND_RUN;
8560: break token;
8561: case "h":
8562: type = ElementType.ETY_COMMAND_HELP;
8563: break token;
8564: case "i":
8565: type = ElementType.ETY_COMMAND_STOP;
8566: break token;
8567: case "l":
8568: type = ElementType.ETY_COMMAND_LIST;
8569: break token;
8570: case "ll":
8571: type = ElementType.ETY_COMMAND_LABEL_LIST;
8572: break token;
8573: case "me":
8574: type = ElementType.ETY_COMMAND_MEMORY_EDIT;
8575: subscript = 'b';
8576: break token;
8577: case "meb":
8578: case "mew":
8579: case "mel":
8580: case "meq":
8581: case "mes":
8582: case "med":
8583: case "mex":
8584: case "met":
8585: case "mep":
8586: type = ElementType.ETY_COMMAND_MEMORY_EDIT;
8587: subscript = lowerIdentifier.charAt (2);
8588: break token;
8589: case "ms":
8590: type = ElementType.ETY_COMMAND_MEMORY_SEARCH;
8591: subscript = 'b';
8592: break token;
8593: case "msb":
8594: case "msw":
8595: case "msl":
8596: case "msq":
8597: case "mss":
8598: case "msd":
8599: case "msx":
8600: case "mst":
8601: case "msp":
8602: type = ElementType.ETY_COMMAND_MEMORY_SEARCH;
8603: subscript = lowerIdentifier.charAt (2);
8604: break token;
8605: case "p":
8606: type = ElementType.ETY_COMMAND_PRINT;
8607: break token;
8608: case "r":
8609: type = ElementType.ETY_COMMAND_RETURN;
8610: break token;
8611: case "s":
8612: type = ElementType.ETY_COMMAND_STEP;
8613: break token;
8614: case "t":
8615: type = ElementType.ETY_COMMAND_TRACE;
8616: break token;
8617: case "tx":
8618: type = ElementType.ETY_COMMAND_TRACE_REGS;
8619: break token;
8620: case "txf":
8621: type = ElementType.ETY_COMMAND_TRACE_FLOAT_REGS;
8622: break token;
8623: case "x":
8624: type = ElementType.ETY_COMMAND_REGS;
8625: break token;
8626: case "xf":
8627: type = ElementType.ETY_COMMAND_FLOAT_REGS;
8628: break token;
8629: }
8630: }
8631: }
8632: if (mode == EVM_ASSEMBLER) {
8633: if (lastToken == null ||
8634: lastToken.exlType == ElementType.ETY_LABEL_DEFINITION ||
8635: lastToken.exlType == ElementType.ETY_LOCAL_LABEL_DEFINITION) {
8636:
8637: if (Assembler.ASM_MNEMONIC_MAP.containsKey (lowerIdentifier)) {
8638: type = ElementType.ETY_MNEMONIC;
8639: break token;
8640: }
8641: }
8642: switch (lowerIdentifier) {
8643:
8644: case "zd0":
8645: case "zd1":
8646: case "zd2":
8647: case "zd3":
8648: case "zd4":
8649: case "zd5":
8650: case "zd6":
8651: case "zd7":
8652: type = ElementType.ETY_ZERO_REGISTER;
8653: subscript = Integer.parseInt (lowerIdentifier.substring (2));
8654: break token;
8655: case "za0":
8656: case "za1":
8657: case "za2":
8658: case "za3":
8659: case "za4":
8660: case "za5":
8661: case "za6":
8662: case "za7":
8663: type = ElementType.ETY_ZERO_REGISTER;
8664: subscript = 8 + Integer.parseInt (lowerIdentifier.substring (2));
8665: break token;
8666: case "zsp":
8667: type = ElementType.ETY_ZERO_REGISTER;
8668: subscript = 15;
8669: stringValue = "za7";
8670: break token;
8671: case "zr0":
8672: case "zr1":
8673: case "zr2":
8674: case "zr3":
8675: case "zr4":
8676: case "zr5":
8677: case "zr6":
8678: case "zr7":
8679: case "zr8":
8680: case "zr9":
8681: case "zr10":
8682: case "zr11":
8683: case "zr12":
8684: case "zr13":
8685: case "zr14":
8686: case "zr15":
8687: type = ElementType.ETY_ZERO_REGISTER;
8688: subscript = Integer.parseInt (lowerIdentifier.substring (2));
8689: stringValue = subscript < 8 ? "zd" + subscript : "za" + (subscript - 8);
8690: break token;
8691: case "zpc":
8692: type = ElementType.ETY_ZERO_PC;
8693: break token;
8694:
8695: case "opc":
8696: type = ElementType.ETY_OPTIONAL_PC;
8697: break token;
8698:
8699: case "nc":
8700: type = ElementType.ETY_CACHE_SELECTION;
8701: subscript = 0;
8702: break token;
8703: case "dc":
8704: type = ElementType.ETY_CACHE_SELECTION;
8705: subscript = 1;
8706: break token;
8707: case "ic":
8708: type = ElementType.ETY_CACHE_SELECTION;
8709: subscript = 2;
8710: break token;
8711: case "bc":
8712: type = ElementType.ETY_CACHE_SELECTION;
8713: subscript = 3;
8714: break token;
8715: }
8716: }
8717:
8718: if (EVX_CONTROL_NAME_TO_MPU_CODE.containsKey (lowerIdentifier)) {
8719: type = ElementType.ETY_CONTROL_REGISTER;
8720: subscript = EVX_CONTROL_NAME_TO_MPU_CODE.get (lowerIdentifier);
8721: break token;
8722: }
8723: switch (lowerIdentifier) {
8724:
8725: case "pc":
8726: type = ElementType.ETY_PC;
8727: break token;
8728: case "ccr":
8729: type = ElementType.ETY_CCR;
8730: break token;
8731: case "sr":
8732: type = ElementType.ETY_SR;
8733: break token;
8734:
8735: case "fpiar":
8736: type = ElementType.ETY_FLOAT_CONTROL_REGISTER;
8737: subscript = 1;
8738: break token;
8739: case "fpsr":
8740: type = ElementType.ETY_FLOAT_CONTROL_REGISTER;
8741: subscript = 2;
8742: break token;
8743: case "fpcr":
8744: type = ElementType.ETY_FLOAT_CONTROL_REGISTER;
8745: subscript = 4;
8746: break token;
8747:
8748: case "infinity":
8749: type = ElementType.ETY_FLOAT;
8750: floatValue = INF;
8751: break token;
8752: case "nan":
8753: type = ElementType.ETY_FLOAT;
8754: floatValue = NAN;
8755: break token;
8756:
8757: case "apery":
8758: type = ElementType.ETY_MATH_APERY;
8759: break token;
8760: case "catalan":
8761: type = ElementType.ETY_MATH_CATALAN;
8762: break token;
8763: case "e":
8764: type = ElementType.ETY_MATH_NAPIER;
8765: break token;
8766: case "euler":
8767: type = ElementType.ETY_MATH_EULER;
8768: break token;
8769: case "pi":
8770: type = ElementType.ETY_MATH_PI;
8771: break token;
8772:
8773: case "d0":
8774: case "d1":
8775: case "d2":
8776: case "d3":
8777: case "d4":
8778: case "d5":
8779: case "d6":
8780: case "d7":
8781: type = ElementType.ETY_INTEGER_REGISTER;
8782: subscript = Integer.parseInt (lowerIdentifier.substring (1));
8783: break token;
8784: case "a0":
8785: case "a1":
8786: case "a2":
8787: case "a3":
8788: case "a4":
8789: case "a5":
8790: case "a6":
8791: case "a7":
8792: type = ElementType.ETY_INTEGER_REGISTER;
8793: subscript = 8 + Integer.parseInt (lowerIdentifier.substring (1));
8794: break token;
8795: case "sp":
8796: type = ElementType.ETY_INTEGER_REGISTER;
8797: subscript = 15;
8798: stringValue = "a7";
8799: break token;
8800: case "r0":
8801: case "r1":
8802: case "r2":
8803: case "r3":
8804: case "r4":
8805: case "r5":
8806: case "r6":
8807: case "r7":
8808: case "r8":
8809: case "r9":
8810: case "r10":
8811: case "r11":
8812: case "r12":
8813: case "r13":
8814: case "r14":
8815: case "r15":
8816: type = ElementType.ETY_INTEGER_REGISTER;
8817: subscript = Integer.parseInt (lowerIdentifier.substring (1));
8818: stringValue = subscript < 8 ? "d" + subscript : "a" + (subscript - 8);
8819: break token;
8820: case "fp0":
8821: case "fp1":
8822: case "fp2":
8823: case "fp3":
8824: case "fp4":
8825: case "fp5":
8826: case "fp6":
8827: case "fp7":
8828: type = ElementType.ETY_FLOATING_POINT_REGISTER;
8829: subscript = Integer.parseInt (lowerIdentifier.substring (2));
8830: break token;
8831:
8832: case "abs":
8833: type = ElementType.ETY_FUNCTION_ABS;
8834: break token;
8835: case "acos":
8836: type = ElementType.ETY_FUNCTION_ACOS;
8837: break token;
8838: case "acosh":
8839: type = ElementType.ETY_FUNCTION_ACOSH;
8840: break token;
8841: case "acot":
8842: type = ElementType.ETY_FUNCTION_ACOT;
8843: break token;
8844: case "acoth":
8845: type = ElementType.ETY_FUNCTION_ACOTH;
8846: break token;
8847: case "acsc":
8848: type = ElementType.ETY_FUNCTION_ACSC;
8849: break token;
8850: case "acsch":
8851: type = ElementType.ETY_FUNCTION_ACSCH;
8852: break token;
8853: case "agi":
8854: type = ElementType.ETY_FUNCTION_AGI;
8855: break token;
8856: case "agm":
8857: type = ElementType.ETY_FUNCTION_AGM;
8858: break token;
8859: case "asc":
8860: type = ElementType.ETY_FUNCTION_ASC;
8861: break token;
8862: case "asec":
8863: type = ElementType.ETY_FUNCTION_ASEC;
8864: break token;
8865: case "asech":
8866: type = ElementType.ETY_FUNCTION_ASECH;
8867: break token;
8868: case "asin":
8869: type = ElementType.ETY_FUNCTION_ASIN;
8870: break token;
8871: case "asinh":
8872: type = ElementType.ETY_FUNCTION_ASINH;
8873: break token;
8874: case "atan":
8875: type = ElementType.ETY_FUNCTION_ATAN;
8876: break token;
8877: case "atan2":
8878: type = ElementType.ETY_FUNCTION_ATAN2;
8879: break token;
8880: case "atanh":
8881: type = ElementType.ETY_FUNCTION_ATANH;
8882: break token;
8883: case "bin$":
8884: type = ElementType.ETY_FUNCTION_BIN_DOLLAR;
8885: break token;
8886: case "cbrt":
8887: type = ElementType.ETY_FUNCTION_CBRT;
8888: break token;
8889: case "ceil":
8890: type = ElementType.ETY_FUNCTION_CEIL;
8891: break token;
8892: case "chr$":
8893: type = ElementType.ETY_FUNCTION_CHR_DOLLAR;
8894: break token;
8895: case "cmp":
8896: type = ElementType.ETY_FUNCTION_CMP;
8897: break token;
8898: case "cmp0":
8899: type = ElementType.ETY_FUNCTION_CMP0;
8900: break token;
8901: case "cmp1":
8902: type = ElementType.ETY_FUNCTION_CMP1;
8903: break token;
8904: case "cmp1abs":
8905: type = ElementType.ETY_FUNCTION_CMP1ABS;
8906: break token;
8907: case "cmpabs":
8908: type = ElementType.ETY_FUNCTION_CMPABS;
8909: break token;
8910: case "cos":
8911: type = ElementType.ETY_FUNCTION_COS;
8912: break token;
8913: case "cosh":
8914: type = ElementType.ETY_FUNCTION_COSH;
8915: break token;
8916: case "cot":
8917: type = ElementType.ETY_FUNCTION_COT;
8918: break token;
8919: case "coth":
8920: type = ElementType.ETY_FUNCTION_COTH;
8921: break token;
8922: case "csc":
8923: type = ElementType.ETY_FUNCTION_CSC;
8924: break token;
8925: case "csch":
8926: type = ElementType.ETY_FUNCTION_CSCH;
8927: break token;
8928: case "cub":
8929: type = ElementType.ETY_FUNCTION_CUB;
8930: break token;
8931: case "dec":
8932: type = ElementType.ETY_FUNCTION_DEC;
8933: break token;
8934: case "deg":
8935: type = ElementType.ETY_FUNCTION_DEG;
8936: break token;
8937: case "div2":
8938: type = ElementType.ETY_FUNCTION_DIV2;
8939: break token;
8940: case "div3":
8941: type = ElementType.ETY_FUNCTION_DIV3;
8942: break token;
8943: case "divpi":
8944: type = ElementType.ETY_FUNCTION_DIVPI;
8945: break token;
8946: case "divrz":
8947: type = ElementType.ETY_FUNCTION_DIVRZ;
8948: break token;
8949: case "exp":
8950: type = ElementType.ETY_FUNCTION_EXP;
8951: break token;
8952: case "exp10":
8953: type = ElementType.ETY_FUNCTION_EXP10;
8954: break token;
8955: case "exp2":
8956: type = ElementType.ETY_FUNCTION_EXP2;
8957: break token;
8958: case "exp2m1":
8959: type = ElementType.ETY_FUNCTION_EXP2M1;
8960: break token;
8961: case "expm1":
8962: type = ElementType.ETY_FUNCTION_EXPM1;
8963: break token;
8964: case "floor":
8965: type = ElementType.ETY_FUNCTION_FLOOR;
8966: break token;
8967: case "frac":
8968: type = ElementType.ETY_FUNCTION_FRAC;
8969: break token;
8970: case "getexp":
8971: type = ElementType.ETY_FUNCTION_GETEXP;
8972: break token;
8973: case "getman":
8974: type = ElementType.ETY_FUNCTION_GETMAN;
8975: break token;
8976: case "hex$":
8977: type = ElementType.ETY_FUNCTION_HEX_DOLLAR;
8978: break token;
8979: case "ieeerem":
8980: type = ElementType.ETY_FUNCTION_IEEEREM;
8981: break token;
8982: case "inc":
8983: type = ElementType.ETY_FUNCTION_INC;
8984: break token;
8985: case "iseven":
8986: type = ElementType.ETY_FUNCTION_ISEVEN;
8987: break token;
8988: case "isinf":
8989: type = ElementType.ETY_FUNCTION_ISINF;
8990: break token;
8991: case "isint":
8992: type = ElementType.ETY_FUNCTION_ISINT;
8993: break token;
8994: case "isnan":
8995: type = ElementType.ETY_FUNCTION_ISNAN;
8996: break token;
8997: case "isodd":
8998: type = ElementType.ETY_FUNCTION_ISODD;
8999: break token;
9000: case "isone":
9001: type = ElementType.ETY_FUNCTION_ISONE;
9002: break token;
9003: case "iszero":
9004: type = ElementType.ETY_FUNCTION_ISZERO;
9005: break token;
9006: case "lgamma":
9007: type = ElementType.ETY_FUNCTION_LGAMMA;
9008: break token;
9009: case "log":
9010: type = ElementType.ETY_FUNCTION_LOG;
9011: break token;
9012: case "log10":
9013: type = ElementType.ETY_FUNCTION_LOG10;
9014: break token;
9015: case "log1p":
9016: type = ElementType.ETY_FUNCTION_LOG1P;
9017: break token;
9018: case "log2":
9019: type = ElementType.ETY_FUNCTION_LOG2;
9020: break token;
9021: case "max":
9022: type = ElementType.ETY_FUNCTION_MAX;
9023: break token;
9024: case "min":
9025: type = ElementType.ETY_FUNCTION_MIN;
9026: break token;
9027: case "mul2":
9028: type = ElementType.ETY_FUNCTION_MUL2;
9029: break token;
9030: case "mul3":
9031: type = ElementType.ETY_FUNCTION_MUL3;
9032: break token;
9033: case "mulpi":
9034: type = ElementType.ETY_FUNCTION_MULPI;
9035: break token;
9036: case "oct$":
9037: type = ElementType.ETY_FUNCTION_OCT_DOLLAR;
9038: break token;
9039: case "pow":
9040: type = ElementType.ETY_FUNCTION_POW;
9041: break token;
9042: case "quo":
9043: type = ElementType.ETY_FUNCTION_QUO;
9044: break token;
9045: case "rad":
9046: type = ElementType.ETY_FUNCTION_RAD;
9047: break token;
9048: case "random":
9049: type = ElementType.ETY_FUNCTION_RANDOM;
9050: break token;
9051: case "rcp":
9052: type = ElementType.ETY_FUNCTION_RCP;
9053: break token;
9054: case "rint":
9055: type = ElementType.ETY_FUNCTION_RINT;
9056: break token;
9057: case "rmode":
9058: type = ElementType.ETY_FUNCTION_RMODE;
9059: break token;
9060: case "round":
9061: type = ElementType.ETY_FUNCTION_ROUND;
9062: break token;
9063: case "rprec":
9064: type = ElementType.ETY_FUNCTION_RPREC;
9065: break token;
9066: case "sec":
9067: type = ElementType.ETY_FUNCTION_SEC;
9068: break token;
9069: case "sech":
9070: type = ElementType.ETY_FUNCTION_SECH;
9071: break token;
9072: case "sgn":
9073: type = ElementType.ETY_FUNCTION_SGN;
9074: break token;
9075: case "sin":
9076: type = ElementType.ETY_FUNCTION_SIN;
9077: break token;
9078: case "sinh":
9079: type = ElementType.ETY_FUNCTION_SINH;
9080: break token;
9081: case "sqrt":
9082: type = ElementType.ETY_FUNCTION_SQRT;
9083: break token;
9084: case "squ":
9085: type = ElementType.ETY_FUNCTION_SQU;
9086: break token;
9087: case "str$":
9088: type = ElementType.ETY_FUNCTION_STR_DOLLAR;
9089: break token;
9090: case "tan":
9091: type = ElementType.ETY_FUNCTION_TAN;
9092: break token;
9093: case "tanh":
9094: type = ElementType.ETY_FUNCTION_TANH;
9095: break token;
9096: case "tgamma":
9097: type = ElementType.ETY_FUNCTION_TGAMMA;
9098: break token;
9099: case "trunc":
9100: type = ElementType.ETY_FUNCTION_TRUNC;
9101: break token;
9102: case "ulp":
9103: type = ElementType.ETY_FUNCTION_ULP;
9104: break token;
9105: case "val":
9106: type = ElementType.ETY_FUNCTION_VAL;
9107: break token;
9108: }
9109:
9110: if (epbConstLongMap.containsKey (lowerIdentifier)) {
9111: type = ElementType.ETY_FLOAT;
9112: floatValue = new EFP (epbConstLongMap.get (lowerIdentifier));
9113: break token;
9114: }
9115: if (mode == EVM_ASSEMBLER &&
9116: lastToken == null) {
9117:
9118: while (c == ':') {
9119: c = p < l ? a[p++] : -1;
9120: }
9121: type = ElementType.ETY_LABEL_DEFINITION;
9122: stringValue = identifier;
9123: break token;
9124: }
9125:
9126: type = (lowerIdentifier.endsWith ("$") ?
9127: ElementType.ETY_VARIABLE_STRING :
9128: ElementType.ETY_VARIABLE_FLOAT);
9129: stringValue = identifier;
9130: break token;
9131: }
9132:
9133:
9134:
9135: {
9136: int d = p < l ? a[p] : -1;
9137: int e = p + 1 < l ? a[p + 1] : -1;
9138: int f = p + 2 < l ? a[p + 2] : -1;
9139: if (c == '!') {
9140: if (d == '=') {
9141: p++;
9142: type = ElementType.ETY_OPERATOR_NOT_EQUAL;
9143: } else {
9144: type = ElementType.ETY_TOKEN_EXCLAMATION_MARK;
9145: }
9146: } else if (c == '%') {
9147: if (d == '=') {
9148: p++;
9149: type = ElementType.ETY_OPERATOR_SELF_MODULUS;
9150: } else {
9151: type = ElementType.ETY_TOKEN_PERCENT_SIGN;
9152: }
9153: } else if (c == '&') {
9154: if (d == '&') {
9155: p++;
9156: type = ElementType.ETY_OPERATOR_LOGICAL_AND;
9157: } else if (d == '=') {
9158: p++;
9159: type = ElementType.ETY_OPERATOR_SELF_BITWISE_AND;
9160: } else {
9161: type = ElementType.ETY_OPERATOR_BITWISE_AND;
9162: }
9163: } else if (c == '#') {
9164: type = ElementType.ETY_TOKEN_NUMBER_SIGN;
9165: } else if (c == '(') {
9166: type = ElementType.ETY_TOKEN_LEFT_PARENTHESIS;
9167: } else if (c == ')') {
9168: type = ElementType.ETY_TOKEN_RIGHT_PARENTHESIS;
9169: } else if (c == '*') {
9170: if (d == '*') {
9171: if (e == '=') {
9172: p += 2;
9173: type = ElementType.ETY_OPERATOR_SELF_POWER;
9174: } else {
9175: p++;
9176: type = ElementType.ETY_OPERATOR_POWER;
9177: }
9178: } else if (d == '=') {
9179: p++;
9180: type = ElementType.ETY_OPERATOR_SELF_MULTIPLICATION;
9181: } else {
9182: type = ElementType.ETY_TOKEN_ASTERISK;
9183: }
9184: } else if (c == '+') {
9185: if (d == '+') {
9186: p++;
9187: type = ElementType.ETY_TOKEN_PLUS_PLUS;
9188: } else if (d == '=') {
9189: p++;
9190: type = ElementType.ETY_OPERATOR_SELF_ADDITION;
9191: } else {
9192: type = ElementType.ETY_TOKEN_PLUS_SIGN;
9193: }
9194: } else if (c == ',') {
9195: type = ElementType.ETY_TOKEN_COMMA;
9196: } else if (c == '-') {
9197: if (d == '-') {
9198: p++;
9199: type = ElementType.ETY_TOKEN_MINUS_MINUS;
9200: } else if (d == '=') {
9201: p++;
9202: type = ElementType.ETY_OPERATOR_SELF_SUBTRACTION;
9203: } else {
9204: type = ElementType.ETY_TOKEN_HYPHEN_MINUS;
9205: }
9206: } else if (c == '.') {
9207: if (!('0' <= e && e <= '9' || 'A' <= e && e <= 'Z' || 'a' <= e & e <= 'z' ||
9208: e == '$' || e == '_')) {
9209: if (d == 'B' || d == 'b') {
9210: p++;
9211: type = ElementType.ETY_OPERATOR_SIZE_BYTE;
9212: subscript = 'b';
9213: } else if (d == 'W' || d == 'w') {
9214: p++;
9215: type = ElementType.ETY_OPERATOR_SIZE_WORD;
9216: subscript = 'w';
9217: } else if (d == 'L' || d == 'l') {
9218: p++;
9219: type = ElementType.ETY_OPERATOR_SIZE_LONG;
9220: subscript = 'l';
9221: } else if (d == 'Q' || d == 'q') {
9222: p++;
9223: type = ElementType.ETY_OPERATOR_SIZE_QUAD;
9224: subscript = 'q';
9225: } else if (d == 'S' || d == 's') {
9226: p++;
9227: type = ElementType.ETY_OPERATOR_SIZE_SINGLE;
9228: subscript = 's';
9229: } else if (d == 'D' || d == 'd') {
9230: p++;
9231: type = ElementType.ETY_OPERATOR_SIZE_DOUBLE;
9232: subscript = 'd';
9233: } else if (d == 'X' || d == 'x') {
9234: p++;
9235: type = ElementType.ETY_OPERATOR_SIZE_EXTENDED;
9236: subscript = 'x';
9237: } else if (d == 'T' || d == 't') {
9238: p++;
9239: type = ElementType.ETY_OPERATOR_SIZE_TRIPLE;
9240: subscript = 't';
9241: } else if (d == 'P' || d == 'p') {
9242: p++;
9243: type = ElementType.ETY_OPERATOR_SIZE_PACKED;
9244: subscript = 'p';
9245: } else {
9246: type = ElementType.ETY_TOKEN_FULL_STOP;
9247: }
9248: } else {
9249: type = ElementType.ETY_TOKEN_FULL_STOP;
9250: }
9251: } else if (c == '/') {
9252: if (d == '=') {
9253: p++;
9254: type = ElementType.ETY_OPERATOR_SELF_DIVISION;
9255: } else {
9256: type = ElementType.ETY_TOKEN_SOLIDUS;
9257: }
9258: } else if (c == ':') {
9259: type = ElementType.ETY_TOKEN_COLON;
9260: } else if (c == ';') {
9261: type = ElementType.ETY_TOKEN_SEMICOLON;
9262: } else if (c == '<') {
9263: if (d == '<') {
9264: if (e == '=') {
9265: p += 2;
9266: type = ElementType.ETY_OPERATOR_SELF_LEFT_SHIFT;
9267: } else {
9268: p++;
9269: type = ElementType.ETY_OPERATOR_LEFT_SHIFT;
9270: }
9271: } else if (d == '=') {
9272: p++;
9273: type = ElementType.ETY_OPERATOR_LESS_OR_EQUAL;
9274: } else {
9275: type = ElementType.ETY_OPERATOR_LESS_THAN;
9276: }
9277: } else if (c == '=') {
9278: if (d == '=') {
9279: p++;
9280: type = ElementType.ETY_OPERATOR_EQUAL;
9281: } else {
9282: type = ElementType.ETY_OPERATOR_ASSIGNMENT;
9283: }
9284: } else if (c == '>') {
9285: if (d == '>') {
9286: if (e == '>') {
9287: if (f == '=') {
9288: p += 3;
9289: type = ElementType.ETY_OPERATOR_SELF_UNSIGNED_RIGHT_SHIFT;
9290: } else {
9291: p += 2;
9292: type = ElementType.ETY_OPERATOR_UNSIGNED_RIGHT_SHIFT;
9293: }
9294: } else if (e == '=') {
9295: p += 2;
9296: type = ElementType.ETY_OPERATOR_SELF_RIGHT_SHIFT;
9297: } else {
9298: p++;
9299: type = ElementType.ETY_OPERATOR_RIGHT_SHIFT;
9300: }
9301: } else if (d == '=') {
9302: p++;
9303: type = ElementType.ETY_OPERATOR_GREATER_OR_EQUAL;
9304: } else {
9305: type = ElementType.ETY_OPERATOR_GREATER_THAN;
9306: }
9307: } else if (c == '?') {
9308: type = ElementType.ETY_TOKEN_QUESTION_MARK;
9309: } else if (c == '@') {
9310: type = ElementType.ETY_OPERATOR_AT;
9311: } else if (c == '[') {
9312: type = ElementType.ETY_TOKEN_LEFT_SQUARE_BRACKET;
9313: } else if (c == ']') {
9314: type = ElementType.ETY_TOKEN_RIGHT_SQUARE_BRACKET;
9315: } else if (c == '^') {
9316: if (d == '=') {
9317: p++;
9318: type = ElementType.ETY_OPERATOR_SELF_BITWISE_XOR;
9319: } else {
9320: type = ElementType.ETY_OPERATOR_BITWISE_XOR;
9321: }
9322: } else if (c == '{') {
9323: type = ElementType.ETY_TOKEN_LEFT_CURLY_BRACKET;
9324: } else if (c == '|') {
9325: if (d == '|') {
9326: p++;
9327: type = ElementType.ETY_OPERATOR_LOGICAL_OR;
9328: } else if (d == '=') {
9329: p++;
9330: type = ElementType.ETY_OPERATOR_SELF_BITWISE_OR;
9331: } else {
9332: type = ElementType.ETY_OPERATOR_BITWISE_OR;
9333: }
9334: } else if (c == '}') {
9335: type = ElementType.ETY_TOKEN_RIGHT_CURLY_BRACKET;
9336: } else if (c == '~') {
9337: type = ElementType.ETY_TOKEN_TILDE;
9338: } else {
9339: evxPrintError (Multilingual.mlnJapanese ?
9340: "使用できない文字です" :
9341: "unusable character",
9342: source, p0, 1);
9343: return null;
9344: }
9345: c = p < l ? a[p++] : -1;
9346: }
9347:
9348: }
9349: lastToken = new ExpressionElement (type, subscript,
9350: valueType, floatValue, stringValue,
9351: source, p0, (c < 0 ? p : p - 1) - p0);
9352: tokenList.add (lastToken);
9353: if (type == ElementType.ETY_TOKEN_SEMICOLON) {
9354: lastToken = null;
9355: }
9356: }
9357:
9358: if (false) {
9359: for (ExpressionElement elem : tokenList) {
9360: DebugConsole.dgtPrintln (elem.exlType.name ());
9361: }
9362: }
9363:
9364:
9365:
9366:
9367: ExpressionElement nodeTree = evxParseSeparator (tokenList, mode);
9368: if (nodeTree == null) {
9369: return null;
9370: }
9371: if (!tokenList.isEmpty ()) {
9372: ExpressionElement elem = tokenList.peekFirst ();
9373: evxPrintError (Multilingual.mlnJapanese ?
9374: "; がありません" :
9375: "; is not found",
9376: elem.exlSource, elem.exlOffset, elem.exlLength);
9377: }
9378:
9379: return nodeTree;
9380:
9381: }
9382:
9383:
9384:
9385:
9386: protected ExpressionElement evxParsePrimitive (LinkedList<ExpressionElement> tokenList, int mode) {
9387: ExpressionElement elem = tokenList.pollFirst ();
9388: if (elem == null) {
9389: return null;
9390: }
9391: switch (elem.exlType) {
9392:
9393:
9394: case ETY_VARIABLE_FLOAT:
9395: {
9396: String variableName = elem.exlStringValue;
9397: ExpressionElement variableBody = evxVariableMap.get (variableName);
9398: if (variableBody == null) {
9399: variableBody = new ExpressionElement (ElementType.ETY_VARIABLE_FLOAT, 0,
9400: ElementType.ETY_FLOAT, new EFP (), "",
9401: elem.exlSource, elem.exlOffset, elem.exlLength);
9402: evxVariableMap.put (variableName, variableBody);
9403: }
9404: elem.exlType = ElementType.ETY_VARIABLE_FLOAT;
9405: elem.exlValueType = ElementType.ETY_FLOAT;
9406: elem.exlParamX = variableBody;
9407: return elem;
9408: }
9409:
9410:
9411: case ETY_VARIABLE_STRING:
9412: {
9413: String variableName = elem.exlStringValue;
9414: ExpressionElement variableBody = evxVariableMap.get (variableName);
9415: if (variableBody == null) {
9416: variableBody = new ExpressionElement (ElementType.ETY_VARIABLE_STRING, 0,
9417: ElementType.ETY_STRING, new EFP (), "",
9418: elem.exlSource, elem.exlOffset, elem.exlLength);
9419: evxVariableMap.put (variableName, variableBody);
9420: }
9421: elem.exlType = ElementType.ETY_VARIABLE_STRING;
9422: elem.exlValueType = ElementType.ETY_STRING;
9423: elem.exlParamX = variableBody;
9424: return elem;
9425: }
9426:
9427:
9428: case ETY_FLOAT:
9429: elem.exlValueType = ElementType.ETY_FLOAT;
9430: return elem;
9431:
9432:
9433: case ETY_STRING:
9434: elem.exlValueType = ElementType.ETY_STRING;
9435: return elem;
9436:
9437:
9438: case ETY_MATH_APERY:
9439: case ETY_MATH_CATALAN:
9440: case ETY_MATH_NAPIER:
9441: case ETY_MATH_EULER:
9442: case ETY_MATH_PI:
9443: elem.exlValueType = ElementType.ETY_FLOAT;
9444: return elem;
9445:
9446:
9447: case ETY_INTEGER_REGISTER:
9448: if (mode != EVM_ASSEMBLER) {
9449: elem.exlValueType = ElementType.ETY_FLOAT;
9450: return elem;
9451: }
9452:
9453: {
9454: ExpressionElement colon = tokenList.peekFirst ();
9455: if (colon == null) {
9456: return elem;
9457: }
9458: ExpressionElement dh = elem;
9459: ExpressionElement dl = dh;
9460: int h = dh.exlSubscript;
9461: int l = h;
9462:
9463: if (colon.exlType == ElementType.ETY_TOKEN_HYPHEN_MINUS ||
9464: colon.exlType == ElementType.ETY_TOKEN_SOLIDUS) {
9465: if (colon.exlType == ElementType.ETY_TOKEN_HYPHEN_MINUS) {
9466: tokenList.pollFirst ();
9467: dl = tokenList.peekFirst ();
9468: if (dl == null || dl.exlType != ElementType.ETY_INTEGER_REGISTER) {
9469: evxPrintError (Multilingual.mlnJapanese ?
9470: "不完全なレジスタリスト" :
9471: "incomplete register list",
9472: elem.exlSource, elem.exlOffset, colon.exlOffset + colon.exlLength - elem.exlOffset);
9473: return null;
9474: }
9475: tokenList.pollFirst ();
9476: l = dl.exlSubscript;
9477: if (l <= h) {
9478: evxPrintError (Multilingual.mlnJapanese ?
9479: "昇順でないレジスタリスト" :
9480: "register list not in ascending order",
9481: elem.exlSource, elem.exlOffset, dl.exlOffset + dl.exlLength - elem.exlOffset);
9482: return null;
9483: }
9484: colon = tokenList.peekFirst ();
9485: }
9486: int subscript = (2 << l) - (1 << h);
9487: while (colon != null && colon.exlType == ElementType.ETY_TOKEN_SOLIDUS) {
9488: tokenList.pollFirst ();
9489: dh = tokenList.peekFirst ();
9490: if (dh == null || dh.exlType != ElementType.ETY_INTEGER_REGISTER) {
9491: evxPrintError (Multilingual.mlnJapanese ?
9492: "不完全なレジスタリスト" :
9493: "incomplete register list",
9494: elem.exlSource, elem.exlOffset, colon.exlOffset + colon.exlLength - elem.exlOffset);
9495: return null;
9496: }
9497: tokenList.pollFirst ();
9498: h = dh.exlSubscript;
9499: dl = dh;
9500: l = dl.exlSubscript;
9501: colon = tokenList.peekFirst ();
9502: if (colon != null && colon.exlType == ElementType.ETY_TOKEN_HYPHEN_MINUS) {
9503: tokenList.pollFirst ();
9504: dl = tokenList.peekFirst ();
9505: if (dl == null || dl.exlType != ElementType.ETY_INTEGER_REGISTER) {
9506: evxPrintError (Multilingual.mlnJapanese ?
9507: "不完全なレジスタリスト" :
9508: "incomplete register list",
9509: elem.exlSource, elem.exlOffset, colon.exlOffset + colon.exlLength - elem.exlOffset);
9510: return null;
9511: }
9512: tokenList.pollFirst ();
9513: l = dl.exlSubscript;
9514: if (l <= h) {
9515: evxPrintError (Multilingual.mlnJapanese ?
9516: "昇順でないレジスタリスト" :
9517: "register list not in ascending order",
9518: elem.exlSource, elem.exlOffset, dl.exlOffset + dl.exlLength - elem.exlOffset);
9519: return null;
9520: }
9521: colon = tokenList.peekFirst ();
9522: }
9523: int mask = (2 << l) - (1 << h);
9524: if ((subscript & mask) != 0) {
9525: evxPrintError (Multilingual.mlnJapanese ?
9526: "レジスタが重複しています" :
9527: "duplicated register",
9528: elem.exlSource, elem.exlOffset, dl.exlOffset + dl.exlLength - elem.exlOffset);
9529: return null;
9530: }
9531: subscript |= mask;
9532: }
9533: return new ExpressionElement (
9534: ElementType.ETY_INTEGER_REGISTER_LIST, subscript,
9535: ElementType.ETY_UNDEF, null, null,
9536: elem.exlSource, elem.exlOffset, dl.exlOffset + dl.exlLength - elem.exlOffset,
9537: null, null, null);
9538: }
9539: }
9540: return elem;
9541:
9542:
9543: case ETY_FLOATING_POINT_REGISTER:
9544: if (mode != EVM_ASSEMBLER) {
9545: elem.exlValueType = ElementType.ETY_FLOAT;
9546: return elem;
9547: }
9548:
9549: {
9550: ExpressionElement hyphen = tokenList.peekFirst ();
9551: if (hyphen == null) {
9552: return elem;
9553: }
9554: ExpressionElement fpm = elem;
9555: int m = fpm.exlSubscript;
9556: ExpressionElement fpn = fpm;
9557: int n = fpn.exlSubscript;
9558:
9559: if (hyphen.exlType == ElementType.ETY_TOKEN_HYPHEN_MINUS ||
9560: hyphen.exlType == ElementType.ETY_TOKEN_SOLIDUS) {
9561: if (hyphen.exlType == ElementType.ETY_TOKEN_HYPHEN_MINUS) {
9562: tokenList.pollFirst ();
9563: fpn = tokenList.peekFirst ();
9564: if (fpn == null || fpn.exlType != ElementType.ETY_FLOATING_POINT_REGISTER) {
9565: evxPrintError (Multilingual.mlnJapanese ?
9566: "不完全なレジスタリスト" :
9567: "incomplete register list",
9568: elem.exlSource, elem.exlOffset, hyphen.exlOffset + hyphen.exlLength - elem.exlOffset);
9569: return null;
9570: }
9571: tokenList.pollFirst ();
9572: n = fpn.exlSubscript;
9573: if (n <= m) {
9574: evxPrintError (Multilingual.mlnJapanese ?
9575: "昇順でないレジスタリスト" :
9576: "register list not in ascending order",
9577: elem.exlSource, elem.exlOffset, fpn.exlOffset + fpn.exlLength - elem.exlOffset);
9578: return null;
9579: }
9580: hyphen = tokenList.peekFirst ();
9581: }
9582: int subscript = (2 << n) - (1 << m);
9583: while (hyphen != null && hyphen.exlType == ElementType.ETY_TOKEN_SOLIDUS) {
9584: tokenList.pollFirst ();
9585: fpm = tokenList.peekFirst ();
9586: if (fpm == null || fpm.exlType != ElementType.ETY_FLOATING_POINT_REGISTER) {
9587: evxPrintError (Multilingual.mlnJapanese ?
9588: "不完全なレジスタリスト" :
9589: "incomplete register list",
9590: elem.exlSource, elem.exlOffset, hyphen.exlOffset + hyphen.exlLength - elem.exlOffset);
9591: return null;
9592: }
9593: tokenList.pollFirst ();
9594: m = fpm.exlSubscript;
9595: fpn = fpm;
9596: n = fpn.exlSubscript;
9597: hyphen = tokenList.peekFirst ();
9598: if (hyphen != null && hyphen.exlType == ElementType.ETY_TOKEN_HYPHEN_MINUS) {
9599: tokenList.pollFirst ();
9600: fpn = tokenList.peekFirst ();
9601: if (fpn == null || fpn.exlType != ElementType.ETY_FLOATING_POINT_REGISTER) {
9602: evxPrintError (Multilingual.mlnJapanese ?
9603: "不完全なレジスタリスト" :
9604: "incomplete register list",
9605: elem.exlSource, elem.exlOffset, hyphen.exlOffset + hyphen.exlLength - elem.exlOffset);
9606: return null;
9607: }
9608: tokenList.pollFirst ();
9609: n = fpn.exlSubscript;
9610: if (n <= m) {
9611: evxPrintError (Multilingual.mlnJapanese ?
9612: "昇順でないレジスタリスト" :
9613: "register list not in ascending order",
9614: elem.exlSource, elem.exlOffset, fpn.exlOffset + fpn.exlLength - elem.exlOffset);
9615: return null;
9616: }
9617: hyphen = tokenList.peekFirst ();
9618: }
9619: int mask = (2 << n) - (1 << m);
9620: if ((subscript & mask) != 0) {
9621: evxPrintError (Multilingual.mlnJapanese ?
9622: "浮動小数点レジスタが重複しています" :
9623: "duplicated floating point register",
9624: elem.exlSource, elem.exlOffset, fpn.exlOffset + fpn.exlLength - elem.exlOffset);
9625: return null;
9626: }
9627: subscript |= mask;
9628: }
9629: return new ExpressionElement (
9630: ElementType.ETY_FLOATING_POINT_REGISTER_LIST, subscript,
9631: ElementType.ETY_UNDEF, null, null,
9632: elem.exlSource, elem.exlOffset, fpn.exlOffset + fpn.exlLength - elem.exlOffset,
9633: null, null, null);
9634: }
9635: }
9636: return elem;
9637:
9638:
9639: case ETY_PC:
9640: case ETY_CCR:
9641: case ETY_SR:
9642: case ETY_CONTROL_REGISTER:
9643: if (mode != EVM_ASSEMBLER) {
9644: elem.exlValueType = ElementType.ETY_FLOAT;
9645: return elem;
9646: }
9647:
9648: return elem;
9649:
9650:
9651: case ETY_FLOAT_CONTROL_REGISTER:
9652: if (mode != EVM_ASSEMBLER) {
9653: elem.exlValueType = ElementType.ETY_FLOAT;
9654: return elem;
9655: }
9656:
9657: {
9658: ExpressionElement cr = elem;
9659:
9660: int subscript = cr.exlSubscript;
9661: ExpressionElement solidus = tokenList.peekFirst ();
9662: while (solidus != null && solidus.exlType == ElementType.ETY_TOKEN_SOLIDUS) {
9663: tokenList.pollFirst ();
9664: cr = tokenList.peekFirst ();
9665: if (cr == null || cr.exlType != ElementType.ETY_FLOAT_CONTROL_REGISTER) {
9666: evxPrintError (Multilingual.mlnJapanese ?
9667: "不完全な浮動小数点制御レジスタリスト" :
9668: "incomplete floating point control register list",
9669: elem.exlSource, elem.exlOffset, solidus.exlOffset + solidus.exlLength - elem.exlOffset);
9670: return null;
9671: }
9672: tokenList.pollFirst ();
9673: int mask = cr.exlSubscript;
9674: if ((subscript & mask) != 0) {
9675: evxPrintError (Multilingual.mlnJapanese ?
9676: "浮動小数点制御レジスタが重複しています" :
9677: "duplicated floating point control register",
9678: elem.exlSource, elem.exlOffset, cr.exlOffset + cr.exlLength - elem.exlOffset);
9679: return null;
9680: }
9681: subscript |= mask;
9682: solidus = tokenList.peekFirst ();
9683: }
9684: return new ExpressionElement (
9685: ElementType.ETY_FLOATING_POINT_CONTROL_REGISTER_LIST, subscript,
9686: ElementType.ETY_UNDEF, null, null,
9687: elem.exlSource, elem.exlOffset, cr.exlOffset + cr.exlLength - elem.exlOffset,
9688: null, null, null);
9689: }
9690:
9691:
9692: case ETY_FUNCTION_ABS:
9693: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9694: case ETY_FUNCTION_ACOS:
9695: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9696: case ETY_FUNCTION_ACOSH:
9697: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9698: case ETY_FUNCTION_ACOT:
9699: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9700: case ETY_FUNCTION_ACOTH:
9701: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9702: case ETY_FUNCTION_ACSC:
9703: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9704: case ETY_FUNCTION_ACSCH:
9705: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9706: case ETY_FUNCTION_AGI:
9707: return evxParseFunctionFloatFloatFloat (elem, tokenList, mode);
9708: case ETY_FUNCTION_AGM:
9709: return evxParseFunctionFloatFloatFloat (elem, tokenList, mode);
9710: case ETY_FUNCTION_ASC:
9711: return evxParseFunctionFloatString (elem, tokenList, mode);
9712: case ETY_FUNCTION_ASEC:
9713: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9714: case ETY_FUNCTION_ASECH:
9715: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9716: case ETY_FUNCTION_ASIN:
9717: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9718: case ETY_FUNCTION_ASINH:
9719: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9720: case ETY_FUNCTION_ATAN:
9721: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9722: case ETY_FUNCTION_ATAN2:
9723: return evxParseFunctionFloatFloatFloat (elem, tokenList, mode);
9724: case ETY_FUNCTION_ATANH:
9725: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9726: case ETY_FUNCTION_BIN_DOLLAR:
9727: return evxParseFunctionStringFloat (elem, tokenList, mode);
9728: case ETY_FUNCTION_CBRT:
9729: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9730: case ETY_FUNCTION_CEIL:
9731: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9732: case ETY_FUNCTION_CHR_DOLLAR:
9733: return evxParseFunctionStringFloat (elem, tokenList, mode);
9734: case ETY_FUNCTION_CMP:
9735: return evxParseFunctionFloatFloatFloat (elem, tokenList, mode);
9736: case ETY_FUNCTION_CMP0:
9737: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9738: case ETY_FUNCTION_CMP1:
9739: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9740: case ETY_FUNCTION_CMP1ABS:
9741: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9742: case ETY_FUNCTION_CMPABS:
9743: return evxParseFunctionFloatFloatFloat (elem, tokenList, mode);
9744: case ETY_FUNCTION_COS:
9745: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9746: case ETY_FUNCTION_COSH:
9747: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9748: case ETY_FUNCTION_COT:
9749: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9750: case ETY_FUNCTION_COTH:
9751: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9752: case ETY_FUNCTION_CSC:
9753: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9754: case ETY_FUNCTION_CSCH:
9755: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9756: case ETY_FUNCTION_CUB:
9757: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9758: case ETY_FUNCTION_DEC:
9759: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9760: case ETY_FUNCTION_DEG:
9761: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9762: case ETY_FUNCTION_DIV2:
9763: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9764: case ETY_FUNCTION_DIV3:
9765: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9766: case ETY_FUNCTION_DIVPI:
9767: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9768: case ETY_FUNCTION_DIVRZ:
9769: return evxParseFunctionFloatFloatFloat (elem, tokenList, mode);
9770: case ETY_FUNCTION_EXP:
9771: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9772: case ETY_FUNCTION_EXP10:
9773: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9774: case ETY_FUNCTION_EXP2:
9775: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9776: case ETY_FUNCTION_EXP2M1:
9777: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9778: case ETY_FUNCTION_EXPM1:
9779: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9780: case ETY_FUNCTION_FLOOR:
9781: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9782: case ETY_FUNCTION_FRAC:
9783: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9784: case ETY_FUNCTION_GETEXP:
9785: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9786: case ETY_FUNCTION_GETMAN:
9787: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9788: case ETY_FUNCTION_HEX_DOLLAR:
9789: return evxParseFunctionStringFloat (elem, tokenList, mode);
9790: case ETY_FUNCTION_IEEEREM:
9791: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9792: case ETY_FUNCTION_INC:
9793: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9794: case ETY_FUNCTION_ISEVEN:
9795: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9796: case ETY_FUNCTION_ISINF:
9797: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9798: case ETY_FUNCTION_ISINT:
9799: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9800: case ETY_FUNCTION_ISNAN:
9801: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9802: case ETY_FUNCTION_ISODD:
9803: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9804: case ETY_FUNCTION_ISONE:
9805: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9806: case ETY_FUNCTION_ISZERO:
9807: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9808: case ETY_FUNCTION_LGAMMA:
9809: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9810: case ETY_FUNCTION_LOG:
9811: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9812: case ETY_FUNCTION_LOG10:
9813: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9814: case ETY_FUNCTION_LOG1P:
9815: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9816: case ETY_FUNCTION_LOG2:
9817: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9818: case ETY_FUNCTION_MAX:
9819: return evxParseFunctionFloatFloatFloat (elem, tokenList, mode);
9820: case ETY_FUNCTION_MIN:
9821: return evxParseFunctionFloatFloatFloat (elem, tokenList, mode);
9822: case ETY_FUNCTION_MUL2:
9823: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9824: case ETY_FUNCTION_MUL3:
9825: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9826: case ETY_FUNCTION_MULPI:
9827: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9828: case ETY_FUNCTION_OCT_DOLLAR:
9829: return evxParseFunctionStringFloat (elem, tokenList, mode);
9830: case ETY_FUNCTION_POW:
9831: return evxParseFunctionFloatFloatFloat (elem, tokenList, mode);
9832: case ETY_FUNCTION_QUO:
9833: return evxParseFunctionFloatFloatFloat (elem, tokenList, mode);
9834: case ETY_FUNCTION_RAD:
9835: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9836: case ETY_FUNCTION_RANDOM:
9837: return evxParseFunctionFloat (elem, tokenList, mode);
9838: case ETY_FUNCTION_RCP:
9839: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9840: case ETY_FUNCTION_RINT:
9841: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9842: case ETY_FUNCTION_RMODE:
9843: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9844: case ETY_FUNCTION_ROUND:
9845: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9846: case ETY_FUNCTION_RPREC:
9847: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9848: case ETY_FUNCTION_SEC:
9849: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9850: case ETY_FUNCTION_SECH:
9851: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9852: case ETY_FUNCTION_SGN:
9853: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9854: case ETY_FUNCTION_SIN:
9855: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9856: case ETY_FUNCTION_SINH:
9857: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9858: case ETY_FUNCTION_SQRT:
9859: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9860: case ETY_FUNCTION_SQU:
9861: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9862: case ETY_FUNCTION_STR_DOLLAR:
9863: return evxParseFunctionStringFloat (elem, tokenList, mode);
9864: case ETY_FUNCTION_TAN:
9865: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9866: case ETY_FUNCTION_TANH:
9867: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9868: case ETY_FUNCTION_TGAMMA:
9869: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9870: case ETY_FUNCTION_TRUNC:
9871: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9872: case ETY_FUNCTION_ULP:
9873: return evxParseFunctionFloatFloat (elem, tokenList, mode);
9874: case ETY_FUNCTION_VAL:
9875: return evxParseFunctionFloatString (elem, tokenList, mode);
9876:
9877:
9878: case ETY_TOKEN_LEFT_PARENTHESIS:
9879: {
9880: ExpressionElement paramX = evxParseComma (tokenList, mode);
9881: if (paramX == null) {
9882: return null;
9883: }
9884: ExpressionElement right = tokenList.peekFirst ();
9885: if (right == null || right.exlType != ElementType.ETY_TOKEN_RIGHT_PARENTHESIS) {
9886: evxPrintError (Multilingual.mlnJapanese ?
9887: "(...) が閉じていません" :
9888: "(...) is not closed",
9889: elem.exlSource, elem.exlOffset, paramX.exlOffset + paramX.exlLength - elem.exlOffset);
9890: return null;
9891: }
9892: tokenList.pollFirst ();
9893: if (paramX.exlValueType == ElementType.ETY_FLOAT ||
9894: paramX.exlValueType == ElementType.ETY_STRING) {
9895: return paramX;
9896: }
9897: if (mode != EVM_ASSEMBLER) {
9898: evxPrintError (Multilingual.mlnJapanese ?
9899: "引数の型が違います" :
9900: "wrong type of parameter",
9901: elem.exlSource, elem.exlOffset, right.exlOffset + right.exlLength - elem.exlOffset);
9902: return null;
9903: }
9904:
9905: if (paramX.exlType == ElementType.ETY_INTEGER_REGISTER) {
9906: return new ExpressionElement (
9907: ElementType.ETY_REGISTER_INDIRECT, paramX.exlSubscript,
9908: ElementType.ETY_UNDEF, null, null,
9909: elem.exlSource, elem.exlOffset, right.exlOffset + right.exlLength - elem.exlOffset,
9910: null, null, null);
9911: }
9912: return new ExpressionElement (
9913: ElementType.ETY_PARENTHESIS, 0,
9914: ElementType.ETY_UNDEF, null, null,
9915: elem.exlSource, elem.exlOffset, right.exlOffset + right.exlLength - elem.exlOffset,
9916: paramX, null, null);
9917: }
9918:
9919:
9920: case ETY_TOKEN_LEFT_SQUARE_BRACKET:
9921: {
9922: ExpressionElement paramX = evxParseComma (tokenList, mode);
9923: if (paramX == null) {
9924: return null;
9925: }
9926: ExpressionElement right = tokenList.pollFirst ();
9927: if (right == null ||
9928: right.exlType != ElementType.ETY_TOKEN_RIGHT_SQUARE_BRACKET) {
9929: evxPrintError (Multilingual.mlnJapanese ?
9930: "[...] が閉じていません" :
9931: "[...] is not closed",
9932: elem.exlSource, elem.exlOffset, paramX.exlOffset + paramX.exlLength - elem.exlOffset);
9933: return null;
9934: }
9935: if (mode != EVM_ASSEMBLER) {
9936: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
9937: evxPrintError (Multilingual.mlnJapanese ?
9938: "アドレスの型が違います" :
9939: "wrong type of address",
9940: elem.exlSource, elem.exlOffset, right.exlOffset + right.exlLength - elem.exlOffset);
9941: return null;
9942: }
9943: }
9944: return new ExpressionElement (
9945: ElementType.ETY_SQUARE_BRACKET, 0,
9946: mode == EVM_ASSEMBLER ? ElementType.ETY_UNDEF : ElementType.ETY_FLOAT, null, "",
9947: elem.exlSource, elem.exlOffset, right.exlOffset + right.exlLength - elem.exlOffset,
9948: paramX, null, null);
9949: }
9950:
9951: }
9952:
9953: if (mode == EVM_ASSEMBLER) {
9954: return elem;
9955: }
9956:
9957: evxPrintError (Multilingual.mlnJapanese ?
9958: "文法エラー" :
9959: "syntax error",
9960: elem.exlSource, elem.exlOffset, elem.exlLength);
9961: return null;
9962:
9963: }
9964:
9965:
9966:
9967:
9968: protected ExpressionElement evxParseFunctionFloat (ExpressionElement elem, LinkedList<ExpressionElement> tokenList, int mode) {
9969: return evxParseFunction0 (elem, tokenList,
9970: ElementType.ETY_FLOAT, mode);
9971: }
9972: protected ExpressionElement evxParseFunctionString (ExpressionElement elem, LinkedList<ExpressionElement> tokenList, int mode) {
9973: return evxParseFunction0 (elem, tokenList,
9974: ElementType.ETY_STRING, mode);
9975: }
9976: protected ExpressionElement evxParseFunction0 (ExpressionElement elem, LinkedList<ExpressionElement> tokenList,
9977: ElementType valueType, int mode) {
9978: ExpressionElement commaOrParen = tokenList.pollFirst ();
9979: if (commaOrParen == null || commaOrParen.exlType != ElementType.ETY_TOKEN_LEFT_PARENTHESIS) {
9980: evxPrintError (Multilingual.mlnJapanese ?
9981: "( がありません" :
9982: "( is not found",
9983: elem.exlSource, -1, 1);
9984: return null;
9985: }
9986: commaOrParen = tokenList.pollFirst ();
9987: if (commaOrParen == null || commaOrParen.exlType != ElementType.ETY_TOKEN_RIGHT_PARENTHESIS) {
9988: evxPrintError (Multilingual.mlnJapanese ?
9989: ") がありません" :
9990: ") is not found",
9991: elem.exlSource, -1, 1);
9992: return null;
9993: }
9994: elem.exlValueType = valueType;
9995: elem.exlParamX = null;
9996: elem.exlParamY = null;
9997: elem.exlParamZ = null;
9998: elem.exlLength = commaOrParen.exlOffset + commaOrParen.exlLength - elem.exlOffset;
9999: return elem;
10000: }
10001:
10002:
10003:
10004:
10005: protected ExpressionElement evxParseFunctionFloatFloat (ExpressionElement elem, LinkedList<ExpressionElement> tokenList, int mode) {
10006: return evxParseFunction1 (elem, tokenList,
10007: ElementType.ETY_FLOAT, ElementType.ETY_FLOAT, mode);
10008: }
10009: protected ExpressionElement evxParseFunctionFloatString (ExpressionElement elem, LinkedList<ExpressionElement> tokenList, int mode) {
10010: return evxParseFunction1 (elem, tokenList,
10011: ElementType.ETY_FLOAT, ElementType.ETY_STRING, mode);
10012: }
10013: protected ExpressionElement evxParseFunctionStringFloat (ExpressionElement elem, LinkedList<ExpressionElement> tokenList, int mode) {
10014: return evxParseFunction1 (elem, tokenList,
10015: ElementType.ETY_STRING, ElementType.ETY_FLOAT, mode);
10016: }
10017: protected ExpressionElement evxParseFunction1 (ExpressionElement elem, LinkedList<ExpressionElement> tokenList,
10018: ElementType valueType, ElementType paramTypeX, int mode) {
10019: ExpressionElement commaOrParen = tokenList.pollFirst ();
10020: if (commaOrParen == null || commaOrParen.exlType != ElementType.ETY_TOKEN_LEFT_PARENTHESIS) {
10021: evxPrintError (Multilingual.mlnJapanese ?
10022: "( がありません" :
10023: "( is not found",
10024: elem.exlSource, -1, 1);
10025: return null;
10026: }
10027: ExpressionElement paramX = evxParseAssignment (tokenList, mode);
10028: if (paramX == null) {
10029: return null;
10030: }
10031: if (paramX.exlValueType != paramTypeX) {
10032: evxPrintError (Multilingual.mlnJapanese ?
10033: "1 番目の引数の型が違います" :
10034: "wrong type of the 1st parameter",
10035: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10036: return null;
10037: }
10038: commaOrParen = tokenList.pollFirst ();
10039: if (commaOrParen == null || commaOrParen.exlType != ElementType.ETY_TOKEN_RIGHT_PARENTHESIS) {
10040: evxPrintError (Multilingual.mlnJapanese ?
10041: ") がありません" :
10042: ") is not found",
10043: elem.exlSource, -1, 1);
10044: return null;
10045: }
10046: elem.exlValueType = valueType;
10047: elem.exlParamX = paramX;
10048: elem.exlParamY = null;
10049: elem.exlParamZ = null;
10050: elem.exlLength = commaOrParen.exlOffset + commaOrParen.exlLength - elem.exlOffset;
10051: return elem;
10052: }
10053:
10054:
10055:
10056:
10057: protected ExpressionElement evxParseFunctionFloatFloatFloat (ExpressionElement elem, LinkedList<ExpressionElement> tokenList, int mode) {
10058: return evxParseFunction2 (elem, tokenList,
10059: ElementType.ETY_FLOAT, ElementType.ETY_FLOAT, ElementType.ETY_FLOAT, mode);
10060: }
10061: protected ExpressionElement evxParseFunction2 (ExpressionElement elem, LinkedList<ExpressionElement> tokenList,
10062: ElementType valueType, ElementType paramTypeX, ElementType paramTypeY, int mode) {
10063: ExpressionElement commaOrParen = tokenList.pollFirst ();
10064: if (commaOrParen == null || commaOrParen.exlType != ElementType.ETY_TOKEN_LEFT_PARENTHESIS) {
10065: evxPrintError (Multilingual.mlnJapanese ?
10066: "( がありません" :
10067: "( is not found",
10068: elem.exlSource, -1, 1);
10069: return null;
10070: }
10071: ExpressionElement paramX = evxParseAssignment (tokenList, mode);
10072: if (paramX == null) {
10073: return null;
10074: }
10075: if (paramX.exlValueType != paramTypeX) {
10076: evxPrintError (Multilingual.mlnJapanese ?
10077: "1 番目の引数の型が違います" :
10078: "wrong type of the 1st parameter",
10079: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10080: return null;
10081: }
10082: commaOrParen = tokenList.pollFirst ();
10083: if (commaOrParen == null || commaOrParen.exlType != ElementType.ETY_OPERATOR_COMMA) {
10084: evxPrintError (Multilingual.mlnJapanese ?
10085: ", がありません" :
10086: ", is not found",
10087: elem.exlSource, -1, 1);
10088: return null;
10089: }
10090: ExpressionElement paramY = evxParseAssignment (tokenList, mode);
10091: if (paramY == null) {
10092: return null;
10093: }
10094: if (paramX.exlValueType != paramTypeY) {
10095: evxPrintError (Multilingual.mlnJapanese ?
10096: "2 番目の引数の型が違います" :
10097: "wrong type of the 2nd parameter",
10098: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10099: return null;
10100: }
10101: commaOrParen = tokenList.pollFirst ();
10102: if (commaOrParen == null || commaOrParen.exlType != ElementType.ETY_TOKEN_RIGHT_PARENTHESIS) {
10103: evxPrintError (Multilingual.mlnJapanese ?
10104: ") がありません" :
10105: ") is not found",
10106: elem.exlSource, -1, 1);
10107: return null;
10108: }
10109: elem.exlValueType = valueType;
10110: elem.exlParamX = paramX;
10111: elem.exlParamY = paramY;
10112: elem.exlParamZ = null;
10113: elem.exlLength = commaOrParen.exlOffset + commaOrParen.exlLength - elem.exlOffset;
10114: return elem;
10115: }
10116:
10117:
10118:
10119:
10120: protected ExpressionElement evxParseAt (LinkedList<ExpressionElement> tokenList, int mode) {
10121: ExpressionElement paramX = evxParsePrimitive (tokenList, mode);
10122: if (paramX == null) {
10123: return null;
10124: }
10125: ExpressionElement elem = tokenList.peekFirst ();
10126: while (elem != null) {
10127: switch (elem.exlType) {
10128: case ETY_OPERATOR_AT:
10129: break;
10130: default:
10131: return paramX;
10132: }
10133: tokenList.pollFirst ();
10134: ExpressionElement paramY = evxParsePrimitive (tokenList, mode);
10135: if (paramY == null) {
10136: return null;
10137: }
10138: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10139: evxPrintError (Multilingual.mlnJapanese ?
10140: "アドレスの型が違います" :
10141: "wrong type of the address",
10142: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10143: return null;
10144: }
10145: if (paramY.exlValueType != ElementType.ETY_FLOAT) {
10146: evxPrintError (Multilingual.mlnJapanese ?
10147: "ファンクションコードの型が違います" :
10148: "wrong type of the function code",
10149: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10150: return null;
10151: }
10152: elem.exlValueType = ElementType.ETY_FLOAT;
10153: elem.exlParamX = paramX;
10154: elem.exlParamY = paramY;
10155: elem.exlOffset = paramX.exlOffset;
10156: elem.exlLength = paramY.exlOffset + paramY.exlLength - elem.exlOffset;
10157: paramX = elem;
10158: elem = tokenList.peekFirst ();
10159: }
10160: return paramX;
10161: }
10162:
10163:
10164:
10165:
10166: protected ExpressionElement evxParsePostfix (LinkedList<ExpressionElement> tokenList, int mode) {
10167:
10168: ExpressionElement paramX = evxParseAt (tokenList, mode);
10169: if (paramX == null) {
10170: return null;
10171: }
10172:
10173: for (ExpressionElement operator = tokenList.peekFirst ();
10174: operator != null;
10175: operator = tokenList.peekFirst ()) {
10176:
10177:
10178:
10179:
10180: if (operator.exlType == ElementType.ETY_TOKEN_PLUS_PLUS ||
10181: operator.exlType == ElementType.ETY_TOKEN_MINUS_MINUS) {
10182: tokenList.pollFirst ();
10183: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10184: evxPrintError (Multilingual.mlnJapanese ?
10185: "引数の型が違います" :
10186: "wrong type of parameter",
10187: operator.exlSource, operator.exlOffset, operator.exlLength);
10188: return null;
10189: }
10190: if (mode == EVM_ASSEMBLER) {
10191: evxPrintError (Multilingual.mlnJapanese ?
10192: "副作用を起こす演算子はここでは使えません" :
10193: "operators which cause a side effect is unusable here",
10194: operator.exlSource, operator.exlOffset, operator.exlLength);
10195: return null;
10196: }
10197: if (!paramX.exlIsFloatSubstituend ()) {
10198: evxPrintError (Multilingual.mlnJapanese ?
10199: "引数が場所を示していません" :
10200: "parameter is not indicating a location",
10201: operator.exlSource, operator.exlOffset, operator.exlLength);
10202: return null;
10203: }
10204: paramX = new ExpressionElement (
10205: operator.exlType == ElementType.ETY_TOKEN_PLUS_PLUS ?
10206: ElementType.ETY_OPERATOR_POSTINCREMENT :
10207: ElementType.ETY_OPERATOR_POSTDECREMENT, 0,
10208: ElementType.ETY_FLOAT, null, null,
10209: paramX.exlSource, paramX.exlOffset, operator.exlOffset + operator.exlLength - paramX.exlOffset,
10210: paramX, null, null);
10211: continue;
10212: }
10213:
10214: if (mode != EVM_ASSEMBLER) {
10215: break;
10216: }
10217:
10218:
10219:
10220:
10221:
10222:
10223: if ((operator.exlType == ElementType.ETY_OPERATOR_SIZE_WORD ||
10224: operator.exlType == ElementType.ETY_OPERATOR_SIZE_LONG) &&
10225: (paramX.exlValueType == ElementType.ETY_FLOAT ||
10226: paramX.exlType == ElementType.ETY_INTEGER_REGISTER)) {
10227: tokenList.pollFirst ();
10228: paramX = new ExpressionElement (
10229: ElementType.ETY_SIZE, operator.exlSubscript,
10230: ElementType.ETY_UNDEF, null, null,
10231: paramX.exlSource, paramX.exlOffset, operator.exlOffset + operator.exlLength - paramX.exlOffset,
10232: paramX, null, null);
10233: continue;
10234: }
10235:
10236:
10237:
10238:
10239:
10240:
10241: if ((paramX.exlValueType == ElementType.ETY_FLOAT ||
10242: (paramX.exlType == ElementType.ETY_SIZE &&
10243: paramX.exlParamX.exlValueType == ElementType.ETY_FLOAT)) &&
10244: operator.exlType == ElementType.ETY_TOKEN_LEFT_PARENTHESIS) {
10245: tokenList.pollFirst ();
10246: ExpressionElement commaRight = tokenList.peekFirst ();
10247: if (commaRight != null && commaRight.exlType != ElementType.ETY_TOKEN_RIGHT_PARENTHESIS) {
10248: for (;;) {
10249:
10250: ExpressionElement paramY = evxParseColon (tokenList, mode);
10251: if (paramY == null) {
10252: return null;
10253: }
10254: paramX = new ExpressionElement (
10255: ElementType.ETY_OPERATOR_COMMA, 0,
10256: paramY.exlValueType, null, null,
10257: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset,
10258: paramX, paramY, null);
10259: commaRight = tokenList.peekFirst ();
10260: if (commaRight == null || commaRight.exlType != ElementType.ETY_TOKEN_COMMA) {
10261: break;
10262: }
10263: tokenList.pollFirst ();
10264: }
10265: }
10266: if (commaRight == null || commaRight.exlType != ElementType.ETY_TOKEN_RIGHT_PARENTHESIS) {
10267: evxPrintError (Multilingual.mlnJapanese ?
10268: "(...) が閉じていません" :
10269: "(...) is not closed",
10270: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10271: return null;
10272: }
10273: tokenList.pollFirst ();
10274: paramX = new ExpressionElement (
10275: ElementType.ETY_PARENTHESIS, 0,
10276: ElementType.ETY_UNDEF, null, null,
10277: paramX.exlSource, paramX.exlOffset, commaRight.exlOffset + commaRight.exlLength - paramX.exlOffset,
10278: paramX, null, null);
10279: continue;
10280: }
10281:
10282:
10283:
10284:
10285: if (operator.exlType == ElementType.ETY_TOKEN_LEFT_CURLY_BRACKET) {
10286: tokenList.pollFirst ();
10287: ExpressionElement paramY = evxParseAssignment (tokenList, mode);
10288: if (paramY == null) {
10289: return null;
10290: }
10291: ExpressionElement colon = tokenList.peekFirst ();
10292: if (colon == null) {
10293: evxPrintError (Multilingual.mlnJapanese ?
10294: "不完全なビットフィールドまたは k-factor" :
10295: "incomplete bit-field or k-factor",
10296: operator.exlSource, operator.exlOffset, paramY.exlOffset + paramY.exlLength - operator.exlOffset);
10297: return null;
10298: }
10299: tokenList.pollFirst ();
10300: if (colon.exlType == ElementType.ETY_TOKEN_COLON) {
10301:
10302: ExpressionElement paramZ = evxParseAssignment (tokenList, mode);
10303: if (paramZ == null) {
10304: return null;
10305: }
10306: ExpressionElement right = tokenList.peekFirst ();
10307: if (right == null || right.exlType != ElementType.ETY_TOKEN_RIGHT_CURLY_BRACKET) {
10308: evxPrintError (Multilingual.mlnJapanese ?
10309: "不完全なビットフィールド" :
10310: "incomplete bit-field",
10311: operator.exlSource, operator.exlOffset, paramZ.exlOffset + paramZ.exlLength - operator.exlOffset);
10312: return null;
10313: }
10314: tokenList.pollFirst ();
10315: if (!(paramY.exlValueType == ElementType.ETY_FLOAT ||
10316: paramY.exlType == ElementType.ETY_IMMEDIATE ||
10317: (paramY.exlType == ElementType.ETY_INTEGER_REGISTER && paramY.exlSubscript < 8))) {
10318: evxPrintError (Multilingual.mlnJapanese ?
10319: "ビットフィールドのオフセットの型が違います" :
10320: "wrong type of bit-field offset",
10321: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10322: }
10323: if (!(paramZ.exlValueType == ElementType.ETY_FLOAT ||
10324: paramZ.exlType == ElementType.ETY_IMMEDIATE ||
10325: (paramZ.exlType == ElementType.ETY_INTEGER_REGISTER && paramZ.exlSubscript < 8))) {
10326: evxPrintError (Multilingual.mlnJapanese ?
10327: "ビットフィールドの幅の型が違います" :
10328: "wrong type of bit-field width",
10329: paramZ.exlSource, paramZ.exlOffset, paramZ.exlLength);
10330: }
10331: paramX = new ExpressionElement (
10332: ElementType.ETY_BIT_FIELD, 0,
10333: ElementType.ETY_UNDEF, null, null,
10334: paramX.exlSource, paramX.exlOffset, right.exlOffset + right.exlLength - paramX.exlOffset,
10335: paramX, paramY, paramZ);
10336: continue;
10337: }
10338: if (colon.exlType == ElementType.ETY_TOKEN_RIGHT_CURLY_BRACKET) {
10339:
10340: if (!(paramY.exlValueType == ElementType.ETY_FLOAT ||
10341: paramY.exlType == ElementType.ETY_IMMEDIATE ||
10342: (paramY.exlType == ElementType.ETY_INTEGER_REGISTER && paramY.exlSubscript < 8))) {
10343: evxPrintError (Multilingual.mlnJapanese ?
10344: "k-factor の型が違います" :
10345: "wrong type of k-factor",
10346: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10347: }
10348: paramX = new ExpressionElement (
10349: ElementType.ETY_K_FACTOR, 0,
10350: ElementType.ETY_UNDEF, null, null,
10351: paramX.exlSource, paramX.exlOffset, colon.exlOffset + colon.exlLength - paramX.exlOffset,
10352: paramX, paramY, null);
10353: continue;
10354: }
10355:
10356: evxPrintError (Multilingual.mlnJapanese ?
10357: "不完全なビットフィールドまたは k-factor" :
10358: "incomplete bit-field or k-factor",
10359: operator.exlSource, operator.exlOffset, paramY.exlOffset + paramY.exlLength - operator.exlOffset);
10360: return null;
10361: }
10362:
10363: break;
10364: }
10365:
10366: return paramX;
10367:
10368: }
10369:
10370:
10371:
10372:
10373: protected ExpressionElement evxParsePrefix (LinkedList<ExpressionElement> tokenList, int mode) {
10374: ExpressionElement operator = tokenList.peekFirst ();
10375: if (operator == null) {
10376: return null;
10377: }
10378: ElementType type = operator.exlType;
10379: if (type == ElementType.ETY_TOKEN_PLUS_PLUS) {
10380: type = ElementType.ETY_OPERATOR_PREINCREMENT;
10381: } else if (type == ElementType.ETY_TOKEN_MINUS_MINUS) {
10382: type = ElementType.ETY_OPERATOR_PREDECREMENT;
10383: } else if (type == ElementType.ETY_TOKEN_PLUS_SIGN) {
10384: type = ElementType.ETY_OPERATOR_NOTHING;
10385: } else if (type == ElementType.ETY_TOKEN_HYPHEN_MINUS) {
10386: type = ElementType.ETY_OPERATOR_NEGATION;
10387: } else if (type == ElementType.ETY_TOKEN_TILDE) {
10388: type = ElementType.ETY_OPERATOR_BITWISE_NOT;
10389: } else if (type == ElementType.ETY_TOKEN_EXCLAMATION_MARK) {
10390: type = ElementType.ETY_OPERATOR_LOGICAL_NOT;
10391: } else if (mode == EVM_ASSEMBLER &&
10392: type == ElementType.ETY_TOKEN_NUMBER_SIGN) {
10393: type = ElementType.ETY_IMMEDIATE;
10394: } else {
10395: return evxParsePostfix (tokenList, mode);
10396: }
10397: tokenList.pollFirst ();
10398: ExpressionElement paramX = evxParsePrefix (tokenList, mode);
10399: if (paramX == null) {
10400: return null;
10401: }
10402: if (mode == EVM_ASSEMBLER &&
10403: type == ElementType.ETY_OPERATOR_NEGATION &&
10404: paramX.exlType == ElementType.ETY_REGISTER_INDIRECT &&
10405: 8 <= paramX.exlSubscript) {
10406: return new ExpressionElement (
10407: ElementType.ETY_PREDECREMENT, paramX.exlSubscript - 8,
10408: ElementType.ETY_UNDEF, null, null,
10409: operator.exlSource, operator.exlOffset, paramX.exlOffset + paramX.exlLength - operator.exlOffset,
10410: null, null, null);
10411: }
10412: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10413: evxPrintError (Multilingual.mlnJapanese ?
10414: "引数の型が違います" :
10415: "wrong type of parameter",
10416: operator.exlSource, operator.exlOffset, operator.exlLength);
10417: return null;
10418: }
10419: if (type == ElementType.ETY_OPERATOR_PREINCREMENT ||
10420: type == ElementType.ETY_OPERATOR_PREDECREMENT) {
10421: if (mode == EVM_ASSEMBLER) {
10422: evxPrintError (Multilingual.mlnJapanese ?
10423: "副作用を起こす演算子はここでは使えません" :
10424: "operators which cause a side effect is unusable here",
10425: operator.exlSource, operator.exlOffset, operator.exlLength);
10426: return null;
10427: }
10428: if (!paramX.exlIsFloatSubstituend ()) {
10429: evxPrintError (Multilingual.mlnJapanese ?
10430: "引数が場所を示していません" :
10431: "parameter is not indicating a location",
10432: operator.exlSource, operator.exlOffset, operator.exlLength);
10433: return null;
10434: }
10435: }
10436: return new ExpressionElement (
10437: type, 0,
10438: ElementType.ETY_FLOAT, null, null,
10439: operator.exlSource, operator.exlOffset, paramX.exlOffset + paramX.exlLength - operator.exlOffset,
10440: paramX, null, null);
10441: }
10442:
10443:
10444:
10445:
10446: protected ExpressionElement evxParseExponentiation (LinkedList<ExpressionElement> tokenList, int mode) {
10447: ExpressionElement paramX = evxParsePrefix (tokenList, mode);
10448: if (paramX == null) {
10449: return null;
10450: }
10451: ExpressionElement elem = tokenList.peekFirst ();
10452: if (elem != null) {
10453: switch (elem.exlType) {
10454: case ETY_OPERATOR_POWER:
10455: break;
10456: default:
10457: return paramX;
10458: }
10459: tokenList.pollFirst ();
10460: ExpressionElement paramY = evxParseExponentiation (tokenList, mode);
10461: if (paramY == null) {
10462: return null;
10463: }
10464: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10465: evxPrintError (Multilingual.mlnJapanese ?
10466: "1 番目の引数の型が違います" :
10467: "wrong type of the 1st parameter",
10468: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10469: return null;
10470: }
10471: if (paramY.exlValueType != ElementType.ETY_FLOAT) {
10472: evxPrintError (Multilingual.mlnJapanese ?
10473: "2 番目の引数の型が違います" :
10474: "wrong type of the 2nd parameter",
10475: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10476: return null;
10477: }
10478: elem.exlValueType = ElementType.ETY_FLOAT;
10479: elem.exlParamX = paramX;
10480: elem.exlParamY = paramY;
10481: elem.exlOffset = paramX.exlOffset;
10482: elem.exlLength = paramY.exlOffset + paramY.exlLength - elem.exlOffset;
10483: return elem;
10484: }
10485: return paramX;
10486: }
10487:
10488:
10489:
10490:
10491: protected ExpressionElement evxParseMultiplication (LinkedList<ExpressionElement> tokenList, int mode) {
10492:
10493: ExpressionElement paramX = evxParseExponentiation (tokenList, mode);
10494: if (paramX == null) {
10495: return null;
10496: }
10497: for (ExpressionElement operator = tokenList.peekFirst ();
10498: operator != null;
10499: operator = tokenList.peekFirst ()) {
10500: ElementType type = operator.exlType;
10501: if (type == ElementType.ETY_TOKEN_ASTERISK) {
10502: type = ElementType.ETY_OPERATOR_MULTIPLICATION;
10503: } else if (type == ElementType.ETY_TOKEN_SOLIDUS) {
10504: type = ElementType.ETY_OPERATOR_DIVISION;
10505: } else if (type == ElementType.ETY_TOKEN_PERCENT_SIGN) {
10506: type = ElementType.ETY_OPERATOR_MODULUS;
10507: } else {
10508: break;
10509: }
10510: tokenList.pollFirst ();
10511:
10512: ExpressionElement paramY = evxParseExponentiation (tokenList, mode);
10513: if (paramY == null) {
10514: return null;
10515: }
10516: if (paramX.exlValueType == ElementType.ETY_FLOAT &&
10517: paramY.exlValueType == ElementType.ETY_FLOAT) {
10518: paramX = new ExpressionElement (
10519: type, 0,
10520: ElementType.ETY_FLOAT, null, null,
10521: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset,
10522: paramX, paramY, null);
10523: continue;
10524: }
10525: if (mode == EVM_ASSEMBLER) {
10526:
10527: if (type == ElementType.ETY_OPERATOR_MULTIPLICATION &&
10528: (paramX.exlType == ElementType.ETY_INTEGER_REGISTER ||
10529: (paramX.exlType == ElementType.ETY_SIZE &&
10530: paramX.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER)) &&
10531: paramY.exlValueType == ElementType.ETY_FLOAT) {
10532: paramX = new ExpressionElement (
10533: ElementType.ETY_SCALE_FACTOR, 0,
10534: ElementType.ETY_UNDEF, null, null,
10535: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset,
10536: paramX, paramY, null);
10537: continue;
10538: }
10539: if (type == ElementType.ETY_OPERATOR_MULTIPLICATION &&
10540: (paramY.exlType == ElementType.ETY_INTEGER_REGISTER ||
10541: (paramY.exlType == ElementType.ETY_SIZE &&
10542: paramY.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER)) &&
10543: paramX.exlValueType == ElementType.ETY_FLOAT) {
10544: paramX = new ExpressionElement (
10545: ElementType.ETY_SCALE_FACTOR, 0,
10546: ElementType.ETY_UNDEF, null, null,
10547: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset,
10548: paramY, paramX, null);
10549: continue;
10550: }
10551: }
10552: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10553: evxPrintError (Multilingual.mlnJapanese ?
10554: "1 番目の引数の型が違います" :
10555: "wrong type of the 1st parameter",
10556: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10557: } else {
10558: evxPrintError (Multilingual.mlnJapanese ?
10559: "2 番目の引数の型が違います" :
10560: "wrong type of the 2nd parameter",
10561: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10562: }
10563: return null;
10564: }
10565: return paramX;
10566: }
10567:
10568:
10569:
10570:
10571: protected ExpressionElement evxParseAddition (LinkedList<ExpressionElement> tokenList, int mode) {
10572: ExpressionElement paramX = evxParseMultiplication (tokenList, mode);
10573: if (paramX == null) {
10574: return null;
10575: }
10576: ExpressionElement operator = tokenList.peekFirst ();
10577: while (operator != null) {
10578: ElementType type = operator.exlType;
10579: ElementType valueType = paramX.exlValueType;
10580: ExpressionElement paramY;
10581: if (type == ElementType.ETY_TOKEN_PLUS_SIGN) {
10582: tokenList.pollFirst ();
10583: if (mode == EVM_ASSEMBLER &&
10584: paramX.exlType == ElementType.ETY_REGISTER_INDIRECT &&
10585: 8 <= paramX.exlSubscript) {
10586: return new ExpressionElement (
10587: ElementType.ETY_POSTINCREMENT, paramX.exlSubscript - 8,
10588: ElementType.ETY_UNDEF, null, null,
10589: paramX.exlSource, paramX.exlOffset, operator.exlOffset + operator.exlLength - paramX.exlOffset,
10590: null, null, null);
10591: }
10592: paramY = evxParseMultiplication (tokenList, mode);
10593: if (paramY == null) {
10594: return null;
10595: }
10596: if (paramX.exlValueType == ElementType.ETY_FLOAT) {
10597: if (paramY.exlValueType == ElementType.ETY_FLOAT) {
10598: type = ElementType.ETY_OPERATOR_ADDITION_FLOAT_FLOAT;
10599: valueType = ElementType.ETY_FLOAT;
10600: } else if (paramY.exlValueType == ElementType.ETY_STRING) {
10601: type = ElementType.ETY_OPERATOR_ADDITION_FLOAT_STRING;
10602: valueType = ElementType.ETY_STRING;
10603: } else {
10604: if (mode != EVM_ASSEMBLER) {
10605: evxPrintError (Multilingual.mlnJapanese ?
10606: "2 番目の引数の型が違います" :
10607: "wrong type of the 2nd parameter",
10608: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset);
10609: return null;
10610: }
10611: }
10612: } else if (paramX.exlValueType == ElementType.ETY_STRING) {
10613: if (paramY.exlValueType == ElementType.ETY_FLOAT) {
10614: type = ElementType.ETY_OPERATOR_ADDITION_STRING_FLOAT;
10615: valueType = ElementType.ETY_STRING;
10616: } else if (paramY.exlValueType == ElementType.ETY_STRING) {
10617: type = ElementType.ETY_OPERATOR_ADDITION_STRING_STRING;
10618: valueType = ElementType.ETY_STRING;
10619: } else {
10620: if (mode != EVM_ASSEMBLER) {
10621: evxPrintError (Multilingual.mlnJapanese ?
10622: "2 番目の引数の型が違います" :
10623: "wrong type of the 2nd parameter",
10624: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset);
10625: return null;
10626: }
10627: }
10628: } else {
10629: if (mode != EVM_ASSEMBLER) {
10630: evxPrintError (Multilingual.mlnJapanese ?
10631: "1 番目の引数の型が違います" :
10632: "wrong type of the 1st parameter",
10633: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset);
10634: return null;
10635: }
10636: }
10637: } else if (mode != EVM_ASSEMBLER &&
10638: type == ElementType.ETY_TOKEN_HYPHEN_MINUS) {
10639: tokenList.pollFirst ();
10640: paramY = evxParseMultiplication (tokenList, mode);
10641: if (paramY == null) {
10642: return null;
10643: }
10644: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10645: evxPrintError (Multilingual.mlnJapanese ?
10646: "1 番目の引数の型が違います" :
10647: "wrong type of the 1st parameter",
10648: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset);
10649: return null;
10650: }
10651: if (paramY.exlValueType != ElementType.ETY_FLOAT) {
10652: evxPrintError (Multilingual.mlnJapanese ?
10653: "2 番目の引数の型が違います" :
10654: "wrong type of the 2nd parameter",
10655: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset);
10656: return null;
10657: }
10658: type = ElementType.ETY_OPERATOR_SUBTRACTION;
10659: valueType = ElementType.ETY_FLOAT;
10660: } else {
10661: return paramX;
10662: }
10663: paramX = new ExpressionElement (
10664: type, 0,
10665: valueType, null, null,
10666: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset,
10667: paramX, paramY, null);
10668: operator = tokenList.peekFirst ();
10669: }
10670: return paramX;
10671: }
10672:
10673:
10674:
10675:
10676: protected ExpressionElement evxParseShift (LinkedList<ExpressionElement> tokenList, int mode) {
10677: ExpressionElement paramX = evxParseAddition (tokenList, mode);
10678: if (paramX == null) {
10679: return null;
10680: }
10681: ExpressionElement elem = tokenList.peekFirst ();
10682: while (elem != null) {
10683: switch (elem.exlType) {
10684: case ETY_OPERATOR_LEFT_SHIFT:
10685: case ETY_OPERATOR_RIGHT_SHIFT:
10686: case ETY_OPERATOR_UNSIGNED_RIGHT_SHIFT:
10687: break;
10688: default:
10689: return paramX;
10690: }
10691: tokenList.pollFirst ();
10692: ExpressionElement paramY = evxParseAddition (tokenList, mode);
10693: if (paramY == null) {
10694: return null;
10695: }
10696: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10697: evxPrintError (Multilingual.mlnJapanese ?
10698: "1 番目の引数の型が違います" :
10699: "wrong type of the 1st parameter",
10700: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10701: return null;
10702: }
10703: if (paramY.exlValueType != ElementType.ETY_FLOAT) {
10704: evxPrintError (Multilingual.mlnJapanese ?
10705: "2 番目の引数の型が違います" :
10706: "wrong type of the 2nd parameter",
10707: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10708: return null;
10709: }
10710: elem.exlValueType = ElementType.ETY_FLOAT;
10711: elem.exlParamX = paramX;
10712: elem.exlParamY = paramY;
10713: elem.exlOffset = paramX.exlOffset;
10714: elem.exlLength = paramY.exlOffset + paramY.exlLength - elem.exlOffset;
10715: paramX = elem;
10716: elem = tokenList.peekFirst ();
10717: }
10718: return paramX;
10719: }
10720:
10721:
10722:
10723:
10724: protected ExpressionElement evxParseComparison (LinkedList<ExpressionElement> tokenList, int mode) {
10725: ExpressionElement paramX = evxParseShift (tokenList, mode);
10726: if (paramX == null) {
10727: return null;
10728: }
10729: ExpressionElement elem = tokenList.peekFirst ();
10730: while (elem != null) {
10731: switch (elem.exlType) {
10732: case ETY_OPERATOR_LESS_THAN:
10733: case ETY_OPERATOR_LESS_OR_EQUAL:
10734: case ETY_OPERATOR_GREATER_THAN:
10735: case ETY_OPERATOR_GREATER_OR_EQUAL:
10736: break;
10737: default:
10738: return paramX;
10739: }
10740: tokenList.pollFirst ();
10741: ExpressionElement paramY = evxParseShift (tokenList, mode);
10742: if (paramY == null) {
10743: return null;
10744: }
10745: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10746: evxPrintError (Multilingual.mlnJapanese ?
10747: "1 番目の引数の型が違います" :
10748: "wrong type of the 1st parameter",
10749: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10750: return null;
10751: }
10752: if (paramY.exlValueType != ElementType.ETY_FLOAT) {
10753: evxPrintError (Multilingual.mlnJapanese ?
10754: "2 番目の引数の型が違います" :
10755: "wrong type of the 2nd parameter",
10756: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10757: return null;
10758: }
10759: elem.exlValueType = ElementType.ETY_FLOAT;
10760: elem.exlParamX = paramX;
10761: elem.exlParamY = paramY;
10762: elem.exlOffset = paramX.exlOffset;
10763: elem.exlLength = paramY.exlOffset + paramY.exlLength - elem.exlOffset;
10764: paramX = elem;
10765: elem = tokenList.peekFirst ();
10766: }
10767: return paramX;
10768: }
10769:
10770:
10771:
10772:
10773: protected ExpressionElement evxParseEquality (LinkedList<ExpressionElement> tokenList, int mode) {
10774: ExpressionElement paramX = evxParseComparison (tokenList, mode);
10775: if (paramX == null) {
10776: return null;
10777: }
10778: ExpressionElement elem = tokenList.peekFirst ();
10779: while (elem != null) {
10780: switch (elem.exlType) {
10781: case ETY_OPERATOR_EQUAL:
10782: case ETY_OPERATOR_NOT_EQUAL:
10783: break;
10784: default:
10785: return paramX;
10786: }
10787: tokenList.pollFirst ();
10788: ExpressionElement paramY = evxParseComparison (tokenList, mode);
10789: if (paramY == null) {
10790: return null;
10791: }
10792: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10793: evxPrintError (Multilingual.mlnJapanese ?
10794: "1 番目の引数の型が違います" :
10795: "wrong type of the 1st parameter",
10796: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10797: return null;
10798: }
10799: if (paramY.exlValueType != ElementType.ETY_FLOAT) {
10800: evxPrintError (Multilingual.mlnJapanese ?
10801: "2 番目の引数の型が違います" :
10802: "wrong type of the 2nd parameter",
10803: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10804: return null;
10805: }
10806: elem.exlValueType = ElementType.ETY_FLOAT;
10807: elem.exlParamX = paramX;
10808: elem.exlParamY = paramY;
10809: elem.exlOffset = paramX.exlOffset;
10810: elem.exlLength = paramY.exlOffset + paramY.exlLength - elem.exlOffset;
10811: paramX = elem;
10812: elem = tokenList.peekFirst ();
10813: }
10814: return paramX;
10815: }
10816:
10817:
10818:
10819:
10820: protected ExpressionElement evxParseBitwiseAnd (LinkedList<ExpressionElement> tokenList, int mode) {
10821: ExpressionElement paramX = evxParseEquality (tokenList, mode);
10822: if (paramX == null) {
10823: return null;
10824: }
10825: ExpressionElement elem = tokenList.peekFirst ();
10826: while (elem != null) {
10827: switch (elem.exlType) {
10828: case ETY_OPERATOR_BITWISE_AND:
10829: break;
10830: default:
10831: return paramX;
10832: }
10833: tokenList.pollFirst ();
10834: ExpressionElement paramY = evxParseEquality (tokenList, mode);
10835: if (paramY == null) {
10836: return null;
10837: }
10838: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10839: evxPrintError (Multilingual.mlnJapanese ?
10840: "1 番目の引数の型が違います" :
10841: "wrong type of the 1st parameter",
10842: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10843: return null;
10844: }
10845: if (paramY.exlValueType != ElementType.ETY_FLOAT) {
10846: evxPrintError (Multilingual.mlnJapanese ?
10847: "2 番目の引数の型が違います" :
10848: "wrong type of the 2nd parameter",
10849: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10850: return null;
10851: }
10852: elem.exlValueType = ElementType.ETY_FLOAT;
10853: elem.exlParamX = paramX;
10854: elem.exlParamY = paramY;
10855: elem.exlOffset = paramX.exlOffset;
10856: elem.exlLength = paramY.exlOffset + paramY.exlLength - elem.exlOffset;
10857: paramX = elem;
10858: elem = tokenList.peekFirst ();
10859: }
10860: return paramX;
10861: }
10862:
10863:
10864:
10865:
10866: protected ExpressionElement evxParseBitwiseXor (LinkedList<ExpressionElement> tokenList, int mode) {
10867: ExpressionElement paramX = evxParseBitwiseAnd (tokenList, mode);
10868: if (paramX == null) {
10869: return null;
10870: }
10871: ExpressionElement elem = tokenList.peekFirst ();
10872: while (elem != null) {
10873: switch (elem.exlType) {
10874: case ETY_OPERATOR_BITWISE_XOR:
10875: break;
10876: default:
10877: return paramX;
10878: }
10879: tokenList.pollFirst ();
10880: ExpressionElement paramY = evxParseBitwiseAnd (tokenList, mode);
10881: if (paramY == null) {
10882: return null;
10883: }
10884: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10885: evxPrintError (Multilingual.mlnJapanese ?
10886: "1 番目の引数の型が違います" :
10887: "wrong type of the 1st parameter",
10888: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10889: return null;
10890: }
10891: if (paramY.exlValueType != ElementType.ETY_FLOAT) {
10892: evxPrintError (Multilingual.mlnJapanese ?
10893: "2 番目の引数の型が違います" :
10894: "wrong type of the 2nd parameter",
10895: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10896: return null;
10897: }
10898: elem.exlValueType = ElementType.ETY_FLOAT;
10899: elem.exlParamX = paramX;
10900: elem.exlParamY = paramY;
10901: elem.exlOffset = paramX.exlOffset;
10902: elem.exlLength = paramY.exlOffset + paramY.exlLength - elem.exlOffset;
10903: paramX = elem;
10904: elem = tokenList.peekFirst ();
10905: }
10906: return paramX;
10907: }
10908:
10909:
10910:
10911:
10912: protected ExpressionElement evxParseBitwiseOr (LinkedList<ExpressionElement> tokenList, int mode) {
10913: ExpressionElement paramX = evxParseBitwiseXor (tokenList, mode);
10914: if (paramX == null) {
10915: return null;
10916: }
10917: ExpressionElement elem = tokenList.peekFirst ();
10918: while (elem != null) {
10919: switch (elem.exlType) {
10920: case ETY_OPERATOR_BITWISE_OR:
10921: break;
10922: default:
10923: return paramX;
10924: }
10925: tokenList.pollFirst ();
10926: ExpressionElement paramY = evxParseBitwiseXor (tokenList, mode);
10927: if (paramY == null) {
10928: return null;
10929: }
10930: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10931: evxPrintError (Multilingual.mlnJapanese ?
10932: "1 番目の引数の型が違います" :
10933: "wrong type of the 1st parameter",
10934: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10935: return null;
10936: }
10937: if (paramY.exlValueType != ElementType.ETY_FLOAT) {
10938: evxPrintError (Multilingual.mlnJapanese ?
10939: "2 番目の引数の型が違います" :
10940: "wrong type of the 2nd parameter",
10941: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10942: return null;
10943: }
10944: elem.exlValueType = ElementType.ETY_FLOAT;
10945: elem.exlParamX = paramX;
10946: elem.exlParamY = paramY;
10947: elem.exlOffset = paramX.exlOffset;
10948: elem.exlLength = paramY.exlOffset + paramY.exlLength - elem.exlOffset;
10949: paramX = elem;
10950: elem = tokenList.peekFirst ();
10951: }
10952: return paramX;
10953: }
10954:
10955:
10956:
10957:
10958: protected ExpressionElement evxParseLogicalAnd (LinkedList<ExpressionElement> tokenList, int mode) {
10959: ExpressionElement paramX = evxParseBitwiseOr (tokenList, mode);
10960: if (paramX == null) {
10961: return null;
10962: }
10963: ExpressionElement elem = tokenList.peekFirst ();
10964: while (elem != null) {
10965: switch (elem.exlType) {
10966: case ETY_OPERATOR_LOGICAL_AND:
10967: break;
10968: default:
10969: return paramX;
10970: }
10971: tokenList.pollFirst ();
10972: ExpressionElement paramY = evxParseBitwiseOr (tokenList, mode);
10973: if (paramY == null) {
10974: return null;
10975: }
10976: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
10977: evxPrintError (Multilingual.mlnJapanese ?
10978: "1 番目の引数の型が違います" :
10979: "wrong type of the 1st parameter",
10980: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
10981: return null;
10982: }
10983: if (paramY.exlValueType != ElementType.ETY_FLOAT) {
10984: evxPrintError (Multilingual.mlnJapanese ?
10985: "2 番目の引数の型が違います" :
10986: "wrong type of the 2nd parameter",
10987: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
10988: return null;
10989: }
10990: elem.exlValueType = ElementType.ETY_FLOAT;
10991: elem.exlParamX = paramX;
10992: elem.exlParamY = paramY;
10993: elem.exlOffset = paramX.exlOffset;
10994: elem.exlLength = paramY.exlOffset + paramY.exlLength - elem.exlOffset;
10995: paramX = elem;
10996: elem = tokenList.peekFirst ();
10997: }
10998: return paramX;
10999: }
11000:
11001:
11002:
11003:
11004: protected ExpressionElement evxParseLogicalOr (LinkedList<ExpressionElement> tokenList, int mode) {
11005: ExpressionElement paramX = evxParseLogicalAnd (tokenList, mode);
11006: if (paramX == null) {
11007: return null;
11008: }
11009: ExpressionElement elem = tokenList.peekFirst ();
11010: while (elem != null) {
11011: switch (elem.exlType) {
11012: case ETY_OPERATOR_LOGICAL_OR:
11013: break;
11014: default:
11015: return paramX;
11016: }
11017: tokenList.pollFirst ();
11018: ExpressionElement paramY = evxParseLogicalAnd (tokenList, mode);
11019: if (paramY == null) {
11020: return null;
11021: }
11022: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
11023: evxPrintError (Multilingual.mlnJapanese ?
11024: "1 番目の引数の型が違います" :
11025: "wrong type of the 1st parameter",
11026: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
11027: return null;
11028: }
11029: if (paramY.exlValueType != ElementType.ETY_FLOAT) {
11030: evxPrintError (Multilingual.mlnJapanese ?
11031: "2 番目の引数の型が違います" :
11032: "wrong type of the 2nd parameter",
11033: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
11034: return null;
11035: }
11036: elem.exlValueType = ElementType.ETY_FLOAT;
11037: elem.exlParamX = paramX;
11038: elem.exlParamY = paramY;
11039: elem.exlOffset = paramX.exlOffset;
11040: elem.exlLength = paramY.exlOffset + paramY.exlLength - elem.exlOffset;
11041: paramX = elem;
11042: elem = tokenList.peekFirst ();
11043: }
11044: return paramX;
11045: }
11046:
11047:
11048:
11049:
11050: protected ExpressionElement evxParseConditional (LinkedList<ExpressionElement> tokenList, int mode) {
11051: ExpressionElement paramX = evxParseLogicalOr (tokenList, mode);
11052: if (paramX == null) {
11053: return null;
11054: }
11055: ExpressionElement elem = tokenList.peekFirst ();
11056: if (elem != null) {
11057: switch (elem.exlType) {
11058: case ETY_TOKEN_QUESTION_MARK:
11059: break;
11060: default:
11061: return paramX;
11062: }
11063: tokenList.pollFirst ();
11064: ExpressionElement paramY = evxParseConditional (tokenList, mode);
11065: if (paramY == null) {
11066: return null;
11067: }
11068: ExpressionElement colon = tokenList.pollFirst ();
11069: if (colon == null) {
11070: evxPrintError (Multilingual.mlnJapanese ?
11071: ": がありません" :
11072: ": is not found",
11073: elem.exlSource, -1, 1);
11074: return null;
11075: }
11076: if (colon.exlType != ElementType.ETY_TOKEN_COLON) {
11077: evxPrintError (Multilingual.mlnJapanese ?
11078: ": がありません" :
11079: ": is not found",
11080: colon.exlSource, colon.exlOffset, 1);
11081: return null;
11082: }
11083: ExpressionElement paramZ = evxParseConditional (tokenList, mode);
11084: if (paramZ == null) {
11085: return null;
11086: }
11087: if (paramX.exlValueType != ElementType.ETY_FLOAT) {
11088: evxPrintError (Multilingual.mlnJapanese ?
11089: "1 番目の引数の型が違います" :
11090: "wrong type of the 1st parameter",
11091: paramX.exlSource, paramX.exlOffset, paramZ.exlOffset + paramZ.exlLength - paramX.exlOffset);
11092: return null;
11093: }
11094: if (!(paramY.exlValueType == ElementType.ETY_FLOAT ||
11095: paramY.exlValueType == ElementType.ETY_STRING)) {
11096: evxPrintError (Multilingual.mlnJapanese ?
11097: "2 番目の引数の型が違います" :
11098: "wrong type of the 2nd parameter",
11099: paramX.exlSource, paramX.exlOffset, paramZ.exlOffset + paramZ.exlLength - paramX.exlOffset);
11100: return null;
11101: } else if (paramY.exlValueType != paramZ.exlValueType) {
11102: evxPrintError (Multilingual.mlnJapanese ?
11103: "3 番目の引数の型が違います" :
11104: "wrong type of the 3rd parameter",
11105: paramX.exlSource, paramX.exlOffset, paramZ.exlOffset + paramZ.exlLength - paramX.exlOffset);
11106: return null;
11107: }
11108: elem.exlType = paramY.exlValueType == ElementType.ETY_FLOAT ? ElementType.ETY_OPERATOR_CONDITIONAL_FLOAT : ElementType.ETY_OPERATOR_CONDITIONAL_STRING;
11109: elem.exlValueType = paramY.exlValueType;
11110: elem.exlParamX = paramX;
11111: elem.exlParamY = paramY;
11112: elem.exlParamZ = paramZ;
11113: elem.exlOffset = paramX.exlOffset;
11114: elem.exlLength = paramZ.exlOffset + paramZ.exlLength - paramX.exlOffset;
11115: return elem;
11116: }
11117: return paramX;
11118: }
11119:
11120:
11121:
11122:
11123: protected ExpressionElement evxParseAssignment (LinkedList<ExpressionElement> tokenList, int mode) {
11124: ExpressionElement paramX = evxParseConditional (tokenList, mode);
11125: if (paramX == null) {
11126: return null;
11127: }
11128: ExpressionElement elem = tokenList.peekFirst ();
11129: if (elem != null) {
11130: switch (elem.exlType) {
11131: case ETY_OPERATOR_ASSIGNMENT:
11132: case ETY_OPERATOR_SELF_POWER:
11133: case ETY_OPERATOR_SELF_MULTIPLICATION:
11134: case ETY_OPERATOR_SELF_DIVISION:
11135: case ETY_OPERATOR_SELF_MODULUS:
11136: case ETY_OPERATOR_SELF_ADDITION:
11137: case ETY_OPERATOR_SELF_SUBTRACTION:
11138: case ETY_OPERATOR_SELF_LEFT_SHIFT:
11139: case ETY_OPERATOR_SELF_RIGHT_SHIFT:
11140: case ETY_OPERATOR_SELF_UNSIGNED_RIGHT_SHIFT:
11141: case ETY_OPERATOR_SELF_BITWISE_AND:
11142: case ETY_OPERATOR_SELF_BITWISE_XOR:
11143: case ETY_OPERATOR_SELF_BITWISE_OR:
11144: break;
11145: default:
11146: return paramX;
11147: }
11148: tokenList.pollFirst ();
11149: ExpressionElement paramY = evxParseAssignment (tokenList, mode);
11150: if (paramY == null) {
11151: return null;
11152: }
11153: if (mode == EVM_ASSEMBLER) {
11154: evxPrintError (Multilingual.mlnJapanese ?
11155: "副作用を起こす演算子はここでは使えません" :
11156: "operators which cause a side effect is unusable here",
11157: elem.exlSource, elem.exlOffset, elem.exlLength);
11158: return null;
11159: }
11160: if (!(paramX.exlIsFloatSubstituend () ||
11161: paramX.exlType == ElementType.ETY_VARIABLE_STRING)) {
11162: evxPrintError (Multilingual.mlnJapanese ?
11163: "引数が場所を示していません" :
11164: "parameter is not indicating a location",
11165: paramX.exlSource, paramX.exlOffset, paramX.exlLength);
11166: return null;
11167: }
11168: if (elem.exlType == ElementType.ETY_OPERATOR_ASSIGNMENT &&
11169: paramX.exlType == ElementType.ETY_VARIABLE_STRING &&
11170: paramY.exlValueType == ElementType.ETY_STRING) {
11171: elem.exlType = ElementType.ETY_OPERATOR_ASSIGN_STRING_TO_VARIABLE;
11172: elem.exlValueType = ElementType.ETY_STRING;
11173: } else if (elem.exlType == ElementType.ETY_OPERATOR_SELF_ADDITION &&
11174: paramX.exlType == ElementType.ETY_VARIABLE_STRING &&
11175: paramY.exlValueType == ElementType.ETY_STRING) {
11176: elem.exlType = ElementType.ETY_OPERATOR_CONCAT_STRING_TO_VARIABLE;
11177: elem.exlValueType = ElementType.ETY_STRING;
11178: } else if (elem.exlType == ElementType.ETY_OPERATOR_ASSIGNMENT &&
11179: paramX.exlType == ElementType.ETY_SQUARE_BRACKET &&
11180: paramY.exlValueType == ElementType.ETY_STRING) {
11181: elem.exlType = ElementType.ETY_OPERATOR_ASSIGN_STRING_TO_MEMORY;
11182: elem.exlValueType = ElementType.ETY_STRING;
11183: } else if (elem.exlType == ElementType.ETY_OPERATOR_SELF_ADDITION &&
11184: paramX.exlType == ElementType.ETY_SQUARE_BRACKET &&
11185: paramY.exlValueType == ElementType.ETY_STRING) {
11186: elem.exlType = ElementType.ETY_OPERATOR_CONCAT_STRING_TO_MEMORY;
11187: elem.exlValueType = ElementType.ETY_STRING;
11188: } else if (paramX.exlType != ElementType.ETY_VARIABLE_STRING &&
11189: paramY.exlValueType == ElementType.ETY_FLOAT) {
11190: elem.exlValueType = ElementType.ETY_FLOAT;
11191: } else {
11192: evxPrintError (Multilingual.mlnJapanese ?
11193: "引数の型が違います" :
11194: "wrong type of parameter",
11195: paramY.exlSource, paramY.exlOffset, paramY.exlLength);
11196: return null;
11197: }
11198: elem.exlParamX = paramX;
11199: elem.exlParamY = paramY;
11200: elem.exlOffset = paramX.exlOffset;
11201: elem.exlLength = paramY.exlOffset + paramY.exlLength - elem.exlOffset;
11202: return elem;
11203: }
11204: return paramX;
11205: }
11206:
11207:
11208:
11209:
11210: protected ExpressionElement evxParseColon (LinkedList<ExpressionElement> tokenList, int mode) {
11211:
11212: ExpressionElement paramX = evxParseAssignment (tokenList, mode);
11213: if (paramX == null) {
11214: return null;
11215: }
11216: for (ExpressionElement operator = tokenList.peekFirst ();
11217: operator != null && operator.exlType == ElementType.ETY_TOKEN_COLON;
11218: operator = tokenList.peekFirst ()) {
11219: tokenList.pollFirst ();
11220:
11221: ExpressionElement paramY = evxParseAssignment (tokenList, mode);
11222: if (paramY == null) {
11223: return null;
11224: }
11225: if (mode == EVM_ASSEMBLER) {
11226: if (paramX.exlType == ElementType.ETY_INTEGER_REGISTER && paramX.exlSubscript < 8 &&
11227: paramY.exlType == ElementType.ETY_INTEGER_REGISTER && paramY.exlSubscript < 8) {
11228:
11229: int h = paramX.exlSubscript;
11230: int l = paramY.exlSubscript;
11231: int subscript = h << 3 | l;
11232: return new ExpressionElement (
11233: ElementType.ETY_DATA_REGISTER_PAIR, subscript,
11234: ElementType.ETY_UNDEF, null, null,
11235: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset,
11236: null, null, null);
11237: }
11238: if (paramX.exlType == ElementType.ETY_REGISTER_INDIRECT &&
11239: paramY.exlType == ElementType.ETY_REGISTER_INDIRECT) {
11240:
11241: int r = paramX.exlSubscript;
11242: int s = paramY.exlSubscript;
11243: int subscript = r << 4 | s;
11244: return new ExpressionElement (
11245: ElementType.ETY_REGISTER_INDIRECT_PAIR, subscript,
11246: ElementType.ETY_UNDEF, null, null,
11247: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset,
11248: null, null, null);
11249: }
11250: }
11251: paramX = new ExpressionElement (
11252: ElementType.ETY_OPERATOR_COLON, 0,
11253: ElementType.ETY_UNDEF, null, null,
11254: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset,
11255: paramX, paramY, null);
11256: }
11257: return paramX;
11258: }
11259:
11260:
11261:
11262:
11263: protected ExpressionElement evxParseComma (LinkedList<ExpressionElement> tokenList, int mode) {
11264:
11265: ExpressionElement paramX = evxParseColon (tokenList, mode);
11266: if (paramX == null) {
11267: return null;
11268: }
11269: for (ExpressionElement operator = tokenList.peekFirst ();
11270: operator != null && operator.exlType == ElementType.ETY_TOKEN_COMMA;
11271: operator = tokenList.peekFirst ()) {
11272: tokenList.pollFirst ();
11273:
11274: ExpressionElement paramY = evxParseColon (tokenList, mode);
11275: if (paramY == null) {
11276: return null;
11277: }
11278: paramX = new ExpressionElement (
11279: ElementType.ETY_OPERATOR_COMMA, 0,
11280: paramY.exlValueType, null, null,
11281: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset,
11282: paramX, paramY, null);
11283: }
11284: return paramX;
11285: }
11286:
11287:
11288:
11289:
11290: protected ExpressionElement evxParseCommand (LinkedList<ExpressionElement> tokenList, int mode) {
11291: ExpressionElement elem = tokenList.peekFirst ();
11292: if (elem == null) {
11293: return null;
11294: }
11295: int minParamCount = 0;
11296: int maxParamCount = 0;
11297: switch (elem.exlType) {
11298: case ETY_COMMAND_RUN:
11299: case ETY_COMMAND_STEP:
11300: case ETY_COMMAND_TRACE:
11301: case ETY_COMMAND_TRACE_REGS:
11302: case ETY_COMMAND_TRACE_FLOAT_REGS:
11303: maxParamCount = 1;
11304: break;
11305: case ETY_COMMAND_DUMP:
11306: case ETY_COMMAND_LIST:
11307: maxParamCount = 2;
11308: break;
11309: case ETY_COMMAND_MEMORY_EDIT:
11310: minParamCount = 1 + 1;
11311: maxParamCount = 1 + 65536;
11312: break;
11313: case ETY_COMMAND_FILL:
11314: case ETY_COMMAND_MEMORY_SEARCH:
11315: minParamCount = 2 + 1;
11316: maxParamCount = 2 + 65536;
11317: break;
11318: case ETY_COMMAND_HELP:
11319: maxParamCount = 65536;
11320: break;
11321: case ETY_COMMAND_PRINT:
11322: maxParamCount = 65536;
11323: break;
11324: case ETY_COMMAND_STOP:
11325: case ETY_COMMAND_LABEL_LIST:
11326: case ETY_COMMAND_RETURN:
11327: case ETY_COMMAND_REGS:
11328: case ETY_COMMAND_FLOAT_REGS:
11329: break;
11330: default:
11331: return evxParseComma (tokenList, mode);
11332: }
11333: elem = tokenList.pollFirst ();
11334: int paramCount = 0;
11335: ExpressionElement paramX = null;
11336: if (!tokenList.isEmpty () &&
11337: tokenList.peekFirst ().exlType != ElementType.ETY_TOKEN_SEMICOLON) {
11338: paramX = evxParseComma (tokenList, mode);
11339: if (paramX == null) {
11340: return null;
11341: }
11342: paramCount = paramX.exlLengthOfCommaList ();
11343: }
11344: if (paramCount < minParamCount) {
11345: evxPrintError (Multilingual.mlnJapanese ?
11346: "引数が足りません" :
11347: "too few arguments",
11348: elem.exlSource, elem.exlOffset, elem.exlLength);
11349: return null;
11350: }
11351: if (maxParamCount < paramCount) {
11352: evxPrintError (Multilingual.mlnJapanese ?
11353: "引数が多すぎます" :
11354: "too many arguments",
11355: elem.exlSource, elem.exlOffset, elem.exlLength);
11356: return null;
11357: }
11358: elem.exlValueType = ElementType.ETY_VOID;
11359: elem.exlParamX = paramX;
11360: return elem;
11361: }
11362:
11363:
11364:
11365:
11366: protected ExpressionElement evxParseLine (LinkedList<ExpressionElement> tokenList, int mode) {
11367: ExpressionElement paramX = null;
11368: String stringValue = null;
11369: int subscript = -1;
11370: ExpressionElement paramY = null;
11371: ExpressionElement elem = tokenList.peekFirst ();
11372: if (elem == null) {
11373: return null;
11374: }
11375: ExpressionElement head = elem;
11376: ExpressionElement tail = elem;
11377:
11378: if (elem.exlType == ElementType.ETY_LABEL_DEFINITION ||
11379: elem.exlType == ElementType.ETY_LOCAL_LABEL_DEFINITION) {
11380: paramX = elem;
11381: tokenList.pollFirst ();
11382: elem = tokenList.peekFirst ();
11383: }
11384:
11385: elem = tokenList.peekFirst ();
11386: if (elem != null && elem.exlType == ElementType.ETY_MNEMONIC) {
11387: tail = elem;
11388: stringValue = elem.exlStringValue;
11389: tokenList.pollFirst ();
11390: elem = tokenList.peekFirst ();
11391:
11392: if (elem != null && (elem.exlType == ElementType.ETY_OPERATOR_SIZE_BYTE ||
11393: elem.exlType == ElementType.ETY_OPERATOR_SIZE_WORD ||
11394: elem.exlType == ElementType.ETY_OPERATOR_SIZE_LONG ||
11395: elem.exlType == ElementType.ETY_OPERATOR_SIZE_QUAD ||
11396: elem.exlType == ElementType.ETY_OPERATOR_SIZE_SINGLE ||
11397: elem.exlType == ElementType.ETY_OPERATOR_SIZE_DOUBLE ||
11398: elem.exlType == ElementType.ETY_OPERATOR_SIZE_EXTENDED ||
11399: elem.exlType == ElementType.ETY_OPERATOR_SIZE_PACKED)) {
11400: tail = elem;
11401: subscript = elem.exlSubscript;
11402: tokenList.pollFirst ();
11403: elem = tokenList.peekFirst ();
11404: }
11405:
11406: if (elem != null && elem.exlType != ElementType.ETY_TOKEN_SEMICOLON) {
11407: paramY = evxParseComma (tokenList, mode);
11408: tail = paramY;
11409: elem = tokenList.peekFirst ();
11410: }
11411: }
11412: if (elem != null && elem.exlType != ElementType.ETY_TOKEN_SEMICOLON) {
11413: evxPrintError (Multilingual.mlnJapanese ?
11414: "文法エラー" :
11415: "syntax error",
11416: elem.exlSource, elem.exlOffset, elem.exlLength);
11417: return null;
11418: }
11419: return new ExpressionElement (
11420: ElementType.ETY_LINE, subscript,
11421: ElementType.ETY_VOID, null, stringValue,
11422: head.exlSource, head.exlOffset, tail.exlOffset + tail.exlLength - head.exlOffset,
11423: paramX, paramY, null);
11424: }
11425:
11426:
11427:
11428:
11429: protected ExpressionElement evxParseSeparator (LinkedList<ExpressionElement> tokenList, int mode) {
11430:
11431: ExpressionElement paramX = (mode == EVM_EXPRESSION ? evxParseComma (tokenList, mode) :
11432: mode == EVM_COMMAND ? evxParseCommand (tokenList, mode) :
11433: mode == EVM_ASSEMBLER ? evxParseLine (tokenList, mode) :
11434: null);
11435: if (paramX == null) {
11436: return null;
11437: }
11438: for (ExpressionElement elem = tokenList.peekFirst ();
11439: elem != null &&
11440: elem.exlType == ElementType.ETY_TOKEN_SEMICOLON;
11441: elem = tokenList.peekFirst ()) {
11442:
11443: do {
11444: tokenList.pollFirst ();
11445: if (tokenList.isEmpty ()) {
11446: break;
11447: }
11448: elem = tokenList.peekFirst ();
11449: } while (elem.exlType == ElementType.ETY_TOKEN_SEMICOLON);
11450:
11451: ExpressionElement paramY = (mode == EVM_EXPRESSION ? evxParseComma (tokenList, mode) :
11452: mode == EVM_COMMAND ? evxParseCommand (tokenList, mode) :
11453: mode == EVM_ASSEMBLER ? evxParseLine (tokenList, mode) :
11454: null);
11455: if (paramY == null) {
11456: return null;
11457: }
11458: ExpressionElement separator = new ExpressionElement (
11459: ElementType.ETY_SEPARATOR, 0,
11460: paramY.exlValueType, null, null,
11461: paramX.exlSource, paramX.exlOffset, paramY.exlOffset + paramY.exlLength - paramX.exlOffset);
11462: separator.exlParamX = paramX;
11463: separator.exlParamY = paramY;
11464: paramX = separator;
11465: }
11466: return paramX;
11467: }
11468:
11469:
11470:
11471:
11472:
11473: public static final int ORM_BASIC = 0;
11474: public static final int ORM_BIT_FIELD = 1;
11475: public static final int ORM_K_FACTOR = 2;
11476: public static final int ORM_RELATIVE = 3;
11477:
11478:
11479:
11480:
11481:
11482:
11483: public static final int ORT_ERROR = -1;
11484: public static final int ORT_DATA_REGISTER = 0;
11485: public static final int ORT_ADDRESS_REGISTER = 1;
11486: public static final int ORT_POSTINCREMENT = 2;
11487: public static final int ORT_PREDECREMENT = 3;
11488: public static final int ORT_IMMEDIATE = 4;
11489: public static final int ORT_ABSOLUTE_ADDRESS = 5;
11490:
11491:
11492: public static final int ORT_RELATIVE_ADDRESS = 6;
11493: public static final int ORT_ADDRESS_INDIRECT = 7;
11494:
11495:
11496: public static final int ORT_PROGRAM_INDIRECT = 8;
11497:
11498:
11499: public static final int ORT_CONDITION_CODE = 9;
11500: public static final int ORT_STATUS_REGISTER = 10;
11501: public static final int ORT_REGISTER_LIST = 11;
11502: public static final int ORT_REGISTER_PAIR = 12;
11503: public static final int ORT_INDIRECT_PAIR = 13;
11504: public static final int ORT_FLOAT_REGISTER = 14;
11505: public static final int ORT_FLOAT_LIST = 15;
11506: public static final int ORT_FLOAT_CONTROL = 16;
11507: public static final int ORT_CACHE_SELECTION = 17;
11508: public static final int ORT_CONTROL_REGISTER = 18;
11509:
11510:
11511:
11512:
11513:
11514: public class Operand {
11515:
11516:
11517: public int asoOperandMode;
11518:
11519:
11520: public ExpressionElement asoOperandElement;
11521: public ExpressionElement asoBasicElement;
11522:
11523:
11524: public int asoMinimumOperationSize;
11525: public int asoMaximumOperationSize;
11526: public int asoOperationSize;
11527:
11528:
11529:
11530:
11531: public boolean asoWithBitField;
11532:
11533: public int asoBitFieldOffsetRegister;
11534: public ExpressionElement asoBitFieldOffsetElement;
11535: public int asoBitFieldOffsetValue;
11536: public int asoBitFieldWidthRegister;
11537: public ExpressionElement asoBitFieldWidthElement;
11538: public int asoBitFieldWidthValue;
11539:
11540:
11541:
11542: public boolean asoWithKFactor;
11543:
11544: public int asoKFactorRegister;
11545: public ExpressionElement asoKFactorElement;
11546: public int asoKFactorValue;
11547:
11548:
11549: public int asoOperandType;
11550: public int asoSubscript;
11551:
11552:
11553:
11554: public boolean asoBaseRegisterSuppress;
11555:
11556: public int asoMinimumBaseDisplacementSize;
11557: public int asoMaximumBaseDisplacementSize;
11558: public ExpressionElement asoBaseDisplacementElement;
11559: public int asoBaseDisplacementValue;
11560: public int asoBaseDisplacementSize;
11561:
11562: public boolean asoMemoryIndirect;
11563:
11564:
11565: public int asoMinimumOuterDisplacementSize;
11566: public int asoMaximumOuterDisplacementSize;
11567: public ExpressionElement asoOuterDisplacementElement;
11568: public int asoOuterDisplacementValue;
11569: public int asoOuterDisplacementSize;
11570:
11571: public boolean asoPostindex;
11572: public boolean asoIndexSuppress;
11573: public int asoIndexRegister;
11574: public ExpressionElement asoScaleFactorElement;
11575: public int asoScaleFactorValue;
11576: public int asoLog2ScaleFactor;
11577:
11578:
11579: public ExpressionElement asoImmediateElement;
11580: public int asoImmediateValue;
11581: public int asoImmediateSize;
11582:
11583:
11584: public int asoMinimumAbsoluteAddressSize;
11585: public int asoMaximumAbsoluteAddressSize;
11586: public ExpressionElement asoAbsoluteAddressElement;
11587: public int asoAbsoluteAddressValue;
11588: public int asoAbsoluteAddressSize;
11589:
11590:
11591:
11592: public int asoBaseAddress;
11593: public ExpressionElement asoRelativeAddressElement;
11594: public int asoRelativeAddressValue;
11595: public int asoRelativeAddressSize;
11596:
11597:
11598:
11599:
11600: public Operand (int operandMode, ExpressionElement operandElement,
11601: int minimumOperationSize, int maximumOperationSize) {
11602: this (operandMode, operandElement,
11603: minimumOperationSize, maximumOperationSize,
11604: 0);
11605: }
11606: public Operand (int operandMode, ExpressionElement operandElement,
11607: int minimumOperationSize, int maximumOperationSize,
11608: int baseAddress) {
11609: asoOperandMode = operandMode;
11610: asoOperandElement = operandElement;
11611: asoMinimumOperationSize = minimumOperationSize;
11612: asoMaximumOperationSize = maximumOperationSize;
11613: asoBaseAddress = baseAddress;
11614:
11615: asoBasicElement = asoOperandElement;
11616: asoOperationSize = maximumOperationSize;
11617:
11618:
11619:
11620:
11621: asoWithBitField = false;
11622: if (asoOperandMode != ORM_BIT_FIELD) {
11623: if (asoOperandElement.exlType == ElementType.ETY_BIT_FIELD) {
11624: evxPrintError (Multilingual.mlnJapanese ?
11625: "予期しないビットフィールド" :
11626: "unexpected bit-field",
11627: asoOperandElement.exlSource, asoOperandElement.exlOffset, asoOperandElement.exlLength);
11628: asoOperandType = ORT_ERROR;
11629: return;
11630: }
11631: } else {
11632: if (asoOperandElement.exlType != ElementType.ETY_BIT_FIELD) {
11633: evxPrintError (Multilingual.mlnJapanese ?
11634: "ビットフィールドが必要です" :
11635: "bit-field is required",
11636: asoOperandElement.exlSource, asoOperandElement.exlOffset, asoOperandElement.exlLength);
11637: asoOperandType = ORT_ERROR;
11638: return;
11639: }
11640: asoBasicElement = asoOperandElement.exlParamX;
11641: asoBitFieldOffsetRegister = -1;
11642: asoBitFieldOffsetElement = asoOperandElement.exlParamY;
11643: if (asoBitFieldOffsetElement.exlType == ElementType.ETY_INTEGER_REGISTER) {
11644: asoBitFieldOffsetRegister = asoBitFieldOffsetElement.exlSubscript;
11645: } else {
11646: if (asoBitFieldOffsetElement.exlType == ElementType.ETY_IMMEDIATE) {
11647: asoBitFieldOffsetElement = asoBitFieldOffsetElement.exlParamX;
11648: }
11649: asoBitFieldOffsetValue = asoBitFieldOffsetElement.exlEval (EVM_EXPRESSION).exlFloatValue.geti ();
11650: }
11651: asoBitFieldWidthRegister = -1;
11652: asoBitFieldWidthElement = asoOperandElement.exlParamZ;
11653: if (asoBitFieldWidthElement.exlType == ElementType.ETY_INTEGER_REGISTER) {
11654: asoBitFieldWidthRegister = asoBitFieldWidthElement.exlSubscript;
11655: } else {
11656: if (asoBitFieldWidthElement.exlType == ElementType.ETY_IMMEDIATE) {
11657: asoBitFieldWidthElement = asoBitFieldWidthElement.exlParamX;
11658: }
11659: asoBitFieldWidthValue = asoBitFieldWidthElement.exlEval (EVM_EXPRESSION).exlFloatValue.geti ();
11660: }
11661: }
11662:
11663:
11664:
11665:
11666: asoWithKFactor = false;
11667: if (asoOperandMode != ORM_K_FACTOR) {
11668: if (asoOperandElement.exlType == ElementType.ETY_K_FACTOR) {
11669: evxPrintError (Multilingual.mlnJapanese ?
11670: "予期しない k-factor" :
11671: "unexpected k-factor",
11672: asoOperandElement.exlSource, asoOperandElement.exlOffset, asoOperandElement.exlLength);
11673: asoOperandType = ORT_ERROR;
11674: return;
11675: }
11676: } else {
11677: if (asoOperandElement.exlType != ElementType.ETY_K_FACTOR) {
11678: evxPrintError (Multilingual.mlnJapanese ?
11679: "k-factor が必要です" :
11680: "k-factor is required",
11681: asoOperandElement.exlSource, asoOperandElement.exlOffset, asoOperandElement.exlLength);
11682: asoOperandType = ORT_ERROR;
11683: return;
11684: }
11685: asoBasicElement = asoOperandElement.exlParamX;
11686: asoKFactorRegister = -1;
11687: asoKFactorElement = asoOperandElement.exlParamY;
11688: if (asoKFactorElement.exlType == ElementType.ETY_INTEGER_REGISTER) {
11689: asoKFactorRegister = asoKFactorElement.exlSubscript;
11690: } else {
11691: if (asoKFactorElement.exlType == ElementType.ETY_IMMEDIATE) {
11692: asoKFactorElement = asoKFactorElement.exlParamX;
11693: }
11694: asoKFactorValue = asoKFactorElement.exlEval (EVM_EXPRESSION).exlFloatValue.geti ();
11695: }
11696: }
11697:
11698:
11699:
11700:
11701: asoBaseRegisterSuppress = false;
11702:
11703: asoMinimumBaseDisplacementSize = 0;
11704: asoMaximumBaseDisplacementSize = 0;
11705: asoBaseDisplacementElement = null;
11706: asoBaseDisplacementValue = 0;
11707: asoBaseDisplacementSize = 0;
11708:
11709: asoMemoryIndirect = false;
11710:
11711: asoMinimumOuterDisplacementSize = 0;
11712: asoMaximumOuterDisplacementSize = 0;
11713: asoOuterDisplacementElement = null;
11714: asoOuterDisplacementValue = 0;
11715: asoOuterDisplacementSize = 0;
11716:
11717: asoPostindex = false;
11718: asoIndexSuppress = true;
11719: asoIndexRegister = 0;
11720: asoScaleFactorElement = null;
11721: asoScaleFactorValue = 1;
11722: asoLog2ScaleFactor = 0;
11723:
11724: asoImmediateElement = null;
11725: asoImmediateValue = 0;
11726: asoImmediateSize = 0;
11727:
11728: asoMinimumAbsoluteAddressSize = 2;
11729: asoMaximumAbsoluteAddressSize = 4;
11730: asoAbsoluteAddressElement = null;
11731: asoAbsoluteAddressValue = 0;
11732: asoAbsoluteAddressSize = 0;
11733:
11734:
11735:
11736: if (asoOperandMode == ORM_RELATIVE) {
11737: if (asoBasicElement.exlValueType != ElementType.ETY_FLOAT) {
11738: evxPrintError (Multilingual.mlnJapanese ?
11739: "相対アドレスが必要です" :
11740: "relative address is required",
11741: asoBasicElement.exlSource, asoBasicElement.exlOffset, asoBasicElement.exlLength);
11742: asoOperandType = ORT_ERROR;
11743: return;
11744: }
11745: asoOperandType = ORT_RELATIVE_ADDRESS;
11746: asoRelativeAddressElement = asoBasicElement;
11747: asoRelativeAddressValue = asoRelativeAddressElement.exlEval (EVM_EXPRESSION).exlFloatValue.geti () - asoBaseAddress;
11748: asoRelativeAddressSize = (asoRelativeAddressValue == 0 ? 0 :
11749: (byte) asoRelativeAddressValue == asoRelativeAddressValue ? 1 :
11750: (short) asoRelativeAddressValue == asoRelativeAddressValue ? 2 :
11751: 4);
11752: return;
11753: }
11754:
11755:
11756:
11757:
11758: if (asoBasicElement.exlType == ElementType.ETY_INTEGER_REGISTER) {
11759: if (asoBasicElement.exlSubscript < 8) {
11760: asoOperandType = ORT_DATA_REGISTER;
11761: asoSubscript = asoBasicElement.exlSubscript;
11762: } else {
11763: asoOperandType = ORT_ADDRESS_REGISTER;
11764: asoSubscript = asoBasicElement.exlSubscript - 8;
11765: }
11766: return;
11767: }
11768:
11769:
11770:
11771: if (asoBasicElement.exlType == ElementType.ETY_POSTINCREMENT) {
11772: asoOperandType = ORT_POSTINCREMENT;
11773: asoSubscript = asoBasicElement.exlSubscript;
11774: return;
11775: }
11776:
11777:
11778:
11779: if (asoBasicElement.exlType == ElementType.ETY_PREDECREMENT) {
11780: asoOperandType = ORT_PREDECREMENT;
11781: asoSubscript = asoBasicElement.exlSubscript;
11782: return;
11783: }
11784:
11785:
11786:
11787: if (asoBasicElement.exlType == ElementType.ETY_IMMEDIATE) {
11788: asoOperandType = ORT_IMMEDIATE;
11789: asoImmediateElement = asoBasicElement.exlParamX;
11790: asoImmediateValue = asoImmediateElement.exlEval (EVM_EXPRESSION).exlFloatValue.geti ();
11791: asoImmediateSize = (asoImmediateValue == 0 ? 0 :
11792: (byte) asoImmediateValue == asoImmediateValue ? 1 :
11793: (short) asoImmediateValue == asoImmediateValue ? 2 :
11794: 4);
11795: return;
11796: }
11797:
11798:
11799:
11800: if (asoBasicElement.exlValueType == ElementType.ETY_FLOAT) {
11801: asoOperandType = ORT_ABSOLUTE_ADDRESS;
11802: asoMinimumAbsoluteAddressSize = 2;
11803: asoMaximumAbsoluteAddressSize = 4;
11804: asoAbsoluteAddressElement = asoBasicElement;
11805: asoAbsoluteAddressValue = asoAbsoluteAddressElement.exlEval (EVM_EXPRESSION).exlFloatValue.geti ();
11806: asoAbsoluteAddressSize = ((short) asoAbsoluteAddressValue == asoAbsoluteAddressValue ? 2 :
11807: 4);
11808: return;
11809: }
11810:
11811:
11812:
11813:
11814: if (asoBasicElement.exlType == ElementType.ETY_SIZE && (asoBasicElement.exlSubscript == 'w' ||
11815: asoBasicElement.exlSubscript == 'l') &&
11816: asoBasicElement.exlParamX.exlValueType == ElementType.ETY_FLOAT) {
11817: asoOperandType = ORT_ABSOLUTE_ADDRESS;
11818: if (asoBasicElement.exlSubscript == 'w') {
11819: asoMinimumAbsoluteAddressSize = 2;
11820: asoMaximumAbsoluteAddressSize = 2;
11821: } else {
11822: asoMinimumAbsoluteAddressSize = 4;
11823: asoMaximumAbsoluteAddressSize = 4;
11824: }
11825: asoAbsoluteAddressElement = asoBasicElement.exlParamX;
11826: asoAbsoluteAddressValue = asoAbsoluteAddressElement.exlEval (EVM_EXPRESSION).exlFloatValue.geti ();
11827: asoAbsoluteAddressSize = ((short) asoAbsoluteAddressValue == asoAbsoluteAddressValue ? 2 :
11828: 4);
11829: return;
11830: }
11831:
11832:
11833:
11834: if (asoBasicElement.exlType == ElementType.ETY_REGISTER_INDIRECT &&
11835: 8 <= asoBasicElement.exlSubscript) {
11836: asoOperandType = ORT_ADDRESS_INDIRECT;
11837: asoSubscript = asoBasicElement.exlSubscript - 8;
11838: return;
11839: }
11840:
11841:
11842:
11843: if (asoBasicElement.exlType == ElementType.ETY_CCR) {
11844: asoOperandType = ORT_CONDITION_CODE;
11845: return;
11846: }
11847:
11848:
11849:
11850: if (asoBasicElement.exlType == ElementType.ETY_SR) {
11851: asoOperandType = ORT_STATUS_REGISTER;
11852: return;
11853: }
11854:
11855:
11856:
11857: if (asoBasicElement.exlType == ElementType.ETY_INTEGER_REGISTER_LIST) {
11858: asoOperandType = ORT_REGISTER_LIST;
11859: asoSubscript = asoBasicElement.exlSubscript;
11860: return;
11861: }
11862:
11863:
11864:
11865: if (asoBasicElement.exlType == ElementType.ETY_DATA_REGISTER_PAIR) {
11866: asoOperandType = ORT_REGISTER_PAIR;
11867: asoSubscript = asoBasicElement.exlSubscript;
11868: return;
11869: }
11870:
11871:
11872:
11873: if (asoBasicElement.exlType == ElementType.ETY_REGISTER_INDIRECT_PAIR) {
11874: asoOperandType = ORT_INDIRECT_PAIR;
11875: asoSubscript = asoBasicElement.exlSubscript;
11876: return;
11877: }
11878:
11879:
11880:
11881: if (asoBasicElement.exlType == ElementType.ETY_FLOATING_POINT_REGISTER) {
11882: asoOperandType = ORT_FLOAT_REGISTER;
11883: asoSubscript = asoBasicElement.exlSubscript;
11884: return;
11885: }
11886:
11887:
11888:
11889: if (asoBasicElement.exlType == ElementType.ETY_FLOATING_POINT_REGISTER_LIST) {
11890: asoOperandType = ORT_FLOAT_LIST;
11891: asoSubscript = asoBasicElement.exlSubscript;
11892: return;
11893: }
11894:
11895:
11896:
11897: if (asoBasicElement.exlType == ElementType.ETY_FLOATING_POINT_CONTROL_REGISTER_LIST) {
11898: asoOperandType = ORT_FLOAT_CONTROL;
11899: asoSubscript = asoBasicElement.exlSubscript;
11900: return;
11901: }
11902:
11903:
11904:
11905: if (asoBasicElement.exlType == ElementType.ETY_CACHE_SELECTION) {
11906: asoOperandType = ORT_CACHE_SELECTION;
11907: asoSubscript = asoBasicElement.exlSubscript;
11908: return;
11909: }
11910:
11911:
11912:
11913: if (asoBasicElement.exlType == ElementType.ETY_CONTROL_REGISTER) {
11914: asoOperandType = ORT_CONTROL_REGISTER;
11915: asoSubscript = asoBasicElement.exlSubscript;
11916: return;
11917: }
11918:
11919:
11920:
11921:
11922:
11923:
11924:
11925:
11926:
11927:
11928:
11929:
11930:
11931:
11932: if (asoBasicElement.exlType == ElementType.ETY_PARENTHESIS) {
11933:
11934:
11935:
11936:
11937:
11938:
11939:
11940: asoMemoryIndirect = false;
11941: LinkedList<ExpressionElement> baseList = asoBasicElement.exlParamX.exlToCommaList ();
11942: LinkedList<ExpressionElement> outerList = null;
11943: for (int i = 0, l = baseList.size (); i < l; i++) {
11944: if (baseList.get (i).exlType == ElementType.ETY_SQUARE_BRACKET) {
11945: asoMemoryIndirect = true;
11946: outerList = baseList;
11947: baseList = outerList.remove (i).exlParamX.exlToCommaList ();
11948: break;
11949: }
11950: }
11951:
11952: asoBaseRegisterSuppress = true;
11953: asoOperandType = ORT_ADDRESS_INDIRECT;
11954: asoSubscript = 0;
11955: for (int i = 0, l = baseList.size (); i < l; i++) {
11956: ExpressionElement e = baseList.get (i);
11957: ElementType t = e.exlType;
11958: if (((t == ElementType.ETY_INTEGER_REGISTER ||
11959: t == ElementType.ETY_ZERO_REGISTER) && 8 <= e.exlSubscript) ||
11960: t == ElementType.ETY_PC ||
11961: t == ElementType.ETY_ZERO_PC) {
11962: baseList.remove (i);
11963: if (t == ElementType.ETY_INTEGER_REGISTER ||
11964: t == ElementType.ETY_ZERO_REGISTER) {
11965: asoOperandType = ORT_ADDRESS_INDIRECT;
11966: asoSubscript = e.exlSubscript - 8;
11967: } else {
11968: asoOperandType = ORT_PROGRAM_INDIRECT;
11969: }
11970: asoBaseRegisterSuppress = (t == ElementType.ETY_ZERO_REGISTER ||
11971: t == ElementType.ETY_ZERO_PC);
11972: break;
11973: }
11974: }
11975:
11976: asoPostindex = false;
11977: asoIndexSuppress = true;
11978: asoIndexRegister = 0;
11979: asoScaleFactorElement = null;
11980: asoScaleFactorValue = 1;
11981: asoLog2ScaleFactor = 0;
11982:
11983: ExpressionElement indexElement = null;
11984: for (int i = 0, l = baseList.size (); i < l; i++) {
11985: ExpressionElement e = baseList.get (i);
11986: ElementType t = e.exlType;
11987: if (t == ElementType.ETY_INTEGER_REGISTER ||
11988: (t == ElementType.ETY_SIZE && (e.exlSubscript == 'w' ||
11989: e.exlSubscript == 'l') &&
11990: e.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) ||
11991: t == ElementType.ETY_SCALE_FACTOR) {
11992: indexElement = e;
11993: baseList.remove (i);
11994: break;
11995: }
11996: }
11997:
11998: if (indexElement == null && asoMemoryIndirect) {
11999: for (int i = 0, l = outerList.size (); i < l; i++) {
12000: ExpressionElement e = outerList.get (i);
12001: ElementType t = e.exlType;
12002: if (t == ElementType.ETY_INTEGER_REGISTER ||
12003: (t == ElementType.ETY_SIZE && (e.exlSubscript == 'w' ||
12004: e.exlSubscript == 'l') &&
12005: e.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER) ||
12006: t == ElementType.ETY_SCALE_FACTOR) {
12007: asoPostindex = true;
12008: indexElement = e;
12009: outerList.remove (i);
12010: break;
12011: }
12012: }
12013: }
12014: if (indexElement != null) {
12015: ExpressionElement e = indexElement;
12016: ElementType t = e.exlType;
12017: asoIndexSuppress = false;
12018: asoIndexRegister = (t == ElementType.ETY_INTEGER_REGISTER ? e.exlSubscript :
12019: t == ElementType.ETY_SIZE ? e.exlParamX.exlSubscript :
12020: e.exlParamX.exlType == ElementType.ETY_INTEGER_REGISTER ? e.exlParamX.exlSubscript :
12021: e.exlParamX.exlParamX.exlSubscript);
12022: if (t == ElementType.ETY_SCALE_FACTOR) {
12023: asoScaleFactorElement = e.exlParamY;
12024: asoScaleFactorValue = asoScaleFactorElement.exlEval (EVM_EXPRESSION).exlFloatValue.geti ();
12025: asoLog2ScaleFactor = (asoScaleFactorValue == 1 ? 0 :
12026: asoScaleFactorValue == 2 ? 1 :
12027: asoScaleFactorValue == 4 ? 2 :
12028: asoScaleFactorValue == 8 ? 3 :
12029: 0);
12030: }
12031: }
12032:
12033: asoMinimumBaseDisplacementSize = 0;
12034: asoMaximumBaseDisplacementSize = 4;
12035: asoBaseDisplacementElement = null;
12036: asoBaseDisplacementValue = 0;
12037: asoBaseDisplacementSize = 0;
12038: for (int i = 0, l = baseList.size (); i < l; i++) {
12039: ExpressionElement e = baseList.get (i);
12040: ElementType t = e.exlType;
12041: if (e.exlValueType == ElementType.ETY_FLOAT) {
12042: asoMinimumBaseDisplacementSize = 0;
12043: asoMaximumBaseDisplacementSize = 4;
12044: asoBaseDisplacementElement = e;
12045: baseList.remove (i);
12046: } else if (t == ElementType.ETY_SIZE && (e.exlSubscript == 'w' ||
12047: e.exlSubscript == 'l') &&
12048: e.exlParamX.exlType == ElementType.ETY_FLOAT) {
12049: asoBaseDisplacementElement = e.exlParamX;
12050: if (e.exlSubscript == 'w') {
12051: asoMinimumBaseDisplacementSize = 2;
12052: asoMaximumBaseDisplacementSize = 2;
12053: } else {
12054: asoMinimumBaseDisplacementSize = 4;
12055: asoMaximumBaseDisplacementSize = 4;
12056: }
12057: baseList.remove (i);
12058: }
12059: asoBaseDisplacementValue = asoBaseDisplacementElement.exlEval (EVM_EXPRESSION).exlFloatValue.geti ();
12060: asoBaseDisplacementSize = (asoBaseDisplacementValue == 0 ? 0 :
12061: !asoMemoryIndirect && (byte) asoBaseDisplacementValue == asoBaseDisplacementValue ? 1 :
12062: (short) asoBaseDisplacementValue == asoBaseDisplacementValue ? 2 :
12063: 4);
12064: break;
12065: }
12066:
12067: asoMinimumOuterDisplacementSize = 0;
12068: asoMaximumOuterDisplacementSize = 4;
12069: asoOuterDisplacementElement = null;
12070: asoOuterDisplacementValue = 0;
12071: asoOuterDisplacementSize = 0;
12072: for (int i = 0, l = outerList.size (); i < l; i++) {
12073: ExpressionElement e = outerList.get (i);
12074: ElementType t = e.exlType;
12075: if (e.exlValueType == ElementType.ETY_FLOAT) {
12076: asoMinimumOuterDisplacementSize = 0;
12077: asoMaximumOuterDisplacementSize = 4;
12078: asoOuterDisplacementElement = e;
12079: outerList.remove (i);
12080: } else if (t == ElementType.ETY_SIZE &&
12081: e.exlParamX.exlType == ElementType.ETY_FLOAT) {
12082: asoOuterDisplacementElement = e.exlParamX;
12083: if (e.exlSubscript == 'w') {
12084: asoMinimumOuterDisplacementSize = 2;
12085: asoMaximumOuterDisplacementSize = 2;
12086: } else {
12087: asoMinimumOuterDisplacementSize = 4;
12088: asoMaximumOuterDisplacementSize = 4;
12089: }
12090: outerList.remove (i);
12091: }
12092: asoOuterDisplacementValue = asoOuterDisplacementElement.exlEval (EVM_EXPRESSION).exlFloatValue.geti ();
12093: asoOuterDisplacementSize = (asoOuterDisplacementValue == 0 ? 0 :
12094: (short) asoOuterDisplacementValue == asoOuterDisplacementValue ? 2 :
12095: 4);
12096: break;
12097: }
12098:
12099: if (0 < baseList.size ()) {
12100: ExpressionElement e = baseList.get (0);
12101: evxPrintError (Multilingual.mlnJapanese ?
12102: "文法エラー" :
12103: "syntax error",
12104: e.exlSource, e.exlOffset, e.exlLength);
12105: asoOperandType = ORT_ERROR;
12106: return;
12107: }
12108: if (0 < outerList.size ()) {
12109: ExpressionElement e = outerList.get (0);
12110: evxPrintError (Multilingual.mlnJapanese ?
12111: "文法エラー" :
12112: "syntax error",
12113: e.exlSource, e.exlOffset, e.exlLength);
12114: asoOperandType = ORT_ERROR;
12115: return;
12116: }
12117: return;
12118: }
12119:
12120: evxPrintError (Multilingual.mlnJapanese ?
12121: "文法エラー" :
12122: "syntax error",
12123: asoBasicElement.exlSource, asoBasicElement.exlOffset, asoBasicElement.exlLength);
12124: asoOperandType = ORT_ERROR;
12125:
12126: }
12127:
12128:
12129:
12130:
12131:
12132:
12133:
12134: public void asoUpdate (int baseAddress, boolean first, boolean last) {
12135: asoBaseAddress = baseAddress;
12136:
12137: }
12138:
12139:
12140:
12141:
12142: public String toString () {
12143: return this.appendTo (new StringBuilder ()).toString ();
12144: }
12145: public StringBuilder appendTo (StringBuilder sb) {
12146: switch (asoOperandType) {
12147:
12148:
12149:
12150: case ORT_DATA_REGISTER:
12151: return sb.append ('d').append (asoSubscript);
12152:
12153:
12154:
12155: case ORT_ADDRESS_REGISTER:
12156: if (asoSubscript < 7) {
12157: return sb.append ('a').append (asoSubscript);
12158: } else {
12159: return sb.append ("sp");
12160: }
12161:
12162:
12163:
12164: case ORT_POSTINCREMENT:
12165: if (asoSubscript < 7) {
12166: return sb.append ("(a").append (asoSubscript).append (")+");
12167: } else {
12168: return sb.append ("(sp)+");
12169: }
12170:
12171:
12172:
12173: case ORT_PREDECREMENT:
12174: if (asoSubscript < 7) {
12175: return sb.append ("-(a").append (asoSubscript).append (')');
12176: } else {
12177: return sb.append ("-(sp)");
12178: }
12179:
12180:
12181:
12182: case ORT_IMMEDIATE:
12183: if (asoOperationSize <= 1) {
12184: return XEiJ.fmtHex2 (sb.append ('#'), asoImmediateValue);
12185: } else if (asoOperationSize <= 2) {
12186: return XEiJ.fmtHex4 (sb.append ('#'), asoImmediateValue);
12187: } else {
12188: return XEiJ.fmtHex8 (sb.append ('#'), asoImmediateValue);
12189: }
12190:
12191:
12192:
12193:
12194:
12195: case ORT_ABSOLUTE_ADDRESS:
12196: if (asoAbsoluteAddressSize <= 2) {
12197: return XEiJ.fmtHex4 (sb.append ('$'), asoAbsoluteAddressValue).append (".w");
12198: } else {
12199: return XEiJ.fmtHex8 (sb.append ('$'), asoAbsoluteAddressValue).append (".l");
12200: }
12201:
12202:
12203:
12204: case ORT_RELATIVE_ADDRESS:
12205: return XEiJ.fmtHex8 (sb.append ('$'), asoRelativeAddressValue + asoBaseAddress);
12206:
12207:
12208:
12209: case ORT_CONDITION_CODE:
12210: return sb.append ("ccr");
12211:
12212:
12213:
12214: case ORT_STATUS_REGISTER:
12215: return sb.append ("sr");
12216:
12217:
12218:
12219: case ORT_REGISTER_LIST:
12220: {
12221: int m = asoSubscript;
12222: m = (m & 0x8000) << 2 | (m & 0x7f00) << 1 | (m & 0x00ff);
12223: boolean s = false;
12224: while (m != 0) {
12225: int i = Integer.numberOfTrailingZeros (m);
12226: m += 1 << i;
12227: int j = Integer.numberOfTrailingZeros (m);
12228: m -= 1 << j;
12229: j--;
12230: if (s) {
12231: sb.append ('/');
12232: }
12233: if (i <= 7) {
12234: sb.append ('d').append (i);
12235: } else if (i <= 16) {
12236: sb.append ('a').append (i - 9);
12237: } else {
12238: sb.append ("sp");
12239: }
12240: if (i < j) {
12241: sb.append ('-');
12242: if (j <= 7) {
12243: sb.append ('d').append (j);
12244: } else if (j <= 16) {
12245: sb.append ('a').append (j - 9);
12246: } else {
12247: sb.append ("sp");
12248: }
12249: }
12250: s = true;
12251: }
12252: return sb;
12253: }
12254:
12255:
12256:
12257: case ORT_REGISTER_PAIR:
12258: {
12259: int h = asoSubscript >> 3;
12260: int l = asoSubscript & 7;
12261: return sb.append ('d').append (h).append (":d").append (l);
12262: }
12263:
12264:
12265:
12266: case ORT_INDIRECT_PAIR:
12267: {
12268: int r = asoSubscript >> 4;
12269: int s = asoSubscript & 15;
12270: sb.append ('(');
12271: if (r <= 7) {
12272: sb.append ('d').append (r);
12273: } else if (r <= 14) {
12274: sb.append ('a').append (r - 8);
12275: } else {
12276: sb.append ("sp");
12277: }
12278: sb.append ("):(");
12279: if (s <= 7) {
12280: sb.append ('d').append (s);
12281: } else if (s <= 14) {
12282: sb.append ('a').append (s - 8);
12283: } else {
12284: sb.append ("sp");
12285: }
12286: return sb.append (')');
12287: }
12288:
12289:
12290:
12291: case ORT_FLOAT_REGISTER:
12292: return sb.append ("fp").append (asoSubscript);
12293:
12294:
12295:
12296: case ORT_FLOAT_LIST:
12297: {
12298: int m = asoSubscript;
12299: boolean s = false;
12300: while (m != 0) {
12301: int i = Integer.numberOfTrailingZeros (m);
12302: m += 1 << i;
12303: int j = Integer.numberOfTrailingZeros (m);
12304: m -= 1 << j;
12305: j--;
12306: if (s) {
12307: sb.append ('/');
12308: }
12309: sb.append ("fp").append (i);
12310: if (i < j) {
12311: sb.append ("-fp").append (j);
12312: }
12313: s = true;
12314: }
12315: return sb;
12316: }
12317:
12318:
12319:
12320: case ORT_FLOAT_CONTROL:
12321: {
12322: int m = asoSubscript;
12323: boolean s = false;
12324: while (m != 0) {
12325: int i = Integer.numberOfTrailingZeros (m);
12326: m -= 1 << i;
12327: if (s) {
12328: sb.append ('/');
12329: }
12330: sb.append (EVX_FLOAT_CONTROL_NAME_ARRAY[i]);
12331: s = true;
12332: }
12333: return sb;
12334: }
12335:
12336:
12337:
12338: case ORT_CACHE_SELECTION:
12339: return sb.append (EVX_CACHE_NAME_ARRAY[asoSubscript]);
12340:
12341:
12342:
12343: case ORT_CONTROL_REGISTER:
12344: return sb.append (EVX_CONTROL_MPU_CODE_TO_NAME.get (asoSubscript));
12345:
12346:
12347:
12348:
12349:
12350:
12351:
12352:
12353:
12354:
12355:
12356:
12357:
12358: case ORT_ADDRESS_INDIRECT:
12359: case ORT_PROGRAM_INDIRECT:
12360: if (!asoBaseRegisterSuppress &&
12361: asoBaseDisplacementSize <= 1 &&
12362: !asoMemoryIndirect &&
12363: !asoIndexSuppress) {
12364: sb.append ('(');
12365:
12366: if (asoOperandType == ORT_PROGRAM_INDIRECT) {
12367: XEiJ.fmtHex8 (sb.append ('$'), asoBaseDisplacementValue + asoBaseAddress);
12368: } else {
12369: XEiJ.fmtHex2 (sb.append ('$'), asoBaseDisplacementValue);
12370: }
12371: sb.append (',');
12372:
12373: if (asoOperandType == ORT_PROGRAM_INDIRECT) {
12374: sb.append ("pc");
12375: } else if (asoSubscript < 7) {
12376: sb.append ('a').append (asoSubscript);
12377: } else {
12378: sb.append ("sp");
12379: }
12380: sb.append (',');
12381:
12382: if (asoIndexRegister < 8) {
12383: sb.append ('d').append (asoIndexRegister);
12384: } else if (asoIndexRegister < 15) {
12385: sb.append ('a').append (asoIndexRegister - 8);
12386: } else {
12387: sb.append ("sp");
12388: }
12389: if (0 < asoLog2ScaleFactor) {
12390: sb.append ('*').append (1 << asoLog2ScaleFactor);
12391: }
12392: sb.append (')');
12393: } else {
12394: sb.append ('(');
12395:
12396: if (asoMemoryIndirect) {
12397: sb.append ('[');
12398: }
12399:
12400: if (0 < asoBaseDisplacementSize) {
12401: if (asoOperandType == ORT_PROGRAM_INDIRECT) {
12402: XEiJ.fmtHex8 (sb.append ('$'), asoBaseDisplacementValue + asoBaseAddress);
12403: } else if (asoBaseDisplacementSize <= 2) {
12404: XEiJ.fmtHex4 (sb.append ('$'), asoBaseDisplacementValue);
12405: } else {
12406: XEiJ.fmtHex8 (sb.append ('$'), asoBaseDisplacementValue);
12407: }
12408: sb.append (',');
12409: }
12410:
12411: if (asoBaseRegisterSuppress) {
12412: sb.append ('z');
12413: }
12414: if (asoOperandType == ORT_PROGRAM_INDIRECT) {
12415: sb.append ("pc");
12416: } else if (asoSubscript < 7) {
12417: sb.append ('a').append (asoSubscript);
12418: } else {
12419: sb.append ("sp");
12420: }
12421:
12422: if (!asoIndexSuppress && !asoPostindex) {
12423: sb.append (',');
12424: if (asoIndexRegister < 8) {
12425: sb.append ('d').append (asoIndexRegister);
12426: } else if (asoIndexRegister < 15) {
12427: sb.append ('a').append (asoIndexRegister - 8);
12428: } else {
12429: sb.append ("sp");
12430: }
12431: if (0 < asoLog2ScaleFactor) {
12432: sb.append ('*').append (1 << asoLog2ScaleFactor);
12433: }
12434: }
12435:
12436: if (asoMemoryIndirect) {
12437: sb.append (']');
12438:
12439: if (0 < asoOuterDisplacementSize) {
12440: if (asoBaseDisplacementSize <= 2) {
12441: XEiJ.fmtHex4 (sb.append ('$'), asoOuterDisplacementValue);
12442: } else {
12443: XEiJ.fmtHex8 (sb.append ('$'), asoOuterDisplacementValue);
12444: }
12445: sb.append (',');
12446: }
12447:
12448: if (!asoIndexSuppress && asoPostindex) {
12449: sb.append (',');
12450: if (asoIndexRegister < 8) {
12451: sb.append ('d').append (asoIndexRegister);
12452: } else if (asoIndexRegister < 15) {
12453: sb.append ('a').append (asoIndexRegister - 8);
12454: } else {
12455: sb.append ("sp");
12456: }
12457: if (0 < asoLog2ScaleFactor) {
12458: sb.append ('*').append (1 << asoLog2ScaleFactor);
12459: }
12460: }
12461: }
12462: sb.append (')');
12463: }
12464: return sb;
12465:
12466: }
12467:
12468: return sb.append ("???");
12469:
12470: }
12471:
12472:
12473: }
12474:
12475:
12476:
12477: }
12478:
12479:
12480: