Changeset 640 in dev for trunk

Timestamp:

Jun 14, 2008, 12:16:27 PM (16 years ago)

Author:

dai_9181

Message:

静的リンクリンカの依存関係解決モジュールを製作中

Location:

trunk/ab5.0/abdev

Files:

• ab_common/ab_common.vcproj (modified) (1 diff)
• ab_common/include/Lexical/Class.h (modified) (2 diffs)
• ab_common/include/Lexical/Const.h (modified) (6 diffs)
• ab_common/include/Lexical/DataTable.h (modified) (1 diff)
• ab_common/include/Lexical/Delegate.h (modified) (2 diffs)
• ab_common/include/Lexical/Interface.h (modified) (1 diff)
• ab_common/include/Lexical/Member.h (modified) (1 diff)
• ab_common/include/Lexical/Meta.h (modified) (1 diff)
• ab_common/include/Lexical/Method.h (modified) (3 diffs)
• ab_common/include/Lexical/NativeCode.h (modified) (2 diffs)
• ab_common/include/Lexical/ObjectModule.h (modified) (1 diff)
• ab_common/include/Lexical/Procedure.h (modified) (7 diffs)
• ab_common/include/Lexical/RelationalObjectModuleItem.h (modified) (1 diff)
• ab_common/include/Lexical/Resolver.h (added)
• ab_common/include/Lexical/Template.h (modified) (1 diff)
• ab_common/include/Lexical/Type.h (modified) (4 diffs)
• ab_common/include/Lexical/TypeDef.h (modified) (1 diff)
• ab_common/include/Lexical/Variable.h (modified) (1 diff)
• ab_common/include/ab_common.h (modified) (1 diff)
• ab_common/src/Lexical/Class.cpp (modified) (8 diffs)
• ab_common/src/Lexical/Const.cpp (modified) (2 diffs)
• ab_common/src/Lexical/DataTable.cpp (modified) (1 diff)
• ab_common/src/Lexical/Delegate.cpp (modified) (1 diff)
• ab_common/src/Lexical/Interface.cpp (modified) (4 diffs)
• ab_common/src/Lexical/Member.cpp (modified) (1 diff)
• ab_common/src/Lexical/Meta.cpp (modified) (10 diffs)
• ab_common/src/Lexical/Method.cpp (modified) (4 diffs)
• ab_common/src/Lexical/NativeCode.cpp (modified) (4 diffs)
• ab_common/src/Lexical/ObjectModule.cpp (modified) (2 diffs)
• ab_common/src/Lexical/Procedure.cpp (modified) (4 diffs)
• ab_common/src/Lexical/Template.cpp (modified) (1 diff)
• ab_common/src/Lexical/Type.cpp (modified) (4 diffs)
• ab_common/src/Lexical/TypeDef.cpp (modified) (1 diff)
• ab_common/src/Lexical/Variable.cpp (modified) (1 diff)
• abdev/src/MainFrame.cpp (modified) (1 diff)
• compiler_x86/MakePeHdr.cpp (modified) (1 diff)

trunk/ab5.0/abdev/ab_common/ab_common.vcproj

@@ -534 +534 @@
                 </File>
                 <File
+                    RelativePath=".\include\Lexical\Resolver.h"
+                    >
+                </File>
+                <File
                     RelativePath=".\include\Lexical\Source.h"
                     >

trunk/ab5.0/abdev/ab_common/include/Lexical/Class.h

@@ -147 +147 @@
         return false;
     }
+    bool Equals( const CClass *pClass ) const
+    {
+        // ポインタが等しいかどうかを見てみる
+        if( this == pClass )
+        {
+            return true;
+        }
+        else if( this->IsNeedResolve() || pClass->IsNeedResolve() )
+        {
+            // 依存関係解決前の状態であれば、パスが等しいかどうかを見てみる
+            if( this->IsDuplication( pClass ) )
+            {
+                return true;
+            }
+        }
+        return false;
+    }
 
     virtual void Using() const;
@@ -466 +483 @@
     void GetReferenceOffsetsInitializeBuffer( std::string &referenceOffsetsBuffer, int &numOfReference, int baseOffset = 0 ) const;
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 

trunk/ab5.0/abdev/ab_common/include/Lexical/Const.h

@@ -1 +1 @@
 #pragma once
 
-//定数
+//萔
 class CConst
     : public RelationalObjectModuleItem
@@ -9 +9 @@
     _int64 i64data;
 
-    // XMLシリアライズ用
+    // XMLVACYp
 private:
     friend class boost::serialization::access;
@@ -66 +66 @@
     double GetDoubleData();
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 class Consts : public Jenga::Common::Hashmap<CConst>
 {
-    // XMLシリアライズ用
+    // XMLVACYp
 private:
     friend class boost::serialization::access;
@@ -96 +96 @@
 };
 
-//定数マクロ
+//萔}N
 class ConstMacro
     : public RelationalObjectModuleItem
@@ -104 +104 @@
     std::string expression;
 
-    // XMLシリアライズ用
+    // XMLVACYp
 private:
     friend class boost::serialization::access;
@@ -154 +154 @@
     }
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 class ConstMacros
     : public Jenga::Common::Hashmap<ConstMacro>
 {
-    // XMLシリアライズ用
+    // XMLVACYp
 private:
     friend class boost::serialization::access;

trunk/ab5.0/abdev/ab_common/include/Lexical/DataTable.h

@@ -150 +150 @@
     void ResetDataSectionBaseOffset( long dataSectionBaseOffset );
 
-    void Resolve( const ObjectModule &resolver );
+    void Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };

trunk/ab5.0/abdev/ab_common/include/Lexical/Delegate.h

@@ -33 +33 @@
 
         ar & BOOST_SERIALIZATION_NVP( importedNamespaces );
+        ar & BOOST_SERIALIZATION_NVP( paramStr );
+        ar & BOOST_SERIALIZATION_NVP( returnTypeName );
+        ar & BOOST_SERIALIZATION_NVP( sourceIndex );
         ar & BOOST_SERIALIZATION_NVP( dynamicParams );
     }
@@ -92 +95 @@
     bool IsSimilar( const Delegate &dgt ) const;
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 typedef Jenga::Common::Hashmap<Delegate> Delegates;

trunk/ab5.0/abdev/ab_common/include/Lexical/Interface.h

@@ -90 +90 @@
     }
 
+    bool Equals( const Interface *pInterface ) const;
+
     std::string GetFullNameWithActualGenericTypeParameters() const;
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 typedef std::vector<Interface *> Interfaces;

trunk/ab5.0/abdev/ab_common/include/Lexical/Member.h

@@ -77 +77 @@
     }
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 typedef std::vector<Member *> Members;

trunk/ab5.0/abdev/ab_common/include/Lexical/Meta.h

@@ -162 +162 @@
     const CClass *FindClassSupportedTypeDef( const Symbol &symbol );
 
-    void Resolve( const ObjectModule &resolver );
+    void Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };

trunk/ab5.0/abdev/ab_common/include/Lexical/Method.h

@@ -49 +49 @@
     virtual void SetNotUseMark( bool isNotUse ) = 0;
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 
@@ -159 +159 @@
     }
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 BOOST_CLASS_EXPORT( DynamicMethod );
@@ -235 +235 @@
     }
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 BOOST_CLASS_EXPORT( StaticMethod );

trunk/ab5.0/abdev/ab_common/include/Lexical/NativeCode.h

@@ -117 +117 @@
     const ::CClass &GetClass() const;
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 typedef std::vector<Schedule> Schedules;
@@ -249 +249 @@
     void ResetRelationalObjectModuleIndex( const std::vector<int> &relationTable );
 
-    void Resolve( const ObjectModule &resolver );
+    void Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };

trunk/ab5.0/abdev/ab_common/include/Lexical/ObjectModule.h

@@ -65 +65 @@
 
     // 依存関係の解決を行う
-    void Resolve();
+    void Resolve( ResolveErrors &resolveErrors );
 
     // 下記の関連になるようなテーブルを取得する

trunk/ab5.0/abdev/ab_common/include/Lexical/Procedure.h

@@ -111 +111 @@
     }
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 
@@ -161 +161 @@
         ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Procedure );
         ar & boost::serialization::make_nvp("pParentClass", const_cast<CClass *&>(pParentClass) );
+        ar & boost::serialization::make_nvp("pInterface", const_cast<Interface *&>(pInterface) );
 
         if( ActiveBasic::Common::Environment::IsRemoveExternal() )
@@ -173 +174 @@
         ar & BOOST_SERIALIZATION_NVP( _paramStr );
         ar & BOOST_SERIALIZATION_NVP( importedNamespaces );
-        ar & boost::serialization::make_nvp("pInterface", const_cast<Interface *&>(pInterface) );
         ar & BOOST_SERIALIZATION_NVP( pMethod );
         ar & BOOST_SERIALIZATION_NVP( isMacro );
@@ -209 +209 @@
     virtual bool IsDuplication( const UserProc *pUserProc ) const
     {
-        if( this->GetParentClassPtr() == pUserProc->GetParentClassPtr() // 親クラスが等しい
-            && this->pInterface == pUserProc->pInterface                // インターフェイスが等しい
-            && pUserProc->IsEqualSymbol( *this )                        // 名前空間及び名前が等しい
-            && this->Params().Equals( pUserProc->Params() )             // パラメータが等しい
-            && this->returnType.Equals( pUserProc->returnType ) )       // 戻り値が等しい
+        bool isEqualParentClass =
+            this->HasParentClass() && pUserProc->HasParentClass()
+            ? this->GetParentClassPtr()->Equals( pUserProc->GetParentClassPtr() )
+            : this->GetParentClassPtr() == pUserProc->GetParentClassPtr();
+        bool isEqualInterface =
+            this->pInterface && pUserProc->pInterface
+            ? this->pInterface->Equals( pUserProc->pInterface )
+            : this->pInterface == pUserProc->pInterface;
+
+        if( isEqualParentClass                                      // 親クラスが等しい
+            && isEqualInterface                                     // インターフェイスが等しい
+            && pUserProc->IsEqualSymbol( *this )                    // 名前空間及び名前が等しい
+            && this->Params().Equals( pUserProc->Params() )         // パラメータが等しい
+            && this->returnType.Equals( pUserProc->returnType ) )   // 戻り値が等しい
         {
             return true;
@@ -376 +385 @@
     const CMethod &GetMethod() const;
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 
     static const UserProc *pGlobalProc;
@@ -484 +493 @@
     }
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 class DllProcs : public Jenga::Common::Hashmap<DllProc>
@@ -525 +534 @@
     }
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 

trunk/ab5.0/abdev/ab_common/include/Lexical/RelationalObjectModuleItem.h

@@ -68 +68 @@
     }
 
-    virtual bool Resolve( const ObjectModule &resolver ) = 0;
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors ) = 0;
 };
 

trunk/ab5.0/abdev/ab_common/include/Lexical/Template.h

@@ -47 +47 @@
     }
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 

trunk/ab5.0/abdev/ab_common/include/Lexical/Type.h

@@ -230 +230 @@
     std::string ToString() const;
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 
 
@@ -311 +311 @@
 {
     Type basicType;
-    CClass *pClass;
+    const CClass *pClass;
 
     // XMLシリアライズ用
@@ -321 +321 @@
 
         ar & BOOST_SERIALIZATION_NVP( basicType );
-        ar & BOOST_SERIALIZATION_NVP( pClass );
-    }
-
-public:
-    BlittableType( const Type &basicType, CClass *pClass )
+        ar & boost::serialization::make_nvp("pClass", const_cast<CClass *&>(pClass) );
+    }
+
+public:
+    BlittableType( const Type &basicType, const CClass *pClass )
         : basicType( basicType )
         , pClass( pClass )
@@ -342 +342 @@
     }
     const std::string GetCreateStaticMethodFullName() const;
+
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 class BlittableTypes : public std::vector<BlittableType>

trunk/ab5.0/abdev/ab_common/include/Lexical/TypeDef.h

@@ -51 +51 @@
     }
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
 

trunk/ab5.0/abdev/ab_common/include/Lexical/Variable.h

@@ -175 +175 @@
     }
 
-    virtual bool Resolve( const ObjectModule &resolver );
+    virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 
 

trunk/ab5.0/abdev/ab_common/include/ab_common.h

@@ -8 +8 @@
 #include "Lexical/NamespaceSupporter.h"
 #include "Lexical/Symbol.h"
+#include "Lexical/Resolver.h"
 #include "Lexical/RelationalObjectModuleItem.h"
 #include "Lexical/Prototype.h"

trunk/ab5.0/abdev/ab_common/src/Lexical/Class.cpp

@@ -869 +869 @@
 }
 
-bool CClass::Resolve( const ObjectModule &resolver )
+bool CClass::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
     // 型パラメータ
     BOOST_FOREACH( GenericType &genericType, formalGenericTypes )
     {
-        genericType.GetType().Resolve( resolver );
+        genericType.GetType().Resolve( resolver, resolveErrors );
     }
 
@@ -882 +882 @@
         if( this->pSuperClass->IsNeedResolve() )
         {
-            this->pSuperClass = resolver.meta.GetClasses().FindEx( *pSuperClass );
+            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pSuperClass );
+            if( pTempClass )
+            {
+                this->pSuperClass = pTempClass;
+            }
+            else
+            {
+                resolveErrors.Add( ResolveError( this->pSuperClass->GetRelationalObjectModuleIndex(), this->pSuperClass->GetFullName() ) );
+            }
         }
     }
@@ -889 +897 @@
     BOOST_FOREACH( Type &superClassActualTypeParameter, superClassActualTypeParameters )
     {
-        superClassActualTypeParameter.Resolve( resolver );
+        superClassActualTypeParameter.Resolve( resolver, resolveErrors );
     }
 
     // Blittable型情報
-    blittableType.Resolve( resolver );
+    blittableType.Resolve( resolver, resolveErrors );
 
     // 実装するインターフェイス
     BOOST_FOREACH( ::Interface *pInterface, interfaces )
     {
-        pInterface->Resolve( resolver );
+        pInterface->Resolve( resolver, resolveErrors );
     }
 
@@ -904 +912 @@
     BOOST_FOREACH( Member *pMember, dynamicMembers )
     {
-        pMember->Resolve( resolver );
+        pMember->Resolve( resolver, resolveErrors );
     }
 
@@ -910 +918 @@
     BOOST_FOREACH( Member *pMember, staticMembers )
     {
-        pMember->Resolve( resolver );
+        pMember->Resolve( resolver, resolveErrors );
     }
 
@@ -916 +924 @@
     BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
     {
-        pMethod->Resolve( resolver );
+        pMethod->Resolve( resolver, resolveErrors );
     }
 
@@ -922 +930 @@
     BOOST_FOREACH( CMethod *pMethod, staticMethods )
     {
-        pMethod->Resolve( resolver );
+        pMethod->Resolve( resolver, resolveErrors );
     }
 
@@ -928 +936 @@
     BOOST_FOREACH( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, expandedTemplateClasses )
     {
-        pExpandedTemplateClass->Resolve( resolver );
+        pExpandedTemplateClass->Resolve( resolver, resolveErrors );
     }
 

trunk/ab5.0/abdev/ab_common/src/Lexical/Const.cpp

@@ -7 +7 @@
 }
 
-bool CConst::Resolve( const ObjectModule &resolver )
+bool CConst::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-    type.Resolve( resolver );
+    type.Resolve( resolver, resolveErrors );
     return true;
 }
@@ -78 +78 @@
 }
 
-bool ConstMacro::Resolve( const ObjectModule &resolver )
+bool ConstMacro::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
     // 依存関係を解決すべきメンバは無い

trunk/ab5.0/abdev/ab_common/src/Lexical/DataTable.cpp

@@ -78 +78 @@
 }
 
-void DataTable::Resolve( const ObjectModule &resolver )
+void DataTable::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
     BOOST_FOREACH( Schedule &schedule, schedules )
     {
-        schedule.Resolve( resolver );
+        schedule.Resolve( resolver, resolveErrors );
     }
 }

trunk/ab5.0/abdev/ab_common/src/Lexical/Delegate.cpp

@@ -19 +19 @@
 }
 
-bool Delegate::Resolve( const ObjectModule &resolver )
+bool Delegate::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-    Procedure::Resolve( resolver );
+    Procedure::Resolve( resolver, resolveErrors );
 
     BOOST_FOREACH( Parameter *pParameter, dynamicParams )
     {
-        pParameter->Resolve( resolver );
+        pParameter->Resolve( resolver, resolveErrors );
     }
 

trunk/ab5.0/abdev/ab_common/src/Lexical/Interface.cpp

@@ -33 +33 @@
 }
 
+bool Interface::Equals( const Interface *pInterface ) const
+{
+    // ポインタが等しいかどうかを見てみる
+    if( this == pInterface )
+    {
+        return true;
+    }
+    else if( this->pInterfaceClass->IsNeedResolve() || pInterface->pInterfaceClass->IsNeedResolve() )
+    {
+        // 依存関係解決前の状態であれば、パスが等しいかどうかを見てみる
+        if( this-pInterfaceClass->IsDuplication( pInterface->pInterfaceClass ) )
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
 std::string Interface::GetFullNameWithActualGenericTypeParameters() const
 {
@@ -53 +71 @@
 }
 
-bool Interface::Resolve( const ObjectModule &resolver )
+bool Interface::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
     // 動的メソッド
     BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
     {
-        pMethod->Resolve( resolver );
+        pMethod->Resolve( resolver, resolveErrors );
     }
 
@@ -66 +84 @@
         if( this->pInterfaceClass->IsNeedResolve() )
         {
-            this->pInterfaceClass = resolver.meta.GetClasses().FindLike( pInterfaceClass );
+            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pInterfaceClass );
+            if( pTempClass )
+            {
+                this->pInterfaceClass = pTempClass;
+            }
+            else
+            {
+                resolveErrors.Add( ResolveError( this->pInterfaceClass->GetRelationalObjectModuleIndex(), this->pInterfaceClass->GetFullName() ) );
+            }
         }
     }
@@ -72 +98 @@
     BOOST_FOREACH( Type &actualTypeParameter, actualTypeParameters )
     {
-        actualTypeParameter.Resolve( resolver );
+        actualTypeParameter.Resolve( resolver, resolveErrors );
     }
 

trunk/ab5.0/abdev/ab_common/src/Lexical/Member.cpp

@@ -41 +41 @@
 }
 
-bool Member::Resolve( const ObjectModule &resolver )
+bool Member::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-    type.Resolve( resolver );
+    type.Resolve( resolver, resolveErrors );
     return true;
 }

trunk/ab5.0/abdev/ab_common/src/Lexical/Meta.cpp

@@ -253 +253 @@
 }
 
-void Meta::Resolve( const ObjectModule &resolver )
+void Meta::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
     // 関数・メソッド
@@ -261 +261 @@
     {
         UserProc *pUserProc = this->GetUserProcs().Iterator_GetNext();
-        pUserProc->Resolve( resolver );
+        pUserProc->Resolve( resolver, resolveErrors );
     }
 
@@ -270 +270 @@
     {
         DllProc *pDllProc = this->GetDllProcs().Iterator_GetNext();
-        pDllProc->Resolve( resolver );
+        pDllProc->Resolve( resolver, resolveErrors );
     }
 
@@ -279 +279 @@
     {
         CClass *pClass = this->GetClasses().Iterator_GetNext();
-        pClass->Resolve( resolver );
+        pClass->Resolve( resolver, resolveErrors );
     }
 
@@ -285 +285 @@
     BOOST_FOREACH( Variable *pVar, globalVars )
     {
-        pVar->Resolve( resolver );
+        pVar->Resolve( resolver, resolveErrors );
     }
 
@@ -294 +294 @@
     {
         CConst *pConst = this->GetGlobalConsts().Iterator_GetNext();
-        pConst->Resolve( resolver );
+        pConst->Resolve( resolver, resolveErrors );
     }
 
@@ -303 +303 @@
     {
         ConstMacro *pConstMacro = this->GetGlobalConstMacros().Iterator_GetNext();
-        pConstMacro->Resolve( resolver );
+        pConstMacro->Resolve( resolver, resolveErrors );
+    }
+
+    // blittable型
+    BOOST_FOREACH( BlittableType &blittableType, blittableTypes )
+    {
+        blittableType.Resolve( resolver, resolveErrors );
     }
 
@@ -309 +315 @@
     BOOST_FOREACH( TypeDef &typeDef, typeDefs )
     {
-        typeDef.Resolve( resolver );
+        typeDef.Resolve( resolver, resolveErrors );
     }
 
@@ -315 +321 @@
     BOOST_FOREACH( ProcPointer *pProcPointer, procPointers )
     {
-        pProcPointer->Resolve( resolver );
+        pProcPointer->Resolve( resolver, resolveErrors );
     }
 
@@ -324 +330 @@
     {
         Delegate *pDelegate = this->GetDelegates().Iterator_GetNext();
-        pDelegate->Resolve( resolver );
-    }
-}
+        pDelegate->Resolve( resolver, resolveErrors );
+    }
+}

trunk/ab5.0/abdev/ab_common/src/Lexical/Method.cpp

@@ -1 +1 @@
 #include "stdafx.h"
 
-bool CMethod::Resolve( const ObjectModule &resolver )
+bool CMethod::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-    if( pUserProc )
+    if( this->pUserProc )
     {
-        if( pUserProc->IsNeedResolve() )
+        if( this->pUserProc->IsNeedResolve() )
         {
-            pUserProc = resolver.meta.GetUserProcs().FindLike( pUserProc );
+            const UserProc *pTempUserProc = resolver.meta.GetUserProcs().FindLike( this->pUserProc );
+            if( pTempUserProc )
+            {
+                this->pUserProc = pTempUserProc;
+            }
+            else
+            {
+                resolveErrors.Add( ResolveError( this->pUserProc->GetRelationalObjectModuleIndex(), this->pUserProc->GetFullName() ) );
+            }
         }
     }
@@ -41 +49 @@
 }
 
-bool DynamicMethod::Resolve( const ObjectModule &resolver )
+bool DynamicMethod::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-    CMethod::Resolve( resolver );
+    CMethod::Resolve( resolver, resolveErrors );
 
     if( this->pInheritsClass )
@@ -49 +57 @@
         if( this->pInheritsClass->IsNeedResolve() )
         {
-            this->pInheritsClass = resolver.meta.GetClasses().FindLike( pInheritsClass );
+            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( pInheritsClass );
+            if( pTempClass )
+            {
+                this->pInheritsClass = pTempClass;
+            }
+            else
+            {
+                resolveErrors.Add( ResolveError( this->pInheritsClass->GetRelationalObjectModuleIndex(), this->pInheritsClass->GetFullName() ) );
+            }
         }
     }
@@ -62 +78 @@
 }
 
-bool StaticMethod::Resolve( const ObjectModule &resolver )
+bool StaticMethod::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-    CMethod::Resolve( resolver );
+    CMethod::Resolve( resolver, resolveErrors );
     return true;
 }

trunk/ab5.0/abdev/ab_common/src/Lexical/NativeCode.cpp

@@ -19 +19 @@
 }
 
-bool Schedule::Resolve( const ObjectModule &resolver )
+bool Schedule::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
     switch( type )
@@ -26 +26 @@
     case AddressOf:
     case CatchAddress:
-        if( pUserProc->IsNeedResolve() )
-        {
-            pUserProc = resolver.meta.GetUserProcs().FindLike( pUserProc );
+        if( this->pUserProc->IsNeedResolve() )
+        {
+            const ::UserProc *pTempUserProc = resolver.meta.GetUserProcs().FindLike( this->pUserProc );
+            if( pTempUserProc )
+            {
+                this->pUserProc = pTempUserProc;
+            }
+            else
+            {
+                resolveErrors.Add( ResolveError( this->pUserProc->GetRelationalObjectModuleIndex(), this->pUserProc->GetFullName() ) );
+            }
         }
         break;
     case DllProc:
-        if( pDllProc->IsNeedResolve() )
-        {
-            pDllProc = resolver.meta.GetDllProcs().FindLike( pDllProc );
+        if( this->pDllProc->IsNeedResolve() )
+        {
+            const ::DllProc *pTempDllProc = resolver.meta.GetDllProcs().FindLike( this->pDllProc );
+            if( pTempDllProc )
+            {
+                this->pDllProc = pTempDllProc;
+            }
+            else
+            {
+                resolveErrors.Add( ResolveError( this->pDllProc->GetRelationalObjectModuleIndex(), this->pDllProc->GetFullName() ) );
+            }
         }
         break;
@@ -40 +56 @@
     case Vtbl:
     case TypeInfo:
-        if( pClass->IsNeedResolve() )
-        {
-            pClass = resolver.meta.GetClasses().FindLike( pClass );
+        if( this->pClass->IsNeedResolve() )
+        {
+            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pClass );
+            if( pTempClass )
+            {
+                this->pClass = pTempClass;
+            }
+            else
+            {
+                resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
+            }
         }
         break;
@@ -191 +215 @@
 }
 
-void NativeCode::Resolve( const ObjectModule &resolver )
+void NativeCode::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
     BOOST_FOREACH( Schedule &schedule, schedules )
     {
-        schedule.Resolve( resolver );
-    }
-}
+        schedule.Resolve( resolver, resolveErrors );
+    }
+}

trunk/ab5.0/abdev/ab_common/src/Lexical/ObjectModule.cpp

@@ -77 +77 @@
     }
 
-    // 依存関係を解決
-    this->Resolve();
-
     // TODO: basbufがいらなくなったら消す
     extern char *basbuf;
@@ -85 +82 @@
 }
 
-void ObjectModule::Resolve()
-{
-    this->meta.Resolve( *this );
+void ObjectModule::Resolve( ResolveErrors &resolveErrors )
+{
+    this->meta.Resolve( *this, resolveErrors );
 
     // グローバルネイティブコードを解決（スケジュールを解決する）
-    this->globalNativeCode.Resolve( *this );
+    this->globalNativeCode.Resolve( *this, resolveErrors );
 
     // データテーブルを解決（スケジュールを解決する）
-    this->dataTable.Resolve( *this );
+    this->dataTable.Resolve( *this, resolveErrors );
 }
 

trunk/ab5.0/abdev/ab_common/src/Lexical/Procedure.cpp

@@ -12 +12 @@
 }
 
-bool Procedure::Resolve( const ObjectModule &resolver )
+bool Procedure::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
     BOOST_FOREACH( Parameter *pParameter, params )
     {
-        pParameter->Resolve( resolver );
-    }
-
-    returnType.Resolve( resolver );
+        pParameter->Resolve( resolver, resolveErrors );
+    }
+
+    returnType.Resolve( resolver, resolveErrors );
 
     return true;
@@ -170 +170 @@
 }
 
-bool UserProc::Resolve( const ObjectModule &resolver )
-{
-    Procedure::Resolve( resolver );
-
-    if( pParentClass )
-    {
-        if( pParentClass->IsNeedResolve() )
-        {
-            pParentClass = resolver.meta.GetClasses().FindLike( pParentClass );
+bool UserProc::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
+{
+    Procedure::Resolve( resolver, resolveErrors );
+
+    if( this->pParentClass )
+    {
+        if( this->pParentClass->IsNeedResolve() )
+        {
+            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pParentClass );
+            if( pTempClass )
+            {
+                this->pParentClass = pTempClass;
+            }
+            else
+            {
+                resolveErrors.Add( ResolveError( this->pParentClass->GetRelationalObjectModuleIndex(), this->pParentClass->GetFullName() ) );
+            }
         }
     }
@@ -184 +192 @@
     if( pInterface )
     {
-        const_cast<Interface *>(pInterface)->Resolve( resolver );
+        const_cast<Interface *>(pInterface)->Resolve( resolver, resolveErrors );
     }
 
     if( pMethod )
     {
-        pMethod->Resolve( resolver );
+        pMethod->Resolve( resolver, resolveErrors );
     }
 
     BOOST_FOREACH( Parameter *pParameter, realParams )
     {
-        pParameter->Resolve( resolver );
+        pParameter->Resolve( resolver, resolveErrors );
     }
 
     BOOST_FOREACH( Variable *pLocalVar, localVars )
     {
-        pLocalVar->Resolve( resolver );
-    }
-
-    nativeCode.Resolve( resolver );
+        pLocalVar->Resolve( resolver, resolveErrors );
+    }
+
+    nativeCode.Resolve( resolver, resolveErrors );
     return true;
 }
@@ -228 +236 @@
 }
 
-bool DllProc::Resolve( const ObjectModule &resolver )
-{
-    Procedure::Resolve( resolver );
-    return true;
-}
-
-bool ProcPointer::Resolve( const ObjectModule &resolver )
-{
-    Procedure::Resolve( resolver );
+bool DllProc::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
+{
+    Procedure::Resolve( resolver, resolveErrors );
+    return true;
+}
+
+bool ProcPointer::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
+{
+    Procedure::Resolve( resolver, resolveErrors );
     return true;
 }

trunk/ab5.0/abdev/ab_common/src/Lexical/Template.cpp

@@ -9 +9 @@
 }
 
-bool ExpandedTemplateClass::Resolve( const ObjectModule &resolver )
+bool ExpandedTemplateClass::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
     if( pClass->IsNeedResolve() )
     {
-        pClass = const_cast<CClass *>(resolver.meta.GetClasses().FindLike( pClass ));
+        CClass *pTempClass = const_cast<CClass *>(resolver.meta.GetClasses().FindLike( pClass ));
+        if( pTempClass )
+        {
+            this->pClass = pTempClass;
+        }
+        else
+        {
+            resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
+        }
     }
 
     BOOST_FOREACH( Type &actualType, actualTypes )
     {
-        actualType.Resolve( resolver );
+        actualType.Resolve( resolver, resolveErrors );
     }
 

trunk/ab5.0/abdev/ab_common/src/Lexical/Type.cpp

@@ -129 +129 @@
 bool Type::Equals( const Type &type ) const
 {
-    if( basicType == type.basicType ){
-        if( NATURAL_TYPE( basicType ) == DEF_OBJECT
-            || NATURAL_TYPE( basicType ) == DEF_STRUCT ){
-
-                if( index == type.index ){
+    if( basicType == type.basicType )
+    {
+        if( NATURAL_TYPE( basicType ) == DEF_OBJECT || NATURAL_TYPE( basicType ) == DEF_STRUCT )
+        {
+            // ポインタが等しいかどうかを見てみる
+            if( this->pClass == type.pClass )
+            {
+                return true;
+            }
+            else if( this->pClass->IsNeedResolve() || type.pClass->IsNeedResolve() )
+            {
+                // 依存関係解決前の状態であれば、パスが等しいかどうかを見てみる
+                if( this->pClass->IsDuplication( type.pClass ) )
+                {
                     return true;
                 }
-
-        }
-        else{
+            }
+        }
+        else
+        {
             return true;
         }
@@ -556 +566 @@
 }
 
-bool Type::Resolve( const ObjectModule &resolver )
+bool Type::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
     if( this->HasMember() )
@@ -562 +572 @@
         if( this->pClass->IsNeedResolve() )
         {
-            this->pClass = resolver.meta.GetClasses().FindLike( this->pClass );
+            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pClass );
+            if( pTempClass )
+            {
+                this->pClass = pTempClass;
+            }
+            else
+            {
+                resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
+            }
         }
 
         BOOST_FOREACH( GenericType &actualGenericType, actualGenericTypes )
         {
-            actualGenericType.GetType().Resolve( resolver );
+            actualGenericType.GetType().Resolve( resolver, resolveErrors );
         }
     }
@@ -655 +673 @@
     return pClass->GetNamespaceScopes().ToString() + "." + pClass->GetName() + "._Create";
 }
+
+bool BlittableType::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
+{
+    basicType.Resolve( resolver, resolveErrors );
+
+    if( this->pClass->IsNeedResolve() )
+    {
+        const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pClass );
+        if( pTempClass )
+        {
+            this->pClass = pTempClass;
+        }
+        else
+        {
+            resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
+        }
+    }
+
+    return true;
+}

trunk/ab5.0/abdev/ab_common/src/Lexical/TypeDef.cpp

@@ -8 +8 @@
 }
 
-bool TypeDef::Resolve( const ObjectModule &resolver )
+bool TypeDef::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-    this->baseType.Resolve( resolver );
+    this->baseType.Resolve( resolver, resolveErrors );
     return true;
 }

trunk/ab5.0/abdev/ab_common/src/Lexical/Variable.cpp

@@ -28 +28 @@
 }
 
-bool Variable::Resolve( const ObjectModule &resolver )
+bool Variable::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
 {
-    this->type.Resolve( resolver );
+    this->type.Resolve( resolver, resolveErrors );
     return true;
 }

trunk/ab5.0/abdev/abdev/src/MainFrame.cpp

@@ -1374 +1374 @@
             hChild=hCompileView;
             hCompileView=(HWND)-1;
-            SendMessage(hChild,WM_COMMAND,IDCANCEL,0);
+            if( ::IsWindow( hChild ) )
+            {
+                SendMessage(hChild,WM_COMMAND,IDCANCEL,0);
+            }
         }
 

trunk/ab5.0/abdev/compiler_x86/MakePeHdr.cpp

@@ -122 +122 @@
     compiler.PreStaticLink( compiler.staticLibraries );
     compiler.StaticLink( compiler.staticLibraries );
+
+    // 依存関係の解決
+    ActiveBasic::Common::Lexical::ResolveErrors resolveErrors;
+    compiler.GetObjectModule().Resolve( resolveErrors );
+    BOOST_FOREACH( const ResolveError &resolveError, resolveErrors )
+    {
+        compiler.errorMessenger.Output( ErrorInfo( 13, resolveError.GetTargetItemName(), -1 ) );
+    }