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

Last change on this file since 538 was 538, checked in by dai_9181, 17 years ago

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