source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/Class.cpp @ 540

Last change on this file since 540 was 540, checked in by dai_9181, 15 years ago

StartCompileメソッドを廃止し、Usingメソッドのオーバーロードに差し替えた。
File size: 31.6 KB
Line 
1#include "stdafx.h"
2
3#include <Source.h>
4#include <Class.h>
5#include <Compiler.h>
6
7#include "../common.h"
8#ifdef _AMD64_
9#include "../../compiler_x64/opcode.h"
10#else
11#include "../../compiler_x86/opcode.h"
12#endif
13
14using namespace ActiveBasic::Compiler;
15
16void CClass::Using() const
17{
18    if( this->IsUsing() )
19    {
20        // 既に使用することになっている
21        return;
22    }
23
24    Prototype::Using();
25
26    // 仮想関数になるメソッドに使用チェックをつける
27    const CClass &objThis = *this;
28    BOOST_FOREACH( const CMethod *pMethod, objThis.GetDynamicMethods() )
29    {
30        if( pMethod->IsVirtual() )
31        {
32            pMethod->GetUserProc().Using();
33        }
34    }
35}
36
37bool CClass::IsClass() const
38{
39    return classType == CClass::Class;
40}
41bool CClass::IsInterface() const
42{
43    return classType == CClass::Interface;
44}
45bool CClass::IsComInterface() const
46{
47    return classType == CClass::ComInterface;
48}
49bool CClass::IsEnum() const
50{
51    return classType == CClass::Enum;
52}
53bool CClass::IsDelegate() const
54{
55    return classType == CClass::Delegate;
56}
57bool CClass::IsStructure() const
58{
59    return classType == CClass::Structure;
60}
61
62
63// コンストラクタのコンパイルを開始
64void CClass::NotifyStartConstructorCompile() const
65{
66    isCompilingConstructor = true;
67}
68
69//コンストラクタのコンパイルを終了
70void CClass::NotifyFinishConstructorCompile() const
71{
72    isCompilingConstructor = false;
73}
74
75//コンストラクタをコンパイル中かどうかを判別
76bool CClass::IsCompilingConstructor() const
77{
78    return isCompilingConstructor;
79}
80
81//デストラクタのコンパイルを開始
82void CClass::NotifyStartDestructorCompile() const{
83    isCompilingDestructor = true;
84}
85
86//デストラクタのコンパイルを終了
87void CClass::NotifyFinishDestructorCompile() const{
88    isCompilingDestructor = false;
89}
90
91//デストラクタをコンパイル中かどうかを判別
92bool CClass::IsCompilingDestructor() const
93{
94    return isCompilingDestructor;
95}
96
97//自身の派生クラスかどうかを確認
98bool CClass::IsSubClass( const CClass *pSubClass ) const
99{
100    if( !pSubClass->HasSuperClass() )
101    {
102        return false;
103    }
104
105    const CClass *pTempClass = &pSubClass->GetSuperClass();
106    while( pTempClass ){
107        if( this == pTempClass ) return true;
108        pTempClass = &pTempClass->GetSuperClass();
109    }
110    return false;
111}
112
113//自身と等しいまたは派生クラスかどうかを確認
114bool CClass::IsEqualsOrSubClass( const CClass *pSubClass ) const
115{
116    if( IsEquals( pSubClass ) ) return true;
117    return IsSubClass( pSubClass );
118}
119
120// 自身と等しいまたは派生クラス、基底クラスかどうかを確認
121bool CClass::IsEqualsOrSubClassOrSuperClass( const CClass &objClass ) const
122{
123    if( IsEquals( &objClass ) ) return true;
124    if( IsSubClass( &objClass ) ) return true;
125    if( objClass.IsSubClass( this ) ) return true;
126    return false;
127}
128
129bool CClass::IsInheritsInterface( const CClass *pInterfaceClass ) const
130{
131    BOOST_FOREACH( const ::Interface *pInterface, interfaces ){
132        if( pInterfaceClass == &pInterface->GetClass() ){
133            return true;
134        }
135    }
136    return false;
137}
138
139bool CClass::InheritsClass( const CClass &inheritsClass, const Types &actualTypeParameters, int nowLine )
140{
141    //メソッドをコピー
142    BOOST_FOREACH( const CMethod *pBaseMethod, inheritsClass.GetDynamicMethods() ){
143        CMethod *pMethod = new DynamicMethod( *pBaseMethod );
144
145        // アクセシビリティ
146        if(pBaseMethod->GetAccessibility() == Prototype::Private){
147            pMethod->SetAccessibility( Prototype::None );
148        }
149        else{
150            pMethod->SetAccessibility( pBaseMethod->GetAccessibility() );
151        }
152
153        //pobj_Inherits
154        // ※継承元のClassIndexをセット（入れ子継承を考慮する）
155        if(pBaseMethod->GetInheritsClassPtr()==0){
156            pMethod->SetInheritsClassPtr( &inheritsClass );
157        }
158        else{
159            pMethod->SetInheritsClassPtr( pBaseMethod->GetInheritsClassPtr() );
160        }
161
162        GetDynamicMethods().push_back( pMethod );
163    }
164
165    //仮想関数の数
166    AddVtblNum( inheritsClass.GetVtblNum() );
167
168    //継承先のクラスをメンバとして保持する
169    SetSuperClass( &inheritsClass );
170    SetSuperClassActualTypeParameters( actualTypeParameters );
171
172    // インターフェイスを引き継ぐ
173    BOOST_FOREACH( ::Interface *pInterface, inheritsClass.GetInterfaces() )
174    {
175        interfaces.push_back( new ::Interface( *pInterface ) );
176    }
177
178    if( this->IsInterface() && inheritsClass.IsComInterface() )
179    {
180        // COMインターフェイスを継承した場合はCOMインターフェイスにする
181        this->SetClassType( CClass::ComInterface );
182    }
183
184    return true;
185}
186
187bool CClass::Implements( const CClass &interfaceClass, const Types &actualTypeParameters, int nowLine )
188{
189    if( !interfaceClass.IsInterface() && !interfaceClass.IsComInterface() )
190    {
191        // インターフェイスではないとき
192        compiler.errorMessenger.Output(138,interfaceClass.GetName().c_str(),nowLine );
193        return false;
194    }
195
196    ::Interface *pDestInterface = new ::Interface( &interfaceClass, actualTypeParameters );
197
198    interfaces.push_back( pDestInterface );
199
200
201    /////////////////////////////////////////////////////////////////
202    // 基底クラスのメソッドからインターフェイスメソッドを再実装する
203    /////////////////////////////////////////////////////////////////
204    BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
205    {
206        CMethod *pMethodForOverride = pDestInterface->GetDynamicMethods().FindForOverride( pDestInterface->GetActualTypeParameters(), &pMethod->GetUserProc() );
207        if( pMethodForOverride )
208        {
209            pMethodForOverride->Override( &pMethod->GetUserProc(), pMethod->GetAccessibility(), false );
210
211            // 実装元になるメソッドは呼び出し不可にしておく（オーバーロードの解決から除外する）
212            pMethod->SetNotUseMark( true );
213        }
214    }
215
216
217    /////////////////////////////////////////////////////////////////
218    // キャストメソッドを追加（内部コードは自動生成すること）
219    /////////////////////////////////////////////////////////////////
220    if( interfaceClass.IsInterface() )
221    {
222        // Function Operator() As ITest
223
224        char methodName[255] = { 1, ESC_OPERATOR, CALC_AS, '\0' };
225
226        //関数ハッシュへ登録
227        UserProc *pUserProc = new UserProc(
228            NamespaceScopes(),
229            NamespaceScopesCollection(),
230            methodName,
231            Procedure::Function,
232            false,
233            false,
234            false );
235        pUserProc->SetParentClass( this );
236
237        Parameters params;
238        params.push_back( new Parameter( "_System_LocalThis", Type( DEF_PTR_VOID ) ) );
239        pUserProc->SetRealParams( params );
240
241        pUserProc->SetReturnType( Type( DEF_OBJECT, interfaceClass ) );
242        pUserProc->_paramStr = "";
243        pUserProc->Using();
244        compiler.GetObjectModule().meta.GetUserProcs().Insert( pUserProc, -1 );
245
246        LexicalAnalyzer::AddMethod(this,
247            pUserProc,
248            Prototype::Public,
249            0,
250            false,          // isConst
251            false,          // isAbstract
252            false,          // isVirtual
253            false,          // isOverride
254            "",
255            true,           // isAutoGeneration
256            -1
257        );
258    }
259
260
261    return true;
262}
263
264CMember *CClass::CreateMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine )
265{
266    extern int cp;
267
268    //構文を解析
269    char VarName[VN_SIZE];
270    char initBuffer[VN_SIZE];
271    char lpszConstructParameter[VN_SIZE];
272    Subscripts subscripts;
273    Type type;
274    GetDimentionFormat(buffer,VarName,subscripts,type,initBuffer,lpszConstructParameter);
275
276    //重複チェック
277    if(this->DupliCheckAll(VarName)){
278        compiler.errorMessenger.Output(15,VarName,cp);
279    }
280
281    CMember *pMember = new CMember( accessibility, VarName, type, isConst, subscripts, initBuffer, lpszConstructParameter );
282    pMember->source_code_address = nowLine;
283    return pMember;
284}
285void CClass::AddMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine ){
286    dynamicMembers.push_back(
287        CreateMember( accessibility, isConst, isRef, buffer, nowLine )
288    );
289}
290void CClass::AddStaticMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine ){
291    staticMembers.push_back(
292        CreateMember( accessibility, isConst, isRef, buffer, nowLine )
293    );
294}
295
296bool CClass::DupliCheckAll(const char *name) const
297{
298    //重複チェック
299
300    //メンバ
301    if(DupliCheckMember(name)) return 1;
302
303    //メソッド
304    BOOST_FOREACH( const CMethod *pMethod, GetDynamicMethods() ){
305        if( lstrcmp( name, pMethod->GetUserProc().GetName().c_str() ) == 0 ){
306            return 1;
307        }
308    }
309
310    return 0;
311}
312bool CClass::DupliCheckMember(const char *name) const
313{
314    //重複チェック
315
316    if( this->HasSuperClass() )
317    {
318        if( this->GetSuperClass().DupliCheckMember( name ) )
319        {
320            // 基底クラスで重複が発見された
321            return true;
322        }
323    }
324
325    // 動的メンバ
326    BOOST_FOREACH( CMember *pMember, dynamicMembers )
327    {
328        if( GetName() == pMember->GetName() )
329        {
330            return true;
331        }
332    }
333
334    // 静的メンバ
335    BOOST_FOREACH( CMember *pMember, staticMembers ){
336        if( GetName() == pMember->GetName() ){
337            return true;
338        }
339    }
340
341    return false;
342}
343
344const CMember *CClass::FindDynamicMember( const char *memberName ) const
345{
346    if( this->HasSuperClass() )
347    {
348        // 基底クラスで検索
349        const CMember *result = this->GetSuperClass().FindDynamicMember( memberName );
350        if( result )
351        {
352            return result;
353        }
354    }
355
356    BOOST_FOREACH( CMember *pMember, GetDynamicMembers() )
357    {
358        if( pMember->GetName() == memberName )
359        {
360            return pMember;
361        }
362    }
363    return NULL;
364}
365
366void CClass::EnumDynamicMethodsOrInterfaceMethods( const char *methodName, std::vector<const UserProc *> &subs ) const
367{
368    // 動的メソッド
369    GetDynamicMethods().Enum( methodName, subs );
370
371    // インターフェイス メソッド
372    BOOST_FOREACH( ::Interface *pInterface, GetInterfaces() )
373    {
374        pInterface->GetDynamicMethods().Enum( methodName, subs );
375    }
376}
377const CMethod *CClass::GetDynamicMethodOrInterfaceMethod( const UserProc *pUserProc ) const
378{
379    // 動的メソッド
380    const CMethod *result = GetDynamicMethods().GetMethodPtr( pUserProc );
381
382    if( !result )
383    {
384        // インターフェイス メソッド
385        BOOST_FOREACH( ::Interface *pInterface, GetInterfaces() )
386        {
387            result = pInterface->GetDynamicMethods().GetMethodPtr( pUserProc );
388            if( result )
389            {
390                return result;
391            }
392        }
393    }
394
395    return result;
396}
397
398const ::Delegate &CClass::GetDelegate() const
399{
400    const ::Delegate *dg = compiler.GetObjectModule().meta.GetDelegates().GetHashArrayElement( GetName().c_str() );
401    while( dg )
402    {
403        if( dg->IsEqualSymbol( GetNamespaceScopes(), GetName() ) ){
404            //名前空間とクラス名が一致した
405            return *dg;
406        }
407        dg = dg->GetChainNext();
408    }
409
410    Jenga::Throw( "CClass::GetDelegateメソッドに失敗" );
411    static ::Delegate dummy;
412    return dummy;
413}
414
415//サイズを取得
416int CClass::GetSize() const
417{
418    int resultSize = 0;
419
420    int alignment = 1;
421    if( this->IsStructure() )
422    {
423        // 構造体のとき
424
425        if( this->GetFixedAlignment() )
426        {
427            // アラインメントの固定値が指定されていた場合はそれを取得
428            alignment = this->GetFixedAlignment();
429        }
430    }
431    else
432    {
433        // それ以外
434
435        if( this->HasSuperClass() )
436        {
437            // 基底クラスのサイズを追加
438            resultSize += this->GetSuperClass().GetSize();
439
440            // 基底クラスのアラインメントを取得
441            alignment = this->GetSuperClass().GetAlignment();
442        }
443        else
444        {
445            // 基底クラスが存在しないとき
446
447            // 仮想関数が存在する場合はvtbl及びvtblMasterListへのポインタのサイズを追加
448            resultSize += IsExistVirtualFunctions() ? PTR_SIZE*2 : 0;
449        }
450    }
451
452    BOOST_FOREACH( CMember *pMember, dynamicMembers )
453    {
454        // メンバサイズ
455        int tempMemberSize = pMember->GetType().GetSize();
456
457        // 一時アラインメントを算出
458        int tempAlignment = tempMemberSize;
459        if( pMember->GetType().IsStruct() )
460        {
461            // メンバが構造体の場合は、メンバのアラインメントを取得
462            tempAlignment = pMember->GetType().GetClass().GetAlignment();
463        }
464
465        // アラインメントを考慮してパディングを追加
466        if( GetFixedAlignment() && alignment < tempAlignment )
467        {
468            if( resultSize % alignment )
469            {
470                resultSize += alignment - ( resultSize % alignment );
471            }
472        }
473        else
474        {
475            if( alignment < tempAlignment )
476            {
477                // 最大アラインメントを更新
478                alignment = tempAlignment;
479            }
480
481            if( tempMemberSize == 0 )
482            {
483                if( !pMember->GetType().IsStruct() )
484                {
485                    compiler.errorMessenger.OutputFatalError();
486                }
487
488                //メンバを持たない構造体
489                //※何もしない（オフセットの計算をしない）
490            }
491            else{
492                if( resultSize % tempAlignment )
493                {
494                    resultSize += tempAlignment - ( resultSize % tempAlignment );
495                }
496            }
497        }
498
499        // メンバサイズを加算（配列を考慮）
500        resultSize += tempMemberSize * Variable::GetSubScriptCounts( pMember->GetSubscripts() );
501    }
502
503    if( alignment )
504    {
505        // 末尾アラインメントを考慮してパディングを追加
506        if( resultSize % alignment )
507        {
508            resultSize += alignment - ( resultSize % alignment );
509        }
510    }
511
512    return resultSize;
513}
514
515//メンバのオフセットを取得
516int CClass::GetMemberOffset( const char *memberName ) const
517{
518    int resultSize = 0;
519
520    int alignment = 1;
521    if( this->IsStructure() )
522    {
523        // 構造体のとき
524
525        if( this->GetFixedAlignment() )
526        {
527            // アラインメントの固定値が指定されていた場合はそれを取得
528            alignment = this->GetFixedAlignment();
529        }
530    }
531    else
532    {
533        // それ以外
534
535        if( this->HasSuperClass() )
536        {
537            if( this->GetSuperClass().HasDynamicMember( memberName ) )
538            {
539                // 基底クラスのメンバを取得
540                return this->GetSuperClass().GetMemberOffset( memberName );
541            }
542
543            // 基底クラスのサイズを追加
544            resultSize += this->GetSuperClass().GetSize();
545
546            // 基底クラスのアラインメントを取得
547            alignment = this->GetSuperClass().GetAlignment();
548        }
549        else
550        {
551            // 基底クラスが存在しないとき
552
553            // 仮想関数が存在する場合はvtbl及びvtblMasterListへのポインタのサイズを追加
554            resultSize += IsExistVirtualFunctions() ? PTR_SIZE*2 : 0;
555        }
556    }
557
558    BOOST_FOREACH( CMember *pMember, dynamicMembers )
559    {
560        // メンバサイズ
561        int tempMemberSize = pMember->GetType().GetSize();
562
563        // 一時アラインメントを算出
564        int tempAlignment = tempMemberSize;
565        if( pMember->GetType().IsStruct() )
566        {
567            // メンバが構造体の場合は、メンバのアラインメントを取得
568            tempAlignment = pMember->GetType().GetClass().GetAlignment();
569        }
570
571        // アラインメントを考慮してパディングを追加
572        if( GetFixedAlignment() && alignment < tempAlignment )
573        {
574            if( resultSize % alignment )
575            {
576                resultSize += alignment - ( resultSize % alignment );
577            }
578        }
579        else
580        {
581            if( alignment < tempAlignment )
582            {
583                // 最大アラインメントを更新
584                alignment = tempAlignment;
585            }
586
587            if( tempMemberSize == 0 )
588            {
589                if( !pMember->GetType().IsStruct() )
590                {
591                    compiler.errorMessenger.OutputFatalError();
592                }
593
594                //メンバを持たない構造体
595                //※何もしない（オフセットの計算をしない）
596            }
597            else{
598                if( resultSize % tempAlignment )
599                {
600                    resultSize += tempAlignment - ( resultSize % tempAlignment );
601                }
602            }
603        }
604
605        if(memberName){
606            //メンバ指定がある場合は、オフセットを返す
607            if( pMember->GetName() == memberName )
608            {
609                return resultSize;
610            }
611        }
612
613        // メンバサイズを加算（配列を考慮）
614        resultSize += tempMemberSize * Variable::GetSubScriptCounts( pMember->GetSubscripts() );
615    }
616
617    if( alignment )
618    {
619        // 末尾アラインメントを考慮してパディングを追加
620        if( resultSize % alignment )
621        {
622            resultSize += alignment - ( resultSize % alignment );
623        }
624    }
625
626    return resultSize;
627}
628int CClass::GetAlignment() const
629{
630    int alignment = 1;
631    if( this->IsStructure() )
632    {
633        // 構造体のとき
634
635        if( this->GetFixedAlignment() )
636        {
637            // アラインメントの固定値が指定されていた場合はそれを取得
638            return this->GetFixedAlignment();
639        }
640    }
641    else
642    {
643        // それ以外
644
645        if( this->HasSuperClass() )
646        {
647            // 基底クラスのアラインメントを取得
648            alignment = this->GetSuperClass().GetAlignment();
649        }
650        else
651        {
652            // 基底クラスが存在しないとき
653
654            // 仮想関数が存在する場合はvtbl及びvtblMasterListへのポインタのサイズを追加
655            alignment = PTR_SIZE;
656        }
657    }
658
659    BOOST_FOREACH( CMember *pMember, dynamicMembers )
660    {
661        int tempAlignment = pMember->GetType().GetSize();
662        if( pMember->GetType().IsStruct() )
663        {
664            // メンバが構造体の場合は、メンバのアラインメントを取得
665            tempAlignment = pMember->GetType().GetClass().GetAlignment();
666        }
667
668        if( alignment < tempAlignment )
669        {
670            // 最大アラインメントを更新
671            alignment = tempAlignment;
672        }
673    }
674
675    return alignment;
676}
677
678void CClass::GetVtblMasterListIndexAndVtblIndex( const UserProc *pUserProc, int &vtblMasterListIndex, int &vtblIndex ) const
679{
680    vtblMasterListIndex = 0;
681
682    vtblIndex = 0;
683    BOOST_FOREACH( const CMethod *pMethod, GetDynamicMethods() ){
684        if( &pMethod->GetUserProc() == pUserProc )
685        {
686            return;
687        }
688
689        if( pMethod->IsVirtual() )
690        {
691            vtblIndex++;
692        }
693    }
694
695    BOOST_FOREACH( const ::Interface *pInterface, interfaces )
696    {
697        vtblMasterListIndex++;
698
699        vtblIndex = 0;
700        BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
701            if( &pMethod->GetUserProc() == pUserProc )
702            {
703                return;
704            }
705
706            if( pMethod->IsVirtual() )
707            {
708                vtblIndex++;
709            }
710        }
711    }
712
713    compiler.errorMessenger.OutputFatalError();
714    return;
715}
716int CClass::GetVtblMasterListIndex( const CClass *pClass ) const
717{
718    int result = 0;
719
720    BOOST_FOREACH( const ::Interface *pInterface, interfaces )
721    {
722        result++;
723       
724        if( &pInterface->GetClass() == pClass )
725        {
726            return result;
727        }
728    }
729
730    compiler.errorMessenger.OutputFatalError();
731    return 0;
732}
733long CClass::GetComVtblOffset() const
734{
735    return comVtblOffset;
736}
737long CClass::GetVtblMasterListOffset() const
738{
739    //既に存在する場合はそれを返す
740    if( vtblMasterListOffset == -1 )
741    {
742        compiler.errorMessenger.OutputFatalError();
743    }
744
745    return vtblMasterListOffset;
746}
747void CClass::GenerateVTableMasterList( const std::vector<long> &vtableMasterList, long &offset )
748{
749    offset = compiler.GetObjectModule().dataTable.AddBinary(
750        (void *)&vtableMasterList[0],
751        static_cast<int>(vtableMasterList.size()*sizeof(LONG_PTR))
752    );
753}
754void CClass::GenerateFullVTables()
755{
756    if( IsAbstract() )
757    {
758        // 抽象クラスは無視
759        return;
760    }
761    if( !IsUsing() )
762    {
763        // 使われていないクラスは無視
764        return;
765    }
766
767    // vtblマスターリストの元データに不要なデータが含まれていたらエラー
768    if( vtblMasterList.size() )
769    {
770        compiler.errorMessenger.OutputFatalError();
771    }
772
773    // 自身のクラスのvtblを生成
774    GetDynamicMethods().GenerateVTablePart( this->vtbl_offset );
775    vtblMasterList.push_back( this->vtbl_offset );
776
777    // インターフェイスのvtblを生成
778    BOOST_FOREACH( const ::Interface *pInterface, interfaces )
779    {
780        long tempVtblOffset;
781        pInterface->GetDynamicMethods().GenerateVTablePart( tempVtblOffset );
782        vtblMasterList.push_back( tempVtblOffset );
783
784        pInterface->SetVtblOffset( tempVtblOffset );
785
786        if( pInterface->GetClass().IsComInterface() )
787        {
788            if( this->comVtblOffset )
789            {
790                compiler.errorMessenger.OutputFatalError();
791            }
792            this->comVtblOffset = tempVtblOffset;
793        }
794    }
795
796    // vtblマスターリストを生成
797    GenerateVTableMasterList( vtblMasterList, this->vtblMasterListOffset );
798}
799void CClass::ActionVtblSchedule( LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection, LONG_PTR MemPos_DataSection )
800{
801    if( IsAbstract() )
802    {
803        // 抽象クラスは無視
804        return;
805    }
806    if( !IsUsing() )
807    {
808        // 使われていないクラスは無視
809        return;
810    }
811    if(vtbl_offset==-1) return;
812
813    // 自身のクラスのvtbl
814    {
815        LONG_PTR *pVtbl = (LONG_PTR *)((char *)compiler.GetObjectModule().dataTable.GetPtr() + vtbl_offset);
816
817        for( int i=0; i<GetVtblNum(); i++ ){
818            const UserProc *pUserProc = (UserProc *)pVtbl[i];
819            if(!pUserProc) continue;
820
821            if( pUserProc->GetBeginOpAddress() == 0
822                && pUserProc->GetEndOpAddress() == 0 )
823            {
824                Jenga::Throw( "未解決の仮想関数が存在する" );
825            }
826
827            pVtbl[i] = pUserProc->GetBeginOpAddress() + ImageBase + MemPos_CodeSection;
828        }
829    }
830
831    // インターフェイスのvtbl
832    BOOST_FOREACH( const ::Interface *pInterface, interfaces )
833    {
834        LONG_PTR *pVtbl = (LONG_PTR *)((char *)compiler.GetObjectModule().dataTable.GetPtr() + pInterface->GetVtblOffset());
835
836        for( int i=0; i<pInterface->GetClass().GetVtblNum(); i++ ){
837            const UserProc *pUserProc = (UserProc *)pVtbl[i];
838            if(!pUserProc) continue;
839
840            if( pUserProc->GetBeginOpAddress() == 0
841                && pUserProc->GetEndOpAddress() == 0 )
842            {
843                Jenga::Throw( "未解決の仮想関数が存在する" );
844            }
845
846            pVtbl[i] = pUserProc->GetBeginOpAddress() + ImageBase + MemPos_CodeSection;
847        }
848    }
849
850    // vtblマスターリスト
851    LONG_PTR *pVtblMasterList = (LONG_PTR *)((char *)compiler.GetObjectModule().dataTable.GetPtr() + vtblMasterListOffset );
852    for( int i=0; i<static_cast<int>(vtblMasterList.size()); i++ )
853    {
854        pVtblMasterList[i] = vtblMasterList[i] + ImageBase + MemPos_DataSection;
855    }
856}
857bool CClass::IsAbstract() const
858{
859    // 未実装(abstract)の仮想関数を持つ場合はtrueを返す
860
861    BOOST_FOREACH( const CMethod *pMethod, GetDynamicMethods() ){
862        if(pMethod->IsVirtual()){
863            if(pMethod->IsAbstract()){
864                return true;
865            }
866        }
867    }
868
869    // インターフェイスのvtbl
870    BOOST_FOREACH( const ::Interface *pInterface, interfaces )
871    {
872        BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
873            if(pMethod->IsVirtual()){
874                if(pMethod->IsAbstract()){
875                    return true;
876                }
877            }
878        }
879    }
880
881    return false;
882}
883
884CClass *Classes::Create( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const char *name){
885    return new CClass(namespaceScopes, importedNamespaces, name);
886}
887bool Classes::Insert( CClass *pClass, int nowLine )
888{
889    /////////////////////////////////
890    // ハッシュデータに追加
891    /////////////////////////////////
892
893    if( !Put( pClass ) )
894    {
895        compiler.errorMessenger.Output(15,pClass->GetName(), nowLine);
896        return false;
897    }
898    return true;
899}
900CClass *Classes::Add( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const char *name,int nowLine){
901    //////////////////////////////////////////////////////////////////////////
902    // クラスを追加
903    // ※名前のみを登録。その他の情報はSetClassメソッドで！
904    //////////////////////////////////////////////////////////////////////////
905
906    CClass *pClass = Create(namespaceScopes, importedNamespaces, name);
907
908    if( !Insert( pClass, nowLine ) )
909    {
910        return NULL;
911    }
912
913    return pClass; 
914}
915
916void Classes::GenerateVTables()
917{
918    Iterator_Reset();
919    while( Iterator_HasNext() )
920    {
921        CClass *pClass = Iterator_GetNext();
922        pClass->GenerateFullVTables();
923    }
924}
925
926void Classes::ActionVtblSchedule( LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection, LONG_PTR MemPos_DataSection ){
927    Iterator_Reset();
928    while( Iterator_HasNext() )
929    {
930        CClass *pClass = Iterator_GetNext();
931        pClass->ActionVtblSchedule( ImageBase, MemPos_CodeSection, MemPos_DataSection);
932    }
933}
934
935
936void Classes::InitStaticMember(){
937    //静的メンバをグローバル領域に作成
938
939    //イテレータをリセット
940
941    extern int cp;
942    int back_cp=cp;
943
944    this->Iterator_Reset();
945    while(this->Iterator_HasNext()){
946        CClass &objClass = *this->Iterator_GetNext();
947        if( objClass.isTargetObjectModule == false )
948        {
949            // 静的リンクライブラリの場合は飛ばす（既にインスタンスが定義済みであるため）
950            continue;
951        }
952
953        // 名前空間をセット
954        compiler.GetNamespaceSupporter().GetLivingNamespaceScopes() = objClass.GetNamespaceScopes();
955
956        DWORD dwFlags = 0;
957        if( objClass.GetName() == "_System_TypeBase" )
958        {
959            // _System_TypeBaseクラスはグローバル、スタティック領域を初期化するためのクラスなのでここでの初期化は除外する
960            dwFlags |= DIMFLAG_NONCALL_CONSTRACTOR;
961        }
962
963        // コンパイル中クラスとしてセット
964        compiler.SetCompilingClass( &objClass );
965
966        const EnumInfo *pEnumInfo = NULL;
967        if( objClass.IsEnum() )
968        {
969            pEnumInfo = compiler.enumInfoCollection.Find( objClass );
970        }
971
972        int i=0;
973        BOOST_FOREACH( CMember *member, objClass.GetStaticMembers() )
974        {
975            if( pEnumInfo )
976            {
977                cp = pEnumInfo->GetEnumMember( member->GetName() ).GetSourceIndex();
978            }
979
980            char temporary[VN_SIZE];
981            sprintf(temporary,"%s.%s",objClass.GetName().c_str(),member->GetName().c_str());
982            dim(
983                temporary,
984                member->GetSubscripts(),
985                member->GetType(),
986                member->GetInitializeExpression().c_str(),
987                member->GetConstructParameter().c_str(),
988                dwFlags);
989
990            i++;
991        }
992
993        compiler.SetCompilingClass( NULL );
994    }
995
996    compiler.GetNamespaceSupporter().GetLivingNamespaceScopes().clear();
997
998    cp=back_cp;
999}
1000
1001void Classes::Compile_System_InitializeUserTypes(){
1002    char temporary[VN_SIZE];
1003
1004    ////////////////////////////////////////////////////////////////////
1005    // クラス登録
1006    ////////////////////////////////////////////////////////////////////
1007
1008    // イテレータをリセット
1009    Iterator_Reset();
1010
1011    while( Iterator_HasNext() ){
1012        const CClass &objClass = *Iterator_GetNext();
1013
1014        if( !objClass.IsUsing() ){
1015            // 未使用のクラスは無視する
1016            continue;
1017        }
1018
1019        std::string referenceOffsetsBuffer;
1020        int numOfReference = 0;
1021        objClass.GetReferenceOffsetsInitializeBuffer( referenceOffsetsBuffer, numOfReference );
1022
1023        sprintf( temporary
1024            , "Add(%c%c_System_TypeForClass[strNamespace=\"%s\",name=\"%s\",fullName=\"%s\",referenceOffsets=[%s],numOfReference=%d])"
1025            , 1
1026            , ESC_SYSTEM_STATIC_NEW
1027            , objClass.GetNamespaceScopes().ToString().c_str()      // 名前空間
1028            , objClass.GetName().c_str()                            // クラス名
1029            , objClass.GetFullName().c_str()                        // フルネーム
1030            , referenceOffsetsBuffer.c_str()                        // 参照メンバオフセット配列
1031            , numOfReference                                        // 参照メンバの個数
1032            );
1033
1034        // コンパイル
1035        ChangeOpcode( temporary );
1036
1037        objClass.SetTypeInfoDataTableOffset(
1038            compiler.GetObjectModule().dataTable.GetLastMadeConstObjectDataTableOffset()
1039        );
1040    }
1041}
1042void Classes::Compile_System_InitializeUserTypesForBaseType()
1043{
1044    extern int cp;
1045    cp = -1;
1046    ////////////////////////////////////////////////////////////////////
1047    // 基底クラスを登録
1048    ////////////////////////////////////////////////////////////////////
1049
1050    char temporary[8192];
1051    sprintf(temporary, "%c%ctempType=Nothing%c%c_System_TypeForClass"
1052        , HIBYTE( COM_DIM )
1053        , LOBYTE( COM_DIM )
1054        , 1
1055        , ESC_AS
1056        );
1057    ChangeOpcode( temporary );
1058
1059    // イテレータをリセット
1060    Iterator_Reset();
1061
1062    while( Iterator_HasNext() ){
1063        const CClass &objClass = *Iterator_GetNext();
1064
1065        if( !objClass.IsUsing() ){
1066            // 未使用のクラスは無視する
1067            continue;
1068        }
1069
1070        if( objClass.HasSuperClass() || objClass.GetDynamicMembers().size() ){
1071            sprintf( temporary
1072                , "tempType=Search(\"%s\") As ActiveBasic.Core._System_TypeForClass"
1073                , objClass.GetFullName().c_str()
1074            );
1075
1076            // コンパイル
1077            MakeMiddleCode( temporary );
1078            ChangeOpcode( temporary );
1079
1080            sprintf( temporary
1081                , "tempType.SetClassInfo(%d,_System_GetComVtbl(%s),_System_GetVtblList(%s),_System_GetDefaultConstructor(%s),_System_GetDestructor(%s))"
1082                , objClass.GetSize()
1083                , objClass.GetFullName().c_str()
1084                , objClass.GetFullName().c_str()
1085                , objClass.GetFullName().c_str()
1086                , objClass.GetFullName().c_str()
1087                , objClass.GetName().c_str()
1088            );
1089
1090            // コンパイル
1091            ChangeOpcode( temporary );
1092
1093            if( objClass.HasSuperClass() )
1094            {
1095                sprintf( temporary
1096                    , "tempType.SetBaseType(Search(\"%s\"))"
1097                    , objClass.GetSuperClass().GetFullName().c_str()
1098                );
1099
1100                // コンパイル
1101                ChangeOpcode( temporary );
1102            }
1103
1104            if( objClass.GetDynamicMembers().size() )
1105            {
1106                // メンバの型を示すTypeInfoオブジェクトへのDataOffset配列の静的データ定義文字列を取得
1107                sprintf(
1108                    temporary,
1109                    "tempType.SetMembers([%s],[%s],[%s],%d)",
1110                    objClass.GetStaticDefiningStringAsMemberNames().c_str(),
1111                    objClass.GetStaticDefiningStringAsMemberTypeInfoNames().c_str(),
1112                    objClass.GetStaticDefiningStringAsMemberOffsets().c_str(),
1113                    objClass.GetDynamicMembers().size()
1114                );
1115                ChangeOpcode( temporary );
1116            }
1117        }
1118    }
1119}
1120
1121const CClass *Classes::Find( const NamespaceScopes &namespaceScopes, const std::string &name ) const
1122{
1123    if( namespaceScopes.size() == 0 && name == "Object" ){
1124        return GetObjectClassPtr();
1125    }
1126    else if( namespaceScopes.size() == 0 && name == "String" ){
1127        return GetStringClassPtr();
1128    }
1129
1130    std::vector<const CClass *> classes;
1131    const CClass *pClass = GetHashArrayElement( name.c_str() );
1132    while( pClass )
1133    {
1134        if( pClass->IsEqualSymbol( namespaceScopes, name ) ){
1135            //名前空間とクラス名が一致した
1136            classes.push_back( pClass );
1137        }
1138        pClass = pClass->GetChainNext();
1139    }
1140    if( classes.size() > 0 )
1141    {
1142        // 複数の名前空間の中に同一のクラス名が存在する場合があるので、アクセス可能で尚且つ階層が一番深いものをチョイスする
1143        pClass = classes.front();
1144
1145        BOOST_FOREACH( const CClass *pTempClass, classes )
1146        {
1147            if( pClass->GetNamespaceScopes().size() < pTempClass->GetNamespaceScopes().size() )
1148            {
1149                pClass = pTempClass;
1150            }
1151        }
1152
1153        return pClass;
1154    }
1155
1156    // TypeDefも見る
1157    int index = compiler.GetObjectModule().meta.GetTypeDefs().GetIndex( namespaceScopes, name );
1158    if( index != -1 ){
1159        Type type = compiler.GetObjectModule().meta.GetTypeDefs()[index].GetBaseType();
1160        if( type.IsObject() ){
1161            return &type.GetClass();
1162        }
1163    }
1164
1165    return NULL;
1166}
1167const CClass *Classes::Find( const std::string &fullName ) const
1168{
1169    char AreaName[VN_SIZE] = "";        //オブジェクト変数
1170    char NestName[VN_SIZE] = "";        //入れ子メンバ
1171    bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );
1172
1173    return Find( NamespaceScopes( AreaName ), NestName );
1174}
1175
1176const CClass *Classes::GetStringClassPtr() const
1177{
1178    if( !pStringClass ){
1179        // キャッシュしておく
1180        pStringClass = this->Find( NamespaceScopes( "System" ), "String" );
1181
1182        if( !pStringClass )
1183        {
1184            compiler.errorMessenger.Output(400, "System.String", cp);
1185            static CClass dummy;
1186            return &dummy;
1187        }
1188        return pStringClass;
1189    }
1190    return pStringClass;
1191}
1192const CClass *Classes::GetObjectClassPtr() const
1193{
1194    if( !pObjectClass ){
1195        // キャッシュしておく
1196        pObjectClass = this->Find( NamespaceScopes( "System" ), "Object" );
1197
1198        if( !pObjectClass )
1199        {
1200            compiler.errorMessenger.Output(400, "System.Object", cp);
1201            static CClass dummy;
1202            return &dummy;
1203        }
1204        return pObjectClass;
1205    }
1206    return pObjectClass;
1207}
1208const CClass *Classes::GetInterfaceInfoClassPtr() const
1209{
1210    if( !pInterfaceInfo ){
1211        // キャッシュしておく
1212        pInterfaceInfo = this->Find( "ActiveBasic.Core.InterfaceInfo" );
1213
1214        if( !pInterfaceInfo )
1215        {
1216            compiler.errorMessenger.Output(400, "ActiveBasic.Core.InterfaceInfo", cp);
1217            static CClass dummy;
1218            return &dummy;
1219        }
1220        return pInterfaceInfo;
1221    }
1222    return pInterfaceInfo;
1223}
1224
1225std::string CClass::GetStaticDefiningStringAsMemberNames() const
1226{
1227    std::string result;
1228
1229    BOOST_FOREACH( const CMember *pMember, dynamicMembers )
1230    {
1231        if( result.size() )
1232        {
1233            result += ",";
1234        }
1235
1236        result += "\"" + pMember->GetName() + "\"";
1237    }
1238
1239    return result;
1240}
1241std::string CClass::GetStaticDefiningStringAsMemberTypeInfoNames() const
1242{
1243    std::string result;
1244
1245    BOOST_FOREACH( const CMember *pMember, dynamicMembers )
1246    {
1247        if( result.size() )
1248        {
1249            result += ",";
1250        }
1251
1252        result += "\"" + compiler.TypeToString( pMember->GetType() ) + "\"";
1253    }
1254
1255    return result;
1256}
1257std::string CClass::GetStaticDefiningStringAsMemberOffsets() const
1258{
1259    std::string result;
1260
1261    BOOST_FOREACH( const CMember *pMember, dynamicMembers )
1262    {
1263        if( result.size() )
1264        {
1265            result += ",";
1266        }
1267
1268        int offset = this->GetMemberOffset( pMember->GetName().c_str() );
1269
1270        char temporary[255];
1271        itoa( offset, temporary, 16 );
1272
1273        result += (std::string)"&H" + temporary;
1274    }
1275
1276    return result;
1277}
1278
1279void CClass::GetReferenceOffsetsInitializeBuffer( std::string &referenceOffsetsBuffer, int &numOfReference, int baseOffset ) const
1280{
1281    const CClass &thisClass = *this;
1282    BOOST_FOREACH( const CMember *pMember, thisClass.GetDynamicMembers() )
1283    {
1284        if( pMember->GetType().IsObject() || pMember->GetType().IsPointer() )
1285        {
1286            if( referenceOffsetsBuffer.size() )
1287            {
1288                referenceOffsetsBuffer += ",";
1289            }
1290
1291            char temp[255];
1292            sprintf( temp, "%d", baseOffset + thisClass.GetMemberOffset( pMember->GetName().c_str() ) );
1293            referenceOffsetsBuffer += temp;
1294
1295            numOfReference++;
1296        }
1297        if( pMember->GetType().IsStruct() && !pMember->GetType().IsPointer() )
1298        {
1299            // 構造体の実体をメンバに持つとき
1300            int baseOffset = thisClass.GetMemberOffset( pMember->GetName().c_str() );
1301
1302            // 構造体メンバでGCによるチェックが必要な参照位置を追加
1303            pMember->GetType().GetClass().GetReferenceOffsetsInitializeBuffer( referenceOffsetsBuffer, numOfReference, baseOffset );
1304        }
1305    }
1306}
Note: See TracBrowser for help on using the repository browser.