source: dev/trunk/ab5.0/abdev/compiler_x86/Compile_Var.cpp@ 628

Last change on this file since 628 was 603, checked in by dai_9181, 16 years ago

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