source: dev/BasicCompiler32/WatchList.cpp@ 62

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

//デバッグ用
#include "../BasicCompiler_Common/debug.h"

int Debugging_GetArray(int *SubScripts,char *array,int type,LONG_PTR lpIndex,LONG_PTR *plpOffset);

ULONG_PTR Debugging_GetVarPtr(RELATIVE_VAR *pRelativeVar){
    extern DWORD ImageBase;
    extern int MemPos_RWSection;
    int i2;

    if(pRelativeVar->dwKind==VAR_GLOBAL){
        return ImageBase+MemPos_RWSection+pRelativeVar->offset;
    }
    else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
        extern HANDLE hDebugProcess;
        ULONG_PTR lpData;
        ULONG_PTR lpAccBytes;
        ReadProcessMemory(hDebugProcess,
            (void *)(ImageBase+MemPos_RWSection+pRelativeVar->offset),
            &lpData,
            sizeof(ULONG_PTR),
            &lpAccBytes);

        return lpData;
    }
    else if(pRelativeVar->dwKind==VAR_LOCAL){
        extern HWND hDebugWnd;
        i2=SendDlgItemMessage(hDebugWnd,IDC_PROCCOMBO,CB_GETCURSEL,0,0);
        i2=pobj_dti->iProcLevel-i2;

        if(pobj_dti->lplpSpBase[i2]==0) return 0;

        return pobj_dti->lplpSpBase[i2]+pRelativeVar->offset;
    }
    else if(pRelativeVar->dwKind==VAR_REFLOCAL){
        extern HWND hDebugWnd;
        i2=SendDlgItemMessage(hDebugWnd,IDC_PROCCOMBO,CB_GETCURSEL,0,0);
        i2=pobj_dti->iProcLevel-i2;

        if(pobj_dti->lplpSpBase[i2]==0) return 0;

        extern HANDLE hDebugProcess;
        ULONG_PTR lpData;
        ULONG_PTR lpAccBytes;
        ReadProcessMemory(hDebugProcess,
            (void *)(pobj_dti->lplpSpBase[i2]+pRelativeVar->offset),
            &lpData,
            sizeof(ULONG_PTR),
            &lpAccBytes);

        return lpData;
    }
    else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
        return pRelativeVar->offset;
    }

    return 0;
}

BOOL Debugging_SetRelativeOffset(int *pType,LONG_PTR lpIndex,RELATIVE_VAR *pRelativeVar,char *lpPtrOffset){
    int array_num;

    _int64 i64data;
    int type;
    type=StaticCalculation(true, lpPtrOffset,0,&i64data,0,1);
    if(!type) return 0;
    if(IsRealNumberType(type)){
        double dbl;
        memcpy(&dbl,&i64data,sizeof(double));
        i64data=(_int64)dbl;
    }

    array_num=(int)i64data;

    if(PTR_LEVEL(*pType)){
        *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
        if((*pType)==DEF_OBJECT)
            array_num*=GetSizeOfClass((CClass *)lpIndex);
        else
            array_num*=GetTypeSize(*pType,-1);
    }
    else{
        //エラー
        return 0;
    }

    extern HANDLE hDebugProcess;
    ULONG_PTR lpData;
    ULONG_PTR lpAccBytes;
    lpData=Debugging_GetVarPtr(pRelativeVar);
    if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(LONG_PTR),&lpAccBytes)) return 0;
    pRelativeVar->dwKind=VAR_DIRECTMEM;

    pRelativeVar->offset+=array_num;
    return 1;
}

BOOL Debugging_GetMember(CClass *pobj_c,char *member,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpNestIndex,BOOL bPrivateAccess){
    int i,i2,offset;

    //直接参照に切り替え
    pRelativeVar->offset=Debugging_GetVarPtr(pRelativeVar);
    pRelativeVar->dwKind=VAR_DIRECTMEM;

    //クラス、配列の構成要素を解析する
    char VarName[VN_SIZE];      //変数名
    char array[VN_SIZE];        //第1次配列
    char lpPtrOffset[VN_SIZE];  //第2次配列
    char NestMember[VN_SIZE];   //入れ子メンバ
    int RefType;                //"."参照のときは0、"->"参照のときは1
    lstrcpy(VarName,member);
    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;


    ////////////////////////////
    // メンバオフセットを取得
    ////////////////////////////

    offset=GetSizeOfClassMember(pobj_c,VarName,&i);
    if(i==pobj_c->iMemberNum) return 0;


    //アクセシビリティをチェック
    if((bPrivateAccess==0&&pobj_c->ppobj_Member[i]->dwAccess==ACCESS_PRIVATE)||
        pobj_c->ppobj_Member[i]->dwAccess==ACCESS_NON){
        return 0;
    }
    else if(bPrivateAccess==0&&pobj_c->ppobj_Member[i]->dwAccess==ACCESS_PROTECTED)
        return 0;

    *pType=pobj_c->ppobj_Member[i]->TypeInfo.type;
    *plpNestIndex=pobj_c->ppobj_Member[i]->TypeInfo.u.lpIndex;

    //ポインタ変数の場合
    if(IsPtrType(*pType)){
        if(pobj_c->ppobj_Member[i]->SubScripts[0]==-1){
            lstrcpy(lpPtrOffset,array);
            array[0]=0;
        }
    }
    else{
        if(lpPtrOffset[0]) return 0;
    }

    pRelativeVar->offset+=offset;

    if(array[0]){
        //配列オフセット
        i2=Debugging_GetArray(
            pobj_c->ppobj_Member[i]->SubScripts,
            array,
            *pType,
            pobj_c->ppobj_Member[i]->TypeInfo.u.lpIndex,
            &pRelativeVar->offset);
        if(i2==0){
            //式エラー
            return 0;
        }
        if(i2==-1){
            //アクセスエラー
            return -1;
        }
    }
    else if(pobj_c->ppobj_Member[i]->SubScripts[0]!=-1){
        *pType|=FLAG_PTR;
    }

    if(NestMember[0]){
        //入れ子構造の場合

        if(*pType==DEF_OBJECT){
            if(RefType!=DEF_OBJECT) return 0;
        }
        else if(*pType==DEF_PTR_OBJECT){
            //構造体ポインタ型メンバ変数

            if(lpPtrOffset[0]){
                if(RefType!=DEF_OBJECT) return 0;

                //直接参照に切り替え
                Debugging_SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);

                lpPtrOffset[0]=0;
            }
            else{
                if(RefType!=DEF_PTR_OBJECT) return 0;

                extern HANDLE hDebugProcess;
                ULONG_PTR lpData;
                ULONG_PTR lpAccBytes;
                lpData=Debugging_GetVarPtr(pRelativeVar);
                if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(LONG_PTR),&lpAccBytes)) return -1;
                pRelativeVar->dwKind=VAR_DIRECTMEM;
            }
        }

        i2=Debugging_GetMember(pobj_c->ppobj_Member[i]->TypeInfo.u.pobj_Class,
            NestMember,
            pType,
            pRelativeVar,
            plpNestIndex,
            0);
        if(i2==0){
            //式エラー
            return 0;
        }
        if(i2==-1){
            //アクセスエラー
            return -1;
        }
    }

    if(lpPtrOffset[0]){
        Debugging_SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
    }

    return 1;
}
int Debugging_GetArray(int *SubScripts,char *array,int type,LONG_PTR lpIndex,LONG_PTR *plpOffset){
    extern HANDLE hHeap;
    int i,i2,i3,i4,i5,array_offset,TypeSize;
    char temporary[VN_SIZE],*pParm[MAX_PARMS];

    for(i=0,i2=0,i3=0;;i++,i2++){
        if(array[i]=='('){
            i4=GetStringInPare(temporary+i2,array+i);
            i+=i4-1;
            i2+=i4-1;
            continue;
        }
        if(array[i]=='['){
            i4=GetStringInBracket(temporary+i2,array+i);
            i+=i4-1;
            i2+=i4-1;
            continue;
        }
        if(array[i]==','||array[i]=='\0'){
            if(SubScripts[i3]==-1){
                for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
                return 0;
            }

            temporary[i2]=0;

            pParm[i3]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
            lstrcpy(pParm[i3],temporary);

            i3++;

            if(array[i]=='\0'){
                if(SubScripts[i3]!=-1){
                    for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
                    return 0;
                }
                break;
            }

            i2=-1;
            continue;
        }
        temporary[i2]=array[i];
    }

    array_offset=0;

    for(i=i3-1;i>=0;i--){
        _int64 i64data;
        i2=StaticCalculation(true, pParm[i],0,&i64data,0,1);
        if(i2==0){
            //式エラー
            return 0;
        }
        if(i2==-1){
            //アクセスエラー
            return -1;
        }
        if(IsRealNumberType(i2)){
            double dbl;
            memcpy(&dbl,&i64data,sizeof(double));
            i64data=(_int64)dbl;
        }
        i5=(int)i64data;

        for(i2=i+1,i4=1;i2<i3;i2++) i4*=SubScripts[i2]+1;

        array_offset+=i5*i4;

        HeapDefaultFree(pParm[i]);
    }

    TypeSize=GetTypeSize(type,lpIndex);

    array_offset*=TypeSize;

    *plpOffset+=array_offset;

    return 1;
}
ULONG_PTR Debugging_GetThisPtrOffset(LONG_PTR obp_Rip){
    int i;
    SUBINFO *psi;

    //ripからプロシージャを取得
    psi=GetSubFromObp(obp_Rip);

    for(i=0;i<psi->VarNum;i++){
        if(lstrcmp(psi->pVar[i].name,"_System_LocalThis")==0) break;
    }
    if(i==psi->VarNum) return 0;

    return psi->pVar[i].offset;
}
int Debugging_GetVarOffset(char *variable,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
    extern HANDLE hDebugProcess;
    int i,i2,i3,RefType;
    char member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    ULONG_PTR lpData;
    ULONG_PTR lpAccBytes;

    lstrcpy(VarName,variable);
    GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);

    LONG_PTR lpIndex;
    int *pSubScripts;
    BOOL bArray;


    /////////////////
    // ローカル変数
    /////////////////
    extern VARIABLE *LocalVar;
    extern int MaxLocalVarNum;
    for(i=0;i<MaxLocalVarNum;i++){
        if(lstrcmp(VarName,LocalVar[i].name)==0) break;
    }
    if(i!=MaxLocalVarNum){
        //ポインタ変数の場合
        if(IsPtrType(LocalVar[i].type)){
            if(!LocalVar[i].bArray){
                lstrcpy(lpPtrOffset,array);
                array[0]=0;
            }
        }
        else{
            if(lpPtrOffset[0]) return 0;
        }

        pRelativeVar->offset=LocalVar[i].offset;
        if(LocalVar[i].fRef) pRelativeVar->dwKind=VAR_REFLOCAL;
        else pRelativeVar->dwKind=VAR_LOCAL;
        *pType=LocalVar[i].type;
        lpIndex=LocalVar[i].u.index;
        *plpIndex=lpIndex;
        bArray=LocalVar[i].bArray;
        pSubScripts=LocalVar[i].SubScripts;
    }
    else{
        if(pobj_CompilingClass){
            ///////////////////////
            // クラスメンバの参照
            ///////////////////////

            if(_memicmp(variable,"This.",5)==0){
                //Thisオブジェクトのメンバを参照するとき
                SlideString(variable+5,-5);
                lstrcpy(VarName,variable);
            }
            else{
                //クラス内メンバを参照するとき（通常）

                for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
                    if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
                }
                if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
            }

            /////////////////////////////
            // thisポインタを取得

            extern HWND hDebugWnd;
            i2=SendDlgItemMessage(hDebugWnd,IDC_PROCCOMBO,CB_GETCURSEL,0,0);
            i2=pobj_dti->iProcLevel-i2;

            lpData=Debugging_GetThisPtrOffset(pobj_dti->lplpObp[i2]);
            lpData+=pobj_dti->lplpSpBase[i2];
            if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(ULONG_PTR),&lpAccBytes)){
                //メモリにアクセスできないとき
                return -1;
            }

            pRelativeVar->dwKind=VAR_DIRECTMEM;

            LONG_PTR lp2;
            i3=Debugging_GetMember(pobj_CompilingClass,variable,pType,pRelativeVar,&lp2,1);
            if(i3==0){
                //式エラー
                return 0;
            }
            if(i3==-1){
                //アクセスエラー
                return -1;
            }

            *plpIndex=lp2;
            return 1;
        }

NonClassMember:


        ///////////////////
        // グローバル変数
        ///////////////////
        extern VARIABLE *GlobalVar;
        extern int MaxGlobalVarNum;

        for(i=0;i<MaxGlobalVarNum;i++){
            if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
        }
        if(i==MaxGlobalVarNum){
            //一致しないとき
            return 0;
        }

        //ポインタ変数の場合
        if(IsPtrType(GlobalVar[i].type)){
            if(!GlobalVar[i].bArray){
                lstrcpy(lpPtrOffset,array);
                array[0]=0;
            }
        }
        else{
            if(lpPtrOffset[0]) return 0;
        }

        pRelativeVar->offset=GlobalVar[i].offset;
        if(GlobalVar[i].fRef) pRelativeVar->dwKind=VAR_REFGLOBAL;
        else pRelativeVar->dwKind=VAR_GLOBAL;
        *pType=GlobalVar[i].type;
        lpIndex=GlobalVar[i].u.index;
        *plpIndex=lpIndex;
        bArray=GlobalVar[i].bArray;
        pSubScripts=GlobalVar[i].SubScripts;
    }


    if(array[0]==0&&bArray){
        //配列の先頭ポインタを示す場合
        *pType|=FLAG_PTR;
        if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
        return 1;
    }

    if(array[0]){
        i3=Debugging_GetArray(pSubScripts,array,*pType,lpIndex,&pRelativeVar->offset);
        if(i3==0){
            //式エラー
            return 0;
        }
        if(i3==-1){
            //アクセスエラー
            return -1;
        }
    }
    if(member[0]){
        if(*pType==DEF_OBJECT){
            //実態オブジェクトのメンバを参照（obj.member）
            if(RefType!=DEF_OBJECT){
                return 0;
            }

            LONG_PTR lp2;
            i3=Debugging_GetMember((CClass *)lpIndex,member,pType,pRelativeVar,&lp2,0);
            if(i3==0){
                //式エラー
                return 0;
            }
            if(i3==-1){
                //アクセスエラー
                return -1;
            }

            *plpIndex=lp2;
        }
        else if(*pType==DEF_PTR_OBJECT){
            //ポインタオブジェクトが示すメンバを参照
            if(lpPtrOffset[0]){
                //pObj[n].member
                if(RefType!=DEF_OBJECT) return 0;
                Debugging_SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);

                LONG_PTR lp2;
                i3=Debugging_GetMember((CClass *)lpIndex,member,pType,pRelativeVar,&lp2,0);
                if(i3==0){
                    //式エラー
                    return 0;
                }
                if(i3==-1){
                    //アクセスエラー
                    return -1;
                }

                *plpIndex=lp2;
            }
            else{
                //pObj->member
                if(RefType!=DEF_PTR_OBJECT) return 0;

                pRelativeVar->offset=Debugging_GetVarPtr(pRelativeVar);
                pRelativeVar->dwKind=VAR_DIRECTMEM;

                if(!ReadProcessMemory(hDebugProcess,(void *)pRelativeVar->offset,&lpData,sizeof(ULONG_PTR),&lpAccBytes)) return -1;
                pRelativeVar->offset=lpData;

                LONG_PTR lp2;
                i3=Debugging_GetMember((CClass *)lpIndex,member,pType,pRelativeVar,&lp2,0);
                if(i3==0){
                    //式エラー
                    return 0;
                }
                if(i3==-1){
                    //アクセスエラー
                    return -1;
                }

                *plpIndex=lp2;
            }
        }
        else{
            return 0;
        }
        return 1;
    }

    if(lpPtrOffset[0]){
        if(!Debugging_SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset)) return 0;
    }

    return 1;
}