Changeset 128 in dev

Timestamp:

May 18, 2007, 4:42:36 AM (17 years ago)

Author:

dai_9181

Message:

Blittable型を導入した。

Files:

• BasicCompiler32/Compile_Calc.cpp (modified) (1 diff)
• BasicCompiler32/Compile_Statement.cpp (modified) (1 diff)
• BasicCompiler32/NumOpe.cpp (modified) (2 diffs)
• BasicCompiler32/Opcode.h (modified) (1 diff)
• BasicCompiler64/BasicCompiler.vcproj (modified) (2 diffs)
• BasicCompiler64/Compile_Calc.cpp (modified) (1 diff)
• BasicCompiler64/Compile_Statement.cpp (modified) (1 diff)
• BasicCompiler64/NumOpe.cpp (modified) (3 diffs)
• BasicCompiler64/Opcode.h (modified) (1 diff)
• BasicCompiler_Common/Class.cpp (modified) (6 diffs)
• BasicCompiler_Common/Class.h (modified) (1 diff)
• BasicCompiler_Common/Intermediate_Step2.cpp (modified) (1 diff)
• BasicCompiler_Common/NumOpe_GetType.cpp (modified) (4 diffs)
• BasicCompiler_Common/Procedure.cpp (modified) (2 diffs)
• BasicCompiler_Common/Type.cpp (modified) (1 diff)
• BasicCompiler_Common/Type.h (modified) (1 diff)
• BasicCompiler_Common/VariableOpe.cpp (modified) (1 diff)
• BasicCompiler_Common/calculation.cpp (modified) (1 diff)
• BasicCompiler_Common/common.h (modified) (2 diffs)
• BasicCompiler_Common/include/Smoothie.h (modified) (1 diff)
• BasicCompiler_Common/src/Smoothie.cpp (modified) (1 diff)

BasicCompiler32/Compile_Calc.cpp

@@ -619 +619 @@
 
 
+    if( varType.IsObject() && Smoothie::Meta::blittableTypes.IsExist( calcType ) ){
+        // Blittable型をオブジェクトとして扱う
+        vector<UserProc *> userProcs;
+        Smoothie::Meta::blittableTypes.GetClass( calcType ).EnumStaticMethod( "_Create", userProcs );
+        if( userProcs.size() != 1 ){
+            SetError();
+            return;
+        }
+        UserProc *pUserProc = userProcs[0];
+
+        // call System.[TypeClass]._Create
+        op_call( pUserProc );
+
+        // push eax
+        op_push( REG_EAX );
+
+        calcType = pUserProc->ReturnType();
+    }
+
 
     /////////////////////////////////

BasicCompiler32/Compile_Statement.cpp

@@ -90 +90 @@
     bool isLiteral;
     BOOL bUseHeap;
-    bool result = TermOpe( leftTerm, Type(), resultType, isLiteral, &bUseHeap, NULL, true );
-
+    bool result = TermOpe( leftTerm, Type(), resultType, isLiteral, &bUseHeap, false, NULL, true );
     if( result ){
 

BasicCompiler32/NumOpe.cpp

@@ -227 +227 @@
     return false;
 }
-bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool *pIsClassName, bool isProcedureCallOnly ){
+bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool isWantObject, bool *pIsClassName, bool isProcedureCallOnly ){
     char parameter[VN_SIZE];
 
@@ -255 +255 @@
         bool isClassName = false;
         Type leftType;
-        if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, &isClassName ) ){
+        if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
+            if( isClassName == false && Smoothie::Meta::blittableTypes.IsExist( leftType ) ){
+                // 左側のオブジェクト部分がBlittable型のとき
+
+                char temporary[VN_SIZE];
+                lstrcpy( temporary, termLeft );
+                sprintf( termLeft, "%s(%s)",
+                    Smoothie::Meta::blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
+                    temporary );
+            }
+        }
+
+        if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, true, &isClassName ) ){
             goto globalArea;
         }

BasicCompiler32/Opcode.h

@@ -102 +102 @@
 //NumOpe.cpp
 void PushReturnValue(int type);
-bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool *pIsClassName = NULL, bool isProcedureCallOnly = false );
+bool TermOpe(
+             const char *term,
+             const Type &baseType,
+             Type &resultType,
+             bool &isLiteral,
+             BOOL *pbUseHeap,
+             bool isWantObject = false,
+             bool *pIsClassName = NULL,
+             bool isProcedureCallOnly = false );
 bool NumOpe( int reg,
             const char *expression,

BasicCompiler64/BasicCompiler.vcproj

@@ -157 +157 @@
                 RuntimeLibrary="1"
                 UsePrecompiledHeader="0"
-                PrecompiledHeaderFile=".\Debug/BasicCompiler.pch"
-                AssemblerListingLocation=".\Debug/"
-                ObjectFile=".\Debug/"
-                ProgramDataBaseFileName=".\Debug/"
+                PrecompiledHeaderFile=".\SmallDebug/BasicCompiler.pch"
+                AssemblerListingLocation=".\SmallDebug/"
+                ObjectFile=".\SmallDebug/"
+                ProgramDataBaseFileName=".\SmallDebug/"
                 BrowseInformation="0"
                 WarningLevel="3"
@@ -188 +188 @@
                 IgnoreDefaultLibraryNames=""
                 GenerateDebugInformation="false"
-                ProgramDatabaseFile=".\Debug/BasicCompiler64.pdb"
+                ProgramDatabaseFile=".\SmallDebug/BasicCompiler64.pdb"
                 SubSystem="2"
                 TargetMachine="0"

BasicCompiler64/Compile_Calc.cpp

@@ -227 +227 @@
     }
 
+    if( varType.IsObject() && Smoothie::Meta::blittableTypes.IsExist( calcType ) ){
+        // Blittable型をオブジェクトとして扱う
+        vector<UserProc *> userProcs;
+        Smoothie::Meta::blittableTypes.GetClass( calcType ).EnumStaticMethod( "_Create", userProcs );
+        if( userProcs.size() != 1 ){
+            SetError();
+            return;
+        }
+        UserProc *pUserProc = userProcs[0];
+
+        // mov rcx, rax
+        op_mov_RR( REG_RCX, REG_RAX );
+
+        // call System.[TypeClass]._Create
+        op_call( pUserProc );
+
+        calcType = pUserProc->ReturnType();
+    }
 
     /////////////////////////////////

BasicCompiler64/Compile_Statement.cpp

@@ -94 +94 @@
     bool isLiteral;
     BOOL bUseHeap;
-    bool result = TermOpe( leftTerm, Type(), resultType, isLiteral, &bUseHeap, NULL, true );
+    bool result = TermOpe( leftTerm, Type(), resultType, isLiteral, &bUseHeap, false, NULL, true );
 
     delete pobj_reg;

BasicCompiler64/NumOpe.cpp

@@ -224 +224 @@
     return false;
 }
-bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool *pIsClassName, bool isProcedureCallOnly ){
+bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool isWantObject, bool *pIsClassName, bool isProcedureCallOnly ){
     char parameter[VN_SIZE];
 
@@ -252 +252 @@
         bool isClassName = false;
         Type leftType;
-        if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, &isClassName ) ){
+        if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
+            if( isClassName == false && Smoothie::Meta::blittableTypes.IsExist( leftType ) ){
+                // 左側のオブジェクト部分がBlittable型のとき
+
+                char temporary[VN_SIZE];
+                lstrcpy( temporary, termLeft );
+                sprintf( termLeft, "%s(%s)",
+                    Smoothie::Meta::blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
+                    temporary );
+            }
+        }
+
+        if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, true, &isClassName ) ){
             goto globalArea;
         }
@@ -705 +717 @@
                     //型名
                     if( Type::StringToType( term, resultType ) ){
+
+                        if( resultType.IsObject() ){
+                            if( resultType.GetClass().IsBlittableType() ){
+                                // Blittable型のときは基本型として扱う
+                                // ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
+                                if( UserProc::IsLocalAreaCompiling()
+                                    && UserProc::CompilingUserProc().HasParentClass()
+                                    && UserProc::CompilingUserProc().GetParentClass().IsBlittableType() )
+                                {
+                                    // コンパイル中のメソッドがBlittable型クラスに属している
+                                }
+                                else{
+                                    resultType = resultType.GetClass().GetBlittableType();
+                                }
+                            }
+                        }
+
                         resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
                     }

BasicCompiler64/Opcode.h

@@ -251 +251 @@
 
 //NumOpe.cpp
-bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool *pIsClassName = NULL, bool isProcedureCallOnly = false );
+bool TermOpe(
+             const char *term,
+             const Type &baseType,
+             Type &resultType,
+             bool &isLiteral,
+             BOOL *pbUseHeap,
+             bool isWantObject = false,
+             bool *pIsClassName = NULL,
+             bool isProcedureCallOnly = false );
 bool NumOpe( int *pReg,
            const char *Command,

BasicCompiler_Common/Class.cpp

@@ -911 +911 @@
     char temporary[VN_SIZE];
 
+    // Blittable型管理オブジェクトを初期化
+    Smoothie::Meta::blittableTypes.clear();
+
     // 名前空間管理
     NamespaceScopes &namespaceScopes = Smoothie::Lexical::liveingNamespaceScopes;
@@ -971 +974 @@
 
                 i+=2;
-                //アラインメント修飾子
+                Type blittableType;
                 if(memicmp(basbuf+i,"Align(",6)==0){
+                    //アラインメント修飾子
                     i+=6;
                     i=JumpStringInPare(basbuf,i)+1;
+                }
+                else if( memicmp( basbuf + i, "Blittable(", 10 ) == 0 ){
+                    // Blittable修飾子
+                    i+=10;
+                    i+=GetStringInPare_RemovePare(temporary,basbuf+i)+1;
+                    Type::StringToType( temporary, blittableType );
                 }
 
@@ -1013 +1023 @@
                     }
                 }
+
+                // Blittable型の場合
+                if( !blittableType.IsNull() ){
+                    pClass->SetBlittableType( blittableType );
+
+                    // Blittable型として登録
+                    Smoothie::Meta::blittableTypes.push_back( BlittableType( blittableType, pClass ) );
+                }
         }
     }
@@ -1344 +1362 @@
             i+=2;
 
-            //アラインメント修飾子
             int iAlign=0;
             if(memicmp(basbuf+i,"Align(",6)==0){
+                //アラインメント修飾子
                 i+=6;
                 i+=GetStringInPare_RemovePare(temporary,basbuf+i)+1;
@@ -1353 +1371 @@
                 if(!(iAlign==1||iAlign==2||iAlign==4||iAlign==8||iAlign==16))
                     SetError(51,NULL,i);
+            }
+            else if( memicmp( basbuf + i, "Blittable(", 10 ) == 0 ){
+                // Blittable修飾子
+                i+=10;
+                i=JumpStringInPare(basbuf,i)+1;
             }
 
@@ -1416 +1439 @@
                         goto InheritsError;
                     }
-                }
-                else if( memicmp( basbuf + i+1,"Blittable", 9 ) == 0 &&
-                    basbuf[i+10] == 1 && basbuf[i+11] == ESC_INHERITS ){
-                        // Blittable Inherits
-
-                        for(i+=12,i2=0;;i++,i2++){
-                            if(IsCommandDelimitation(basbuf[i])){
-                                temporary[i2]=0;
-                                break;
-                            }
-                            temporary[i2]=basbuf[i];
-                        }
-
-                        Type type;
-                        Type::StringToType( temporary, type );
-                        pobj_c->SetBlittableType( type );
-
                 }
 

BasicCompiler_Common/Class.h

@@ -130 +130 @@
     bool IsBlittableType() const
     {
-        return blittableType.IsNull();
+        return !blittableType.IsNull();
     }
     const Type &GetBlittableType() const

BasicCompiler_Common/Intermediate_Step2.cpp

@@ -418 +418 @@
                 if( Command[i2] == 1 && Command[i2+1] == ESC_ENUM ){
                     i2 += 2;
+                }
+                else if( memicmp( Command + i2, "Blittable(", 10 ) == 0 ){
+                    i2 += 10;
+                    i2 = JumpStringInPare(Command,i2)+1;
                 }
 

BasicCompiler_Common/NumOpe_GetType.cpp

@@ -294 +294 @@
 }
 
-bool GetTermType( const char *term, Type &resultType, bool &isLiteral, bool *pIsClassName = NULL ){
+bool GetTermType( const char *term, Type &resultType, bool &isLiteral, bool *pIsClassName ){
     char parameter[VN_SIZE];
 
@@ -322 +322 @@
         bool isClassName = false;
         Type leftType;
-        if( !GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
+        if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
+            if( isClassName == false && Smoothie::Meta::blittableTypes.IsExist( leftType ) ){
+                // 左側のオブジェクト部分がBlittable型のとき
+
+                char temporary[VN_SIZE];
+                lstrcpy( temporary, termLeft );
+                sprintf( termLeft, "%s(%s)",
+                    Smoothie::Meta::blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
+                    temporary );
+
+                if( !GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
+                    goto globalArea;
+                }
+            }
+        }
+        else{
             goto globalArea;
         }
@@ -615 +630 @@
                     //型名
                     if( Type::StringToType( term, resultType ) ){
+
+                        if( resultType.IsObject() ){
+                            if( resultType.GetClass().IsBlittableType() ){
+                                // Blittable型のときは基本型として扱う
+                                // ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
+                                if( UserProc::IsLocalAreaCompiling()
+                                    && UserProc::CompilingUserProc().HasParentClass()
+                                    && UserProc::CompilingUserProc().GetParentClass().IsBlittableType() )
+                                {
+                                    // コンパイル中のメソッドがBlittable型クラスに属している
+                                }
+                                else{
+                                    resultType = resultType.GetClass().GetBlittableType();
+                                }
+                            }
+                        }
+
                         resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
                     }
@@ -656 +688 @@
                     //////////////////
                     // 何らかの識別子
-
-                        if( strstr(term,"T.B")){
-                            int test=0;
-                        }
 
                     bool isLiteral = true;

BasicCompiler_Common/Procedure.cpp

@@ -105 +105 @@
         }
         else if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
+            // As指定
             i+=2;
 
@@ -131 +132 @@
                 SetError(3,temporary,nowLine);
                 type.SetBasicType( DEF_PTR_VOID );
+            }
+
+            if( type.IsObject() ){
+                if( type.GetClass().IsBlittableType() ){
+                    // Blittable型のときは基本型として扱う
+                    type = type.GetClass().GetBlittableType();
+                }
             }
         }

BasicCompiler_Common/Type.cpp

@@ -522 +522 @@
     return Type( DEF_OBJECT, *pobj_DBClass->GetStringClassPtr() );
 }
+
+const string BlittableType::GetCreateStaticMethodFullName() const
+{
+    return pClass->GetNamespaceScopes().ToString() + "." + pClass->GetName() + "._Create";
+}

BasicCompiler_Common/Type.h

@@ -130 +130 @@
     static bool StringToType( const string &typeName, Type &type );
 };
+
+class BlittableType
+{
+    Type basicType;
+    CClass *pClass;
+public:
+    BlittableType( const Type &basicType, CClass *pClass )
+        : basicType( basicType )
+        , pClass( pClass )
+    {
+    }
+    BlittableType(){}
+    const Type &GetBasicType() const
+    {
+        return basicType;
+    }
+    const CClass *GetClassPtr() const
+    {
+        return pClass;
+    }
+    const string GetCreateStaticMethodFullName() const;
+};
+class BlittableTypes : public vector<BlittableType>
+{
+public:
+    bool IsExist( Type type ) const
+    {
+        const BlittableTypes &blittableTypes = *this;
+        BOOST_FOREACH( const BlittableType &blittableType, blittableTypes ){
+            if( blittableType.GetBasicType().Equals( type ) ){
+                return true;
+            }
+        }
+        return false;
+    }
+    const BlittableType &Find( const Type &type ) const
+    {
+        const BlittableTypes &blittableTypes = *this;
+        BOOST_FOREACH( const BlittableType &blittableType, blittableTypes ){
+            if( blittableType.GetBasicType().Equals( type ) ){
+                return blittableType;
+            }
+        }
+        throw "Blittable型ではない";
+    }
+    const CClass *GetClassPtr( const Type &type ) const
+    {
+        const BlittableTypes &blittableTypes = *this;
+        BOOST_FOREACH( const BlittableType &blittableType, blittableTypes ){
+            if( blittableType.GetBasicType().Equals( type ) ){
+                return blittableType.GetClassPtr();
+            }
+        }
+        return NULL;
+    }
+    const CClass &GetClass( const Type &type ) const
+    {
+        return *GetClassPtr( type );
+    }
+};

BasicCompiler_Common/VariableOpe.cpp

@@ -1203 +1203 @@
     }
 
+    if( type.IsObject() ){
+        if( type.GetClass().IsBlittableType() ){
+            // Blittable型のときは基本型として扱う
+            // ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
+            if( UserProc::IsLocalAreaCompiling()
+                && UserProc::CompilingUserProc().HasParentClass()
+                && UserProc::CompilingUserProc().GetParentClass().IsBlittableType() )
+            {
+                // コンパイル中のメソッドがBlittable型クラスに属している
+            }
+            else{
+                type = type.GetClass().GetBlittableType();
+            }
+        }
+    }
+
     if(dwFlags&DIMFLAG_STATIC){
         if( UserProc::IsGlobalAreaCompiling() ){

BasicCompiler_Common/calculation.cpp

@@ -698 +698 @@
                             }
 
+                            if( tempType.IsObject() ){
+                                if( tempType.GetClass().IsBlittableType() ){
+                                    // Blittable型のときは基本型として扱う
+                                    tempType = tempType.GetClass().GetBlittableType();
+                                }
+                            }
+
                             type[pnum] = tempType.GetBasicType();
                             before_index[pnum] = tempType.GetIndex();

BasicCompiler_Common/common.h

@@ -47 +47 @@
 
 #ifdef _AMD64_
-#define VER_INFO        "(x64) β rev.248"
+#define VER_INFO        "(x64) β rev.255"
 #else
-#define VER_INFO        "β rev.248"
+#define VER_INFO        "β rev.255"
 #endif
 
@@ -439 +439 @@
 int AutoBigCast(int BaseType,int CalcType);
 BOOL CheckCalcType(int idCalc,int *type,int sp);
+bool GetTermType( const char *term, Type &resultType, bool &isLiteral, bool *pIsClassName = NULL );
 bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType );
 

BasicCompiler_Common/include/Smoothie.h

@@ -40 +40 @@
         static NamespaceScopesCollection namespaceScopesCollection;
         static NamespaceScopesCollection importedNamespaces;
+        static BlittableTypes blittableTypes;
     };
 

BasicCompiler_Common/src/Smoothie.cpp

@@ -23 +23 @@
 NamespaceScopesCollection Smoothie::Meta::namespaceScopesCollection;
 NamespaceScopesCollection Smoothie::Meta::importedNamespaces;
+BlittableTypes Smoothie::Meta::blittableTypes;
 
 bool Smoothie::isFullCompile = false;