Changeset 76 in dev for BasicCompiler32/CParameter.cpp


Ignore:
Timestamp:
Mar 21, 2007, 9:26:56 PM (18 years ago)
Author:
dai_9181
Message:

TYPEINFO→Typeへのリファクタリングを実施。32bitが未完成。

File:
1 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler32/CParameter.cpp

    r75 r76  
    3939        }
    4040
    41         Type DummyTypeInfo;
     41        Type dummyType;
    4242        BOOL bByVal;
    4343        if(bEllipse){
    44             DummyTypeInfo.type=NumOpe_GetType_Old(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
     44            NumOpe_GetType( Parms[i2], Type(), dummyType );
    4545            bByVal=1;
    4646        }
    4747        else{
    48             DummyTypeInfo.type=params[i2]->GetBasicType();
    49             DummyTypeInfo.u.lpIndex=params[i2]->GetIndex();
     48            dummyType = *params[i2];
    5049            bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
    5150        }
    … …  
    5958            }
    6059
    61             LONG_PTR lpVarIndex;
    62             if( GetVarType( Parms[i2], &lpVarIndex, FALSE ) == -1 ){
     60            if( !GetVarType( Parms[i2], Type(), FALSE ) ){
    6361                //変数ではないとき
    64                 int reg = REG_RAX;
    65                 int type = NumOpe( Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
     62                Type calcType;
     63                NumOpe( Parms[i2], dummyType, calcType );
    6664                //↑ここでスタックに積む
    6765
    6866                nCountOfTempObjects++;
    6967
    70                 if( type != DEF_STRUCT ){
     68                if( !calcType.IsStruct() ){
    7169                    //一時参照を作成
    7270
    … …  
    7876
    7977                bool result = CheckDifferentType(
    80                     DummyTypeInfo.type,
    81                     DummyTypeInfo.u.lpIndex,
    82                     type,
    83                     lpVarIndex,
     78                    dummyType,
     79                    calcType,
    8480                    procName.c_str(),
    8581                    i2);
    … …  
    8985                    useTempObject = true;
    9086
    91                     types[i2].type = type;
    92                     types[i2].u.lpIndex = lpVarIndex;
     87                    types[i2] = calcType;
    9388                }
    9489            }
    … …  
    107102    for(int i2=ParmsNum-1;i2>=0;i2--){
    108103        if( useTempParameters[i2] ){
    109             if( types[i2].type == DEF_STRUCT ){
     104            if( types[i2].IsStruct() ){
    110105                // 構造体の一時メモリ
    111106
    … …  
    117112            }
    118113            else{
    119                 if( Is64Type( types[i2].type ) ){
     114                if( types[i2].Is64() ){
    120115                    //pop ... 参照を消す
    121116                    //pop ... 上位32ビット
    … …  
    133128}
    134129
    135 void ParamImpl::SetStructParameter(CClass *pobj_Class,LPSTR Parameter){
    136     int object_size = pobj_Class->GetSize();
     130void ParamImpl::SetStructParameter( const Type &baseType, const char *expression ){
     131    int object_size = baseType.GetClass().GetSize();
    137132
    138133    //push object_size
    … …  
    143138    op_call(pSub_calloc);
    144139
     140    //push eax（ここでプッシュされた値が実際にパラメータとして引き渡される）
     141    op_push(REG_EAX);
     142
    145143    //push eax
    146144    op_push(REG_EAX);
    147145
    148 
    149     Type BaseType={DEF_STRUCT,(LONG_PTR)pobj_Class};
    150     Type CalcType;
    151     CalcType.type=NumOpe_GetType_Old(Parameter,&BaseType,&CalcType.u.lpIndex);
    152 
    153     /*
    154     TODO: 消す
    155     if( pobj_Class->GetCopyConstructorMethod()
    156         && CalcType.type==DEF_OBJECT&&CalcType.u.pobj_Class==pobj_Class){
    157         ////////////////////////////////////
    158         // コピーコンストラクタを呼び出す
    159         ////////////////////////////////////
    160 
    161         //push eax
    162         op_push(REG_EAX);
    163 
    164         BOOL bUseHeap;
    165         CalcType.type=NumOpe(Parameter,DEF_OBJECT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
    166 
    167         //pop ecx
    168         op_pop(REG_ECX);
    169 
    170         //pop eax
    171         op_pop(REG_EAX);
    172 
    173         if(bUseHeap){
    174             //※解放用に退避
    175             //mov esi,ecx
    176             op_mov_RR(REG_ESI,REG_ECX);
    177         }
    178 
    179         //push ecx
    180         op_push(REG_ECX);
    181 
    182         //push eax
    183         op_push(REG_EAX);
    184 
    185         //call constructor
    186         op_call(pobj_Class->GetCopyConstructorMethod()->pUserProc);
    187 
    188 
    189         if(bUseHeap){
    190             FreeTempObject(REG_ESI,pobj_Class);
    191         }
    192     }
    193     else{*/
    194 
    195 
    196         //push eax
    197         op_push(REG_EAX);
    198 
    199 /*
    200             TODO: 消す
    201             if( pobj_Class->GetConstructorMethod() ){
    202                 ////////////////////////////////
    203                 // コンストラクタを呼び出す
    204                 ////////////////////////////////
    205 
    206                 //push this
    207                 op_push(REG_EAX);
    208 
    209                 //call constructor
    210                 op_call(pobj_Class->GetConstructorMethod()->pUserProc);
    211             }
    212 */
    213 
    214             BOOL bUseHeap;
    215             CalcType.type=NumOpe(Parameter,DEF_STRUCT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
    216 
    217 
    218 
    219         SetStructVariable((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,bUseHeap);
    220     //}
     146    Type calcType;
     147    BOOL bUseHeap;
     148    NumOpe( expression,
     149        baseType,
     150        calcType,
     151        &bUseHeap );
     152
     153    // ※スタックにある二つのデータ（コピー先、コピー元）の値を必要とする
     154    SetStructVariable( baseType, calcType, bUseHeap );
    221155}
    222156
    … …  
    247181
    248182    //パラメータをレジスタとスタックに格納
    249     int CalcType;
    250     LONG_PTR lpCalcIndex;
    251     BOOL bCalcUseHeap;
    252183    int ParmSize=0;
    253184    RELATIVE_VAR RelativeVar;
    … …  
    269200        }
    270201
    271         Type DummyTypeInfo;
     202        Type dummyType;
    272203        BOOL bByVal;
    273204        if(bEllipse){
    274             DummyTypeInfo.type=NumOpe_GetType_Old(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
     205            NumOpe_GetType( Parms[i2], Type(), dummyType );
    275206            bByVal=1;
    276207        }
    277208        else{
    278             DummyTypeInfo.type=params[i2]->GetBasicType();
    279             DummyTypeInfo.u.lpIndex=params[i2]->GetIndex();
    280             bByVal = (params[i2]->IsRef() == false ) ? TRUE:FALSE;
     209            dummyType = *params[i2];
     210            bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
    281211        }
    282212
    … …  
    291221            }
    292222
    293             if(DummyTypeInfo.type==DEF_STRUCT){
    294                 SetStructParameter(DummyTypeInfo.u.pobj_Class,Parms[i2]);
     223            if( dummyType.IsStruct() ){
     224                SetStructParameter( dummyType, Parms[i2] );
    295225                goto next;
    296226            }
    297227
    298 
    299228            extern LONG_PTR ProcPtr_BaseIndex;
    300             LONG_PTR back_ProcPtr_BaseIndex;
    301             back_ProcPtr_BaseIndex=ProcPtr_BaseIndex;
    302             if(DummyTypeInfo.type==DEF_PTR_PROC) ProcPtr_BaseIndex=DummyTypeInfo.u.lpIndex;
    303             else ProcPtr_BaseIndex=-1;
    304 
    305             CalcType=NumOpe(Parms[i2],DummyTypeInfo.type,DummyTypeInfo.u.lpIndex,&lpCalcIndex,&bCalcUseHeap);
     229            LONG_PTR back_ProcPtr_BaseIndex = ProcPtr_BaseIndex;
     230            if( dummyType.IsProcPtr() ){
     231                ProcPtr_BaseIndex = dummyType.GetIndex();
     232            }
     233            else{
     234                ProcPtr_BaseIndex=-1;
     235            }
     236
     237            BOOL bCalcUseHeap;
     238            Type calcType;
     239            if( !NumOpe( Parms[i2], dummyType, calcType, &bCalcUseHeap ) ){
     240                break;
     241            }
    306242
    307243            ProcPtr_BaseIndex=back_ProcPtr_BaseIndex;
    308244
    309             if(CalcType==-1) break;
    310 
    311             if(CalcType==DEF_OBJECT){
    312                 if( DummyTypeInfo.type != DEF_OBJECT
     245            if( calcType.IsObject() ){
     246                if( !dummyType.IsObject()
    313247                    ||
    314                     DummyTypeInfo.type == DEF_OBJECT &&
    315                     !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpCalcIndex ) ){
     248                    dummyType.IsObject() &&
     249                    !dummyType.GetClass().IsEqualsOrSubClass( &calcType.GetClass() ) ){
    316250                        //キャスト演算子のオーバーロードに対応する
    317                         CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
     251                        CallCastOperatorProc( calcType, bCalcUseHeap,dummyType );
    318252                }
    319253            }
    320254
    321255            if(!bEllipse){
     256                //型チェック
     257                // TODO: _System_ReturnValueが考慮されていない？
     258                if(bHas_System_LocalThis) i3=i2-1;
     259                else i3=i2;
     260                CheckDifferentType(
     261                    dummyType,
     262                    calcType,
     263                    procName.c_str(),
     264                    i3);
     265            }
     266
     267            if( dummyType.IsDouble() ){
     268                ChangeTypeToDouble( calcType.GetBasicType() );
     269                ParmSize+=sizeof(long)*2;
     270            }
     271            else if( dummyType.IsSingle() ){
     272                ChangeTypeToSingle( calcType.GetBasicType() );
     273                ParmSize+=sizeof(long);
     274            }
     275            else if( dummyType.Is64() ){
     276                ChangeTypeToInt64( calcType.GetBasicType() );
     277                ParmSize+=sizeof(long)*2;
     278            }
     279            else if( dummyType.IsLong() || dummyType.IsDWord()
     280                || dummyType.IsPointer()
     281                || dummyType.IsObject() || dummyType.IsStruct() ){
     282                    ChangeTypeToLong( calcType.GetBasicType() );
     283                    ParmSize+=sizeof(long);
     284            }
     285            else if( dummyType.IsInteger() || dummyType.IsWord() ){
     286                ChangeTypeToInteger( calcType.GetBasicType() );
     287                ParmSize+=sizeof(long);
     288            }
     289            else if( dummyType.IsSByte() || dummyType.IsByte() || dummyType.IsBoolean() ){
     290                ChangeTypeToByte( calcType.GetBasicType() );
     291                ParmSize+=sizeof(long);
     292            }
     293            else{
     294                SetError(300,NULL,cp);
     295            }
     296        }
     297        else{
     298            //ポインタ参照
     299            if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
     300                //ポインタ指定
     301
     302                Type calcType;
     303                if( !NumOpe( Parms[i2]+2, dummyType, calcType) ){
     304                    break;
     305                }
     306
     307                ChangeTypeToLong( calcType.GetBasicType() );
     308
     309                dummyType.PtrLevelUp();
     310
    322311                //型チェック
    323312                if(bHas_System_LocalThis) i3=i2-1;
    324313                else i3=i2;
    325314                CheckDifferentType(
    326                     DummyTypeInfo.type,
    327                     DummyTypeInfo.u.lpIndex,
    328                     CalcType,
    329                     lpCalcIndex,
     315                    dummyType,
     316                    calcType,
    330317                    procName.c_str(),
    331318                    i3);
    332             }
    333 
    334             if(DummyTypeInfo.type==DEF_DOUBLE){
    335                 ChangeTypeToDouble(CalcType);
    336                 ParmSize+=sizeof(long)*2;
    337             }
    338             else if(DummyTypeInfo.type==DEF_SINGLE){
    339                 ChangeTypeToSingle(CalcType);
    340                 ParmSize+=sizeof(long);
    341             }
    342             else if(DummyTypeInfo.type==DEF_INT64||DummyTypeInfo.type==DEF_QWORD){
    343                 ChangeTypeToInt64(CalcType);
    344                 ParmSize+=sizeof(long)*2;
    345             }
    346             else if(DummyTypeInfo.type==DEF_LONG||DummyTypeInfo.type==DEF_DWORD||DummyTypeInfo.type==DEF_OBJECT||DummyTypeInfo.type==DEF_STRUCT||
    347                 (IsPtrType(DummyTypeInfo.type)/*&&DummyTypeInfo.type!=DEF_PTR_VOID&&DummyTypeInfo.type!=DEF_PTR_BYTE*/)){
    348                 ChangeTypeToLong(CalcType);
    349                 ParmSize+=sizeof(long);
    350             }
    351             else if(DummyTypeInfo.type==DEF_INTEGER||DummyTypeInfo.type==DEF_WORD || (isUnicode&&DummyTypeInfo.type==DEF_CHAR)){
    352                 ChangeTypeToInteger(CalcType);
    353                 ParmSize+=sizeof(long);
    354             }
    355             else if(DummyTypeInfo.type==DEF_SBYTE||DummyTypeInfo.type==DEF_BYTE||DummyTypeInfo.type==DEF_BOOLEAN || (isUnicode==false&&DummyTypeInfo.type==DEF_CHAR)){
    356                 ChangeTypeToByte(CalcType);
    357                 ParmSize+=sizeof(long);
    358             }
    359             else{
    360                 SetError(300,NULL,cp);
    361             }
    362         }
    363         else{
    364             //ポインタ参照
    365             if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
    366                 //ポインタ指定
    367                 i3=NumOpe(Parms[i2]+2,0,0,0);
    368 
    369                 ChangeTypeToLong(i3);
    370319            }
    371320            else{
    … …  
    373322                    //一時オブジェクトをコピー
    374323
    375                     if( types[i2].type != DEF_STRUCT ){
     324                    if( !types[i2].IsStruct() ){
    376325                        // 一時参照のための領域を考慮する
    377326                        nCountOfNowTempObjects++;
    … …  
    393342                else{
    394343                    //変数のアドレスを取得
    395                     int VarType;
    396                     LONG_PTR lpVarIndex;
     344                    Type varType;
    397345                    if(GetVarOffset(
    398346                        false,
    399347                        false,
    400348                        Parms[i2],
    401                         &VarType,
    402349                        &RelativeVar,
    403                         &lpVarIndex)){
    404                             if(DummyTypeInfo.type!=DEF_ANY){
     350                        varType)){
     351                            if( !dummyType.IsAny() ){
    405352                                //型チェックを行う
    406                                 if(DummyTypeInfo.type==VarType){
    407                                     if(DummyTypeInfo.type==DEF_OBJECT){
    408                                         if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
     353                                if( dummyType.GetBasicType() == varType.GetBasicType() ){
     354                                    if( dummyType.IsObject() ){
     355                                        if( !dummyType.GetClass().IsEqualsOrSubClass( &varType.GetClass() ) ){
    409356                                            SetError(11,Parms[i2],cp);
    410357                                        }
    411358                                    }
    412                                     else if(DummyTypeInfo.type==DEF_STRUCT){
    413                                         if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
     359                                    else if( dummyType.IsStruct() ){
     360                                        if( !dummyType.GetClass().IsEquals( &varType.GetClass() ) ){
    414361                                            SetError(11,Parms[i2],cp);
    415362                                        }
    416363                                    }
    417364                                }
    418                                 else if((VarType&FLAG_PTR)&&((int)(VarType^FLAG_PTR)==DummyTypeInfo.type)){
     365                                else if( (varType.GetBasicType()&FLAG_PTR)
     366                                    &&((varType.GetBasicType()^FLAG_PTR)==dummyType.GetBasicType())){
    419367                                    //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
    420368                                }
Note: See TracChangeset for help on using the changeset viewer.