source: dev/BasicCompiler64/Compile_Var.cpp@ 59

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

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

/unicodeコマンドオプションに対応。
File size: 33.5 KB
RevLine 
[3]1#include "../BasicCompiler_Common/common.h"
2#include "Opcode.h"
3
4//変数
5VARIABLE *GlobalVar;
6int MaxGlobalVarNum;
7int AllGlobalVarSize;
8int AllInitGlobalVarSize;
9VARIABLE *LocalVar;
10int MaxLocalVarNum;
11int AllLocalVarSize;
12
13
14void SetRelativeOffset(int *pType,LONG_PTR lpIndex,RELATIVE_VAR *pRelativeVar,char *lpPtrOffset){
15 int i2;
16
17
18 /////////////////////////////////////////////
19 // 先頭ポインタをr12に取得してメモリへ退避
20 /////////////////////////////////////////////
21
22 SetReg_WholeVariable(DEF_INT64,pRelativeVar,REG_R11);
23
24 //mov qword ptr[rsp+offset],r11 ※スタックフレームを利用
25 pobj_sf->push(REG_R11);
26
27
28 ////////////////////////////////
29 // 添え字を計算する
30 ////////////////////////////////
31
32 int reg=REG_NON;
33 i2=NumOpe(&reg,lpPtrOffset,0,0,0);
34 if(!IsWholeNumberType(i2)) SetError(46,NULL,cp);
35 ExtendTypeTo64(i2,reg);
36
37 if(reg==REG_R14){
38 //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
39 pobj_sf->pop(REG_R14);
40 }
41
42 if(PTR_LEVEL(*pType)){
43 *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
44 if((*pType)==DEF_OBJECT){
45 //imul reg,objsize
46 op_imul_value(sizeof(_int64),reg,GetSizeOfClassMember((CClass *)lpIndex,NULL,NULL));
47 }
48 else{
49 i2=GetTypeSize(*pType,-1);
50 if(i2>=2){
51 //imul reg,i2
52 op_imul_value(sizeof(_int64),reg,i2);
53 }
54 }
55 }
56 else{
57 //エラー
58 SetError(1,NULL,cp);
59 return;
60 }
61
62
63 //////////////////////////////
64 // 先頭ポインタに添え字を加算
65 //////////////////////////////
66
67 //mov r11,qword ptr[rsp+offset] ※スタックフレームを利用
68 pobj_sf->pop(REG_R11);
69
70 //add r11,reg
71 op_add64_reg(REG_R11,reg);
72}
73BOOL GetArrayOffset(int *SubScripts,char *array,int type,LONG_PTR lpIndex){
74 extern HANDLE hHeap;
75 int i,i2,i3,i4,TypeSize;
76 char temporary[VN_SIZE],*pParm[MAX_PARMS];
77
78 for(i=0,i2=0,i3=0;;i++,i2++){
79 if(array[i]=='('){
80 i4=GetStringInPare(temporary+i2,array+i);
81 i+=i4-1;
82 i2+=i4-1;
83 continue;
84 }
85 if(array[i]=='['){
86 i4=GetStringInBracket(temporary+i2,array+i);
87 i+=i4-1;
88 i2+=i4-1;
89 continue;
90 }
91 if(array[i]==','||array[i]=='\0'){
92 if(SubScripts[i3]==-1){
93 for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
94 return 0;
95 }
96
97 temporary[i2]=0;
98
99 pParm[i3]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
100 lstrcpy(pParm[i3],temporary);
101
102 i3++;
103
104 if(array[i]=='\0'){
105 if(SubScripts[i3]!=-1){
106 for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
107 return 0;
108 }
109 break;
110 }
111
112 i2=-1;
113 continue;
114 }
115 temporary[i2]=array[i];
116 }
117
118 //mov qword ptr[rsp+offset],r11 ※スタックフレームを利用
119 pobj_sf->push(REG_R11);
120
121 //xor r12,r12
122 op_zero_reg(REG_R12);
123
124 for(i=i3-1;i>=0;i--){
125 //mov qword ptr[rsp+offset],r12 ※スタックフレームを利用
126 pobj_sf->push(REG_R12);
127
128 int reg=REG_NON;
129 TYPEINFO TypeInfo;
130 BOOL bUseHeap;
131 TypeInfo.type=NumOpe(&reg,pParm[i],DEF_LONG,-1,&TypeInfo.u.lpIndex,&bUseHeap);
132 if(TypeInfo.type==DEF_OBJECT){
133 //キャスト演算子のオーバーロードに対応する
134 CallCastOperatorProc(reg,
135 TypeInfo.type,TypeInfo.u.lpIndex,
136 bUseHeap,DEF_LONG,-1);
137 TypeInfo.type=DEF_LONG;
138 }
139
140 if(!IsWholeNumberType(TypeInfo.type)) SetError(46,NULL,cp);
141 ExtendTypeTo64(TypeInfo.type,reg);
142
143 if(reg==REG_R14){
144 //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
145 pobj_sf->pop(REG_R14);
146 }
147
148 //mov r12,qword ptr[rsp+offset] ※スタックフレームを利用
149 pobj_sf->pop(REG_R12);
150
151 for(i2=i+1,i4=1;i2<i3;i2++) i4*=SubScripts[i2]+1;
152
153 //imul reg,i4
154 op_imul_value(sizeof(_int64),reg,i4);
155
156 //add r12,reg
157 op_add64_reg(REG_R12,reg);
158
159 HeapDefaultFree(pParm[i]);
160 }
161
162 TypeSize=GetTypeSize(type,lpIndex);
163
164 //imul r12,TypeSize
165 OpBuffer[obp++]=(char)0x4D;
166 OpBuffer[obp++]=(char)0x69;
167 OpBuffer[obp++]=(char)0xE4;
168 *((long *)(OpBuffer+obp))=TypeSize;
169 obp+=sizeof(long);
170
171 //mov r11,qword ptr[rsp+offset] ※スタックフレームを利用
172 pobj_sf->pop(REG_R11);
173
174 //add r11,r12
175 OpBuffer[obp++]=(char)0x4D;
176 OpBuffer[obp++]=(char)0x03;
177 OpBuffer[obp++]=(char)0xDC;
178
179 return 1;
180}
[17]181BOOL GetMemberOffset(bool isErrorEnabled, bool isWriteAccess, CClass *pobj_c, char *member, int *pType, RELATIVE_VAR *pRelativeVar, LONG_PTR *plpNestIndex, BOOL bPrivateAccess){
[3]182 int i,offset;
183
184
185 //////////////////////////////////////
186 // クラス、配列の構成要素を解析する
187 //////////////////////////////////////
188
189 char VarName[VN_SIZE]; //変数名
190 char array[VN_SIZE]; //第1次配列
191 char lpPtrOffset[VN_SIZE]; //第2次配列
192 char NestMember[VN_SIZE]; //入れ子メンバ
193 int RefType; //"."参照のときは0、"->"参照のときは1
194 lstrcpy(VarName,member);
195 if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;
196
197
198 ////////////////////////////
199 // メンバオフセットを取得
200 ////////////////////////////
201
202 offset=GetSizeOfClassMember(pobj_c,VarName,&i);
203 if(i==pobj_c->iMemberNum){
[17]204 if(isErrorEnabled) SetError(103,VarName,cp);
[3]205 return 0;
206 }
207
[40]208 CMember *pMember=pobj_c->ppobj_Member[i];
[3]209
[40]210
[3]211 //アクセシビリティをチェック
212 if(pobj_c==pobj_CompilingClass){
213 //同一クラスオブジェクトの場合はプライベートアクセスを容認する
[40]214 if(pMember->dwAccess==ACCESS_NON){
[17]215 if(isErrorEnabled) SetError(107,VarName,cp);
[3]216 return 0;
217 }
218 }
219 else{
[40]220 if((bPrivateAccess==0&&pMember->dwAccess==ACCESS_PRIVATE)||
221 pMember->dwAccess==ACCESS_NON){
[17]222 if(isErrorEnabled) SetError(107,VarName,cp);
[3]223 return 0;
224 }
[40]225 else if(bPrivateAccess==0&&pMember->dwAccess==ACCESS_PROTECTED){
[17]226 if(isErrorEnabled) SetError(108,VarName,cp);
[3]227 return 0;
228 }
229 }
230
[17]231 //Const定義の場合は書き込みアクセスを制限する
232 //※コンストラクタをコンパイル中の場合は例外的に許可する
[40]233 if( pMember->IsConst() && //定数メンバである
[17]234 isWriteAccess && //書き込みアクセスを要求されている
235 pobj_c->IsCompilingConstructor() == false //コンストラクタ コンパイル中を除く
236 ){
237 //Const定義の変数に書き込みアクセスをしようとした場合
238 SetError(61,VarName,cp);
239 }
240
[40]241 *pType=pMember->TypeInfo.type;
242 *plpNestIndex=pMember->TypeInfo.u.lpIndex;
[3]243
244 //ポインタ変数の場合
245 if(IsPtrType(*pType)){
[40]246 if(pMember->SubScripts[0]==-1){
[3]247 lstrcpy(lpPtrOffset,array);
248 array[0]=0;
249 }
250 }
251 else{
252 if(lpPtrOffset[0]){
[17]253 if(isErrorEnabled) SetError(16,member,cp);
[3]254 return 0;
255 }
256 }
257
258 if(offset){
259 //add r11,offset
260 OpBuffer[obp++]=(char)0x49;
261 OpBuffer[obp++]=(char)0x81;
262 OpBuffer[obp++]=(char)0xC3;
263 *((long *)(OpBuffer+obp))=offset;
264 obp+=sizeof(long);
265 }
266
267 if(array[0]){
268 //配列オフセット
[40]269 if(!GetArrayOffset(pMember->SubScripts,array,*pType,pMember->TypeInfo.u.lpIndex)){
[17]270 if(isErrorEnabled) SetError(14,member,cp);
[3]271 }
272 }
[40]273 else if(pMember->SubScripts[0]!=-1){
[3]274 *pType|=FLAG_PTR;
275 }
276
277 if(NestMember[0]){
278 //入れ子構造の場合
279
[40]280 if(*pType==DEF_OBJECT && pMember->IsRef() == false){
[3]281 if(RefType!=DEF_OBJECT){
[17]282 if(isErrorEnabled) SetError(104,member,cp);
[3]283 return 0;
284 }
285 }
[40]286 else if(*pType==DEF_PTR_OBJECT || ( *pType==DEF_OBJECT && pMember->IsRef() )){
[3]287 //構造体ポインタ型メンバ変数
288
289 if(lpPtrOffset[0]){
290 //pObj[n].member
[40]291 if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_OBJECT){
[17]292 if(isErrorEnabled) SetError(104,member,cp);
[3]293 return 0;
294 }
295
296 //直接参照に切り替え
297 SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
298 pRelativeVar->dwKind=VAR_DIRECTMEM;
299
300 lpPtrOffset[0]=0;
301 }
302 else{
303 //pObj->member
[40]304 if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_PTR_OBJECT){
[17]305 if(isErrorEnabled) SetError(104,member,cp);
[3]306 return 0;
307 }
308
309 if(pRelativeVar->dwKind==VAR_DIRECTMEM){
310 //mov r11,qword ptr[r11]
311 op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
312 }
313 else{
314 //直接参照に切り替え
315 SetVarPtrToReg(REG_R12,pRelativeVar);
316 pRelativeVar->dwKind=VAR_DIRECTMEM;
317
318 //mov r11,qword ptr[r12]
319 op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
320 }
321 }
322 }
323 else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
324 //構造体ポインタのポインタ型メンバ変数
325
326 if(lpPtrOffset[0]){
327 //ppObj[n]->member
328 if(RefType!=DEF_PTR_OBJECT){
[17]329 if(isErrorEnabled) SetError(104,member,cp);
[3]330 return 0;
331 }
332
333 //直接参照に切り替え
334 SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
335 pRelativeVar->dwKind=VAR_DIRECTMEM;
336
337 lpPtrOffset[0]=0;
338
339 //mov r11,qword ptr[r11]
340 op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
341 }
342 else{
[17]343 if(isErrorEnabled) SetError(104,member,cp);
[3]344 return 0;
345 }
346 }
347
[17]348 if(!GetMemberOffset(
349 isErrorEnabled,
350 isWriteAccess,
[40]351 pMember->TypeInfo.u.pobj_Class,
[3]352 NestMember,
353 pType,
354 pRelativeVar,
355 plpNestIndex,
356 0)) return 0;
357 }
358
359 if(lpPtrOffset[0]){
360 SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
361 pRelativeVar->dwKind=VAR_DIRECTMEM;
362 }
363
364 return 1;
365}
366void GetWithName(char *buffer){
367 extern WITHINFO WithInfo;
368 int i;
369
370 buffer[0]=0;
371 for(i=0;i<WithInfo.num;i++)
372 lstrcat(buffer,WithInfo.ppName[i]);
373}
374
375int LocalVar_ThisPtrOffset;
376void SetThisPtrToReg(int reg){
377 //自身のオブジェクトのThisポインタをregにコピー
378
379 extern VARIABLE *LocalVar;
380 RELATIVE_VAR RelativeVar;
381 RelativeVar.dwKind=VAR_LOCAL;
382 RelativeVar.bOffsetOffset=0;
383 RelativeVar.offset=-LocalVar_ThisPtrOffset;
384
385 SetReg_WholeVariable(DEF_PTR_VOID,&RelativeVar,reg);
386}
[40]387BOOL GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
[3]388 extern BOOL bCompilingGlobal;
389 int i,RefType;
[49]390 LONG_PTR lpIndex;
[3]391 char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
392
393 if(NameBuffer[0]=='.'){
394 GetWithName(variable);
395 lstrcat(variable,NameBuffer);
396 }
397 else lstrcpy(variable,NameBuffer);
398
[49]399 if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
400 // 戻り値オブジェクトのメンバを直接参照しているとき
401 //例: func().member
402
403 void *pInfo;
404 int idProc=GetProc(VarName,&pInfo);
405
406 if(idProc){
407 pRelativeVar->dwKind=VAR_DIRECTMEM;
408
409 //////////////////////////////////////////////////////
410 ///// レジスタ資源のバックアップ
411 { BACKUP_REGISTER_RESOURCE
412 //////////////////////////////////////////////////////
413
414 ////////////////
415 // 呼び出し
416 ////////////////
417
418 *pType=CallProc(idProc,pInfo,VarName,array,&lpIndex);
419
420 //戻り値をr11にコピー
421 op_mov_RR( REG_R11, REG_RAX );
422
423 /////////////////////////////////////////////
424 ////// レジスタ資源を復元
425 RESTORE_REGISTER_RESOURCE
426 }////////////////////////////////////////////
427
428 LONG_PTR lp2;
429 if(!GetMemberOffset(
430 isErrorEnabled,
431 isWriteAccess,
432 (CClass *)lpIndex,
433 member,pType,pRelativeVar,&lp2,0)) return 0;
434 if(plpIndex) *plpIndex=lp2;
435
436 return 1;
437 }
438 }
439
440
441
[3]442 lstrcpy(VarName,variable);
443 GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
444
445 int *pSubScripts;
[11]446 bool bConst = false;
[3]447
448
449 if(bCompilingGlobal==0){
450 //////////////////
451 // ローカル変数
452 //////////////////
453
454 for(i=MaxLocalVarNum-1;i>=0;i--){ //レキシカルスコープを考慮してバックサーチ
[34]455 if( LocalVar[i].bLiving //現在のスコープで有効なもの
456 && LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel() //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
457 ){
458 if(lstrcmp(VarName,LocalVar[i].name)==0) break;
[3]459 }
460 }
461 if(i>=0){
462 //ポインタ変数の場合
463 if(IsPtrType(LocalVar[i].type)){
464 if(LocalVar[i].SubScripts[0]==-1){
465 lstrcpy(lpPtrOffset,array);
466 array[0]=0;
467 }
468 }
469 else{
470 if(lpPtrOffset[0]){
471 SetError(16,variable,cp);
472 pRelativeVar->dwKind=NON_VAR;
473 return 0;
474 }
475 }
476
477 pRelativeVar->offset=-LocalVar[i].offset;
478 pRelativeVar->bOffsetOffset=0;
[40]479 if(LocalVar[i].fRef){
480 // 参照型
481 pRelativeVar->dwKind = VAR_REFLOCAL;
482 }
[3]483 else pRelativeVar->dwKind=VAR_LOCAL;
484 *pType=LocalVar[i].type;
485 lpIndex=LocalVar[i].u.index;
486 if(plpIndex) *plpIndex=lpIndex;
487 pSubScripts=LocalVar[i].SubScripts;
[11]488 bConst = LocalVar[i].bConst;
[3]489
490 goto ok;
491 }
492 }
493
494
495 if(pobj_CompilingClass){
496 //////////////////////
497 // クラスメンバの参照
498 //////////////////////
499
500 if(lstrcmpi(variable,"This")==0){
501 //自身のオブジェクトのThisポインタをr11にコピー
502 SetThisPtrToReg(REG_R11);
503
504 *pType=DEF_OBJECT;
505 pRelativeVar->dwKind=VAR_DIRECTMEM;
506
507 if(plpIndex) *plpIndex=(LONG_PTR)pobj_CompilingClass;
508 return 1;
509 }
510
511 if(memicmp(variable,"This.",5)==0){
512 //Thisオブジェクトのメンバを参照するとき
513 SlideString(variable+5,-5);
514 lstrcpy(VarName,variable);
515 }
516 else{
517 //クラス内メンバを参照するとき（通常）
518
519 for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
520 if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
521 }
522 if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
523 }
524
[18]525 //Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
526 //（コンストラクタ、デストラクタ内を除く）
527 CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
528 if( isWriteAccess &&
529 pMethod->isConst &&
530 pobj_CompilingClass->IsCompilingConstructor() == false &&
531 pobj_CompilingClass->IsCompilingDestructor() == false
532 ){
533 SetError(131, NULL, cp );
534 }
535
[3]536 //自身のオブジェクトのThisポインタをr11にコピー
537 SetThisPtrToReg(REG_R11);
538
539 pRelativeVar->dwKind=VAR_DIRECTMEM;
[17]540 if(!GetMemberOffset(
541 isErrorEnabled,
542 isWriteAccess,
543 pobj_CompilingClass,
544 variable,
545 pType,
546 pRelativeVar,
547 &lpIndex,1)) return 0;
[3]548 if(plpIndex) *plpIndex=lpIndex;
549 return 1;
550 }
551
552NonClassMember:
553
554 //////////////////////////
555 // 静的ローカル変数
556 // ※"Static.Object.Method.Variable"
557 //////////////////////////
558
559 char temporary[VN_SIZE];
560 extern SUBINFO *pCompilingSubInfo;
561 if(pCompilingSubInfo){
562 GetNowStaticVarFullName(VarName,temporary);
563
564 for(i=0;i<MaxGlobalVarNum;i++){
565 if(lstrcmp(temporary,GlobalVar[i].name)==0) break;
566 }
567 if(i!=MaxGlobalVarNum){
568 goto GlobalOk;
569 }
570 }
571
572
573 //////////////////////////
574 // クラスの静的メンバ
575 //////////////////////////
576
577 if(member[0]){
578 lstrcpy(temporary,member);
579
[27]580 char tempMember[VN_SIZE];
581 char tempArray[VN_SIZE];
582 GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);
583
[3]584 char temp2[VN_SIZE];
585 sprintf(temp2,"%s.%s",VarName,temporary);
586 for(i=0;i<MaxGlobalVarNum;i++){
587 if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
588 }
589
590 if(i!=MaxGlobalVarNum){
[27]591 lstrcpy(member,tempMember);
592 lstrcpy(array,tempArray);
[3]593 goto GlobalOk;
594 }
595 }
596
597 if(pobj_CompilingClass){
598 //自身のクラスから静的メンバを参照する場合
599 char temp2[VN_SIZE];
600 sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
601 for(i=0;i<MaxGlobalVarNum;i++){
602 if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
603 }
604
605 if(i!=MaxGlobalVarNum){
606 goto GlobalOk;
607 }
608 }
609
[27]610 /////////////////////
611 // グローバル変数
612 /////////////////////
613
614 for(i=MaxGlobalVarNum-1;i>=0;i--){ //レキシカルスコープを考慮してバックサーチ
[34]615 if( GlobalVar[i].bLiving //現在のスコープで有効なもの
616 && GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel() //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
617 ){
618 if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
[27]619 }
620 }
621 if(i>=0){
622 goto GlobalOk;
623 }
624
[17]625 if(isErrorEnabled) SetError(3,variable,cp);
[3]626 pRelativeVar->dwKind=NON_VAR;
627 return 0;
628
629
630
631GlobalOk:
632 //ポインタ変数の場合
633 if(IsPtrType(GlobalVar[i].type)){
634 if(GlobalVar[i].SubScripts[0]==-1){
635 lstrcpy(lpPtrOffset,array);
636 array[0]=0;
637 }
638 }
639 else{
640 if(lpPtrOffset[0]){
641 SetError(16,variable,cp);
642 pRelativeVar->dwKind=NON_VAR;
643 return 0;
644 }
645 }
646
647 pRelativeVar->offset=GlobalVar[i].offset;
648 pRelativeVar->bOffsetOffset=0;
649 pRelativeVar->dwKind=VAR_GLOBAL;
650 *pType=GlobalVar[i].type;
651 lpIndex=GlobalVar[i].u.index;
652 if(plpIndex) *plpIndex=lpIndex;
653 pSubScripts=GlobalVar[i].SubScripts;
[11]654 bConst = GlobalVar[i].bConst;
[3]655
656
657
658ok:
659
[18]660 if( bConst && isWriteAccess ){
[11]661 //Const定義の変数に書き込みアクセスをしようとした場合
[18]662 if( *pType == DEF_OBJECT ){
663 //オブジェクト定数
664 SetError(130, VarName, cp );
665 }
666 else{
667 //一般のConst変数
668 SetError(61,VarName,cp);
669 }
[11]670 }
[3]671
672 if(array[0]==0&&pSubScripts[0]!=-1){
673 //配列の先頭ポインタを示す場合
674 *pType|=FLAG_PTR;
675 if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
676 return 1;
677 }
678
[49]679 if( array[0] || member[0] ){
[3]680 //xor r11,r11（r11を0に初期化する）
681 //※r11は変数ベースアドレスからの相対オフセットを示す
682 op_zero_reg(REG_R11);
683
684 pRelativeVar->bOffsetOffset=1;
685 }
686 if(array[0]){
687 if(!GetArrayOffset(pSubScripts,array,*pType,lpIndex)){
688 SetError(14,variable,cp);
689 pRelativeVar->dwKind=NON_VAR;
690 return 0;
691 }
692 }
693 if(member[0]){
694 if(*pType==DEF_OBJECT){
695 //実態オブジェクトのメンバを参照（obj.member）
696 if(RefType!=DEF_OBJECT){
697 SetError(104,VarName,cp);
698 pRelativeVar->dwKind=NON_VAR;
699 return 0;
700 }
701 }
702 else if(*pType==DEF_PTR_OBJECT){
703 //ポインタオブジェクトが示すメンバを参照
704 if(lpPtrOffset[0]){
705 //pObj[n].member
706 if(RefType!=DEF_OBJECT){
707 SetError(104,VarName,cp);
708 pRelativeVar->dwKind=NON_VAR;
709 return 0;
710 }
711 SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
712 pRelativeVar->dwKind=VAR_DIRECTMEM;
713 }
714 else{
715 //pObj->member
716 if(RefType!=DEF_PTR_OBJECT){
717 SetError(104,VarName,cp);
718 pRelativeVar->dwKind=NON_VAR;
719 return 0;
720 }
721
722 SetVarPtrToReg(REG_R12,pRelativeVar);
723 pRelativeVar->dwKind=VAR_DIRECTMEM;
724
725 //mov r11,qword ptr[r12]
726 op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
727 }
728 }
729 else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
730 //ポインタオブジェクトが示すメンバを参照
731 if(lpPtrOffset[0]){
732 //ppObj[n]->member
733 if(RefType!=DEF_PTR_OBJECT){
734 SetError(104,VarName,cp);
735 pRelativeVar->dwKind=NON_VAR;
736 return 0;
737 }
738
739 SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
740 pRelativeVar->dwKind=VAR_DIRECTMEM;
741
742
743 SetVarPtrToReg(REG_R12,pRelativeVar);
744
745 //mov r11,qword ptr[r12]
746 op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
747 }
748 else{
749 SetError(104,VarName,cp);
750 pRelativeVar->dwKind=NON_VAR;
751 return 0;
752 }
753 }
754 else{
755 SetError(102,VarName,cp);
756 pRelativeVar->dwKind=NON_VAR;
757 return 0;
758 }
[17]759
760 LONG_PTR lp2;
761 if(!GetMemberOffset(
762 isErrorEnabled,
763 isWriteAccess,
764 (CClass *)lpIndex,
765 member,pType,pRelativeVar,&lp2,0)) return 0;
766 if(plpIndex) *plpIndex=lp2;
767
[3]768 return 1;
769 }
770
771 if(lpPtrOffset[0]){
772 SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
773 pRelativeVar->dwKind=VAR_DIRECTMEM;
774 }
775
776 return 1;
777}
778
779BOOL SetInitGlobalData(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
780 extern BYTE *initGlobalBuf;
781 int i,i2,i3,TypeSize;
782 char temporary[VN_SIZE];
783
784 if(InitBuf[0]=='['){
785 SlideString(InitBuf+1,-1);
786 InitBuf[lstrlen(InitBuf)-1]=0;
787
788 TypeSize=GetTypeSize(type,lpIndex);
789
790 if(SubScripts[0]!=-1){
791 TypeSize*=JumpSubScripts(SubScripts+1);
792 i=0;
793 i2=0;
794 while(1){
795 if(SubScripts[0]<i2){
796 SetError(41,0,cp);
797 return 0;
798 }
799 i=GetOneParameter(InitBuf,i,temporary);
800 if(!SetInitGlobalData(
801 offset+i2*TypeSize,
802 type,
803 lpIndex,
804 SubScripts+1,
805 temporary)) return 0;
806 i2++;
807 if(InitBuf[i]=='\0') break;
808 }
809 return -1;
810 }
811
812 if(type==DEF_OBJECT){
813 CClass *pobj_c;
814 pobj_c=(CClass *)lpIndex;
815
816 for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
817 i=GetOneParameter(InitBuf,i,temporary);
818
819 i3=GetSizeOfClassMember(pobj_c,pobj_c->ppobj_Member[i2]->name,NULL);
820
821 if(!SetInitGlobalData(offset+i3,
822 pobj_c->ppobj_Member[i2]->TypeInfo.type,
823 pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
824 pobj_c->ppobj_Member[i2]->SubScripts,
825 temporary)) return 0;
826
827 if(InitBuf[i]=='\0') break;
828 }
829 if(i2+1!=pobj_c->iMemberNum){
830 SetError(41,0,cp);
831 return 0;
832 }
833 return 1;
834 }
835
836 SetError(41,0,cp);
837 return 0;
838 }
839
[20]840
841 ///////////////////////////////////////
842 // 単発式（[]で囲まれていない）
843 ///////////////////////////////////////
844
845 if( type == DEF_OBJECT){
846 //オブジェクトの場合はありえない
847 SetError(300,NULL,cp);
848 return 0;
849 }
850
[3]851 if(SubScripts[0]!=-1){
852 SetError(41,0,cp);
853 return 0;
854 }
855
856 double dbl;
857 _int64 i64data;
858 int CalcType;
859 LONG_PTR lpCalcIndex;
860
[9]861 CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
862 if(!CalcType){
863 //動的データだった場合
864 return 0;
865 }
[3]866 if(IsRealNumberType(CalcType)){
867 memcpy(&dbl,&i64data,sizeof(double));
868 i64data=(_int64)dbl;
869 }
870 else dbl=(double)i64data;
871
872 //型チェック
873 CheckDifferentType(
874 type,
875 lpIndex,
876 CalcType,
877 lpCalcIndex,
878 0,0);
879
880 if(type==DEF_DOUBLE)
881 *(double *)(initGlobalBuf+offset)=(double)dbl;
882 else if(type==DEF_SINGLE)
883 *(float *)(initGlobalBuf+offset)=(float)dbl;
884 else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
885 if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
886 //文字列定数のとき
887
888 char *temp;
889 temp=(char *)i64data;
[56]890 i2=dataTable.AddString( temp );
[3]891 HeapDefaultFree(temp);
892
893 //mov rax,DataPos
894 op_mov_RV(sizeof(_int64),REG_RAX,i2);
895 obp-=sizeof(long);
896 pobj_DataTableSchedule->add();
897 obp+=sizeof(long);
898
899 //mov qword ptr[offset],rax
900 op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32);
901 obp-=sizeof(long);
902 pobj_GlobalVarSchedule->add();
903 obp+=sizeof(long);
904 }
905 else{
906 *(_int64 *)(initGlobalBuf+offset)=i64data;
907 }
908 }
909 else if(type==DEF_LONG||type==DEF_DWORD)
910 *(DWORD *)(initGlobalBuf+offset)=(DWORD)i64data;
[55]911 else if(type==DEF_INTEGER||type==DEF_WORD || (isUnicode&&type==DEF_CHAR))
[3]912 *(WORD *)(initGlobalBuf+offset)=(WORD)i64data;
[55]913 else if(type==DEF_SBYTE||type==DEF_BYTE||type==DEF_BOOLEAN || (isUnicode==false&&type==DEF_CHAR))
[3]914 *(BYTE *)(initGlobalBuf+offset)=(BYTE)i64data;
915
916 return 1;
917}
918BOOL InitLocalVar(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
919 int i,i2,i3,TypeSize;
920 char temporary[VN_SIZE];
921
922 if(InitBuf[0]=='['){
923 SlideString(InitBuf+1,-1);
924 InitBuf[lstrlen(InitBuf)-1]=0;
925
926 TypeSize=GetTypeSize(type,lpIndex);
927
928 if(SubScripts[0]!=-1){
929 TypeSize*=JumpSubScripts(SubScripts+1);
930 i=0;
931 i2=0;
932 while(1){
933 if(SubScripts[0]<i2){
934 SetError(41,0,cp);
935 return 0;
936 }
937 i=GetOneParameter(InitBuf,i,temporary);
938 if(!InitLocalVar(
939 offset+i2*TypeSize,
940 type,
941 lpIndex,
942 SubScripts+1,
943 temporary)) return 0;
944 i2++;
945 if(InitBuf[i]=='\0') break;
946 }
947 return -1;
948 }
949
950 if(type==DEF_OBJECT){
951 CClass *pobj_c;
952 pobj_c=(CClass *)lpIndex;
953
954 for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
955 i=GetOneParameter(InitBuf,i,temporary);
956
957 i3=GetSizeOfClassMember(pobj_c,pobj_c->ppobj_Member[i2]->name,NULL);
958
959 if(!InitLocalVar(offset+i3,
960 pobj_c->ppobj_Member[i2]->TypeInfo.type,
961 pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
962 pobj_c->ppobj_Member[i2]->SubScripts,
963 temporary)) return 0;
964
965 if(InitBuf[i]=='\0') break;
966 }
967 if(i2+1!=pobj_c->iMemberNum){
968 SetError(41,0,cp);
969 return 0;
970 }
971 return 1;
972 }
973
974 SetError(41,0,cp);
975 return 0;
976 }
977
[41]978
979 ///////////////////////////////////////
980 // 単発式（[]で囲まれていない）
981 ///////////////////////////////////////
982
[3]983 if(SubScripts[0]!=-1){
984 SetError(41,0,cp);
985 return 0;
986 }
987
988 double dbl;
989 _int64 i64data;
990 int CalcType;
991 LONG_PTR lpCalcIndex;
[9]992 CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
993 if(!CalcType){
994 //動的データだった場合
995 return 0;
996 }
[3]997 if(IsRealNumberType(CalcType)){
998 memcpy(&dbl,&i64data,sizeof(double));
999 i64data=(_int64)dbl;
1000 }
1001 else dbl=(double)i64data;
1002
1003 //型チェック
1004 CheckDifferentType(
1005 type,
1006 lpIndex,
1007 CalcType,
1008 lpCalcIndex,
1009 0,0);
1010
1011 if(type==DEF_DOUBLE){
1012 memcpy(&i64data,&dbl,sizeof(double));
1013
1014 //mov rax,i64data
1015 op_mov64_ToReg(REG_RAX,i64data);
1016
1017 //mov qword ptr[rsp+offset],rax
1018 op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
1019 obp-=sizeof(long);
1020 AddLocalVarAddrSchedule();
1021 obp+=sizeof(long);
1022 }
1023 else if(type==DEF_SINGLE){
1024 float flt;
1025 flt=(float)dbl;
1026
1027 //mov dword ptr[rsp+offset],value
1028 op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,*(int *)&flt);
1029 obp-=sizeof(long)+sizeof(long);
1030 AddLocalVarAddrSchedule();
1031 obp+=sizeof(long)+sizeof(long);
1032 }
1033 else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
1034 if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
1035 //文字列定数のとき
1036
1037 char *temp;
1038 temp=(char *)i64data;
[56]1039 i2=dataTable.AddString( temp );
[3]1040 HeapDefaultFree(temp);
1041
1042 //mov rax,i2
1043 op_mov_RV(sizeof(_int64),REG_RAX,i2);
1044 obp-=sizeof(long);
1045 pobj_DataTableSchedule->add();
1046 obp+=sizeof(long);
1047
1048 //mov qword ptr[rsp+offset],rax
1049 op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
1050 obp-=sizeof(long);
1051 AddLocalVarAddrSchedule();
1052 obp+=sizeof(long);
1053 }
1054 else{
1055 if(i64data&0xFFFFFFFF00000000){
1056 //mov rax,i64data
1057 op_mov64_ToReg(REG_RAX,i64data);
1058
1059 //mov qword ptr[rsp+offset],rax
1060 op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
1061 obp-=sizeof(long);
1062 AddLocalVarAddrSchedule();
1063 obp+=sizeof(long);
1064 }
1065 else{
1066 //mov qword ptr[rsp+offset],value
1067 op_mov_MV(sizeof(_int64),REG_RSP,offset,USE_OFFSET,(int)i64data);
1068 obp-=sizeof(long)+sizeof(long);
1069 AddLocalVarAddrSchedule();
1070 obp+=sizeof(long)+sizeof(long);
1071 }
1072 }
1073 }
1074 else if(type==DEF_LONG||type==DEF_DWORD){
1075 //mov dword ptr[rsp+offset],value
1076 op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int)i64data);
1077 obp-=sizeof(long)+sizeof(long);
1078 AddLocalVarAddrSchedule();
1079 obp+=sizeof(long)+sizeof(long);
1080 }
[55]1081 else if(type==DEF_INTEGER||type==DEF_WORD || (isUnicode&&type==DEF_CHAR)){
[3]1082 //mov word ptr[rsp+offset],value
1083 op_mov_MV(sizeof(short),REG_RSP,offset,USE_OFFSET,(int)i64data);
1084 obp-=sizeof(long)+sizeof(short);
1085 AddLocalVarAddrSchedule();
1086 obp+=sizeof(long)+sizeof(short);
1087 }
[55]1088 else if(type==DEF_SBYTE||type==DEF_BYTE||type==DEF_BOOLEAN || (isUnicode==false&&type==DEF_CHAR)){
[3]1089 //mov byte ptr[rsp+offset],value
1090 op_mov_MV(sizeof(char),REG_RSP,offset,USE_OFFSET,(int)i64data);
1091 obp-=sizeof(long)+sizeof(char);
1092 AddLocalVarAddrSchedule();
1093 obp+=sizeof(long)+sizeof(char);
1094 }
1095 return 1;
1096}
1097
1098
[40]1099void dim(char *Parameter,DWORD dwFlags){
[3]1100 extern BOOL bCompilingGlobal;
1101 extern HANDLE hHeap;
1102 int i2,i3,VarSize;
[9]1103 char VarName[VN_SIZE];
[3]1104
[40]1105 //参照型かどうか
1106 bool isRef = false;
[9]1107
[40]1108 i2 = 0;
1109
1110 if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
1111 //参照型
1112 isRef = true;
1113 Parameter += 2;
1114 }
1115
1116 if(dwFlags & DIMFLAG_CONST){
1117
[9]1118 //////////////////////////////////
1119 // 定数変数の場合を考慮
1120 //////////////////////////////////
[40]1121 for(;;i2++){
[9]1122 if(Parameter[i2] == '=' ||
1123 Parameter[i2] == 1 && Parameter[i2] == ESC_AS ||
1124 Parameter[i2] =='('){
1125 VarName[i2] = 0;
1126 break;
1127 }
1128 VarName[i2] = Parameter[i2];
1129 }
1130
1131 //定数と２重定義されていないる場合は抜け出す
1132 if(CDBConst::obj.GetType(VarName)){
1133 return;
1134 }
1135
1136 //定数マクロとして定義されている場合は抜け出す
1137 if(GetConstHash(VarName)){
1138 return;
1139 }
1140 }
1141
1142
[3]1143 //構文を解析
1144 int SubScripts[MAX_ARRAYDIM];
1145 TYPEINFO TypeInfo;
1146 char InitBuf[8192];
1147 char ConstractParameter[VN_SIZE];
[40]1148 if(!GetDimentionFormat(Parameter, isRef , VarName,SubScripts,&TypeInfo,InitBuf,ConstractParameter))
[3]1149 return;
1150
1151
1152 //定数と２重定義されていないかを調べる
[9]1153 if(CDBConst::obj.GetType(VarName)){
1154 SetError(15,VarName,cp);
1155 return;
1156 }
1157
1158 //定数マクロとして定義されている場合
[3]1159 if(GetConstHash(VarName)){
1160 SetError(15,VarName,cp);
1161 return;
1162 }
1163
[9]1164
1165 //タイプサイズを取得
1166 int TypeSize;
1167 TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
1168
[40]1169 if(dwFlags&DIMFLAG_STATIC){
[3]1170 if(bCompilingGlobal){
1171 SetError(60,NULL,cp);
1172 return;
1173 }
1174
1175 /////////////////////
1176 // Static変数
1177 // ※"Static.Object.Method.Variable"
1178 /////////////////////
1179
1180 char temporary[VN_SIZE];
1181 GetNowStaticVarFullName(VarName,temporary);
1182
[40]1183 AddGlobalVariable(temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
[3]1184
1185 /*
1186 Note: 静的変数のコンストラクタ呼び出しは
1187 _System_InitStaticLocalVariables関数内で一括して行う
1188 */
1189 }
1190 else{
1191 if(bCompilingGlobal){
1192 /////////////////////////
1193 // グローバル変数
1194 /////////////////////////
1195
[40]1196 AddGlobalVariable(VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
[3]1197 }
1198 else{
1199 /////////////////
1200 // ローカル変数
1201 /////////////////
1202
1203 for(i2=0;i2<MaxLocalVarNum;i2++){
1204 if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
1205 if(lstrcmp(LocalVar[i2].name,VarName)==0){
1206 //２重定義のエラー
1207 SetError(15,VarName,cp);
1208 return;
1209 }
1210 }
1211 }
1212
1213 LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
[40]1214 VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
1215 MaxLocalVarNum++;
[3]1216
[40]1217 if( isRef ){
1218 //参照型
1219 pVar->fRef = REF_VARIABLE;
1220 TypeSize = PTR_SIZE;
1221 }
1222 else pVar->fRef=0;
1223
[3]1224 for(i2=1,i3=0;i3<255;i3++){
1225 //配列要素数
[40]1226 pVar->SubScripts[i3]=SubScripts[i3];
[3]1227
1228 if(SubScripts[i3]==-1) break;
1229 i2*=SubScripts[i3]+1;
1230 }
1231 VarSize=TypeSize*i2;
1232 if(VarSize%8) VarSize+=8-(VarSize%8);
1233
1234 //変数データを追加
[9]1235 lstrcpy(pVar->name,VarName);
[40]1236 if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
[11]1237 else pVar->bConst = false;
[9]1238 if(SubScripts[0]==-1) pVar->bArray=0;
1239 else pVar->bArray=1;
1240 pVar->type=TypeInfo.type;
1241 pVar->u.index=TypeInfo.u.lpIndex;
[3]1242 AllLocalVarSize+=VarSize;
[9]1243 pVar->offset=AllLocalVarSize;
[3]1244
1245 //レキシカルスコープ
[9]1246 pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
1247 pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
1248 pVar->bLiving=TRUE;
[3]1249
1250 if(InitBuf[0]){
[11]1251 //初期代入時のみ、書き込みアクセスを許可する
1252 bool bConstBack = pVar->bConst;
1253 pVar->bConst = false;
1254
[9]1255 int result = InitLocalVar(-pVar->offset,
1256 pVar->type,
1257 pVar->u.index,
1258 pVar->SubScripts,
[3]1259 InitBuf);
[9]1260
1261 if(!result){
1262 //動的な式だった場合は代入演算を行う
[40]1263 if( isRef ){
1264 SetRefVariable( VarName, InitBuf );
1265 }
1266 else{
1267 char temporary[8192];
1268 sprintf(temporary,"%s=%s",VarName,InitBuf);
1269 OpcodeCalc(temporary);
1270 }
[9]1271 }
[11]1272
1273 pVar->bConst = bConstBack;
[3]1274 }
1275 else{
[19]1276 //0初期化
1277
1278 //mov r8, 0
1279 op_zero_reg( REG_R8 );
1280
1281 //mov rdx, VarSize
1282 op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
1283
1284 //mov rcx, rsp
1285 op_mov_RR( REG_RCX, REG_RSP );
1286
1287 //add rcx, offset
1288 op_add64_value( REG_RCX, -pVar->offset );
1289 obp-=sizeof(long);
1290 AddLocalVarAddrSchedule();
1291 obp+=sizeof(long);
1292
1293 //call FillMemory
1294 DECLAREINFO *pdi;
1295 pdi=GetDeclareHash("FillMemory");
1296 op_call( pdi );
[3]1297 }
1298 }
1299
1300 //コンストラクタ呼び出し
[40]1301 if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
[50]1302 CallConstructor(VarName,SubScripts,TypeInfo,ConstractParameter);
[3]1303 }
1304 }
1305
1306 if(TypeInfo.type==DEF_OBJECT){
[28]1307 if(TypeInfo.u.pobj_Class->IsAbstract()){
[3]1308 //抽象クラスだったとき
1309 SetError(125,TypeInfo.u.pobj_Class->name,cp);
1310 }
1311 }
1312}
[40]1313void OpcodeDim(char *Parameter,DWORD dwFlags){
[3]1314 int i,i2,i3,IsStr=0;
1315 char temporary[8192];
1316
1317 for(i=0,i2=0;;i++,i2++){
1318 if(Parameter[i]=='\"') IsStr^=1;
1319 if(Parameter[i]=='('&&IsStr==0){
1320 i3=GetStringInPare(temporary+i2,Parameter+i);
1321 i+=i3-1;
1322 i2+=i3-1;
1323 continue;
1324 }
1325 if(Parameter[i]=='['&&IsStr==0){
1326 i3=GetStringInBracket(temporary+i2,Parameter+i);
1327 i+=i3-1;
1328 i2+=i3-1;
1329 continue;
1330 }
1331 if((Parameter[i]==','&&IsStr==0)||
1332 Parameter[i]=='\0'){
1333 temporary[i2]=0;
1334
[40]1335 dim(temporary,dwFlags);
[3]1336
1337 if(Parameter[i]=='\0') break;
1338 i2=-1;
1339 continue;
1340 }
1341 temporary[i2]=Parameter[i];
1342 }
1343}
1344
1345void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
1346 if(!IsGeneralReg(reg)) SetError(300,NULL,cp);
1347
1348 if(pRelativeVar->dwKind==VAR_GLOBAL){
1349 if(pRelativeVar->bOffsetOffset){
1350 //add r11,offset
1351 OpBuffer[obp++]=(char)0x49;
1352 OpBuffer[obp++]=(char)0x81;
1353 OpBuffer[obp++]=(char)0xC3;
1354 *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
1355 pobj_GlobalVarSchedule->add();
1356 obp+=sizeof(long);
1357
1358 //mov reg,r11
1359 op_mov64_ToReg_FromReg(reg,REG_R11);
1360 }
1361 else{
1362 //mov reg,offset
1363 op_mov64_ToReg(reg,(int)pRelativeVar->offset);
1364 obp-=sizeof(long);
1365 pobj_GlobalVarSchedule->add();
1366 obp+=sizeof(long);
1367 }
1368 }
1369 else if(pRelativeVar->dwKind==VAR_LOCAL){
1370 if(pRelativeVar->bOffsetOffset){
1371 //add r11,offset
1372 OpBuffer[obp++]=(char)0x49;
1373 OpBuffer[obp++]=(char)0x81;
1374 OpBuffer[obp++]=(char)0xC3;
1375 *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
1376 AddLocalVarAddrSchedule();
1377 obp+=sizeof(long);
1378
1379 //add r11,rsp
1380 op_add64_reg(REG_R11,REG_RSP);
1381
1382 //mov reg,r11
1383 op_mov64_ToReg_FromReg(reg,REG_R11);
1384 }
1385 else{
1386 //mov reg,rsp
1387 op_mov64_ToReg_FromReg(reg,REG_RSP);
1388
1389 //add reg,offset
1390 op_add64_value(reg,(int)pRelativeVar->offset);
1391 obp-=sizeof(long);
1392 AddLocalVarAddrSchedule();
1393 obp+=sizeof(long);
1394 }
1395 }
[40]1396 else if( pRelativeVar->dwKind == VAR_REFLOCAL ){
[3]1397 if(pRelativeVar->bOffsetOffset){
1398 //add r11,qword ptr[rsp+offset]
1399 OpBuffer[obp++]=(char)0x4C;
1400 OpBuffer[obp++]=(char)0x03;
1401 OpBuffer[obp++]=(char)0x9C;
1402 OpBuffer[obp++]=(char)0x24;
1403 *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
1404 AddLocalVarAddrSchedule();
1405 obp+=sizeof(long);
1406 }
1407 else{
1408 //mov r11,qword ptr[rsp+offset]
1409 op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
1410 obp-=sizeof(long);
1411 AddLocalVarAddrSchedule();
1412 obp+=sizeof(long);
1413 }
1414
1415 goto directmem;
1416 }
1417 else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
1418directmem:
1419 //mov reg,r11
1420 op_mov64_ToReg_FromReg(reg,REG_R11);
1421 }
1422}
Note: See TracBrowser for help on using the repository browser.