Changeset 632 in dev for trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Class.cpp

Timestamp:

Jun 5, 2008, 10:04:39 PM (16 years ago)

Author:

dai_9181

Message:

ジェネリッククラスの型パラメータに値型が指定されたときに限り、テンプレート展開を行うようにした。

TODO: libファイルを跨ってテンプレート展開ができていないため、ソースコード管理部分に手を加える必要あり。

File:

• trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Class.cpp (modified) (3 diffs)

trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Class.cpp

@@ -287 +287 @@
     Subscripts subscripts;
     Type type;
-    GetDimentionFormat(buffer,VarName,subscripts,type,initBuffer,lpszConstructParameter);
+    if( !GetDimentionFormat(buffer,VarName,subscripts,type,initBuffer,lpszConstructParameter) )
+    {
+        return NULL;
+    }
 
     //重複チェック
@@ -1217 +1220 @@
                 extern int cp;
                 if(i3==0){
-                    if(bStatic){
-                        //静的メンバを追加
-                        cp=i;   //エラー用
-                        pobj_c->AddStaticMember(
-                            LexicalAnalyzer::CreateMember( *pobj_c, accessibility, isConst, false, temporary, i )
-                        );
-                    }
-                    else{
-                        //メンバを追加
-                        cp=i;   //エラー用
-                        pobj_c->AddDynamicMember(
-                            LexicalAnalyzer::CreateMember( *pobj_c, accessibility, isConst, false, temporary, i )
-                        );
-
-
-                        if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
-                            if( !pobj_c->GetDynamicMembers().back()->GetType().GetClass().IsReady() ){
-                                //参照先が読み取られていないとき
-                                GetClass_recur( pobj_c->GetDynamicMembers().back()->GetType().GetClass().GetName().c_str(), classes );
+                    cp=i;   //エラー用
+                    Member *pMember = LexicalAnalyzer::CreateMember( *pobj_c, accessibility, isConst, false, temporary, i );
+                    if( pMember )
+                    {
+                        if(bStatic)
+                        {
+                            //静的メンバを追加
+                            pobj_c->AddStaticMember( pMember );
+                        }
+                        else
+                        {
+                            //メンバを追加
+                            pobj_c->AddDynamicMember( pMember );
+
+
+                            if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
+                                if( !pobj_c->GetDynamicMembers().back()->GetType().GetClass().IsReady() ){
+                                    //参照先が読み取られていないとき
+                                    GetClass_recur( pobj_c->GetDynamicMembers().back()->GetType().GetClass().GetName().c_str(), classes );
+                                }
                             }
-                        }
-
-
-                        if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
-                            //循環参照のチェック
-                            pobj_LoopRefCheck->add(pobj_c->GetName().c_str());
-                            if(!MemberVar_LoopRefCheck(pobj_c->GetDynamicMembers().back()->GetType().GetClass())){
-                                //エラー回避
-                                Type &type = const_cast<Type &>(pobj_c->GetDynamicMembers().back()->GetType());
-                                type.SetBasicType( DEF_PTR_VOID );
+
+
+                            if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
+                                //循環参照のチェック
+                                pobj_LoopRefCheck->add(pobj_c->GetName().c_str());
+                                if(!MemberVar_LoopRefCheck(pobj_c->GetDynamicMembers().back()->GetType().GetClass())){
+                                    //エラー回避
+                                    Type &type = const_cast<Type &>(pobj_c->GetDynamicMembers().back()->GetType());
+                                    type.SetBasicType( DEF_PTR_VOID );
+                                }
+                                pobj_LoopRefCheck->del(pobj_c->GetName().c_str());
                             }
-                            pobj_LoopRefCheck->del(pobj_c->GetName().c_str());
                         }
                     }
@@ -1355 +1359 @@
     classes.Iterator_Init();
 }
+
+void LexicalAnalyzer::TemplateExpand_ResolveMethod( const CMethod *pBaseMethod, const Types &actualTypes, CClass *pNewClass )
+{
+    UserProc *pUserProc = new UserProc(
+        pBaseMethod->GetUserProc(),
+        pNewClass
+    );
+    pUserProc->Using();
+    pUserProc->GetParameters().clear();
+    pUserProc->RealParams().clear();
+
+    // パラメータのジェネリック型を解決
+    BOOST_FOREACH( const Parameter *pParam, pBaseMethod->GetUserProc().Params() )
+    {
+        Type type = pParam->IsTypeParameter()
+            ? actualTypes[pParam->GetFormalTypeIndex()]
+            : *pParam;
+        type.SetPtrLevel( pParam->PtrLevel() );
+
+        pUserProc->GetParameters().push_back( new Parameter( *pParam, type ) );
+    }
+    BOOST_FOREACH( const Parameter *pParam, pBaseMethod->GetUserProc().RealParams() )
+    {
+        Type type = pParam->IsTypeParameter()
+            ? actualTypes[pParam->GetFormalTypeIndex()]
+            : *pParam;
+        type.SetPtrLevel( pParam->PtrLevel() );
+
+        pUserProc->RealParams().push_back( new Parameter( *pParam, type ) );
+    }
+
+    // 戻り値のジェネリック型を解決
+    if( pUserProc->ReturnType().IsTypeParameter() )
+    {
+        Type type = actualTypes[pUserProc->ReturnType().GetFormalTypeIndex()];
+        type.SetPtrLevel( pUserProc->ReturnType().PtrLevel() );
+        pUserProc->SetReturnType( type );
+    }
+
+    compiler.GetObjectModule().meta.GetUserProcs().Put( pUserProc );
+    compiler.GetObjectModule().meta.GetUserProcs().Iterator_Init();
+
+    LexicalAnalyzer::AddMethod(
+        pNewClass,
+        pUserProc,
+        pBaseMethod->GetAccessibility(),
+        pBaseMethod->IsStatic(),
+        pBaseMethod->IsConst(),
+        pBaseMethod->IsAbstract(),
+        pBaseMethod->IsVirtual(),
+        false,
+        "",
+        false,
+        -1
+    );
+}
+
+const CClass *LexicalAnalyzer::TemplateExpand( CClass &_class, const Types &actualTypes )
+{
+    // 展開済みのクラスがあればそれを返す
+    BOOST_FOREACH( const ExpandedTemplateClass *pExpandedTemplateClass, _class.expandedTemplateClasses )
+    {
+        if( pExpandedTemplateClass->GetActualTypes().IsEquals( actualTypes ) )
+        {
+            return &pExpandedTemplateClass->GetClass();
+        }
+    }
+
+
+    /////////////////////////////////////////////////////////////////
+    // 未展開の場合は新たに展開する
+    /////////////////////////////////////////////////////////////////
+
+    // クラスをコピー
+    CClass *pNewClass = new CClass(
+        _class.GetNamespaceScopes(),
+        _class.GetImportedNamespaces(),
+        _class.GetName(),
+        _class.GetClassType(),
+        _class.GetFormalGenericTypes(),
+        actualTypes,
+        _class.GetConstructorMemberSubIndex(),
+        _class.GetDestructorMemberSubIndex(),
+        0,
+        _class.GetFixedAlignment()
+    );
+
+    // 基底クラス
+    pNewClass->SetSuperClass( &_class.GetSuperClass() );
+
+    // インターフェイスのジェネリック型を解決
+    BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
+    {
+        pNewClass->AddInterface( new ::Interface( &pInterface->GetClass(), actualTypes ) );
+    }
+
+    // メンバのジェネリック型を解決
+    BOOST_FOREACH( const Member *pMember, _class.GetDynamicMembers() )
+    {
+        Type type = pMember->GetType();
+        if( type.IsTypeParameter() )
+        {
+            // ジェネリック型だったときは値型に変換
+            type = actualTypes[type.GetFormalTypeIndex()];
+            type.SetPtrLevel( pMember->GetType().PtrLevel() );
+        }
+
+        pNewClass->GetDynamicMembers().push_back(
+            new Member( *pMember, type )
+        );
+    }
+
+    // クラス メソッドのジェネリック型を解決
+    BOOST_FOREACH( const CMethod *pMethod, _class.GetDynamicMethods() )
+    {
+        if( pMethod->GetUserProc().GetParentClassPtr() == &_class )
+        {
+            // ターゲットクラス内で実装されるメソッドの場合
+
+            TemplateExpand_ResolveMethod( pMethod, actualTypes, pNewClass );
+        }
+        else
+        {
+            DynamicMethod *pNewDynamicMethod = new DynamicMethod( *pMethod );
+            pNewClass->GetDynamicMethods().push_back( pNewDynamicMethod );
+        }
+    }
+
+    // インターフェイス メソッドのジェネリック型を解決
+    BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
+    {
+        BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() )
+        {
+            TemplateExpand_ResolveMethod( pMethod, actualTypes, pNewClass );
+        }
+    }
+
+    pNewClass->SetVtblNum( _class.GetVtblNum() );
+
+    // 展開済みクラスとして登録
+    _class.expandedTemplateClasses.push_back( new ExpandedTemplateClass( pNewClass, actualTypes ) );
+
+    pNewClass->Readed();
+
+    return pNewClass;
+}