source: dev/BasicCompiler32/Compile_Calc.cpp@ 74

Last change on this file since 74 was 67, checked in by dai_9181, 18 years ago

[32bit Compiler]op_push_value → op_push_V
Nothingに対応。
File size: 17.6 KB
Line 
1#include "../BasicCompiler_Common/common.h"
2#include "Opcode.h"
3
4void ChangeTypeToDouble_ToFpuReg(int OldType){
5 //現在のスタックの内容を実数レジスタに保存する
6 //NumOpeの直後専用
7 if(OldType==DEF_DOUBLE){
8 //fld qword ptr[esp]
9 op_fld_ptr_esp(DEF_DOUBLE);
10
11 //add esp,8
12 op_add_esp(8);
13 }
14 else if(OldType==DEF_SINGLE){
15 //fld dword ptr[esp]
16 op_fld_ptr_esp(DEF_SINGLE);
17
18 //add esp,4
19 op_add_esp(4);
20 }
21 else if(OldType==DEF_LONG){
22 //fild dword ptr[esp]
23 op_fld_ptr_esp(DEF_LONG);
24
25 //add esp,4
26 op_add_esp(4);
27 }
28 else if(OldType==DEF_DWORD){
29 //pop eax
30 op_pop(REG_EAX);
31
32 //push 0
33 op_push_V(0);
34
35 //push eax
36 op_push(REG_EAX);
37
38 //fild qword ptr[esp]
39 OpBuffer[obp++]=(char)0xDF;
40 OpBuffer[obp++]=(char)0x2C;
41 OpBuffer[obp++]=(char)0x24;
42
43 //add esp,8
44 op_add_esp(8);
45 }
46}
47void ChangeTypeToDouble(int OldType){
48 //現在のスタックの内容をdouble型に変換する
49 //NumOpeの直後専用
50 if(OldType==DEF_DOUBLE) return;
51 else if(OldType==DEF_SINGLE){
52 //fld dword ptr[esp]
53 op_fld_ptr_esp(DEF_SINGLE);
54
55 //sub esp,4
56 op_sub_esp(4);
57
58 //fstp qword ptr[esp]
59 OpBuffer[obp++]=(char)0xDD;
60 OpBuffer[obp++]=(char)0x1C;
61 OpBuffer[obp++]=(char)0x24;
62 }
63 else if(OldType==DEF_INT64||OldType==DEF_QWORD){
64 //64ビット整数型
65
66 //fild qword ptr[esp]
67 op_fld_ptr_esp(DEF_INT64);
68
69 //fstp qword ptr[esp]
70 OpBuffer[obp++]=(char)0xDD;
71 OpBuffer[obp++]=(char)0x1C;
72 OpBuffer[obp++]=(char)0x24;
73 }
74 else if(IsWholeNumberType(OldType)){
75 //その他整数型
76
77 if(IsSignedType(OldType)){
78 //符号あり
79
80 if(OldType==DEF_INTEGER || (isUnicode&&OldType==DEF_CHAR)){
81 //pop eax
82 op_pop(REG_EAX);
83
84 //movsx eax,ax
85 OpBuffer[obp++]=(char)0x0F;
86 OpBuffer[obp++]=(char)0xBF;
87 OpBuffer[obp++]=(char)0xC0;
88
89 //push eax
90 op_push(REG_EAX);
91 }
92 else if(OldType==DEF_SBYTE || (isUnicode==false&&OldType==DEF_CHAR)){
93 //pop eax
94 op_pop(REG_EAX);
95
96 //movsx eax,al
97 OpBuffer[obp++]=(char)0x0F;
98 OpBuffer[obp++]=(char)0xBE;
99 OpBuffer[obp++]=(char)0xC0;
100
101 //push eax
102 op_push(REG_EAX);
103 }
104
105 //fild dword ptr[esp]
106 op_fld_ptr_esp(DEF_LONG);
107
108 //sub esp,4
109 op_sub_esp(4);
110 }
111 else{
112 //符号なし
113
114 //pop eax
115 op_pop(REG_EAX);
116
117 //push 0
118 op_push_V(0);
119
120 //push eax
121 op_push(REG_EAX);
122
123 //fild qword ptr[esp]
124 OpBuffer[obp++]=(char)0xDF;
125 OpBuffer[obp++]=(char)0x2C;
126 OpBuffer[obp++]=(char)0x24;
127 }
128
129 //fstp qword ptr[esp]
130 OpBuffer[obp++]=(char)0xDD;
131 OpBuffer[obp++]=(char)0x1C;
132 OpBuffer[obp++]=(char)0x24;
133 }
134 else SetError(9,NULL,cp);
135}
136void ChangeTypeToSingle(int OldType){
137 //現在のスタックの内容をfloat型に変換する
138 //NumOpeの直後専用
139 if(OldType==DEF_SINGLE) return;
140 else if(OldType==DEF_DOUBLE){
141 //fld qword ptr[esp]
142 op_fld_ptr_esp(DEF_DOUBLE);
143
144 //add esp,4
145 op_add_esp(4);
146
147 //fstp dword ptr[esp]
148 OpBuffer[obp++]=(char)0xD9;
149 OpBuffer[obp++]=(char)0x1C;
150 OpBuffer[obp++]=(char)0x24;
151 }
152 else if(OldType==DEF_INT64||OldType==DEF_QWORD){
153 //64ビット整数型
154
155 //fild qword ptr[esp]
156 op_fld_ptr_esp(DEF_INT64);
157
158 //add esp,4
159 op_add_esp(4);
160
161 //fstp dword ptr[esp]
162 OpBuffer[obp++]=(char)0xD9;
163 OpBuffer[obp++]=(char)0x1C;
164 OpBuffer[obp++]=(char)0x24;
165 }
166 else if(IsWholeNumberType(OldType)){
167 //その他整数型
168
169 if(IsSignedType(OldType)){
170 //符号あり
171
172 if(OldType==DEF_INTEGER || (isUnicode&&OldType==DEF_CHAR)){
173 //pop eax
174 op_pop(REG_EAX);
175
176 //movsx eax,ax
177 OpBuffer[obp++]=(char)0x0F;
178 OpBuffer[obp++]=(char)0xBF;
179 OpBuffer[obp++]=(char)0xC0;
180
181 //push eax
182 op_push(REG_EAX);
183 }
184 else if(OldType==DEF_SBYTE || (isUnicode==false&&OldType==DEF_CHAR)){
185 //pop eax
186 op_pop(REG_EAX);
187
188 //movsx eax,al
189 OpBuffer[obp++]=(char)0x0F;
190 OpBuffer[obp++]=(char)0xBE;
191 OpBuffer[obp++]=(char)0xC0;
192
193 //push eax
194 op_push(REG_EAX);
195 }
196
197 //fild dword ptr[esp]
198 op_fld_ptr_esp(DEF_LONG);
199 }
200 else{
201 //符号なし
202
203 //fild dword ptr[esp]
204 op_fld_ptr_esp(DEF_LONG);
205 }
206
207 //fstp dword ptr[esp]
208 OpBuffer[obp++]=(char)0xD9;
209 OpBuffer[obp++]=(char)0x1C;
210 OpBuffer[obp++]=(char)0x24;
211 }
212 else SetError(9,NULL,cp);
213}
214
215void ChangeTypeToInt64(int OldType){
216 //現在のスタックの内容をInt64型に変換する
217 //NumOpeの直後専用
218 if(Is64Type(OldType)) return;
219
220 else if(OldType==DEF_DOUBLE){
221 //fld qword ptr[esp]
222 op_fld_ptr_esp(DEF_DOUBLE);
223
224 //fistp qword ptr[esp]
225 op_fistp_ptr_esp( sizeof(_int64) );
226 }
227 else if(OldType==DEF_SINGLE){
228 //fld dword ptr[esp]
229 op_fld_ptr_esp(DEF_SINGLE);
230
231 //sub esp,4
232 op_sub_esp(4);
233
234 //fistp qword ptr[esp]
235 op_fistp_ptr_esp( sizeof(_int64) );
236 }
237 else if(IsWholeNumberType(OldType)){
238 //その他整数
239
240 if(IsSignedType(OldType)){
241 //符号あり
242
243 //pop eax
244 op_pop(REG_EAX);
245
246 //cdq
247 op_cdq();
248
249 //push edx
250 op_push(REG_EDX);
251
252 //push eax
253 op_push(REG_EAX);
254 }
255 else{
256 //符号なし
257
258 //pop eax
259 op_pop(REG_EAX);
260
261 //push 0
262 op_push_V(0);
263
264 //push eax
265 op_push(REG_EAX);
266 }
267 }
268 else SetError(9,NULL,cp);
269}
270void ChangeTypeToLong(int OldType){
271 //現在のスタックの内容をLong型に変換する
272 //NumOpeの直後専用
273 if(OldType==DEF_DOUBLE){
274
275 //fld qword ptr[esp]
276 op_fld_ptr_esp(DEF_DOUBLE);
277
278 //add esp,4
279 op_add_esp(4);
280
281 //fistp dword ptr[esp]
282 op_fistp_ptr_esp( sizeof(long) );
283 }
284 else if(OldType==DEF_SINGLE){
285 //fld dword ptr[esp]
286 op_fld_ptr_esp(DEF_SINGLE);
287
288 //fistp dword ptr[esp]
289 op_fistp_ptr_esp( sizeof(long) );
290 }
291 else if(OldType==DEF_INT64||OldType==DEF_QWORD){
292 //pop eax
293 op_pop(REG_EAX);
294
295 //add esp,4
296 op_add_esp(4);
297
298 //push eax
299 op_push(REG_EAX);
300 }
301}
302void ChangeTypeToInteger(int OldType){
303 //現在のスタックの内容をInteger型に変換する
304 if(OldType==DEF_BOOLEAN||
305 OldType==DEF_BYTE||
306 OldType==DEF_WORD||OldType==DEF_INTEGER || (isUnicode&&OldType==DEF_CHAR)) return;
307 else if(OldType==DEF_SBYTE || (isUnicode==false&&OldType==DEF_CHAR)){
308 //pop eax
309 op_pop(REG_EAX);
310
311 //movsx eax,al
312 OpBuffer[obp++]=(char)0x0F;
313 OpBuffer[obp++]=(char)0xBE;
314 OpBuffer[obp++]=(char)0xC0;
315
316 //push eax
317 op_push(REG_EAX);
318 }
319 else{
320 ChangeTypeToLong(OldType);
321
322 //pop eax
323 op_pop(REG_EAX);
324
325 //and eax,0000FFFFh
326 OpBuffer[obp++]=(char)0x25;
327 *((long *)(OpBuffer+obp))=0x0000FFFF;
328 obp+=sizeof(long);
329
330 //push eax
331 op_push(REG_EAX);
332 }
333}
334void ChangeTypeToByte(int OldType){
335 //現在のスタックの内容をbyte型に変換する
336 if(OldType==DEF_BYTE||OldType==DEF_SBYTE || (isUnicode==false&&OldType==DEF_CHAR)) return;
337
338 ChangeTypeToLong(OldType);
339
340 //pop eax
341 op_pop(REG_EAX);
342
343 //and eax,000000FFh
344 OpBuffer[obp++]=(char)0x25;
345 *((long *)(OpBuffer+obp))=0x000000FF;
346 obp+=sizeof(long);
347
348 //push eax
349 op_push(REG_EAX);
350}
351
352
353
354
355
356
357
358
359
360void RestoreDefaultRegisterFromStackMemory( int type ){
361 //現在のスタックの内容を実数レジスタに保存する
362 //NumOpeの直後専用
363 if(type==DEF_DOUBLE){
364 //fld qword ptr[esp]
365 op_fld_ptr_esp(DEF_DOUBLE);
366
367 //add esp,8
368 op_add_esp(8);
369 }
370 else if(type==DEF_SINGLE){
371 //fld dword ptr[esp]
372 op_fld_ptr_esp(DEF_SINGLE);
373
374 //add esp,4
375 op_add_esp(4);
376 }
377 else if( Is64Type( type ) ){
378 //pop eax
379 op_pop(REG_EAX);
380
381 //pop edx
382 op_pop(REG_EDX);
383 }
384 else{
385 //pop eax
386 op_pop(REG_EAX);
387 }
388}
389
390void SetVariableFromEax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
391 /////////////////////////////////////////////////
392 // eaxの内容を変数にコピーするコードを抽出
393 /////////////////////////////////////////////////
394
395 if(VarType==DEF_BOOLEAN){
396 //bool
397 SetBooleanVariable(CalcType,pRelativeVar);
398 }
399 else if( IsRealNumberType( VarType ) ){
400 // Double/Single型変数へレジスタの値を代入
401 SetRealVariable(VarType, CalcType, pRelativeVar);
402 }
403 else if( IsWholeNumberType( VarType ) || VarType == DEF_OBJECT ){
404 int typeSize = GetTypeSize( VarType, -1 );
405
406 //整数変数へraxの値を格納する
407 SetWholeVariable( typeSize, CalcType, pRelativeVar );
408 }
409 else{
410 SetError(300,NULL,cp);
411 }
412}
413
414void OpcodeCalc(char *Command){
415 int i,i2,i3;
416 char variable[VN_SIZE];
417
418 for(i=0;;i++){
419 if(Command[i]=='\"'){
420 //ダブルクォートは不正なのでエラー扱い
421 variable[i]=0;
422 SetError(3,variable,cp);
423 return;
424 }
425
426 if(Command[i]=='('){
427 i2=GetStringInPare(variable+i,Command+i);
428 i+=i2-1;
429 continue;
430 }
431 if(Command[i]=='['){
432 i2=GetStringInBracket(variable+i,Command+i);
433 i+=i2-1;
434 continue;
435 }
436 if(Command[i]=='\0'){
437
438 ///////////////////////////////////
439 // インクリメント・デクリメント
440 ///////////////////////////////////
441
442 if(i>2){
443 if(Command[i-2]=='+'&&Command[i-1]=='+'){
444 //インクリメント
445 variable[i-2]=0;
446 IncDec(CALC_ADDITION,variable,"1");
447 return;
448 }
449 else if(Command[i-2]=='-'&&Command[i-1]=='-'){
450 //デクリメント
451 variable[i-2]=0;
452 IncDec(CALC_SUBTRACTION,variable,"1");
453 return;
454 }
455 }
456
457
458 //先端部分の識別子をエラーキーワードにする
459 for(i=0;;i++){
460 if(!IsVariableChar(Command[i])){
461 variable[i]=0;
462 break;
463 }
464 variable[i]=Command[i];
465 }
466
467 LONG_PTR lp;
468 if(GetVarType(variable,&lp,0)!=-1){
469 //変数リストに該当したとき
470 SetError(1,NULL,cp);
471 }
472 else{
473 if(GetConstHash(variable)){
474 //定数リストに該当したとき
475 SetError(1,NULL,cp);
476 }
477 else{
478 //変数リスト、定数リストに該当しないとき
479 SetError(3,variable,cp);
480 }
481 }
482 return;
483 }
484
485 i2=GetCalcId(Command+i,&i3);
486 if(i2){
487 variable[i]=0;
488
489 if(Command[i]=='=') break;
490
491 if(Command[i+1+i3]=='='){
492 IncDec(i2,variable,Command+i+1+i3+1);
493 return;
494 }
495 }
496
497 variable[i]=Command[i];
498 }
499
500 if(Command[i+1]=='\0'){
501 SetError(1,NULL,cp);
502 return;
503 }
504
505
506
507 ///////////////////////////////////////////////////////////////
508 // インデクサのsetアクセサ（[]=演算子のオーバーロードに対応）
509 ///////////////////////////////////////////////////////////////
510
511 char ObjName[VN_SIZE],array_element[VN_SIZE];
512 CClass *pobj_c;
513 GetArrayElement(variable,ObjName,array_element);
514 if(array_element[0]){
515 i2=GetVarType(ObjName,(LONG_PTR *)&pobj_c,0);
516 if(i2==DEF_OBJECT){
517 char temporary[VN_SIZE];
518 sprintf(temporary,"%s.%c%c%c",ObjName,1,ESC_OPERATOR,CALC_ARRAY_SET);
519
520 char temp2[VN_SIZE];
521 sprintf(temp2,"%s,%s",array_element,Command+i+1);
522
523 int idProc;
524 void *pInfo;
525 idProc=GetProc(temporary,&pInfo);
526 if(idProc){
527 CallProc(idProc,pInfo,temporary,temp2,NULL);
528 return;
529 }
530 }
531 }
532
533
534 if( lstrcmpi( variable, "This" ) == 0 ){
535 SetError(133,NULL,cp);
536 return;
537 }
538
539
540 ////////////////////////////////////////
541 // 変数のタイプ型を識別して、演算を行う
542 ////////////////////////////////////////
543
544 int VarType,CalcType;
545 LONG_PTR lpVarIndex,lpCalcIndex;
546 RELATIVE_VAR VarRelativeVar;
547 BOOL bCalcUseHeap;
548
549 //型を識別
550 VarType=GetVarType(variable,&lpVarIndex,0);
551 if(VarType==-1){
552
553 // プロパティ用のメソッドを呼び出す
554 if(!CallPropertyMethod(variable,Command+i+1,NULL)){
555 //エラーを表示
556 GetVarType(variable,&lpVarIndex,1);
557 }
558
559 return;
560 }
561
562 extern LONG_PTR ProcPtr_BaseIndex;
563 if(VarType==DEF_PTR_PROC) ProcPtr_BaseIndex=lpVarIndex;
564 else ProcPtr_BaseIndex=-1;
565
566 if(VarType==DEF_STRUCT){
567 //代入コピーに備える
568
569 //変数アドレスを取得
570 if(!GetVarOffsetReadWrite(
571 variable,
572 &VarType,
573 &VarRelativeVar,
574 &lpVarIndex)) return;
575
576 SetVarPtrToEax(&VarRelativeVar);
577
578 //push eax
579 op_push(REG_EAX);
580 }
581
582
583 //NumOpe...（スタックに答えが格納される）
584 CalcType=NumOpe(Command+i+1,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
585 if(VarType==-1||CalcType==-1) return;
586
587 //変数アドレスを取得
588 if(!GetVarOffsetReadWrite(
589 variable,
590 &VarType,
591 &VarRelativeVar,
592 &lpVarIndex)) return;
593
594 if(VarType&FLAG_PTR){
595 SetError(14,variable,cp);
596 return;
597 }
598
599 if(VarType==DEF_STRUCT){
600 //オブジェクトインスタンスへの代入
601 SetStructVariable(lpVarIndex,CalcType,lpCalcIndex,bCalcUseHeap);
602 return;
603 }
604
605 if(CalcType==DEF_OBJECT && (CalcType!=VarType || lpCalcIndex!=lpVarIndex) ){
606 //キャスト演算子のオーバーロードに対応する
607 CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,VarType,lpVarIndex);
608 }
609
610
611
612 /////////////////////////////////
613 // 右辺、左辺の型チェックを行う
614 /////////////////////////////////
615
616 CheckDifferentType(VarType,lpVarIndex,CalcType,lpCalcIndex,0,0);
617
618
619 /////////////////////////////////////////////////
620 // スタックの内容を変数にコピーするコードを抽出
621 /////////////////////////////////////////////////
622
623 //eax、edx:eax、またはst(0)にスタック上のデータを取り出す
624 RestoreDefaultRegisterFromStackMemory( CalcType );
625
626 SetVariableFromEax( VarType, CalcType, &VarRelativeVar );
627/*
628 TODO: 消す
629 if(VarType==DEF_BOOLEAN){
630 //bool
631 SetBooleanVariable(CalcType,&VarRelativeVar);
632 }
633 else if(VarType==DEF_SBYTE||VarType==DEF_BYTE || (isUnicode==false&&VarType==DEF_CHAR)){
634 //8ビット整数型変数へスタックの内容を格納する
635 Set8Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
636 }
637 else if(VarType==DEF_INTEGER||VarType==DEF_WORD || (isUnicode&&VarType==DEF_CHAR)){
638 //16ビット整数型変数へスタックの内容を格納する
639 Set16Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
640 }
641 else if(VarType==DEF_LONG||VarType==DEF_DWORD||IsPtrType(VarType)){
642 //32ビット整数型変数へスタックの内容を格納する
643 if(VarType==DEF_LONG)
644 SetLongVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
645 else
646 SetDWordVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
647 }
648 else if(VarType==DEF_INT64||VarType==DEF_QWORD){
649 //64ビット整数型変数へスタックの内容を格納する
650 SetInt64Variable(CalcType,&VarRelativeVar);
651 }
652 else if(VarType==DEF_DOUBLE){
653 //Double型変数へスタックの内容を格納する
654 SetDoubleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
655 }
656 else if(VarType==DEF_SINGLE){
657 //Single型変数へスタックの内容を格納する
658 SetSingleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
659 }*/
660}
661
662
663// TODO: 消す
664/*
665void SetRefVariable( const char *varname, const char *expression ){
666 ////////////////////////////////////////
667 // 変数のタイプ型を識別して、演算を行う
668 ////////////////////////////////////////
669
670 int VarType,CalcType;
671 LONG_PTR lpVarIndex,lpCalcIndex;
672 RELATIVE_VAR VarRelativeVar;
673 BOOL bCalcUseHeap;
674
675 //型を識別
676 VarType=GetVarType(varname,&lpVarIndex,0);
677 if(VarType==-1){
678 SetError(300,NULL,cp);
679 return;
680 }
681
682 extern LONG_PTR ProcPtr_BaseIndex;
683 if(VarType==DEF_PTR_PROC) ProcPtr_BaseIndex=lpVarIndex;
684 else ProcPtr_BaseIndex=-1;
685
686 if(VarType==DEF_OBJECT){
687 //代入演算のオーバーロード オペレータに備える
688
689 //変数アドレスを取得
690 if(!GetVarOffsetReadWrite(
691 varname,
692 &VarType,
693 &VarRelativeVar,
694 &lpVarIndex)) return;
695
696 SetVarPtrToEax(&VarRelativeVar);
697
698 //push eax
699 op_push(REG_EAX);
700 }
701
702
703 //NumOpe...（スタックに答えが格納される）
704 CalcType=NumOpe(expression,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
705 if(VarType==-1||CalcType==-1) return;
706
707 //変数アドレスを取得
708 if(!GetVarOffsetReadWrite(
709 varname,
710 &VarType,
711 &VarRelativeVar,
712 &lpVarIndex)) return;
713
714 if(VarType&FLAG_PTR){
715 SetError(14,varname,cp);
716 return;
717 }
718
719
720 if( VarType == DEF_OBJECT
721 && (VarRelativeVar.dwKind == VAR_REFLOCAL || VarRelativeVar.dwKind == VAR_REFGLOBAL ) ){
722 // 参照型オブジェクトへの代入（初期化）はポインタ変数と同様の処理に値する
723 PTR_LEVEL_UP( VarType );
724
725 if( VarRelativeVar.dwKind == VAR_REFGLOBAL ){
726 VarRelativeVar.dwKind = VAR_GLOBAL;
727 }
728 else if( VarRelativeVar.dwKind == VAR_REFLOCAL ){
729 VarRelativeVar.dwKind = VAR_LOCAL;
730 }
731
732 if( CalcType == DEF_OBJECT ){
733 //右辺値が実体オブジェクトのときは、参照をコピー
734 PTR_LEVEL_UP( CalcType );
735 }
736 }
737 else{
738 SetError(300,NULL,cp);
739 }
740
741
742 /////////////////////////////////
743 // 右辺、左辺の型チェックを行う
744 /////////////////////////////////
745
746 CheckDifferentType(VarType,lpVarIndex,CalcType,lpCalcIndex,0,0);
747
748
749 /////////////////////////////////////////////////
750 // スタックの内容を変数にコピーするコードを抽出
751 /////////////////////////////////////////////////
752
753 if(VarType==DEF_BOOLEAN){
754 //bool
755 SetBooleanVariable(CalcType,&VarRelativeVar);
756 }
757 else if(VarType==DEF_SBYTE||VarType==DEF_BYTE || (isUnicode==false&&VarType==DEF_CHAR)){
758 //8ビット整数型変数へスタックの内容を格納する
759 Set8Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
760 }
761 else if(VarType==DEF_INTEGER||VarType==DEF_WORD || (isUnicode&&VarType==DEF_CHAR)){
762 //16ビット整数型変数へスタックの内容を格納する
763 Set16Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
764 }
765 else if(VarType==DEF_LONG||VarType==DEF_DWORD||IsPtrType(VarType)){
766 //32ビット整数型変数へスタックの内容を格納する
767 if(VarType==DEF_LONG)
768 SetLongVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
769 else
770 SetDWordVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
771 }
772 else if(VarType==DEF_INT64||VarType==DEF_QWORD){
773 //64ビット整数型変数へスタックの内容を格納する
774 SetInt64Variable(CalcType,&VarRelativeVar);
775 }
776 else if(VarType==DEF_DOUBLE){
777 //Double型変数へスタックの内容を格納する
778 SetDoubleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
779 }
780 else if(VarType==DEF_SINGLE){
781 //Single型変数へスタックの内容を格納する
782 SetSingleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
783 }
784}
785*/
Note: See TracBrowser for help on using the repository browser.