Changeset 97 in dev for BasicCompiler64/NumOpe.cpp


Ignore:
Timestamp:
Apr 16, 2007, 3:52:40 AM (17 years ago)
Author:
dai_9181
Message:

関数の戻り値オブジェクトのメンバ・メソッドを一時オブジェクトを介さずに参照できるようにした。

File:
1 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler64/NumOpe.cpp

    r94 r97  
    8383}
    8484
     85
     86bool VarToReg( RELATIVE_VAR &relativeVar, const Type &baseType, Type &resultType ){
     87    int UseReg=pobj_reg->GetNextReg();
     88    int XmmReg=pobj_reg->GetNextXmmReg();
     89
     90    //大きな型への暗黙の変換
     91    int bigType = AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
     92
     93    if(resultType.GetBasicType()&FLAG_PTR){
     94        //配列ポインタ
     95        resultType.SetBasicType( GetPtrType(resultType.GetBasicType()^FLAG_PTR) );
     96
     97        SetVarPtrToReg(UseReg,&relativeVar);
     98    }
     99    else if(resultType.IsReal()){
     100        //実数型
     101        if( resultType.IsDouble() )
     102            SetXmmReg_DoubleVariable(&relativeVar,XmmReg);
     103        if( resultType.IsSingle() )
     104            SetXmmReg_SingleVariable(&relativeVar,XmmReg);
     105    }
     106    else if( resultType.IsWhole() || resultType.IsObject()){
     107        //整数型
     108        SetReg_WholeVariable(resultType.GetBasicType(),&relativeVar,UseReg);
     109    }
     110    else if( resultType.IsStruct() ){
     111        //構造体ポインタをUseRegへ格納（構造体は値型）
     112        SetVarPtrToReg(UseReg,&relativeVar);
     113    }
     114    else{
     115        return false;
     116    }
     117
     118    if( resultType.GetBasicType() != bigType ){
     119        // 大きな型へ変換された場合
     120        // ※レジスタの値をキャストする
     121        ExtendRegToBigType( UseReg, bigType, resultType.GetBasicType() );
     122
     123        resultType.SetBasicType( bigType );
     124    }
     125
     126    return true;
     127}
     128bool TermMemberOpe( const CClass &objClass, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member ){
     129
     130    int UseReg=pobj_reg->GetNextReg();
     131    int XmmReg=pobj_reg->GetNextXmmReg();
     132
     133
     134    if( GetMemberType( objClass, member, resultType, 0, false ) ){
     135        // メンバが見つかったとき
     136
     137        //オブジェクトポインタをr11にコピー
     138        op_mov_RR( REG_R11, UseReg );
     139
     140        RELATIVE_VAR relativeVar;
     141        relativeVar.dwKind=VAR_DIRECTMEM;
     142
     143        if( !_member_offset(
     144            true,   //エラー表示あり
     145            false,  //読み込み専用
     146            objClass,
     147            member,&relativeVar,resultType,0)){
     148                return false;
     149        }
     150
     151        if( !VarToReg( relativeVar, baseType, resultType ) ){
     152            SetError(11,termFull,cp);
     153        }
     154
     155        return true;
     156    }
     157
     158
     159    ///////////////////////////////////////////////////////////////////
     160    // 動的メソッドを検索
     161    ///////////////////////////////////////////////////////////////////
     162    vector<UserProc *> userProcs;
     163
     164    char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1];
     165    CClass::RefType refType;
     166    lstrcpy( methodName, member );
     167    GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
     168
     169    objClass.EnumMethod( methodName, userProcs );
     170    UserProc *pUserProc;
     171    if(userProcs.size()){
     172        //オーバーロードを解決
     173        pUserProc=OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
     174
     175        if( pUserProc ){
     176
     177            resultType = pUserProc->ReturnType();
     178
     179
     180            //////////////////////////////////////////////////////
     181            /////    レジスタ資源のバックアップ
     182            {   BACKUP_REGISTER_RESOURCE
     183            //////////////////////////////////////////////////////
     184
     185                //オブジェクトポインタをスタックに入れておく
     186                //mov qword ptr[rsp+offset],reg     ※スタックフレームを利用
     187                pobj_sf->push( UseReg );
     188
     189                if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){
     190                    //レジスタ資源を復元
     191                    RESTORE_REGISTER_RESOURCE
     192
     193                    return false;
     194                }
     195
     196                pobj_sf->pop();
     197
     198                /////////////////////
     199                // 戻り値の処理
     200                /////////////////////
     201
     202                //大きな型への暗黙の変換
     203                int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
     204
     205                if( resultType.GetBasicType() != bigType ){
     206                    // 大きな型へ変換された場合
     207                    // ※レジスタの値をキャストする
     208                    ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
     209
     210                    resultType.SetBasicType( bigType );
     211                }
     212
     213                SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
     214
     215
     216            /////////////////////////////////////////////
     217            //////   レジスタ資源を復元
     218                RESTORE_REGISTER_RESOURCE
     219            }////////////////////////////////////////////
     220           
     221            return true;
     222        }
     223    }
     224
     225    return false;
     226}
     227bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool *pIsClassName = NULL ){
     228    char parameter[VN_SIZE];
     229
     230    // Withを解決
     231    char termFull[VN_SIZE];
     232    if(term[0]=='.'){
     233        GetWithName(termFull);
     234        lstrcat(termFull,term);
     235    }
     236    else lstrcpy(termFull,term);
     237
     238    char termLeft[VN_SIZE];
     239    lstrcpy(termLeft,termFull);
     240
     241    if( (string)term=="DayOfWeek"){
     242        int test=0;
     243    }
     244
     245    // パース
     246    char member[VN_SIZE];
     247    CClass::RefType refType;
     248    if( SplitMemberName( termFull, termLeft, member, refType ) ){
     249        ///////////////////////////////////////////////////////////////////
     250        // オブジェクトとメンバに分解できるとき
     251        // termLeft.member
     252        ///////////////////////////////////////////////////////////////////
     253
     254        isLiteral = false;
     255
     256        // オブジェクト側の型を取得
     257        bool isClassName = false;
     258        Type leftType;
     259        if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, &isClassName ) ){
     260            return false;
     261        }
     262
     263        if( isClassName ){
     264            // 静的メンバ/メソッドの場合
     265            goto globalArea;
     266        }
     267
     268        if( !leftType.HasMember() ){
     269            // メンバを持たない型の場合
     270            return false;
     271        }
     272
     273        return TermMemberOpe( leftType.GetClass(), baseType, resultType, termFull, termLeft, member );
     274    }
     275
     276
     277    //////////////////////////////////////////////
     278    // クラス名かどうかをチェック（静的メンバ用）
     279    //////////////////////////////////////////////
     280
     281    if( pIsClassName ){
     282        if( pobj_DBClass->check( termFull ) ){
     283            *pIsClassName = true;
     284            return true;
     285        }
     286    }
     287
     288
     289    /////////////////////////////////////////////////////////////////
     290    // グローバル属性エリア
     291    /////////////////////////////////////////////////////////////////
     292globalArea:
     293
     294    int UseReg=pobj_reg->GetNextReg();
     295    int XmmReg=pobj_reg->GetNextXmmReg();
     296
     297
     298    if(lstrcmpi(termFull,"This")==0){
     299        //Thisオブジェクト
     300        resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
     301
     302        SetThisPtrToReg( UseReg );
     303
     304        isLiteral = false;
     305
     306        return true;
     307    }
     308
     309
     310    //////////////////////////////////////
     311    // 関数（DLL、ユーザー定義、組み込み）
     312    //////////////////////////////////////
     313    char procName[VN_SIZE];
     314    char temporary[8192];
     315
     316    int i2=GetCallProcName(termFull,procName);
     317    if(termFull[i2]=='('){
     318        int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1);
     319
     320        void *pInfo;
     321        int idProc=GetProc(procName,(void **)&pInfo);
     322
     323        if(idProc){
     324            //閉じカッコ")"に続く文字がNULLでないとき
     325            if(termFull[i2+1+i4+1]!='\0'){
     326                SetError(42,NULL,cp);
     327            }
     328
     329
     330            //////////////////////////////////////////////////////
     331            /////    レジスタ資源のバックアップ
     332            {   BACKUP_REGISTER_RESOURCE
     333            //////////////////////////////////////////////////////
     334
     335
     336                ////////////////
     337                // 呼び出し
     338                ////////////////
     339
     340                CallProc(idProc,pInfo,procName,parameter,resultType);
     341
     342
     343                /////////////////////
     344                // 戻り値の処理
     345                /////////////////////
     346
     347                //大きな型への暗黙の変換
     348                int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
     349
     350                if( resultType.GetBasicType() != bigType ){
     351                    // 大きな型へ変換された場合
     352                    // ※レジスタの値をキャストする
     353                    ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
     354
     355                    resultType.SetBasicType( bigType );
     356                }
     357
     358                SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
     359
     360            /////////////////////////////////////////////
     361            //////   レジスタ資源を復元
     362                RESTORE_REGISTER_RESOURCE
     363            }////////////////////////////////////////////
     364
     365            if(resultType.IsStruct()){
     366                //構造体が戻ったときはヒープ領域にインスタンスが格納されている
     367                //※後にfreeする必要あり
     368                // TODO: 解放はGCに任せる
     369                *pbUseHeap = 1;
     370            }
     371
     372            isLiteral = false;
     373
     374            return true;
     375        }
     376        else if(GetConstCalcBuffer(procName,parameter,temporary)){
     377            /////////////////////////
     378            // マクロ関数
     379            /////////////////////////
     380
     381            //閉じカッコ")"に続く文字がNULLでないときはエラーにする
     382            if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
     383
     384            //マクロ関数の場合
     385            NumOpe(&UseReg,temporary,Type(),resultType);
     386
     387            if(!IS_LITERAL(resultType.GetIndex())){
     388                //リテラル値ではなかったとき
     389                isLiteral = false;
     390            }
     391
     392            return true;
     393        }
     394    }
     395
     396
     397    ////////////////////////////////
     398    // インデクサ（getアクセサ）
     399    ////////////////////////////////
     400
     401    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
     402    GetArrayElement(termFull,VarName,ArrayElements);
     403    if(ArrayElements[0]){
     404        GetVarType(VarName,resultType,false);
     405        if( resultType.IsObject() ){
     406            CallIndexerGetterProc(UseReg,&resultType.GetClass(),VarName,ArrayElements,resultType);
     407
     408            isLiteral = false;
     409
     410            return true;
     411        }
     412    }
     413
     414
     415    ////////////////////////////////
     416    // 変数
     417    ////////////////////////////////
     418
     419    RELATIVE_VAR relativeVar;
     420    if(GetVarOffset(
     421        false,  //エラー表示なし
     422        false,  //読み込み専用
     423        termFull,
     424        &relativeVar,resultType)){
     425        //////////
     426        // 変数
     427        //////////
     428
     429        if( !VarToReg( relativeVar, baseType, resultType ) ){
     430            SetError(11,termFull,cp);
     431        }
     432
     433        isLiteral = false;
     434
     435        return true;
     436    }
     437
     438/*
     439    ////////////////////////////////
     440    // 型名
     441    ////////////////////////////////
     442
     443    if( Type::StringToType( termFull, resultType ) ){
     444        resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
     445        return true;
     446    }*/
     447
     448
     449    /////////////////////////////////
     450    // プロパティ用のメソッド
     451    /////////////////////////////////
     452
     453    //配列要素を排除
     454    GetArrayElement(termFull,VarName,ArrayElements);
     455
     456    if(GetSubHash(VarName,0)){
     457
     458        //////////////////////////////////////////////////////
     459        /////    レジスタ資源のバックアップ
     460        {   BACKUP_REGISTER_RESOURCE
     461        //////////////////////////////////////////////////////
     462
     463            CallPropertyMethod(termFull,NULL,resultType);
     464
     465            //大きな型への暗黙の変換
     466            int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
     467
     468            if( resultType.GetBasicType() != bigType ){
     469                // 大きな型へ変換された場合
     470                // ※レジスタの値をキャストする
     471                ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
     472
     473                resultType.SetBasicType( bigType );
     474            }
     475
     476            SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
     477
     478        /////////////////////////////////////////////
     479        //////   レジスタ資源を復元
     480            RESTORE_REGISTER_RESOURCE
     481        }////////////////////////////////////////////
     482
     483        if(resultType.IsStruct()){
     484            //構造体が戻ったときはヒープ領域にインスタンスが格納されている
     485            //※後にfreeする必要あり
     486            // TODO: 解放はGCに任せる
     487            *pbUseHeap = 1;
     488        }
     489
     490        isLiteral = false;
     491
     492        return true;
     493    }
     494
     495
     496    return false;
     497}
     498
    85499bool NumOpe( int *pReg,
    86500            const char *expression,
    … …  
    89503            BOOL *pbUseHeap ){
    90504
    91     int i,i2,i3,i4;
    92     char temporary[1024],temp2[1024],temp3[1024];
     505    int i,i2,i3;
     506    char temporary[1024],temp2[1024];
    93507
    94508    if(expression[0]=='\0'){
    … …  
    289703                term=values[i];
    290704
     705                if( calc[i+1]%100 == CALC_AS ){
     706                    // As演算子の右辺値
     707                    //型名
     708                    if( Type::StringToType( term, resultType ) ){
     709                        resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
     710                    }
     711                    else{
     712                        SetError(3, term, cp );
     713                        goto error;
     714                    }
     715
     716                    type_stack[sp] = resultType.GetBasicType();
     717                    index_stack[sp] = resultType.GetIndex();
     718                    sp++;
     719
     720                    break;
     721                }
     722
    291723                if(term[0]=='\"'){
    292724                    //リテラル文字列
    … …  
    298730StrLiteral:
    299731
    300                     if( baseType.IsObject() ){
    301                         if( baseType.IsStringObject() ){
    302                             //要求タイプがStringのとき
    303 
    304                             //String型オブジェクトを生成
    305                             NewStringObject(UseReg,term);
    306 
    307                             extern CClass *pobj_StringClass;
    308                             type_stack[sp]=DEF_OBJECT;
    309                             index_stack[sp]=(LONG_PTR)pobj_StringClass;
    310                             bLiteralCalculation=0;
    311 
    312                             if(bXmm) pobj_reg->LockXmmReg();
    313                             else pobj_reg->LockReg();
    314 
    315                             sp++;
    316                             break;
    317                         }
     732                    if( baseType.IsObject() || baseType.IsNull() ){
     733                        //要求タイプがオブジェクト、または未定のとき
     734
     735                        //String型オブジェクトを生成
     736                        NewStringObject(UseReg,term);
     737
     738                        extern CClass *pobj_StringClass;
     739                        type_stack[sp]=DEF_OBJECT;
     740                        index_stack[sp]=(LONG_PTR)pobj_StringClass;
     741                        bLiteralCalculation=0;
     742
     743                        if(bXmm) pobj_reg->LockXmmReg();
     744                        else pobj_reg->LockReg();
     745
     746                        sp++;
     747                        break;
    318748                    }
    319749
    … …  
    353783                    // 何らかの識別子
    354784
    355                     //////////////////////////////////////
    356                     // 関数（DLL、ユーザー定義、組み込み）
    357                     //////////////////////////////////////
    358 
    359                     i2=GetCallProcName(term,temporary);
    360                     if(term[i2]=='('){
    361                         i4=GetStringInPare_RemovePare(temp2,term+i2+1);
    362 
    363                         void *pInfo;
    364                         int idProc=GetProc(temporary,(void **)&pInfo);
    365 
    366                         Type resultType;
    367                         if(idProc){
    368                             //閉じカッコ")"に続く文字がNULLでないとき
    369                             if(term[i2+1+i4+1]!='\0'){
    370                                 if( term[i2+1+i4+1] == '.'
    371                                     || term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
    372                                         goto NonProc;
    373                                 }
    374                                 else{
    375                                     SetError(42,NULL,cp);
     785                    bool isLiteral;
     786                    if( TermOpe( term, baseType, resultType, isLiteral, &bUseHeap[sp] ) ){
     787                        if(resultType.IsNull()){
     788                            //戻り値が存在しないとき
     789                            for(i2=0;;i2++){
     790                                if(term[i2]=='('||term[i2]=='\0'){
     791                                    term[i2]=0;
     792                                    break;
    376793                                }
    377794                            }
    378 
    379 
    380                             //////////////////////////////////////////////////////
    381                             /////    レジスタ資源のバックアップ
    382                             {   BACKUP_REGISTER_RESOURCE
    383                             //////////////////////////////////////////////////////
    384 
    385 
    386                                 ////////////////
    387                                 // 呼び出し
    388                                 ////////////////
    389 
    390                                 CallProc(idProc,pInfo,temporary,temp2,resultType);
    391                                 if(resultType.IsNull()){
    392                                     //戻り値が存在しないとき
    393                                     for(i2=2;;i2++){
    394                                         if(term[i2]=='('||term[i2]=='\0'){
    395                                             term[i2]=0;
    396                                             break;
    397                                         }
    398                                     }
    399                                     SetError(38,term,cp);
    400 
    401                                     //レジスタ資源を復元
    402                                     RESTORE_REGISTER_RESOURCE
    403 
    404                                     goto error;
     795                            SetError(38,term,cp);
     796
     797                            goto error;
     798                        }
     799
     800                        type_stack[sp] = resultType.GetBasicType();
     801                        index_stack[sp] = resultType.GetIndex();
     802
     803                        if( !isLiteral ){
     804                            bLiteralCalculation=0;
     805                        }
     806
     807                        if( resultType.GetBasicType() & FLAG_CAST ){
     808                            // 型名のみ
     809                            SetError();
     810                        }
     811                        else{
     812                            if( resultType.IsReal() == false && UseReg==REG_R14 ){
     813                                //mov qword ptr[rsp+offset],r14     ※スタックフレームを利用
     814                                pobj_sf->push(REG_R14);
     815                            }
     816                            if( resultType.IsReal() && XmmReg==REG_XMM4 ){
     817                                if(resultType.IsDouble()){
     818                                    //movsd qword ptr[rsp+offset],xmm4  ※スタックフレームを利用
     819                                    pobj_sf->push(REG_XMM4,sizeof(double));
    405820                                }
    406 
    407 
    408                                 /////////////////////
    409                                 // 戻り値の処理
    410                                 /////////////////////
    411 
    412                                 //大きな型への暗黙の変換
    413                                 type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
    414                                 index_stack[sp] = resultType.GetIndex();
    415                                 bLiteralCalculation=0;
    416 
    417                                 if( type_stack[sp] != resultType.GetBasicType() ){
    418                                     // 大きな型へ変換された場合
    419                                     // ※レジスタの値をキャストする
    420                                     ExtendRegToBigType( REG_RAX, type_stack[sp], resultType.GetBasicType() );
     821                                if(resultType.IsSingle()){
     822                                    //movss dword ptr[rsp+offset],xmm4  ※スタックフレームを利用
     823                                    pobj_sf->push(REG_XMM4,sizeof(float));
    421824                                }
    422 
    423                                 SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
    424 
    425                                 if(resultType.IsReal()) bXmm=1;
    426                                 else bXmm=0;
    427 
    428                             /////////////////////////////////////////////
    429                             //////   レジスタ資源を復元
    430                                 RESTORE_REGISTER_RESOURCE
    431                             }////////////////////////////////////////////
    432 
    433 
    434                             if(bXmm) pobj_reg->LockXmmReg();
    435                             else pobj_reg->LockReg();
    436 
    437                             if(resultType.IsStruct()){
    438                                 //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    439                                 //※後にfreeする必要あり
    440                                 bUseHeap[sp]=1;
    441825                            }
    442826
    443                             sp++;
    444                             break;
    445                         }
    446                         else if(GetConstCalcBuffer(temporary,temp2,temp3)){
    447                             /////////////////////////
    448                             // マクロ関数
    449                             /////////////////////////
    450 
    451                             //閉じカッコ")"に続く文字がNULLでないときはエラーにする
    452                             if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
    453 
    454                             //マクロ関数の場合
    455                             NumOpe(&UseReg,temp3,Type(),resultType);
    456 
    457                             if(!IS_LITERAL(resultType.GetIndex())){
    458                                 //リテラル値ではなかったとき
    459                                 bLiteralCalculation=0;
     827                            if( resultType.IsReal() ){
     828                                pobj_reg->LockXmmReg();
    460829                            }
    461 
    462                             type_stack[sp] = resultType.GetBasicType();
    463                             index_stack[sp] = resultType.GetIndex();
    464 
    465                             if(resultType.IsReal()) pobj_reg->LockXmmReg();
    466                             else pobj_reg->LockReg();
    467 
    468                             sp++;
    469                             break;
    470                         }
    471                     }
    472 NonProc:
    473 
    474 
    475                     //インデクサ（getアクセサ）
    476                     char variable[VN_SIZE],array_element[VN_SIZE];
    477                     GetArrayElement(term,variable,array_element);
    478                     if(array_element[0]){
    479                         Type resultType;
    480                         GetVarType(variable,resultType,0);
    481                         if( resultType.IsObject() ){
    482                             CallIndexerGetterProc(UseReg,&resultType.GetClass(),variable,array_element,resultType);
    483                             type_stack[sp]=resultType.GetBasicType();
    484                             index_stack[sp]=resultType.GetIndex();
    485                             bLiteralCalculation=0;
    486 
    487                             if(resultType.IsReal()) pobj_reg->LockXmmReg();
    488                             else pobj_reg->LockReg();
    489                             sp++;
    490                             break;
    491                         }
     830                            else{
     831                                pobj_reg->LockReg();
     832                            }
     833                        }
     834
     835                        sp++;
     836                        break;
    492837                    }
    493838
    … …  
    516861
    517862                        pobj_reg->LockReg();
    518                         sp++;
    519                         break;
    520                     }
    521 
    522 
    523                     RELATIVE_VAR RelativeVar;
    524                     Type varType;
    525                     if(GetVarOffset(
    526                         false,  //エラー表示あり
    527                         false,  //読み込み専用
    528                         term,
    529                         &RelativeVar,varType)){
    530                         //////////
    531                         // 変数
    532                         //////////
    533 
    534                         //大きな型への暗黙の変換
    535                         type_stack[sp]=AutoBigCast(baseType.GetBasicType(),varType.GetBasicType());
    536                         index_stack[sp] = varType.GetIndex();
    537                         bLiteralCalculation=0;
    538 
    539                         if(varType.GetBasicType()&FLAG_PTR){
    540                             //配列ポインタ
    541                             type_stack[sp]=GetPtrType(varType.GetBasicType()^FLAG_PTR);
    542 
    543                             SetVarPtrToReg(UseReg,&RelativeVar);
    544                         }
    545                         else if(varType.IsReal()){
    546                             //実数型
    547                             bXmm=1;
    548 
    549                             if( varType.IsDouble() )
    550                                 SetXmmReg_DoubleVariable(&RelativeVar,XmmReg);
    551                             if( varType.IsSingle() )
    552                                 SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
    553                         }
    554                         else if( varType.IsWhole() || varType.IsObject()){
    555                             //整数型
    556                             SetReg_WholeVariable(varType.GetBasicType(),&RelativeVar,UseReg);
    557                         }
    558                         else if( varType.IsStruct() ){
    559                             //構造体ポインタをUseRegへ格納（構造体は値型）
    560                             SetVarPtrToReg(UseReg,&RelativeVar);
    561                         }
    562                         else SetError(11,term,cp);
    563 
    564                         if( type_stack[sp] != varType.GetBasicType() ){
    565                             // 大きな型へ変換された場合
    566                             // ※レジスタの値をキャストする
    567                             ExtendRegToBigType( UseReg, type_stack[sp], varType.GetBasicType() );
    568                         }
    569 
    570                         if(bXmm==0&&UseReg==REG_R14){
    571                             //mov qword ptr[rsp+offset],r14     ※スタックフレームを利用
    572                             pobj_sf->push(REG_R14);
    573                         }
    574                         if(bXmm&&XmmReg==REG_XMM4){
    575                             if(varType.IsDouble()){
    576                                 //movsd qword ptr[rsp+offset],xmm4  ※スタックフレームを利用
    577                                 pobj_sf->push(REG_XMM4,sizeof(double));
    578                             }
    579                             if(varType.IsSingle()){
    580                                 //movss dword ptr[rsp+offset],xmm4  ※スタックフレームを利用
    581                                 pobj_sf->push(REG_XMM4,sizeof(float));
    582                             }
    583                         }
    584 
    585                         if(bXmm) pobj_reg->LockXmmReg();
    586                         else pobj_reg->LockReg();
    587863                        sp++;
    588864                        break;
    … …  
    622898                        }
    623899                    }
    624 
    625 
    626                     //////////////
    627                     // 型名の場合
    628                     //////////////
    629                     Type tempType;
    630                     if( Type::StringToType( term, tempType ) ){
    631                         type_stack[sp] = tempType.GetBasicType() | FLAG_CAST;
    632                         index_stack[sp] = tempType.GetIndex();
    633                         sp++;
    634                         break;
    635                     }
    636 
    637 
    638                     /////////////////////////////////
    639                     // プロパティ用のメソッド
    640                     /////////////////////////////////
    641 
    642                     //配列要素を排除
    643                     char VarName[VN_SIZE],ArrayElements[VN_SIZE];
    644                     GetArrayElement(term,VarName,ArrayElements);
    645 
    646                     if(GetSubHash(VarName,0)){
    647 
    648                         //////////////////////////////////////////////////////
    649                         /////    レジスタ資源のバックアップ
    650                         {   BACKUP_REGISTER_RESOURCE
    651                         //////////////////////////////////////////////////////
    652 
    653                             Type resultType;
    654                             CallPropertyMethod(term,NULL,resultType);
    655 
    656                             //大きな型への暗黙の変換
    657                             type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
    658                             index_stack[sp]=resultType.GetIndex();
    659                             bLiteralCalculation=0;
    660 
    661                             if( type_stack[sp] != resultType.GetBasicType() ){
    662                                 // 大きな型へ変換された場合
    663                                 // ※レジスタの値をキャストする
    664                                 ExtendRegToBigType( REG_RAX, type_stack[sp], resultType.GetBasicType() );
    665                             }
    666 
    667                             SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
    668 
    669                             if(IsRealNumberType(type_stack[sp])) bXmm=1;
    670                             else bXmm=0;
    671 
    672                         /////////////////////////////////////////////
    673                         //////   レジスタ資源を復元
    674                             RESTORE_REGISTER_RESOURCE
    675                         }////////////////////////////////////////////
    676 
    677                         if(type_stack[sp]==DEF_STRUCT){
    678                             //構造体が戻ったときはヒープ領域にインスタンスが格納されている
    679                             //※後にfreeする必要あり
    680                             bUseHeap[sp]=1;
    681                         }
    682 
    683                         if(bXmm) pobj_reg->LockXmmReg();
    684                         else pobj_reg->LockReg();
    685                         sp++;
    686                         break;
    687                     }
    688 
    689900
    690901
    … …  
    735946
    736947                        if(XmmReg==REG_XMM4){
     948                            SetError();     // TODO: 未実装
    737949                            //push term
    738950                            op_push_value(i32data);
Note: See TracChangeset for help on using the changeset viewer.