Changeset 64 in dev for BasicCompiler32


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

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

Location:
BasicCompiler32
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler32/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     //TODO: 64ビットコードのままなので、32ビット用に書き換える
    98
    109    useTempObject = false;
    1110
    12     //一時オブジェクトの数
     11    //一時参照の数
    1312    nCountOfTempObjects = 0;
    1413
    … …  
    6463                int type = NumOpe( Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
    6564                //↑ここでスタックに積む
     65
     66                nCountOfTempObjects++;
     67
     68                if( type == DEF_OBJECT ){
     69                    //一時参照を作成
     70
     71                    //push esp
     72                    op_push( REG_ESP );
     73
     74                    nCountOfTempObjects++;
     75                }
    6676
    6777                bool result = CheckDifferentType(
    … …  
    8090                    types[i2].u.lpIndex = lpVarIndex;
    8191                }
    82 
    83                 nCountOfTempObjects++;
    84             }
    85         }
    86     }
     92            }
     93        }
     94    }
     95
     96    return nCountOfTempObjects * PTR_SIZE;
    8797}
     98
    8899void CParameter::DeleteTempParameters(){
    89100    ///////////////////////////////////////////////////////
    90101    // 一時オブジェクトを破棄
    91102    ///////////////////////////////////////////////////////
    92     //TODO: 64ビットコードのままなので、32ビット用に書き換える
    93 
    94103    if( !useTempObject ) return;
    95104
    96105    for(int i2=ParmsNum-1;i2>=0;i2--){
    97106        if( useTempParameters[i2] ){
    98             //スタックフレームから取得
    99             // ※関数呼び出し時も値が普遍のebxを利用する
    100             op_pop(REG_EBX);
    101 
    102 
    103             ///////////////////////////
    104             // デストラクタを呼び出す
    105             ///////////////////////////
    106 
    107             //push ebx
    108             op_push(REG_EBX);
    109 
    110             //call destructor
    111             CMethod *method = types[i2].u.pobj_Class->GetDestructorMethod();
    112             if( method ){
    113                 op_call( method->psi );
    114             }
    115 
    116 
    117             /////////////////////////
    118             // メモリを解放する
    119             /////////////////////////
    120 
    121             //push ebx
    122             op_push(REG_EBX);
    123 
    124             //call free
    125             extern SUBINFO *pSub_free;
    126             op_call(pSub_free);
     107            if( types[i2].type == DEF_STRUCT ){
     108                // 構造体の一時メモリ
     109
     110                //メモリを解放する
     111
     112                //call free
     113                extern SUBINFO *pSub_free;
     114                op_call(pSub_free);
     115            }
     116            else if( types[i2].type == DEF_OBJECT ){
     117                op_pop( REG_NON );
     118                op_pop( REG_NON );
     119            }
     120            else{
     121                SetError(300,NULL,cp);
     122            }
     123
    127124        }
    128125    }
    129126}
    130127
    131 void CParameter::SetObjectParameter(CClass *pobj_Class,LPSTR Parameter){
     128void CParameter::SetStructParameter(CClass *pobj_Class,LPSTR Parameter){
    132129    int object_size = pobj_Class->GetSize();
    133130
    … …  
    143140
    144141
    145     TYPEINFO BaseType={DEF_OBJECT,(LONG_PTR)pobj_Class};
     142    TYPEINFO BaseType={DEF_STRUCT,(LONG_PTR)pobj_Class};
    146143    TYPEINFO CalcType;
    147144    CalcType.type=NumOpe_GetType(Parameter,&BaseType,&CalcType.u.lpIndex);
    148145
     146    /*
     147    TODO: 消す
    149148    if( pobj_Class->GetCopyConstructorMethod()
    150149        && CalcType.type==DEF_OBJECT&&CalcType.u.pobj_Class==pobj_Class){
    … …  
    185184        }
    186185    }
    187     else{
     186    else{*/
     187
     188
    188189        //push eax
    189190        op_push(REG_EAX);
    190191
    191 
     192/*
     193            TODO: 消す
    192194            if( pobj_Class->GetConstructorMethod() ){
    193195                ////////////////////////////////
    … …  
    201203                op_call(pobj_Class->GetConstructorMethod()->psi);
    202204            }
    203 
    204 
    205             TYPEINFO CalcType;
     205*/
     206
    206207            BOOL bUseHeap;
    207             CalcType.type=NumOpe(Parameter,DEF_OBJECT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
    208 
    209 
    210 
    211         SetObjectVariable((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,bUseHeap);
    212     }
     208            CalcType.type=NumOpe(Parameter,DEF_STRUCT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
     209
     210
     211
     212        SetStructVariable((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,bUseHeap);
     213    //}
    213214}
    214215
    … …  
    280281            }
    281282
    282             if(DummyTypeInfo.type==DEF_OBJECT){
    283                 SetObjectParameter(DummyTypeInfo.u.pobj_Class,Parms[i2]);
     283            if(DummyTypeInfo.type==DEF_STRUCT){
     284                SetStructParameter(DummyTypeInfo.u.pobj_Class,Parms[i2]);
    284285                goto next;
    285286            }
    … …  
    299300
    300301            if(CalcType==DEF_OBJECT){
    301                 //キャスト演算子のオーバーロードに対応する
    302                 CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
     302                if( DummyTypeInfo.type != DEF_OBJECT
     303                    ||
     304                    DummyTypeInfo.type == DEF_OBJECT &&
     305                    !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpCalcIndex ) ){
     306                        //キャスト演算子のオーバーロードに対応する
     307                        CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
     308                }
    303309            }
    304310
    … …  
    328334                ParmSize+=sizeof(long)*2;
    329335            }
    330             else if(DummyTypeInfo.type==DEF_LONG||DummyTypeInfo.type==DEF_DWORD||
     336            else if(DummyTypeInfo.type==DEF_LONG||DummyTypeInfo.type==DEF_DWORD||DummyTypeInfo.type==DEF_OBJECT||DummyTypeInfo.type==DEF_STRUCT||
    331337                (IsPtrType(DummyTypeInfo.type)/*&&DummyTypeInfo.type!=DEF_PTR_VOID&&DummyTypeInfo.type!=DEF_PTR_BYTE*/)){
    332338                ChangeTypeToLong(CalcType);
    … …  
    354360            }
    355361            else{
    356                 //変数のアドレスを取得
    357                 int VarType;
    358                 LONG_PTR lpVarIndex;
    359                 if(GetVarOffset(
    360                     false,
    361                     false,
    362                     Parms[i2],
    363                     &VarType,
    364                     &RelativeVar,
    365                     &lpVarIndex)){
    366                         if(DummyTypeInfo.type!=DEF_ANY){
    367                             //型チェックを行う
    368                             if(DummyTypeInfo.type==VarType){
    369                                 if(DummyTypeInfo.type==DEF_OBJECT){
    370                                     if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
    371                                         SetError(11,Parms[i2],cp);
    372                                     }
    373                                 }
    374                             }
    375                             else if((VarType&FLAG_PTR)&&((int)(VarType^FLAG_PTR)==DummyTypeInfo.type)){
    376                                 //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
    377                             }
    378                             else{
    379                                 SetError(11,Parms[i2],cp);
    380                             }
    381                         }
    382 
    383                         //変数アドレスをレジスタにセット
    384                         SetVarPtrToEax(&RelativeVar);
    385 
    386                         //push eax
    387                         op_push(REG_EAX);
    388                 }
    389                 else{
     362                if( useTempParameters[i2] ){
    390363                    //一時オブジェクトをコピー
     364
     365                    if( types[i2].type == DEF_OBJECT ){
     366                        // 一時参照のための領域を考慮する
     367                        nCountOfNowTempObjects++;
     368                    }
     369
     370                    nCountOfNowTempObjects++;
    391371
    392372                    //mov eax, dword ptr[esp+offset]
    … …  
    395375                        REG_EAX,
    396376                        REG_ESP,
    397                         ( ( ParmsNum - i2 - 1 ) + ( nCountOfTempObjects - nCountOfNowTempObjects - 1 ) ) * PTR_SIZE,
     377                        ( ( ParmsNum - i2 - 1 ) + ( nCountOfTempObjects - nCountOfNowTempObjects ) ) * PTR_SIZE,
    398378                        MOD_BASE_DISP32 );
    399 
    400                     nCountOfNowTempObjects++;
    401379
    402380                    //push eax
    403381                    op_push(REG_EAX);
    404 
    405                     //VarType = NumOpe( Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
     382                }
     383                else{
     384                    //変数のアドレスを取得
     385                    int VarType;
     386                    LONG_PTR lpVarIndex;
     387                    if(GetVarOffset(
     388                        false,
     389                        false,
     390                        Parms[i2],
     391                        &VarType,
     392                        &RelativeVar,
     393                        &lpVarIndex)){
     394                            if(DummyTypeInfo.type!=DEF_ANY){
     395                                //型チェックを行う
     396                                if(DummyTypeInfo.type==VarType){
     397                                    if(DummyTypeInfo.type==DEF_OBJECT){
     398                                        if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
     399                                            SetError(11,Parms[i2],cp);
     400                                        }
     401                                    }
     402                                    else if(DummyTypeInfo.type==DEF_STRUCT){
     403                                        if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
     404                                            SetError(11,Parms[i2],cp);
     405                                        }
     406                                    }
     407                                }
     408                                else if((VarType&FLAG_PTR)&&((int)(VarType^FLAG_PTR)==DummyTypeInfo.type)){
     409                                    //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
     410                                }
     411                                else{
     412                                    SetError(11,Parms[i2],cp);
     413                                }
     414                            }
     415
     416                            //変数アドレスをレジスタにセット
     417                            SetVarPtrToEax(&RelativeVar);
     418
     419                            //push eax
     420                            op_push(REG_EAX);
     421                    }
    406422                }
    407423            }

  • BasicCompiler32/Compile_Calc.cpp

    r62 r64  
    364364    //push eax
    365365    op_push(REG_EAX);
     366}
     367
     368
     369
     370
     371
     372
     373
     374
     375
     376void RestoreDefaultRegisterFromStackMemory( int type ){
     377    //現在のスタックの内容を実数レジスタに保存する
     378    //NumOpeの直後専用
     379    if(type==DEF_DOUBLE){
     380        //fld qword ptr[esp]
     381        op_fld_ptr_esp(DEF_DOUBLE);
     382
     383        //add esp,8
     384        op_add_esp(8);
     385    }
     386    else if(type==DEF_SINGLE){
     387        //fld dword ptr[esp]
     388        op_fld_ptr_esp(DEF_SINGLE);
     389
     390        //add esp,4
     391        op_add_esp(4);
     392    }
     393    else if( Is64Type( type ) ){
     394        //pop eax
     395        op_pop(REG_EAX);
     396
     397        //pop edx
     398        op_pop(REG_EDX);
     399    }
     400    else{
     401        //pop eax
     402        op_pop(REG_EAX);
     403    }
     404}
     405
     406void SetVariableFromEax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
     407    /////////////////////////////////////////////////
     408    // eaxの内容を変数にコピーするコードを抽出
     409    /////////////////////////////////////////////////
     410
     411    if(VarType==DEF_BOOLEAN){
     412        //bool
     413        SetBooleanVariable(CalcType,pRelativeVar);
     414    }
     415    else if( IsRealNumberType( VarType ) ){
     416        // Double/Single型変数へレジスタの値を代入
     417        SetRealVariable(VarType, CalcType, pRelativeVar);
     418    }
     419    else if( IsWholeNumberType( VarType ) || VarType == DEF_OBJECT ){
     420        int typeSize = GetTypeSize( VarType, -1 );
     421
     422        //整数変数へraxの値を格納する
     423        SetWholeVariable( typeSize, CalcType, pRelativeVar );
     424    }
     425    else{
     426        SetError(300,NULL,cp);
     427    }
    366428}
    367429
    … …  
    485547    }
    486548
     549
     550    if( lstrcmpi( variable, "This" ) == 0 ){
     551        SetError(133,NULL,cp);
     552        return;
     553    }
     554
     555
    487556    ////////////////////////////////////////
    488557    // 変数のタイプ型を識別して、演算を行う
    … …  
    511580    else ProcPtr_BaseIndex=-1;
    512581
    513     if(VarType==DEF_OBJECT){
    514         //代入演算のオーバーロード オペレータに備える
     582    if(VarType==DEF_STRUCT){
     583        //代入コピーに備える
    515584
    516585        //変数アドレスを取得
    … …  
    544613    }
    545614
    546     if(VarType==DEF_OBJECT){
     615    if(VarType==DEF_STRUCT){
    547616        //オブジェクトインスタンスへの代入
    548         SetObjectVariable(lpVarIndex,CalcType,lpCalcIndex,bCalcUseHeap);
     617        SetStructVariable(lpVarIndex,CalcType,lpCalcIndex,bCalcUseHeap);
    549618        return;
    550619    }
    551620
    552     if(CalcType==DEF_OBJECT){
     621    if(CalcType==DEF_OBJECT && (CalcType!=VarType || lpCalcIndex!=lpVarIndex) ){
    553622        //キャスト演算子のオーバーロードに対応する
    554623        CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,VarType,lpVarIndex);
    … …  
    568637    /////////////////////////////////////////////////
    569638
     639    //eax、edx:eax、またはst(0)にスタック上のデータを取り出す
     640    RestoreDefaultRegisterFromStackMemory( CalcType );
     641
     642    SetVariableFromEax( VarType, CalcType, &VarRelativeVar );
     643/*
     644    TODO: 消す
    570645    if(VarType==DEF_BOOLEAN){
    571646        //bool
    … …  
    598673        //Single型変数へスタックの内容を格納する
    599674        SetSingleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
    600     }
    601 }
    602 
     675    }*/
     676}
     677
     678
     679// TODO: 消す
     680/*
    603681void SetRefVariable( const char *varname, const char *expression ){
    604682    ////////////////////////////////////////
    … …  
    721799    }
    722800}
     801*/

  • BasicCompiler32/Compile_CallProc.cpp

    r63 r64  
    9494}
    9595
    96 void Opcode_CallProc(char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType){
     96void Opcode_CallProc(const char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType){
    9797    int i2;
    9898
    … …  
    206206
    207207    ///////////////////////////////////////////////////////////////
    208     // _System_LocalThis、_System_ReturnObjectのダミーをセット
     208    // _System_LocalThisのダミーをセット
    209209    ///////////////////////////////////////////////////////////////
    210210
    … …  
    215215    }
    216216
    217     if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false ){
    218         //_System_ReturnObject（第一または第二パラメータのダミーを作成）
    219         sprintf(temporary+lstrlen(temporary),"%c%c0,",1,ESC_BYVAL);
    220     }
    221 
    222217    if(Parameter[0]=='\0'&&temporary[0])
    223218        temporary[lstrlen(temporary)-1]=0;
    … …  
    246241
    247242    //一時オブジェクトを生成
    248     pobj_parameter->NewTempParameters( psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum );
     243    int tempSize = pobj_parameter->NewTempParameters( psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum );
    249244
    250245    //レジスタ、スタックフレームにセット
    … …  
    252247    ParmSize=pobj_parameter->SetParameter(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum);
    253248
    254 
    255     if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
     249    if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
    256250        //////////////////////////////////////////////////////
    257         // 戻り値にオブジェクト インスタンスを持つ場合
    258         // ※ByRef _System_ReturnObject パラメータをセット
     251        // 戻り値に構造体インスタンスを持つ場合
     252        // ※ByRef _System_ReturnValue パラメータをセット
    259253        //////////////////////////////////////////////////////
    260254
    … …  
    294288                SetVarPtrToEax(&RelativeVar);
    295289
    296                 //参照タイプが "->" の場合
    297                 if(RefType==DEF_PTR_OBJECT){
    298                     //mov eax,dword ptr[eax]
    299                     OpBuffer[obp++]=(char)0x8B;
    300                     OpBuffer[obp++]=(char)0x00;
    301                 }
    302 
    303                 //mov ecx,eax
    304                 OpBuffer[obp++]=(char)0x8B;
    305                 OpBuffer[obp++]=(char)0xC8;
     290                // 参照を実体ポインタにする
     291                op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
    306292            }
    307293        }
    … …  
    310296            if(dwFlags&PROCFLAG_NEW){
    311297                //New演算子によるコンストラクタ呼び出しの場合
     298
    312299                //mov ecx,dword ptr[esp+ParmSize]
    313                 OpBuffer[obp++]=(char)0x8B;
    314                 OpBuffer[obp++]=(char)0x8C;
    315                 OpBuffer[obp++]=(char)0x24;
    316                 *((long *)(OpBuffer+obp))=ParmSize;
    317                 obp+=sizeof(long);
     300                op_mov_RM( sizeof(long), REG_ECX, REG_ESP, ParmSize + tempSize, MOD_BASE_DISP32 );
    318301            }
    319302            else{

  • BasicCompiler32/Compile_Func.cpp

    r51 r64  
    208208
    209209    TYPEINFO TypeInfo={type,lpIndex};
    210     if(IsStringObjectType(&TypeInfo)){
     210    if(IsStringObjectType(TypeInfo)){
    211211        //Stringオブジェクトの場合
    212212        char temporary[VN_SIZE];
    … …  
    346346}
    347347void Opcode_Func_SizeOf(const char *Parameter){
    348     int type,size;
    349348    LONG_PTR lpIndex;
    350 
    351     type=GetTypeFixed(Parameter,&lpIndex);
    352     if(type==-1){
    353         extern int cp;
    354         SetError(3,Parameter,cp);
    355         return;
    356     }
    357     size=GetTypeSize(type,lpIndex);
     349    int type = GetTypeFixed(Parameter,&lpIndex);
     350
     351    int size;
     352    if( type == DEF_OBJECT ){
     353        CClass *pClass = (CClass *)lpIndex;
     354        size = pClass->GetSize();
     355    }
     356    else{
     357        size=GetTypeSize(type,lpIndex);
     358    }
    358359
    359360    //mov eax,size
    360     OpBuffer[obp++]=(char)0xB8;
    361     *((long *)(OpBuffer+obp))=size;
    362     obp+=sizeof(long);
     361    op_mov_RV( REG_EAX, size );
    363362}
    364363void Opcode_Func_VarPtr( const char *Parameter, TYPEINFO &ReturnTypeInfo ){
    … …  
    368367    if(!GetVarOffsetReadOnly( Parameter, &ReturnTypeInfo.type, &RelativeVar, &ReturnTypeInfo.u.lpIndex )) return;
    369368
     369    int beforeType = ReturnTypeInfo.type;
     370
    370371    PTR_LEVEL_UP( ReturnTypeInfo.type );
    371372
    372373    SetVarPtrToEax(&RelativeVar);
     374
     375    if( beforeType == DEF_OBJECT && lstrcmpi( Parameter, "This" ) != 0 ){
     376        //参照をオブジェクトポインタに変更
     377
     378        //mov eax,dword ptr[eax]
     379        op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
     380    }
    373381}
    374382void Opcode_Func_GetPtrData(const char *Parameter,const int type){

  • BasicCompiler32/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    // コンストラクタの呼び出し
    … …  
    7474    }
    7575}
    76 int Operator_New(const char *Parameter,LONG_PTR *plpIndex){
    77     char TypeName[VN_SIZE],CreateParameter[VN_SIZE],ObjectSize[VN_SIZE];
     76void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter, const TYPEINFO &baseTypeInfo ){
     77    int typeSize = classObj.GetSize();
     78
     79    if(classObj.IsAbstract()){
     80        //抽象クラスだったとき
     81        SetError(125,classObj.name,cp);
     82    }
     83
     84    if(objectSizeStr[0]){
     85        int type = NumOpe(objectSizeStr,0,0,0);
     86        ChangeTypeToLong(type);
     87
     88        //pop eax
     89        op_pop(REG_EAX);
     90
     91        //※添え字上限値であることを考慮
     92        //add eax,1
     93        OpBuffer[obp++]=(char)0x83;
     94        OpBuffer[obp++]=(char)0xC0;
     95        OpBuffer[obp++]=(char)0x01;
     96
     97        //オブジェクトの個数をebxに一時保持
     98        //※ebxは関数が呼ばれても不変
     99        //mov ebx,eax
     100        OpBuffer[obp++]=(char)0x8B;
     101        OpBuffer[obp++]=(char)0xD8;
     102
     103        //imul eax,size
     104        OpBuffer[obp++]=(char)0x69;
     105        OpBuffer[obp++]=(char)0xC0;
     106        *((long *)(OpBuffer+obp))=typeSize;
     107        obp+=sizeof(long);
     108
     109        //add eax,sizeof(DWORD)*2
     110        OpBuffer[obp++]=(char)0x05;
     111        *((long *)(OpBuffer+obp))=sizeof(DWORD)*3;
     112        obp+=sizeof(long);
     113
     114        //push eax
     115        op_push(REG_EAX);
     116    }
     117    else{
     118        //オブジェクトの個数をebxに一時保持
     119        //※ebxは関数が呼ばれても不変
     120        //mov ebx,1
     121        OpBuffer[obp++]=(char)0xBB;
     122        *((long *)(OpBuffer+obp))=1;
     123        obp+=sizeof(long);
     124
     125        //push size
     126        OpBuffer[obp++]=(char)0x68;
     127        *((long *)(OpBuffer+obp))=typeSize+sizeof(DWORD)*3;
     128        obp+=sizeof(long);
     129    }
     130
     131    if( baseTypeInfo.type == DEF_OBJECT ){
     132        //DeleteはGCで処理
     133
     134        //call _System_GC_malloc_ForObject
     135        extern SUBINFO *pSub_System_GC_malloc_ForObject;
     136        op_call(pSub_System_GC_malloc_ForObject);
     137    }
     138    else{
     139        //明示的なDeleteが必要
     140
     141        //call _System_GC_malloc_ForObjectPtr
     142        extern SUBINFO *pSub_System_GC_malloc_ForObjectPtr;
     143        op_call(pSub_System_GC_malloc_ForObjectPtr);
     144    }
     145
     146
     147    /*
     148    確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
     149    pPtr-=sizeof(DWORD)*3
     150    pPtr[0]=オブジェクトの個数
     151    pPtr[1]=オブジェクトのサイズ
     152    pPtr[2]=デストラクタの関数ポインタ
     153    */
     154
     155
     156    //mov dword ptr[eax],ebx（オブジェクトの個数）
     157    OpBuffer[obp++]=(char)0x89;
     158    OpBuffer[obp++]=(char)0x18;
     159
     160    //add eax,sizeof(DWORD)
     161    OpBuffer[obp++]=(char)0x05;
     162    *((long *)(OpBuffer+obp))=sizeof(DWORD);
     163    obp+=sizeof(long);
     164
     165
     166    //mov ecx,TypeSize
     167    OpBuffer[obp++]=(char)0xB9;
     168    *((long *)(OpBuffer+obp))=typeSize;
     169    obp+=sizeof(long);
     170
     171    //mov dword ptr[eax],ecx
     172    OpBuffer[obp++]=(char)0x89;
     173    OpBuffer[obp++]=(char)0x08;
     174
     175    //add eax,sizeof(DWORD)
     176    OpBuffer[obp++]=(char)0x05;
     177    *((long *)(OpBuffer+obp))=sizeof(DWORD);
     178    obp+=sizeof(long);
     179
     180
     181    CMethod *method = classObj.GetDestructorMethod();
     182    if( method == NULL ) return;
     183
     184    //mov ecx,DestructorProcAddr
     185    OpBuffer[obp++]=(char)0xB9;
     186    pobj_SubAddrSchedule->add(method->psi,0);
     187    method->psi->bUse=1;
     188    obp+=sizeof(long);
     189
     190    //mov dword ptr[eax],ecx
     191    OpBuffer[obp++]=(char)0x89;
     192    OpBuffer[obp++]=(char)0x08;
     193
     194    //add eax,sizeof(DWORD)
     195    OpBuffer[obp++]=(char)0x05;
     196    *((long *)(OpBuffer+obp))=sizeof(DWORD);
     197    obp+=sizeof(long);
     198
     199
     200    // ※ここでプッシュされた値はNew演算子の戻り値となる
     201    //push eax
     202    op_push(REG_EAX);
     203
     204
     205    /////////////////////////////////////////////////////////////////////
     206
     207    ////////////////////////////
     208    // コンストラクタの呼び出し
     209    ////////////////////////////
     210
     211    BOOL bSomeObjects;
     212    if(objectSizeStr[0]) bSomeObjects=1;
     213    else bSomeObjects=0;
     214    _call_constructor(&classObj,parameter,typeSize,bSomeObjects);
     215}
     216int Operator_New(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo ){
     217    char TypeName[VN_SIZE],CreateParameter[VN_SIZE],objectSizeStr[VN_SIZE];
    78218    int i,i2;
    79219
    … …  
    81221
    82222    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;
     223        i=GetStringInBracket(objectSizeStr,Parameter);
     224
     225        SlideString(objectSizeStr+1,-1);
     226        objectSizeStr[i-2]=0;
     227    }
     228    else objectSizeStr[0]=0;
    89229
    90230    for(i2=0;;i++,i2++){
    … …  
    129269    pobj_c=(CClass *)*plpIndex;
    130270
    131     if(pobj_c->IsAbstract()){
    132         //抽象クラスだったとき
    133         SetError(125,pobj_c->name,cp);
    134     }
    135 
    136     if(ObjectSize[0]){
    137         i2=NumOpe(ObjectSize,0,0,0);
    138         ChangeTypeToLong(i2);
    139 
    140         //pop eax
    141         op_pop(REG_EAX);
    142 
    143         //※添え字上限値であることを考慮
    144         //add eax,1
    145         OpBuffer[obp++]=(char)0x83;
    146         OpBuffer[obp++]=(char)0xC0;
    147         OpBuffer[obp++]=(char)0x01;
    148 
    149         //オブジェクトの個数をebxに一時保持
    150         //※ebxは関数が呼ばれても不変
    151         //mov ebx,eax
    152         OpBuffer[obp++]=(char)0x8B;
    153         OpBuffer[obp++]=(char)0xD8;
    154 
    155         //imul eax,size
    156         OpBuffer[obp++]=(char)0x69;
    157         OpBuffer[obp++]=(char)0xC0;
    158         *((long *)(OpBuffer+obp))=TypeSize;
    159         obp+=sizeof(long);
    160 
    161         //add eax,sizeof(DWORD)*2
    162         OpBuffer[obp++]=(char)0x05;
    163         *((long *)(OpBuffer+obp))=sizeof(DWORD)*3;
    164         obp+=sizeof(long);
    165 
    166         //push eax
    167         op_push(REG_EAX);
    168     }
    169     else{
    170         //オブジェクトの個数をebxに一時保持
    171         //※ebxは関数が呼ばれても不変
    172         //mov ebx,1
    173         OpBuffer[obp++]=(char)0xBB;
    174         *((long *)(OpBuffer+obp))=1;
    175         obp+=sizeof(long);
    176 
    177         //push size
    178         OpBuffer[obp++]=(char)0x68;
    179         *((long *)(OpBuffer+obp))=TypeSize+sizeof(DWORD)*3;
    180         obp+=sizeof(long);
    181     }
    182 
    183     //call calloc
    184     extern SUBINFO *pSub_calloc;
    185     op_call(pSub_calloc);
    186 
    187 
    188     /*
    189     確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
    190     pPtr-=sizeof(DWORD)*3
    191     pPtr[0]=オブジェクトの個数
    192     pPtr[1]=オブジェクトのサイズ
    193     pPtr[2]=デストラクタの関数ポインタ
    194     */
    195 
    196 
    197     //mov dword ptr[eax],ebx（オブジェクトの個数）
    198     OpBuffer[obp++]=(char)0x89;
    199     OpBuffer[obp++]=(char)0x18;
    200 
    201     //add eax,sizeof(DWORD)
    202     OpBuffer[obp++]=(char)0x05;
    203     *((long *)(OpBuffer+obp))=sizeof(DWORD);
    204     obp+=sizeof(long);
    205 
    206 
    207     //mov ecx,TypeSize
    208     OpBuffer[obp++]=(char)0xB9;
    209     *((long *)(OpBuffer+obp))=TypeSize;
    210     obp+=sizeof(long);
    211 
    212     //mov dword ptr[eax],ecx
    213     OpBuffer[obp++]=(char)0x89;
    214     OpBuffer[obp++]=(char)0x08;
    215 
    216     //add eax,sizeof(DWORD)
    217     OpBuffer[obp++]=(char)0x05;
    218     *((long *)(OpBuffer+obp))=sizeof(DWORD);
    219     obp+=sizeof(long);
    220 
    221 
    222     CMethod *method = pobj_c->GetDestructorMethod();
    223     if( method == NULL ) return 0;
    224 
    225     //mov ecx,DestructorProcAddr
    226     OpBuffer[obp++]=(char)0xB9;
    227     pobj_SubAddrSchedule->add(method->psi,0);
    228     method->psi->bUse=1;
    229     obp+=sizeof(long);
    230 
    231     //mov dword ptr[eax],ecx
    232     OpBuffer[obp++]=(char)0x89;
    233     OpBuffer[obp++]=(char)0x08;
    234 
    235     //add eax,sizeof(DWORD)
    236     OpBuffer[obp++]=(char)0x05;
    237     *((long *)(OpBuffer+obp))=sizeof(DWORD);
    238     obp+=sizeof(long);
    239 
    240 
    241     // ※ここでプッシュされた値はNew演算子の戻り値となる
    242     //push eax
    243     op_push(REG_EAX);
    244 
    245 
    246     /////////////////////////////////////////////////////////////////////
    247 
    248     ////////////////////////////
    249     // コンストラクタの呼び出し
    250     ////////////////////////////
    251 
    252     BOOL bSomeObjects;
    253     if(ObjectSize[0]) bSomeObjects=1;
    254     else bSomeObjects=0;
    255     _call_constructor(pobj_c,CreateParameter,TypeSize,bSomeObjects);
    256 
     271    Operator_New( *pobj_c, objectSizeStr, CreateParameter, baseTypeInfo );
     272
     273    if( baseTypeInfo.type == DEF_OBJECT ){
     274        return DEF_OBJECT;
     275    }
    257276    return DEF_PTR_OBJECT;
    258277}
    259278
    260 void OpcodeDelete(char *Parameter){
     279void OpcodeDelete(const char *Parameter, bool isSweeping){
    261280    int type;
    262281
    … …  
    355374    //////////////////////////////////////////
    356375
    357     //call free
    358     extern SUBINFO *pSub_free;
    359     op_call(pSub_free);
     376    if( isSweeping ){
     377        //call _System_GC_free_for_SweepingDelete
     378        extern SUBINFO *pSub_System_GC_free_for_SweepingDelete;
     379        op_call(pSub_System_GC_free_for_SweepingDelete);
     380    }
     381    else{
     382        //call free
     383        extern SUBINFO *pSub_free;
     384        op_call(pSub_free);
     385    }
    360386}

  • BasicCompiler32/Compile_ProcOp.cpp

    r63 r64  
    293293
    294294        LocalVar[MaxLocalVarNum].type=psi->pRealParmInfo[i3].type;
    295         if(LocalVar[MaxLocalVarNum].type==DEF_OBJECT){
    296             if(psi->bExport)
    297                 SetError(24,NULL,cp);
     295        if(LocalVar[MaxLocalVarNum].type==DEF_OBJECT
     296            ||LocalVar[MaxLocalVarNum].type==DEF_STRUCT){
     297                if(psi->bExport)
     298                    SetError(24,NULL,cp);
    298299        }
    299300
    300301        LocalVar[MaxLocalVarNum].u.index=psi->pRealParmInfo[i3].u.index;
    301302
    302         if(psi->pRealParmInfo[i3].bByVal&&psi->pRealParmInfo[i3].type==DEF_OBJECT){
    303             //実態オブジェクトのByValパラメータ
     303        if(psi->pRealParmInfo[i3].bByVal&&psi->pRealParmInfo[i3].type==DEF_STRUCT){
     304            //構造体のByValパラメータ
    304305            LocalVar[MaxLocalVarNum].fRef=REF_PARAMETER | OBJECT_PARAMETER;
    305306            VarSize=PTR_SIZE;
    … …  
    370371    OpBuffer[obp++]=(char)0x57;
    371372
    372     if(psi->ReturnType!=-1){
     373    if(psi->ReturnType!=DEF_NON){
    373374        //戻り値が存在するとき
    374375
    … …  
    377378        else temp=psi->name;
    378379
    379         if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
    380             //戻り値用オブジェクトのコンストラクタを呼び出す
    381             if( psi->u.Return_pobj_c->GetConstructorMethod() ){
    382                 sprintf(temporary,"%s.%s()",temp,psi->u.Return_pobj_c->name);
    383                 OpcodeOthers(temporary);
    384             }
     380        if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
     381            //戻り値用の構造体（値型）はパラメータで引き渡される
    385382        }
    386383        else{
    … …  
    517514            for(i3=0;i3<pobj_CompilingClass->iMemberNum;i3++){
    518515                CMember *pMember = pobj_CompilingClass->ppobj_Member[i3];
    519                 int MemberTypeSize=
    520                     GetTypeSize(pMember->TypeInfo.type,
    521                         pMember->TypeInfo.u.lpIndex);
    522 
    523                 int MemberObjectNum=
    524                     JumpSubScripts(pMember->SubScripts);
    525 
    526                 int offset = pobj_CompilingClass->GetMemberOffset( pMember->name, NULL );
    527 
    528                 if(pMember->TypeInfo.type==DEF_OBJECT && pMember->IsRef() == false){
    529                     CMethod *method = pMember->TypeInfo.u.pobj_Class->GetConstructorMethod();
    530                     if( method ){
    531                         if( method->psi->RealParmNum == 1 ){    //Thisポインタを第一引数に持ち合わせるため、引数なしの場合はこの値が1になる
    532                             for(i4=0;i4<MemberObjectNum;i4++){
    533                                 //Thisポインタをecxにコピー
    534                                 SetThisPtrToReg(REG_ECX);
    535 
    536                                 //add ecx,offset
    537                                 OpBuffer[obp++]=(char)0x81;
    538                                 OpBuffer[obp++]=(char)0xC1;
    539                                 *((long *)(OpBuffer+obp))=offset+i4*MemberTypeSize;
    540                                 obp+=sizeof(long);
    541 
    542                                 //push ecx
    543                                 op_push(REG_ECX);
    544 
    545                                 //call constructor
    546                                 op_call( method->psi );
    547                             }
    548                         }
    549                     }
     516                if(pMember->TypeInfo.type==DEF_OBJECT){
     517                    // オブジェクトメンバを発見したとき
     518
     519                    sprintf(temporary, "This.%s=%c%c%s()",
     520                        pMember->name,
     521                        1, ESC_NEW,
     522                        pMember->TypeInfo.u.pobj_Class->name );
     523                    OpcodeCalc( temporary );
    550524                }
    551525            }
    … …  
    619593            }
    620594
    621             //実体クラスを持つメンバのデストラクタを呼び出す
     595            //実体クラスを持つメンバのデストラクタ呼び出しはGCに任せる
     596            /*
    622597            //※コンストラクタと逆順序で呼び出す
    623598            int offset;
    … …  
    658633                    }
    659634                }
    660             }
     635            }*/
    661636        }
    662637    }
    … …  
    706681
    707682    if(bDebugCompile&&bDebugSupportProc==0){
    708         *((long *)(OpBuffer+EspOffsetSchedule))=AllLocalVarSize-BaseOffset;
     683        *((long *)(OpBuffer+EspOffsetSchedule))=AllLocalVarSize-BaseOffset-sizeof(long);
    709684
    710685        //call _DebugSys_EndProc
    … …  
    713688    }
    714689
    715     if(psi->ReturnType!=-1){
     690    if(psi->ReturnType!=DEF_NON){
    716691        //戻り値をeax、edxに設定
    717692        RELATIVE_VAR RelativeVar;
    … …  
    726701        i3=psi->ReturnType;
    727702
    728         if(i3==DEF_OBJECT){
     703        if(i3==DEF_OBJECT || i3==DEF_STRUCT){
    729704            SetVarPtrToEax(&RelativeVar);
     705            if( i3==DEF_OBJECT ){
     706                //mov eax,dword ptr[eax]
     707                op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
     708            }
    730709        }
    731710        else if(i3==DEF_DOUBLE){
    … …  
    818797    op_pop(REG_EBX);
    819798
     799    if(bDebugCompile){
     800        //cmp esp,ebp
     801        op_cmp_RR( REG_ESP, REG_EBP );
     802
     803        //jz 6（次のcallとbreakpointを飛び越す）
     804        OpBuffer[obp++]=(char)0x74;
     805        OpBuffer[obp++]=(char)0x06;
     806
     807        //call _esp_error
     808        extern SUBINFO *pSub_esp_error;
     809        op_call( pSub_esp_error );
     810
     811        breakpoint;
     812    }
     813
    820814    //mov esp,ebp
    821815    OpBuffer[obp++]=(char)0x8B;

  • BasicCompiler32/Compile_Set_Var.cpp

    r63 r64  
    77}
    88
    9 void SetObjectVariable(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,BOOL bUseHeap){
     9void SetStructVariable(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,BOOL bUseHeap){
     10/*
     11    TODO: 消す
    1012    ///////////////////////////////////////////////////////////////////
    1113    // オペレータ '=' のオーバーロード関数を呼ぶ
    … …  
    3234        //成功したとき、またはエラーが発行されたとき
    3335        return;
    34     }
    35 
    36 
    37     if( CalcType == DEF_OBJECT ){
     36    }*/
     37
     38
     39    if( CalcType == DEF_STRUCT ){
    3840        CClass *pVarClass = (CClass *)lpVarIndex;
    3941        CClass *pCalcClass = (CClass *)lpCalcIndex;
    4042
    4143
    42         if( pVarClass->IsEquals( pCalcClass )           //等しい
    43             || pVarClass->IsSubClass( pCalcClass ) ){   //派生・継承関係
     44        if( pVarClass->IsEquals( pCalcClass ) ){        //等しい
    4445
    4546                //双方のオブジェクト型が一致、または派生・継承関係にあるとき
    … …  
    8182}
    8283
     84
     85void SetRealVariable(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
     86    if( !IsRealNumberType( CalcType ) ){
     87        // 実数へ変換
     88        // 64bit edx:eax -> st(0)
     89        // 32bit     eax -> st(0)
     90
     91        if( Is64Type( CalcType ) ){
     92            //64ビット整数型
     93
     94            //push edx
     95            op_push( REG_EDX );
     96
     97            //push eax
     98            op_push( REG_EAX );
     99
     100            //fild qword ptr[esp]
     101            op_fld_ptr_esp(DEF_INT64);
     102
     103            //pop
     104            op_pop( REG_NON );
     105
     106            //pop
     107            op_pop( REG_NON );
     108        }
     109        else{
     110            //push eax
     111            op_push( REG_EAX );
     112
     113            //fild qword ptr[esp]
     114            op_fld_ptr_esp(DEF_LONG);
     115
     116            //pop
     117            op_pop( REG_NON );
     118        }
     119    }
     120
     121    if(pRelativeVar->dwKind==VAR_GLOBAL){
     122        if(pRelativeVar->bOffsetOffset){
     123            //fstp ptr[ecx+offset]
     124            op_fstp_base_offset(VarType,REG_ECX,(int)pRelativeVar->offset);
     125            obp-=sizeof(long);
     126            pobj_GlobalVarSchedule->add();
     127            obp+=sizeof(long);
     128        }
     129        else{
     130            //mov ecx,offset
     131            op_mov_RV(REG_ECX,(int)pRelativeVar->offset);
     132            obp-=sizeof(long);
     133            pobj_GlobalVarSchedule->add();
     134            obp+=sizeof(long);
     135
     136            //fstp ptr[ecx]
     137            op_fstp_basereg(VarType,REG_ECX);
     138        }
     139    }
     140    else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
     141        if(pRelativeVar->bOffsetOffset){
     142            //add ecx,qword ptr[offset]
     143            op_add_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
     144        }
     145        else{
     146            //mov ecx,qword ptr[offset]
     147            op_mov_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
     148        }
     149        obp-=sizeof(long);
     150        pobj_GlobalVarSchedule->add();
     151        obp+=sizeof(long);
     152
     153        goto directmem;
     154    }
     155    else if(pRelativeVar->dwKind==VAR_LOCAL){
     156        if(pRelativeVar->bOffsetOffset){
     157            //fstp ptr[ebp+ecx+offset]
     158            op_fstp_base_offset_ex(VarType,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);
     159        }
     160        else{
     161            //fstp ptr[ebp+offset]
     162            op_fstp_base_offset(VarType,REG_EBP,(int)pRelativeVar->offset);
     163        }
     164        obp-=sizeof(long);
     165        AddLocalVarAddrSchedule();
     166        obp+=sizeof(long);
     167    }
     168    else if(pRelativeVar->dwKind==VAR_REFLOCAL){
     169        if(pRelativeVar->bOffsetOffset){
     170            //add ecx,qword ptr[ebp+offset]
     171            op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     172        }
     173        else{
     174            //mov ecx,qword ptr[ebp+offset]
     175            op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
     176        }
     177        obp-=sizeof(long);
     178        AddLocalVarAddrSchedule();
     179        obp+=sizeof(long);
     180
     181        goto directmem;
     182    }
     183    else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
     184directmem:
     185        //fstp ptr[ecx]
     186        op_fstp_basereg(VarType,REG_ECX);
     187    }
     188}
     189
     190void SetBooleanVariable(int type,RELATIVE_VAR *pRelative){
     191    if(type==DEF_DOUBLE){
     192        // TODO: 実装
     193        SetError();
     194    }
     195    else if(type==DEF_SINGLE){
     196        // TODO: 実装
     197        SetError();
     198    }
     199    else if(type==DEF_INT64||type==DEF_QWORD){
     200        //cmp eax,0
     201        op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
     202
     203        //setne al
     204        op_setne( REG_EAX );
     205
     206        //cmp edx,0
     207        op_cmp_value(GetTypeSize(type,-1),REG_EDX,0);
     208
     209        //setne cl
     210        op_setne( REG_ECX );
     211
     212        //or al,cl
     213        op_or_RR( sizeof( _int8 ), REG_EAX, REG_ECX );
     214    }
     215    else{
     216        if(!IsWholeNumberType(type)){
     217            //不正な型の場合
     218            SetError(9,NULL,cp);
     219            return;
     220        }
     221    }
     222
     223    //cmp eax,0
     224    op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
     225
     226    //setne al
     227    op_setne( REG_EAX );
     228
     229    SetWholeVariable( sizeof(char), DEF_BYTE, pRelative );
     230}
     231
     232void ExtendTypeTo32(int type,int reg);
     233void ExtendTypeTo64(int type){
     234    if(Is64Type(type)) return;
     235
     236    ExtendTypeTo32(type,REG_EAX);
     237
     238    if(IsSignedType(type)){
     239        //cdq
     240        op_cdq();
     241    }
     242    else{
     243        //xor edx,edx
     244        op_zero_reg(REG_EDX);
     245    }
     246}
     247void ExtendTypeTo32(int type,int reg){
     248    if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){
     249        //movsx reg32,reg16
     250        op_movsx_R32R16(reg,reg);
     251    }
     252    else if(type==DEF_WORD){
     253        //and reg,0000FFFFh
     254        op_and_RV(reg,(int)0x0000FFFF);
     255    }
     256    else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
     257        //movsx reg32,reg8
     258        op_movsx_R32R8(reg,reg);
     259    }
     260    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
     261        //and reg,000000FFh
     262        op_and_RV(reg,(int)0xFF);
     263    }
     264}
     265void ExtendTypeTo16(int type,int reg){
     266    if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
     267        //movsx reg16,reg8
     268        op_movsx_R16R8(reg,reg);
     269    }
     270    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
     271        //and reg,000000FFh
     272        op_and_RV(reg,(int)0xFF);
     273    }
     274}
     275
     276void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative){
     277    if(type==DEF_DOUBLE){
     278        //Double型
     279        // st(0)の内容をedx:eaxに変換
     280
     281        //TODO: 実装
     282        SetError();
     283    }
     284    else if(type==DEF_SINGLE){
     285        //Single型
     286        // st(0)の内容をeaxに変換
     287
     288        //TODO: 実装
     289        SetError();
     290    }
     291    else{
     292        //その他の整数
     293
     294        if(var_size==sizeof(_int64)){
     295            //eaxの値を64ビット（edx:eax）に拡張する
     296            ExtendTypeTo64(type);
     297        }
     298        else if(var_size==sizeof(long)){
     299            //レジスタの値を32ビット（eax）に拡張する
     300            ExtendTypeTo32(type,REG_EAX);
     301        }
     302        else if(var_size==sizeof(short)){
     303            //レジスタの値を16ビット（ax）に拡張する
     304            ExtendTypeTo16(type,REG_EAX);
     305        }
     306        //8ビットは拡張なし
     307    }
     308
     309    if(var_size==sizeof(_int64)){
     310        //下位32ビット
     311        SetWholeVariable(sizeof(long),DEF_LONG,pRelative);
     312
     313        //mov eax,edx
     314        op_mov_RR( REG_EAX, REG_EDX );
     315
     316        //上位32ビット
     317        if( pRelative->dwKind == VAR_DIRECTMEM ){
     318            //add ecx,sizeof(long)
     319            op_add_RV8( REG_ECX, sizeof(long) );
     320        }
     321        pRelative->offset+=sizeof(long);
     322        SetWholeVariable(sizeof(long),DEF_LONG,pRelative);
     323        pRelative->offset-=sizeof(long);
     324
     325        return;
     326    }
     327
     328    if(pRelative->dwKind==VAR_GLOBAL){
     329        if(pRelative->bOffsetOffset){
     330            //mov ptr[ecx+offset],eax/ax/al
     331            op_mov_MR(var_size,REG_EAX,REG_ECX,(int)pRelative->offset,MOD_BASE_DISP32);
     332        }
     333        else{
     334            //mov ptr[offset],eax/ax/al
     335            op_mov_MR(var_size,REG_EAX,0,(int)pRelative->offset,MOD_DISP32);
     336        }
     337        obp-=sizeof(long);
     338        pobj_GlobalVarSchedule->add();
     339        obp+=sizeof(long);
     340    }
     341    else if(pRelative->dwKind==VAR_REFGLOBAL){
     342        if(pRelative->bOffsetOffset){
     343            //add ecx,qword ptr[offset]
     344            op_add_RM(var_size,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
     345        }
     346        else{
     347            //mov ecx,qword ptr[offset]
     348            op_mov_RM(var_size,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
     349        }
     350        obp-=sizeof(long);
     351        pobj_GlobalVarSchedule->add();
     352        obp+=sizeof(long);
     353
     354        goto directmem;
     355    }
     356    else if(pRelative->dwKind==VAR_LOCAL){
     357        if(pRelative->bOffsetOffset){
     358            //mov ptr[ebp+ecx+offset],eax/ax/al
     359            op_mov_MR_ex(var_size,REG_EAX,REG_EBP,REG_ECX,(int)pRelative->offset,USE_OFFSET);
     360        }
     361        else{
     362            //mov ptr[ebp+offset],eax/ax/al
     363            op_mov_MR(var_size,REG_EAX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
     364        }
     365        obp-=sizeof(long);
     366        AddLocalVarAddrSchedule();
     367        obp+=sizeof(long);
     368    }
     369    else if(pRelative->dwKind==VAR_REFLOCAL){
     370        if(pRelative->bOffsetOffset){
     371            //add ecx,qword ptr[ebp+offset]
     372            op_add_RM(var_size,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
     373        }
     374        else{
     375            //mov ecx,qword ptr[ebp+offset]
     376            op_mov_RM(var_size,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
     377        }
     378        obp-=sizeof(long);
     379        AddLocalVarAddrSchedule();
     380        obp+=sizeof(long);
     381
     382        goto directmem;
     383    }
     384    else if(pRelative->dwKind==VAR_DIRECTMEM){
     385directmem:
     386
     387        //mov ptr[ecx],eax/ax/al
     388        op_mov_MR(var_size,REG_EAX,REG_ECX,0,MOD_BASE);
     389    }
     390}
     391
     392
     393
     394
     395
     396
     397
     398
     399
     400
     401
     402
     403
     404
     405
     406
     407
     408
     409
     410
     411
     412
     413
     414
     415
     416/*
     417TODO: 消す
    83418void SetDoubleVariable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset){
    84419    ChangeTypeToDouble(type);
    … …  
    9721307    }
    9731308}
    974 void SetBooleanVariable(int type,RELATIVE_VAR *pRelative){
    975     if(type==DEF_DOUBLE){
    976         // TODO: 実装
    977     }
    978     else if(type==DEF_SINGLE){
    979         // TODO: 実装
    980     }
    981     else if(type==DEF_INT64||type==DEF_QWORD){
    982         // TODO: 実装
    983 
    984         //pop eax
    985         op_pop(REG_EAX);
    986 
    987         //cmp eax,0
    988         op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
    989 
    990         //setne al
    991         op_setne( REG_EAX );
    992 
    993         //pop ecx
    994         op_pop(REG_ECX);
    995 
    996         //cmp ecx,0
    997         op_cmp_value(GetTypeSize(type,-1),REG_ECX,0);
    998 
    999         //setne cl
    1000         op_setne( REG_ECX );
    1001 
    1002         //or al,cl
    1003         op_or_RR( sizeof( _int8 ), REG_EAX, REG_ECX );
    1004     }
    1005     else{
    1006         if(!IsWholeNumberType(type)){
    1007             //不正な型の場合
    1008             SetError(9,NULL,cp);
    1009             return;
    1010         }
    1011 
    1012         //pop eax
    1013         op_pop(REG_EAX);
    1014     }
    1015 
    1016     //cmp eax,0
    1017     op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
    1018 
    1019     //setne al
    1020     op_setne( REG_EAX );
    1021 
    1022     //push eax
    1023     op_push(REG_EAX);
    1024 
    1025     Set8Variable(DEF_BYTE,pRelative->dwKind,pRelative->offset,pRelative->bOffsetOffset);
    1026 }
     1309*/

  • BasicCompiler32/Compile_Statement.cpp

    r55 r64  
    105105            OpBuffer[obp++]=(char)0xD8;
    106106        }
    107         if(i2==DEF_OBJECT){
     107        if(i2==DEF_STRUCT){
    108108            //mov ebx,eax
    109109            op_mov_RR(REG_EBX,REG_EAX);
    … …  
    13361336            else temp=pCompilingSubInfo->name;
    13371337
     1338            /*
     1339            TODO: 消す
    13381340            if( pCompilingSubInfo->isReturnRef ){
    13391341                //参照型
    … …  
    13411343            }
    13421344            else{
    1343                 //値型
     1345                //値型*/
    13441346                char temporary[VN_SIZE];
    13451347                sprintf(temporary,"%s=%s",temp,Parameter);
    13461348                OpcodeCalc(temporary);
    1347             }
     1349            //}
    13481350        }
    13491351
    … …  
    13531355}
    13541356
    1355 void Opcode_Input(char *Parameter){
     1357void Opcode_Input(const char *Parameter){
    13561358    extern int cp;
    13571359    int i2,i3,i4,i5,type;
    13581360    BOOL bFile;
    13591361    char temporary[VN_SIZE],temp2[VN_SIZE],buffer[VN_SIZE];
    1360 
    1361     KillStringSpaces(Parameter);
    13621362
    13631363    if(Parameter[0]=='#'){
    … …  
    14691469    Opcode_CallProc(buffer,psi,0,"",0);
    14701470}
    1471 void Opcode_PrintUsing(char *Parameter,char *buffer,BOOL bFile){
     1471void Opcode_PrintUsing(const char *Parameter,char *buffer,BOOL bFile){
    14721472    extern int cp;
    14731473    int i2,i3,i4,i5;
    … …  
    14751475    BOOL bReturnLine;
    14761476
    1477     i2=lstrlen(Parameter);
    1478     if(Parameter[i2-1]==';'){
     1477    char parms[8192];
     1478    lstrcpy( parms, Parameter );
     1479
     1480    i2=lstrlen(parms);
     1481    if(parms[i2-1]==';'){
    14791482        bReturnLine=0;
    1480         Parameter[i2-1]=0;
     1483        parms[i2-1]=0;
    14811484    }
    14821485    else bReturnLine=1;
    … …  
    14841487    i3=lstrlen(buffer);
    14851488    for(i2=0;;i2++,i3++){
    1486         if(Parameter[i2]==';'){
     1489        if(parms[i2]==';'){
    14871490            buffer[i3]=0;
    14881491            break;
    14891492        }
    1490         buffer[i3]=Parameter[i2];
    1491         if(Parameter[i2]=='\0') break;
    1492     }
    1493     if(Parameter[i2]==';') i2++;
     1493        buffer[i3]=parms[i2];
     1494        if(parms[i2]=='\0') break;
     1495    }
     1496    if(parms[i2]==';') i2++;
    14941497
    14951498    if(bReturnLine) lstrcat(buffer,"+Ex\"\\r\\n\"");
    … …  
    14991502    while(1){
    15001503        for(i3=0;;i2++,i3++){
    1501             if(Parameter[i2]=='\"'){
    1502                 temporary[i3]=Parameter[i2];
     1504            if(parms[i2]=='\"'){
     1505                temporary[i3]=parms[i2];
    15031506                for(i2++,i3++;;i2++,i3++){
    1504                     temporary[i3]=Parameter[i2];
    1505                     if(Parameter[i2]=='\"') break;
     1507                    temporary[i3]=parms[i2];
     1508                    if(parms[i2]=='\"') break;
    15061509                }
    15071510                continue;
    15081511            }
    1509             if(Parameter[i2]=='('){
    1510                 i5=GetStringInPare(temporary+i3,Parameter+i2);
     1512            if(parms[i2]=='('){
     1513                i5=GetStringInPare(temporary+i3,parms+i2);
    15111514                i2+=i5-1;
    15121515                i3+=i5-1;
    15131516                continue;
    15141517            }
    1515             if(Parameter[i2]=='['){
    1516                 i5=GetStringInBracket(temporary+i3,Parameter+i2);
     1518            if(parms[i2]=='['){
     1519                i5=GetStringInBracket(temporary+i3,parms+i2);
    15171520                i2+=i5-1;
    15181521                i3+=i5-1;
    15191522                continue;
    15201523            }
    1521             if(Parameter[i2]==','){
     1524            if(parms[i2]==','){
    15221525                temporary[i3]=0;
    15231526                i2++;
    15241527                break;
    15251528            }
    1526             temporary[i3]=Parameter[i2];
    1527             if(Parameter[i2]=='\0') break;
     1529            temporary[i3]=parms[i2];
     1530            if(parms[i2]=='\0') break;
    15281531        }
    15291532        if(temporary[0]=='\0'){
    … …  
    15541557
    15551558        i4++;
    1556         if(Parameter[i2]=='\0') break;
     1559        if(parms[i2]=='\0') break;
    15571560    }
    15581561    sprintf(temp2,"_System_UsingDataType[%d]=-1",i4);
    … …  
    15681571    Opcode_CallProc(buffer,psi,0,"",0);
    15691572}
    1570 void Opcode_Print(char *Parameter,BOOL bWrite){
     1573void Opcode_Print(const char *Parameter,BOOL bWrite){
    15711574    int i2,i3,i4,sw;
    15721575    char temporary[VN_SIZE],buffer[VN_SIZE];
    15731576    BOOL bFile;
    1574 
    1575     KillStringSpaces(Parameter);
    15761577
    15771578    if(Parameter[0]=='#'){

  • BasicCompiler32/Compile_Var.cpp

    r63 r64  
    2323
    2424    if(PTR_LEVEL(*pType)){
    25         *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
    26         if((*pType)==DEF_OBJECT){
    27             CClass *pClass = (CClass *)lpIndex;
    28             int objsize = pClass->GetSize();
    29 
    30             //imul ebx,objsize
    31             OpBuffer[obp++]=(char)0x69;
    32             OpBuffer[obp++]=(char)0xDB;
    33             *((long *)(OpBuffer+obp))=objsize;
    34             obp+=sizeof(long);
    35         }
    36         else{
    37             i2=GetTypeSize(*pType,-1);
    38             if(i2>=2){
    39                 //imul ebx,i2
    40                 OpBuffer[obp++]=(char)0x6B;
    41                 OpBuffer[obp++]=(char)0xDB;
    42                 OpBuffer[obp++]=(char)i2;
    43             }
     25        *pType = PTR_LEVEL_DOWN( *pType );
     26
     27        i2=GetTypeSize(*pType,-1);
     28        if(i2>=2){
     29            //imul ebx,i2
     30            op_imul_RV( REG_EBX, i2 );
    4431        }
    4532    }
    … …  
    5643    OpBuffer[obp++]=(char)0x03;
    5744    OpBuffer[obp++]=(char)0xCB;
     45}
     46void SetRelativeOffset( RELATIVE_VAR &relativeVar ){
     47    if(relativeVar.dwKind==VAR_DIRECTMEM){
     48        //mov ecx,dword ptr[ecx]
     49        op_mov_RM( sizeof(long), REG_ECX, REG_ECX, 0, MOD_BASE );
     50    }
     51    else{
     52        //直接参照に切り替え
     53        SetVarPtrToEax(&relativeVar);
     54        relativeVar.dwKind=VAR_DIRECTMEM;
     55
     56        //mov ecx,dword ptr[eax]
     57        op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
     58    }
    5859}
    5960BOOL GetArrayOffset(int *SubScripts,char *array,int type,LONG_PTR lpIndex){
    … …  
    168169    char lpPtrOffset[VN_SIZE];  //第2次配列
    169170    char NestMember[VN_SIZE];   //入れ子メンバ
    170     int RefType;                //"."参照のときは0、"->"参照のときは1
     171    CClass::RefType refType;
    171172    lstrcpy(VarName,member);
    172     if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;
     173    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
    173174
    174175    ////////////////////////////
    … …  
    251252        //入れ子構造の場合
    252253
    253         if(*pType==DEF_OBJECT){
    254             if(RefType!=DEF_OBJECT){
     254        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
     255            if( refType != CClass::Dot ){
    255256                if(isErrorEnabled) SetError(104,member,cp);
    256257                return 0;
    257258            }
    258         }
    259         else if(*pType==DEF_PTR_OBJECT){
     259
     260            if( *pType==DEF_OBJECT ){
     261                // 参照内容へのポインタを抽出
     262                SetRelativeOffset( *pRelativeVar );
     263            }
     264        }
     265        else if(*pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT){
    260266            //構造体ポインタ型メンバ変数
    261267
    262268            if(lpPtrOffset[0]){
    263269                //pObj[n].member
    264                 if(RefType!=DEF_OBJECT){
     270                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Dot ){
    265271                    if(isErrorEnabled) SetError(104,member,cp);
    266272                    return 0;
    … …  
    275281            else{
    276282                //pObj->member
    277                 if(RefType!=DEF_PTR_OBJECT){
     283                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Pointer ){
    278284                    if(isErrorEnabled) SetError(104,member,cp);
    279285                    return 0;
    280286                }
    281287
    282                 if(pRelativeVar->dwKind==VAR_DIRECTMEM){
    283                     //mov ecx,dword ptr[ecx]
    284                     OpBuffer[obp++]=(char)0x8B;
    285                     OpBuffer[obp++]=(char)0x09;
    286                 }
    287                 else{
    288                     //直接参照に切り替え
    289                     SetVarPtrToEax(pRelativeVar);
    290                     pRelativeVar->dwKind=VAR_DIRECTMEM;
    291 
    292                     //mov ecx,dword ptr[eax]
    293                     OpBuffer[obp++]=(char)0x8B;
    294                     OpBuffer[obp++]=(char)0x08;
    295                 }
    296             }
    297         }
    298         else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
     288                SetRelativeOffset( *pRelativeVar );
     289            }
     290        }
     291        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
    299292            //構造体ポインタのポインタ型メンバ変数
    300293
    301294            if(lpPtrOffset[0]){
    302295                //ppObj[n]->member
    303                 if(RefType!=DEF_PTR_OBJECT){
     296                if( refType != CClass::Pointer ){
    304297                    if(isErrorEnabled) SetError(104,member,cp);
    305298                    return 0;
    … …  
    364357BOOL GetVarOffset(bool isErrorEnabled, bool isWriteAccess, const char *NameBuffer, int *pType, RELATIVE_VAR *pRelativeVar, LONG_PTR *plpIndex, int *pss){
    365358    extern BOOL bCompilingGlobal;
    366     int i,RefType;
     359    int i;
    367360    LONG_PTR lpIndex;
    368361    char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    … …  
    374367    else lstrcpy(variable,NameBuffer);
    375368
    376 
    377     if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
     369    CClass::RefType refType;
     370    if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){
    378371        // 戻り値オブジェクトのメンバを直接参照しているとき
    379372        //例: func().member
    … …  
    410403
    411404    lstrcpy(VarName,variable);
    412     GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
     405    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
    413406
    414407    int *pSubScripts;
    … …  
    546539    if(member[0]){
    547540        lstrcpy(temporary,member);
     541
    548542        char tempMember[VN_SIZE];
    549543        char tempArray[VN_SIZE];
    550         GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);
     544        {
     545            CClass::RefType refType;
     546            GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
     547        }
    551548
    552549        char temp2[VN_SIZE];
    … …  
    665662    }
    666663    if(member[0]){
    667         if(*pType==DEF_OBJECT){
     664        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
    668665            //実態オブジェクトのメンバを参照（obj.member）
    669             if(RefType!=DEF_OBJECT){
     666            if( refType != CClass::Dot ){
    670667                SetError(104,VarName,cp);
    671668                pRelativeVar->dwKind=NON_VAR;
    672669                return 0;
    673670            }
    674         }
    675         else if(*pType==DEF_PTR_OBJECT){
     671
     672            if( *pType==DEF_OBJECT ){
     673                // 参照内容へのポインタを抽出
     674                SetRelativeOffset( *pRelativeVar );
     675            }
     676        }
     677        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
    676678            //ポインタオブジェクトが示すメンバを参照
    677679            if(lpPtrOffset[0]){
    678680                //pObj[n].member
    679                 if(RefType!=DEF_OBJECT){
     681                if( refType != CClass::Dot ){
    680682                    SetError(104,VarName,cp);
    681683                    pRelativeVar->dwKind=NON_VAR;
    … …  
    687689            else{
    688690                //pObj->member
    689                 if(RefType!=DEF_PTR_OBJECT){
     691                if( refType != CClass::Pointer ){
    690692                    SetError(104,VarName,cp);
    691693                    pRelativeVar->dwKind=NON_VAR;
    … …  
    701703            }
    702704        }
    703         else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
     705        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
    704706            //ポインタオブジェクトが示すメンバを参照
    705707            if(lpPtrOffset[0]){
    706708                //ppObj[n]->member
    707                 if(RefType!=DEF_PTR_OBJECT){
     709                if( refType != CClass::Pointer ){
    708710                    SetError(104,VarName,cp);
    709711                    pRelativeVar->dwKind=NON_VAR;
    … …  
    785787        }
    786788
    787         if(type==DEF_OBJECT){
     789        if(type==DEF_STRUCT){
    788790            CClass *pobj_c;
    789791            pobj_c=(CClass *)lpIndex;
    … …  
    818820    ///////////////////////////////////////
    819821
    820     if( type == DEF_OBJECT){
    821         //オブジェクトの場合はありえない
     822    if( type == DEF_OBJECT || type == DEF_STRUCT ){
     823        //オブジェクトまたは構造体の場合はありえない
    822824        SetError(300,NULL,cp);
    823825        return 0;
    … …  
    855857        *(_int64 *)(initGlobalBuf+offset)=i64data;
    856858    else if(type==DEF_LONG||type==DEF_DWORD||IsPtrType(type)){
    857         if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
     859        if(type==DEF_PTR_CHAR&&lpCalcIndex==LITERAL_STRING){
    858860            //文字列定数のとき
    859861
    … …  
    918920        }
    919921
    920         if(type==DEF_OBJECT){
     922        if(type==DEF_STRUCT){
    921923            CClass *pobj_c;
    922924            pobj_c=(CClass *)lpIndex;
    … …  
    10451047    }
    10461048    else if(type==DEF_LONG||type==DEF_DWORD||IsPtrType(type)){
    1047         if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
     1049        if(type==DEF_PTR_CHAR&&lpCalcIndex==LITERAL_STRING){
    10481050            //文字列定数のとき
    10491051
    … …  
    11021104}
    11031105
     1106void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags){
     1107    extern BOOL bCompilingGlobal;
     1108    if(bCompilingGlobal){
     1109        /////////////////////////
     1110        // グローバル変数
     1111        /////////////////////////
     1112
     1113        AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
     1114    }
     1115    else{
     1116        /////////////////
     1117        // ローカル変数
     1118        /////////////////
     1119
     1120        int i2,i3;
     1121
     1122        for(i2=0;i2<MaxLocalVarNum;i2++){
     1123            if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
     1124                if(lstrcmp(LocalVar[i2].name,VarName)==0){
     1125                    //２重定義のエラー
     1126                    SetError(15,VarName,cp);
     1127                    return;
     1128                }
     1129            }
     1130        }
     1131
     1132        LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
     1133        VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
     1134        MaxLocalVarNum++;
     1135
     1136        if( isRef ){
     1137            //参照型
     1138            pVar->fRef = REF_VARIABLE;
     1139            TypeSize = PTR_SIZE;
     1140        }
     1141        else pVar->fRef=0;
     1142
     1143        for(i2=1,i3=0;i3<255;i3++){
     1144            //配列要素数
     1145            pVar->SubScripts[i3]=SubScripts[i3];
     1146
     1147            if(SubScripts[i3]==-1) break;
     1148            i2*=SubScripts[i3]+1;
     1149        }
     1150        int VarSize=TypeSize*i2;
     1151        if(VarSize%4) VarSize+=4-(VarSize%4);
     1152
     1153        //変数データを追加
     1154        lstrcpy(pVar->name,VarName);
     1155        if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
     1156        else pVar->bConst = false;
     1157        if(SubScripts[0]==-1) pVar->bArray=0;
     1158        else pVar->bArray=1;
     1159        pVar->type=TypeInfo.type;
     1160        pVar->u.index=TypeInfo.u.lpIndex;
     1161        AllLocalVarSize+=VarSize;
     1162        pVar->offset=AllLocalVarSize;
     1163
     1164        //レキシカルスコープ
     1165        pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
     1166        pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
     1167        pVar->bLiving=TRUE;
     1168
     1169        if(InitBuf[0]){
     1170            //初期代入時のみ、書き込みアクセスを許可する
     1171            bool bConstBack = pVar->bConst;
     1172            pVar->bConst = false;
     1173
     1174            int result = 0;
     1175            if( pVar->type != DEF_OBJECT ){
     1176                result = InitLocalVar(-pVar->offset,
     1177                    pVar->type,
     1178                    pVar->u.index,
     1179                    pVar->SubScripts,
     1180                    InitBuf);
     1181            }
     1182
     1183            if(!result){
     1184                //動的な式だった場合は代入演算を行う
     1185                char temporary[8192];
     1186                sprintf(temporary,"%s=%s",VarName,InitBuf);
     1187                OpcodeCalc(temporary);
     1188            }
     1189
     1190            pVar->bConst = bConstBack;
     1191        }
     1192        else{
     1193            //push 0
     1194            op_push_value(0);
     1195
     1196            //push VarSize
     1197            op_push_value(VarSize);
     1198
     1199            //mov eax,ebp
     1200            OpBuffer[obp++]=(char)0x8B;
     1201            OpBuffer[obp++]=(char)0xC5;
     1202
     1203            //add eax,offset
     1204            OpBuffer[obp++]=(char)0x05;
     1205            *((long *)(OpBuffer+obp))=-pVar->offset;
     1206            AddLocalVarAddrSchedule();
     1207            obp+=sizeof(long);
     1208
     1209            //push eax
     1210            op_push(REG_EAX);
     1211
     1212            //call FillMemory
     1213            OpBuffer[obp++]=(char)0xFF;
     1214            OpBuffer[obp++]=(char)0x15;
     1215            DECLAREINFO *pdi;
     1216            pdi=GetDeclareHash("FillMemory");
     1217            pdi->bUse=1;
     1218            pobj_ImportAddrSchedule->add(pdi);
     1219            obp+=sizeof(long);
     1220        }
     1221    }
     1222
     1223    //New呼び出し
     1224    if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
     1225        char objectSize[255];
     1226        if( SubScripts[0] == -1 ){
     1227            objectSize[0] = 0;
     1228        }
     1229        else{
     1230            if( SubScripts[1] != -1 ){
     1231                SetError(300,NULL,cp);
     1232            }
     1233            sprintf( objectSize, "%d", SubScripts[0] );
     1234        }
     1235        Operator_New( *TypeInfo.u.pobj_Class, objectSize, ConstractParameter, TypeInfo );
     1236
     1237        //pop eax
     1238        op_pop( REG_EAX );
     1239
     1240        int type;
     1241        LONG_PTR lpIndex;
     1242        RELATIVE_VAR RelativeVar;
     1243        GetVarOffset( true, false, VarName, &type, &RelativeVar, &lpIndex );
     1244        if( RelativeVar.dwKind == VAR_DIRECTMEM ){
     1245            SetError();
     1246        }
     1247        SetVariableFromEax( DEF_OBJECT, DEF_OBJECT, &RelativeVar );
     1248    }
     1249
     1250    if(TypeInfo.type==DEF_OBJECT){
     1251        if(TypeInfo.u.pobj_Class->IsAbstract()){
     1252            //抽象クラスだったとき
     1253            SetError(125,TypeInfo.u.pobj_Class->name,cp);
     1254        }
     1255    }
     1256}
    11041257void dim(char *Parameter,DWORD dwFlags){
    11051258    extern BOOL bCompilingGlobal;
    11061259    extern HANDLE hHeap;
    1107     int i2,i3,VarSize;
     1260    int i2;
    11081261    char VarName[VN_SIZE];
    11091262
    … …  
    11871340        GetNowStaticVarFullName(VarName,temporary);
    11881341
    1189         AddGlobalVariable(isRef, temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
     1342        dim( isRef,temporary,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
    11901343
    11911344        /*
    … …  
    11951348    }
    11961349    else{
    1197         if(bCompilingGlobal){
    1198             /////////////////////////
    1199             // グローバル変数
    1200             /////////////////////////
    1201 
    1202             AddGlobalVariable(isRef, VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
    1203         }
    1204         else{
    1205             /////////////////
    1206             // ローカル変数
    1207             /////////////////
    1208 
    1209             for(i2=0;i2<MaxLocalVarNum;i2++){
    1210                 if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
    1211                     if(lstrcmp(LocalVar[i2].name,VarName)==0){
    1212                         //２重定義のエラー
    1213                         SetError(15,VarName,cp);
    1214                         return;
    1215                     }
    1216                 }
    1217             }
    1218 
    1219             LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
    1220             VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
    1221             MaxLocalVarNum++;
    1222 
    1223             if( isRef ){
    1224                 //参照型
    1225                 pVar->fRef = REF_VARIABLE;
    1226                 TypeSize = PTR_SIZE;
    1227             }
    1228             else pVar->fRef=0;
    1229 
    1230             for(i2=1,i3=0;i3<255;i3++){
    1231                 //配列要素数
    1232                 pVar->SubScripts[i3]=SubScripts[i3];
    1233 
    1234                 if(SubScripts[i3]==-1) break;
    1235                 i2*=SubScripts[i3]+1;
    1236             }
    1237             VarSize=TypeSize*i2;
    1238             if(VarSize%4) VarSize+=4-(VarSize%4);
    1239 
    1240             //変数データを追加
    1241             lstrcpy(pVar->name,VarName);
    1242             if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
    1243             else pVar->bConst = false;
    1244             if(SubScripts[0]==-1) pVar->bArray=0;
    1245             else pVar->bArray=1;
    1246             pVar->type=TypeInfo.type;
    1247             pVar->u.index=TypeInfo.u.lpIndex;
    1248             AllLocalVarSize+=VarSize;
    1249             pVar->offset=AllLocalVarSize;
    1250 
    1251             //レキシカルスコープ
    1252             pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    1253             pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
    1254             pVar->bLiving=TRUE;
    1255 
    1256             if(InitBuf[0]){
    1257                 //初期代入時のみ、書き込みアクセスを許可する
    1258                 bool bConstBack = pVar->bConst;
    1259                 pVar->bConst = false;
    1260 
    1261                 int result = InitLocalVar(-pVar->offset,
    1262                     pVar->type,
    1263                     pVar->u.index,
    1264                     pVar->SubScripts,
    1265                     InitBuf);
    1266 
    1267                 if(!result){
    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                 //push 0
    1282                 op_push_value(0);
    1283 
    1284                 //push VarSize
    1285                 op_push_value(VarSize);
    1286 
    1287                 //mov eax,ebp
    1288                 OpBuffer[obp++]=(char)0x8B;
    1289                 OpBuffer[obp++]=(char)0xC5;
    1290 
    1291                 //add eax,offset
    1292                 OpBuffer[obp++]=(char)0x05;
    1293                 *((long *)(OpBuffer+obp))=-pVar->offset;
    1294                 AddLocalVarAddrSchedule();
    1295                 obp+=sizeof(long);
    1296 
    1297                 //push eax
    1298                 op_push(REG_EAX);
    1299 
    1300                 //call FillMemory
    1301                 OpBuffer[obp++]=(char)0xFF;
    1302                 OpBuffer[obp++]=(char)0x15;
    1303                 DECLAREINFO *pdi;
    1304                 pdi=GetDeclareHash("FillMemory");
    1305                 pdi->bUse=1;
    1306                 pobj_ImportAddrSchedule->add(pdi);
    1307                 obp+=sizeof(long);
    1308             }
    1309         }
    1310 
    1311         //コンストラクタ呼び出し
    1312         if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
    1313             CallConstructor(VarName,SubScripts,TypeInfo,ConstractParameter);
    1314         }
    1315     }
    1316 
    1317     if(TypeInfo.type==DEF_OBJECT){
    1318         if(TypeInfo.u.pobj_Class->IsAbstract()){
    1319             //抽象クラスだったとき
    1320             SetError(125,TypeInfo.u.pobj_Class->name,cp);
    1321         }
     1350        dim( isRef,VarName,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
    13221351    }
    13231352}

  • BasicCompiler32/MakePeHdr.cpp

    r56 r64  
    2222    *pSub_realloc,
    2323    *pSub_free,
     24    *pSub_System_GC_malloc_ForObject,
     25    *pSub_System_GC_malloc_ForObjectPtr,
     26    *pSub_System_GC_free_for_SweepingDelete,
    2427
    2528    *pSub_allrem,
    … …  
    3033    *pSub_allshl,
    3134    *pSub_allshr,
    32     *pSub_aullshr;
     35    *pSub_aullshr,
     36   
     37    *pSub_esp_error;
    3338
    3439
    … …  
    227232        pSub_free->bUse=1;
    228233
     234    if( pSub_System_GC_malloc_ForObject = GetSubHash( "_System_GC_malloc_ForObject",1 ) )
     235        pSub_System_GC_malloc_ForObject->bUse = 1;
     236
     237    if( pSub_System_GC_malloc_ForObjectPtr = GetSubHash( "_System_GC_malloc_ForObjectPtr",1 ) )
     238        pSub_System_GC_malloc_ForObjectPtr->bUse = 1;
     239
     240    if( pSub_System_GC_free_for_SweepingDelete = GetSubHash( "_System_GC_free_for_SweepingDelete",1 ) )
     241        pSub_System_GC_free_for_SweepingDelete->bUse = 1;
     242
    229243    pSub_allrem=GetSubHash("_allrem");
    230244    pSub_allrem->bUse=1;
    … …  
    258272    pSub_aullshr->bUse=1;
    259273    pSub_aullshr->bSystem=1;
     274
     275    pSub_esp_error=GetSubHash("_esp_error");
     276    pSub_esp_error->bUse=1;
     277
     278
    260279
    261280

  • BasicCompiler32/NumOpe.cpp

    r63 r64  
    66    //※この処理内では、esi、ediは使用不可
    77
    8     if(type==DEF_OBJECT){
     8    if(type==DEF_OBJECT || type==DEF_STRUCT){
    99        //push eax
    1010        op_push(REG_EAX);
    … …  
    6262        op_push(REG_EAX);
    6363    }
    64     else if(type==DEF_PTR_BYTE){
    65         //push eax
    66         op_push(REG_EAX);
     64    else{
     65        SetError();
    6766    }
    6867}
    … …  
    7170    ///////////////////////////////////////////////////////
    7271    // lpszTextを元にStringオブジェクトを生成し、
    73     // オブジェクトポインタをスタックに格納する
     72    // オブジェクトポインタをregに格納する
    7473    ///////////////////////////////////////////////////////
    7574
     75    char *parameter = (char *)malloc( lstrlen( lpszText ) + 3 );
     76    lstrcpy( parameter, lpszText );
     77    SetStringQuotes( parameter );
     78
    7679    extern CClass *pobj_StringClass;
    77     int object_size = pobj_StringClass->GetSize();
    78 
    79     //push object_size
    80     op_push_value(object_size);
    81 
    82     //call calloc
    83     extern SUBINFO *pSub_calloc;
    84     op_call(pSub_calloc);
    85 
    86     //push eax
    87     op_push(REG_EAX);
    88 
    89     //push eax
    90     op_push(REG_EAX);
    91 
    92     {
    93         //push eax
    94         op_push(REG_EAX);
    95 
    96         //call constructor
    97         op_call(pobj_StringClass->GetConstructorMethod()->psi);
    98     }
    99 
    100     // TODO: Ex表記による文字列長に対応する
    101     int i2 = dataTable.AddString( lpszText );
    102 
    103     //push lpszPtr
    104     OpBuffer[obp++]=(char)0x68;
    105     *((long *)(OpBuffer+obp))=i2;
    106     pobj_DataTableSchedule->add();
    107     obp+=sizeof(long);
    108 
    109 
    110     SetObjectVariable((LONG_PTR)pobj_StringClass,DEF_PTR_BYTE,-1,0);
     80    TYPEINFO baseTypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
     81    Operator_New( *pobj_StringClass, "", parameter, baseTypeInfo );
     82
     83    free( parameter );
    11184}
    11285
    … …  
    12295    }
    12396
    124     if(Command[0]==1&&Command[1]==ESC_NEW){
     97    if(Command[0]==1&& Command[1]==ESC_NEW ){
    12598        //New演算子（オブジェクト生成）
    126         return Operator_New(Command+2,plpIndex);
     99        TYPEINFO baseTypeInfo = { BaseType, lpBaseIndex };
     100        int resultType = Operator_New(Command+2,plpIndex, baseTypeInfo );
     101
     102        return resultType;
    127103    }
    128104
    … …  
    221197                        TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex};
    222198                        if(IsStringSubsituation(pobj_Class)
    223                             || IsStringObjectType(&BaseTypeInfo)){
     199                            || IsStringObjectType(BaseTypeInfo)){
    224200                            //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
    225201
    … …  
    239215
    240216
    241                     type[sp]=DEF_PTR_BYTE;
     217                    type[sp]=DEF_PTR_CHAR;
    242218                    index_stack[sp]=LITERAL_STRING;
    243219                    bLiteralCalculation=0;
    … …  
    329305                            }
    330306
    331                             if(i2==DEF_OBJECT){
    332                                 //Object型が戻ったときはヒープ領域にインスタンスが格納されている
     307                            if(i2==DEF_STRUCT){
     308                                //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    333309                                //※後にfreeする必要あり
    334310                                bUseHeap[sp]=1;
    … …  
    413389                        }
    414390                        else if(i2==DEF_LONG||i2==DEF_DWORD||i2==DEF_SINGLE||
    415                             IsPtrType(i2)){
     391                            IsPtrType(i2) || i2==DEF_OBJECT){
    416392                            //32ビット型
    417393                            PushLongVariable(&RelativeVar);
    … …  
    429405                            PushByteVariable(&RelativeVar);
    430406                        }
    431                         else if(i2==DEF_OBJECT){
    432                             //オブジェクト ポインタをeaxへ格納
     407                        else if(i2==DEF_STRUCT){
     408                            //構造体ポインタをeaxへ格納（構造体は値型）
    433409                            SetVarPtrToEax(&RelativeVar);
    434410
    … …  
    436412                            op_push(REG_EAX);
    437413                        }
     414                        else SetError(11,term,cp);
    438415
    439416                        if(Is64Type(type[sp])&&IsWholeNumberType(i2)&&GetTypeSize(i2,-1)<=sizeof(long)){
    … …  
    517494                        PushReturnValue(RetTypeInfo.type);
    518495
    519                         if(type[sp]==DEF_OBJECT){
    520                             //Object型が戻ったときはヒープ領域にインスタンスが格納されている
     496                        if(type[sp]==DEF_STRUCT){
     497                            //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    521498                            //※後にfreeする必要あり
    522499                            bUseHeap[sp]=1;

  • BasicCompiler32/NumOpe_Relation.cpp

    r36 r64  
    13131313        OpBuffer[obp++]=(char)0xC3;
    13141314
    1315         //jnz 4（次のxorとjmpを飛び越す）
     1315        //jz 4（次のxorとjmpを飛び越す）
    13161316        OpBuffer[obp++]=(char)0x74;
    13171317        OpBuffer[obp++]=(char)0x04;

  • BasicCompiler32/Opcode.h

    r62 r64  
    9797void ChangeTypeToInteger(int OldType);
    9898void ChangeTypeToByte(int OldType);
     99void SetVariableFromEax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar);
    99100void OpcodeCalc(char *Command);
    100 void SetRefVariable( const char *varname, const char *expression );
    101101
    102102//NumOpe.cpp
    … …  
    136136//Compile_Set_Var.cpp
    137137BOOL IsUse_ecx(RELATIVE_VAR *pRelativeVar);
    138 void SetObjectVariable(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,BOOL bUseHeap);
     138void SetStructVariable(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,BOOL bUseHeap);
     139void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar);
     140void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative);
     141
    139142void SetDoubleVariable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
    140143void SetSingleVariable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
    … …  
    171174
    172175//Compile_Object.cpp
    173 int Operator_New(const char *Parameter,LONG_PTR *plpIndex);
    174 void OpcodeDelete(char *Parameter);
     176void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter, const TYPEINFO &baseTypeInfo );
     177int Operator_New(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo );
     178void OpcodeDelete(const char *Parameter, bool isSweeping);
    175179
    176180//Compile_Var.cpp
    … …  
    183187#define DIMFLAG_STATIC                  4
    184188#define DIMFLAG_CONST                   8
     189void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags);
    185190void OpcodeDim(char *Parameter,DWORD dwFlag);
    186191void SetVarPtrToEax(RELATIVE_VAR *pRelativeVar);
    187192
    188193//CParameter.cpp
     194#define OVERLOAD_MIN_LEVEL 0
     195#define OVERLOAD_MAX_LEVEL 3
     196#define OVERLOAD_LEVEL0 0
    189197#define OVERLOAD_LEVEL1 1
    190198#define OVERLOAD_LEVEL2 2
    … …  
    216224    BOOL ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
    217225    void MacroParameterSupport(PARAMETER_INFO *ppi);
    218     void SetObjectParameter(CClass *pobj_Class,LPSTR Parameter);
     226    void SetStructParameter(CClass *pobj_Class,LPSTR Parameter);
    219227    int SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
    220228
    221229    //一時オブジェクトパラメータの生成と破棄
    222     void NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum );
     230    int NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum );
    223231    void DeleteTempParameters();
    224232};
    … …  
    228236#define PROCFLAG_NEW    1
    229237int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex);
    230 void Opcode_CallProc(char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType);
     238void Opcode_CallProc(const char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType);
    231239int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex);
    232240
    … …  
    258266void OpcodeGosub(char *Parameter);
    259267void OpcodeReturn(char *Parameter);
    260 void Opcode_Input(char *Parameter);
    261 void Opcode_Print(char *Parameter,BOOL bWrite);
     268void Opcode_Input(const char *Parameter);
     269void Opcode_Print(const char *Parameter,BOOL bWrite);
    262270void OpcodeCallPtr(char *Parameter);
    263271void OpcodeSetPtrData(char *Parameter,int type);
    … …  
    300308void op_sbb_RV8         (int reg,char cValue);
    301309void op_sbb_RR          ( int reg1, int reg2 );
     310void op_imul_RR         (int reg1,int reg2);
     311void op_imul_RV         (int reg,int i32data);
    302312void op_and_RV          (int reg,int value);
    303313void op_or_RR           ( int op_size, int reg1, int reg2 );
    … …  
    312322void op_add_esp(int num);
    313323void op_sub_esp(int num);
     324void op_cmp_RR( int reg1, int reg2 );
    314325void op_cmp_value(int op_size,int reg,char byte_data);
    315326void op_setne( int reg );

  • BasicCompiler32/OperatorProc.cpp

    r63 r64  
    5050        if(pBaseTypeInfo){
    5151            if(pBaseTypeInfo->type==DEF_OBJECT){
    52                 bReturnTypeIsObject=1;
    5352                ReturnType.u.lpIndex=pBaseTypeInfo->u.lpIndex;
    5453            }
    … …  
    107106    HeapDefaultFree(ppi);
    108107
    109     int right_side_size;
    110     if(type[sp-1]==DEF_OBJECT) right_side_size=PTR_SIZE;
    111     else right_side_size=GetTypeSize(type[sp-1],index_stack[sp-1]);
    112 
    113     if(bTwoTerm){
    114         if(psi->pParmInfo[1].type==DEF_OBJECT&&psi->pParmInfo[1].bByVal){
     108    int right_side_size = GetTypeSize(type[sp-1],index_stack[sp-1]);
     109
     110    if(bTwoTerm){
     111        if(psi->pRealParmInfo[1].type==DEF_STRUCT&&psi->pRealParmInfo[1].bByVal){
    115112            //一時オブジェクトはメソッド内で破棄される
    116113            bUseHeap[sp-1]=0;
    … …  
    119116
    120117
    121     if(psi->ReturnType==DEF_OBJECT){
     118    if(psi->ReturnType==DEF_STRUCT){
    122119        //////////////////////////////////////////////////////
    123         // 戻り値にオブジェクト インスタンスを持つ場合
    124         // ※ByRef _System_ReturnObject パラメータ用領域を取得
     120        // 戻り値に構造体インスタンスを持つ場合
     121        // ※ByRef _System_ReturnValue パラメータ用領域を取得
    125122        //////////////////////////////////////////////////////
    126123
    … …  
    182179            op_push(REG_EAX);
    183180        }
    184     }
    185 
    186     if(psi->ReturnType==DEF_OBJECT){
     181
     182        if( !psi->pRealParmInfo[1].bByVal ){
     183            //一時参照を作成
     184
     185            //mov eax,esp
     186            op_mov_RR( REG_EAX, REG_ESP );
     187
     188            //push eax
     189            op_push( REG_EAX );
     190        }
     191    }
     192
     193    if(psi->ReturnType==DEF_STRUCT){
    187194        //push ebx
    188195        op_push(REG_EBX);
    … …  
    195202    op_call(psi);
    196203
    197     if(psi->ReturnType!=-1){
     204    if(bTwoTerm){
     205        if( !psi->pRealParmInfo[1].bByVal ){
     206            //一時参照を破棄
     207            op_pop( REG_NON );
     208        }
     209    }
     210
     211    if(psi->ReturnType!=DEF_NON){
    198212        //スタックへプッシュ
    199213        PushReturnValue(psi->ReturnType);
    … …  
    211225    index_stack[sp-1]=psi->u.ReturnIndex;
    212226
    213     if(psi->ReturnType==DEF_OBJECT){
    214         //Object型が戻ったときはヒープ領域にインスタンスが格納されている
     227    if(psi->ReturnType==DEF_STRUCT){
     228        //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    215229        //※後にfreeする必要あり
    216230        bUseHeap[sp-1]=1;

  • BasicCompiler32/VarList.cpp

    r63 r64  
    2020    HTREEITEM hParent;
    2121
    22     if(type==DEF_OBJECT){
     22    if(type==DEF_OBJECT||type==DEF_STRUCT){
     23        if( type==DEF_OBJECT ){
     24            // 参照型ということを考慮する
     25            ReadProcessMemory(hDebugProcess,(void *)offset,&dwData,sizeof(void *),&dwAccessByte);
     26            offset = dwData;
     27        }
     28
    2329        sprintf(lptv->item.pszText,"%s %s(&H%X)",VarName,STRING_OBJECT,offset);
    2430        lptv->item.iImage=1;
    … …  
    2935        return;
    3036    }
    31     if(type==DEF_PTR_OBJECT){
     37    if(type==DEF_PTR_OBJECT||type==DEF_PTR_STRUCT){
    3238        i2=ReadProcessMemory(hDebugProcess,(void *)offset,&dwData,sizeof(DWORD),&dwAccessByte);
    3339
    … …  
    4147    }
    4248    else{
    43         if(type==DEF_PTR_BYTE){
     49        if(type==DEF_PTR_CHAR||type==MAKE_PTR_TYPE(DEF_BYTE,1)){
    4450            if(ReadProcessMemory(hDebugProcess,(void *)offset,&dwData,sizeof(DWORD),&dwAccessByte)){
    4551                for(i2=0;;i2++){

  • BasicCompiler32/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;
    … …  
    319322int Debugging_GetVarOffset(char *variable,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
    320323    extern HANDLE hDebugProcess;
    321     int i,i2,i3,RefType;
     324    int i,i2,i3;
    322325    char member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    323326    ULONG_PTR lpData;
    … …  
    325328
    326329    lstrcpy(VarName,variable);
    327     GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
     330    CClass::RefType refType;
     331    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
    328332
    329333    LONG_PTR lpIndex;
    … …  
    470474    }
    471475    if(member[0]){
    472         if(*pType==DEF_OBJECT){
     476        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
    473477            //実態オブジェクトのメンバを参照（obj.member）
    474             if(RefType!=DEF_OBJECT){
     478            if( refType != CClass::Dot ){
    475479                return 0;
    476480            }
    … …  
    489493            *plpIndex=lp2;
    490494        }
    491         else if(*pType==DEF_PTR_OBJECT){
     495        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
    492496            //ポインタオブジェクトが示すメンバを参照
    493497            if(lpPtrOffset[0]){
    494498                //pObj[n].member
    495                 if(RefType!=DEF_OBJECT) return 0;
     499                if( refType != CClass::Dot ) return 0;
    496500                Debugging_SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
    497501
    … …  
    511515            else{
    512516                //pObj->member
    513                 if(RefType!=DEF_PTR_OBJECT) return 0;
     517                if( refType != CClass::Pointer ) return 0;
    514518
    515519                pRelativeVar->offset=Debugging_GetVarPtr(pRelativeVar);

  • BasicCompiler32/commandvalue.h

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

  • BasicCompiler32/increment.cpp

    r62 r64  
    11#include "../BasicCompiler_Common/common.h"
    22#include "Opcode.h"
    3 
    4 
    5 void SetRealVariable(int type,RELATIVE_VAR *pRelativeVar){
    6     if(pRelativeVar->dwKind==VAR_GLOBAL){
    7         if(pRelativeVar->bOffsetOffset){
    8             //fstp ptr[ecx+offset]
    9             op_fstp_base_offset(type,REG_ECX,(int)pRelativeVar->offset);
    10             obp-=sizeof(long);
    11             pobj_GlobalVarSchedule->add();
    12             obp+=sizeof(long);
    13         }
    14         else{
    15             //mov ecx,offset
    16             op_mov_RV(REG_ECX,(int)pRelativeVar->offset);
    17             obp-=sizeof(long);
    18             pobj_GlobalVarSchedule->add();
    19             obp+=sizeof(long);
    20 
    21             //fstp ptr[ecx]
    22             op_fstp_basereg(type,REG_ECX);
    23         }
    24     }
    25     else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
    26         if(pRelativeVar->bOffsetOffset){
    27             //add ecx,qword ptr[offset]
    28             op_add_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
    29         }
    30         else{
    31             //mov ecx,qword ptr[offset]
    32             op_mov_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
    33         }
    34         obp-=sizeof(long);
    35         pobj_GlobalVarSchedule->add();
    36         obp+=sizeof(long);
    37 
    38         goto directmem;
    39     }
    40     else if(pRelativeVar->dwKind==VAR_LOCAL){
    41         if(pRelativeVar->bOffsetOffset){
    42             //fstp ptr[ebp+ecx+offset]
    43             op_fstp_base_offset_ex(type,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);
    44         }
    45         else{
    46             //fstp ptr[ebp+offset]
    47             op_fstp_base_offset(type,REG_EBP,(int)pRelativeVar->offset);
    48         }
    49         obp-=sizeof(long);
    50         AddLocalVarAddrSchedule();
    51         obp+=sizeof(long);
    52     }
    53     else if(pRelativeVar->dwKind==VAR_REFLOCAL){
    54         if(pRelativeVar->bOffsetOffset){
    55             //add ecx,qword ptr[ebp+offset]
    56             op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    57         }
    58         else{
    59             //mov ecx,qword ptr[ebp+offset]
    60             op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
    61         }
    62         obp-=sizeof(long);
    63         AddLocalVarAddrSchedule();
    64         obp+=sizeof(long);
    65 
    66         goto directmem;
    67     }
    68     else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
    69 directmem:
    70         //fstp ptr[ecx]
    71         op_fstp_basereg(type,REG_ECX);
    72     }
    73 }
    74 
    75 void ExtendTypeTo32(int type,int reg);
    76 void ExtendTypeTo64(int type){
    77     if(Is64Type(type)) return;
    78 
    79     ExtendTypeTo32(type,REG_EAX);
    80 
    81     if(IsSignedType(type)){
    82         //cdq
    83         op_cdq();
    84     }
    85     else{
    86         //xor edx,edx
    87         op_zero_reg(REG_EDX);
    88     }
    89 }
    90 void ExtendTypeTo32(int type,int reg){
    91     if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){
    92         //movsx reg32,reg16
    93         op_movsx_R32R16(reg,reg);
    94     }
    95     else if(type==DEF_WORD){
    96         //and reg,0000FFFFh
    97         op_and_RV(reg,(int)0x0000FFFF);
    98     }
    99     else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
    100         //movsx reg32,reg8
    101         op_movsx_R32R8(reg,reg);
    102     }
    103     else if(type==DEF_BYTE||type==DEF_BOOLEAN){
    104         //and reg,000000FFh
    105         op_and_RV(reg,(int)0xFF);
    106     }
    107 }
    108 void ExtendTypeTo16(int type,int reg){
    109     if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
    110         //movsx reg16,reg8
    111         op_movsx_R16R8(reg,reg);
    112     }
    113     else if(type==DEF_BYTE||type==DEF_BOOLEAN){
    114         //and reg,000000FFh
    115         op_and_RV(reg,(int)0xFF);
    116     }
    117 }
    118 
    119 void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative,int reg){
    120     if(type==DEF_DOUBLE){
    121         //Double型
    122 
    123     }
    124     else if(type==DEF_SINGLE){
    125         //Single型
    126 
    127     }
    128     else{
    129         //その他の整数
    130 
    131         if(var_size==sizeof(_int64)){
    132             //eaxの値を64ビット（edx:eax）に拡張する
    133             ExtendTypeTo64(type);
    134         }
    135         else if(var_size==sizeof(long)){
    136             //レジスタの値を32ビット（eax）に拡張する
    137             ExtendTypeTo32(type,reg);
    138         }
    139         else if(var_size==sizeof(short)){
    140             //レジスタの値を16ビット（ax）に拡張する
    141             ExtendTypeTo16(type,reg);
    142         }
    143         //8ビットは拡張なし
    144     }
    145 
    146     if(var_size==sizeof(_int64)){
    147         //下位32ビット
    148         SetWholeVariable(sizeof(long),DEF_LONG,pRelative,REG_EAX);
    149 
    150         //上位32ビット
    151         pRelative->offset+=sizeof(long);
    152         SetWholeVariable(sizeof(long),DEF_LONG,pRelative,REG_EDX);
    153         pRelative->offset-=sizeof(long);
    154 
    155         return;
    156     }
    157 
    158     if(pRelative->dwKind==VAR_GLOBAL){
    159         if(pRelative->bOffsetOffset){
    160             //mov ptr[ecx+offset],eax/ax/al
    161             op_mov_MR(var_size,reg,REG_ECX,(int)pRelative->offset,MOD_BASE_DISP32);
    162         }
    163         else{
    164             //mov ptr[offset],eax/ax/al
    165             op_mov_MR(var_size,reg,0,(int)pRelative->offset,MOD_DISP32);
    166         }
    167         obp-=sizeof(long);
    168         pobj_GlobalVarSchedule->add();
    169         obp+=sizeof(long);
    170     }
    171     else if(pRelative->dwKind==VAR_REFGLOBAL){
    172         if(pRelative->bOffsetOffset){
    173             //add ecx,qword ptr[offset]
    174             op_add_RM(var_size,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
    175         }
    176         else{
    177             //mov ecx,qword ptr[offset]
    178             op_mov_RM(var_size,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
    179         }
    180         obp-=sizeof(long);
    181         pobj_GlobalVarSchedule->add();
    182         obp+=sizeof(long);
    183 
    184         goto directmem;
    185     }
    186     else if(pRelative->dwKind==VAR_LOCAL){
    187         if(pRelative->bOffsetOffset){
    188             //mov ptr[ebp+ecx+offset],eax/ax/al
    189             op_mov_MR_ex(var_size,reg,REG_EBP,REG_ECX,(int)pRelative->offset,USE_OFFSET);
    190         }
    191         else{
    192             //mov ptr[ebp+offset],eax/ax/al
    193             op_mov_MR(var_size,reg,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
    194         }
    195         obp-=sizeof(long);
    196         AddLocalVarAddrSchedule();
    197         obp+=sizeof(long);
    198     }
    199     else if(pRelative->dwKind==VAR_REFLOCAL){
    200         if(pRelative->bOffsetOffset){
    201             //add ecx,qword ptr[ebp+offset]
    202             op_add_RM(var_size,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
    203         }
    204         else{
    205             //mov ecx,qword ptr[ebp+offset]
    206             op_mov_RM(var_size,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
    207         }
    208         obp-=sizeof(long);
    209         AddLocalVarAddrSchedule();
    210         obp+=sizeof(long);
    211 
    212         goto directmem;
    213     }
    214     else if(pRelative->dwKind==VAR_DIRECTMEM){
    215 directmem:
    216 
    217         //mov ptr[ecx],eax/ax/al
    218         op_mov_MR(var_size,reg,REG_ECX,0,MOD_BASE);
    219     }
    220 }
    221 
    222 void SetVariableFromReg(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
    223     /////////////////////////////////////////////////
    224     // raxの内容を変数にコピーするコードを抽出
    225     /////////////////////////////////////////////////
    226 
    227     if(VarType==DEF_DOUBLE){
    228         //Double型変数へスタックの内容を格納する
    229         SetRealVariable(VarType,pRelativeVar);
    230     }
    231     else if(VarType==DEF_SINGLE){
    232         //Single型変数へスタックの内容を格納する
    233         SetRealVariable(VarType,pRelativeVar);
    234     }
    235     else{
    236         //整数型
    237         SetWholeVariable(GetTypeSize(VarType,-1),CalcType,pRelativeVar,REG_EAX);
    238     }
    239 }
    240 
    2413
    2424void IncDec(int idCalc, char *lpszLeft, char *lpszRight){
    … …  
    438200    }
    439201
    440     SetVariableFromReg(VarType,VarType,&VarRelativeVar);
     202    SetVariableFromEax(VarType,VarType,&VarRelativeVar);
    441203}

  • BasicCompiler32/op32_main.cpp

    r36 r64  
    372372
    373373
     374////////////////////////
     375// imul関連
     376////////////////////////
     377
     378void op_imul_RR(int reg1,int reg2){
     379    //imul reg1,reg2
     380
     381    //オペコード
     382    OpBuffer[obp++]=(char)0x0F;
     383    OpBuffer[obp++]=(char)0xAF;
     384
     385    //レジスタ
     386    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
     387}
     388
     389void op_imul_RV(int reg,int i32data){
     390    //imul reg,i32data
     391
     392    if(-128<=i32data&&i32data<=127){
     393        //オペコード
     394        OpBuffer[obp++]=(char)0x6B;
     395
     396        //レジスタ
     397        OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg));
     398
     399        //値
     400        OpBuffer[obp++]=(char)i32data;
     401    }
     402    else{
     403        //オペコード
     404        OpBuffer[obp++]=(char)0x69;
     405
     406        //レジスタ
     407        OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg));
     408
     409        //値
     410        *((long *)(OpBuffer+obp))=i32data;
     411        obp+=sizeof(long);
     412    }
     413}
     414
     415
    374416
    375417//////////////////////
    … …  
    468510void op_push(int reg){
    469511    //push reg
     512
     513    if( reg == REG_NON ){
     514        op_sub_esp( PTR_SIZE );
     515        return;
     516    }
    470517
    471518    //オペコード、レジスタ
    … …  
    489536    //pop reg
    490537
     538    if( reg == REG_NON ){
     539        op_add_esp( PTR_SIZE );
     540        return;
     541    }
     542
    491543    //オペコード、レジスタ
    492544    __op_format(0,(char)0x58,reg);
    … …  
    532584// cmp関連
    533585/////////////////////
     586void op_cmp_RR( int reg1, int reg2 ){
     587    //オペコード
     588    OpBuffer[obp++]=(char)0x3B;
     589
     590    //レジスタ
     591    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
     592}
    534593void op_cmp_value(int op_size,int reg,char byte_data){
    535594    //cmp reg,byte_data
Note: See TracChangeset for help on using the changeset viewer.