Changeset 75 in dev for BasicCompiler64/NumOpe.cpp


Ignore:
Timestamp:
Mar 20, 2007, 4:36:16 AM (17 years ago)
Author:
dai_9181
Message:

TYPEINFO→Typeへのリファクタリングを実施。64bitはほぼ完了。32bitが全般的に未完成。

File:
1 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler64/NumOpe.cpp

    r69 r75  
    1919
    2020        extern CClass *pobj_StringClass;
    21         TYPEINFO baseTypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
    22         Operator_New( *pobj_StringClass, "", parameter, baseTypeInfo );
     21        Operator_New( *pobj_StringClass, "", parameter, Type( DEF_OBJECT, *pobj_StringClass ) );
    2322
    2423        free( parameter );
    … …  
    7069}
    7170
    72 int NumOpe(int *pReg,const char *Command,int BaseType,LONG_PTR lpBaseIndex,LONG_PTR *plpIndex,BOOL *pbUseHeap){
    73     extern HANDLE hHeap;
     71void ExtendRegToBigType( int reg, int bigBasicType, int baseBasicType ){
     72    switch( Type::GetBasicSize( bigBasicType ) ){
     73        case sizeof(_int64):
     74            ExtendTypeTo64(baseBasicType,reg);
     75            break;
     76        case sizeof(long):
     77            ExtendTypeTo32(baseBasicType,reg);
     78            break;
     79        case sizeof(short):
     80            ExtendTypeTo16(baseBasicType,reg);
     81            break;
     82    }
     83}
     84
     85bool NumOpe( int *pReg,
     86            const char *expression,
     87            const Type &baseType,
     88            Type &resultType,
     89            BOOL *pbUseHeap ){
     90
    7491    int i,i2,i3,i4;
    7592    char temporary[1024],temp2[1024],temp3[1024];
    7693
    77     if(Command[0]=='\0'){
     94    if(expression[0]=='\0'){
    7895        SetError(1,NULL,cp);
    79         return 0;
    80     }
    81 
    82     if(Command[0]==1&& Command[1]==ESC_NEW ){
     96        return false;
     97    }
     98
     99    if(expression[0]==1&& expression[1]==ESC_NEW ){
    83100        //New演算子（オブジェクト生成）
    84         TYPEINFO baseTypeInfo = { BaseType, lpBaseIndex };
    85         int resultType = Operator_New(Command+2,plpIndex, baseTypeInfo );
     101
     102        if( !Operator_New( expression+2, baseType, resultType ) ){
     103            return false;
     104        }
    86105
    87106        //mov reg,rax
    88107        op_mov_RR( *pReg, REG_RAX );
    89108
    90         return resultType;
     109        return true;
    91110    }
    92111
    … …  
    100119    long stack[255];
    101120    int pnum;
    102     if(!GetNumOpeElements(Command,&pnum,values,calc,stack)){
     121    if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
    103122        for(i=0;i<pnum;i++){
    104123            if(values[i]) HeapDefaultFree(values[i]);
    … …  
    156175    double dbl;
    157176    int sp;
    158     int type[255];
     177    int type_stack[255];
    159178    LONG_PTR index_stack[255];
    160179    BOOL bUseHeap[255];
    … …  
    167186
    168187        if(idCalc){
    169             if(type[sp-2]==DEF_OBJECT){
     188            if(type_stack[sp-2]==DEF_OBJECT){
    170189                //オーバーロードされたオペレータを呼び出す
    171                 TYPEINFO BaseTypeInfo={BaseType,lpBaseIndex};
    172                 i2=CallOperatorProc(idCalc,&BaseTypeInfo,type,index_stack,bUseHeap,sp);
     190                i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,bUseHeap,sp);
    173191                if(i2==0){
    174192                    if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
    … …  
    183201            }
    184202
    185             if(!CheckCalcType(idCalc,type,sp)) goto error;
     203            if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
    186204        }
    187205
    … …  
    209227StrLiteral:
    210228                   
    211                     if(BaseType==DEF_OBJECT){
    212                         CClass *pobj_Class;
    213                         pobj_Class=(CClass *)lpBaseIndex;
    214                         TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex};
    215                         if(IsStringObjectType(BaseTypeInfo)){
     229                    if( baseType.IsObject() ){
     230                        if( baseType.IsStringObject() ){
    216231                            //要求タイプがStringのとき
    217232
    … …  
    220235
    221236                            extern CClass *pobj_StringClass;
    222                             type[sp]=DEF_OBJECT;
     237                            type_stack[sp]=DEF_OBJECT;
    223238                            index_stack[sp]=(LONG_PTR)pobj_StringClass;
    224239                            bLiteralCalculation=0;
    … …  
    232247                    }
    233248
    234                     type[sp]=typeOfPtrChar;
     249                    type_stack[sp]=typeOfPtrChar;
    235250                    bLiteralCalculation=0;
    236251
    … …  
    277292                        int idProc;
    278293                        void *pInfo;
    279                         idProc=GetProc(temporary,&pInfo);
    280 
     294                        idProc=GetProc(temporary,(void **)&pInfo);
     295
     296                        Type resultType;
    281297                        if(idProc){
    282298                            //閉じカッコ")"に続く文字がNULLでないとき
    … …  
    302318                                ////////////////
    303319
    304                                 i2=CallProc(idProc,pInfo,temporary,temp2,&index_stack[sp]);
    305                                 if(i2==-1){
     320                                CallProc(idProc,pInfo,temporary,temp2,resultType);
     321                                if(resultType.IsNull()){
    306322                                    //戻り値が存在しないとき
    307323                                    for(i2=2;;i2++){
    … …  
    325341
    326342                                //大きな型への暗黙の変換
    327                                 type[sp]=AutoBigCast(BaseType,i2);
     343                                type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
     344                                index_stack[sp] = resultType.GetIndex();
    328345                                bLiteralCalculation=0;
    329346
    330                                 SetUseRegFromRax(i2,UseReg,XmmReg);
    331 
    332                                 if(IsRealNumberType(i2)) bXmm=1;
     347                                if( type_stack[sp] != resultType.GetBasicType() ){
     348                                    // 大きな型へ変換された場合
     349                                    // ※レジスタの値をキャストする
     350                                    ExtendRegToBigType( REG_RAX, type_stack[sp], resultType.GetBasicType() );
     351                                }
     352
     353                                SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
     354
     355                                if(resultType.IsReal()) bXmm=1;
    333356                                else bXmm=0;
    334357
    … …  
    342365                            else pobj_reg->LockReg();
    343366
    344                             if(i2==DEF_STRUCT){
     367                            if(resultType.IsStruct()){
    345368                                //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    346369                                //※後にfreeする必要あり
    … …  
    360383
    361384                            //マクロ関数の場合
    362                             i2=NumOpe(&UseReg,temp3,0,0,&index_stack[sp]);
    363 
    364                             if(!IS_LITERAL(index_stack[sp])){
     385                            NumOpe(&UseReg,temp3,Type(),resultType);
     386
     387                            if(!IS_LITERAL(resultType.GetIndex())){
    365388                                //リテラル値ではなかったとき
    366389                                bLiteralCalculation=0;
    367390                            }
    368391
    369                             type[sp]=i2;
    370 
    371                             if(IsRealNumberType(i2)) pobj_reg->LockXmmReg();
     392                            type_stack[sp] = resultType.GetBasicType();
     393                            index_stack[sp] = resultType.GetIndex();
     394
     395                            if(resultType.IsReal()) pobj_reg->LockXmmReg();
    372396                            else pobj_reg->LockReg();
    373397
    … …  
    381405                    //インデクサ（getアクセサ）
    382406                    char variable[VN_SIZE],array_element[VN_SIZE];
    383                     CClass *pobj_c;
    384407                    GetArrayElement(term,variable,array_element);
    385408                    if(array_element[0]){
    386                         i2=GetVarType(variable,(LONG_PTR *)&pobj_c,0);
    387                         if(i2==DEF_OBJECT){
    388                             TYPEINFO RetTypeInfo;
    389                             CallIndexerGetterProc(UseReg,pobj_c,variable,array_element,RetTypeInfo);
    390                             type[sp]=RetTypeInfo.type;
    391                             index_stack[sp]=RetTypeInfo.u.lpIndex;
     409                        Type resultType;
     410                        GetVarType(variable,resultType,0);
     411                        if( resultType.IsObject() ){
     412                            CallIndexerGetterProc(UseReg,&resultType.GetClass(),variable,array_element,resultType);
     413                            type_stack[sp]=resultType.GetBasicType();
     414                            index_stack[sp]=resultType.GetIndex();
    392415                            bLiteralCalculation=0;
    393416
    394                             if(IsRealNumberType(RetTypeInfo.type)) pobj_reg->LockXmmReg();
     417                            if(resultType.IsReal()) pobj_reg->LockXmmReg();
    395418                            else pobj_reg->LockReg();
    396419                            sp++;
    … …  
    402425                    // Nothing
    403426                    if( lstrcmp( term, "Nothing" ) == 0 ){
    404                         type[sp] = DEF_OBJECT;
    405                         if( BaseType == DEF_OBJECT ){
    406                             index_stack[sp] = lpBaseIndex;
     427                        type_stack[sp] = DEF_OBJECT;
     428                        if( baseType.IsObject() ){
     429                            index_stack[sp] = baseType.GetIndex();
    407430                        }
    408431                        else{
    … …  
    427450
    428451                    RELATIVE_VAR RelativeVar;
     452                    Type varType;
    429453                    if(GetVarOffset(
    430454                        false,  //エラー表示あり
    431455                        false,  //読み込み専用
    432456                        term,
    433                         &i2,&RelativeVar,&index_stack[sp])){
     457                        &RelativeVar,varType)){
    434458                        //////////
    435459                        // 変数
    … …  
    437461
    438462                        //大きな型への暗黙の変換
    439                         type[sp]=AutoBigCast(BaseType,i2);
     463                        type_stack[sp]=AutoBigCast(baseType.GetBasicType(),varType.GetBasicType());
     464                        index_stack[sp] = varType.GetIndex();
    440465                        bLiteralCalculation=0;
    441466
    442                         if(type[sp]!=i2){
    443                             //大きな型へ変換された場合（レジスタを0に初期化する）
    444 
    445                             //xor reg,reg
    446                             op_zero_reg(UseReg);
    447                         }
    448 
    449                         if(i2&FLAG_PTR){
     467                        if(varType.GetBasicType()&FLAG_PTR){
    450468                            //配列ポインタ
    451                             type[sp]=GetPtrType(i2^FLAG_PTR,index_stack[sp]);
     469                            type_stack[sp]=GetPtrType(varType.GetBasicType()^FLAG_PTR);
    452470
    453471                            SetVarPtrToReg(UseReg,&RelativeVar);
    454472                        }
    455                         else if(IsRealNumberType(i2)){
     473                        else if(varType.IsReal()){
    456474                            //実数型
    457475                            bXmm=1;
    458476
    459                             if(i2==DEF_DOUBLE)
     477                            if( varType.IsDouble() )
    460478                                SetXmmReg_DoubleVariable(&RelativeVar,XmmReg);
    461                             if(i2==DEF_SINGLE)
     479                            if( varType.IsSingle() )
    462480                                SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
    463481                        }
    464                         else if(IsWholeNumberType(i2) || i2==DEF_OBJECT){
     482                        else if( varType.IsWhole() || varType.IsObject()){
    465483                            //整数型
    466                             SetReg_WholeVariable(i2,&RelativeVar,UseReg);
    467                         }
    468                         else if(i2==DEF_STRUCT){
     484                            SetReg_WholeVariable(varType.GetBasicType(),&RelativeVar,UseReg);
     485                        }
     486                        else if( varType.IsStruct() ){
    469487                            //構造体ポインタをUseRegへ格納（構造体は値型）
    470488                            SetVarPtrToReg(UseReg,&RelativeVar);
    471489                        }
    472490                        else SetError(11,term,cp);
     491
     492                        if( type_stack[sp] != varType.GetBasicType() ){
     493                            // 大きな型へ変換された場合
     494                            // ※レジスタの値をキャストする
     495                            ExtendRegToBigType( UseReg, type_stack[sp], varType.GetBasicType() );
     496                        }
    473497
    474498                        if(bXmm==0&&UseReg==REG_R14){
    … …  
    477501                        }
    478502                        if(bXmm&&XmmReg==REG_XMM4){
    479                             if(i2==DEF_DOUBLE){
     503                            if(varType.IsDouble()){
    480504                                //movsd qword ptr[rsp+offset],xmm4  ※スタックフレームを利用
    481505                                pobj_sf->push(REG_XMM4,sizeof(double));
    482506                            }
    483                             if(i2==DEF_SINGLE){
     507                            if(varType.IsSingle()){
    484508                                //movss dword ptr[rsp+offset],xmm4  ※スタックフレームを利用
    485509                                pobj_sf->push(REG_XMM4,sizeof(float));
    … …  
    500524                    i3 = CDBConst::obj.GetType(term);
    501525                    if(i3){
    502                         type[sp] = i3;
     526                        type_stack[sp] = i3;
    503527                        if(IsRealNumberType(i3)){
    504528                            //実数
    … …  
    536560                    i3=GetTypeFixed(term,&lp);
    537561                    if(i3!=-1){
    538                         type[sp]=i3|FLAG_CAST;
     562                        type_stack[sp]=i3|FLAG_CAST;
    539563                        index_stack[sp]=lp;
    540564                        sp++;
    … …  
    559583                        //////////////////////////////////////////////////////
    560584
    561                             TYPEINFO RetTypeInfo;
    562                             CallPropertyMethod(term,NULL,&RetTypeInfo);
     585                            Type resultType;
     586                            CallPropertyMethod(term,NULL,resultType);
    563587
    564588                            //大きな型への暗黙の変換
    565                             type[sp]=AutoBigCast(BaseType,RetTypeInfo.type);
    566 
    567                             index_stack[sp]=RetTypeInfo.u.lpIndex;
     589                            type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
     590                            index_stack[sp]=resultType.GetIndex();
    568591                            bLiteralCalculation=0;
    569592
    570                             SetUseRegFromRax(RetTypeInfo.type,UseReg,XmmReg);
    571 
    572                             if(IsRealNumberType(type[sp])) bXmm=1;
     593                            if( type_stack[sp] != resultType.GetBasicType() ){
     594                                // 大きな型へ変換された場合
     595                                // ※レジスタの値をキャストする
     596                                ExtendRegToBigType( REG_RAX, type_stack[sp], resultType.GetBasicType() );
     597                            }
     598
     599                            SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
     600
     601                            if(IsRealNumberType(type_stack[sp])) bXmm=1;
    573602                            else bXmm=0;
    574603
    … …  
    578607                        }////////////////////////////////////////////
    579608
    580                         if(type[sp]==DEF_STRUCT){
     609                        if(type_stack[sp]==DEF_STRUCT){
    581610                            //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    582611                            //※後にfreeする必要あり
    … …  
    595624                    bError=1;
    596625                    SetError(3,term,cp);
    597                     type[sp]=DEF_DOUBLE;
     626                    type_stack[sp]=DEF_DOUBLE;
    598627                }
    599628                else{
    600629                    //リテラル値
    601                     type[sp]=GetLiteralValue(term,&i64data,BaseType);
     630                    type_stack[sp]=GetLiteralValue(term,&i64data,baseType.GetBasicType());
    602631Literal:
    603                     if(type[sp]==DEF_DOUBLE){
     632                    if(type_stack[sp]==DEF_DOUBLE){
    604633                        //64ビット浮動小数型
    605634                        bXmm=1;
    … …  
    627656                        }
    628657                    }
    629                     else if(type[sp]==DEF_SINGLE){
     658                    else if(type_stack[sp]==DEF_SINGLE){
    630659                        //32ビット浮動小数型
    631660                        bXmm=1;
    … …  
    680709            case CALC_OR:
    681710            case CALC_AND:
    682                 if(!CalcTwoTerm_Logical(idCalc,type,index_stack,&sp)) goto error;
     711                if(!CalcTwoTerm_Logical(idCalc,type_stack,index_stack,&sp)) goto error;
    683712                break;
    684713            case CALC_NOT:
    685714                //value[sp-1]=Not value[sp-1]
    686715                //NOT演算子
    687                 if(!Calc_Not(type,sp)) goto error;
     716                if(!Calc_Not(type_stack,sp)) goto error;
    688717                break;
    689718
    … …  
    695724            case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
    696725            case CALC_EQUAL:    //value[sp-2] =  value[sp-1]               
    697                 if(!CalcTwoTerm_Relational(idCalc,type,index_stack,&sp)) goto error;
     726                if(!CalcTwoTerm_Relational(idCalc,type_stack,index_stack,&sp)) goto error;
    698727                break;
    699728
    … …  
    701730            case CALC_SHL:  //value[sp-2] << value[sp-1]
    702731            case CALC_SHR:  //value[sp-2] >> value[sp-1]
    703                 if(!Calc_Shift(idCalc,type,&sp)) goto error;
     732                if(!Calc_Shift(idCalc,type_stack,&sp)) goto error;
    704733                break;
    705734
    … …  
    708737            case CALC_SUBTRACTION:
    709738            case CALC_PRODUCT:
    710                 if(!CalcTwoTerm_Arithmetic(idCalc,type,index_stack,&sp)) goto error;
     739                if(!CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp)) goto error;
    711740                break;
    712741            case CALC_MOD:
    713742                //value[sp-2]%=value[sp-1]
    714743                //剰余演算
    715                 if(!Calc_Mod(type,index_stack,&sp)) goto error;
     744                if(!Calc_Mod(type_stack,index_stack,&sp)) goto error;
    716745                break;
    717746            case CALC_QUOTIENT:
    718747                //value[sp-2]/=value[sp-1];
    719748                //除算
    720                 if(!Calc_Divide(type,&sp,BaseType)) goto error;
     749                if(!Calc_Divide(type_stack,&sp,baseType.GetBasicType())) goto error;
    721750                break;
    722751            case CALC_INTQUOTIENT:
    723752                //value[sp-2]/=value[sp-1]
    724753                //整数除算
    725                 if(!Calc_IntDivide(type,index_stack,&sp)) goto error;
     754                if(!Calc_IntDivide(type_stack,index_stack,&sp)) goto error;
    726755                break;
    727756            case CALC_MINUSMARK:
    728757                //value[sp-1]=-value[sp-1]
    729758                //符号反転
    730                 if(!Calc_MinusMark(type,sp)) goto error;
     759                if(!Calc_MinusMark(type_stack,sp)) goto error;
    731760                break;
    732761            case CALC_POWER:
    733762                //べき乗演算（浮動小数点演算のみ）
    734                 if(!Calc_Power(type,&sp)) goto error;
     763                if(!Calc_Power(type_stack,&sp)) goto error;
    735764                break;
    736765            case CALC_AS:
    737766                //キャスト
    738                 if(!Calc_Cast(type,index_stack,&sp)) goto error;
     767                if(!Calc_Cast(type_stack,index_stack,&sp)) goto error;
    739768                break;
    740769            case CALC_BYVAL:
    741770                //ポインタ型→参照型
    742                 if( PTR_LEVEL( type[sp-1] ) <= 0 ){
     771                if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
    743772                    //ポインタ型ではないとき
    744773                    SetError( 3, NULL, cp );
    … …  
    746775                }
    747776
    748                 type[sp-1] = PTR_LEVEL_DOWN( type[sp-1] );
     777                type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
    749778
    750779                break;
    … …  
    765794    if(bLiteralCalculation){
    766795        //右辺値が数値の定数式の場合
    767         LONG_PTR lpClassIndex;
    768         i2=StaticCalculation(true, Command,BaseType,&i64data,&lpClassIndex);
     796        Type resultType;
     797        StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
    769798
    770799        obp=BeforeObp;
    … …  
    775804        *pobj_reg=objReg_Backup;
    776805
    777         if(IsRealNumberType(i2)){
    778             if(IsRealNumberType(BaseType)) i2=BaseType;
     806        if(resultType.IsReal()){
     807            if(baseType.IsReal()) resultType=baseType;
    779808
    780809            XmmReg=pobj_reg->LockXmmReg();
    781810
    782             if(i2==DEF_DOUBLE){
     811            if(resultType.IsDouble()){
    783812                i3 = dataTable.Add( i64data );
    784813
    … …  
    793822                obp+=sizeof(long);
    794823            }
    795             if(i2==DEF_SINGLE){
     824            if(resultType.IsSingle()){
    796825                memcpy(&dbl,&i64data,sizeof(_int64));
    797826
    … …  
    815844        }
    816845        else{
    817             if(!Is64Type(i2)){
     846            if(!resultType.Is64()){
    818847                //整数（符号有り/無し）
    819848
    820849                i3=(long)i64data;
    821850
    822                 if(GetTypeSize(i2,-1)==sizeof(char)) i3=i3&0x000000FF;
    823                 if(GetTypeSize(i2,-1)==sizeof(short)) i3=i3&0x0000FFFF;
     851                if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF;
     852                if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF;
    824853
    825854                i64data=(_int64)i3;
    … …  
    832861        }
    833862
    834         type[0]=i2;
    835         index_stack[0]=lpClassIndex;
     863        type_stack[0]=resultType.GetBasicType();
     864        index_stack[0]=resultType.GetIndex();
    836865    }
    837866    else{
    … …  
    840869    }
    841870
    842     if(plpIndex) *plpIndex=index_stack[0];
    843871    if(pbUseHeap) *pbUseHeap=bUseHeap[0];
    844872
    845     if(IsRealNumberType(type[0]))
     873    if(IsRealNumberType(type_stack[0]))
    846874        *pReg=pobj_reg->UnlockXmmReg();
    847875    else
    … …  
    858886    }
    859887
    860     int RetType;
    861     RetType=type[0];
     888    resultType.SetType( type_stack[0], index_stack[0] );
     889
     890    bool isSuccessful = true;
    862891    goto finish;
    863892
    … …  
    878907    }
    879908
    880     RetType=-1;
     909    isSuccessful = false;
    881910    goto finish;
    882911
    … …  
    893922    delete pobj_BackReloc;
    894923
    895     return RetType;
     924    return isSuccessful;
    896925}
Note: See TracChangeset for help on using the changeset viewer.