source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/WatchList.cpp@ 508

#include "stdafx.h"

#include <Compiler.h>

#include "common.h"

#ifdef _AMD64_
#include "../compiler_x64/opcode.h"
#else
#include "../compiler_x86/opcode.h"
#endif

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

using namespace ActiveBasic::Compiler;

int Debugging_GetArray( const Subscripts &subscripts,char *array,const Type &type,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;
        LONG_PTR lpData;
        SIZE_T accessBytes;
        ReadProcessMemory(hDebugProcess,
            (void *)(ImageBase+MemPos_RWSection+pRelativeVar->offset),
            &lpData,
            sizeof(LONG_PTR),
            &accessBytes);

        return lpData;
    }
    else if(pRelativeVar->dwKind==VAR_LOCAL){
        extern HWND hDebugWnd;
        i2=(int)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=(int)SendDlgItemMessage(hDebugWnd,IDC_PROCCOMBO,CB_GETCURSEL,0,0);
        i2=pobj_dti->iProcLevel-i2;

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

        extern HANDLE hDebugProcess;
        LONG_PTR lpData;
        SIZE_T accessBytes;
        ReadProcessMemory(hDebugProcess,
            (void *)(pobj_dti->lplpSpBase[i2]+(int)pRelativeVar->offset),
            &lpData,
            sizeof(LONG_PTR),
            &accessBytes);

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

    return 0;
}

bool Debugging_SetRelativeOffset( Type &type,RELATIVE_VAR *pRelativeVar,char *lpPtrOffset){
    int array_num;

    _int64 i64data;
    if( !StaticCalculation( true, lpPtrOffset, 0, &i64data, Type(), 1 ) ){
        return false;
    }
    if( type.IsReal() ){
        double dbl;
        memcpy(&dbl,&i64data,sizeof(double));
        i64data=(_int64)dbl;
    }

    array_num=(int)i64data;

    if( type.PtrLevel() ){
        type.PtrLevelDown();
        array_num *= type.GetSize();
    }
    else{
        //エラー
        return false;
    }

    extern HANDLE hDebugProcess;
    LONG_PTR lpData;
    SIZE_T accessBytes;
    lpData=Debugging_GetVarPtr(pRelativeVar);
    if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(LONG_PTR),&accessBytes)){
        return false;
    }
    pRelativeVar->dwKind=VAR_DIRECTMEM;

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

int Debugging_GetMember( const CClass &objClass,char *member,RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess){
    int i2;

    //直接参照に切り替え
    pRelativeVar->offset=(LONG_PTR)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];   //入れ子メンバ
    ReferenceKind refType;
    lstrcpy(VarName,member);
    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember, refType ) ) return 0;


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

    const CMember *pMember = objClass.FindDynamicMember( VarName );
    if( !pMember )
    {
        return 0;
    }

    int offset = objClass.GetMemberOffset( VarName );


    //アクセシビリティをチェック
    if(( bPrivateAccess==0 && pMember->IsPrivate() )||
        pMember->IsNoneAccess() ){
        return 0;
    }
    else if(bPrivateAccess==0&&pMember->IsProtected())
        return 0;

    resultType = pMember->GetType();

    //ポインタ変数の場合
    if( resultType.IsPointer() ){
        if( pMember->GetSubscripts().size() == 0 ){
            lstrcpy(lpPtrOffset,array);
            array[0]=0;
        }
    }
    else{
        if(lpPtrOffset[0]) return 0;
    }

    pRelativeVar->offset+=offset;

    if(array[0]){
        //配列オフセット
        i2=Debugging_GetArray(
            pMember->GetSubscripts(),
            array,
            resultType,
            &pRelativeVar->offset);
        if(i2==0){
            //式エラー
            return 0;
        }
        if(i2==-1){
            //アクセスエラー
            return -1;
        }
    }
    else if( pMember->GetSubscripts().size() > 0 ){
        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
    }

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

        if( resultType.IsObject() || resultType.IsStruct() ){
            if( refType != RefDot ) return 0;

            if( resultType.IsObject() ){
                extern HANDLE hDebugProcess;
                LONG_PTR lpData;
                SIZE_T accessBytes;
                lpData=Debugging_GetVarPtr(pRelativeVar);
                if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(LONG_PTR),&accessBytes)) return -1;
                pRelativeVar->dwKind=VAR_DIRECTMEM;
            }
        }
        else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
            //構造体ポインタ型メンバ変数

            if(lpPtrOffset[0]){
                if( refType != RefDot ) return 0;

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

                lpPtrOffset[0]=0;
            }
            else{
                if( refType != RefPointer ) return 0;

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

        i2=Debugging_GetMember(pMember->GetType().GetClass(),
            NestMember,
            pRelativeVar,
            resultType,
            0);
        if(i2==0){
            //式エラー
            return 0;
        }
        if(i2==-1){
            //アクセスエラー
            return -1;
        }
    }

    if(lpPtrOffset[0]){
        Debugging_SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
    }

    return 1;
}
int Debugging_GetArray( const Subscripts &subscripts,char *array,const Type &type,LONG_PTR *plpOffset){
    extern HANDLE hHeap;
    int i,i2,i3,i4,i5,array_offset;
    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( i3 >= (int)subscripts.size() )
            {
                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( i3 < (int)subscripts.size() )
                {
                    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;
        Type resultType;
        bool isMemoryAccessError;
        if( !StaticCalculation(true, pParm[i],0,&i64data,resultType,1, &isMemoryAccessError ) ){
            //式エラー
            return 0;
        }
        if(isMemoryAccessError){
            //アクセスエラー
            return -1;
        }

        if(resultType.IsReal()){
            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]);
    }

    array_offset *= type.GetSize();

    *plpOffset+=array_offset;

    return 1;
}
ULONG_PTR Debugging_GetThisPtrOffset(LONG_PTR obp_Rip){
    UserProc *pUserProc = GetSubFromObp(obp_Rip);

    BOOST_FOREACH( Variable *pVar, pUserProc->GetLocalVars() ){
        if( pVar->GetName() == "_System_LocalThis" ){
            return pVar->GetOffsetAddress();
        }
    }
    return 0;
}
int Debugging_GetVarOffset( char *variable,RELATIVE_VAR *pRelativeVar, Type &resultType, Subscripts *pResultSubscripts){
    extern HANDLE hDebugProcess;
    int i2,i3;
    char member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    LONG_PTR lpData;
    SIZE_T accessBytes;

    lstrcpy(VarName,variable);
    ReferenceKind refType;
    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);

    const Subscripts *pSubscripts;
    bool isArray;


    /////////////////
    // ローカル変数
    /////////////////
    if( UserProc::IsLocalAreaCompiling() ){
        const Variable *pVar = UserProc::CompilingUserProc().GetLocalVars().Find( LexicalAnalyzer::FullNameToSymbol( VarName ) );

        if( pVar ){
            //ポインタ変数の場合
            if( pVar->GetType().IsPointer() ){
                if( !pVar->IsArray() ){
                    lstrcpy(lpPtrOffset,array);
                    array[0]=0;
                }
            }
            else{
                if(lpPtrOffset[0]) return 0;
            }

            pRelativeVar->offset = pVar->GetOffsetAddress();
            if( pVar->IsRef() ){
                pRelativeVar->dwKind=VAR_REFLOCAL;
            }
            else{
                pRelativeVar->dwKind=VAR_LOCAL;
            }
            resultType = pVar->GetType();
            isArray = pVar->IsArray();
            pSubscripts = &pVar->GetSubscripts();
        }
    }

    if(compiler.pCompilingClass){
        ///////////////////////
        // クラスメンバの参照
        ///////////////////////

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

            if( !compiler.pCompilingClass->HasDynamicMember( VarName ) )
            {
                goto NonClassMember;
            }
        }

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

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

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

        pRelativeVar->dwKind=VAR_DIRECTMEM;

        i3=Debugging_GetMember(*compiler.pCompilingClass,variable,pRelativeVar,resultType,1);
        if(i3==0){
            //式エラー
            return 0;
        }
        if(i3==-1){
            //アクセスエラー
            return -1;
        }

        return 1;
    }

NonClassMember:

    {
        ///////////////////
        // グローバル変数
        ///////////////////

        const Variable *pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( VarName ) );
        if( !pVar ){
            //一致しないとき
            return 0;
        }

        //ポインタ変数の場合
        if( pVar->GetType().IsPointer() ){
            if( !pVar->IsArray() ){
                lstrcpy(lpPtrOffset,array);
                array[0]=0;
            }
        }
        else{
            if(lpPtrOffset[0]) return 0;
        }

        pRelativeVar->offset=pVar->GetOffsetAddress();
        if(pVar->IsRef()) pRelativeVar->dwKind=VAR_REFGLOBAL;
        else pRelativeVar->dwKind=VAR_GLOBAL;
        resultType = pVar->GetType();
        isArray = pVar->IsArray();
        pSubscripts = &pVar->GetSubscripts();
    }


    if(array[0]==0&&isArray){
        //配列の先頭ポインタを示す場合
        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
        if( pResultSubscripts )
        {
            (*pResultSubscripts) = *pSubscripts;
        }
        return 1;
    }

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

            i3=Debugging_GetMember(resultType.GetClass(),member,pRelativeVar,resultType,0);
            if(i3==0){
                //式エラー
                return 0;
            }
            if(i3==-1){
                //アクセスエラー
                return -1;
            }
        }
        else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
            //ポインタオブジェクトが示すメンバを参照
            if(lpPtrOffset[0]){
                //pObj[n].member
                if( refType != RefDot ) return 0;
                Debugging_SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);

                i3=Debugging_GetMember(resultType.GetClass(),member,pRelativeVar,resultType,0);
                if(i3==0){
                    //式エラー
                    return 0;
                }
                if(i3==-1){
                    //アクセスエラー
                    return -1;
                }
            }
            else{
                //pObj->member
                if( refType != RefPointer ) return 0;

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

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

                i3=Debugging_GetMember(resultType.GetClass(),member,pRelativeVar,resultType,0);
                if(i3==0){
                    //式エラー
                    return 0;
                }
                if(i3==-1){
                    //アクセスエラー
                    return -1;
                }
            }
        }
        else{
            return 0;
        }
        return 1;
    }

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

    return 1;
}