source: dev/BasicCompiler_Common/LexicalScoping.cpp@ 72

#include "common.h"
#ifdef _AMD64_
#include "../BasicCompiler64/opcode.h"
#else
#include "../BasicCompiler32/opcode.h"
#endif


CLexicalScopes obj_LexScopes;


CScope::CScope( int level, int addr, SCOPE_TYPE TypeOfStatement ){
    this->level = level;
    this->StartAddress = addr;
    this->TypeOfStatement = TypeOfStatement;

    pBreakSchedule = (DWORD *)malloc( 1 );
    nBreakSchedule = 0;
}
CScope::~CScope(){
    free( pBreakSchedule );
}

int CScope::GetStartAddress(){
    return StartAddress;
}
SCOPE_TYPE CScope::GetTypeOfStatement(){
    return TypeOfStatement;
}

void CScope::Break(){
    //未解放のローカルオブジェクトを解放する
    obj_LexScopes.CallDestructorsOfReturn( level );

    //jmp ...(Next addr)
    OpBuffer[obp++]=(char)0xE9;

    pBreakSchedule=(DWORD *)realloc( pBreakSchedule, ( nBreakSchedule + 1 ) * sizeof(DWORD) );
    pBreakSchedule[nBreakSchedule]=obp;
    nBreakSchedule++;

    obp+=sizeof(long);
}
void CScope::RunScheduleOfBreak(){
    for(int i=0;i<nBreakSchedule;i++){
        *((long *)(OpBuffer+pBreakSchedule[i]))=obp-(pBreakSchedule[i]+sizeof(long));
    }
}


CScope *CLexicalScopes::SearchScope( SCOPE_TYPE TypeOfStatement ){
    for( int i = level; i>=0; i-- ){
        if( ppScopes[i]->GetTypeOfStatement() == TypeOfStatement ){
            return ppScopes[i];
        }
    }
    return NULL;
}

CLexicalScopes::CLexicalScopes(){
    ppScopes = (CScope **)malloc( 1 );
    level=0;
}
CLexicalScopes::~CLexicalScopes(){
    free( ppScopes );
}
void CLexicalScopes::Init(int addr){
    // TODO: エラーチェック

    level = -1;
    Start( addr, SCOPE_TYPE_BASE );
}
void CLexicalScopes::Start( int addr, SCOPE_TYPE TypeOfStatement ){
    level++;
    ppScopes = (CScope **)realloc( ppScopes, ( level + 1 ) * sizeof( CScope * ) );
    ppScopes[level] = new CScope( level, addr, TypeOfStatement );
}
void CLexicalScopes::End(){
    if( level <= 0 ){
        SetError(300,NULL,cp);
        return;
    }

    //デストラクタを呼ぶ
    CallDestructorsOfScopeEnd();

    extern BOOL bCompilingGlobal;
    VARIABLE *pVar;
    int num;
    if(bCompilingGlobal){
        //グローバル領域をコンパイルしているとき
        extern VARIABLE *GlobalVar;
        extern int MaxGlobalVarNum;
        pVar=GlobalVar;
        num=MaxGlobalVarNum;
    }
    else{
        //ローカル領域をコンパイルしているとき
        extern VARIABLE *LocalVar;
        extern int MaxLocalVarNum;
        pVar=LocalVar;
        num=MaxLocalVarNum;
    }

    //使用済みローカル変数の生存チェックを外す
    for(int i=0;i<num;i++){
        if(pVar[i].bLiving&&pVar[i].ScopeLevel==level){
            pVar[i].bLiving=0;
            extern int obp;
            pVar[i].ScopeEndAddress=obp;
        }
    }


    //スコープ抜け出しスケジュール
    ppScopes[level]->RunScheduleOfBreak();


    //スコープレベルを下げる
    delete ppScopes[level];
    level--;
}

void CLexicalScopes::ExitFor(){
    CScope *pScope = SearchScope( SCOPE_TYPE_FOR );
    if( !pScope ){
        SetError(12,"Exit For",cp);
        return;
    }

    pScope->Break();
}
void CLexicalScopes::ExitWhile(){
    CScope *pScope = SearchScope( SCOPE_TYPE_WHILE );
    if( !pScope ){
        SetError(12,"Exit While",cp);
        return;
    }

    pScope->Break();
}
void CLexicalScopes::ExitDo(){
    CScope *pScope = SearchScope( SCOPE_TYPE_DO );
    if( !pScope ){
        SetError(12,"Exit Do",cp);
        return;
    }

    pScope->Break();
}

int CLexicalScopes::GetNowLevel(){
    return level;
}
void CLexicalScopes::SetNowLevel( int level ){
    this->level = level;
}
int CLexicalScopes::GetStartAddress(){
    return ppScopes[level]->GetStartAddress();
}


// スコープ終了時のデストラクタ呼び出し
void CLexicalScopes::CallDestructorsOfScopeEnd(){
    extern BOOL bCompilingGlobal;
    VARIABLE *pVar;
    int num;
    if(bCompilingGlobal){
        //グローバルオブジェクトの解放処理
        extern VARIABLE *GlobalVar;
        extern int MaxGlobalVarNum;
        pVar=GlobalVar;
        num=MaxGlobalVarNum;
    }
    else{
        //ローカルオブジェクトの解放処理
        extern VARIABLE *LocalVar;
        extern int MaxLocalVarNum;
        pVar=LocalVar;
        num=MaxLocalVarNum;
    }


    int i3;
    int indexSystemGC=-1;
    for( i3 = num - 1; i3 >= 0; i3-- ){     //確保したのと逆順序で解放するため、バックサーチにする

        if( bCompilingGlobal && GetNowLevel() == 0 ){
            if(lstrcmp(pVar[i3].name,"_System_GC")==0){
                indexSystemGC=i3;
                continue;
            }
        }

        //同一レベルのレキシカルスコープのみを検知
        if(!pVar[i3].bLiving) continue;
        if( pVar[i3].ScopeLevel != GetNowLevel() ) continue;

        if(pVar[i3].type==DEF_STRUCT&&pVar[i3].fRef&OBJECT_PARAMETER){
            //構造体パラメータを持つとき

            //メモリを解放する

#ifdef _AMD64_
            //x64ビットコード

            //mov rcx,qword ptr[rsp+offset]
            op_mov_RM(sizeof(_int64),REG_RCX,REG_RSP,
                -pVar[i3].offset,
                MOD_BASE_DISP32);
            obp-=sizeof(long);
            AddLocalVarAddrSchedule();
            obp+=sizeof(long);
#else
            //x86コード

            //mov ecx,dword ptr[ebp+offset]
            op_mov_RM(sizeof(long),REG_ECX,REG_EBP,-pVar[i3].offset,MOD_BASE_DISP32);
            obp-=sizeof(long);
            AddLocalVarAddrSchedule();
            obp+=sizeof(long);

            //push ecx
            op_push(REG_ECX);
#endif

            //call free
            extern SUBINFO *pSub_free;
            op_call(pSub_free);


            if(bCompilingGlobal){
                //ここには来ないハズ
                SetError(300,NULL,cp);
            }
        }

        /*
        TODO: 消す
        else if(pVar[i3].type==DEF_OBJECT&&pVar[i3].fRef==0){
            //デストラクタの呼び出し
            CMethod *method = pVar[i3].u.pobj_c->GetDestructorMethod();
            if( method ){
                int ss[MAX_ARRAYDIM];
                memset(ss,0,MAX_ARRAYDIM*sizeof(int));
                if(pVar[i3].SubScripts[0]!=-1){
                    while(1){
                        for(i4=0;;i4++){
                            if(pVar[i3].SubScripts[i4]==-1) break;

                            if(ss[i4]>pVar[i3].SubScripts[i4]){
                                ss[i4]=0;
                                ss[i4+1]++;
                            }
                            else break;
                        }
                        if(pVar[i3].SubScripts[i4]==-1) break;
                        char temporary[VN_SIZE];
                        sprintf(temporary,"%s[%d",pVar[i3].name,ss[0]);
                        for(i4=1;;i4++){
                            if(pVar[i3].SubScripts[i4]==-1) break;

                            sprintf(temporary+lstrlen(temporary),",%d",ss[i4]);
                        }
                        lstrcat(temporary,"]");
                        Opcode_CallProc("",method->psi,0,temporary,DEF_OBJECT);

                        ss[0]++;


                        //ネイティブコードバッファの再確保
                        extern int obp_AllocSize;
                        if(obp_AllocSize<obp+8192){
                            obp_AllocSize+=8192;
                            OpBuffer=(char *)HeapReAlloc(hHeap,0,OpBuffer,obp_AllocSize); //matea
                        }
                    }
                }
                else{
                    Opcode_CallProc("",method->psi,0,pVar[i3].name,DEF_OBJECT);
                }
            }
        }
        */
    }

    if(indexSystemGC!=-1){
        //_System_GCオブジェクトのデストラクタの呼び出し処理
        CMethod *method = pVar[indexSystemGC].u.pobj_c->GetDestructorMethod();
        if( method ){
            Opcode_CallProc("",method->psi,0,pVar[indexSystemGC].name,DEF_OBJECT);
        }
    }
}

// Returnステートメントで発行されるデストラクタを生成
void CLexicalScopes::CallDestructorsOfReturn( int BaseLevel ){
    //現在のスコープレベルを退避
    int backupScopeLevel = GetNowLevel();

    for( int i = GetNowLevel(); i >= BaseLevel; i-- ){
        SetNowLevel( i );

        CallDestructorsOfScopeEnd();
    }

    //現在のスコープレベルを復元
    SetNowLevel( backupScopeLevel );
}