source: dev/branches/egtra/ab5.0/abdev/compiler_x86/NumOpe_Arithmetic.cpp

Last change on this file was 465, checked in by dai_9181, 17 years ago

Messenger/ErrorMessengerクラスを導入。SetError関数によるエラー生成を廃止した。
File size: 32.1 KB
Line 
1#include "stdafx.h"
2
3#include <Compiler.h>
4
5#include "../BasicCompiler_Common/common.h"
6#include "Opcode.h"
7
8void GetStackData_ToRegister(int *type,int sp){
9 /*NumOpeポーランドのスタック蓄積による演算内容（2つのデータ）を
10 レジスタedx:eax、ecx:ebxに取得する*/
11
12 if(type[sp-1]==DEF_DOUBLE){
13 //fld qword ptr[esp]
14 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
15
16 //fistp qword ptr[esp]
17 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
18
19 //pop ebx
20 compiler.codeGenerator.op_pop(REG_EBX);
21
22 //pop ecx
23 compiler.codeGenerator.op_pop(REG_ECX);
24 }
25 else if(type[sp-1]==DEF_SINGLE){
26 //fld dword ptr[esp]
27 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
28
29 //sub esp,4
30 compiler.codeGenerator.op_sub_esp(4);
31
32 //fistp qword ptr[esp]
33 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
34
35 //pop ebx
36 compiler.codeGenerator.op_pop(REG_EBX);
37
38 //pop ecx
39 compiler.codeGenerator.op_pop(REG_ECX);
40 }
41 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
42 //pop ebx
43 compiler.codeGenerator.op_pop(REG_EBX);
44
45 //pop ecx
46 compiler.codeGenerator.op_pop(REG_ECX);
47 }
48 else{
49 //pop eax
50 compiler.codeGenerator.op_pop(REG_EAX);
51
52 if(IsSignedType(type[sp-1])){
53 //符号拡張
54 //edx:eax ← eax
55
56 //cdq
57 compiler.codeGenerator.op_cdq();
58 }
59 else{
60 //ビット拡張
61 //edx:eax ← eax
62
63 //xor edx,edx
64 compiler.codeGenerator.op_zero_reg(REG_EDX);
65 }
66
67 //mov ebx,eax
68 compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
69
70 //mov ecx,edx
71 compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
72 }
73
74 //第1項を64ビットに対応させる
75 if(type[sp-2]==DEF_DOUBLE){
76 //fld qword ptr[esp]
77 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
78
79 //fistp qword ptr[esp]
80 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
81
82 //pop eax
83 compiler.codeGenerator.op_pop(REG_EAX);
84
85 //pop edx
86 compiler.codeGenerator.op_pop(REG_EDX);
87 }
88 else if(type[sp-2]==DEF_SINGLE){
89 //fld dword ptr[esp]
90 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
91
92 //sub esp,4
93 compiler.codeGenerator.op_sub_esp(4);
94
95 //fistp qword ptr[esp]
96 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
97
98 //pop eax
99 compiler.codeGenerator.op_pop(REG_EAX);
100
101 //pop edx
102 compiler.codeGenerator.op_pop(REG_EDX);
103 }
104 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
105 //pop eax
106 compiler.codeGenerator.op_pop(REG_EAX);
107
108 //pop edx
109 compiler.codeGenerator.op_pop(REG_EDX);
110 }
111 else{
112 //pop eax
113 compiler.codeGenerator.op_pop(REG_EAX);
114
115 if(IsSignedType(type[sp-2])){
116 //符号拡張
117 //edx:eax ← eax
118
119 //cdq
120 compiler.codeGenerator.op_cdq();
121 }
122 else{
123 //ビット拡張
124 //edx:eax ← eax
125
126 //xor edx,edx
127 compiler.codeGenerator.op_zero_reg(REG_EDX);
128 }
129 }
130}
131
132void FormatStackData_To64bit(int *type,int sp){
133 //NumOpeポーランドのスタック蓄積による演算内容（2つのデータ）を64ビット整数型にする
134
135 GetStackData_ToRegister(type,sp);
136
137 //push ecx
138 compiler.codeGenerator.op_push(REG_ECX);
139
140 //push ebx
141 compiler.codeGenerator.op_push(REG_EBX);
142
143 //push edx
144 compiler.codeGenerator.op_push(REG_EDX);
145
146 //push eax
147 compiler.codeGenerator.op_push(REG_EAX);
148}
149
150BOOL CalcTwoTerm_Arithmetic(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer){
151 /* value[sp-2] = value[sp-2] + value[sp-1]
152 value[sp-2] = value[sp-2] - value[sp-1]
153 value[sp-2] = value[sp-2] * value[sp-1] */
154
155 int sp;
156 sp=*pStackPointer;
157
158 int AnswerType;
159 AnswerType=NeutralizationType(type[sp-2],index_stack[sp-2],type[sp-1],index_stack[sp-1]);
160
161 if(type[sp-2]==DEF_DOUBLE||type[sp-2]==DEF_SINGLE||
162 type[sp-1]==DEF_DOUBLE||type[sp-1]==DEF_SINGLE){
163 /////////////
164 // 実数演算
165 /////////////
166
167 if(type[sp-1]==DEF_DOUBLE){
168 //fld qword ptr[esp]
169 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
170
171 //add esp,8
172 compiler.codeGenerator.op_add_esp(8);
173 }
174 else if(type[sp-1]==DEF_SINGLE){
175 //fld dword ptr[esp]
176 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
177
178 //add esp,4
179 compiler.codeGenerator.op_add_esp(4);
180 }
181 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
182 //64ビット整数値
183
184 //fild qword ptr[esp]
185 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
186
187 //add esp,8
188 compiler.codeGenerator.op_add_esp(8);
189 }
190 else{
191 //その他整数型
192
193 //fild dword ptr[esp]
194 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
195
196 //add esp,4
197 compiler.codeGenerator.op_add_esp(4);
198 }
199
200 if(type[sp-2]==DEF_DOUBLE){
201 //fld qword ptr[esp]
202 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
203 }
204 else if(type[sp-2]==DEF_SINGLE){
205 //fld dword ptr[esp]
206 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
207 }
208 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
209 //64ビット整数値
210 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
211 }
212 else{
213 //その他整数型
214
215 //fild dword ptr[esp]
216 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
217 }
218
219 if(Type(type[sp-2],-1).GetSize()==sizeof(_int64)){
220 if(AnswerType==DEF_SINGLE){
221 //add esp,4
222 compiler.codeGenerator.op_add_esp(4);
223 }
224 }
225 else{
226 if(AnswerType==DEF_DOUBLE){
227 //sub esp,4
228 compiler.codeGenerator.op_sub_esp(4);
229 }
230 }
231
232 if(idCalc==CALC_ADDITION){
233 //faddp st(1),st
234 compiler.codeGenerator.PutOld(
235 (char)0xDE,
236 (char)0xC1
237 );
238 }
239 else if(idCalc==CALC_SUBTRACTION){
240 //fsubrp st(1),st
241 compiler.codeGenerator.PutOld(
242 (char)0xDE,
243 (char)0xE1
244 );
245 }
246 else if(idCalc==CALC_PRODUCT){
247 //fmulp st(1),st
248 compiler.codeGenerator.PutOld(
249 (char)0xDE,
250 (char)0xC9
251 );
252 }
253
254 if(AnswerType==DEF_DOUBLE){
255 //fstp qword ptr[esp]
256 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
257 }
258 else{
259 //fstp dword ptr[esp]
260 compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
261 }
262 }
263 else if(Is64Type(type[sp-2])||Is64Type(type[sp-1])){
264 //////////////////////
265 // 64ビット整数演算
266 //////////////////////
267
268 if(idCalc==CALC_PRODUCT){
269 if(!((type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD)&&
270 (type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD))){
271 //2つの項のどちらかが64ビット整数でないとき
272 FormatStackData_To64bit(type,sp);
273 }
274
275 //call _allmul
276 extern const UserProc *pSub_allmul;
277 compiler.codeGenerator.op_call(pSub_allmul);
278
279 //push edx
280 compiler.codeGenerator.op_push(REG_EDX);
281
282 //push eax
283 compiler.codeGenerator.op_push(REG_EAX);
284 }
285 else{
286 if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
287 //第2項が64ビット整数値のとき
288
289 //pop ebx
290 compiler.codeGenerator.op_pop(REG_EBX);
291
292 //pop ecx
293 compiler.codeGenerator.op_pop(REG_ECX);
294 }
295 else{
296 //第2項がその他整数値のとき
297
298 //pop eax
299 compiler.codeGenerator.op_pop(REG_EAX);
300
301 if(IsSignedType(type[sp-1])){
302 //符号拡張
303 //edx:eax ← eax
304
305 //cdq
306 compiler.codeGenerator.op_cdq();
307 }
308 else{
309 //ビット拡張
310 //edx:eax ← eax
311
312 //xor edx,edx
313 compiler.codeGenerator.op_zero_reg(REG_EDX);
314 }
315
316 //mov ebx,eax
317 compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
318
319 //mov ecx,edx
320 compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
321 }
322
323 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
324 //第1項が64ビット整数値のとき
325
326 if(idCalc==CALC_ADDITION){
327 //add dword ptr[esp],ebx
328 compiler.codeGenerator.PutOld(
329 (char)0x01,
330 (char)0x1C,
331 (char)0x24
332 );
333
334 //adc dword ptr[esp+sizeof(long)],ecx
335 compiler.codeGenerator.PutOld(
336 (char)0x11,
337 (char)0x4C,
338 (char)0x24,
339 (char)0x04
340 );
341 }
342 else if(idCalc==CALC_SUBTRACTION){
343 //sub dword ptr[esp],ebx
344 compiler.codeGenerator.PutOld(
345 (char)0x29,
346 (char)0x1C,
347 (char)0x24
348 );
349
350 //sbb dword ptr[esp+sizeof(long)],ecx
351 compiler.codeGenerator.PutOld(
352 (char)0x19,
353 (char)0x4C,
354 (char)0x24,
355 (char)0x04
356 );
357 }
358 }
359 else{
360 //第1項がその他整数値のとき
361
362 //pop eax
363 compiler.codeGenerator.op_pop(REG_EAX);
364
365 if(IsSignedType(type[sp-2])){
366 //符号拡張
367 //edx:eax ← eax
368
369 //cdq
370 compiler.codeGenerator.op_cdq();
371 }
372 else{
373 //ビット拡張
374 //edx:eax ← eax
375
376 //xor edx,edx
377 compiler.codeGenerator.op_zero_reg(REG_EDX);
378 }
379
380 if(idCalc==CALC_ADDITION){
381 //add ebx,eax
382 compiler.codeGenerator.op_add_RR( REG_EBX, REG_EAX );
383
384 //adc ecx,edx
385 compiler.codeGenerator.op_adc_RR( REG_ECX, REG_EDX );
386 }
387 else if(idCalc==CALC_SUBTRACTION){
388 //sub ebx,eax
389 compiler.codeGenerator.op_sub_RR( REG_EBX, REG_EAX );
390
391 //sbb ecx,edx
392 compiler.codeGenerator.op_sub_RR( REG_ECX, REG_EDX );
393 }
394
395 //push ecx
396 compiler.codeGenerator.op_push(REG_ECX);
397
398 //push ebx
399 compiler.codeGenerator.op_push(REG_EBX);
400 }
401 }
402 }
403 else{
404 //////////////////////////
405 //32ビット以下の整数演算
406 //////////////////////////
407
408 //pop ebx
409 compiler.codeGenerator.op_pop(REG_EBX);
410
411 //pop eax
412 compiler.codeGenerator.op_pop(REG_EAX);
413
414 //sub esp,4
415 compiler.codeGenerator.op_sub_esp(4);
416
417 if(idCalc==CALC_ADDITION){
418 //add eax,ebx
419 compiler.codeGenerator.op_add_RR( REG_EAX, REG_EBX );
420 }
421 else if(idCalc==CALC_SUBTRACTION){
422 //sub eax,ebx
423 compiler.codeGenerator.op_sub_RR( REG_EAX, REG_EBX );
424 }
425 else if(idCalc==CALC_PRODUCT){
426 //imul eax,ebx（64ビット演算ではないので、符号を考慮しない）
427 compiler.codeGenerator.op_imul_RR( REG_EAX, REG_EBX );
428 }
429
430 //mov dword ptr[esp],eax
431 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
432 }
433
434 sp--;
435 type[sp-1]=AnswerType;
436
437 *pStackPointer=sp;
438
439 return 1;
440}
441
442BOOL Calc_Mod(int *type,int *pStackPointer){
443 //value[sp-2]%=value[sp-1]
444 //剰余演算
445
446 int sp;
447 sp=*pStackPointer;
448
449 if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD||
450 type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
451 ////////////////
452 // 64ビット演算
453 ////////////////
454
455 //第2項を64ビットに対応させる
456 FormatStackData_To64bit(type,sp);
457
458 if(IsSignedType(type[sp-2])==0&&IsSignedType(type[sp-1])==0){
459 //符号なし演算
460
461 //call _aullrem
462 extern const UserProc *pSub_aullrem;
463 compiler.codeGenerator.op_call(pSub_aullrem);
464 }
465 else{
466 //符号あり演算
467
468 //call _allrem
469 extern const UserProc *pSub_allrem;
470 compiler.codeGenerator.op_call(pSub_allrem);
471 }
472
473 //push edx
474 compiler.codeGenerator.op_push(REG_EDX);
475
476 //push eax
477 compiler.codeGenerator.op_push(REG_EAX);
478
479 sp--;
480 if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
481 else type[sp-1]=DEF_INT64;
482 }
483 else{
484 ////////////////
485 // 32ビット演算
486 ////////////////
487
488 if(type[sp-1]==DEF_DOUBLE){
489 //fld qword ptr[esp]
490 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
491
492 //add esp,4
493 compiler.codeGenerator.op_add_esp(4);
494
495 //fistp dword ptr[esp]
496 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
497 }
498 else if(type[sp-1]==DEF_SINGLE){
499 //fld dword ptr[esp]
500 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
501
502 //fistp dword ptr[esp]
503 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
504 }
505
506 //pop ebx
507 compiler.codeGenerator.op_pop(REG_EBX);
508
509 if(type[sp-2]==DEF_DOUBLE){
510 //fld qword ptr[esp]
511 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
512
513 //add esp,4
514 compiler.codeGenerator.op_add_esp(4);
515
516 //fistp dword ptr[esp]
517 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
518 }
519 else if(type[sp-2]==DEF_SINGLE){
520 //fld dword ptr[esp]
521 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
522
523 //fistp dword ptr[esp]
524 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
525 }
526
527 //pop eax
528 compiler.codeGenerator.op_pop(REG_EAX);
529
530 //sub esp,4
531 compiler.codeGenerator.op_sub_esp(4);
532
533 if(type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD){
534 //xor edx,edx
535 compiler.codeGenerator.op_zero_reg(REG_EDX);
536
537 //div ebx (eax=eax/ebx...edx)
538 compiler.codeGenerator.op_div_R( REG_EBX );
539 }
540 else{
541 //cdq
542 compiler.codeGenerator.op_cdq();
543
544 //idiv ebx (eax=eax/ebx...edx)
545 compiler.codeGenerator.op_idiv_R( REG_EBX );
546 }
547
548 //mov dword ptr[esp],edx
549 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EDX, REG_ESP, 0, MOD_BASE );
550
551 sp--;
552 type[sp-1]=DEF_LONG;
553 }
554
555 *pStackPointer=sp;
556
557 return 1;
558}
559
560BOOL Calc_Divide(int *type,int *pStackPointer,int BaseType){
561 //value[sp-2]/=value[sp-1];
562 //除算
563
564 int sp;
565 sp=*pStackPointer;
566
567 ///////////////////////
568 // 浮動小数点演算のみ
569 ///////////////////////
570
571 int AnswerType;
572 if(type[sp-2]==DEF_DOUBLE||type[sp-1]==DEF_DOUBLE||BaseType==DEF_DOUBLE) AnswerType=DEF_DOUBLE;
573 else AnswerType=DEF_SINGLE;
574
575 if(type[sp-1]==DEF_DOUBLE){
576 //fld qword ptr[esp]
577 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
578
579 //add esp,8
580 compiler.codeGenerator.op_add_esp(8);
581 }
582 else if(type[sp-1]==DEF_SINGLE){
583 //fld dword ptr[esp]
584 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
585
586 //add esp,4
587 compiler.codeGenerator.op_add_esp(4);
588 }
589 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
590 //64ビット整数値
591
592 //fild qword ptr[esp]
593 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
594
595 //add esp,8
596 compiler.codeGenerator.op_add_esp(8);
597 }
598 else if(type[sp-1]==DEF_DWORD){
599 //pop eax
600 compiler.codeGenerator.op_pop(REG_EAX);
601
602 //push 0
603 compiler.codeGenerator.op_push_V(0);
604
605 //push eax
606 compiler.codeGenerator.op_push(REG_EAX);
607
608 //fild qword ptr[esp]
609 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
610
611 //add esp,8
612 compiler.codeGenerator.op_add_esp(8);
613 }
614 else{
615 //fild dword ptr[esp]
616 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
617
618 //add esp,4
619 compiler.codeGenerator.op_add_esp(4);
620 }
621
622 if(type[sp-2]==DEF_DOUBLE){
623 //fld qword ptr[esp]
624 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
625 }
626 else if(type[sp-2]==DEF_SINGLE){
627 //fld dword ptr[esp]
628 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
629 }
630 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
631 //64ビット整数値
632
633 //fild qword ptr[esp]
634 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
635 }
636 else if(type[sp-2]==DEF_DWORD){
637 //pop eax
638 compiler.codeGenerator.op_pop(REG_EAX);
639
640 //push 0
641 compiler.codeGenerator.op_push_V(0);
642
643 //push eax
644 compiler.codeGenerator.op_push(REG_EAX);
645
646 //fild qword ptr[esp]
647 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
648 }
649 else{ //Long
650 //fild dword ptr[esp]
651 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
652 }
653 //↓ここだけ例外DWord
654 if(Type(type[sp-2],-1).GetSize()==sizeof(_int64)||type[sp-2]==DEF_DWORD){
655 if(AnswerType==DEF_SINGLE){
656 //add esp,4
657 compiler.codeGenerator.op_add_esp(4);
658 }
659 }
660 else{
661 if(AnswerType==DEF_DOUBLE){
662 //sub esp,4
663 compiler.codeGenerator.op_sub_esp(4);
664 }
665 }
666
667 //fdivrp st(1),st
668 compiler.codeGenerator.PutOld(
669 (char)0xDE,
670 (char)0xF1
671 );
672
673 sp--;
674 if(AnswerType==DEF_DOUBLE){
675 //fstp qword ptr[esp]
676 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
677
678 type[sp-1]=DEF_DOUBLE;
679 }
680 else{
681 //fstp dword ptr[esp]
682 compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
683
684 type[sp-1]=DEF_SINGLE;
685 }
686
687 *pStackPointer=sp;
688
689 return 1;
690}
691
692BOOL Calc_IntDivide(int *type,LONG_PTR *index_stack,int *pStackPointer){
693 //value[sp-2]/=value[sp-1]
694 //除算（整数）
695
696 int sp;
697 sp=*pStackPointer;
698
699 if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD||
700 type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
701 ////////////////
702 // 64ビット演算
703 ////////////////
704
705 //2つの項を64ビットに対応させる
706 FormatStackData_To64bit(type,sp);
707
708 if(IsSignedType(type[sp-2])==0&&IsSignedType(type[sp-1])==0){
709 //符号なし演算
710
711 //call _aulldiv
712 extern const UserProc *pSub_aulldiv;
713 compiler.codeGenerator.op_call(pSub_aulldiv);
714 }
715 else{
716 //符号あり演算
717
718 //call _alldiv
719 extern const UserProc *pSub_alldiv;
720 compiler.codeGenerator.op_call(pSub_alldiv);
721 }
722
723 //push edx
724 compiler.codeGenerator.op_push(REG_EDX);
725
726 //push eax
727 compiler.codeGenerator.op_push(REG_EAX);
728
729 sp--;
730 if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
731 else type[sp-1]=DEF_INT64;
732 }
733 else{
734 ////////////////
735 // 32ビット演算
736 ////////////////
737
738 if(type[sp-1]==DEF_DOUBLE){
739 //fld qword ptr[esp]
740 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
741
742 //add esp,4
743 compiler.codeGenerator.op_add_esp(4);
744
745 //fistp dword ptr[esp]
746 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
747 }
748 else if(type[sp-1]==DEF_SINGLE){
749 //fld dword ptr[esp]
750 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
751
752 //fistp dword ptr[esp]
753 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
754 }
755
756 //pop ebx
757 compiler.codeGenerator.op_pop(REG_EBX);
758
759 if(type[sp-2]==DEF_DOUBLE){
760 //fld qword ptr[esp]
761 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
762
763 //add esp,4
764 compiler.codeGenerator.op_add_esp(4);
765
766 //fistp dword ptr[esp]
767 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
768 }
769 else if(type[sp-2]==DEF_SINGLE){
770 //fld dword ptr[esp]
771 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
772
773 //fistp dword ptr[esp]
774 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
775 }
776
777 //pop eax
778 compiler.codeGenerator.op_pop(REG_EAX);
779
780 //sub esp,4
781 compiler.codeGenerator.op_sub_esp(4);
782
783 if((type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD)||
784 (IS_POSITIVE_LITERAL(index_stack[sp-2])&&type[sp-1]==DEF_DWORD)||
785 (type[sp-2]==DEF_DWORD&&IS_POSITIVE_LITERAL(index_stack[sp-1]))){
786 //xor edx,edx
787 compiler.codeGenerator.op_zero_reg(REG_EDX);
788
789 //div ebx (eax=eax/ebx...edx)
790 compiler.codeGenerator.op_div_R( REG_EBX );
791 }
792 else{
793 //cdq
794 compiler.codeGenerator.op_cdq();
795
796 //idiv ebx (eax=eax/ebx...edx)
797 compiler.codeGenerator.op_idiv_R( REG_EBX );
798 }
799
800 //mov dword ptr[esp],eax
801 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
802
803 sp--;
804
805 //整数以外の型だったときはLong型にする
806 if(!IsWholeNumberType(type[sp-1])) type[sp-1]=DEF_LONG;
807 }
808
809 *pStackPointer=sp;
810 return 1;
811}
812
813BOOL Calc_MinusMark(int *type,int sp){
814 //value[sp-1]=-value[sp-1]
815 //符号反転
816
817 if(type[sp-1]==DEF_DOUBLE){
818 //fld qword ptr[esp]
819 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
820
821 //push -1
822 compiler.codeGenerator.op_push_V(-1);
823
824 //fild dword ptr[esp]
825 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
826
827 //add esp,4
828 compiler.codeGenerator.op_add_esp(4);
829
830 //fmulp st(1),st
831 compiler.codeGenerator.PutOld(
832 (char)0xDE,
833 (char)0xC9
834 );
835
836 //fstp qword ptr[esp]
837 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
838 }
839 else if(type[sp-1]==DEF_SINGLE){
840 //fld dword ptr[esp]
841 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
842
843 //push -1
844 compiler.codeGenerator.op_push_V(-1);
845
846 //fild dword ptr[esp]
847 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
848
849 //add esp,4
850 compiler.codeGenerator.op_add_esp(4);
851
852 //fmulp st(1),st
853 compiler.codeGenerator.PutOld(
854 (char)0xDE,
855 (char)0xC9
856 );
857
858 //fstp dword ptr[esp]
859 compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
860 }
861 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
862 //pop eax
863 compiler.codeGenerator.op_pop(REG_EAX);
864
865 //neg eax
866 compiler.codeGenerator.op_neg( REG_EAX );
867
868 //pop edx
869 compiler.codeGenerator.op_pop(REG_EDX);
870
871 //adc edx,0
872 compiler.codeGenerator.op_adc_RV8(REG_EDX,0);
873
874 //neg edx
875 compiler.codeGenerator.op_neg( REG_EDX );
876
877 //push edx
878 compiler.codeGenerator.op_push(REG_EDX);
879
880 //push eax
881 compiler.codeGenerator.op_push(REG_EAX);
882
883 type[sp-1]=DEF_INT64; //QWordはInt64へ
884 }
885 else if(IsWholeNumberType(type[sp-1])){
886 //pop eax
887 compiler.codeGenerator.op_pop(REG_EAX);
888
889 //imul eax,-1
890 compiler.codeGenerator.op_imul_RV8( REG_EAX, -1 );
891
892 //push eax
893 compiler.codeGenerator.op_push(REG_EAX);
894
895 type[sp-1]=GetSignedType(type[sp-1]);
896 }
897
898 return 1;
899}
900
901BOOL Calc_Power(int *type,int *pStackPointer){
902 //べき乗（実数演算のみ）
903
904 int sp;
905 sp=*pStackPointer;
906
907 if(type[sp-1]==DEF_DOUBLE){
908 //fld qword ptr[esp]
909 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
910
911 //add esp,8
912 compiler.codeGenerator.op_add_esp(8);
913 }
914 else if(type[sp-1]==DEF_SINGLE){
915 //fld dword ptr[esp]
916 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
917
918 //add esp,4
919 compiler.codeGenerator.op_add_esp(4);
920 }
921 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
922 //64ビット整数値
923
924 //fild qword ptr[esp]
925 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
926
927 //add esp,8
928 compiler.codeGenerator.op_add_esp(8);
929 }
930 else{
931 //32ビット整数値
932
933 //fild dword ptr[esp]
934 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
935
936 //add esp,4
937 compiler.codeGenerator.op_add_esp(4);
938 }
939
940 if(type[sp-2]==DEF_DOUBLE){
941 //fld qword ptr[esp]
942 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
943 }
944 else if(type[sp-2]==DEF_SINGLE){
945 //fld dword ptr[esp]
946 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
947
948 //sub esp,4
949 compiler.codeGenerator.op_sub_esp(4);
950 }
951 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
952 //64ビット整数値
953
954 //fild qword ptr[esp]
955 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
956 }
957 else{
958 //32ビット整数値
959
960 //fild dword ptr[esp]
961 compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
962
963 //sub esp,4
964 compiler.codeGenerator.op_sub_esp(4);
965 }
966
967 //sub esp,8
968 compiler.codeGenerator.op_sub_esp(8);
969
970 //fstp qword ptr[esp]
971 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
972
973 //fstp qword ptr[esp+8]
974 compiler.codeGenerator.op_fstp_base_offset(DEF_DOUBLE,REG_ESP,8);
975
976 //call pow
977 extern const UserProc *pSub_pow;
978 compiler.codeGenerator.op_call(pSub_pow);
979
980 //sub esp,8
981 compiler.codeGenerator.op_sub_esp(8);
982
983 //fstp qword ptr[esp]
984 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
985
986 sp--;
987 type[sp-1]=DEF_DOUBLE;
988
989 *pStackPointer=sp;
990 return 1;
991}
992
993BOOL Calc_Cast(int *type,LONG_PTR *index_stack,int *pStackPointer){
994 //キャスト
995
996 int sp;
997 sp=*pStackPointer;
998
999 int castBasicType = type[sp-1];
1000 if((castBasicType&FLAG_CAST)==0){
1001 compiler.errorMessenger.Output(47,NULL,cp);
1002 return 0;
1003 }
1004 castBasicType = castBasicType&(~FLAG_CAST);
1005
1006 Type oldType( type[sp-2], index_stack[sp-2] );
1007 Type castType( castBasicType, index_stack[sp-1] );
1008
1009 if( castType.IsPointer() )
1010 {
1011 ChangeTypeToLong( oldType.GetBasicType() );
1012 }
1013 else if( castType.IsReal() )
1014 {
1015 if( castType.IsDouble() )
1016 {
1017 ChangeTypeToDouble( oldType.GetBasicType() );
1018 }
1019 else if( castType.IsSingle() )
1020 {
1021 ChangeTypeToSingle( oldType.GetBasicType() );
1022 }
1023 }
1024 else
1025 {
1026 ChangeTypeToWhole( oldType, castType );
1027 }
1028
1029 type[sp-2] = castType.GetBasicType();
1030 index_stack[sp-2] = castType.GetIndex();
1031
1032 sp--;
1033
1034 *pStackPointer=sp;
1035 return 1;
1036}
1037
1038BOOL Calc_SHL(int *type,int *pStackPointer){
1039 //左ビットシフト
1040 //value[sp-2]=value[sp-2]<<value[sp-1]
1041
1042 int sp;
1043 sp=*pStackPointer;
1044
1045 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
1046 ////////////////
1047 // 64ビット演算
1048 ////////////////
1049
1050 //2項目は32ビット整数として利用
1051 if(type[sp-1]==DEF_DOUBLE){
1052 //fld qword ptr[esp]
1053 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1054
1055 //add esp,4
1056 compiler.codeGenerator.op_add_esp(4);
1057
1058 //fistp dword ptr[esp]
1059 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1060
1061 //pop ecx
1062 compiler.codeGenerator.op_pop(REG_ECX);
1063 }
1064 else if(type[sp-1]==DEF_SINGLE){
1065 //fld dword ptr[esp]
1066 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1067
1068 //fistp dword ptr[esp]
1069 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1070
1071 //pop ecx
1072 compiler.codeGenerator.op_pop(REG_ECX);
1073 }
1074 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
1075 //pop ecx
1076 compiler.codeGenerator.op_pop(REG_ECX);
1077
1078 //add esp,4
1079 compiler.codeGenerator.op_add_esp(4);
1080 }
1081 else{
1082 //pop ecx
1083 compiler.codeGenerator.op_pop(REG_ECX);
1084 }
1085
1086 //第1項を64ビットに対応させる
1087 if(type[sp-2]==DEF_DOUBLE){
1088 //fld qword ptr[esp]
1089 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1090
1091 //fistp qword ptr[esp]
1092 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
1093
1094 //pop eax
1095 compiler.codeGenerator.op_pop(REG_EAX);
1096
1097 //pop edx
1098 compiler.codeGenerator.op_pop(REG_EDX);
1099 }
1100 else if(type[sp-2]==DEF_SINGLE){
1101 //fld dword ptr[esp]
1102 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1103
1104 //sub esp,4
1105 compiler.codeGenerator.op_sub_esp(4);
1106
1107 //fistp qword ptr[esp]
1108 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
1109
1110 //pop eax
1111 compiler.codeGenerator.op_pop(REG_EAX);
1112
1113 //pop edx
1114 compiler.codeGenerator.op_pop(REG_EDX);
1115 }
1116 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
1117 //pop eax
1118 compiler.codeGenerator.op_pop(REG_EAX);
1119
1120 //pop edx
1121 compiler.codeGenerator.op_pop(REG_EDX);
1122 }
1123 else{
1124 //pop eax
1125 compiler.codeGenerator.op_pop(REG_EAX);
1126
1127 if(IsSignedType(type[sp-2])){
1128 //符号拡張
1129 //edx:eax ← eax
1130
1131 //cdq
1132 compiler.codeGenerator.op_cdq();
1133 }
1134 else{
1135 //ビット拡張
1136 //edx:eax ← eax
1137
1138 //xor edx,edx
1139 compiler.codeGenerator.op_zero_reg(REG_EDX);
1140 }
1141 }
1142
1143 //call _allshl
1144 extern const UserProc *pSub_allshl;
1145 compiler.codeGenerator.op_call(pSub_allshl);
1146
1147 //push edx
1148 compiler.codeGenerator.op_push(REG_EDX);
1149
1150 //push eax
1151 compiler.codeGenerator.op_push(REG_EAX);
1152
1153 sp--;
1154 }
1155 else{
1156 ////////////////
1157 // 32ビット演算
1158 ////////////////
1159
1160 //2項目は32ビット整数として利用
1161 if(type[sp-1]==DEF_DOUBLE){
1162 //fld qword ptr[esp]
1163 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1164
1165 //add esp,4
1166 compiler.codeGenerator.op_add_esp(4);
1167
1168 //fistp dword ptr[esp]
1169 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1170
1171 //pop ecx
1172 compiler.codeGenerator.op_pop(REG_ECX);
1173 }
1174 else if(type[sp-1]==DEF_SINGLE){
1175 //fld dword ptr[esp]
1176 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1177
1178 //fistp dword ptr[esp]
1179 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1180
1181 //pop ecx
1182 compiler.codeGenerator.op_pop(REG_ECX);
1183 }
1184 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
1185 //pop ecx
1186 compiler.codeGenerator.op_pop(REG_ECX);
1187
1188 //add esp,4
1189 compiler.codeGenerator.op_add_esp(4);
1190 }
1191 else{
1192 //pop ecx
1193 compiler.codeGenerator.op_pop(REG_ECX);
1194 }
1195
1196 if(type[sp-2]==DEF_DOUBLE){
1197 //fld qword ptr[esp]
1198 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1199
1200 //add esp,4
1201 compiler.codeGenerator.op_add_esp(4);
1202
1203 //fistp dword ptr[esp]
1204 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1205 }
1206 else if(type[sp-2]==DEF_SINGLE){
1207 //fld dword ptr[esp]
1208 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1209
1210 //fistp dword ptr[esp]
1211 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1212 }
1213
1214 //pop eax
1215 compiler.codeGenerator.op_pop(REG_EAX);
1216
1217 //sub esp,4
1218 compiler.codeGenerator.op_sub_esp(4);
1219
1220 //shl eax,cl
1221 compiler.codeGenerator.PutOld(
1222 (char)0xD3,
1223 (char)0xE0
1224 );
1225
1226 //mov dword ptr[esp],eax
1227 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
1228
1229 sp--;
1230
1231 //32ビット型にする
1232 if(IsSignedType(type[sp-1])) type[sp-1]=DEF_LONG;
1233 else type[sp-1]=DEF_DWORD;
1234 }
1235
1236 *pStackPointer=sp;
1237 return 1;
1238}
1239
1240BOOL Calc_SHR(int *type,int *pStackPointer){
1241 //右ビットシフト
1242 //value[sp-2]=value[sp-2]>>value[sp-1]
1243
1244 int sp;
1245 sp=*pStackPointer;
1246
1247 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
1248 ////////////////
1249 // 64ビット演算
1250 ////////////////
1251
1252 //2項目は32ビット整数として利用
1253 if(type[sp-1]==DEF_DOUBLE){
1254 //fld qword ptr[esp]
1255 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1256
1257 //add esp,4
1258 compiler.codeGenerator.op_add_esp(4);
1259
1260 //fistp dword ptr[esp]
1261 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1262
1263 //pop ecx
1264 compiler.codeGenerator.op_pop(REG_ECX);
1265 }
1266 else if(type[sp-1]==DEF_SINGLE){
1267 //fld dword ptr[esp]
1268 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1269
1270 //fistp dword ptr[esp]
1271 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1272
1273 //pop ecx
1274 compiler.codeGenerator.op_pop(REG_ECX);
1275 }
1276 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
1277 //pop ecx
1278 compiler.codeGenerator.op_pop(REG_ECX);
1279
1280 //add esp,4
1281 compiler.codeGenerator.op_add_esp(4);
1282 }
1283 else{
1284 //pop ecx
1285 compiler.codeGenerator.op_pop(REG_ECX);
1286 }
1287
1288 //第1項を64ビットに対応させる
1289 if(type[sp-2]==DEF_DOUBLE){
1290 //fld qword ptr[esp]
1291 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1292
1293 //fistp qword ptr[esp]
1294 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
1295
1296 //pop eax
1297 compiler.codeGenerator.op_pop(REG_EAX);
1298
1299 //pop edx
1300 compiler.codeGenerator.op_pop(REG_EDX);
1301 }
1302 else if(type[sp-2]==DEF_SINGLE){
1303 //fld dword ptr[esp]
1304 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1305
1306 //sub esp,4
1307 compiler.codeGenerator.op_sub_esp(4);
1308
1309 //fistp qword ptr[esp]
1310 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
1311
1312 //pop eax
1313 compiler.codeGenerator.op_pop(REG_EAX);
1314
1315 //pop edx
1316 compiler.codeGenerator.op_pop(REG_EDX);
1317 }
1318 else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
1319 //pop eax
1320 compiler.codeGenerator.op_pop(REG_EAX);
1321
1322 //pop edx
1323 compiler.codeGenerator.op_pop(REG_EDX);
1324 }
1325 else{
1326 //pop eax
1327 compiler.codeGenerator.op_pop(REG_EAX);
1328
1329 if(IsSignedType(type[sp-2])){
1330 //符号拡張
1331 //edx:eax ← eax
1332
1333 //cdq
1334 compiler.codeGenerator.op_cdq();
1335 }
1336 else{
1337 //ビット拡張
1338 //edx:eax ← eax
1339
1340 //xor edx,edx
1341 compiler.codeGenerator.op_zero_reg(REG_EDX);
1342 }
1343 }
1344
1345 if(type[sp-2]==DEF_QWORD){
1346 //符号なし演算
1347
1348 //call _aullshr
1349 extern const UserProc *pSub_aullshr;
1350 compiler.codeGenerator.op_call(pSub_aullshr);
1351 }
1352 else{
1353 //符号あり演算
1354
1355 //call _allshr
1356 extern const UserProc *pSub_allshr;
1357 compiler.codeGenerator.op_call(pSub_allshr);
1358 }
1359
1360 //push edx
1361 compiler.codeGenerator.op_push(REG_EDX);
1362
1363 //push eax
1364 compiler.codeGenerator.op_push(REG_EAX);
1365
1366 sp--;
1367 }
1368 else{
1369 ////////////////
1370 // 32ビット演算
1371 ////////////////
1372
1373 //2項目は32ビット整数として利用
1374 if(type[sp-1]==DEF_DOUBLE){
1375 //fld qword ptr[esp]
1376 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1377
1378 //add esp,4
1379 compiler.codeGenerator.op_add_esp(4);
1380
1381 //fistp dword ptr[esp]
1382 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1383
1384 //pop ecx
1385 compiler.codeGenerator.op_pop(REG_ECX);
1386 }
1387 else if(type[sp-1]==DEF_SINGLE){
1388 //fld dword ptr[esp]
1389 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1390
1391 //fistp dword ptr[esp]
1392 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1393
1394 //pop ecx
1395 compiler.codeGenerator.op_pop(REG_ECX);
1396 }
1397 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
1398 //pop ecx
1399 compiler.codeGenerator.op_pop(REG_ECX);
1400
1401 //add esp,4
1402 compiler.codeGenerator.op_add_esp(4);
1403 }
1404 else{
1405 //pop ecx
1406 compiler.codeGenerator.op_pop(REG_ECX);
1407 }
1408
1409 if(type[sp-2]==DEF_DOUBLE){
1410 //fld qword ptr[esp]
1411 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
1412
1413 //add esp,4
1414 compiler.codeGenerator.op_add_esp(4);
1415
1416 //fistp dword ptr[esp]
1417 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1418 }
1419 else if(type[sp-2]==DEF_SINGLE){
1420 //fld dword ptr[esp]
1421 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
1422
1423 //fistp dword ptr[esp]
1424 compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
1425 }
1426
1427 //pop eax
1428 compiler.codeGenerator.op_pop(REG_EAX);
1429
1430 //sub esp,4
1431 compiler.codeGenerator.op_sub_esp(4);
1432
1433 if(type[sp-2]==DEF_DWORD){
1434 //shr eax,cl
1435 compiler.codeGenerator.PutOld(
1436 (char)0xD3,
1437 (char)0xE8
1438 );
1439 }
1440 else{
1441 //sar eax,cl
1442 compiler.codeGenerator.PutOld(
1443 (char)0xD3,
1444 (char)0xF8
1445 );
1446 }
1447
1448 //mov dword ptr[esp],eax
1449 compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
1450
1451 sp--;
1452
1453 //整数以外の型だったときはLong型にする
1454 if(!IsWholeNumberType(type[sp-1])) type[sp-1]=DEF_LONG;
1455 }
1456
1457 *pStackPointer=sp;
1458 return 1;
1459}
Note: See TracBrowser for help on using the repository browser.