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

Last change on this file since 580 was 580, checked in by dai_9181, 15 years ago

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