source: dev/BasicCompiler64/Compile_Var.cpp@ 63

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

//変数
VARIABLE *GlobalVar;
int MaxGlobalVarNum;
int AllGlobalVarSize;
int AllInitGlobalVarSize;
VARIABLE *LocalVar;
int MaxLocalVarNum;
int AllLocalVarSize;


void SetRelativeOffset(int *pType,LONG_PTR lpIndex,RELATIVE_VAR *pRelativeVar,char *lpPtrOffset){
    int i2;


    /////////////////////////////////////////////
    // 先頭ポインタをr12に取得してメモリへ退避
    /////////////////////////////////////////////

    SetReg_WholeVariable(DEF_INT64,pRelativeVar,REG_R11);

    //mov qword ptr[rsp+offset],r11     ※スタックフレームを利用
    pobj_sf->push(REG_R11);


    ////////////////////////////////
    // 添え字を計算する
    ////////////////////////////////

    int reg=REG_NON;
    i2=NumOpe(&reg,lpPtrOffset,0,0,0);
    if(!IsWholeNumberType(i2)) SetError(46,NULL,cp);
    ExtendTypeTo64(i2,reg);

    if(reg==REG_R14){
        //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(REG_R14);
    }

    if(PTR_LEVEL(*pType)){
        *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
        if((*pType)==DEF_OBJECT){
            CClass *pClass = (CClass *)lpIndex;
            //imul reg,objsize
            op_imul_value( sizeof(_int64), reg, pClass->GetSize() );
        }
        else{
            i2=GetTypeSize(*pType,-1);
            if(i2>=2){
                //imul reg,i2
                op_imul_value(sizeof(_int64),reg,i2);
            }
        }
    }
    else{
        //エラー
        SetError(1,NULL,cp);
        return;
    }


    //////////////////////////////
    // 先頭ポインタに添え字を加算
    //////////////////////////////

    //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
    pobj_sf->pop(REG_R11);

    //add r11,reg
    op_add64_reg(REG_R11,reg);
}
BOOL GetArrayOffset(int *SubScripts,char *array,int type,LONG_PTR lpIndex){
    extern HANDLE hHeap;
    int i,i2,i3,i4,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];
    }

    //mov qword ptr[rsp+offset],r11     ※スタックフレームを利用
    pobj_sf->push(REG_R11);

    //xor r12,r12
    op_zero_reg(REG_R12);

    for(i=i3-1;i>=0;i--){
        //mov qword ptr[rsp+offset],r12     ※スタックフレームを利用
        pobj_sf->push(REG_R12);

        int reg=REG_NON;
        TYPEINFO TypeInfo;
        BOOL bUseHeap;
        TypeInfo.type=NumOpe(&reg,pParm[i],DEF_LONG,-1,&TypeInfo.u.lpIndex,&bUseHeap);
        if(TypeInfo.type==DEF_OBJECT){
            //キャスト演算子のオーバーロードに対応する
            CallCastOperatorProc(reg,
                TypeInfo.type,TypeInfo.u.lpIndex,
                bUseHeap,DEF_LONG,-1);
            TypeInfo.type=DEF_LONG;
        }

        if(!IsWholeNumberType(TypeInfo.type)) SetError(46,NULL,cp);
        ExtendTypeTo64(TypeInfo.type,reg);

        if(reg==REG_R14){
            //mov r14,qword ptr[rsp+offset]     ※スタックフレームを利用
            pobj_sf->pop(REG_R14);
        }

        //mov r12,qword ptr[rsp+offset]     ※スタックフレームを利用
        pobj_sf->pop(REG_R12);

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

        //imul reg,i4
        op_imul_value(sizeof(_int64),reg,i4);

        //add r12,reg
        op_add64_reg(REG_R12,reg);

        HeapDefaultFree(pParm[i]);
    }

    TypeSize=GetTypeSize(type,lpIndex);

    //imul r12,TypeSize
    OpBuffer[obp++]=(char)0x4D;
    OpBuffer[obp++]=(char)0x69;
    OpBuffer[obp++]=(char)0xE4;
    *((long *)(OpBuffer+obp))=TypeSize;
    obp+=sizeof(long);

    //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
    pobj_sf->pop(REG_R11);

    //add r11,r12
    OpBuffer[obp++]=(char)0x4D;
    OpBuffer[obp++]=(char)0x03;
    OpBuffer[obp++]=(char)0xDC;

    return 1;
}
BOOL GetMemberOffset(bool isErrorEnabled, bool isWriteAccess, CClass *pobj_c, char *member, int *pType, RELATIVE_VAR *pRelativeVar, LONG_PTR *plpNestIndex, BOOL bPrivateAccess){
    int i;


    //////////////////////////////////////
    // クラス、配列の構成要素を解析する
    //////////////////////////////////////

    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;


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

    int offset = pobj_c->GetMemberOffset( VarName, &i );
    if(i==pobj_c->iMemberNum){
        if(isErrorEnabled) SetError(103,VarName,cp);
        return 0;
    }

    CMember *pMember=pobj_c->ppobj_Member[i];


    //アクセシビリティをチェック
    if(pobj_c==pobj_CompilingClass){
        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
        if(pMember->dwAccess==ACCESS_NON){
            if(isErrorEnabled) SetError(107,VarName,cp);
            return 0;
        }
    }
    else{
        if((bPrivateAccess==0&&pMember->dwAccess==ACCESS_PRIVATE)||
            pMember->dwAccess==ACCESS_NON){
            if(isErrorEnabled) SetError(107,VarName,cp);
            return 0;
        }
        else if(bPrivateAccess==0&&pMember->dwAccess==ACCESS_PROTECTED){
            if(isErrorEnabled) SetError(108,VarName,cp);
            return 0;
        }
    }

    //Const定義の場合は書き込みアクセスを制限する
    //※コンストラクタをコンパイル中の場合は例外的に許可する
    if( pMember->IsConst() &&       //定数メンバである
        isWriteAccess &&                            //書き込みアクセスを要求されている
        pobj_c->IsCompilingConstructor() == false   //コンストラクタ コンパイル中を除く
        ){
            //Const定義の変数に書き込みアクセスをしようとした場合
            SetError(61,VarName,cp);
    }

    *pType=pMember->TypeInfo.type;
    *plpNestIndex=pMember->TypeInfo.u.lpIndex;

    //ポインタ変数の場合
    if(IsPtrType(*pType)){
        if(pMember->SubScripts[0]==-1){
            lstrcpy(lpPtrOffset,array);
            array[0]=0;
        }
    }
    else{
        if(lpPtrOffset[0]){
            if(isErrorEnabled) SetError(16,member,cp);
            return 0;
        }
    }

    if(offset){
        //add r11,offset
        OpBuffer[obp++]=(char)0x49;
        OpBuffer[obp++]=(char)0x81;
        OpBuffer[obp++]=(char)0xC3;
        *((long *)(OpBuffer+obp))=offset;
        obp+=sizeof(long);
    }

    if(array[0]){
        //配列オフセット
        if(!GetArrayOffset(pMember->SubScripts,array,*pType,pMember->TypeInfo.u.lpIndex)){
            if(isErrorEnabled) SetError(14,member,cp);
        }
    }
    else if(pMember->SubScripts[0]!=-1){
        *pType|=FLAG_PTR;
    }

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

        if(*pType==DEF_OBJECT && pMember->IsRef() == false){
            if(RefType!=DEF_OBJECT){
                if(isErrorEnabled) SetError(104,member,cp);
                return 0;
            }
        }
        else if(*pType==DEF_PTR_OBJECT || ( *pType==DEF_OBJECT && pMember->IsRef() )){
            //構造体ポインタ型メンバ変数

            if(lpPtrOffset[0]){
                //pObj[n].member
                if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_OBJECT){
                    if(isErrorEnabled) SetError(104,member,cp);
                    return 0;
                }

                //直接参照に切り替え
                SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
                pRelativeVar->dwKind=VAR_DIRECTMEM;

                lpPtrOffset[0]=0;
            }
            else{
                //pObj->member
                if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_PTR_OBJECT){
                    if(isErrorEnabled) SetError(104,member,cp);
                    return 0;
                }

                if(pRelativeVar->dwKind==VAR_DIRECTMEM){
                    //mov r11,qword ptr[r11]
                    op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
                }
                else{
                    //直接参照に切り替え
                    SetVarPtrToReg(REG_R12,pRelativeVar);
                    pRelativeVar->dwKind=VAR_DIRECTMEM;

                    //mov r11,qword ptr[r12]
                    op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
                }
            }
        }
        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
            //構造体ポインタのポインタ型メンバ変数

            if(lpPtrOffset[0]){
                //ppObj[n]->member
                if(RefType!=DEF_PTR_OBJECT){
                    if(isErrorEnabled) SetError(104,member,cp);
                    return 0;
                }

                //直接参照に切り替え
                SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
                pRelativeVar->dwKind=VAR_DIRECTMEM;

                lpPtrOffset[0]=0;

                //mov r11,qword ptr[r11]
                op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
            }
            else{
                if(isErrorEnabled) SetError(104,member,cp);
                return 0;
            }
        }

        if(!GetMemberOffset(
            isErrorEnabled,
            isWriteAccess,
            pMember->TypeInfo.u.pobj_Class,
            NestMember,
            pType,
            pRelativeVar,
            plpNestIndex,
            0)) return 0;
    }

    if(lpPtrOffset[0]){
        SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
        pRelativeVar->dwKind=VAR_DIRECTMEM;
    }

    return 1;
}
void GetWithName(char *buffer){
    extern WITHINFO WithInfo;
    int i;

    buffer[0]=0;
    for(i=0;i<WithInfo.num;i++)
        lstrcat(buffer,WithInfo.ppName[i]);
}

int LocalVar_ThisPtrOffset;
void SetThisPtrToReg(int reg){
    //自身のオブジェクトのThisポインタをregにコピー

    extern VARIABLE *LocalVar;
    RELATIVE_VAR RelativeVar;
    RelativeVar.dwKind=VAR_LOCAL;
    RelativeVar.bOffsetOffset=0;
    RelativeVar.offset=-LocalVar_ThisPtrOffset;

    SetReg_WholeVariable(DEF_PTR_VOID,&RelativeVar,reg);
}
BOOL GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
    extern BOOL bCompilingGlobal;
    int i,RefType;
    LONG_PTR lpIndex;
    char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];

    if(NameBuffer[0]=='.'){
        GetWithName(variable);
        lstrcat(variable,NameBuffer);
    }
    else lstrcpy(variable,NameBuffer);

    if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
        // 戻り値オブジェクトのメンバを直接参照しているとき
        //例: func().member

        void *pInfo;
        int idProc=GetProc(VarName,&pInfo);

        if(idProc){
            pRelativeVar->dwKind=VAR_DIRECTMEM;

            //////////////////////////////////////////////////////
            /////    レジスタ資源のバックアップ
            {   BACKUP_REGISTER_RESOURCE
            //////////////////////////////////////////////////////

                ////////////////
                // 呼び出し
                ////////////////

                *pType=CallProc(idProc,pInfo,VarName,array,&lpIndex);

                //戻り値をr11にコピー
                op_mov_RR( REG_R11, REG_RAX );

            /////////////////////////////////////////////
            //////   レジスタ資源を復元
                RESTORE_REGISTER_RESOURCE
            }////////////////////////////////////////////

            LONG_PTR lp2;
            if(!GetMemberOffset(
                isErrorEnabled,
                isWriteAccess,
                (CClass *)lpIndex,
                member,pType,pRelativeVar,&lp2,0)) return 0;
            if(plpIndex) *plpIndex=lp2;

            return 1;
        }
    }



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

    int *pSubScripts;
    bool bConst = false;


    if(bCompilingGlobal==0){
        //////////////////
        // ローカル変数
        //////////////////

        for(i=MaxLocalVarNum-1;i>=0;i--){   //レキシカルスコープを考慮してバックサーチ
            if( LocalVar[i].bLiving                                         //現在のスコープで有効なもの
                && LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()    //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
                ){
                    if(lstrcmp(VarName,LocalVar[i].name)==0) break;
            }
        }
        if(i>=0){
            //ポインタ変数の場合
            if(IsPtrType(LocalVar[i].type)){
                if(LocalVar[i].SubScripts[0]==-1){
                    lstrcpy(lpPtrOffset,array);
                    array[0]=0;
                }
            }
            else{
                if(lpPtrOffset[0]){
                    SetError(16,variable,cp);
                    pRelativeVar->dwKind=NON_VAR;
                    return 0;
                }
            }

            pRelativeVar->offset=-LocalVar[i].offset;
            pRelativeVar->bOffsetOffset=0;
            if(LocalVar[i].fRef){
                // 参照型
                pRelativeVar->dwKind = VAR_REFLOCAL;
            }
            else pRelativeVar->dwKind=VAR_LOCAL;
            *pType=LocalVar[i].type;
            lpIndex=LocalVar[i].u.index;
            if(plpIndex) *plpIndex=lpIndex;
            pSubScripts=LocalVar[i].SubScripts;
            bConst = LocalVar[i].bConst;

            goto ok;
        }
    }


    if(pobj_CompilingClass){
        //////////////////////
        // クラスメンバの参照
        //////////////////////

        if(lstrcmpi(variable,"This")==0){
            //自身のオブジェクトのThisポインタをr11にコピー
            SetThisPtrToReg(REG_R11);

            *pType=DEF_OBJECT;
            pRelativeVar->dwKind=VAR_DIRECTMEM;

            if(plpIndex) *plpIndex=(LONG_PTR)pobj_CompilingClass;
            return 1;
        }

        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;
        }

        //Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
        //（コンストラクタ、デストラクタ内を除く）
        CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
        if( isWriteAccess &&
            pMethod->isConst &&
            pobj_CompilingClass->IsCompilingConstructor() == false &&
            pobj_CompilingClass->IsCompilingDestructor() == false
            ){
                SetError(131, NULL, cp );
        }

        //自身のオブジェクトのThisポインタをr11にコピー
        SetThisPtrToReg(REG_R11);

        pRelativeVar->dwKind=VAR_DIRECTMEM;
        if(!GetMemberOffset(
            isErrorEnabled,
            isWriteAccess,
            pobj_CompilingClass,
            variable,
            pType,
            pRelativeVar,
            &lpIndex,1)) return 0;
        if(plpIndex) *plpIndex=lpIndex;
        return 1;
    }

NonClassMember:

    //////////////////////////
    // 静的ローカル変数
    // ※"Static.Object.Method.Variable"
    //////////////////////////

    char temporary[VN_SIZE];
    extern SUBINFO *pCompilingSubInfo;
    if(pCompilingSubInfo){
        GetNowStaticVarFullName(VarName,temporary);

        for(i=0;i<MaxGlobalVarNum;i++){
            if(lstrcmp(temporary,GlobalVar[i].name)==0) break;
        }
        if(i!=MaxGlobalVarNum){
            goto GlobalOk;
        }
    }


    //////////////////////////
    // クラスの静的メンバ
    //////////////////////////

    if(member[0]){
        lstrcpy(temporary,member);

        char tempMember[VN_SIZE];
        char tempArray[VN_SIZE];
        GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);

        char temp2[VN_SIZE];
        sprintf(temp2,"%s.%s",VarName,temporary);
        for(i=0;i<MaxGlobalVarNum;i++){
            if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
        }

        if(i!=MaxGlobalVarNum){
            lstrcpy(member,tempMember);
            lstrcpy(array,tempArray);
            goto GlobalOk;
        }
    }

    if(pobj_CompilingClass){
        //自身のクラスから静的メンバを参照する場合
        char temp2[VN_SIZE];
        sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
        for(i=0;i<MaxGlobalVarNum;i++){
            if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
        }

        if(i!=MaxGlobalVarNum){
            goto GlobalOk;
        }
    }

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

    for(i=MaxGlobalVarNum-1;i>=0;i--){  //レキシカルスコープを考慮してバックサーチ
        if( GlobalVar[i].bLiving                                        //現在のスコープで有効なもの
            && GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()   //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
            ){
                if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
        }
    }
    if(i>=0){
        goto GlobalOk;
    }

    if(isErrorEnabled) SetError(3,variable,cp);
    pRelativeVar->dwKind=NON_VAR;
    return 0;



GlobalOk:
    //ポインタ変数の場合
    if(IsPtrType(GlobalVar[i].type)){
        if(GlobalVar[i].SubScripts[0]==-1){
            lstrcpy(lpPtrOffset,array);
            array[0]=0;
        }
    }
    else{
        if(lpPtrOffset[0]){
            SetError(16,variable,cp);
            pRelativeVar->dwKind=NON_VAR;
            return 0;
        }
    }

    pRelativeVar->offset=GlobalVar[i].offset;
    pRelativeVar->bOffsetOffset=0;
    if(GlobalVar[i].fRef){
        // 参照型
        pRelativeVar->dwKind = VAR_REFGLOBAL;
    }
    else pRelativeVar->dwKind=VAR_GLOBAL;
    *pType=GlobalVar[i].type;
    lpIndex=GlobalVar[i].u.index;
    if(plpIndex) *plpIndex=lpIndex;
    pSubScripts=GlobalVar[i].SubScripts;
    bConst = GlobalVar[i].bConst;



ok:

    if( bConst && isWriteAccess ){
        //Const定義の変数に書き込みアクセスをしようとした場合
        if( *pType == DEF_OBJECT ){
            //オブジェクト定数
            SetError(130, VarName, cp );
        }
        else{
            //一般のConst変数
            SetError(61,VarName,cp);
        }
    }

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

    if( array[0] || member[0] ){
        //xor r11,r11（r11を0に初期化する）
        //※r11は変数ベースアドレスからの相対オフセットを示す
        op_zero_reg(REG_R11);

        pRelativeVar->bOffsetOffset=1;
    }
    if(array[0]){
        if(!GetArrayOffset(pSubScripts,array,*pType,lpIndex)){
            SetError(14,variable,cp);
            pRelativeVar->dwKind=NON_VAR;
            return 0;
        }
    }
    if(member[0]){
        if(*pType==DEF_OBJECT){
            //実態オブジェクトのメンバを参照（obj.member）
            if(RefType!=DEF_OBJECT){
                SetError(104,VarName,cp);
                pRelativeVar->dwKind=NON_VAR;
                return 0;
            }
        }
        else if(*pType==DEF_PTR_OBJECT){
            //ポインタオブジェクトが示すメンバを参照
            if(lpPtrOffset[0]){
                //pObj[n].member
                if(RefType!=DEF_OBJECT){
                    SetError(104,VarName,cp);
                    pRelativeVar->dwKind=NON_VAR;
                    return 0;
                }
                SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
                pRelativeVar->dwKind=VAR_DIRECTMEM;
            }
            else{
                //pObj->member
                if(RefType!=DEF_PTR_OBJECT){
                    SetError(104,VarName,cp);
                    pRelativeVar->dwKind=NON_VAR;
                    return 0;
                }

                SetVarPtrToReg(REG_R12,pRelativeVar);
                pRelativeVar->dwKind=VAR_DIRECTMEM;

                //mov r11,qword ptr[r12]
                op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
            }
        }
        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
            //ポインタオブジェクトが示すメンバを参照
            if(lpPtrOffset[0]){
                //ppObj[n]->member
                if(RefType!=DEF_PTR_OBJECT){
                    SetError(104,VarName,cp);
                    pRelativeVar->dwKind=NON_VAR;
                    return 0;
                }

                SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
                pRelativeVar->dwKind=VAR_DIRECTMEM;


                SetVarPtrToReg(REG_R12,pRelativeVar);

                //mov r11,qword ptr[r12]
                op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
            }
            else{
                SetError(104,VarName,cp);
                pRelativeVar->dwKind=NON_VAR;
                return 0;
            }
        }
        else{
            SetError(102,VarName,cp);
            pRelativeVar->dwKind=NON_VAR;
            return 0;
        }

        LONG_PTR lp2;
        if(!GetMemberOffset(
            isErrorEnabled,
            isWriteAccess,
            (CClass *)lpIndex,
            member,pType,pRelativeVar,&lp2,0)) return 0;
        if(plpIndex) *plpIndex=lp2;

        return 1;
    }

    if(lpPtrOffset[0]){
        SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
        pRelativeVar->dwKind=VAR_DIRECTMEM;
    }

    return 1;
}

BOOL SetInitGlobalData(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
    extern BYTE *initGlobalBuf;
    int i,i2,i3,TypeSize;
    char temporary[VN_SIZE];

    if(InitBuf[0]=='['){
        SlideString(InitBuf+1,-1);
        InitBuf[lstrlen(InitBuf)-1]=0;

        TypeSize=GetTypeSize(type,lpIndex);

        if(SubScripts[0]!=-1){
            TypeSize*=JumpSubScripts(SubScripts+1);
            i=0;
            i2=0;
            while(1){
                if(SubScripts[0]<i2){
                    SetError(41,0,cp);
                    return 0;
                }
                i=GetOneParameter(InitBuf,i,temporary);
                if(!SetInitGlobalData(
                    offset+i2*TypeSize,
                    type,
                    lpIndex,
                    SubScripts+1,
                    temporary)) return 0;
                i2++;
                if(InitBuf[i]=='\0') break;
            }
            return -1;
        }

        if(type==DEF_OBJECT){
            CClass *pobj_c;
            pobj_c=(CClass *)lpIndex;

            for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
                i=GetOneParameter(InitBuf,i,temporary);

                i3=pobj_c->GetMemberOffset( pobj_c->ppobj_Member[i2]->name, NULL );

                if(!SetInitGlobalData(offset+i3,
                    pobj_c->ppobj_Member[i2]->TypeInfo.type,
                    pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
                    pobj_c->ppobj_Member[i2]->SubScripts,
                    temporary)) return 0;

                if(InitBuf[i]=='\0') break;
            }
            if(i2+1!=pobj_c->iMemberNum){
                SetError(41,0,cp);
                return 0;
            }
            return 1;
        }

        SetError(41,0,cp);
        return 0;
    }


    ///////////////////////////////////////
    // 単発式（[]で囲まれていない）
    ///////////////////////////////////////

    if( type == DEF_OBJECT){
        //オブジェクトの場合はありえない
        SetError(300,NULL,cp);
        return 0;
    }

    if(SubScripts[0]!=-1){
        SetError(41,0,cp);
        return 0;
    }

    double dbl;
    _int64 i64data;
    int CalcType;
    LONG_PTR lpCalcIndex;

    CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
    if(!CalcType){
        //動的データだった場合
        return 0;
    }
    if(IsRealNumberType(CalcType)){
        memcpy(&dbl,&i64data,sizeof(double));
        i64data=(_int64)dbl;
    }
    else dbl=(double)i64data;

    //型チェック
    CheckDifferentType(
        type,
        lpIndex,
        CalcType,
        lpCalcIndex,
        0,0);

    if(type==DEF_DOUBLE)
        *(double *)(initGlobalBuf+offset)=(double)dbl;
    else if(type==DEF_SINGLE)
            *(float *)(initGlobalBuf+offset)=(float)dbl;
    else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
        if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
            //文字列定数のとき

            char *temp;
            temp=(char *)i64data;
            i2=dataTable.AddString( temp );
            HeapDefaultFree(temp);

            //mov rax,DataPos
            op_mov_RV(sizeof(_int64),REG_RAX,i2);
            obp-=sizeof(long);
            pobj_DataTableSchedule->add();
            obp+=sizeof(long);

            //mov qword ptr[offset],rax
            op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32);
            obp-=sizeof(long);
            pobj_GlobalVarSchedule->add();
            obp+=sizeof(long);
        }
        else{
            *(_int64 *)(initGlobalBuf+offset)=i64data;
        }
    }
    else if(type==DEF_LONG||type==DEF_DWORD)
        *(DWORD *)(initGlobalBuf+offset)=(DWORD)i64data;
    else if(type==DEF_INTEGER||type==DEF_WORD || (isUnicode&&type==DEF_CHAR))
        *(WORD *)(initGlobalBuf+offset)=(WORD)i64data;
    else if(type==DEF_SBYTE||type==DEF_BYTE||type==DEF_BOOLEAN || (isUnicode==false&&type==DEF_CHAR))
        *(BYTE *)(initGlobalBuf+offset)=(BYTE)i64data;

    return 1;
}
BOOL InitLocalVar(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
    int i,i2,i3,TypeSize;
    char temporary[VN_SIZE];

    if(InitBuf[0]=='['){
        SlideString(InitBuf+1,-1);
        InitBuf[lstrlen(InitBuf)-1]=0;

        TypeSize=GetTypeSize(type,lpIndex);

        if(SubScripts[0]!=-1){
            TypeSize*=JumpSubScripts(SubScripts+1);
            i=0;
            i2=0;
            while(1){
                if(SubScripts[0]<i2){
                    SetError(41,0,cp);
                    return 0;
                }
                i=GetOneParameter(InitBuf,i,temporary);
                if(!InitLocalVar(
                    offset+i2*TypeSize,
                    type,
                    lpIndex,
                    SubScripts+1,
                    temporary)) return 0;
                i2++;
                if(InitBuf[i]=='\0') break;
            }
            return -1;
        }

        if(type==DEF_OBJECT){
            CClass *pobj_c;
            pobj_c=(CClass *)lpIndex;

            for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
                i=GetOneParameter(InitBuf,i,temporary);

                i3=pobj_c->GetMemberOffset( pobj_c->ppobj_Member[i2]->name, NULL );

                if(!InitLocalVar(offset+i3,
                    pobj_c->ppobj_Member[i2]->TypeInfo.type,
                    pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
                    pobj_c->ppobj_Member[i2]->SubScripts,
                    temporary)) return 0;

                if(InitBuf[i]=='\0') break;
            }
            if(i2+1!=pobj_c->iMemberNum){
                SetError(41,0,cp);
                return 0;
            }
            return 1;
        }

        SetError(41,0,cp);
        return 0;
    }


    ///////////////////////////////////////
    // 単発式（[]で囲まれていない）
    ///////////////////////////////////////

    if(SubScripts[0]!=-1){
        SetError(41,0,cp);
        return 0;
    }

    double dbl;
    _int64 i64data;
    int CalcType;
    LONG_PTR lpCalcIndex;
    CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
    if(!CalcType){
        //動的データだった場合
        return 0;
    }
    if(IsRealNumberType(CalcType)){
        memcpy(&dbl,&i64data,sizeof(double));
        i64data=(_int64)dbl;
    }
    else dbl=(double)i64data;

    //型チェック
    CheckDifferentType(
        type,
        lpIndex,
        CalcType,
        lpCalcIndex,
        0,0);

    if(type==DEF_DOUBLE){
        memcpy(&i64data,&dbl,sizeof(double));

        //mov rax,i64data
        op_mov64_ToReg(REG_RAX,i64data);

        //mov qword ptr[rsp+offset],rax
        op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
        obp-=sizeof(long);
        AddLocalVarAddrSchedule();
        obp+=sizeof(long);
    }
    else if(type==DEF_SINGLE){
        float flt;
        flt=(float)dbl;

        //mov dword ptr[rsp+offset],value
        op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,*(int *)&flt);
        obp-=sizeof(long)+sizeof(long);
        AddLocalVarAddrSchedule();
        obp+=sizeof(long)+sizeof(long);
    }
    else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
        if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
            //文字列定数のとき

            char *temp;
            temp=(char *)i64data;
            i2=dataTable.AddString( temp );
            HeapDefaultFree(temp);

            //mov rax,i2
            op_mov_RV(sizeof(_int64),REG_RAX,i2);
            obp-=sizeof(long);
            pobj_DataTableSchedule->add();
            obp+=sizeof(long);

            //mov qword ptr[rsp+offset],rax
            op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
            obp-=sizeof(long);
            AddLocalVarAddrSchedule();
            obp+=sizeof(long);
        }
        else{
            if(i64data&0xFFFFFFFF00000000){
                //mov rax,i64data
                op_mov64_ToReg(REG_RAX,i64data);

                //mov qword ptr[rsp+offset],rax
                op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32);
                obp-=sizeof(long);
                AddLocalVarAddrSchedule();
                obp+=sizeof(long);
            }
            else{
                //mov qword ptr[rsp+offset],value
                op_mov_MV(sizeof(_int64),REG_RSP,offset,USE_OFFSET,(int)i64data);
                obp-=sizeof(long)+sizeof(long);
                AddLocalVarAddrSchedule();
                obp+=sizeof(long)+sizeof(long);
            }
        }
    }
    else if(type==DEF_LONG||type==DEF_DWORD){
        //mov dword ptr[rsp+offset],value
        op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int)i64data);
        obp-=sizeof(long)+sizeof(long);
        AddLocalVarAddrSchedule();
        obp+=sizeof(long)+sizeof(long);
    }
    else if(type==DEF_INTEGER||type==DEF_WORD || (isUnicode&&type==DEF_CHAR)){
        //mov word ptr[rsp+offset],value
        op_mov_MV(sizeof(short),REG_RSP,offset,USE_OFFSET,(int)i64data);
        obp-=sizeof(long)+sizeof(short);
        AddLocalVarAddrSchedule();
        obp+=sizeof(long)+sizeof(short);
    }
    else if(type==DEF_SBYTE||type==DEF_BYTE||type==DEF_BOOLEAN || (isUnicode==false&&type==DEF_CHAR)){
        //mov byte ptr[rsp+offset],value
        op_mov_MV(sizeof(char),REG_RSP,offset,USE_OFFSET,(int)i64data);
        obp-=sizeof(long)+sizeof(char);
        AddLocalVarAddrSchedule();
        obp+=sizeof(long)+sizeof(char);
    }
    return 1;
}


void dim(char *Parameter,DWORD dwFlags){
    extern BOOL bCompilingGlobal;
    extern HANDLE hHeap;
    int i2,i3,VarSize;
    char VarName[VN_SIZE];

    //参照型かどうか
    bool isRef = false;

    i2 = 0;

    if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
        //参照型
        isRef = true;
        Parameter += 2;
    }

    if(dwFlags & DIMFLAG_CONST){

        //////////////////////////////////
        // 定数変数の場合を考慮
        //////////////////////////////////
        for(;;i2++){
            if(Parameter[i2] == '=' ||
                Parameter[i2] == 1 && Parameter[i2] == ESC_AS ||
                Parameter[i2] =='('){
                    VarName[i2] = 0;
                    break;
            }
            VarName[i2] = Parameter[i2];
        }

        //定数と２重定義されていないる場合は抜け出す
        if(CDBConst::obj.GetType(VarName)){
            return;
        }

        //定数マクロとして定義されている場合は抜け出す
        if(GetConstHash(VarName)){
            return;
        }
    }


    //構文を解析
    int SubScripts[MAX_ARRAYDIM];
    TYPEINFO TypeInfo;
    char InitBuf[8192];
    char ConstractParameter[VN_SIZE];
    if(!GetDimentionFormat(Parameter, isRef , VarName,SubScripts,&TypeInfo,InitBuf,ConstractParameter))
        return;


    //定数と２重定義されていないかを調べる
    if(CDBConst::obj.GetType(VarName)){
        SetError(15,VarName,cp);
        return;
    }

    //定数マクロとして定義されている場合
    if(GetConstHash(VarName)){
        SetError(15,VarName,cp);
        return;
    }


    //タイプサイズを取得
    int TypeSize;
    TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);

    if(dwFlags&DIMFLAG_STATIC){
        if(bCompilingGlobal){
            SetError(60,NULL,cp);
            return;
        }

        /////////////////////
        // Static変数
        // ※"Static.Object.Method.Variable"
        /////////////////////

        char temporary[VN_SIZE];
        GetNowStaticVarFullName(VarName,temporary);

        AddGlobalVariable(isRef,temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);

        /*
        Note: 静的変数のコンストラクタ呼び出しは
            _System_InitStaticLocalVariables関数内で一括して行う
        */
    }
    else{
        if(bCompilingGlobal){
            /////////////////////////
            // グローバル変数
            /////////////////////////

            AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
        }
        else{
            /////////////////
            // ローカル変数
            /////////////////

            for(i2=0;i2<MaxLocalVarNum;i2++){
                if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
                    if(lstrcmp(LocalVar[i2].name,VarName)==0){
                        //２重定義のエラー
                        SetError(15,VarName,cp);
                        return;
                    }
                }
            }

            LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
            VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
            MaxLocalVarNum++;

            if( isRef ){
                //参照型
                pVar->fRef = REF_VARIABLE;
                TypeSize = PTR_SIZE;
            }
            else pVar->fRef=0;

            for(i2=1,i3=0;i3<255;i3++){
                //配列要素数
                pVar->SubScripts[i3]=SubScripts[i3];

                if(SubScripts[i3]==-1) break;
                i2*=SubScripts[i3]+1;
            }
            VarSize=TypeSize*i2;
            if(VarSize%8) VarSize+=8-(VarSize%8);

            //変数データを追加
            lstrcpy(pVar->name,VarName);
            if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
            else pVar->bConst = false;
            if(SubScripts[0]==-1) pVar->bArray=0;
            else pVar->bArray=1;
            pVar->type=TypeInfo.type;
            pVar->u.index=TypeInfo.u.lpIndex;
            AllLocalVarSize+=VarSize;
            pVar->offset=AllLocalVarSize;

            //レキシカルスコープ
            pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
            pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
            pVar->bLiving=TRUE;

            if(InitBuf[0]){
                //初期代入時のみ、書き込みアクセスを許可する
                bool bConstBack = pVar->bConst;
                pVar->bConst = false;

                int result = InitLocalVar(-pVar->offset,
                    pVar->type,
                    pVar->u.index,
                    pVar->SubScripts,
                    InitBuf);

                if(!result){
                    //動的な式だった場合は代入演算を行う
                    if( isRef ){
                        SetRefVariable( VarName, InitBuf );
                    }
                    else{
                        char temporary[8192];
                        sprintf(temporary,"%s=%s",VarName,InitBuf);
                        OpcodeCalc(temporary);
                    }
                }

                pVar->bConst = bConstBack;
            }
            else{
                //0初期化

                //mov r8, 0
                op_zero_reg( REG_R8 );

                //mov rdx, VarSize
                op_mov_RV( sizeof(_int64), REG_RDX, VarSize );

                //mov rcx, rsp
                op_mov_RR( REG_RCX, REG_RSP );

                //add rcx, offset
                op_add64_value( REG_RCX, -pVar->offset );
                obp-=sizeof(long);
                AddLocalVarAddrSchedule();
                obp+=sizeof(long);

                //call FillMemory
                DECLAREINFO *pdi;
                pdi=GetDeclareHash("FillMemory");
                op_call( pdi );
            }
        }

        //コンストラクタ呼び出し
        if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
            CallConstructor(VarName,SubScripts,TypeInfo,ConstractParameter);
        }
    }

    if(TypeInfo.type==DEF_OBJECT){
        if(TypeInfo.u.pobj_Class->IsAbstract()){
            //抽象クラスだったとき
            SetError(125,TypeInfo.u.pobj_Class->name,cp);
        }
    }
}
void OpcodeDim(char *Parameter,DWORD dwFlags){
    int i,i2,i3,IsStr=0;
    char temporary[8192];

    for(i=0,i2=0;;i++,i2++){
        if(Parameter[i]=='\"') IsStr^=1;
        if(Parameter[i]=='('&&IsStr==0){
            i3=GetStringInPare(temporary+i2,Parameter+i);
            i+=i3-1;
            i2+=i3-1;
            continue;
        }
        if(Parameter[i]=='['&&IsStr==0){
            i3=GetStringInBracket(temporary+i2,Parameter+i);
            i+=i3-1;
            i2+=i3-1;
            continue;
        }
        if((Parameter[i]==','&&IsStr==0)||
            Parameter[i]=='\0'){
            temporary[i2]=0;

            dim(temporary,dwFlags);

            if(Parameter[i]=='\0') break;
            i2=-1;
            continue;
        }
        temporary[i2]=Parameter[i];
    }
}

void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
    if(!IsGeneralReg(reg)) SetError(300,NULL,cp);

    if(pRelativeVar->dwKind==VAR_GLOBAL){
        if(pRelativeVar->bOffsetOffset){
            //add r11,offset
            OpBuffer[obp++]=(char)0x49;
            OpBuffer[obp++]=(char)0x81;
            OpBuffer[obp++]=(char)0xC3;
            *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
            pobj_GlobalVarSchedule->add();
            obp+=sizeof(long);

            //mov reg,r11
            op_mov64_ToReg_FromReg(reg,REG_R11);
        }
        else{
            //mov reg,offset
            op_mov64_ToReg(reg,(int)pRelativeVar->offset);
            obp-=sizeof(long);
            pobj_GlobalVarSchedule->add();
            obp+=sizeof(long);
        }
    }
    else if( pRelativeVar->dwKind == VAR_REFGLOBAL ){
        if(pRelativeVar->bOffsetOffset){
            //add r11,qword ptr[offset]
            op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelativeVar->offset, MOD_DISP32 );
            obp-=sizeof(long);
            pobj_GlobalVarSchedule->add();
            obp+=sizeof(long);
        }
        else{
            //mov r11,qword ptr[offset]
            op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
            obp-=sizeof(long);
            pobj_GlobalVarSchedule->add();
            obp+=sizeof(long);
        }

        goto directmem;
    }
    else if(pRelativeVar->dwKind==VAR_LOCAL){
        if(pRelativeVar->bOffsetOffset){
            //add r11,offset
            OpBuffer[obp++]=(char)0x49;
            OpBuffer[obp++]=(char)0x81;
            OpBuffer[obp++]=(char)0xC3;
            *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
            AddLocalVarAddrSchedule();
            obp+=sizeof(long);

            //add r11,rsp
            op_add64_reg(REG_R11,REG_RSP);

            //mov reg,r11
            op_mov64_ToReg_FromReg(reg,REG_R11);
        }
        else{
            //mov reg,rsp
            op_mov64_ToReg_FromReg(reg,REG_RSP);

            //add reg,offset
            op_add64_value(reg,(int)pRelativeVar->offset);
            obp-=sizeof(long);
            AddLocalVarAddrSchedule();
            obp+=sizeof(long);
        }
    }
    else if( pRelativeVar->dwKind == VAR_REFLOCAL ){
        if(pRelativeVar->bOffsetOffset){
            //add r11,qword ptr[rsp+offset]
            OpBuffer[obp++]=(char)0x4C;
            OpBuffer[obp++]=(char)0x03;
            OpBuffer[obp++]=(char)0x9C;
            OpBuffer[obp++]=(char)0x24;
            *((long *)(OpBuffer+obp))=(int)pRelativeVar->offset;
            AddLocalVarAddrSchedule();
            obp+=sizeof(long);
        }
        else{
            //mov r11,qword ptr[rsp+offset]
            op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
            obp-=sizeof(long);
            AddLocalVarAddrSchedule();
            obp+=sizeof(long);
        }

        goto directmem;
    }
    else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
directmem:
        //mov reg,r11
        op_mov64_ToReg_FromReg(reg,REG_R11);
    }
}