source: dev/BasicCompiler32/Compile_Calc.cpp@ 64

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

すべてのオブジェクトを参照型に切り替えた。
File size: 17.9 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_value(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_value(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 fpu_cast();
226 OpBuffer[obp++]=(char)0xDF;
227 OpBuffer[obp++]=(char)0x3C;
228 OpBuffer[obp++]=(char)0x24;
229 fpu_cast_end();
230 }
231 else if(OldType==DEF_SINGLE){
232 //fld dword ptr[esp]
233 op_fld_ptr_esp(DEF_SINGLE);
234
235 //sub esp,4
236 op_sub_esp(4);
237
238 //fistp qword ptr[esp]
239 fpu_cast();
240 OpBuffer[obp++]=(char)0xDF;
241 OpBuffer[obp++]=(char)0x3C;
242 OpBuffer[obp++]=(char)0x24;
243 fpu_cast_end();
244 }
245 else if(IsWholeNumberType(OldType)){
246 //その他整数
247
248 if(IsSignedType(OldType)){
249 //符号あり
250
251 //pop eax
252 op_pop(REG_EAX);
253
254 //cdq
255 op_cdq();
256
257 //push edx
258 op_push(REG_EDX);
259
260 //push eax
261 op_push(REG_EAX);
262 }
263 else{
264 //符号なし
265
266 //pop eax
267 op_pop(REG_EAX);
268
269 //push 0
270 op_push_value(0);
271
272 //push eax
273 op_push(REG_EAX);
274 }
275 }
276 else SetError(9,NULL,cp);
277}
278void ChangeTypeToLong(int OldType){
279 //現在のスタックの内容をLong型に変換する
280 //NumOpeの直後専用
281 if(OldType==DEF_DOUBLE){
282
283 //fld qword ptr[esp]
284 op_fld_ptr_esp(DEF_DOUBLE);
285
286 //add esp,4
287 op_add_esp(4);
288
289 //fistp dword ptr[esp]
290 fpu_cast();
291 OpBuffer[obp++]=(char)0xDB;
292 OpBuffer[obp++]=(char)0x1C;
293 OpBuffer[obp++]=(char)0x24;
294 fpu_cast_end();
295 }
296 else if(OldType==DEF_SINGLE){
297 //fld dword ptr[esp]
298 op_fld_ptr_esp(DEF_SINGLE);
299
300 //fistp dword ptr[esp]
301 fpu_cast();
302 OpBuffer[obp++]=(char)0xDB;
303 OpBuffer[obp++]=(char)0x1C;
304 OpBuffer[obp++]=(char)0x24;
305 fpu_cast_end();
306 }
307 else if(OldType==DEF_INT64||OldType==DEF_QWORD){
308 //pop eax
309 op_pop(REG_EAX);
310
311 //add esp,4
312 op_add_esp(4);
313
314 //push eax
315 op_push(REG_EAX);
316 }
317}
318void ChangeTypeToInteger(int OldType){
319 //現在のスタックの内容をInteger型に変換する
320 if(OldType==DEF_BOOLEAN||
321 OldType==DEF_BYTE||
322 OldType==DEF_WORD||OldType==DEF_INTEGER || (isUnicode&&OldType==DEF_CHAR)) return;
323 else if(OldType==DEF_SBYTE || (isUnicode==false&&OldType==DEF_CHAR)){
324 //pop eax
325 op_pop(REG_EAX);
326
327 //movsx eax,al
328 OpBuffer[obp++]=(char)0x0F;
329 OpBuffer[obp++]=(char)0xBE;
330 OpBuffer[obp++]=(char)0xC0;
331
332 //push eax
333 op_push(REG_EAX);
334 }
335 else{
336 ChangeTypeToLong(OldType);
337
338 //pop eax
339 op_pop(REG_EAX);
340
341 //and eax,0000FFFFh
342 OpBuffer[obp++]=(char)0x25;
343 *((long *)(OpBuffer+obp))=0x0000FFFF;
344 obp+=sizeof(long);
345
346 //push eax
347 op_push(REG_EAX);
348 }
349}
350void ChangeTypeToByte(int OldType){
351 //現在のスタックの内容をbyte型に変換する
352 if(OldType==DEF_BYTE||OldType==DEF_SBYTE || (isUnicode==false&&OldType==DEF_CHAR)) return;
353
354 ChangeTypeToLong(OldType);
355
356 //pop eax
357 op_pop(REG_EAX);
358
359 //and eax,000000FFh
360 OpBuffer[obp++]=(char)0x25;
361 *((long *)(OpBuffer+obp))=0x000000FF;
362 obp+=sizeof(long);
363
364 //push eax
365 op_push(REG_EAX);
366}
367
368
369
370
371
372
373
374
375
376void RestoreDefaultRegisterFromStackMemory( int type ){
377 //現在のスタックの内容を実数レジスタに保存する
378 //NumOpeの直後専用
379 if(type==DEF_DOUBLE){
380 //fld qword ptr[esp]
381 op_fld_ptr_esp(DEF_DOUBLE);
382
383 //add esp,8
384 op_add_esp(8);
385 }
386 else if(type==DEF_SINGLE){
387 //fld dword ptr[esp]
388 op_fld_ptr_esp(DEF_SINGLE);
389
390 //add esp,4
391 op_add_esp(4);
392 }
393 else if( Is64Type( type ) ){
394 //pop eax
395 op_pop(REG_EAX);
396
397 //pop edx
398 op_pop(REG_EDX);
399 }
400 else{
401 //pop eax
402 op_pop(REG_EAX);
403 }
404}
405
406void SetVariableFromEax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
407 /////////////////////////////////////////////////
408 // eaxの内容を変数にコピーするコードを抽出
409 /////////////////////////////////////////////////
410
411 if(VarType==DEF_BOOLEAN){
412 //bool
413 SetBooleanVariable(CalcType,pRelativeVar);
414 }
415 else if( IsRealNumberType( VarType ) ){
416 // Double/Single型変数へレジスタの値を代入
417 SetRealVariable(VarType, CalcType, pRelativeVar);
418 }
419 else if( IsWholeNumberType( VarType ) || VarType == DEF_OBJECT ){
420 int typeSize = GetTypeSize( VarType, -1 );
421
422 //整数変数へraxの値を格納する
423 SetWholeVariable( typeSize, CalcType, pRelativeVar );
424 }
425 else{
426 SetError(300,NULL,cp);
427 }
428}
429
430void OpcodeCalc(char *Command){
431 int i,i2,i3;
432 char variable[VN_SIZE];
433
434 for(i=0;;i++){
435 if(Command[i]=='\"'){
436 //ダブルクォートは不正なのでエラー扱い
437 variable[i]=0;
438 SetError(3,variable,cp);
439 return;
440 }
441
442 if(Command[i]=='('){
443 i2=GetStringInPare(variable+i,Command+i);
444 i+=i2-1;
445 continue;
446 }
447 if(Command[i]=='['){
448 i2=GetStringInBracket(variable+i,Command+i);
449 i+=i2-1;
450 continue;
451 }
452 if(Command[i]=='\0'){
453
454 ///////////////////////////////////
455 // インクリメント・デクリメント
456 ///////////////////////////////////
457
458 if(i>2){
459 if(Command[i-2]=='+'&&Command[i-1]=='+'){
460 //インクリメント
461 variable[i-2]=0;
462 IncDec(CALC_ADDITION,variable,"1");
463 return;
464 }
465 else if(Command[i-2]=='-'&&Command[i-1]=='-'){
466 //デクリメント
467 variable[i-2]=0;
468 IncDec(CALC_SUBTRACTION,variable,"1");
469 return;
470 }
471 }
472
473
474 //先端部分の識別子をエラーキーワードにする
475 for(i=0;;i++){
476 if(!IsVariableChar(Command[i])){
477 variable[i]=0;
478 break;
479 }
480 variable[i]=Command[i];
481 }
482
483 LONG_PTR lp;
484 if(GetVarType(variable,&lp,0)!=-1){
485 //変数リストに該当したとき
486 SetError(1,NULL,cp);
487 }
488 else{
489 if(GetConstHash(variable)){
490 //定数リストに該当したとき
491 SetError(1,NULL,cp);
492 }
493 else{
494 //変数リスト、定数リストに該当しないとき
495 SetError(3,variable,cp);
496 }
497 }
498 return;
499 }
500
501 i2=GetCalcId(Command+i,&i3);
502 if(i2){
503 variable[i]=0;
504
505 if(Command[i]=='=') break;
506
507 if(Command[i+1+i3]=='='){
508 IncDec(i2,variable,Command+i+1+i3+1);
509 return;
510 }
511 }
512
513 variable[i]=Command[i];
514 }
515
516 if(Command[i+1]=='\0'){
517 SetError(1,NULL,cp);
518 return;
519 }
520
521
522
523 ///////////////////////////////////////////////////////////////
524 // インデクサのsetアクセサ（[]=演算子のオーバーロードに対応）
525 ///////////////////////////////////////////////////////////////
526
527 char ObjName[VN_SIZE],array_element[VN_SIZE];
528 CClass *pobj_c;
529 GetArrayElement(variable,ObjName,array_element);
530 if(array_element[0]){
531 i2=GetVarType(ObjName,(LONG_PTR *)&pobj_c,0);
532 if(i2==DEF_OBJECT){
533 char temporary[VN_SIZE];
534 sprintf(temporary,"%s.%c%c%c",ObjName,1,ESC_OPERATOR,CALC_ARRAY_SET);
535
536 char temp2[VN_SIZE];
537 sprintf(temp2,"%s,%s",array_element,Command+i+1);
538
539 int idProc;
540 void *pInfo;
541 idProc=GetProc(temporary,&pInfo);
542 if(idProc){
543 CallProc(idProc,pInfo,temporary,temp2,NULL);
544 return;
545 }
546 }
547 }
548
549
550 if( lstrcmpi( variable, "This" ) == 0 ){
551 SetError(133,NULL,cp);
552 return;
553 }
554
555
556 ////////////////////////////////////////
557 // 変数のタイプ型を識別して、演算を行う
558 ////////////////////////////////////////
559
560 int VarType,CalcType;
561 LONG_PTR lpVarIndex,lpCalcIndex;
562 RELATIVE_VAR VarRelativeVar;
563 BOOL bCalcUseHeap;
564
565 //型を識別
566 VarType=GetVarType(variable,&lpVarIndex,0);
567 if(VarType==-1){
568
569 // プロパティ用のメソッドを呼び出す
570 if(!CallPropertyMethod(variable,Command+i+1,NULL)){
571 //エラーを表示
572 GetVarType(variable,&lpVarIndex,1);
573 }
574
575 return;
576 }
577
578 extern LONG_PTR ProcPtr_BaseIndex;
579 if(VarType==DEF_PTR_PROC) ProcPtr_BaseIndex=lpVarIndex;
580 else ProcPtr_BaseIndex=-1;
581
582 if(VarType==DEF_STRUCT){
583 //代入コピーに備える
584
585 //変数アドレスを取得
586 if(!GetVarOffsetReadWrite(
587 variable,
588 &VarType,
589 &VarRelativeVar,
590 &lpVarIndex)) return;
591
592 SetVarPtrToEax(&VarRelativeVar);
593
594 //push eax
595 op_push(REG_EAX);
596 }
597
598
599 //NumOpe...（スタックに答えが格納される）
600 CalcType=NumOpe(Command+i+1,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
601 if(VarType==-1||CalcType==-1) return;
602
603 //変数アドレスを取得
604 if(!GetVarOffsetReadWrite(
605 variable,
606 &VarType,
607 &VarRelativeVar,
608 &lpVarIndex)) return;
609
610 if(VarType&FLAG_PTR){
611 SetError(14,variable,cp);
612 return;
613 }
614
615 if(VarType==DEF_STRUCT){
616 //オブジェクトインスタンスへの代入
617 SetStructVariable(lpVarIndex,CalcType,lpCalcIndex,bCalcUseHeap);
618 return;
619 }
620
621 if(CalcType==DEF_OBJECT && (CalcType!=VarType || lpCalcIndex!=lpVarIndex) ){
622 //キャスト演算子のオーバーロードに対応する
623 CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,VarType,lpVarIndex);
624 }
625
626
627
628 /////////////////////////////////
629 // 右辺、左辺の型チェックを行う
630 /////////////////////////////////
631
632 CheckDifferentType(VarType,lpVarIndex,CalcType,lpCalcIndex,0,0);
633
634
635 /////////////////////////////////////////////////
636 // スタックの内容を変数にコピーするコードを抽出
637 /////////////////////////////////////////////////
638
639 //eax、edx:eax、またはst(0)にスタック上のデータを取り出す
640 RestoreDefaultRegisterFromStackMemory( CalcType );
641
642 SetVariableFromEax( VarType, CalcType, &VarRelativeVar );
643/*
644 TODO: 消す
645 if(VarType==DEF_BOOLEAN){
646 //bool
647 SetBooleanVariable(CalcType,&VarRelativeVar);
648 }
649 else if(VarType==DEF_SBYTE||VarType==DEF_BYTE || (isUnicode==false&&VarType==DEF_CHAR)){
650 //8ビット整数型変数へスタックの内容を格納する
651 Set8Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
652 }
653 else if(VarType==DEF_INTEGER||VarType==DEF_WORD || (isUnicode&&VarType==DEF_CHAR)){
654 //16ビット整数型変数へスタックの内容を格納する
655 Set16Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
656 }
657 else if(VarType==DEF_LONG||VarType==DEF_DWORD||IsPtrType(VarType)){
658 //32ビット整数型変数へスタックの内容を格納する
659 if(VarType==DEF_LONG)
660 SetLongVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
661 else
662 SetDWordVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
663 }
664 else if(VarType==DEF_INT64||VarType==DEF_QWORD){
665 //64ビット整数型変数へスタックの内容を格納する
666 SetInt64Variable(CalcType,&VarRelativeVar);
667 }
668 else if(VarType==DEF_DOUBLE){
669 //Double型変数へスタックの内容を格納する
670 SetDoubleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
671 }
672 else if(VarType==DEF_SINGLE){
673 //Single型変数へスタックの内容を格納する
674 SetSingleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
675 }*/
676}
677
678
679// TODO: 消す
680/*
681void SetRefVariable( const char *varname, const char *expression ){
682 ////////////////////////////////////////
683 // 変数のタイプ型を識別して、演算を行う
684 ////////////////////////////////////////
685
686 int VarType,CalcType;
687 LONG_PTR lpVarIndex,lpCalcIndex;
688 RELATIVE_VAR VarRelativeVar;
689 BOOL bCalcUseHeap;
690
691 //型を識別
692 VarType=GetVarType(varname,&lpVarIndex,0);
693 if(VarType==-1){
694 SetError(300,NULL,cp);
695 return;
696 }
697
698 extern LONG_PTR ProcPtr_BaseIndex;
699 if(VarType==DEF_PTR_PROC) ProcPtr_BaseIndex=lpVarIndex;
700 else ProcPtr_BaseIndex=-1;
701
702 if(VarType==DEF_OBJECT){
703 //代入演算のオーバーロード オペレータに備える
704
705 //変数アドレスを取得
706 if(!GetVarOffsetReadWrite(
707 varname,
708 &VarType,
709 &VarRelativeVar,
710 &lpVarIndex)) return;
711
712 SetVarPtrToEax(&VarRelativeVar);
713
714 //push eax
715 op_push(REG_EAX);
716 }
717
718
719 //NumOpe...（スタックに答えが格納される）
720 CalcType=NumOpe(expression,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
721 if(VarType==-1||CalcType==-1) return;
722
723 //変数アドレスを取得
724 if(!GetVarOffsetReadWrite(
725 varname,
726 &VarType,
727 &VarRelativeVar,
728 &lpVarIndex)) return;
729
730 if(VarType&FLAG_PTR){
731 SetError(14,varname,cp);
732 return;
733 }
734
735
736 if( VarType == DEF_OBJECT
737 && (VarRelativeVar.dwKind == VAR_REFLOCAL || VarRelativeVar.dwKind == VAR_REFGLOBAL ) ){
738 // 参照型オブジェクトへの代入（初期化）はポインタ変数と同様の処理に値する
739 PTR_LEVEL_UP( VarType );
740
741 if( VarRelativeVar.dwKind == VAR_REFGLOBAL ){
742 VarRelativeVar.dwKind = VAR_GLOBAL;
743 }
744 else if( VarRelativeVar.dwKind == VAR_REFLOCAL ){
745 VarRelativeVar.dwKind = VAR_LOCAL;
746 }
747
748 if( CalcType == DEF_OBJECT ){
749 //右辺値が実体オブジェクトのときは、参照をコピー
750 PTR_LEVEL_UP( CalcType );
751 }
752 }
753 else{
754 SetError(300,NULL,cp);
755 }
756
757
758 /////////////////////////////////
759 // 右辺、左辺の型チェックを行う
760 /////////////////////////////////
761
762 CheckDifferentType(VarType,lpVarIndex,CalcType,lpCalcIndex,0,0);
763
764
765 /////////////////////////////////////////////////
766 // スタックの内容を変数にコピーするコードを抽出
767 /////////////////////////////////////////////////
768
769 if(VarType==DEF_BOOLEAN){
770 //bool
771 SetBooleanVariable(CalcType,&VarRelativeVar);
772 }
773 else if(VarType==DEF_SBYTE||VarType==DEF_BYTE || (isUnicode==false&&VarType==DEF_CHAR)){
774 //8ビット整数型変数へスタックの内容を格納する
775 Set8Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
776 }
777 else if(VarType==DEF_INTEGER||VarType==DEF_WORD || (isUnicode&&VarType==DEF_CHAR)){
778 //16ビット整数型変数へスタックの内容を格納する
779 Set16Variable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
780 }
781 else if(VarType==DEF_LONG||VarType==DEF_DWORD||IsPtrType(VarType)){
782 //32ビット整数型変数へスタックの内容を格納する
783 if(VarType==DEF_LONG)
784 SetLongVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
785 else
786 SetDWordVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
787 }
788 else if(VarType==DEF_INT64||VarType==DEF_QWORD){
789 //64ビット整数型変数へスタックの内容を格納する
790 SetInt64Variable(CalcType,&VarRelativeVar);
791 }
792 else if(VarType==DEF_DOUBLE){
793 //Double型変数へスタックの内容を格納する
794 SetDoubleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
795 }
796 else if(VarType==DEF_SINGLE){
797 //Single型変数へスタックの内容を格納する
798 SetSingleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
799 }
800}
801*/
Note: See TracBrowser for help on using the repository browser.