source: dev/BasicCompiler64/NumOpe.cpp@ 58

Last change on this file since 58 was 56, checked in by dai_9181, 18 years ago

・[Unicode]リテラル文字列のスイッチング
・[Unicode]Char型を文字型として扱うようにする
・[Unicode]SByte型を追加する
に対応。

/unicodeコマンドオプションに対応。
File size: 21.5 KB
Line 
1#include "../BasicCompiler_Common/common.h"
2#include "Opcode.h"
3
4void NewStringObject(int reg,LPSTR lpszText){
5 ///////////////////////////////////////////////////////
6 // lpszTextを元にStringオブジェクトを生成し、
7 // オブジェクトポインタをregに格納する
8 ///////////////////////////////////////////////////////
9
10
11 //////////////////////////////////////////////////////
12 ///// レジスタ資源のバックアップ
13 { BACKUP_REGISTER_RESOURCE
14 //////////////////////////////////////////////////////
15
16 extern CClass *pobj_StringClass;
17 int object_size;
18 object_size=GetSizeOfClass(pobj_StringClass);
19
20 //mov rcx,object_size
21 op_mov_RV(sizeof(_int64),REG_RCX,object_size);
22
23 //call calloc
24 extern SUBINFO *pSub_calloc;
25 op_call(pSub_calloc);
26
27 //mov r11,rax
28 op_mov_RR(REG_R11,REG_RAX);
29
30 //mov qword ptr[rsp+offset],r11 ※スタックフレームを利用
31 pobj_sf->push(REG_R11);
32
33 //mov rcx,rax
34 op_mov_RR(REG_RCX,REG_RAX);
35
36 //call constructor
37 op_call(pobj_StringClass->GetConstructorMethod()->psi);
38
39 // TODO: Ex表記による文字列長に対応する
40 int i2 = dataTable.AddString( lpszText );
41
42 //mov rax,i2
43 op_mov_RV(sizeof(_int64),REG_RAX,i2);
44 obp-=sizeof(long);
45 pobj_DataTableSchedule->add();
46 obp+=sizeof(long);
47
48
49 //mov r11,qword ptr[rsp+offset] ※スタックフレームを利用
50 pobj_sf->ref(REG_R11);
51
52
53 RELATIVE_VAR RelativeVar;
54 RelativeVar.bOffsetOffset=0;
55 RelativeVar.offset=0;
56 RelativeVar.dwKind=VAR_DIRECTMEM;
57
58 SetObjectVariableFromRax((LONG_PTR)pobj_StringClass,DEF_PTR_BYTE,-1,&RelativeVar,0);
59
60 //mov r11,qword ptr[rsp+offset] ※スタックフレームを利用
61 pobj_sf->pop(REG_R11);
62
63
64 /////////////////////////////////////////////
65 ////// レジスタ資源を復元
66 RESTORE_REGISTER_RESOURCE
67 }////////////////////////////////////////////
68
69 //mov reg,r11
70 op_mov_RR(reg,REG_R11);
71}
72
73void SetUseRegFromRax(int type,int UseReg,int XmmReg){
74 if(IsRealNumberType(type)){
75 //実数型
76 if(XmmReg==REG_XMM4){
77 if(type==DEF_DOUBLE){
78 //movsd qword ptr[rsp+offset],xmm0 ※スタックフレームを利用
79 pobj_sf->push(REG_XMM0,sizeof(double));
80 }
81 if(type==DEF_SINGLE){
82 //movss dword ptr[rsp+offset],xmm0 ※スタックフレームを利用
83 pobj_sf->push(REG_XMM0,sizeof(float));
84 }
85 }
86 else{
87 if(type==DEF_DOUBLE){
88 //movsd xmm_reg,xmm0
89 op_movsd_RR(XmmReg,REG_XMM0);
90 }
91 else if(type==DEF_SINGLE){
92 //movss xmm_reg,xmm0
93 op_movss_RR(XmmReg,REG_XMM0);
94 }
95 }
96 }
97 else{
98 //整数型
99 if(UseReg==REG_R14){
100 //mov qword ptr[rsp+offset],rax ※スタックフレームを利用
101 pobj_sf->push(REG_RAX);
102 }
103 else{
104 //mov reg,rax
105 op_mov64_ToReg_FromReg(UseReg,REG_RAX);
106 }
107 }
108}
109
110int NumOpe(int *pReg,const char *Command,int BaseType,LONG_PTR lpBaseIndex,LONG_PTR *plpIndex,BOOL *pbUseHeap){
111 extern HANDLE hHeap;
112 int i,i2,i3,i4;
113 char temporary[1024],temp2[1024],temp3[1024];
114
115 if(Command[0]=='\0'){
116 SetError(1,NULL,cp);
117 return 0;
118 }
119
120 if(Command[0]==1&&Command[1]==ESC_NEW){
121 //New演算子（オブジェクト生成）
122 return Operator_New(Command+2,plpIndex);
123 }
124
125
126 /////////////////////////////////
127 // 式要素を逆ポーランド式で取得
128 /////////////////////////////////
129
130 char *values[255];
131 long calc[255];
132 long stack[255];
133 int pnum;
134 if(!GetNumOpeElements(Command,&pnum,values,calc,stack)){
135 for(i=0;i<pnum;i++){
136 if(values[i]) HeapDefaultFree(values[i]);
137 }
138 return 0;
139 }
140
141
142 BOOL bInitRegSwitch=0;
143 if(!pobj_reg){
144 bInitRegSwitch=1;
145
146 //作業用レジスタを取得
147 pobj_reg=new CRegister(*pReg);
148 }
149
150 //エラー時の復旧用
151 CRegister objReg_Backup;
152 objReg_Backup=*pobj_reg;
153
154
155
156 ////////////////////////////////
157 // 演算部分のコード生成を開始
158 ////////////////////////////////
159
160 BOOL bError;
161 bError=0;
162
163 //リテラル値のみの計算かどうかを判別するためのフラグ
164 BOOL bLiteralCalculation=1;
165
166 //リテラル演算の場合を考慮した演算前のバッファ位置
167 int BeforeObp;
168 BeforeObp=obp;
169
170 //リテラル演算の場合を考慮した演算前のプロシージャスケジュール位置
171 //※64ビットの掛け算、除算などで特殊関数が呼ばれるため
172 int Before_ProcAddrScheduleNum;
173 Before_ProcAddrScheduleNum=pobj_SubAddrSchedule->num;
174
175 //リテラル演算の場合を考慮した演算前のデータテーブルスケジュール位置
176 int Before_DataTableScheduleNum;
177 Before_DataTableScheduleNum=pobj_DataTableSchedule->num;
178
179 //リテラル演算の場合を考慮した演算前の再配置スケジュール
180 CReloc *pobj_BackReloc;
181 pobj_BackReloc=new CReloc();
182 pobj_BackReloc->copy(pobj_Reloc);
183
184 //リテラル演算の場合を考慮した演算前のスタックフレームスケジュール位置
185 int Before_StackFrameScheduleNum;
186 Before_StackFrameScheduleNum=pobj_sf->num;
187
188 double dbl;
189 int sp;
190 int type[255];
191 LONG_PTR index_stack[255];
192 BOOL bUseHeap[255];
193 _int64 i64data;
194 int UseReg,XmmReg;
195 BOOL bXmm;
196 for(i=0,sp=0;i<pnum;i++){
197 int idCalc;
198 idCalc=calc[i]%100;
199
200 if(idCalc){
201 if(type[sp-2]==DEF_OBJECT){
202 //オーバーロードされたオペレータを呼び出す
203 TYPEINFO BaseTypeInfo={BaseType,lpBaseIndex};
204 i2=CallOperatorProc(idCalc,&BaseTypeInfo,type,index_stack,bUseHeap,sp);
205 if(i2==0){
206 if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
207 else GetCalcName(idCalc,temp2);
208 sprintf(temporary,"Operator %s",temp2);
209 SetError(27,temporary,cp);
210 goto error;
211 }
212 else if(i2==-1) goto error;
213
214 continue;
215 }
216
217 if(!CheckCalcType(idCalc,type,sp)) goto error;
218 }
219
220 switch(idCalc){
221 //数値
222 case 0:
223 index_stack[sp]=-1;
224 bUseHeap[sp]=0;
225
226 UseReg=pobj_reg->GetNextReg();
227 XmmReg=pobj_reg->GetNextXmmReg();
228
229 bXmm=0;
230
231 char *term;
232 term=values[i];
233
234 if(term[0]=='\"'){
235 //リテラル文字列
236 if(!RemoveStringQuotes(term)){
237 SetError(43,NULL,cp);
238 goto error;
239 }
240 i3=lstrlen(term);
241StrLiteral:
242
243 if(BaseType==DEF_OBJECT){
244 CClass *pobj_Class;
245 pobj_Class=(CClass *)lpBaseIndex;
246 TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex};
247 if(IsStringSubsituation(pobj_Class)
248 || IsStringObjectType(&BaseTypeInfo)){
249 //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
250
251 //String型オブジェクトを生成
252 NewStringObject(UseReg,term);
253
254 extern CClass *pobj_StringClass;
255 type[sp]=DEF_OBJECT;
256 index_stack[sp]=(LONG_PTR)pobj_StringClass;
257 bUseHeap[sp]=1;
258 bLiteralCalculation=0;
259
260 if(bXmm) pobj_reg->LockXmmReg();
261 else pobj_reg->LockReg();
262
263 sp++;
264 break;
265 }
266 }
267
268 type[sp]=DEF_PTR_BYTE;
269 bLiteralCalculation=0;
270
271 i2 = dataTable.AddString( term, i3 );
272
273 //mov reg,i2
274 op_mov_RV(sizeof(_int64),UseReg,i2);
275 obp-=sizeof(long);
276 pobj_DataTableSchedule->add();
277 obp+=sizeof(long);
278
279 if(UseReg==REG_R14){
280 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
281 pobj_sf->push(REG_R14);
282 }
283 }
284 else if((term[0]=='e'||term[0]=='E')&&
285 (term[1]=='x'||term[1]=='X')&&
286 term[2]=='\"'){
287 //拡張版リテラル文字列（エスケープシーケンス可能）
288 if(!RemoveStringQuotes(term+2)){
289 SetError(43,NULL,cp);
290 goto error;
291 }
292 i3=FormatString_EscapeSequence(term+2);
293 term+=2;
294
295 goto StrLiteral;
296 }
297 else if(IsVariableTopChar(term[0])||
298 term[0]=='*'||
299 (term[0]=='.'&&IsVariableTopChar(term[1]))){
300 //////////////////
301 // 何らかの識別子
302
303 //////////////////////////////////////
304 // 関数（DLL、ユーザー定義、組み込み）
305 //////////////////////////////////////
306
307 i2=GetCallProcName(term,temporary);
308 if(term[i2]=='('){
309 i4=GetStringInPare_RemovePare(temp2,term+i2+1);
310
311 int idProc;
312 void *pInfo;
313 idProc=GetProc(temporary,&pInfo);
314
315 if(idProc){
316 //閉じカッコ")"に続く文字がNULLでないとき
317 if(term[i2+1+i4+1]!='\0'){
318 if( term[i2+1+i4+1] == '.'
319 || term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
320 goto NonProc;
321 }
322 else{
323 SetError(42,NULL,cp);
324 }
325 }
326
327
328 //////////////////////////////////////////////////////
329 ///// レジスタ資源のバックアップ
330 { BACKUP_REGISTER_RESOURCE
331 //////////////////////////////////////////////////////
332
333
334 ////////////////
335 // 呼び出し
336 ////////////////
337
338 i2=CallProc(idProc,pInfo,temporary,temp2,&index_stack[sp]);
339 if(i2==-1){
340 //戻り値が存在しないとき
341 for(i2=2;;i2++){
342 if(term[i2]=='('||term[i2]=='\0'){
343 term[i2]=0;
344 break;
345 }
346 }
347 SetError(38,term,cp);
348
349 //レジスタ資源を復元
350 RESTORE_REGISTER_RESOURCE
351
352 goto error;
353 }
354
355
356 /////////////////////
357 // 戻り値の処理
358 /////////////////////
359
360 //大きな型への暗黙の変換
361 type[sp]=AutoBigCast(BaseType,i2);
362 bLiteralCalculation=0;
363
364 SetUseRegFromRax(i2,UseReg,XmmReg);
365
366 if(IsRealNumberType(i2)) bXmm=1;
367 else bXmm=0;
368
369 /////////////////////////////////////////////
370 ////// レジスタ資源を復元
371 RESTORE_REGISTER_RESOURCE
372 }////////////////////////////////////////////
373
374
375 if(bXmm) pobj_reg->LockXmmReg();
376 else pobj_reg->LockReg();
377
378 if(i2==DEF_OBJECT){
379 //Object型が戻ったときはヒープ領域にインスタンスが格納されている
380 //※後にfreeする必要あり
381 bUseHeap[sp]=1;
382 }
383
384 sp++;
385 break;
386 }
387 else if(GetConstCalcBuffer(temporary,temp2,temp3)){
388 /////////////////////////
389 // マクロ関数
390 /////////////////////////
391
392 //閉じカッコ")"に続く文字がNULLでないときはエラーにする
393 if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
394
395 //マクロ関数の場合
396 i2=NumOpe(&UseReg,temp3,0,0,&index_stack[sp]);
397
398 if(!IS_LITERAL(index_stack[sp])){
399 //リテラル値ではなかったとき
400 bLiteralCalculation=0;
401 }
402
403 type[sp]=i2;
404
405 if(IsRealNumberType(i2)) pobj_reg->LockXmmReg();
406 else pobj_reg->LockReg();
407
408 sp++;
409 break;
410 }
411 }
412NonProc:
413
414
415 //インデクサ（getアクセサ）
416 char variable[VN_SIZE],array_element[VN_SIZE];
417 CClass *pobj_c;
418 GetArrayElement(term,variable,array_element);
419 if(array_element[0]){
420 i2=GetVarType(variable,(LONG_PTR *)&pobj_c,0);
421 if(i2==DEF_OBJECT){
422 TYPEINFO RetTypeInfo;
423 CallIndexerGetterProc(UseReg,pobj_c,variable,array_element,RetTypeInfo);
424 type[sp]=RetTypeInfo.type;
425 index_stack[sp]=RetTypeInfo.u.lpIndex;
426 bLiteralCalculation=0;
427
428 if(IsRealNumberType(RetTypeInfo.type)) pobj_reg->LockXmmReg();
429 else pobj_reg->LockReg();
430 sp++;
431 break;
432 }
433 }
434
435
436 RELATIVE_VAR RelativeVar;
437 if(GetVarOffset(
438 false, //エラー表示あり
439 false, //読み込み専用
440 term,
441 &i2,&RelativeVar,&index_stack[sp])){
442 //////////
443 // 変数
444 //////////
445
446 //大きな型への暗黙の変換
447 type[sp]=AutoBigCast(BaseType,i2);
448 bLiteralCalculation=0;
449
450 if(type[sp]!=i2){
451 //大きな型へ変換された場合（レジスタを0に初期化する）
452
453 //xor reg,reg
454 op_zero_reg(UseReg);
455 }
456
457 if(i2&FLAG_PTR){
458 //配列ポインタ
459 type[sp]=GetPtrType(i2^FLAG_PTR,index_stack[sp]);
460
461 SetVarPtrToReg(UseReg,&RelativeVar);
462 }
463 else if(IsRealNumberType(i2)){
464 //実数型
465 bXmm=1;
466
467 if(i2==DEF_DOUBLE)
468 SetXmmReg_DoubleVariable(&RelativeVar,XmmReg);
469 if(i2==DEF_SINGLE)
470 SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
471 }
472 else if(IsWholeNumberType(i2)){
473 //整数型
474 SetReg_WholeVariable(i2,&RelativeVar,UseReg);
475 }
476 else if(i2==DEF_OBJECT){
477 //オブジェクト ポインタをUseRegへ格納
478 SetVarPtrToReg(UseReg,&RelativeVar);
479 }
480 else SetError(11,term,cp);
481
482 if(bXmm==0&&UseReg==REG_R14){
483 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
484 pobj_sf->push(REG_R14);
485 }
486 if(bXmm&&XmmReg==REG_XMM4){
487 if(i2==DEF_DOUBLE){
488 //movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
489 pobj_sf->push(REG_XMM4,sizeof(double));
490 }
491 if(i2==DEF_SINGLE){
492 //movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
493 pobj_sf->push(REG_XMM4,sizeof(float));
494 }
495 }
496
497 if(bXmm) pobj_reg->LockXmmReg();
498 else pobj_reg->LockReg();
499 sp++;
500 break;
501 }
502
503
504 //////////////
505 // 定数の場合
506 //////////////
507
508 i3 = CDBConst::obj.GetType(term);
509 if(i3){
510 type[sp] = i3;
511 if(IsRealNumberType(i3)){
512 //実数
513 double dbl = CDBConst::obj.GetDoubleData(term);
514 memcpy(&i64data,&dbl,sizeof(double));
515 goto Literal;
516 }
517 else if(IsWholeNumberType(i3)){
518 //整数
519 i64data = CDBConst::obj.GetWholeData(term);
520 goto Literal;
521 }
522 /*else if(i3==DEF_STRING){
523 //リテラル文字列
524
525 //バイト数
526 i3=(int)dbl;
527
528 memcpy(term,temporary,i3);
529 goto StrLiteral;
530 }*/
531 else{
532 SetError(1,NULL,0);
533 goto error;
534 }
535 }
536
537
538
539 //////////////
540 // 型名の場合
541 //////////////
542
543 LONG_PTR lp;
544 i3=GetTypeFixed(term,&lp);
545 if(i3!=-1){
546 type[sp]=i3|FLAG_CAST;
547 index_stack[sp]=lp;
548 sp++;
549 break;
550 }
551
552
553
554 /////////////////////////////////
555 // プロパティ用のメソッド
556 /////////////////////////////////
557
558 //配列要素を排除
559 char VarName[VN_SIZE],ArrayElements[VN_SIZE];
560 GetArrayElement(term,VarName,ArrayElements);
561
562 if(GetSubHash(VarName,0)){
563
564 //////////////////////////////////////////////////////
565 ///// レジスタ資源のバックアップ
566 { BACKUP_REGISTER_RESOURCE
567 //////////////////////////////////////////////////////
568
569 TYPEINFO RetTypeInfo;
570 CallPropertyMethod(term,NULL,&RetTypeInfo);
571
572 //大きな型への暗黙の変換
573 type[sp]=AutoBigCast(BaseType,RetTypeInfo.type);
574
575 index_stack[sp]=RetTypeInfo.u.lpIndex;
576 bLiteralCalculation=0;
577
578 SetUseRegFromRax(RetTypeInfo.type,UseReg,XmmReg);
579
580 if(IsRealNumberType(type[sp])) bXmm=1;
581 else bXmm=0;
582
583 /////////////////////////////////////////////
584 ////// レジスタ資源を復元
585 RESTORE_REGISTER_RESOURCE
586 }////////////////////////////////////////////
587
588 if(type[sp]==DEF_OBJECT){
589 //Object型が戻ったときはヒープ領域にインスタンスが格納されている
590 //※後にfreeする必要あり
591 bUseHeap[sp]=1;
592 }
593
594 if(bXmm) pobj_reg->LockXmmReg();
595 else pobj_reg->LockReg();
596 sp++;
597 break;
598 }
599
600
601
602 //該当する識別子が見当たらないときはエラー扱いにする
603 bError=1;
604 SetError(3,term,cp);
605 type[sp]=DEF_DOUBLE;
606 }
607 else{
608 //リテラル値
609 type[sp]=GetLiteralValue(term,&i64data,BaseType);
610Literal:
611 if(type[sp]==DEF_DOUBLE){
612 //64ビット浮動小数型
613 bXmm=1;
614
615 if(XmmReg==REG_XMM4){
616 //mov r14,i64data
617 op_mov64_ToReg(REG_R14,i64data);
618
619
620 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
621 pobj_sf->push(REG_R14);
622 }
623 else{
624 i3 = dataTable.Add( i64data );
625
626 //movlpd xmm_reg,qword ptr[data table offset]
627 OpBuffer[obp++]=(char)0x66;
628 OpBuffer[obp++]=(char)0x0F;
629 OpBuffer[obp++]=(char)0x12;
630 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
631 OpBuffer[obp++]=(char)0x25;
632 *((long *)(OpBuffer+obp))=i3;
633 pobj_DataTableSchedule->add();
634 obp+=sizeof(long);
635 }
636 }
637 else if(type[sp]==DEF_SINGLE){
638 //32ビット浮動小数型
639 bXmm=1;
640
641 float flt;
642 int i32data;
643 memcpy(&dbl,&i64data,sizeof(double));
644 flt=(float)dbl;
645 memcpy(&i32data,&flt,sizeof(long));
646
647 if(XmmReg==REG_XMM4){
648 //push term
649 op_push_value(i32data);
650 }
651 else{
652 i3=dataTable.Add( i32data );
653
654 //movss xmm_reg,dword ptr[data table offset]
655 OpBuffer[obp++]=(char)0xF3;
656 OpBuffer[obp++]=(char)0x0F;
657 OpBuffer[obp++]=(char)0x10;
658 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
659 OpBuffer[obp++]=(char)0x25;
660 *((long *)(OpBuffer+obp))=i3;
661 pobj_DataTableSchedule->add();
662 obp+=sizeof(long);
663 }
664 }
665 else{
666 //整数
667
668 index_stack[sp]=GetLiteralIndex(i64data);
669
670 //mov reg,i64data
671 op_mov64_ToReg(UseReg,i64data);
672
673 if(UseReg==REG_R14){
674 //mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
675 pobj_sf->push(REG_R14);
676 }
677 }
678 }
679
680 if(bXmm) pobj_reg->LockXmmReg();
681 else pobj_reg->LockReg();
682
683 sp++;
684 break;
685
686 //論理演算子
687 case CALC_XOR:
688 case CALC_OR:
689 case CALC_AND:
690 if(!CalcTwoTerm_Logical(idCalc,type,index_stack,&sp)) goto error;
691 break;
692 case CALC_NOT:
693 //value[sp-1]=Not value[sp-1]
694 //NOT演算子
695 if(!Calc_Not(type,sp)) goto error;
696 break;
697
698 //比較演算子
699 case CALC_PE: //value[sp-2] <= value[sp-1]
700 case CALC_QE: //value[sp-2] >= value[sp-1]
701 case CALC_P: //value[sp-2] < value[sp-1]
702 case CALC_Q: //value[sp-2] > value[sp-1]
703 case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
704 case CALC_EQUAL: //value[sp-2] = value[sp-1]
705 if(!CalcTwoTerm_Relational(idCalc,type,index_stack,&sp)) goto error;
706 break;
707
708 //ビットシフト
709 case CALC_SHL: //value[sp-2] << value[sp-1]
710 case CALC_SHR: //value[sp-2] >> value[sp-1]
711 if(!Calc_Shift(idCalc,type,&sp)) goto error;
712 break;
713
714 //算術演算
715 case CALC_ADDITION:
716 case CALC_SUBTRACTION:
717 case CALC_PRODUCT:
718 if(!CalcTwoTerm_Arithmetic(idCalc,type,index_stack,&sp)) goto error;
719 break;
720 case CALC_MOD:
721 //value[sp-2]%=value[sp-1]
722 //剰余演算
723 if(!Calc_Mod(type,index_stack,&sp)) goto error;
724 break;
725 case CALC_QUOTIENT:
726 //value[sp-2]/=value[sp-1];
727 //除算
728 if(!Calc_Divide(type,&sp,BaseType)) goto error;
729 break;
730 case CALC_INTQUOTIENT:
731 //value[sp-2]/=value[sp-1]
732 //整数除算
733 if(!Calc_IntDivide(type,index_stack,&sp)) goto error;
734 break;
735 case CALC_MINUSMARK:
736 //value[sp-1]=-value[sp-1]
737 //符号反転
738 if(!Calc_MinusMark(type,sp)) goto error;
739 break;
740 case CALC_POWER:
741 //べき乗演算（浮動小数点演算のみ）
742 if(!Calc_Power(type,&sp)) goto error;
743 break;
744 case CALC_AS:
745 //キャスト
746 if(!Calc_Cast(type,index_stack,&sp)) goto error;
747 break;
748 case CALC_BYVAL:
749 //ポインタ型→参照型
750 if( PTR_LEVEL( type[sp-1] ) <= 0 ){
751 //ポインタ型ではないとき
752 SetError( 3, NULL, cp );
753 goto error;
754 }
755
756 type[sp-1] = PTR_LEVEL_DOWN( type[sp-1] );
757
758 break;
759
760 default:
761 SetError(300,NULL,cp);
762 goto error;
763 }
764 }
765
766 if(bError) goto error;
767
768 if(sp!=1){
769 SetError(1,NULL,cp);
770 goto error;
771 }
772
773 if(bLiteralCalculation){
774 //右辺値が数値の定数式の場合
775 LONG_PTR lpClassIndex;
776 i2=StaticCalculation(true, Command,BaseType,&i64data,&lpClassIndex);
777
778 obp=BeforeObp;
779 pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
780 pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
781 pobj_Reloc->copy(pobj_BackReloc);
782 pobj_sf->num=Before_StackFrameScheduleNum;
783 *pobj_reg=objReg_Backup;
784
785 if(IsRealNumberType(i2)){
786 if(IsRealNumberType(BaseType)) i2=BaseType;
787
788 XmmReg=pobj_reg->LockXmmReg();
789
790 if(i2==DEF_DOUBLE){
791 i3 = dataTable.Add( i64data );
792
793 //movlpd xmm_reg,qword ptr[data table offset]
794 OpBuffer[obp++]=(char)0x66;
795 OpBuffer[obp++]=(char)0x0F;
796 OpBuffer[obp++]=(char)0x12;
797 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
798 OpBuffer[obp++]=(char)0x25;
799 *((long *)(OpBuffer+obp))=i3;
800 pobj_DataTableSchedule->add();
801 obp+=sizeof(long);
802 }
803 if(i2==DEF_SINGLE){
804 memcpy(&dbl,&i64data,sizeof(_int64));
805
806 float flt;
807 int i32data;
808 flt=(float)dbl;
809 memcpy(&i32data,&flt,sizeof(long));
810
811 i3 = dataTable.Add( i32data );
812
813 //movss xmm_reg,dword ptr[data table offset]
814 OpBuffer[obp++]=(char)0xF3;
815 OpBuffer[obp++]=(char)0x0F;
816 OpBuffer[obp++]=(char)0x10;
817 OpBuffer[obp++]=(char)(0x04 | REGISTER_OPERAND(XmmReg)<<3);
818 OpBuffer[obp++]=(char)0x25;
819 *((long *)(OpBuffer+obp))=i3;
820 pobj_DataTableSchedule->add();
821 obp+=sizeof(long);
822 }
823 }
824 else{
825 if(!Is64Type(i2)){
826 //整数（符号有り/無し）
827
828 i3=(long)i64data;
829
830 if(GetTypeSize(i2,-1)==sizeof(char)) i3=i3&0x000000FF;
831 if(GetTypeSize(i2,-1)==sizeof(short)) i3=i3&0x0000FFFF;
832
833 i64data=(_int64)i3;
834 }
835
836 UseReg=pobj_reg->LockReg();
837
838 //mov reg,i64data
839 op_mov64_ToReg(UseReg,i64data);
840 }
841
842 type[0]=i2;
843 index_stack[0]=lpClassIndex;
844 }
845 else{
846 //右辺値が数値の定数式ではないとき
847 if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
848 }
849
850 if(plpIndex) *plpIndex=index_stack[0];
851 if(pbUseHeap) *pbUseHeap=bUseHeap[0];
852
853 if(IsRealNumberType(type[0]))
854 *pReg=pobj_reg->UnlockXmmReg();
855 else
856 *pReg=pobj_reg->UnlockReg();
857
858
859 if(bInitRegSwitch){
860 //整合性をチェック（バグ回避）
861 pobj_reg->bug_check();
862
863 //作業レジスタを解放
864 delete pobj_reg;
865 pobj_reg=0;
866 }
867
868 int RetType;
869 RetType=type[0];
870 goto finish;
871
872
873
874 //////////////////
875 // エラー処理
876 //////////////////
877
878error:
879
880 *pobj_reg=objReg_Backup;
881
882 if(bInitRegSwitch){
883 //作業レジスタを解放
884 delete pobj_reg;
885 pobj_reg=0;
886 }
887
888 RetType=-1;
889 goto finish;
890
891
892
893
894finish:
895
896 for(i=0;i<pnum;i++){
897 if(values[i]) HeapDefaultFree(values[i]);
898 }
899
900 //再配置スケジュールバックアップ情報を解放
901 delete pobj_BackReloc;
902
903 return RetType;
904}
Note: See TracBrowser for help on using the repository browser.