Changeset 97 in dev for BasicCompiler32/NumOpe.cpp

Timestamp:

Apr 16, 2007, 3:52:40 AM (17 years ago)

Author:

dai_9181

Message:

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

File:

• BasicCompiler32/NumOpe.cpp (modified) (7 diffs)

BasicCompiler32/NumOpe.cpp

@@ -83 +83 @@
 }
 
-
+void ExtendRegToBigType( int reg, int bigBasicType, int baseBasicType ){
+    if( reg != REG_EAX ){
+        SetError();
+    }
+    switch( Type::GetBasicSize( bigBasicType ) ){
+        case sizeof(_int64):
+            ExtendTypeTo64(baseBasicType);
+            break;
+        case sizeof(long):
+            ExtendTypeTo32(baseBasicType,reg);
+            break;
+        case sizeof(short):
+            ExtendTypeTo16(baseBasicType,reg);
+            break;
+    }
+}
+
+
+
+bool VarToReg( RELATIVE_VAR &relativeVar, const Type &baseType, Type &resultType ){
+    const int useReg = REG_EAX;
+
+    //大きな型への暗黙の変換
+    int bigType = AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
+
+    if(resultType.GetBasicType()&FLAG_PTR){
+        //配列ポインタ
+        resultType.SetBasicType( GetPtrType(resultType.GetBasicType()^FLAG_PTR) );
+
+        SetVarPtrToReg(useReg, &relativeVar);
+    }
+    else if( resultType.IsStruct() ){
+        //構造体ポインタをeaxへ格納（構造体は値型）
+        SetVarPtrToReg(useReg, &relativeVar);
+    }
+    else if( resultType.IsReal() ){
+        // 実数
+        SetReg_RealVariable( resultType.GetBasicType(), &relativeVar );
+    }
+    else if( resultType.IsWhole() || resultType.IsObject()){
+        //整数型
+        SetReg_WholeVariable(resultType.GetBasicType(),&relativeVar,useReg);
+    }
+    else if( resultType.IsStruct() ){
+        //構造体ポインタをUseRegへ格納（構造体は値型）
+        SetVarPtrToReg(useReg,&relativeVar);
+    }
+    else{
+        return false;
+    }
+
+    if( resultType.GetBasicType() != bigType ){
+        // 大きな型へ変換された場合
+        // ※レジスタの値をキャストする
+        ExtendRegToBigType( useReg, bigType, resultType.GetBasicType() );
+
+        resultType.SetBasicType( bigType );
+    }
+
+    return true;
+}
+bool TermMemberOpe( const CClass &objClass, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member ){
+    const int useReg = REG_EAX;
+
+    if( GetMemberType( objClass, member, resultType, 0, false ) ){
+        // メンバが見つかったとき
+
+        //オブジェクトポインタをecxにコピー
+        op_mov_RR( REG_ECX, useReg );
+
+        RELATIVE_VAR relativeVar;
+        relativeVar.dwKind=VAR_DIRECTMEM;
+
+        if( !_member_offset(
+            true,   //エラー表示あり
+            false,  //読み込み専用
+            objClass,
+            member,&relativeVar,resultType,0)){
+                return false;
+        }
+
+        if( !VarToReg( relativeVar, baseType, resultType ) ){
+            SetError(11,termFull,cp);
+        }
+
+        return true;
+    }
+
+
+    ///////////////////////////////////////////////////////////////////
+    // 動的メソッドを検索
+    ///////////////////////////////////////////////////////////////////
+    vector<UserProc *> userProcs;
+
+    char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1];
+    CClass::RefType refType;
+    lstrcpy( methodName, member );
+    GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
+
+    objClass.EnumMethod( methodName, userProcs );
+    UserProc *pUserProc;
+    if(userProcs.size()){
+        //オーバーロードを解決
+        pUserProc=OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
+
+        if( pUserProc ){
+
+            resultType = pUserProc->ReturnType();
+
+            {
+                //オブジェクトポインタをスタックに入れておく
+                //push reg
+                op_push( useReg );
+
+                if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){
+
+                    return false;
+                }
+
+                op_pop();
+
+                /////////////////////
+                // 戻り値の処理
+                /////////////////////
+
+                //大きな型への暗黙の変換
+                int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+                if( resultType.GetBasicType() != bigType ){
+                    // 大きな型へ変換された場合
+                    // ※レジスタの値をキャストする
+                    ExtendRegToBigType( REG_EAX, bigType, resultType.GetBasicType() );
+
+                    resultType.SetBasicType( bigType );
+                }
+
+                //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+            }
+            
+            return true;
+        }
+    }
+
+    return false;
+}
+bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool *pIsClassName = NULL ){
+    char parameter[VN_SIZE];
+
+    // Withを解決
+    char termFull[VN_SIZE];
+    if(term[0]=='.'){
+        GetWithName(termFull);
+        lstrcat(termFull,term);
+    }
+    else lstrcpy(termFull,term);
+
+    char termLeft[VN_SIZE];
+    lstrcpy(termLeft,termFull);
+
+    // パース
+    char member[VN_SIZE];
+    CClass::RefType refType;
+    if( SplitMemberName( termFull, termLeft, member, refType ) ){
+        ///////////////////////////////////////////////////////////////////
+        // オブジェクトとメンバに分解できるとき
+        // termLeft.member
+        ///////////////////////////////////////////////////////////////////
+
+        isLiteral = false;
+
+        // オブジェクト側の型を取得
+        bool isClassName = false;
+        Type leftType;
+        if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, &isClassName ) ){
+            return false;
+        }
+
+        if( isClassName ){
+            // 静的メンバ/メソッドの場合
+            goto globalArea;
+        }
+
+        if( !leftType.HasMember() ){
+            // メンバを持たない型の場合
+            return false;
+        }
+
+        return TermMemberOpe( leftType.GetClass(), baseType, resultType, termFull, termLeft, member );
+    }
+
+
+    //////////////////////////////////////////////
+    // クラス名かどうかをチェック（静的メンバ用）
+    //////////////////////////////////////////////
+
+    if( pIsClassName ){
+        if( pobj_DBClass->check( termFull ) ){
+            *pIsClassName = true;
+            return true;
+        }
+    }
+
+
+    /////////////////////////////////////////////////////////////////
+    // グローバル属性エリア
+    /////////////////////////////////////////////////////////////////
+globalArea:
+
+    const int useReg = REG_EAX;
+
+
+    if(lstrcmpi(termFull,"This")==0){
+        //Thisオブジェクト
+        resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
+
+        SetThisPtrToReg( useReg );
+
+        isLiteral = false;
+
+        return true;
+    }
+
+
+    //////////////////////////////////////
+    // 関数（DLL、ユーザー定義、組み込み）
+    //////////////////////////////////////
+    char procName[VN_SIZE];
+    char temporary[8192];
+
+    int i2=GetCallProcName(termFull,procName);
+    if(termFull[i2]=='('){
+        int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1);
+
+        void *pInfo;
+        int idProc=GetProc(procName,(void **)&pInfo);
+
+        if(idProc){
+            //閉じカッコ")"に続く文字がNULLでないとき
+            if(termFull[i2+1+i4+1]!='\0'){
+                SetError(42,NULL,cp);
+            }
+
+
+            {
+                ////////////////
+                // 呼び出し
+                ////////////////
+
+                CallProc(idProc,pInfo,procName,parameter,resultType);
+
+
+                /////////////////////
+                // 戻り値の処理
+                /////////////////////
+
+                //大きな型への暗黙の変換
+                int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+                /*
+                ※後でNumOpe内でプッシュする
+                //スタックへプッシュ
+                PushReturnValue( resultType.GetBasicType() );
+                */
+
+                if( resultType.GetBasicType() != bigType ){
+                    // 大きな型へ変換された場合
+                    // ※レジスタの値をキャストする
+                    ExtendRegToBigType( useReg, bigType, resultType.GetBasicType() );
+
+                    resultType.SetBasicType( bigType );
+                }
+
+                //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+            }
+
+
+            if(resultType.IsStruct()){
+                //構造体が戻ったときはヒープ領域にインスタンスが格納されている
+                //※後にfreeする必要あり
+                // TODO: 解放はGCに任せる
+                *pbUseHeap = 1;
+            }
+
+            isLiteral = false;
+
+            return true;
+        }
+        else if(GetConstCalcBuffer(procName,parameter,temporary)){
+            /////////////////////////
+            // マクロ関数
+            /////////////////////////
+
+            //閉じカッコ")"に続く文字がNULLでないときはエラーにする
+            if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
+
+            //マクロ関数の場合
+            NumOpe(useReg, temporary,Type(),resultType);
+
+            if(!IS_LITERAL(resultType.GetIndex())){
+                //リテラル値ではなかったとき
+                isLiteral = false;
+            }
+
+            return true;
+        }
+    }
+
+
+    ////////////////////////////////
+    // インデクサ（getアクセサ）
+    ////////////////////////////////
+
+    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
+    GetArrayElement(termFull,VarName,ArrayElements);
+    if(ArrayElements[0]){
+        GetVarType(VarName,resultType,false);
+        if( resultType.IsObject() ){
+            CallIndexerGetterProc(/*UseReg,*/&resultType.GetClass(),VarName,ArrayElements,resultType);
+
+            isLiteral = false;
+
+            return true;
+        }
+    }
+
+
+    ////////////////////////////////
+    // 変数
+    ////////////////////////////////
+
+    RELATIVE_VAR relativeVar;
+    if(GetVarOffset(
+        false,  //エラー表示なし
+        false,  //読み込み専用
+        termFull,
+        &relativeVar,resultType)){
+        //////////
+        // 変数
+        //////////
+
+        if( !VarToReg( relativeVar, baseType, resultType ) ){
+            SetError(11,termFull,cp);
+        }
+
+        isLiteral = false;
+
+        return true;
+    }
+
+
+    /////////////////////////////////
+    // プロパティ用のメソッド
+    /////////////////////////////////
+
+    //配列要素を排除
+    GetArrayElement(termFull,VarName,ArrayElements);
+
+    if(GetSubHash(VarName,0)){
+
+        {
+            CallPropertyMethod(termFull,NULL,resultType);
+
+            //大きな型への暗黙の変換
+            int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+            if( resultType.GetBasicType() != bigType ){
+                // 大きな型へ変換された場合
+                // ※レジスタの値をキャストする
+                ExtendRegToBigType( REG_EAX, bigType, resultType.GetBasicType() );
+
+                resultType.SetBasicType( bigType );
+            }
+
+            //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+        }
+
+
+        if(resultType.IsStruct()){
+            //構造体が戻ったときはヒープ領域にインスタンスが格納されている
+            //※後にfreeする必要あり
+            // TODO: 解放はGCに任せる
+            *pbUseHeap = 1;
+        }
+
+        isLiteral = false;
+
+        return true;
+    }
+
+
+    return false;
+}
+
+
+bool NumOpe( int reg,
+            const char *expression,
+            const Type &baseType,
+            Type &resultType,
+            BOOL *pbUseHeap ){
+
+    if( !NumOpe( expression, baseType, resultType, pbUseHeap ) ){
+        return false;
+    }
+
+    if( reg != REG_EAX ){
+        // TODO: 未実装
+        SetError();
+    }
+
+    if( resultType.IsReal() ){
+        //fld ptr[esp]
+        op_fld_ptr_esp( resultType.GetBasicType() );
+
+        //add esp,size
+        op_add_esp( resultType.GetBasicSize() );
+    }
+    else{
+        //pop eax
+        op_pop(REG_EAX);
+
+        if( resultType.Is64() ){
+            //pop edx
+            op_pop(REG_EDX);
+        }
+    }
+    return true;
+}
 bool NumOpe( const char *expression,
             const Type &baseType,
@@ -89 +515 @@
             BOOL *pbUseHeap ){
 
-    int i,i2,i3,i4;
-    char temporary[1024],temp2[1024],temp3[1024];
+    int i,i2,i3;
+    char temporary[1024],temp2[1024];
 
     if(expression[0]=='\0'){
@@ -260 +686 @@
                 term=values[i];
 
+                if( calc[i+1]%100 == CALC_AS ){
+                    // As演算子の右辺値
+                    //型名
+                    if( Type::StringToType( term, resultType ) ){
+                        resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
+                    }
+                    else{
+                        SetError(3, term, cp );
+                        goto error;
+                    }
+
+                    type_stack[sp] = resultType.GetBasicType();
+                    index_stack[sp] = resultType.GetIndex();
+                    sp++;
+
+                    break;
+                }
+
                 if(term[0]=='\"'){
                     //リテラル文字列
@@ -269 +713 @@
 StrLiteral:
 
-                    if( baseType.IsObject() ){
-                        if( baseType.IsStringObject() ){
-                            //要求タイプがStringのとき
-
-                            //String型オブジェクトを生成
-                            NewStringObject(term);
-
-                            extern CClass *pobj_StringClass;
-                            type_stack[sp]=DEF_OBJECT;
-                            index_stack[sp]=(LONG_PTR)pobj_StringClass;
-                            bLiteralCalculation=0;
-
-                            sp++;
-                            break;
-                        }
+                    if( baseType.IsObject() || baseType.IsNull() ){
+                        //要求タイプがオブジェクト、または未定のとき
+
+                        //String型オブジェクトを生成
+                        NewStringObject(term);
+
+                        extern CClass *pobj_StringClass;
+                        type_stack[sp]=DEF_OBJECT;
+                        index_stack[sp]=(LONG_PTR)pobj_StringClass;
+                        bLiteralCalculation=0;
+
+                        sp++;
+                        break;
                     }
 
@@ -317 +759 @@
                     // 何らかの識別子
 
-                    //////////////////////////////////////
-                    // 関数（DLL、ユーザー定義、組み込み）
-                    //////////////////////////////////////
-
-                    i2=GetCallProcName(term,temporary);
-                    if(term[i2]=='('){
-                        i4=GetStringInPare_RemovePare(temp2,term+i2+1);
-
-                        void *pInfo;
-                        int idProc=GetProc(temporary,(void **)&pInfo);
-
-                        Type resultType;
-                        if(idProc){
-                            //閉じカッコ")"に続く文字がNULLでないとき
-                            if(term[i2+1+i4+1]!='\0'){
-                                if( term[i2+1+i4+1] == '.'
-                                    || term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
-                                        goto NonProc;
+                    bool isLiteral;
+                    if( TermOpe( term, baseType, resultType, isLiteral, &bUseHeap[sp] ) ){
+                        if(resultType.IsNull()){
+                            //戻り値が存在しないとき
+                            for(i2=0;;i2++){
+                                if(term[i2]=='('||term[i2]=='\0'){
+                                    term[i2]=0;
+                                    break;
+                                }
+                            }
+                            SetError(38,term,cp);
+
+                            goto error;
+                        }
+
+                        type_stack[sp] = resultType.GetBasicType();
+                        index_stack[sp] = resultType.GetIndex();
+
+                        if( !isLiteral ){
+                            bLiteralCalculation=0;
+                        }
+
+                        if( resultType.GetBasicType() & FLAG_CAST ){
+                            // 型名のみ
+                            SetError();
+                        }
+                        else{
+                            if( resultType.IsReal() ){
+                                //sub esp,size
+                                //fstp ptr[esp]
+                                op_fstp_push( resultType );
+                            }
+                            else{
+                                if( resultType.Is64() ){
+                                    //push edx
+                                    op_push( REG_EDX );
                                 }
                                 else{
-                                    SetError(42,NULL,cp);
+                                    ExtendTypeTo32( resultType.GetBasicType(), REG_EAX );
                                 }
+
+                                //push eax
+                                op_push( REG_EAX );
                             }
-
-                            ////////////////
-                            // 呼び出し
-                            ////////////////
-
-                            CallProc(idProc,pInfo,temporary,temp2,resultType);
-                            if(resultType.IsNull()){
-                                //戻り値が存在しないとき
-                                for(i2=2;;i2++){
-                                    if(term[i2]=='('||term[i2]=='\0'){
-                                        term[i2]=0;
-                                        break;
-                                    }
-                                }
-                                SetError(38,term,cp);
-
-                                goto error;
-                            }
-
-
-                            /////////////////////
-                            // 戻り値の処理
-                            /////////////////////
-
-                            //大きな型への暗黙の変換
-                            type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
-                            index_stack[sp] = resultType.GetIndex();
-                            bLiteralCalculation=0;
-
-                            //スタックへプッシュ
-                            PushReturnValue( resultType.GetBasicType() );
-
-                            if( Is64Type(type_stack[sp])
-                                && resultType.IsWhole()
-                                && resultType.GetBasicSize() <= sizeof(long) ){
-                                    //必要に応じて64ビット拡張
-                                    ExtendStackTo64( resultType.GetBasicType() );
-                            }
-
-                            if( resultType.IsStruct() ){
-                                //構造体が戻ったときはヒープ領域にインスタンスが格納されている
-                                //※後にfreeする必要あり
-                                bUseHeap[sp]=1;
-                            }
-
-                            sp++;
-                            break;
                         }
-                        else if(GetConstCalcBuffer(temporary,temp2,temp3)){
-                            /////////////////////////
-                            // マクロ関数
-                            /////////////////////////
-
-                            //閉じカッコ")"に続く文字がNULLでないときはエラーにする
-                            if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
-
-                            //マクロ関数の場合
-                            NumOpe(temp3,Type(),resultType);
-
-                            if(!IS_LITERAL(resultType.GetIndex())){
-                                //リテラル値ではなかったとき
-                                bLiteralCalculation=0;
-                            }
-
-                            type_stack[sp] = resultType.GetBasicType();
-                            index_stack[sp] = resultType.GetIndex();
-
-                            sp++;
-                            break;
-                        }
-                    }
-NonProc:
-
-
-                    //インデクサ（getアクセサ）
-                    char variable[VN_SIZE],array_element[VN_SIZE];
-                    GetArrayElement(term,variable,array_element);
-                    if(array_element[0]){
-                        Type resultType;
-                        GetVarType(variable,resultType,0);
-                        if( resultType.IsObject() ){
-                            CallIndexerGetterProc(&resultType.GetClass(),variable,array_element,resultType);
-                            type_stack[sp]=resultType.GetBasicType();
-                            index_stack[sp]=resultType.GetIndex();
-                            bLiteralCalculation=0;
-
-                            //push eax
-                            op_push(REG_EAX);
-
-                            sp++;
-                            break;
-                        }
+
+                        sp++;
+                        break;
                     }
 
@@ -451 +826 @@
                         //push 0
                         op_push_V( 0 );
-
-                        sp++;
-                        break;
-                    }
-
-                    RELATIVE_VAR RelativeVar;
-                    Type varType;
-                    if(GetVarOffset(
-                        false,  //エラー表示あり
-                        false,  //読み込み専用
-                        term,
-                        &RelativeVar,varType)){
-                        //////////
-                        // 変数
-                        //////////
-
-                        //大きな型への暗黙の変換
-                        type_stack[sp]=AutoBigCast(baseType.GetBasicType(),varType.GetBasicType());
-                        index_stack[sp] = varType.GetIndex();
-                        bLiteralCalculation=0;
-
-                        if(varType.GetBasicType()&FLAG_PTR){
-                            //配列ポインタ
-                            type_stack[sp]=GetPtrType(varType.GetBasicType()^FLAG_PTR);
-
-                            SetVarPtrToEax(&RelativeVar);
-
-                            //push eax
-                            op_push(REG_EAX);
-                        }
-                        else if( varType.IsStruct() ){
-                            //構造体ポインタをeaxへ格納（構造体は値型）
-                            SetVarPtrToEax(&RelativeVar);
-
-                            //push eax
-                            op_push(REG_EAX);
-                        }
-                        else if( varType.GetBasicSize() == sizeof(_int64) ){
-                            //64ビット型
-                            PushDoubleVariable(&RelativeVar);
-                        }
-                        else if( varType.GetBasicSize() == sizeof(long) ){
-                            //32ビット型
-                            PushLongVariable(&RelativeVar);
-                        }
-                        else if( varType.IsInteger() ){
-                            PushIntegerVariable(&RelativeVar);
-                        }
-                        else if( varType.IsWord() ){
-                            PushWordVariable(&RelativeVar);
-                        }
-                        else if( varType.IsSByte() ){
-                            PushCharVariable(&RelativeVar);
-                        }
-                        else if( varType.IsByte() || varType.IsBoolean() ){
-                            PushByteVariable(&RelativeVar);
-                        }
-                        else SetError(11,term,cp);
-
-                        if( Is64Type(type_stack[sp])
-                            && varType.IsWhole()
-                            && varType.GetBasicSize()<=sizeof(long)){
-                            //必要に応じて64ビット拡張
-                                ExtendStackTo64( varType.GetBasicType() );
-                        }
 
                         sp++;
@@ -556 +866 @@
 
 
-                    //////////////
-                    // 型名の場合
-                    //////////////
-                    Type tempType;
-                    if( Type::StringToType( term, tempType ) ){
-                        type_stack[sp] = tempType.GetBasicType() | FLAG_CAST;
-                        index_stack[sp] = tempType.GetIndex();
-                        sp++;
-                        break;
-                    }
-
-
-                    /////////////////////////////////
-                    // プロパティ用のメソッド
-                    /////////////////////////////////
-
-                    //配列要素を排除
-                    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
-                    GetArrayElement(term,VarName,ArrayElements);
-
-                    if(GetSubHash(VarName,0)){
-                        Type resultType;
-                        CallPropertyMethod(term,NULL,resultType);
-
-                        //大きな型への暗黙の変換
-                        type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
-                        index_stack[sp]=resultType.GetIndex();
-                        bLiteralCalculation=0;
-
-                        //スタックへプッシュ
-                        PushReturnValue( resultType.GetBasicType() );
-
-                        if(type_stack[sp]==DEF_STRUCT){
-                            //構造体が戻ったときはヒープ領域にインスタンスが格納されている
-                            //※後にfreeする必要あり
-                            bUseHeap[sp]=1;
-                        }
-
-                        sp++;
-                        break;
-                    }
-
-
-
                     //該当する識別子が見当たらないときはエラー扱いにする
                     bError=1;