source: dev/trunk/ab5.0/abdev/compiler_x64/Compile_Var.cpp@ 519

Last change on this file since 519 was 514, checked in by dai_9181, 16 years ago

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