Changeset 97 in dev for BasicCompiler_Common/NumOpe_GetType.cpp

Timestamp:

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

Author:

dai_9181

Message:

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

File:

• BasicCompiler_Common/NumOpe_GetType.cpp (modified) (6 diffs)

BasicCompiler_Common/NumOpe_GetType.cpp

@@ -294 +294 @@
 }
 
+bool GetTermType( const char *term, Type &resultType, bool &isLiteral, 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( !GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
+            return false;
+        }
+
+        if( isClassName ){
+            // 静的メンバ/メソッドの場合
+            goto globalArea;
+        }
+
+        if( !leftType.HasMember() ){
+            // メンバを持たない型の場合
+            return false;
+        }
+
+        const CClass &objClass = leftType.GetClass();
+
+
+        ///////////////////////////////////////////////////////////////////
+        // メンバを検索
+        ///////////////////////////////////////////////////////////////////
+        if( GetMemberType( objClass, member, resultType, 0, false ) ){
+            // メンバが見つかったとき
+            return true;
+        }
+
+
+        ///////////////////////////////////////////////////////////////////
+        // 動的メソッドを検索
+        ///////////////////////////////////////////////////////////////////
+        vector<UserProc *> userProcs;
+
+        char methodName[VN_SIZE] ,lpPtrOffset[VN_SIZE];
+        lstrcpy( methodName, member );
+        GetVarFormatString(methodName,parameter,lpPtrOffset,member,refType);
+
+        objClass.EnumMethod( methodName, userProcs );
+        UserProc *pUserProc;
+        if(userProcs.size()){
+            //オーバーロードを解決
+            pUserProc=OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
+
+            if( pUserProc ){
+                resultType = pUserProc->ReturnType();
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
+    //////////////////////////////////////////////
+    // クラス名かどうかをチェック（静的メンバ用）
+    //////////////////////////////////////////////
+
+    if( pIsClassName ){
+        if( pobj_DBClass->check( termFull ) ){
+            *pIsClassName = true;
+            return true;
+        }
+    }
+
+
+    /////////////////////////////////////////////////////////////////
+    // グローバル属性
+    /////////////////////////////////////////////////////////////////
+globalArea:
+
+
+    if(lstrcmpi(termFull,"This")==0){
+        //Thisオブジェクト
+        resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
+        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 *pProc;
+        int idProc=GetProc(procName,(void **)&pProc);
+
+        if(idProc){
+            //閉じカッコ")"に続く文字がNULLでないとき
+            if(termFull[i2+1+i4+1]!='\0'){
+                SetError(42,NULL,cp);
+            }
+
+
+            ////////////////
+            // 呼び出し
+            ////////////////
+
+            if( !CallProc(idProc,pProc,procName,parameter, resultType, false ) ){
+                return false;
+            }
+            if( resultType.IsNull() ){
+                //戻り値が存在しないとき
+                return false;
+            }
+
+            isLiteral = false;
+
+            return true;
+        }
+        else if(GetConstCalcBuffer(procName,parameter,temporary)){
+            /////////////////////////
+            // マクロ関数
+            /////////////////////////
+
+            //閉じカッコ")"に続く文字がNULLでないときはエラーにする
+            if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
+
+            //マクロ関数の場合
+            if( !NumOpe_GetType(temporary,Type(),resultType) ){
+                return false;
+            }
+
+            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() ){
+            if( !GetReturnTypeOfIndexerGetterProc( resultType.GetClass(),resultType) ){
+                SetError(1,NULL,cp);
+                return false;
+            }
+
+            isLiteral = false;
+
+            return true;
+        }
+    }
+
+
+    ////////////////////////////////
+    // 変数
+    ////////////////////////////////
+
+    if( GetVarType( termFull, resultType, false ) ){
+        if( resultType.GetBasicType() & FLAG_PTR ){
+            //配列ポインタ
+            resultType.SetBasicType( GetPtrType( resultType.GetBasicType()^FLAG_PTR ) );
+        }
+
+        isLiteral = false;
+
+        return true;
+    }
+
+
+    /////////////////////////////////
+    // プロパティ用のメソッド
+    /////////////////////////////////
+
+    //配列要素を排除
+    GetArrayElement(termFull,VarName,ArrayElements);
+
+    if(GetSubHash(VarName,0)){
+        GetReturnTypeOfPropertyMethod(termFull,NULL,resultType);
+
+        isLiteral = false;
+
+        return true;
+    }
+
+
+    return false;
+}
+
 bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType ){
     extern int cp;
-    int i,i2,i3,i4;
-    char temporary[1024],temp2[1024],temp3[1024];
+    int i,i3;
 
     if(expression[0]=='\0'){
@@ -392 +610 @@
                 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]=='\"'){
 StrLiteral:
 
-                    if( baseType.IsStringObject() ){
-                        //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
+                    if( baseType.IsObject() || baseType.IsNull() ){
+                        //要求タイプがオブジェクト、または未定のとき
                         extern CClass *pobj_StringClass;
                         type_stack[sp]=DEF_OBJECT;
@@ -421 +657 @@
                     // 何らかの識別子
 
-                    //////////////////////////////////////
-                    // 関数（DLL、ユーザー定義、組み込み）
-                    //////////////////////////////////////
-
-                    i2=GetCallProcName(term,temporary);
-                    if(term[i2]=='('){
-                        i4=GetStringInPare_RemovePare(temp2,term+i2+1);
-
-                        int idProc;
-                        void *pProc;
-                        idProc=GetProc(temporary,(void **)&pProc);
-
-                        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;
-                                }
-                                else{
-                                    SetError(42,NULL,cp);
-                                }
-                            }
-
-
-                            ////////////////
-                            // 呼び出し
-                            ////////////////
-
-                            Type resultType;
-                            if( !CallProc(idProc,pProc,temporary,temp2, resultType, false ) ){
-                                goto error;
-                            }
-                            if( resultType.IsNull() ){
-                                //戻り値が存在しないとき
-                                goto error;
-                            }
-
-                            type_stack[sp] = resultType.GetBasicType();
-                            index_stack[sp] = resultType.GetIndex();
-
+                    bool isLiteral = true;
+                    if( GetTermType( term, resultType, isLiteral ) ){
+                        type_stack[sp] = resultType.GetBasicType();
+                        index_stack[sp] = resultType.GetIndex();
+
+                        if( !isLiteral ){
                             bLiteralCalculation=0;
-
-                            sp++;
-                            break;
                         }
-                        else if(GetConstCalcBuffer(temporary,temp2,temp3)){
-                            /////////////////////////
-                            // マクロ関数
-                            /////////////////////////
-
-                            //閉じカッコ")"に続く文字がNULLでないときはエラーにする
-                            if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
-
-                            //マクロ関数の場合
-                            Type tempType;
-                            NumOpe_GetType(temp3,Type(),tempType);
-
-                            if(!IS_LITERAL(tempType.GetIndex())){
-                                //リテラル値ではなかったとき
-                                bLiteralCalculation=0;
-                            }
-
-                            type_stack[sp] = tempType.GetBasicType();
-                            index_stack[sp] = tempType.GetIndex(); 
-
-                            sp++;
-                            break;
-                        }
-                    }
-NonProc:
-
-                    //インデクサ（getアクセサ）
-                    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
-                    GetArrayElement(term,VarName,ArrayElements);
-                    if(ArrayElements[0]){
-                        Type type;
-                        GetVarType(VarName,type,false);
-                        if( type.IsObject() ){
-                            if( !GetReturnTypeOfIndexerGetterProc( type.GetClass(),type) ){
-                                SetError(1,NULL,cp);
-                                goto error;
-                            }
-                            type_stack[sp]=type.GetBasicType();
-                            index_stack[sp]=type.GetIndex();
-                            bLiteralCalculation=0;
-
-                            sp++;
-                            break;
-                        }
+
+                        sp++;
+                        break;
                     }
 
@@ -526 +683 @@
                         }
                         bLiteralCalculation = 0;
-                        sp++;
-                        break;
-                    }
-
-                    if( (string)term == "s.GetType().Name" ){
-                        int test=0;
-                    }
-
-
-                    Type varType;
-                    if( GetVarType(term,varType,0) ){
-                        //////////
-                        // 変数
-                        //////////
-
-                        if( varType.GetBasicType() & FLAG_PTR ){
-                            //配列ポインタ
-                            type_stack[sp]=GetPtrType( varType.GetBasicType()^FLAG_PTR );
-                        }
-                        else{
-                            type_stack[sp]=varType.GetBasicType();
-                        }
-                        index_stack[sp] = varType.GetIndex();
-
-                        bLiteralCalculation=0;
                         sp++;
                         break;
@@ -586 +718 @@
 
 
-                    //////////////
-                    // 型名の場合
-                    //////////////
-
-                    Type tempType;
-                    if( Type::StringToType( term, tempType ) ){
-                        type_stack[sp] = tempType.GetBasicType() | FLAG_CAST;
-                        index_stack[sp] = tempType.GetIndex();
-                        sp++;
-                        break;
-                    }
-
-
                     /////////////////////////////////
                     // プロパティ用のメソッド
@@ -604 +723 @@
 
                     //配列要素を排除
+                    char VarName[VN_SIZE],ArrayElements[VN_SIZE];
                     GetArrayElement(term,VarName,ArrayElements);
 
                     if(GetSubHash(VarName,0)){
+                        SetError();
                         Type tempType;
                         GetReturnTypeOfPropertyMethod(term,NULL,tempType);