Changeset 64 in dev for BasicCompiler64


Ignore:
Timestamp:
Mar 8, 2007, 2:49:34 AM (18 years ago)
Author:
dai_9181
Message:

すべてのオブジェクトを参照型に切り替えた。

Location:
BasicCompiler64
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler64/CParameter.cpp

    r63 r64  
    22#include "opcode.h"
    33
    4 void CParameter::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){
     4int CParameter::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){
    55    ///////////////////////////////////////////////////////
    66    // 一時オブジェクトをあらかじめスタックに積んでおく
    77    ///////////////////////////////////////////////////////
     8
     9    int stackItemNum = 0;
    810
    911    useTempObject = false;
    … …  
    6062                int type = NumOpe( &reg, Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
    6163
     64                if( type == DEF_OBJECT ){
     65                    //一時参照を作成
     66                    pobj_sf->push( reg );
     67                    pobj_sf->mov_sp( reg );
     68
     69                    stackItemNum++;
     70                }
     71
    6272                //スタックフレームへコピー
    6373                StackOffsetOfTempObject[i2] = pobj_sf->push(reg);
     74
     75                stackItemNum++;
    6476
    6577                bool result = CheckDifferentType(
    … …  
    8193        }
    8294    }
     95
     96    return stackItemNum * PTR_SIZE;
    8397}
    8498void CParameter::DeleteTempParameters(){
    … …  
    90104    for(int i2=ParmsNum-1;i2>=0;i2--){
    91105        if( useTempParameters[i2] ){
    92             //スタックフレームから取得
    93             pobj_sf->ref(REG_RCX);
    94 
    95             //デストラクタを呼び出す
    96 
    97             //call destructor
    98             CMethod *method = types[i2].u.pobj_Class->GetDestructorMethod();
    99             if( method ){
    100                 op_call( method->psi );
    101             }
    102 
    103             //メモリを解放する
    104 
    105             pobj_sf->pop(REG_RCX);
    106 
    107             //call free
    108             extern SUBINFO *pSub_free;
    109             op_call(pSub_free);
     106            if( types[i2].type == DEF_STRUCT ){
     107                // 構造体の一時メモリ
     108
     109                //メモリを解放する
     110
     111                pobj_sf->pop( REG_RCX );
     112
     113                //call free
     114                extern SUBINFO *pSub_free;
     115                op_call(pSub_free);
     116            }
     117            else if( types[i2].type == DEF_OBJECT ){
     118                pobj_sf->pop();
     119                pobj_sf->pop();
     120            }
     121            else{
     122                SetError(300,NULL,cp);
     123            }
    110124        }
    111125    }
    112126}
    113127
    114 void CParameter::SetObjectParameter(int reg,CClass *pobj_Class,LPSTR Parameter){
     128void CParameter::SetStructParameter(int reg,CClass *pobj_Class,LPSTR Parameter){
    115129    //////////////////////////////////////////////////////
    116130    /////    レジスタ資源のバックアップ
    … …  
    133147        pobj_sf->push(REG_R11);
    134148
    135         TYPEINFO BaseType={DEF_OBJECT,(LONG_PTR)pobj_Class};
     149        TYPEINFO BaseType={DEF_STRUCT,(LONG_PTR)pobj_Class};
    136150        TYPEINFO CalcType;
    137151        CalcType.type=NumOpe_GetType(Parameter,&BaseType,&CalcType.u.lpIndex);
    138152
     153        /*
     154        TODO: 消す
    139155        if( pobj_Class->GetCopyConstructorMethod()
    140156            && CalcType.type==DEF_OBJECT&&CalcType.u.pobj_Class==pobj_Class){
    … …  
    178194                op_call(pobj_Class->GetConstructorMethod()->psi);
    179195            }
     196            */
    180197
    181198
    182199            BOOL bUseHeap;
    183200            int temp_reg=REG_RAX;
    184             CalcType.type=NumOpe(&temp_reg,Parameter,DEF_OBJECT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
     201            CalcType.type=NumOpe(&temp_reg,Parameter,DEF_STRUCT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
    185202
    186203
    … …  
    194211            RelativeVar.dwKind=VAR_DIRECTMEM;
    195212
    196             SetObjectVariableFromRax((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,&RelativeVar,bUseHeap);
    197 
    198         }
     213            SetStructVariableFromRax((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,&RelativeVar,bUseHeap);
     214
     215        //}
    199216
    200217        //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
    … …  
    209226    op_mov_RR(reg,REG_R11);
    210227}
     228
    211229
    212230void CParameter::SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
    … …  
    298316            }
    299317
    300             if(DummyTypeInfo.type==DEF_OBJECT){
    301                 SetObjectParameter(reg,DummyTypeInfo.u.pobj_Class,Parms[i2]);
     318            if(DummyTypeInfo.type==DEF_STRUCT){
     319                SetStructParameter(reg,DummyTypeInfo.u.pobj_Class,Parms[i2]);
    302320                goto next;
    303321            }
    … …  
    318336
    319337            if(CalcType==DEF_OBJECT){
    320                 //キャスト演算子のオーバーロードに対応する
    321                 CallCastOperatorProc(reg,CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
     338                if( DummyTypeInfo.type != DEF_OBJECT
     339                    ||
     340                    DummyTypeInfo.type == DEF_OBJECT &&
     341                    !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpCalcIndex ) ){
     342                        //キャスト演算子のオーバーロードに対応する
     343                        CallCastOperatorProc(reg,CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
     344                }
    322345            }
    323346
    … …  
    419442                                    }
    420443                                }
     444                                else if(DummyTypeInfo.type==DEF_STRUCT){
     445                                    if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
     446                                        SetError(11,Parms[i2],cp);
     447                                    }
     448                                }
    421449                            }
    422450                            else if((VarType&FLAG_PTR)&&((VarType^FLAG_PTR)==DummyTypeInfo.type)){
    … …  
    442470            }
    443471        }
     472
    444473next:
     474
    445475        if(reg==REG_RAX){
    446476            //スタックフレームへコピー

  • BasicCompiler64/CommandValue.h

    r3 r64  
    1919#define COM_LET     0x1066
    2020#define COM_DELETE  0x1068
     21#define COM_SWEEPINGDELETE  0x1069
    2122
    2223//その他

  • BasicCompiler64/Compile_Calc.cpp

    r62 r64  
    1111        SetBooleanVariable(CalcType,pRelativeVar);
    1212    }
    13     else if(VarType==DEF_SBYTE||VarType==DEF_BYTE || (isUnicode==false&&VarType==DEF_CHAR)){
    14         //8ビット変数へalレジスタの内容を格納する
    15         SetWholeVariable(sizeof(char),CalcType,pRelativeVar);
    16     }
    17     else if(VarType==DEF_INTEGER||VarType==DEF_WORD || (isUnicode&&VarType==DEF_CHAR)){
    18         //16ビット変数へaxレジスタの内容を格納する
    19         SetWholeVariable(sizeof(short),CalcType,pRelativeVar);
    20     }
    21     else if(VarType==DEF_LONG||VarType==DEF_DWORD){
    22         //32ビット変数へeaxレジスタの内容を格納する
    23         SetWholeVariable(sizeof(long),CalcType,pRelativeVar);
    24     }
    25     else if(VarType==DEF_INT64||VarType==DEF_QWORD||IsPtrType(VarType)){
    26         //64ビット変数へraxレジスタの内容を格納する
    27         SetWholeVariable(sizeof(_int64),CalcType,pRelativeVar);
    28     }
    29     else if(VarType==DEF_DOUBLE){
    30         //Double型変数へスタックの内容を格納する
    31         SetDoubleVariable(CalcType,pRelativeVar);
    32     }
    33     else if(VarType==DEF_SINGLE){
    34         //Single型変数へスタックの内容を格納する
    35         SetSingleVariable(CalcType,pRelativeVar);
     13    else if( IsRealNumberType( VarType ) ){
     14        // Double/Single型変数へレジスタの値を代入
     15        SetRealVariable(VarType, CalcType, pRelativeVar);
     16    }
     17    else if( IsWholeNumberType( VarType ) || VarType == DEF_OBJECT ){
     18        int typeSize = GetTypeSize( VarType, -1 );
     19
     20        //整数変数へraxの値を格納する
     21        SetWholeVariable( typeSize, CalcType, pRelativeVar );
    3622    }
    3723    else{
    … …  
    165151
    166152
     153    if( lstrcmpi( variable, "This" ) == 0 ){
     154        SetError(133,NULL,cp);
     155        return;
     156    }
     157
    167158
    168159    ////////////////////////////////////////
    … …  
    195186    CalcType=NumOpe(&reg,Command+i+1,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
    196187
     188    if(reg!=REG_RAX&&IsWholeNumberType(CalcType)){
     189        SetError(300,NULL,cp);
     190    }
     191
     192    if(VarType==-1||CalcType==-1) return;
     193
    197194    //結果を格納しているレジスタをブロッキング
    198195    pobj_BlockReg->lock(reg);
    199 
    200     if(VarType==-1||CalcType==-1) return;
    201196
    202197    //変数アドレスを取得
    … …  
    206201        &VarType,
    207202        &VarRelativeVar,
    208         &lpVarIndex)) return;
     203        &lpVarIndex,
     204        NULL)) return;
    209205
    210206    //レジスタのブロッキングを解除
    … …  
    216212    }
    217213
    218     if(VarType==DEF_OBJECT){
    219         //オブジェクトインスタンスへの代入
    220         SetObjectVariableFromRax(lpVarIndex,CalcType,lpCalcIndex,&VarRelativeVar,bCalcUseHeap);
    221         return;
    222     }
    223 
    224     if(CalcType==DEF_OBJECT){
     214    if(VarType==DEF_STRUCT ){
     215        //構造体インスタンスへの代入
     216        SetStructVariableFromRax(lpVarIndex,CalcType,lpCalcIndex,&VarRelativeVar,bCalcUseHeap);
     217        return;
     218    }
     219
     220    if(CalcType==DEF_OBJECT && (CalcType!=VarType || lpCalcIndex!=lpVarIndex) ){
    225221        //キャスト演算子のオーバーロードに対応する
    226222        CallCastOperatorProc(REG_RAX,CalcType,lpCalcIndex,bCalcUseHeap,VarType,lpVarIndex);
    … …  
    241237}
    242238
     239// TODO: 消す
     240/*
    243241void SetRefVariable( const char *varname, const char *expression ){
    244242    ////////////////////////////////////////
    … …  
    320318    SetVariableFromRax(VarType,CalcType,&VarRelativeVar);
    321319}
     320*/

  • BasicCompiler64/Compile_CallProc.cpp

    r63 r64  
    1212
    1313    //mov rdx,rax
    14     op_mov64_ToReg_FromReg(REG_RDX,REG_RAX);
     14    op_mov_RR(REG_RDX,REG_RAX);
    1515
    1616    //mov rcx,rsp
    17     op_mov64_ToReg_FromReg(REG_RCX,REG_RSP);
     17    op_mov_RR(REG_RCX,REG_RSP);
    1818
    1919    //call _DebugSys_SaveContext
    … …  
    9696}
    9797
    98 void Opcode_CallProc(char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType){
     98void Opcode_CallProc(const char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType){
    9999    int i2;
    100100
    … …  
    207207
    208208    ///////////////////////////////////////////////////////////////
    209     // _System_LocalThis、_System_ReturnObjectのダミーをセット
     209    // _System_LocalThisのダミーをセット
    210210    ///////////////////////////////////////////////////////////////
    211211
    … …  
    216216    }
    217217
    218     if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false ){
    219         //_System_ReturnObject（第一または第二パラメータのダミーを作成）
    220         sprintf(temporary+lstrlen(temporary),"%c%c0,",1,ESC_BYVAL);
    221     }
    222 
    223218    if(Parameter[0]=='\0'&&temporary[0])
    224219        temporary[lstrlen(temporary)-1]=0;
    225220    else lstrcat(temporary,Parameter);
     221
     222
     223    //パラメータセット前のspオフセットを取得（Newの場合はここにThisポインタが格納されている）
     224    int this_sp_offset = pobj_sf->GetNowSp();
    226225
    227226
    … …  
    254253    pobj_parameter->SetParameter(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum);
    255254
    256 
    257     if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
     255    if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
    258256        //////////////////////////////////////////////////////
    259         // 戻り値にオブジェクト インスタンスを持つ場合
    260         // ※ByRef _System_ReturnObject パラメータをセット
     257        // 戻り値に構造体インスタンスを持つ場合
     258        // ※ByRef _System_ReturnValue パラメータをセット
    261259        //////////////////////////////////////////////////////
    262260
    … …  
    316314                SetVarPtrToReg(REG_RCX,&RelativeVar);
    317315
    318                 //参照タイプが "->" の場合
    319                 if(RefType==DEF_PTR_OBJECT){
    320                     //mov rcx,qword ptr[rcx]
    321                     op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
    322                 }
     316                // 参照を実体ポインタにする
     317                //mov rcx,qword ptr[rcx]
     318                op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
    323319            }
    324320        }
    … …  
    329325
    330326                //mov rcx,qword ptr[rsp+offset]     ※スタックフレームを利用
    331                 pobj_sf->ref(REG_RCX);
     327                pobj_sf->ref_offset_data(REG_RCX, this_sp_offset);
    332328            }
    333329            else{

  • BasicCompiler64/Compile_Func.cpp

    r51 r64  
    6262
    6363    TYPEINFO TypeInfo={type,lpIndex};
    64     if(IsStringObjectType(&TypeInfo)){
     64    if(IsStringObjectType(TypeInfo)){
    6565        //Stringオブジェクトの場合
    6666        sprintf(temporary,"%s.Length",tempParm);
    … …  
    195195}
    196196void Opcode_Func_SizeOf( const char *Parameter ){
    197     int type,size;
    198197    LONG_PTR lpIndex;
    199 
    200     type=GetTypeFixed(Parameter,&lpIndex);
    201     size=GetTypeSize(type,lpIndex);
     198    int type = GetTypeFixed(Parameter,&lpIndex);
     199
     200    int size;
     201    if( type == DEF_OBJECT ){
     202        CClass *pClass = (CClass *)lpIndex;
     203        size = pClass->GetSize();
     204    }
     205    else{
     206        size=GetTypeSize(type,lpIndex);
     207    }
    202208
    203209    //mov rax,size
    … …  
    210216    if(!GetVarOffsetReadOnly( Parameter, &ReturnTypeInfo.type, &RelativeVar, &ReturnTypeInfo.u.lpIndex )) return;
    211217
     218    int beforeType = ReturnTypeInfo.type;
     219
    212220    PTR_LEVEL_UP( ReturnTypeInfo.type );
    213221
    214222    SetVarPtrToReg(REG_RAX,&RelativeVar);
     223
     224    if( beforeType == DEF_OBJECT && lstrcmpi( Parameter, "This" ) != 0 ){
     225        //参照をオブジェクトポインタに変更
     226
     227        //mov rax,qword ptr[rax]
     228        op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
     229    }
    215230}
    216231void Opcode_Func_GetPtrData( const char *Parameter, const int type ){

  • BasicCompiler64/Compile_Object.cpp

    r51 r64  
    22#include "opcode.h"
    33
    4 void _call_constructor(CClass *pobj_c,char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
     4void _call_constructor(CClass *pobj_c,const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
    55    ////////////////////////////
    66    // コンストラクタの呼び出し
    … …  
    7373    }
    7474}
    75 int Operator_New(const char *Parameter,LONG_PTR *plpIndex){
    76     char TypeName[VN_SIZE],CreateParameter[VN_SIZE],ObjectSize[VN_SIZE];
     75void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter, const TYPEINFO &baseTypeInfo ){
     76    int typeSize = classObj.GetSize();
     77
     78    if(classObj.IsAbstract()){
     79        //抽象クラスだったとき
     80        SetError(125,classObj.name,cp);
     81    }
     82
     83    BOOL bSomeObjects=0;
     84    if(objectSizeStr[0]){
     85        bSomeObjects=1;
     86
     87        int reg=REG_RAX;
     88        int type = NumOpe(&reg,objectSizeStr,0,0,0);
     89        if(!IsWholeNumberType(type)) SetError(49,NULL,cp);
     90
     91        //※添え字上限値であることを考慮
     92        //add rax,1
     93        op_add_RV(REG_RAX,1);
     94
     95        //オブジェクトの個数をrbxに一時保持
     96        //※rbxは関数が呼ばれても不変
     97        //mov rbx,rax
     98        op_mov_RR(REG_RBX,REG_RAX);
     99
     100        //imul rax,size
     101        op_imul_RV(sizeof(_int64),REG_RAX,typeSize);
     102
     103        //add rax,PTR_SIZE*3
     104        op_add_RV(REG_RAX,PTR_SIZE*3);
     105
     106        //mov rcx,rax
     107        op_mov_RR(REG_RCX,REG_RAX);
     108    }
     109    else{
     110        //オブジェクトの個数をrbxに一時保持
     111        //※rbxは関数が呼ばれても不変
     112        //mov rbx,1
     113        op_mov_RV(sizeof(_int64),REG_RBX,1);
     114
     115        //mov rcx,typeSize+PTR_SIZE*3
     116        op_mov_RV(sizeof(_int64),REG_RCX,typeSize+PTR_SIZE*3);
     117    }
     118
     119    if( baseTypeInfo.type == DEF_OBJECT ){
     120        //DeleteはGCで処理
     121
     122        //call _System_GC_malloc_ForObject
     123        extern SUBINFO *pSub_System_GC_malloc_ForObject;
     124        op_call(pSub_System_GC_malloc_ForObject);
     125    }
     126    else{
     127        //明示的なDeleteが必要
     128
     129        //call _System_GC_malloc_ForObjectPtr
     130        extern SUBINFO *pSub_System_GC_malloc_ForObjectPtr;
     131        op_call(pSub_System_GC_malloc_ForObjectPtr);
     132    }
     133
     134
     135    /*
     136    確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
     137    pPtr-=sizeof(DWORD)*3
     138    pPtr[0]=オブジェクトの個数
     139    pPtr[1]=オブジェクトのサイズ
     140    pPtr[2]=デストラクタの関数ポインタ
     141    */
     142
     143
     144    //mov qword ptr[rax],rbx（オブジェクトの個数）
     145    op_mov_MR(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);
     146
     147    //add rax,PTR_SIZE
     148    op_add_RV(REG_RAX,PTR_SIZE);
     149
     150
     151    //mov qword ptr[rax],typeSize（オブジェクトのサイズ）
     152    op_mov_MV(sizeof(_int64),REG_RAX,0,NON_OFFSET,typeSize);
     153
     154    //add rax,PTR_SIZE
     155    op_add_RV(REG_RAX,PTR_SIZE);
     156
     157
     158    CMethod *method = classObj.GetDestructorMethod();
     159    if( method == NULL ) return;
     160
     161    //mov rcx,DestructorProcAddr
     162    op_mov_RV(sizeof(_int64),REG_RCX,0);
     163    obp-=sizeof(long);
     164    pobj_SubAddrSchedule->add(method->psi,0);
     165    method->psi->bUse=1;
     166    obp+=sizeof(long);
     167
     168    //mov qword ptr[rax],rcx
     169    op_mov_MR(sizeof(_int64),REG_RCX,REG_RAX,0,MOD_BASE);
     170
     171    //add rax,PTR_SIZE
     172    op_add_RV(REG_RAX,PTR_SIZE);
     173
     174
     175    // ※ここでプッシュされた値はNew演算子の戻り値となる
     176    //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
     177    pobj_sf->push(REG_RAX);
     178
     179
     180    /////////////////////////////////////////////////////////////////////
     181
     182    ////////////////////////////
     183    // コンストラクタの呼び出し
     184    ////////////////////////////
     185
     186    _call_constructor(&classObj,parameter,typeSize,bSomeObjects);
     187
     188
     189    //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
     190    pobj_sf->pop(REG_RAX);
     191}
     192int Operator_New(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo ){
     193    char TypeName[VN_SIZE],CreateParameter[VN_SIZE],objectSizeStr[VN_SIZE];
    77194    int i,i2;
    78     int reg;
    79195
    80196    i=0;
    81197
    82198    if(Parameter[0]=='['){
    83         i=GetStringInBracket(ObjectSize,Parameter);
    84 
    85         SlideString(ObjectSize+1,-1);
    86         ObjectSize[i-2]=0;
    87     }
    88     else ObjectSize[0]=0;
     199        i=GetStringInBracket(objectSizeStr,Parameter);
     200
     201        SlideString(objectSizeStr+1,-1);
     202        objectSizeStr[i-2]=0;
     203    }
     204    else objectSizeStr[0]=0;
    89205
    90206    for(i2=0;;i++,i2++){
    … …  
    109225    }
    110226
    111     int type,TypeSize;
     227    int type;
    112228    type=GetTypeFixed(TypeName,plpIndex);
    113229    if(type==-1){
    … …  
    115231        return 0;
    116232    }
    117     TypeSize=GetTypeSize(type,*plpIndex);
    118233
    119234    if(type!=DEF_OBJECT){
    … …  
    129244    pobj_c=(CClass *)*plpIndex;
    130245
    131     if(pobj_c->IsAbstract()){
    132         //抽象クラスだったとき
    133         SetError(125,pobj_c->name,cp);
    134     }
    135 
    136     BOOL bSomeObjects=0;
    137     if(ObjectSize[0]){
    138         bSomeObjects=1;
    139 
    140         reg=REG_RAX;
    141         i2=NumOpe(&reg,ObjectSize,0,0,0);
    142         if(!IsWholeNumberType(i2)) SetError(49,NULL,cp);
    143 
    144         //※添え字上限値であることを考慮
    145         //add rax,1
    146         op_add64_value(REG_RAX,1);
    147 
    148         //オブジェクトの個数をrbxに一時保持
    149         //※rbxは関数が呼ばれても不変
    150         //mov rbx,rax
    151         op_mov64_ToReg_FromReg(REG_RBX,REG_RAX);
    152 
    153         //imul rax,size
    154         op_imul_value(sizeof(_int64),REG_RAX,TypeSize);
    155 
    156         //add rax,PTR_SIZE*3
    157         op_add64_value(REG_RAX,PTR_SIZE*3);
    158 
    159         //mov rcx,rax
    160         op_mov64_ToReg_FromReg(REG_RCX,REG_RAX);
    161     }
    162     else{
    163         //オブジェクトの個数をrbxに一時保持
    164         //※rbxは関数が呼ばれても不変
    165         //mov rbx,1
    166         op_mov_RV(sizeof(_int64),REG_RBX,1);
    167 
    168         //mov rcx,TypeSize+PTR_SIZE*3
    169         op_mov_RV(sizeof(_int64),REG_RCX,TypeSize+PTR_SIZE*3);
    170     }
    171 
    172     //call calloc
    173     extern SUBINFO *pSub_calloc;
    174     op_call(pSub_calloc);
    175 
    176 
    177     /*
    178     確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
    179     pPtr-=sizeof(DWORD)*3
    180     pPtr[0]=オブジェクトの個数
    181     pPtr[1]=オブジェクトのサイズ
    182     pPtr[2]=デストラクタの関数ポインタ
    183     */
    184 
    185 
    186     //mov qword ptr[rax],rbx（オブジェクトの個数）
    187     op_mov_MR(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);
    188 
    189     //add rax,PTR_SIZE
    190     op_add64_value(REG_RAX,PTR_SIZE);
    191 
    192 
    193     //mov qword ptr[rax],TypeSize（オブジェクトのサイズ）
    194     op_mov_MV(sizeof(_int64),REG_RAX,0,NON_OFFSET,TypeSize);
    195 
    196     //add rax,PTR_SIZE
    197     op_add64_value(REG_RAX,PTR_SIZE);
    198 
    199 
    200     CMethod *method = pobj_c->GetDestructorMethod();
    201     if( method == NULL ) return 0;
    202 
    203     //mov rcx,DestructorProcAddr
    204     op_mov_RV(sizeof(_int64),REG_RCX,0);
    205     obp-=sizeof(long);
    206     pobj_SubAddrSchedule->add(method->psi,0);
    207     method->psi->bUse=1;
    208     obp+=sizeof(long);
    209 
    210     //mov qword ptr[rax],rcx
    211     op_mov_MR(sizeof(_int64),REG_RCX,REG_RAX,0,MOD_BASE);
    212 
    213     //add rax,PTR_SIZE
    214     op_add64_value(REG_RAX,PTR_SIZE);
    215 
    216 
    217     // ※ここでプッシュされた値はNew演算子の戻り値となる
    218     //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
    219     pobj_sf->push(REG_RAX);
    220 
    221 
    222     /////////////////////////////////////////////////////////////////////
    223 
    224     ////////////////////////////
    225     // コンストラクタの呼び出し
    226     ////////////////////////////
    227 
    228     _call_constructor(pobj_c,CreateParameter,TypeSize,bSomeObjects);
    229 
    230 
    231     //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
    232     pobj_sf->pop(REG_RAX);
    233 
     246    Operator_New( *pobj_c, objectSizeStr, CreateParameter, baseTypeInfo );
     247
     248    if( baseTypeInfo.type == DEF_OBJECT ){
     249        return DEF_OBJECT;
     250    }
    234251    return DEF_PTR_OBJECT;
    235252}
    236253
    237 void OpcodeDelete(const char *Parameter){
     254void OpcodeDelete(const char *Parameter, bool isSweeping){
    238255    int type;
    239256
    … …  
    254271
    255272    //add rax,PTR_SIZE
    256     op_add64_value(REG_RAX,PTR_SIZE);
     273    op_add_RV(REG_RAX,PTR_SIZE);
    257274
    258275
    … …  
    261278
    262279    //add rax,PTR_SIZE
    263     op_add64_value(REG_RAX,PTR_SIZE);
     280    op_add_RV(REG_RAX,PTR_SIZE);
    264281
    265282
    … …  
    268285
    269286    //add rax,PTR_SIZE
    270     op_add64_value(REG_RAX,PTR_SIZE);
     287    op_add_RV(REG_RAX,PTR_SIZE);
    271288
    272289
    273290    //mov rcx,rax
    274     op_mov64_ToReg_FromReg(REG_RCX,REG_RAX);
     291    op_mov_RR(REG_RCX,REG_RAX);
    275292
    276293
    … …  
    279296    jnz_back=obp;
    280297
    281     //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
    282     pobj_sf->push(REG_RAX);
     298    //mov qword ptr[rsp+offset],rcx     ※スタックフレームを利用
     299    pobj_sf->push(REG_RCX);
    283300
    284301    //call rdi
    … …  
    309326    pobj_sf->pop(REG_RCX);
    310327
    311     //call free
    312     extern SUBINFO *pSub_free;
    313     op_call(pSub_free);
     328    if( isSweeping ){
     329        //call _System_GC_free_for_SweepingDelete
     330        extern SUBINFO *pSub_System_GC_free_for_SweepingDelete;
     331        op_call(pSub_System_GC_free_for_SweepingDelete);
     332    }
     333    else{
     334        //call free
     335        extern SUBINFO *pSub_free;
     336        op_call(pSub_free);
     337    }
    314338}

  • BasicCompiler64/Compile_ProcOp.cpp

    r63 r64  
    5151
    5252        //add rsp,スタックフレームサイズ
    53         op_add64_value(REG_RSP,pobj_sf->GetFrameSize());
     53        op_add_RV(REG_RSP,pobj_sf->GetFrameSize());
    5454
    5555        //スタックフレームスケジュール（subコマンドに渡す値）
    … …  
    9494
    9595        //add rsp,スタックフレームサイズ
    96         op_add64_value(REG_RSP,pobj_sf->GetFrameSize());
     96        op_add_RV(REG_RSP,pobj_sf->GetFrameSize());
    9797
    9898        //スタックフレームスケジュール（subコマンドに渡す値）
    … …  
    118118
    119119        //add rsp,8
    120         op_add64_value(REG_RSP,0x8);
     120        op_add_RV(REG_RSP,0x8);
    121121
    122122        //ret
    … …  
    128128
    129129        //add rax,PTR_SIZE
    130         op_add64_value(REG_RAX,PTR_SIZE);
     130        op_add_RV(REG_RAX,PTR_SIZE);
    131131
    132132        //ret
    … …  
    337337
    338338        LocalVar[MaxLocalVarNum].type=psi->pRealParmInfo[i3].type;
    339         if(LocalVar[MaxLocalVarNum].type==DEF_OBJECT){
    340             if(psi->bExport)
    341                 SetError(24,NULL,cp);
     339        if(LocalVar[MaxLocalVarNum].type==DEF_OBJECT
     340            ||LocalVar[MaxLocalVarNum].type==DEF_STRUCT){
     341                if(psi->bExport)
     342                    SetError(24,NULL,cp);
    342343        }
    343344
    344345        LocalVar[MaxLocalVarNum].u.index=psi->pRealParmInfo[i3].u.index;
    345346
    346         if(psi->pRealParmInfo[i3].bByVal&&psi->pRealParmInfo[i3].type==DEF_OBJECT){
    347             //実態オブジェクトのByValパラメータ
     347        if(psi->pRealParmInfo[i3].bByVal&&psi->pRealParmInfo[i3].type==DEF_STRUCT){
     348            //構造体のByValパラメータ
    348349            LocalVar[MaxLocalVarNum].fRef=REF_PARAMETER | OBJECT_PARAMETER;
    349350            VarSize=PTR_SIZE;
    … …  
    457458    BaseLocalVar=AllLocalVarSize;
    458459
    459     if(psi->ReturnType!=-1){
     460    if(psi->ReturnType!=DEF_NON){
    460461        //戻り値が存在するとき
    461462
    … …  
    464465        else temp=psi->name;
    465466
    466         if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
    467             //戻り値用オブジェクトのコンストラクタを呼び出す
    468             if( psi->u.Return_pobj_c->GetConstructorMethod() ){
    469                 sprintf(temporary,"%s.%s()",temp,psi->u.Return_pobj_c->name);
    470                 OpcodeOthers(temporary);
    471             }
     467        if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
     468            //戻り値用の構造体（値型）はパラメータで引き渡される
    472469        }
    473470        else{
    … …  
    493490
    494491        //mov rcx,rsp
    495         op_mov64_ToReg_FromReg(REG_RCX,REG_RSP);
     492        op_mov_RR(REG_RCX,REG_RSP);
    496493
    497494        //add rcx,スタックフレームサイズ+sizeof(_int64) ※ret用のサイズを考慮
    498         op_add64_value(REG_RCX,0);
     495        op_add_RV(REG_RCX,0);
    499496        RspOffsetSchedule2=obp-sizeof(long);
    500497
    … …  
    571568            for(i3=0;i3<pobj_CompilingClass->iMemberNum;i3++){
    572569                CMember *pMember = pobj_CompilingClass->ppobj_Member[i3];
    573                 int MemberTypeSize=
    574                     GetTypeSize(pMember->TypeInfo.type,
    575                         pMember->TypeInfo.u.lpIndex);
    576 
    577                 int MemberObjectNum=
    578                     JumpSubScripts(pMember->SubScripts);
    579 
    580                 int offset = pobj_CompilingClass->GetMemberOffset( pMember->name, NULL );
    581 
    582                 if(pMember->TypeInfo.type==DEF_OBJECT && pMember->IsRef() == false){
    583                     CMethod *method = pMember->TypeInfo.u.pobj_Class->GetConstructorMethod();
    584                     if( method ){
    585                         if( method->psi->RealParmNum == 1 ){    //Thisポインタを第一引数に持ち合わせるため、引数なしの場合はこの値が1になる
    586                             for(i4=0;i4<MemberObjectNum;i4++){
    587                                 //Thisポインタをrcxにコピー
    588                                 SetThisPtrToReg(REG_RCX);
    589 
    590                                 //add rcx,offset
    591                                 op_add64_value(REG_RCX,offset+i4*MemberTypeSize);
    592 
    593                                 //call constructor
    594                                 op_call( method->psi );
    595                             }
    596                         }
    597                     }
     570                if(pMember->TypeInfo.type==DEF_OBJECT){
     571                    // オブジェクトメンバを発見したとき
     572
     573                    sprintf(temporary, "This.%s=%c%c%s()",
     574                        pMember->name,
     575                        1, ESC_NEW,
     576                        pMember->TypeInfo.u.pobj_Class->name );
     577                    OpcodeCalc( temporary );
    598578                }
    599579            }
    … …  
    665645            }
    666646
    667             //実体クラスを持つメンバのデストラクタを呼び出す
     647            //実体クラスを持つメンバのデストラクタ呼び出しはGCに任せる
     648            /*
    668649            //※コンストラクタと逆順序で呼び出す
    669650            for(i3=pobj_CompilingClass->iMemberNum-1;i3>=0;i3--){
    … …  
    678659                int offset = pobj_CompilingClass->GetMemberOffset( pMember->name, NULL );
    679660
    680                 if(pMember->TypeInfo.type==DEF_OBJECT && pMember->IsRef() == false){
     661                if(pMember->TypeInfo.type==DEF_OBJECT){
    681662                    CMethod *method = pMember->TypeInfo.u.pobj_Class->GetDestructorMethod();
    682663                    if( method ){
    … …  
    686667
    687668                            //add rcx,offset
    688                             op_add64_value(REG_RCX,offset+i4*MemberTypeSize);
     669                            op_add_RV(REG_RCX,offset+i4*MemberTypeSize);
    689670
    690671                            //call destructor
    … …  
    693674                    }
    694675                }
    695             }
     676            }*/
    696677        }
    697678    }
    … …  
    743724    }
    744725
    745     if(psi->ReturnType!=-1){
     726    if(psi->ReturnType!=DEF_NON){
    746727        //////////////////////////////////
    747728        // 戻り値をraxまたはxmm0に設定
    … …  
    759740        i3=psi->ReturnType;
    760741
    761         if(i3==DEF_OBJECT){
     742        if(i3==DEF_OBJECT || i3==DEF_STRUCT){
    762743            SetVarPtrToReg(REG_RAX,&RelativeVar);
     744            if( i3==DEF_OBJECT ){
     745                //mov rax,qword ptr[rax]
     746                op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
     747            }
    763748        }
    764749        else if(i3==DEF_DOUBLE){

  • BasicCompiler64/Compile_Set_Var.cpp

    r63 r64  
    77}
    88
    9 void SetObjectVariableFromRax(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,RELATIVE_VAR *pRelativeVar,BOOL bUseHeap){
     9void SetStructVariableFromRax(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,RELATIVE_VAR *pRelativeVar,BOOL bUseHeap){
    1010    int RightTermReg;
    1111    pobj_reg=new CRegister(REG_RCX);
    … …  
    3636    }
    3737
    38 
     38/*
     39    TODO: 消す
    3940    ///////////////////////////////////////////////////////////////////
    4041    // オペレータ '=' のオーバーロード関数を呼ぶ
    … …  
    5960    int iRet;
    6061    iRet=CallOperatorProc(CALC_SUBSITUATION,NULL,type,index_stack,array_bUseHeap,sp);
    61 
     62*/
    6263    //右辺用レジスタを解除
    6364    if(IsRealNumberType(CalcType)) pobj_reg->UnlockXmmReg();
    … …  
    7172    pobj_reg=0;
    7273
    73     if(iRet==-1||iRet==1){
    74         //成功したとき、またはエラーが発行されたとき
    75         return;
    76     }
    77 
    78 
    79     if( CalcType == DEF_OBJECT ){
     74
     75    if( CalcType == DEF_STRUCT ){
    8076        CClass *pVarClass = (CClass *)lpVarIndex;
    8177        CClass *pCalcClass = (CClass *)lpCalcIndex;
    8278
    83         if( pVarClass->IsEquals( pCalcClass )           //等しい
    84             || pVarClass->IsSubClass( pCalcClass ) ){   //派生・継承関係
     79        if( pVarClass->IsEquals( pCalcClass ) ){            //等しい
    8580
    8681                //双方のオブジェクト型が一致、または派生・継承関係にあるとき
    … …  
    122117    SetError(1,NULL,cp);
    123118}
     119
    124120
    125121void SetDoubleVariable(int type,RELATIVE_VAR *pRelative){
    … …  
    305301    }
    306302}
     303void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar){
     304    if(VarType==DEF_DOUBLE){
     305        //Double型変数へスタックの内容を格納する
     306        SetDoubleVariable(CalcType,pRelativeVar);
     307    }
     308    else if(VarType==DEF_SINGLE){
     309        //Single型変数へスタックの内容を格納する
     310        SetSingleVariable(CalcType,pRelativeVar);
     311    }
     312}
    307313void SetBooleanVariable(int type,RELATIVE_VAR *pRelative){
    308314    if(type==DEF_DOUBLE){

  • BasicCompiler64/Compile_Statement.cpp

    r56 r64  
    9999        /////////////////////
    100100
    101         if(i2==DEF_OBJECT){
     101        if(i2==DEF_STRUCT){
    102102            //mov r14,rax
    103103            op_mov_RR(REG_R14,REG_RAX);
    … …  
    888888    //add rax,offset（Gosubステートメントの最終ポイント）
    889889    int schedule=obp,schedule2;
    890     op_add64_value(REG_RAX,0);
     890    op_add_RV(REG_RAX,0);
    891891    schedule2=obp-sizeof(long);
    892892
    … …  
    951951            else temp=pCompilingSubInfo->name;
    952952
     953            /*
     954            TODO: 消す
    953955            if( pCompilingSubInfo->isReturnRef ){
    954956                //参照型
    … …  
    956958            }
    957959            else{
    958                 //値型
     960                //値型*/
    959961                char temporary[VN_SIZE];
    960962                sprintf(temporary,"%s=%s",temp,Parameter);
    961963                OpcodeCalc(temporary);
    962             }
     964            //}
    963965        }
    964966
    … …  
    968970}
    969971
    970 void Opcode_Input(char *Parameter){
     972void Opcode_Input(const char *Parameter){
    971973    extern int cp;
    972974    int i2,i3,i4,i5,type;
    973975    BOOL bFile;
    974976    char temporary[VN_SIZE],temp2[VN_SIZE],buffer[VN_SIZE];
    975 
    976     KillStringSpaces(Parameter);
    977977
    978978    if(Parameter[0]=='#'){
    … …  
    10841084    Opcode_CallProc(buffer,psi,0,"",0);
    10851085}
    1086 void Opcode_PrintUsing(char *Parameter,char *buffer,BOOL bFile){
     1086void Opcode_PrintUsing(const char *Parameter,char *buffer,BOOL bFile){
    10871087    extern int cp;
    10881088    int i2,i3,i4,i5;
    … …  
    10901090    BOOL bReturnLine;
    10911091
    1092     i2=lstrlen(Parameter);
    1093     if(Parameter[i2-1]==';'){
     1092    char parms[8192];
     1093    lstrcpy( parms, Parameter );
     1094
     1095    i2=lstrlen(parms);
     1096    if(parms[i2-1]==';'){
    10941097        bReturnLine=0;
    1095         Parameter[i2-1]=0;
     1098        parms[i2-1]=0;
    10961099    }
    10971100    else bReturnLine=1;
    … …  
    10991102    i3=lstrlen(buffer);
    11001103    for(i2=0;;i2++,i3++){
    1101         if(Parameter[i2]==';'){
     1104        if(parms[i2]==';'){
    11021105            buffer[i3]=0;
    11031106            break;
    11041107        }
    1105         buffer[i3]=Parameter[i2];
    1106         if(Parameter[i2]=='\0') break;
    1107     }
    1108     if(Parameter[i2]==';') i2++;
     1108        buffer[i3]=parms[i2];
     1109        if(parms[i2]=='\0') break;
     1110    }
     1111    if(parms[i2]==';') i2++;
    11091112
    11101113    if(bReturnLine) lstrcat(buffer,"+Ex\"\\r\\n\"");
    … …  
    11141117    while(1){
    11151118        for(i3=0;;i2++,i3++){
    1116             if(Parameter[i2]=='\"'){
    1117                 temporary[i3]=Parameter[i2];
     1119            if(parms[i2]=='\"'){
     1120                temporary[i3]=parms[i2];
    11181121                for(i2++,i3++;;i2++,i3++){
    1119                     temporary[i3]=Parameter[i2];
    1120                     if(Parameter[i2]=='\"') break;
     1122                    temporary[i3]=parms[i2];
     1123                    if(parms[i2]=='\"') break;
    11211124                }
    11221125                continue;
    11231126            }
    1124             if(Parameter[i2]=='('){
    1125                 i5=GetStringInPare(temporary+i3,Parameter+i2);
     1127            if(parms[i2]=='('){
     1128                i5=GetStringInPare(temporary+i3,parms+i2);
    11261129                i2+=i5-1;
    11271130                i3+=i5-1;
    11281131                continue;
    11291132            }
    1130             if(Parameter[i2]=='['){
    1131                 i5=GetStringInBracket(temporary+i3,Parameter+i2);
     1133            if(parms[i2]=='['){
     1134                i5=GetStringInBracket(temporary+i3,parms+i2);
    11321135                i2+=i5-1;
    11331136                i3+=i5-1;
    11341137                continue;
    11351138            }
    1136             if(Parameter[i2]==','){
     1139            if(parms[i2]==','){
    11371140                temporary[i3]=0;
    11381141                i2++;
    11391142                break;
    11401143            }
    1141             temporary[i3]=Parameter[i2];
    1142             if(Parameter[i2]=='\0') break;
     1144            temporary[i3]=parms[i2];
     1145            if(parms[i2]=='\0') break;
    11431146        }
    11441147        if(temporary[0]=='\0'){
    … …  
    11691172
    11701173        i4++;
    1171         if(Parameter[i2]=='\0') break;
     1174        if(parms[i2]=='\0') break;
    11721175    }
    11731176    sprintf(temp2,"_System_UsingDataType[%d]=-1",i4);
    … …  
    11831186    Opcode_CallProc(buffer,psi,0,"",0);
    11841187}
    1185 void Opcode_Print(char *Parameter,BOOL bWrite){
     1188void Opcode_Print(const char *Parameter,BOOL bWrite){
    11861189    int i2,i3,i4,sw;
    11871190    char temporary[VN_SIZE],buffer[VN_SIZE];
    11881191    BOOL bFile;
    1189 
    1190     KillStringSpaces(Parameter);
    11911192
    11921193    if(Parameter[0]=='#'){

  • BasicCompiler64/Compile_Var.cpp

    r63 r64  
    4141
    4242    if(PTR_LEVEL(*pType)){
    43         *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
    44         if((*pType)==DEF_OBJECT){
    45             CClass *pClass = (CClass *)lpIndex;
    46             //imul reg,objsize
    47             op_imul_value( sizeof(_int64), reg, pClass->GetSize() );
    48         }
    49         else{
    50             i2=GetTypeSize(*pType,-1);
    51             if(i2>=2){
    52                 //imul reg,i2
    53                 op_imul_value(sizeof(_int64),reg,i2);
    54             }
     43        *pType = PTR_LEVEL_DOWN( *pType );
     44
     45        i2=GetTypeSize(*pType,-1);
     46        if(i2>=2){
     47            //imul reg,i2
     48            op_imul_RV(sizeof(_int64),reg,i2);
    5549        }
    5650    }
    … …  
    7165    //add r11,reg
    7266    op_add64_reg(REG_R11,reg);
     67}
     68void SetRelativeOffset( RELATIVE_VAR &relativeVar ){
     69    if(relativeVar.dwKind==VAR_DIRECTMEM){
     70        //mov r11,qword ptr[r11]
     71        op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
     72    }
     73    else{
     74        //直接参照に切り替え
     75        SetVarPtrToReg(REG_R12,&relativeVar);
     76        relativeVar.dwKind=VAR_DIRECTMEM;
     77
     78        //mov r11,qword ptr[r12]
     79        op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
     80    }
    7381}
    7482BOOL GetArrayOffset(int *SubScripts,char *array,int type,LONG_PTR lpIndex){
    … …  
    153161
    154162        //imul reg,i4
    155         op_imul_value(sizeof(_int64),reg,i4);
     163        op_imul_RV(sizeof(_int64),reg,i4);
    156164
    157165        //add r12,reg
    … …  
    192200    char lpPtrOffset[VN_SIZE];  //第2次配列
    193201    char NestMember[VN_SIZE];   //入れ子メンバ
    194     int RefType;                //"."参照のときは0、"->"参照のときは1
     202    CClass::RefType refType;
    195203    lstrcpy(VarName,member);
    196     if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;
     204    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
    197205
    198206
    … …  
    279287        //入れ子構造の場合
    280288
    281         if(*pType==DEF_OBJECT && pMember->IsRef() == false){
    282             if(RefType!=DEF_OBJECT){
     289        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
     290            if( refType != CClass::Dot ){
    283291                if(isErrorEnabled) SetError(104,member,cp);
    284292                return 0;
    285293            }
    286         }
    287         else if(*pType==DEF_PTR_OBJECT || ( *pType==DEF_OBJECT && pMember->IsRef() )){
     294
     295            if( *pType==DEF_OBJECT ){
     296                // 参照内容へのポインタを抽出
     297                SetRelativeOffset( *pRelativeVar );
     298            }
     299        }
     300        else if(*pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT){
    288301            //構造体ポインタ型メンバ変数
    289302
    290303            if(lpPtrOffset[0]){
    291304                //pObj[n].member
    292                 if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_OBJECT){
     305                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Dot ){
    293306                    if(isErrorEnabled) SetError(104,member,cp);
    294307                    return 0;
    … …  
    303316            else{
    304317                //pObj->member
    305                 if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_PTR_OBJECT){
     318                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Pointer ){
    306319                    if(isErrorEnabled) SetError(104,member,cp);
    307320                    return 0;
    308321                }
    309322
    310                 if(pRelativeVar->dwKind==VAR_DIRECTMEM){
    311                     //mov r11,qword ptr[r11]
    312                     op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
    313                 }
    314                 else{
    315                     //直接参照に切り替え
    316                     SetVarPtrToReg(REG_R12,pRelativeVar);
    317                     pRelativeVar->dwKind=VAR_DIRECTMEM;
    318 
    319                     //mov r11,qword ptr[r12]
    320                     op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
    321                 }
    322             }
    323         }
    324         else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
     323                SetRelativeOffset( *pRelativeVar );
     324            }
     325        }
     326        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
    325327            //構造体ポインタのポインタ型メンバ変数
    326328
    327329            if(lpPtrOffset[0]){
    328330                //ppObj[n]->member
    329                 if(RefType!=DEF_PTR_OBJECT){
     331                if( refType != CClass::Pointer ){
    330332                    if(isErrorEnabled) SetError(104,member,cp);
    331333                    return 0;
    … …  
    388390BOOL GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
    389391    extern BOOL bCompilingGlobal;
    390     int i,RefType;
     392    int i;
    391393    LONG_PTR lpIndex;
    392394    char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    … …  
    398400    else lstrcpy(variable,NameBuffer);
    399401
    400     if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
     402    CClass::RefType refType;
     403    if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){
    401404        // 戻り値オブジェクトのメンバを直接参照しているとき
    402405        //例: func().member
    … …  
    442445
    443446    lstrcpy(VarName,variable);
    444     GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
     447    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
    445448
    446449    int *pSubScripts;
    … …  
    581584        char tempMember[VN_SIZE];
    582585        char tempArray[VN_SIZE];
    583         GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);
     586        {
     587            CClass::RefType refType;
     588            GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
     589        }
    584590
    585591        char temp2[VN_SIZE];
    … …  
    697703    }
    698704    if(member[0]){
    699         if(*pType==DEF_OBJECT){
     705        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
    700706            //実態オブジェクトのメンバを参照（obj.member）
    701             if(RefType!=DEF_OBJECT){
     707            if( refType != CClass::Dot ){
    702708                SetError(104,VarName,cp);
    703709                pRelativeVar->dwKind=NON_VAR;
    704710                return 0;
    705711            }
    706         }
    707         else if(*pType==DEF_PTR_OBJECT){
     712
     713            if( *pType==DEF_OBJECT ){
     714                // 参照内容へのポインタを抽出
     715                SetRelativeOffset( *pRelativeVar );
     716            }
     717        }
     718        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
    708719            //ポインタオブジェクトが示すメンバを参照
    709720            if(lpPtrOffset[0]){
    710721                //pObj[n].member
    711                 if(RefType!=DEF_OBJECT){
     722                if( refType != CClass::Dot ){
    712723                    SetError(104,VarName,cp);
    713724                    pRelativeVar->dwKind=NON_VAR;
    … …  
    719730            else{
    720731                //pObj->member
    721                 if(RefType!=DEF_PTR_OBJECT){
     732                if( refType != CClass::Pointer ){
    722733                    SetError(104,VarName,cp);
    723734                    pRelativeVar->dwKind=NON_VAR;
    … …  
    732743            }
    733744        }
    734         else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
     745        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
    735746            //ポインタオブジェクトが示すメンバを参照
    736747            if(lpPtrOffset[0]){
    737748                //ppObj[n]->member
    738                 if(RefType!=DEF_PTR_OBJECT){
     749                if( refType != CClass::Pointer ){
    739750                    SetError(104,VarName,cp);
    740751                    pRelativeVar->dwKind=NON_VAR;
    … …  
    815826        }
    816827
    817         if(type==DEF_OBJECT){
     828        if(type==DEF_STRUCT){
    818829            CClass *pobj_c;
    819830            pobj_c=(CClass *)lpIndex;
    … …  
    848859    ///////////////////////////////////////
    849860
    850     if( type == DEF_OBJECT){
    851         //オブジェクトの場合はありえない
     861    if( type == DEF_OBJECT || type == DEF_STRUCT ){
     862        //オブジェクトまたは構造体の場合はありえない
    852863        SetError(300,NULL,cp);
    853864        return 0;
    … …  
    888899            *(float *)(initGlobalBuf+offset)=(float)dbl;
    889900    else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
    890         if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
     901        if(type==DEF_PTR_CHAR&&lpCalcIndex==LITERAL_STRING){
    891902            //文字列定数のとき
    892903
    … …  
    953964        }
    954965
    955         if(type==DEF_OBJECT){
     966        if(type==DEF_STRUCT){
    956967            CClass *pobj_c;
    957968            pobj_c=(CClass *)lpIndex;
    … …  
    10371048    }
    10381049    else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
    1039         if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
     1050        if(type==DEF_PTR_CHAR&&lpCalcIndex==LITERAL_STRING){
    10401051            //文字列定数のとき
    10411052
    … …  
    11011112}
    11021113
    1103 
     1114void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags){
     1115    extern BOOL bCompilingGlobal;
     1116    if(bCompilingGlobal){
     1117        /////////////////////////
     1118        // グローバル変数
     1119        /////////////////////////
     1120
     1121        AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
     1122    }
     1123    else{
     1124        /////////////////
     1125        // ローカル変数
     1126        /////////////////
     1127
     1128        int i2,i3;
     1129
     1130        for(i2=0;i2<MaxLocalVarNum;i2++){
     1131            if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
     1132                if(lstrcmp(LocalVar[i2].name,VarName)==0){
     1133                    //２重定義のエラー
     1134                    SetError(15,VarName,cp);
     1135                    return;
     1136                }
     1137            }
     1138        }
     1139
     1140        LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
     1141        VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
     1142        MaxLocalVarNum++;
     1143
     1144        if( isRef ){
     1145            //参照型
     1146            pVar->fRef = REF_VARIABLE;
     1147            TypeSize = PTR_SIZE;
     1148        }
     1149        else pVar->fRef=0;
     1150
     1151        for(i2=1,i3=0;i3<255;i3++){
     1152            //配列要素数
     1153            pVar->SubScripts[i3]=SubScripts[i3];
     1154
     1155            if(SubScripts[i3]==-1) break;
     1156            i2*=SubScripts[i3]+1;
     1157        }
     1158        int VarSize=TypeSize*i2;
     1159        if(VarSize%8) VarSize+=8-(VarSize%8);
     1160
     1161        //変数データを追加
     1162        lstrcpy(pVar->name,VarName);
     1163        if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
     1164        else pVar->bConst = false;
     1165        if(SubScripts[0]==-1) pVar->bArray=0;
     1166        else pVar->bArray=1;
     1167        pVar->type=TypeInfo.type;
     1168        pVar->u.index=TypeInfo.u.lpIndex;
     1169
     1170        //アラインメントを考慮
     1171        if( pVar->type==DEF_STRUCT ){
     1172            int alignment = pVar->u.pobj_c->iAlign;
     1173            if( alignment ){
     1174                if( AllLocalVarSize % alignment ){
     1175                    AllLocalVarSize += alignment - (AllLocalVarSize % alignment);
     1176                }
     1177            }
     1178        }
     1179
     1180        AllLocalVarSize+=VarSize;
     1181        pVar->offset=AllLocalVarSize;
     1182
     1183        //レキシカルスコープ
     1184        pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
     1185        pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     1186        pVar->bLiving=TRUE;
     1187
     1188        if(InitBuf[0]){
     1189            //初期代入時のみ、書き込みアクセスを許可する
     1190            bool bConstBack = pVar->bConst;
     1191            pVar->bConst = false;
     1192
     1193            int result = 0;
     1194            if( pVar->type != DEF_OBJECT ){
     1195                result = InitLocalVar(-pVar->offset,
     1196                    pVar->type,
     1197                    pVar->u.index,
     1198                    pVar->SubScripts,
     1199                    InitBuf);
     1200            }
     1201
     1202            if(!result){
     1203                //動的な式だった場合は代入演算を行う
     1204                char temporary[8192];
     1205                sprintf(temporary,"%s=%s",VarName,InitBuf);
     1206                OpcodeCalc(temporary);
     1207            }
     1208
     1209            pVar->bConst = bConstBack;
     1210        }
     1211        else{
     1212            //0初期化
     1213
     1214            //mov r8, 0
     1215            op_zero_reg( REG_R8 );
     1216
     1217            //mov rdx, VarSize
     1218            op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
     1219
     1220            //mov rcx, rsp
     1221            op_mov_RR( REG_RCX, REG_RSP );
     1222
     1223            //add rcx, offset
     1224            op_add_RV( REG_RCX, -pVar->offset );
     1225            obp-=sizeof(long);
     1226            AddLocalVarAddrSchedule();
     1227            obp+=sizeof(long);
     1228
     1229            //call FillMemory
     1230            DECLAREINFO *pdi;
     1231            pdi=GetDeclareHash("FillMemory");
     1232            op_call( pdi );
     1233        }
     1234    }
     1235
     1236    //コンストラクタ呼び出し
     1237    if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
     1238        char objectSize[255];
     1239        if( SubScripts[0] == -1 ){
     1240            objectSize[0] = 0;
     1241        }
     1242        else{
     1243            if( SubScripts[1] != -1 ){
     1244                SetError(300,NULL,cp);
     1245            }
     1246            sprintf( objectSize, "%d", SubScripts[0] );
     1247        }
     1248        Operator_New( *TypeInfo.u.pobj_Class, objectSize, ConstractParameter, TypeInfo );
     1249
     1250        int type;
     1251        LONG_PTR lpIndex;
     1252        RELATIVE_VAR RelativeVar;
     1253        GetVarOffset( true, false, VarName, &type, &RelativeVar, &lpIndex );
     1254        if( RelativeVar.dwKind == VAR_DIRECTMEM ){
     1255            SetError();
     1256        }
     1257        SetVariableFromRax( DEF_OBJECT, DEF_OBJECT, &RelativeVar );
     1258    }
     1259
     1260    if(TypeInfo.type==DEF_OBJECT){
     1261        if(TypeInfo.u.pobj_Class->IsAbstract()){
     1262            //抽象クラスだったとき
     1263            SetError(125,TypeInfo.u.pobj_Class->name,cp);
     1264        }
     1265    }
     1266}
    11041267void dim(char *Parameter,DWORD dwFlags){
    11051268    extern BOOL bCompilingGlobal;
    11061269    extern HANDLE hHeap;
    1107     int i2,i3,VarSize;
     1270    int i2;
    11081271    char VarName[VN_SIZE];
    11091272
    … …  
    11721335    TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
    11731336
     1337    extern BOOL bCompilingGlobal;
    11741338    if(dwFlags&DIMFLAG_STATIC){
    11751339        if(bCompilingGlobal){
    … …  
    11861350        GetNowStaticVarFullName(VarName,temporary);
    11871351
    1188         AddGlobalVariable(isRef,temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
     1352        dim( isRef,temporary,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
    11891353
    11901354        /*
    … …  
    11941358    }
    11951359    else{
    1196         if(bCompilingGlobal){
    1197             /////////////////////////
    1198             // グローバル変数
    1199             /////////////////////////
    1200 
    1201             AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
    1202         }
    1203         else{
    1204             /////////////////
    1205             // ローカル変数
    1206             /////////////////
    1207 
    1208             for(i2=0;i2<MaxLocalVarNum;i2++){
    1209                 if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
    1210                     if(lstrcmp(LocalVar[i2].name,VarName)==0){
    1211                         //２重定義のエラー
    1212                         SetError(15,VarName,cp);
    1213                         return;
    1214                     }
    1215                 }
    1216             }
    1217 
    1218             LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
    1219             VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
    1220             MaxLocalVarNum++;
    1221 
    1222             if( isRef ){
    1223                 //参照型
    1224                 pVar->fRef = REF_VARIABLE;
    1225                 TypeSize = PTR_SIZE;
    1226             }
    1227             else pVar->fRef=0;
    1228 
    1229             for(i2=1,i3=0;i3<255;i3++){
    1230                 //配列要素数
    1231                 pVar->SubScripts[i3]=SubScripts[i3];
    1232 
    1233                 if(SubScripts[i3]==-1) break;
    1234                 i2*=SubScripts[i3]+1;
    1235             }
    1236             VarSize=TypeSize*i2;
    1237             if(VarSize%8) VarSize+=8-(VarSize%8);
    1238 
    1239             //変数データを追加
    1240             lstrcpy(pVar->name,VarName);
    1241             if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
    1242             else pVar->bConst = false;
    1243             if(SubScripts[0]==-1) pVar->bArray=0;
    1244             else pVar->bArray=1;
    1245             pVar->type=TypeInfo.type;
    1246             pVar->u.index=TypeInfo.u.lpIndex;
    1247             AllLocalVarSize+=VarSize;
    1248             pVar->offset=AllLocalVarSize;
    1249 
    1250             //レキシカルスコープ
    1251             pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    1252             pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
    1253             pVar->bLiving=TRUE;
    1254 
    1255             if(InitBuf[0]){
    1256                 //初期代入時のみ、書き込みアクセスを許可する
    1257                 bool bConstBack = pVar->bConst;
    1258                 pVar->bConst = false;
    1259 
    1260                 int result = InitLocalVar(-pVar->offset,
    1261                     pVar->type,
    1262                     pVar->u.index,
    1263                     pVar->SubScripts,
    1264                     InitBuf);
    1265 
    1266                 if(!result){
    1267                     //動的な式だった場合は代入演算を行う
    1268                     if( isRef ){
    1269                         SetRefVariable( VarName, InitBuf );
    1270                     }
    1271                     else{
    1272                         char temporary[8192];
    1273                         sprintf(temporary,"%s=%s",VarName,InitBuf);
    1274                         OpcodeCalc(temporary);
    1275                     }
    1276                 }
    1277 
    1278                 pVar->bConst = bConstBack;
    1279             }
    1280             else{
    1281                 //0初期化
    1282 
    1283                 //mov r8, 0
    1284                 op_zero_reg( REG_R8 );
    1285 
    1286                 //mov rdx, VarSize
    1287                 op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
    1288 
    1289                 //mov rcx, rsp
    1290                 op_mov_RR( REG_RCX, REG_RSP );
    1291 
    1292                 //add rcx, offset
    1293                 op_add64_value( REG_RCX, -pVar->offset );
    1294                 obp-=sizeof(long);
    1295                 AddLocalVarAddrSchedule();
    1296                 obp+=sizeof(long);
    1297 
    1298                 //call FillMemory
    1299                 DECLAREINFO *pdi;
    1300                 pdi=GetDeclareHash("FillMemory");
    1301                 op_call( pdi );
    1302             }
    1303         }
    1304 
    1305         //コンストラクタ呼び出し
    1306         if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
    1307             CallConstructor(VarName,SubScripts,TypeInfo,ConstractParameter);
    1308         }
    1309     }
    1310 
    1311     if(TypeInfo.type==DEF_OBJECT){
    1312         if(TypeInfo.u.pobj_Class->IsAbstract()){
    1313             //抽象クラスだったとき
    1314             SetError(125,TypeInfo.u.pobj_Class->name,cp);
    1315         }
     1360        dim( isRef,VarName,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
    13161361    }
    13171362}
    … …  
    13621407
    13631408            //mov reg,r11
    1364             op_mov64_ToReg_FromReg(reg,REG_R11);
     1409            op_mov_RR(reg,REG_R11);
    13651410        }
    13661411        else{
    … …  
    14041449
    14051450            //mov reg,r11
    1406             op_mov64_ToReg_FromReg(reg,REG_R11);
     1451            op_mov_RR(reg,REG_R11);
    14071452        }
    14081453        else{
    14091454            //mov reg,rsp
    1410             op_mov64_ToReg_FromReg(reg,REG_RSP);
     1455            op_mov_RR(reg,REG_RSP);
    14111456
    14121457            //add reg,offset
    1413             op_add64_value(reg,(int)pRelativeVar->offset);
     1458            op_add_RV(reg,(int)pRelativeVar->offset);
    14141459            obp-=sizeof(long);
    14151460            AddLocalVarAddrSchedule();
    … …  
    14411486directmem:
    14421487        //mov reg,r11
    1443         op_mov64_ToReg_FromReg(reg,REG_R11);
     1488        op_mov_RR(reg,REG_R11);
    14441489    }
    14451490}

  • BasicCompiler64/MakePeHdr.cpp

    r56 r64  
    1919    *pSub_calloc,
    2020    *pSub_realloc,
    21     *pSub_free;
     21    *pSub_free,
     22    *pSub_System_GC_malloc_ForObject,
     23    *pSub_System_GC_malloc_ForObjectPtr,
     24    *pSub_System_GC_free_for_SweepingDelete;
    2225
    2326
    … …  
    215218        pSub_free->bUse=1;
    216219
     220    if( pSub_System_GC_malloc_ForObject = GetSubHash( "_System_GC_malloc_ForObject",1 ) )
     221        pSub_System_GC_malloc_ForObject->bUse = 1;
     222
     223    if( pSub_System_GC_malloc_ForObjectPtr = GetSubHash( "_System_GC_malloc_ForObjectPtr",1 ) )
     224        pSub_System_GC_malloc_ForObjectPtr->bUse = 1;
     225
     226    if( pSub_System_GC_free_for_SweepingDelete = GetSubHash( "_System_GC_free_for_SweepingDelete",1 ) )
     227        pSub_System_GC_free_for_SweepingDelete->bUse = 1;
     228
    217229
    218230
    … …  
    345357
    346358        //add rsp,スタックフレームサイズ
    347         op_add64_value(REG_RSP,pobj_sf->GetFrameSize());
     359        op_add_RV(REG_RSP,pobj_sf->GetFrameSize());
    348360
    349361        //xor rax,rax（raxを0に初期化する）

  • BasicCompiler64/NumOpe.cpp

    r63 r64  
    1414    //////////////////////////////////////////////////////
    1515
     16        char *parameter = (char *)malloc( lstrlen( lpszText ) + 3 );
     17        lstrcpy( parameter, lpszText );
     18        SetStringQuotes( parameter );
     19
    1620        extern CClass *pobj_StringClass;
    17         int object_size = pobj_StringClass->GetSize();
    18 
    19         //mov rcx,object_size
    20         op_mov_RV(sizeof(_int64),REG_RCX,object_size);
    21 
    22         //call calloc
    23         extern SUBINFO *pSub_calloc;
    24         op_call(pSub_calloc);
    25 
    26         //mov r11,rax
    27         op_mov_RR(REG_R11,REG_RAX);
    28 
    29         //mov qword ptr[rsp+offset],r11     ※スタックフレームを利用
    30         pobj_sf->push(REG_R11);
    31 
    32         //mov rcx,rax
    33         op_mov_RR(REG_RCX,REG_RAX);
    34 
    35         //call constructor
    36         op_call(pobj_StringClass->GetConstructorMethod()->psi);
    37 
    38         // TODO: Ex表記による文字列長に対応する
    39         int i2 = dataTable.AddString( lpszText );
    40 
    41         //mov rax,i2
    42         op_mov_RV(sizeof(_int64),REG_RAX,i2);
    43         obp-=sizeof(long);
    44         pobj_DataTableSchedule->add();
    45         obp+=sizeof(long);
    46 
    47 
    48         //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
    49         pobj_sf->ref(REG_R11);
    50 
    51 
    52         RELATIVE_VAR RelativeVar;
    53         RelativeVar.bOffsetOffset=0;
    54         RelativeVar.offset=0;
    55         RelativeVar.dwKind=VAR_DIRECTMEM;
    56 
    57         SetObjectVariableFromRax((LONG_PTR)pobj_StringClass,DEF_PTR_BYTE,-1,&RelativeVar,0);
    58 
    59         //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
    60         pobj_sf->pop(REG_R11);
    61 
     21        TYPEINFO baseTypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
     22        Operator_New( *pobj_StringClass, "", parameter, baseTypeInfo );
     23
     24        free( parameter );
     25
     26        //mov reg,rax
     27        op_mov_RR( reg, REG_RAX );
    6228
    6329    /////////////////////////////////////////////
    … …  
    6531        RESTORE_REGISTER_RESOURCE
    6632    }////////////////////////////////////////////
    67 
    68     //mov reg,r11
    69     op_mov_RR(reg,REG_R11);
    7033}
    7134
    … …  
    10265        else{
    10366            //mov reg,rax
    104             op_mov64_ToReg_FromReg(UseReg,REG_RAX);
     67            op_mov_RR(UseReg,REG_RAX);
    10568        }
    10669    }
    … …  
    11780    }
    11881
    119     if(Command[0]==1&&Command[1]==ESC_NEW){
     82    if(Command[0]==1&& Command[1]==ESC_NEW ){
    12083        //New演算子（オブジェクト生成）
    121         return Operator_New(Command+2,plpIndex);
     84        TYPEINFO baseTypeInfo = { BaseType, lpBaseIndex };
     85        int resultType = Operator_New(Command+2,plpIndex, baseTypeInfo );
     86
     87        //mov reg,rax
     88        op_mov_RR( *pReg, REG_RAX );
     89
     90        return resultType;
    12291    }
    12392
    … …  
    245214                        TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex};
    246215                        if(IsStringSubsituation(pobj_Class)
    247                             || IsStringObjectType(&BaseTypeInfo)){
     216                            || IsStringObjectType(BaseTypeInfo)){
    248217                            //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
    249218
    … …  
    265234                    }
    266235
    267                     type[sp]=DEF_PTR_BYTE;
     236                    type[sp]=DEF_PTR_CHAR;
    268237                    bLiteralCalculation=0;
    269238
    … …  
    375344                            else pobj_reg->LockReg();
    376345
    377                             if(i2==DEF_OBJECT){
    378                                 //Object型が戻ったときはヒープ領域にインスタンスが格納されている
     346                            if(i2==DEF_STRUCT){
     347                                //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    379348                                //※後にfreeする必要あり
    380349                                bUseHeap[sp]=1;
    … …  
    469438                                SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
    470439                        }
    471                         else if(IsWholeNumberType(i2)){
     440                        else if(IsWholeNumberType(i2) || i2==DEF_OBJECT){
    472441                            //整数型
    473442                            SetReg_WholeVariable(i2,&RelativeVar,UseReg);
    474443                        }
    475                         else if(i2==DEF_OBJECT){
    476                             //オブジェクト ポインタをUseRegへ格納
     444                        else if(i2==DEF_STRUCT){
     445                            //構造体ポインタをUseRegへ格納（構造体は値型）
    477446                            SetVarPtrToReg(UseReg,&RelativeVar);
    478447                        }
    … …  
    585554                        }////////////////////////////////////////////
    586555
    587                         if(type[sp]==DEF_OBJECT){
    588                             //Object型が戻ったときはヒープ領域にインスタンスが格納されている
     556                        if(type[sp]==DEF_STRUCT){
     557                            //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    589558                            //※後にfreeする必要あり
    590559                            bUseHeap[sp]=1;

  • BasicCompiler64/NumOpe_Arithmetic.cpp

    r56 r64  
    108108        else if(idCalc==CALC_PRODUCT){
    109109            //mul reg1,reg2
    110             op_imul_reg(sizeof(_int64),reg1,reg2);
     110            op_imul_RR(sizeof(_int64),reg1,reg2);
    111111        }
    112112
    … …  
    131131        else if(idCalc==CALC_PRODUCT){
    132132            //mul reg1,reg2
    133             op_imul_reg(sizeof(long),reg1,reg2);
     133            op_imul_RR(sizeof(long),reg1,reg2);
    134134        }
    135135
    … …  
    177177    if(reg2==REG_RAX||reg2==REG_RDX){
    178178        //mov r15,reg2
    179         op_mov64_ToReg_FromReg(REG_R15,reg2);
     179        op_mov_RR(REG_R15,reg2);
    180180
    181181        reg2=REG_R15;
    … …  
    203203
    204204        //mov rax,reg1
    205         op_mov64_ToReg_FromReg(REG_RAX,reg1);
     205        op_mov_RR(REG_RAX,reg1);
    206206
    207207        if(IsSignedType(type[sp-2])){
    … …  
    231231
    232232        //mov reg1,rdx
    233         op_mov64_ToReg_FromReg(reg1,REG_RDX);
     233        op_mov_RR(reg1,REG_RDX);
    234234
    235235    }
    … …  
    353353    if(reg2==REG_RAX||reg2==REG_RDX){
    354354        //mov r15,reg2
    355         op_mov64_ToReg_FromReg(REG_R15,reg2);
     355        op_mov_RR(REG_R15,reg2);
    356356
    357357        reg2=REG_R15;
    … …  
    379379
    380380        //mov rax,reg1
    381         op_mov64_ToReg_FromReg(REG_RAX,reg1);
     381        op_mov_RR(REG_RAX,reg1);
    382382
    383383        if(IsSignedType(type[sp-2])){
    … …  
    407407
    408408        //mov reg1,rax
    409         op_mov64_ToReg_FromReg(reg1,REG_RAX);
     409        op_mov_RR(reg1,REG_RAX);
    410410
    411411    }
    … …  
    495495
    496496        //imul reg,-1
    497         op_imul_value(sizeof(_int64),reg,-1);
     497        op_imul_RV(sizeof(_int64),reg,-1);
    498498
    499499        if(reg==REG_R14){
    … …  
    508508
    509509        //imul reg,-1
    510         op_imul_value(sizeof(long),reg,-1);
     510        op_imul_RV(sizeof(long),reg,-1);
    511511
    512512        if(reg==REG_R14){
    … …  
    617617    if(reg1==REG_RCX){
    618618        //mov r15,rcx
    619         op_mov64_ToReg_FromReg(REG_R15,REG_RCX);
     619        op_mov_RR(REG_R15,REG_RCX);
    620620
    621621        reg1=REG_R15;
    … …  
    629629
    630630    //mov rcx,reg2
    631     op_mov64_ToReg_FromReg(REG_RCX,reg2);
     631    op_mov_RR(REG_RCX,reg2);
    632632
    633633    if(idCalc==CALC_SHL){
    … …  
    662662    if(sw==0){
    663663        //mov rcx,r15
    664         op_mov64_ToReg_FromReg(REG_RCX,REG_R15);
     664        op_mov_RR(REG_RCX,REG_R15);
    665665    }
    666666    else{

  • BasicCompiler64/NumOpe_Logical.cpp

    r36 r64  
    112112
    113113        //add rax, 1
    114         op_add64_value( REG_RAX, 1 );
     114        op_add_RV( REG_RAX, 1 );
    115115
    116116        if( reg != REG_RAX ){

  • BasicCompiler64/Opcode.h

    r62 r64  
    125125    void SetLocalParmSize(int size);
    126126    int GetFrameSize();
     127    int GetNowSp();
     128    void mov_sp( int reg );
    127129    int push(int reg);
    128130    void push(int xmm_reg,int var_size);
    … …  
    130132    void ref(int reg);
    131133    void ref(int xmm_reg,int var_size);
    132     void pop(int reg);
     134    void pop(int reg = REG_NON);
    133135    void pop(int xmm_reg,int var_size);
    134136    void parameter_allocate(int size);
    … …  
    247249void SetVariableFromRax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar);
    248250void OpcodeCalc(char *Command);
    249 void SetRefVariable( const char *varname, const char *expression );
    250251
    251252//NumOpe.cpp
    … …  
    285286//Compile_Set_Var.cpp
    286287BOOL IsUse_r11(RELATIVE_VAR *pRelativeVar);
    287 void SetObjectVariableFromRax(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,RELATIVE_VAR *pRelativeVar,BOOL bUseHeap);
    288 void SetDoubleVariable(int type,RELATIVE_VAR *pRelative);
    289 void SetSingleVariable(int type,RELATIVE_VAR *pRelative);
     288void SetStructVariableFromRax(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,RELATIVE_VAR *pRelativeVar,BOOL bUseHeap);
     289void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar);
    290290void SetBooleanVariable(int type,RELATIVE_VAR *pRelative);
    291291void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative);
    … …  
    307307
    308308//Compile_Object.cpp
    309 int Operator_New(const char *Parameter,LONG_PTR *plpIndex);
    310 void OpcodeDelete(const char *Parameter);
     309void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter,const TYPEINFO &baseTypeInfo );
     310int Operator_New(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo );
     311void OpcodeDelete(const char *Parameter, bool isSweeping);
    311312
    312313//Compile_Var.cpp
    … …  
    319320#define DIMFLAG_STATIC                  0x04
    320321#define DIMFLAG_CONST                   0x08
     322void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags);
    321323void OpcodeDim(char *Parameter,DWORD dwFlag);
    322324void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar);
    323325
    324326//CParameter.cpp
     327#define OVERLOAD_MIN_LEVEL 0
     328#define OVERLOAD_MAX_LEVEL 3
     329#define OVERLOAD_LEVEL0 0
    325330#define OVERLOAD_LEVEL1 1
    326331#define OVERLOAD_LEVEL2 2
    … …  
    352357    BOOL ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
    353358    void MacroParameterSupport(PARAMETER_INFO *ppi);
    354     void SetObjectParameter(int reg,CClass *pobj_Class,LPSTR Parameter);
     359    void SetStructParameter(int reg,CClass *pobj_Class,LPSTR Parameter);
    355360
    356361    //一時オブジェクトパラメータの生成と破棄
    357     void NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum );
     362    int NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum );
    358363    void DeleteTempParameters();
    359364
    … …  
    380385#define PROCFLAG_NEW    1
    381386int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex);
    382 void Opcode_CallProc(char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType);
     387void Opcode_CallProc(const char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType);
    383388int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex);
    384389
    … …  
    410415void OpcodeGosub(char *Parameter);
    411416void OpcodeReturn(char *Parameter);
    412 void Opcode_Input(char *Parameter);
    413 void Opcode_Print(char *Parameter,BOOL bWrite);
     417void Opcode_Input(const char *Parameter);
     418void Opcode_Print(const char *Parameter,BOOL bWrite);
    414419void OpcodeCallPtr(char *Parameter);
    415420void OpcodeSetPtrData(char *Parameter,int type);
    … …  
    450455void op_mov64_ToReg             (int reg,_int64 i64data);
    451456void op_mov64_ToReg             (int reg,int i32data);
    452 void op_mov64_ToReg_FromReg     (int reg1,int reg2);
    453457void op_movsxd                  (int reg64,int reg32);
    454458void op_movsx64_FromReg16       (int reg64,int reg16);
    … …  
    460464void op_dec                     (int reg);
    461465void op_add_RM                  (int op_size,int reg,int base_reg,int offset,char mod);
    462 void op_add64_value             (int reg,int offset);
     466void op_add_RV              (int reg,int offset);
    463467void op_add64_reg               (int reg1,int reg2);
    464468void op_add32_reg               (int reg1,int reg2);
    … …  
    467471void op_sub32_reg               (int reg1,int reg2);
    468472void op_sbb_RR                  ( int op_size, int reg1, int reg2 );
    469 void op_imul_reg                (int op_size,int reg1,int reg2);
    470 void op_imul_value              (int op_size,int reg,int i32data);
     473void op_imul_RR             (int op_size,int reg1,int reg2);
     474void op_imul_RV             (int op_size,int reg,int i32data);
    471475void op_div64_reg               (int reg);
    472476void op_idiv64_reg              (int reg);

  • BasicCompiler64/OperatorProc.cpp

    r63 r64  
    5555        if(pBaseTypeInfo){
    5656            if(pBaseTypeInfo->type==DEF_OBJECT){
    57                 bReturnTypeIsObject=1;
    5857                ReturnType.u.lpIndex=pBaseTypeInfo->u.lpIndex;
    5958            }
    … …  
    113112    HeapDefaultFree(ppi);
    114113
    115     int right_side_size;
    116     if(type[sp-1]==DEF_OBJECT) right_side_size=PTR_SIZE;
    117     else right_side_size=GetTypeSize(type[sp-1],index_stack[sp-1]);
    118 
    119114    if(bTwoTerm){
    120         if(psi->pParmInfo[1].type==DEF_OBJECT&&psi->pParmInfo[1].bByVal){
     115        if(psi->pRealParmInfo[1].type==DEF_STRUCT&&psi->pRealParmInfo[1].bByVal){
    121116            //一時オブジェクトはメソッド内で破棄される
    122117            bUseHeap[sp-1]=0;
    … …  
    124119    }
    125120
    126 
    127     if(psi->ReturnType==DEF_OBJECT){
    128         //////////////////////////////////////////////////////
    129         // 戻り値にオブジェクト インスタンスを持つ場合
    130         // ※ByRef _System_ReturnObject パラメータ用領域を取得
     121    if(psi->ReturnType==DEF_STRUCT){
     122        //////////////////////////////////////////////////////
     123        // 戻り値に構造体インスタンスを持つ場合
     124        // ※ByRef _System_ReturnValue パラメータ用領域を取得
    131125        //////////////////////////////////////////////////////
    132126
    … …  
    154148        }////////////////////////////////////////////
    155149    }
    156 
    157150
    158151    int reg1,reg2;
    … …  
    161154        SetOneTermToReg_Whole64Calc(type[sp-1],&reg2);
    162155        pobj_reg->UnlockReg();
     156        if( !psi->pRealParmInfo[1].bByVal ){
     157            //一時参照を作成
     158            pobj_sf->push( reg2 );
     159            pobj_sf->mov_sp( reg2 );
     160        }
    163161    }
    164162
    … …  
    192190
    193191        if(bTwoTerm){
    194             if(psi->ReturnType==DEF_OBJECT){
     192            if(psi->ReturnType==DEF_STRUCT){
    195193                //mov r8,reg2
    196194                op_mov_RR(REG_R8,reg2);
    … …  
    202200        }
    203201
    204         if(psi->ReturnType==DEF_OBJECT){
     202        if(psi->ReturnType==DEF_STRUCT){
    205203            //mov rdx,r13
    206204            op_mov_RR(REG_RDX,REG_R13);
    … …  
    213211        op_call(psi);
    214212
    215         if(psi->ReturnType!=-1){
     213        if(psi->ReturnType!=DEF_NON){
    216214            //戻り値を一時的に退避
    217215
    … …  
    254252    }
    255253
    256     if(psi->ReturnType!=-1){
     254    if(bTwoTerm){
     255        if( !psi->pRealParmInfo[1].bByVal ){
     256            //一時参照を破棄
     257            pobj_sf->pop();
     258        }
     259    }
     260
     261    if(psi->ReturnType!=DEF_NON){
    257262        //戻り値をreg1にセット
    258263        reg1=pobj_reg->LockReg();
    … …  
    266271    index_stack[sp-1]=psi->u.ReturnIndex;
    267272
    268     if(psi->ReturnType==DEF_OBJECT){
    269         //Object型が戻ったときはヒープ領域にインスタンスが格納されている
     273    if(psi->ReturnType==DEF_STRUCT){
     274        //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    270275        //※後にfreeする必要あり
    271276        bUseHeap[sp-1]=1;

  • BasicCompiler64/WatchList.cpp

    r63 r64  
    7878    if(PTR_LEVEL(*pType)){
    7979        *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
    80         if((*pType)==DEF_OBJECT){
    81             CClass *pClass = (CClass *)lpIndex;
    82             array_num *= pClass->GetSize();
    83         }
    84         else{
    85             array_num *= GetTypeSize(*pType,-1);
    86         }
     80        array_num *= GetTypeSize(*pType,-1);
    8781    }
    8882    else{
    … …  
    114108    char lpPtrOffset[VN_SIZE];  //第2次配列
    115109    char NestMember[VN_SIZE];   //入れ子メンバ
    116     int RefType;                //"."参照のときは0、"->"参照のときは1
     110    CClass::RefType refType;
    117111    lstrcpy(VarName,member);
    118     if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;
     112    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember, refType ) ) return 0;
    119113
    120114
    … …  
    175169        //入れ子構造の場合
    176170
    177         if(*pType==DEF_OBJECT){
    178             if(RefType!=DEF_OBJECT) return 0;
    179         }
    180         else if(*pType==DEF_PTR_OBJECT){
     171        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
     172            if( refType != CClass::Dot ) return 0;
     173
     174            if( *pType==DEF_OBJECT ){
     175                extern HANDLE hDebugProcess;
     176                LONG_PTR lpData;
     177                SIZE_T stAccBytes;
     178                lpData=Debugging_GetVarPtr(pRelativeVar);
     179                if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(LONG_PTR),&stAccBytes)) return -1;
     180                pRelativeVar->dwKind=VAR_DIRECTMEM;
     181            }
     182        }
     183        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
    181184            //構造体ポインタ型メンバ変数
    182185
    183186            if(lpPtrOffset[0]){
    184                 if(RefType!=DEF_OBJECT) return 0;
     187                if( refType != CClass::Dot ) return 0;
    185188
    186189                //直接参照に切り替え
    … …  
    190193            }
    191194            else{
    192                 if(RefType!=DEF_PTR_OBJECT) return 0;
     195                if( refType != CClass::Pointer ) return 0;
    193196
    194197                extern HANDLE hDebugProcess;
    … …  
    320323int Debugging_GetVarOffset(char *variable,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
    321324    extern HANDLE hDebugProcess;
    322     int i,i2,i3,RefType;
     325    int i,i2,i3;
    323326    char member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    324327    LONG_PTR lpData;
    … …  
    326329
    327330    lstrcpy(VarName,variable);
    328     GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
     331    CClass::RefType refType;
     332    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
    329333
    330334    LONG_PTR lpIndex;
    … …  
    474478    }
    475479    if(member[0]){
    476         if(*pType==DEF_OBJECT){
     480        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
    477481            //実態オブジェクトのメンバを参照（obj.member）
    478             if(RefType!=DEF_OBJECT){
     482            if( refType != CClass::Dot ){
    479483                return 0;
    480484            }
    … …  
    493497            *plpIndex=lp2;
    494498        }
    495         else if(*pType==DEF_PTR_OBJECT){
     499        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
    496500            //ポインタオブジェクトが示すメンバを参照
    497501            if(lpPtrOffset[0]){
    498502                //pObj[n].member
    499                 if(RefType!=DEF_OBJECT) return 0;
     503                if( refType != CClass::Dot ) return 0;
    500504                Debugging_SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
    501505
    … …  
    515519            else{
    516520                //pObj->member
    517                 if(RefType!=DEF_PTR_OBJECT) return 0;
     521                if( refType != CClass::Pointer ) return 0;
    518522
    519523                pRelativeVar->offset=Debugging_GetVarPtr(pRelativeVar);

  • BasicCompiler64/amd64_main.cpp

    r36 r64  
    424424
    425425void op_mov_RR(int reg1,int reg2){
    426     op_mov64_ToReg_FromReg(reg1,reg2);
     426    //mov reg1,reg2
     427    char RexByte=-1;
     428
     429    if(reg1==reg2) return;
     430
     431    if(REG_RAX<=reg1&&reg1<=REG_RDI){
     432        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
     433        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
     434    }
     435    if(REG_R8<=reg1&&reg1<=REG_R15){
     436        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
     437        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x4D;
     438    }
     439
     440    if(RexByte==-1) SetError(300,NULL,cp);
     441
     442    // [8bit rex] 1000 1011 11xx xbbb
     443    OpBuffer[obp++]=RexByte;
     444    OpBuffer[obp++]=(char)0x8B;
     445    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
    427446}
    428447
    … …  
    475494    }
    476495}
    477 void op_mov64_ToReg_FromReg(int reg1,int reg2){
    478     //mov reg1,reg2
    479     char RexByte=-1;
    480 
    481     if(reg1==reg2) return;
    482 
    483     if(REG_RAX<=reg1&&reg1<=REG_RDI){
    484         if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
    485         if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
    486     }
    487     if(REG_R8<=reg1&&reg1<=REG_R15){
    488         if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
    489         if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x4D;
    490     }
    491 
    492     if(RexByte==-1) SetError(300,NULL,cp);
    493 
    494     // [8bit rex] 1000 1011 11xx xbbb
    495     OpBuffer[obp++]=RexByte;
    496     OpBuffer[obp++]=(char)0x8B;
    497     OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
    498 }
    499496void op_movsxd(int reg64,int reg32){
    500497    //movsxd reg64,reg32
    … …  
    686683}
    687684
    688 void op_add64_value(int reg,int offset){
     685void op_add_RV(int reg,int offset){
    689686    //add reg,offset
    690687    char RexByte=-1;
    … …  
    843840////////////////////////
    844841
    845 void op_imul_reg(int op_size,int reg1,int reg2){
     842void op_imul_RR(int op_size,int reg1,int reg2){
    846843    //imul reg1,reg2
    847844    char RexByte=-1;
    … …  
    881878    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
    882879}
    883 void op_imul_value(int op_size,int reg,int i32data){
     880void op_imul_RV(int op_size,int reg,int i32data){
    884881    //imul reg,i32data
    885882    char RexByte=-1;

  • BasicCompiler64/stack_frame.cpp

    r20 r64  
    3838    }
    3939    return -(answer_sp-0x08);
     40}
     41int CStackFrame::GetNowSp(){
     42    return now_sp;
     43}
     44void CStackFrame::mov_sp( int reg ){
     45    //mov reg,rsp
     46    op_mov_RR( reg, REG_RSP );
     47
     48    //add reg,now_sp
     49    op_add_RV( reg, now_sp );
     50
     51    //スケジュールをセット
     52    obp-=sizeof(long);
     53    add();
     54    obp+=sizeof(long);
    4055}
    4156int CStackFrame::push(int reg){

  • BasicCompiler64/varlist.cpp

    r63 r64  
    2222    _int64 i64data;
    2323
    24     if(type==DEF_OBJECT){
     24    if(type==DEF_OBJECT||type==DEF_STRUCT){
     25        if( type==DEF_OBJECT ){
     26            // 参照型ということを考慮する
     27            ReadProcessMemory(hDebugProcess,(void *)offset,&pData,sizeof(void *),&stAccBytes);
     28            offset = pData;
     29        }
     30
    2531        sprintf(lptv->item.pszText,"%s %s(&H%X)",VarName,STRING_OBJECT,(DWORD64)offset);
    2632        lptv->item.iImage=1;
    … …  
    3137        return;
    3238    }
    33     if(type==DEF_PTR_OBJECT){
     39    if(type==DEF_PTR_OBJECT||type==DEF_PTR_STRUCT){
    3440        i2=ReadProcessMemory(hDebugProcess,(void *)offset,&pData,sizeof(void *),&stAccBytes);
    3541
    … …  
    4349    }
    4450    else{
    45         if(type==DEF_PTR_BYTE){
     51        if(type==DEF_PTR_CHAR||type==MAKE_PTR_TYPE(DEF_BYTE,1)){
    4652            if(ReadProcessMemory(hDebugProcess,(void *)offset,&pData,sizeof(void *),&stAccBytes)){
    4753                for(i2=0;;i2++){
Note: See TracChangeset for help on using the changeset viewer.