Changeset 97 in dev for BasicCompiler_Common

Timestamp:

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

Author:

dai_9181

Message:

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

Location:

BasicCompiler_Common

Files:

• BasicCompiler.cpp (modified) (1 diff)
• BasicCompiler.h (modified) (1 diff)
• Class.cpp (modified) (1 diff)
• Class.h (modified) (1 diff)
• NumOpe_GetType.cpp (modified) (6 diffs)
• OldStatement.cpp (modified) (1 diff)
• Procedure.h (modified) (1 diff)
• Subroutine.cpp (modified) (3 diffs)
• Type.cpp (modified) (2 diffs)
• Type.h (modified) (1 diff)
• VariableOpe.cpp (modified) (2 diffs)
• VariableOpe.h (modified) (2 diffs)
• calculation.cpp (modified) (6 diffs)
• common.h (modified) (4 diffs)
• hash.cpp (modified) (1 diff)

BasicCompiler_Common/BasicCompiler.cpp

@@ -697 +697 @@
             isUnicode = true;
             typeOfPtrChar = MAKE_PTR_TYPE(DEF_WORD,1);
+            typeOfPtrUChar = MAKE_PTR_TYPE(DEF_WORD,1);
         }
 

BasicCompiler_Common/BasicCompiler.h

@@ -81 +81 @@
 bool isUnicode = false;
 int typeOfPtrChar = MAKE_PTR_TYPE(DEF_SBYTE,1);
+int typeOfPtrUChar = MAKE_PTR_TYPE(DEF_BYTE,1);
 
 char *basbuf;

BasicCompiler_Common/Class.cpp

@@ -1528 +1528 @@
         if( !objClass.IsUsing() ){
             // 未使用のクラスは無視する
-            if( (string)objClass.name == "CTest"){
-                int test=0;
-            }
             continue;
         }

BasicCompiler_Common/Class.h

@@ -210 +210 @@
     //メンバの参照方法
     enum RefType{
+        Non = 0,        // no reference member
         Dot,            // obj.member
         Pointer,        // obj->member
-        Non,            // no reference member
     };
 };

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);

BasicCompiler_Common/OldStatement.cpp

@@ -103 +103 @@
         else if(varType.IsObject()){
             varType.SetBasicType( DEF_OBJECT );
-            if( varType.IsStringObject() ){
+            if( varType.IsStringClass() ){
                 varType.SetBasicType( DEF_STRING );
             }

BasicCompiler_Common/Procedure.h

@@ -85 +85 @@
 class UserProc : public Procedure
 {
+#ifdef _DEBUG
+public:
+    string _paramStr;
+#endif
 
 private:

BasicCompiler_Common/Subroutine.cpp

@@ -83 +83 @@
     }
 }
+bool SplitMemberName( const char *desc, char *object, char *member, CClass::RefType &refType ){
+    int lastIndex = -1;
+    for( int i=0; desc[i]; i++ ){
+        if( desc[i] == '(' ){
+            i=JumpStringInPare(desc,i+1);
+            continue;
+        }
+        else if( desc[i] == '[' ){
+            i=JumpStringInBracket(desc,i+1);
+            continue;
+        }
+        else if(desc[i]=='.'||(desc[i]==1&&desc[i+1]==ESC_PSMEM)){
+            lastIndex = i;
+        }
+    }
+    if( lastIndex == -1 ){
+        return false;
+    }
+
+    if(desc[lastIndex]=='.'){
+        lstrcpy(member,desc+lastIndex+1);
+        refType = CClass::Dot;
+    }
+    else{
+        lstrcpy(member,desc+lastIndex+2);
+        refType = CClass::Pointer;
+    }
+
+    if( object ){
+        lstrcpy( object, desc );
+        object[lastIndex]=0;
+    }
+
+    return true;
+}
 bool SplitMemberName( const char *desc, char *object, char *member ){
-    int i;
-    for(i=lstrlen(desc)-1;i>=0;i--){
-        if(desc[i]=='.'||(desc[i]==1&&desc[i+1]==ESC_PSMEM))
-            break;
-    }
-    if(i==-1) return false;
-    else{
-        if(desc[i]=='.')
-            lstrcpy(member,desc+i+1);
-        else
-            lstrcpy(member,desc+i+2);
-
-        if( object ){
-            lstrcpy( object, desc );
-            object[i]=0;
-        }
-    }
-
-    return true;
+    CClass::RefType dummyRefType;
+    return SplitMemberName( desc, object, member, dummyRefType );
 }
 
@@ -565 +583 @@
     SubNum++;
 
-
     UserProc *pUserProc = new UserProc( temporary, kind, isMacro, isCdecl, isExport );
     pUserProc->SetParentClass( pobj_c );
@@ -580 +597 @@
     // ※第1パラメータにに指定するデータの例："( s As String ) As String"
     pUserProc->SetParamsAndReturnType( buffer + i, nowLine, isStatic );
+
+#ifdef _DEBUG
+    pUserProc->_paramStr = buffer + i;
+#endif
 
 

BasicCompiler_Common/Type.cpp

@@ -417 +417 @@
     return false;
 }
-bool Type::IsStringObject() const
+bool Type::IsObjectClass() const
+{
+    if( basicType == DEF_OBJECT ){
+        if( lstrcmp( pClass->name,"Object")==0){
+            return true;
+        }
+    }
+    return false;
+}
+bool Type::IsStringClass() const
 {
     if( basicType == DEF_OBJECT ){
@@ -438 +447 @@
     if( basicType == DEF_ANY ){
         return true;
+    }
+    return false;
+}
+
+bool Type::HasMember() const
+{
+    if( NATURAL_TYPE( basicType ) == DEF_OBJECT
+        || NATURAL_TYPE( basicType ) == DEF_STRUCT ){
+            return true;
     }
     return false;

BasicCompiler_Common/Type.h

@@ -105 +105 @@
     bool IsObject() const;
     bool IsObjectPtr() const;
-    bool IsStringObject() const;
+    bool IsObjectClass() const;
+    bool IsStringClass() const;
     bool IsVoidPtr() const;
     bool IsAny() const;
+
+    // オブジェクトや構造体など、メンバを持つ型かどうかを判別する
+    bool HasMember() const;
 
     const string ToString() const;

BasicCompiler_Common/VariableOpe.cpp

@@ -240 +240 @@
 }
 
+void GetWithName(char *buffer){
+    extern WITHINFO WithInfo;
+    int i;
+
+    buffer[0]=0;
+    for(i=0;i<WithInfo.num;i++)
+        lstrcat(buffer,WithInfo.ppName[i]);
+}
+
 bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, CClass::RefType &refType, char *member ){
     int p1 = 0, p2 = 0;
@@ -1173 +1182 @@
     }
 
-
     //構文を解析
     int SubScripts[MAX_ARRAYDIM];

BasicCompiler_Common/VariableOpe.h

@@ -14 +14 @@
 int GetPtrType(int type);
 BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name);
+void GetWithName(char *buffer);
 bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, CClass::RefType &refType, char *member );
 BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember, CClass::RefType &refType );
@@ -21 +22 @@
 void GetArrange(char *variable,char *variAnswer,int *SubScripts);
 int GetTypeFromSimpleName(char *variable);
+bool GetMemberType( const CClass &objClass, const char *lpszMember, Type &resultType, BOOL bPrivateAccess, bool isErrorEnabled);
 bool GetVarType( const char *nameBuffer, Type &resultType, bool isError);
 bool GetVarOffsetReadOnly(const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss = NULL );

BasicCompiler_Common/calculation.cpp

@@ -820 +820 @@
     for(i=0,sp=0;i<pnum;i++){
 
-        //型チェック（正常でない場合はエラーにする）
-        TypeErrorCheck(stack,sp,calc[i]%100);
+        if( enableerror ){
+            //型チェック（正常でない場合はエラーにする）
+            TypeErrorCheck(stack,sp,calc[i]%100);
+        }
 
         idCalc=calc[i]%100;
@@ -1088 +1090 @@
 #pragma optimize("", on)
 
-BOOL GetConstCalcBuffer(char *name,char *Parameter,char *pCalcBuffer){
+BOOL GetConstCalcBuffer(const char *name,const char *Parameter,char *pCalcBuffer){
     extern HANDLE hHeap;
     int i2,i3,i4,num;
@@ -1256 +1258 @@
                     pDllProc=GetDeclareHash(temporary);
                     if(pDllProc){
-                        if( pDllProc->ReturnType().IsStringObject() ){
+                        if( pDllProc->ReturnType().IsStringClass() ){
                             return 1;
                         }
@@ -1266 +1268 @@
                     pUserProc=GetSubHash(temporary);
                     if(pUserProc){
-                        if( pUserProc->ReturnType().IsStringObject() ){
+                        if( pUserProc->ReturnType().IsStringClass() ){
                             return 1;
                         }
@@ -1307 +1309 @@
                     return -1;
                 }
-                if( varType.IsStringObject() ){
+                if( varType.IsStringClass() ){
                     return 1;
                 }
@@ -1526 +1528 @@
     }
 
+    calc[*pnum]=0;
+
     return 1;
 }

BasicCompiler_Common/common.h

@@ -94 +94 @@
 extern bool isUnicode;
 extern int typeOfPtrChar;
+extern int typeOfPtrUChar;
 
 
@@ -294 +295 @@
 //hash.cpp
 int hash_default(const char *name);
-CONSTINFO *GetConstHash(char *name);
+CONSTINFO *GetConstHash(const char *name);
 DllProc *GetDeclareHash(char *name);
 void GetOverloadSubHash( const char *lpszName, std::vector<UserProc *> &subs );
@@ -418 +419 @@
 int NeutralizationType(int type1,LONG_PTR index1,int type2,LONG_PTR index2);
 DWORD GetLiteralValue(char *value,_int64 *pi64,int BaseType);
-BOOL GetConstCalcBuffer(char *name,char *Parameter,char *pCalcBuffer);
+BOOL GetConstCalcBuffer(const char *name,const char *Parameter,char *pCalcBuffer);
 DWORD GetConstValue(char *name,double *dbl,char *buffer,LONG_PTR *plpIndex);
 bool IsStringObjectType(const Type &TypeInfo);
@@ -435 +436 @@
 int GetProc(char *name,void **ppInfo);
 void SplitObjectName(const char *name,char *ObjectName,int *pRefType);
+bool SplitMemberName( const char *desc, char *object, char *member, CClass::RefType &refType );
 bool SplitMemberName( const char *desc, char *object, char *member );
 bool CallProc( int kind, const void *pProc, const char *fullCallName, const char *lpszParms, Type &resultType, bool isCallOn = true );

BasicCompiler_Common/hash.cpp

@@ -17 +17 @@
 }
 
-CONSTINFO *GetConstHash(char *name){
+CONSTINFO *GetConstHash(const char *name){
     //ハッシュ値を取得
     int key;