source: dev/BasicCompiler32/Compile_CallProc.cpp@ 26

#include "../BasicCompiler_Common/common.h"
#include "Opcode.h"

//ローカル変数アドレススケジュール
DWORD *pLocalVarAddrSchedule;
int LocalVarAddrScheduleNum;

void Call_DebugSys_SaveContext(){
    //call _System_GetEip
    extern SUBINFO *pSub_System_GetEip;
    op_call(pSub_System_GetEip);

    //push eax
    op_push(REG_EAX);

    //push ebp
    op_push(REG_EBP);

    //call _DebugSys_SaveContext
    extern SUBINFO *pSub_DebugSys_SaveContext;
    op_call(pSub_DebugSys_SaveContext);
}

void AddLocalVarAddrSchedule(){
    extern HANDLE hHeap;

    //ローカル変数アドレススケジュールに追加する
    pLocalVarAddrSchedule=(DWORD *)HeapReAlloc(hHeap,0,pLocalVarAddrSchedule,(LocalVarAddrScheduleNum+1)*sizeof(DWORD));
    pLocalVarAddrSchedule[LocalVarAddrScheduleNum]=obp;
    LocalVarAddrScheduleNum++;
}
int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
    int ret_type;

    if(idProc==PROC_DEFAULT){
        /////////////////////
        // ユーザー定義関数
        /////////////////////

        SUBINFO *psi;
        psi=(SUBINFO *)pInfo;

        //GetSubHash内でエラー提示が行われた場合
        if(psi==(SUBINFO *)-1) return -1;


        //オブジェクト名を取得
        char ObjectName[VN_SIZE];
        int RefType;
        GetObjectName(name,ObjectName,&RefType);


        ////////////////////////
        // オーバーロードを解決
        ////////////////////////

        SUBINFO **ppsi;
        int num;
        ppsi=GetOverloadSubHash(name,&num);
        if(num){
            //オーバーロードを解決
            psi=OverloadSolutionWithStrParam(name,ppsi,num,Parameter,ObjectName,NULL);
            HeapDefaultFree(ppsi);

            if(!psi) return 0;
        }


        ret_type=Opcode_CallProc(Parameter,psi,plpRetIndex,0,ObjectName,RefType);
    }
    else if(idProc==PROC_DLL){
        /////////////////////////
        // DLL関数
        /////////////////////////
        DECLAREINFO *pdi;
        pdi=(DECLAREINFO *)pInfo;

        ret_type=Opcode_CallDllProc(Parameter,pdi,plpRetIndex);
    }
    else if(idProc==PROC_BUILTIN){
        /////////////////////////
        // 組み込み関数
        /////////////////////////
        int FuncId;
        FuncId=(int)(_int64)pInfo;

        ret_type=Opcode_CallFunc(Parameter,FuncId);
    }
    else if(idProc==PROC_PTR){
        /////////////////
        // 関数ポインタ
        /////////////////

        LONG_PTR lpIndex;
        GetVarType(name,&lpIndex,0);

        extern PROCPTRINFO *pProcPtrInfo;
        ret_type=Opcode_CallProcPtr(name,Parameter,&pProcPtrInfo[lpIndex],plpRetIndex);
    }

    return ret_type;
}

BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
    //プロパティ用のメソッドを呼び出す

    //配列要素を取得
    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
    GetArrayElement(variable,VarName,ArrayElements);

    //オブジェクト名を取得
    char ObjectName[VN_SIZE];
    int RefType;
    GetObjectName(VarName,ObjectName,&RefType);

    //オーバーロード用の関数リストを作成
    SUBINFO **ppsi;
    int num;
    ppsi=GetOverloadSubHash(VarName,&num);
    if(num==0){
        return 0;
    }

    //パラメータを整備
    char *Parameter;
    Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(RightSide)+32);
    lstrcpy(Parameter,ArrayElements);
    if(RightSide){
        if(Parameter[0]&&RightSide[0]) lstrcat(Parameter,",");
        lstrcat(Parameter,RightSide);
    }

    //オーバーロードを解決
    SUBINFO *psi;
    psi=OverloadSolutionWithStrParam(VarName,ppsi,num,Parameter,ObjectName,NULL);
    HeapDefaultFree(ppsi);

    if(psi){
        //呼び出し
        int type;
        LONG_PTR lpIndex;
        type=Opcode_CallProc(Parameter,psi,&lpIndex,0,ObjectName,RefType);

        if(pRetTypeInfo){
            pRetTypeInfo->type=type;
            pRetTypeInfo->u.lpIndex=lpIndex;
        }
    }

    HeapDefaultFree(Parameter);

    return 1;
}


int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex){
    extern HANDLE hHeap;
    int i;


    extern BOOL bDebugCompile;
    extern BOOL bDebugSupportProc;
    if(bDebugCompile&&bDebugSupportProc==0)
        Call_DebugSys_SaveContext();


    ////////////////////////
    // パラメータのセット
    ////////////////////////

    //パラメータオブジェクトを生成
    CParameter *pobj_parameter=0;
    pobj_parameter=new CParameter(Parameter);

    //エラーチェック
    pobj_parameter->ErrorCheck(variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum);

    //一時オブジェクトを生成
    pobj_parameter->NewTempParameters( variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum );

    //レジスタ、スタックフレームにセット
    pobj_parameter->SetParameter(variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum);



    ////////////////////////
    // call
    ////////////////////////
    RELATIVE_VAR RelativeVar;
    LONG_PTR lp;
    GetVarOffsetReadOnly(variable,&i,&RelativeVar,&lp);
    SetVarPtrToEax(&RelativeVar);

    //mov eax,dword ptr[eax]
    OpBuffer[obp++]=(char)0x8B;
    OpBuffer[obp++]=(char)0x00;

    //call eax
    OpBuffer[obp++]=(char)0xFF;
    OpBuffer[obp++]=(char)0xD0;



    //一時オブジェクトを破棄
    pobj_parameter->DeleteTempParameters();

    //パラメータオブジェクトを破棄
    delete pobj_parameter;

    if(plpIndex) *plpIndex=pi->u.ReturnIndex;

    return pi->ReturnType;
}

int Opcode_CallProc(char *Parameter,SUBINFO *psi,LONG_PTR *plpIndex,DWORD dwFlags,char *ObjectName,int RefType){
    int i,i2;

    if(psi->dwType==SUBTYPE_MACRO){
        if(lstrcmpi(psi->name,"Print")==0){
            Opcode_Print(Parameter,0);
            return -1;
        }
        if(lstrcmpi(psi->name,"Input")==0){
            Opcode_Input(Parameter);
            return -1;
        }
        if(lstrcmpi(psi->name,"Write")==0){
            Opcode_Print(Parameter,1);
            return -1;
        }
    }

    psi->bUse=1;

    BOOL bStatic=0;
    CClass *pobj_c = NULL;
    CMethod *pMethod = NULL;
    if(psi->pobj_ParentClass){
        //クラスのメンバ関数を呼び出す場合はアクセスチェックを行う
        if(ObjectName[0]){
            if(lstrcmpi(ObjectName,"Super")==0){
                //クラスメンバ関数内からスーパークラスの呼び出し
                pobj_c=pobj_CompilingClass;
            }
            else{
                pobj_c=pobj_DBClass->check(ObjectName);
                if(pobj_c){
                    //静的メンバ
                    bStatic=1;
                }
                else{
                    //"->"によってオブジェクトを指定する通常のメンバ関数呼び出し
                    GetVarType(ObjectName,(LONG_PTR *)&pobj_c,1);
                }
            }
        }
        else{
            if(dwFlags&PROCFLAG_NEW){
                //New演算子によるコンストラクタ呼び出し
                pobj_c=psi->pobj_ParentClass;
            }
            else{
                //クラスメンバ関数内から同一クラスのメンバ関数の呼び出し
                pobj_c=pobj_CompilingClass;
            }
        }


        /////////////////////////////////
        // メソッド情報を取得
        /////////////////////////////////
        pMethod = pobj_c->GetMethodInfo( psi );
        if( !pMethod ){
            //動的メソッドが取得できなかったときは静的メソッドを当たる
            pMethod = pobj_c->GetStaticMethodInfo( psi );
            if( !pMethod ){
                SetError(300,NULL,cp);
                return -1;
            }

            //静的メンバ
            bStatic=1;
        }


        //////////////////////////////
        // アクセスエラーチェック
        //////////////////////////////
        DWORD dwAccess = pMethod->dwAccess;

        if(ObjectName[0]){
            //外部からの呼び出し
            if(pobj_c==pobj_CompilingClass){
                //同一クラスオブジェクトの場合はプライベートアクセスを容認する
                if(dwAccess==ACCESS_NON){
                    SetError(109,psi->name,cp);
                    return -1;
                }
            }
            else{
                if(dwAccess==ACCESS_PRIVATE||
                    dwAccess==ACCESS_NON){
                    SetError(109,psi->name,cp);
                    return -1;
                }
                if(dwAccess==ACCESS_PROTECTED){
                    SetError(110,psi->name,cp);
                    return -1;
                }
            }
        }
        else{
            //クラス内部からの呼び出し（継承によるACCESS_NONのみをエラーとする）
            if(dwAccess==ACCESS_NON){
                SetError(109,psi->name,cp);
                return -1;
            }
        }
    }



    ///////////////////////////////////////////////////////////////
    // _System_LocalThis、_System_ReturnObjectのダミーをセット
    ///////////////////////////////////////////////////////////////

    char temporary[VN_SIZE]={0};
    if(psi->pobj_ParentClass&&bStatic==0){
        //_System_LocalThis（第一パラメータ）のダミーを作成
        lstrcpy(temporary,"0,");
    }

    if(psi->ReturnType==DEF_OBJECT){
        //_System_ReturnObject（第一または第二パラメータのダミーを作成）
        sprintf(temporary+lstrlen(temporary),"%c%c0,",1,ESC_BYVAL);
    }

    if(Parameter[0]=='\0'&&temporary[0])
        temporary[lstrlen(temporary)-1]=0;
    else lstrcat(temporary,Parameter);



    ////////////////////////
    // パラメータをセット
    ////////////////////////

    //パラメータオブジェクトを生成
    CParameter *pobj_parameter=0;
    pobj_parameter=new CParameter(temporary);

    //エラーチェック
    pobj_parameter->ErrorCheck(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum);

    if(psi->dwType==SUBTYPE_MACRO){
        //マクロ関数の場合は、パラメータ省略を考慮する
        pobj_parameter->MacroParameterSupport(psi->pRealParmInfo);
    }

    //一時オブジェクトを生成
    pobj_parameter->NewTempParameters( psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum );

    //レジスタ、スタックフレームにセット
    int ParmSize;
    ParmSize=pobj_parameter->SetParameter(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum);



    if(psi->ReturnType==DEF_OBJECT){
        //////////////////////////////////////////////////////
        // 戻り値にオブジェクト インスタンスを持つ場合
        // ※ByRef _System_ReturnObject パラメータをセット
        //////////////////////////////////////////////////////

        int object_size;
        object_size=GetSizeOfClass(psi->u.Return_pobj_c);

        //push object_size
        op_push_value(object_size);

        //call calloc
        extern SUBINFO *pSub_calloc;
        op_call(pSub_calloc);

        //push eax
        op_push(REG_EAX);
    }


    if(psi->pobj_ParentClass&&bStatic==0){
        //////////////////////////////////////////////////////
        // メンバ関数の場合
        // ※_System_LocalThis パラメータをセット
        //////////////////////////////////////////////////////

        if(ObjectName[0]){
            if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
            else{
                RELATIVE_VAR RelativeVar;
                if( pMethod->isConst ){
                    //Constアクセスが可能なメソッドの場合
                    if( !GetVarOffsetReadOnly( ObjectName, &i2, &RelativeVar, 0 ) ) return -1;
                }
                else{
                    //Constアクセスが不可能なメソッドの場合
                    if( !GetVarOffsetReadWrite( ObjectName, &i2, &RelativeVar, 0 ) ) return -1;
                }

                SetVarPtrToEax(&RelativeVar);

                //参照タイプが整合しているかをチェック
                if(i2!=RefType) SetError(104,ObjectName,cp);

                if(i2==DEF_PTR_OBJECT){
                    //mov eax,dword ptr[eax]
                    OpBuffer[obp++]=(char)0x8B;
                    OpBuffer[obp++]=(char)0x00;
                }

                //mov ecx,eax
                OpBuffer[obp++]=(char)0x8B;
                OpBuffer[obp++]=(char)0xC8;
            }
        }
        else{
InClassMember:
            if(dwFlags&PROCFLAG_NEW){
                //New演算子によるコンストラクタ呼び出しの場合
                //mov ecx,dword ptr[esp+ParmSize]
                OpBuffer[obp++]=(char)0x8B;
                OpBuffer[obp++]=(char)0x8C;
                OpBuffer[obp++]=(char)0x24;
                *((long *)(OpBuffer+obp))=ParmSize;
                obp+=sizeof(long);
            }
            else{
                //Thisポインタをecxにコピー
                SetThisPtrToReg(REG_ECX);
            }
        }

        //push ecx
        op_push(REG_ECX);
    }

    if(psi->bVirtual){
        //仮想関数（オブジェクトメソッド）呼び出し
        //pObj->func_table->func1
        //                ->func2
        //                ->func3

        //mov edx,dword ptr[ecx]
        OpBuffer[obp++]=(char)0x8B;
        OpBuffer[obp++]=(char)0x11;

        for(i=0,i2=0;i<pobj_c->iMethodNum;i++){
            if(pobj_c->ppobj_Method[i]->psi==psi) break;
            if(pobj_c->ppobj_Method[i]->psi->bVirtual) i2++;
        }

        //call dword ptr[edx+func_index]
        if(i2*PTR_SIZE<=0x7F){
            OpBuffer[obp++]=(char)0xFF;
            OpBuffer[obp++]=(char)0x52;
            OpBuffer[obp++]=(char)(i2*PTR_SIZE);
        }
        else{
            OpBuffer[obp++]=(char)0xFF;
            OpBuffer[obp++]=(char)0x92;
            *((long *)(OpBuffer+obp))=i2*PTR_SIZE;
            obp+=sizeof(long);
        }
    }
    else{
        //通常呼び出し

        //call ProcAddr
        op_call(psi);
    }

    if(psi->bCdecl){
        //add esp,ParmSize
        op_add_esp(ParmSize);
    }

    //一時オブジェクトを破棄
    pobj_parameter->DeleteTempParameters();

    //パラメータオブジェクトを破棄
    delete pobj_parameter;

    if(plpIndex) *plpIndex=psi->u.ReturnIndex;

    return psi->ReturnType;
}

int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex){
    char *temporary;

    temporary=(char *)HeapAlloc(hHeap,0,lstrlen(Parameter)+1);

    extern BOOL bDebugCompile;
    extern BOOL bDebugSupportProc;
    if(bDebugCompile&&bDebugSupportProc==0&&lstrcmp(pdi->name,"DebugBreak")!=0)
        Call_DebugSys_SaveContext();

    pdi->bUse=1;


    ////////////////////////
    // パラメータのセット
    ////////////////////////

    //パラメータオブジェクトを生成
    CParameter *pobj_parameter=0;
    pobj_parameter=new CParameter(Parameter);

    //エラーチェック
    pobj_parameter->ErrorCheck(pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum);

    //レジスタ、スタックフレームにセット
    int ParmSize;
    ParmSize=pobj_parameter->SetParameter(pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum);

    //パラメータオブジェクトを破棄
    delete pobj_parameter;


    //動的リンクされたプロシージャの呼び出し

    //call dword ptr[LookupTable]
    OpBuffer[obp++]=(char)0xFF;
    OpBuffer[obp++]=(char)0x15;
    pobj_ImportAddrSchedule->add(pdi);
    obp+=sizeof(long);

    if(pdi->bCdecl){
        //add esp,ParmSize
        op_add_esp(ParmSize);
    }

    if(plpIndex) *plpIndex=pdi->u.ReturnIndex;

    HeapDefaultFree(temporary);

    return pdi->ReturnType;
}