source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/include/Class.h@ 510

Last change on this file since 510 was 510, checked in by dai_9181, 16 years ago

Prototypeクラスをab_commonプロジェクトに移動した。
File size: 16.4 KB
Line 
1#pragma once
2
3#include <option.h>
4#include <Program.h>
5#include <Type.h>
6#include <Method.h>
7#include <Member.h>
8#include <Source.h>
9
10class UserProc;
11class CClass;
12class Delegate;
13
14class DynamicMethodsPrototype
15{
16 // 動的メソッド
17 Methods dynamicMethods;
18
19 // XMLシリアライズ用
20private:
21 friend class boost::serialization::access;
22 template<class Archive> void serialize(Archive& ar, const unsigned int version)
23 {
24 ar & BOOST_SERIALIZATION_NVP( dynamicMethods );
25 }
26
27public:
28 DynamicMethodsPrototype(){}
29 DynamicMethodsPrototype( const DynamicMethodsPrototype &dynamicMethodsPrototype )
30 : dynamicMethods( dynamicMethodsPrototype.dynamicMethods )
31 {
32 }
33 ~DynamicMethodsPrototype(){}
34
35 const Methods &GetDynamicMethods() const
36 {
37 return dynamicMethods;
38 }
39 Methods &GetDynamicMethods()
40 {
41 return dynamicMethods;
42 }
43
44 void AddDynamicMethods( CMethod *pMethod )
45 {
46 dynamicMethods.push_back( pMethod );
47 }
48};
49
50class ClassPrototype : public Prototype, public DynamicMethodsPrototype
51{
52 // XMLシリアライズ用
53private:
54 friend class boost::serialization::access;
55 template<class Archive> void serialize(Archive& ar, const unsigned int version)
56 {
57 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( Prototype );
58 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( DynamicMethodsPrototype );
59 }
60
61public:
62 ClassPrototype( const NamespaceScopes &namespaceScopes, const string &name )
63 : Prototype( namespaceScopes, name )
64 , DynamicMethodsPrototype()
65 {
66 }
67 ClassPrototype()
68 : Prototype()
69 , DynamicMethodsPrototype()
70 {
71 }
72};
73
74class Interface : public DynamicMethodsPrototype
75{
76 const CClass *pInterfaceClass;
77 mutable LONG_PTR vtblOffset;
78
79 // 型パラメータ（実パラメータ）
80 Types actualTypeParameters;
81
82 // XMLシリアライズ用
83private:
84 friend class boost::serialization::access;
85 template<class Archive> void serialize(Archive& ar, const unsigned int version)
86 {
87 trace_for_serialize( "serializing - Interface" );
88
89 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( DynamicMethodsPrototype );
90 ar & boost::serialization::make_nvp("pInterfaceClass", const_cast<CClass *&>(pInterfaceClass) );
91 ar & BOOST_SERIALIZATION_NVP( vtblOffset );
92 ar & BOOST_SERIALIZATION_NVP( actualTypeParameters );
93 }
94
95public:
96 Interface( const CClass *pInterfaceClass, const Types &actualTypeParameters );
97 Interface( const Interface &objInterface )
98 : DynamicMethodsPrototype( objInterface )
99 , pInterfaceClass( objInterface.pInterfaceClass )
100 , vtblOffset( objInterface.vtblOffset )
101 {
102 }
103 Interface()
104 {
105 }
106
107 const CClass &GetClass() const{
108 return *pInterfaceClass;
109 }
110 LONG_PTR GetVtblOffset() const
111 {
112 return vtblOffset;
113 }
114 void SetVtblOffset( LONG_PTR vtblOffset ) const
115 {
116 this->vtblOffset = vtblOffset;
117 }
118
119 const Types &GetActualTypeParameters() const
120 {
121 return actualTypeParameters;
122 }
123
124 std::string GetFullNameWithActualGenericTypeParameters() const;
125};
126typedef std::vector<Interface *> Interfaces;
127
128class CClass: public ClassPrototype, public Jenga::Common::ObjectInHashmap<CClass>
129{
130public:
131 // 型の種類
132 enum ClassType{
133 Class,
134 Interface,
135 ComInterface,
136 Enum,
137 Delegate,
138 Structure,
139 };
140
141private:
142 ClassType classType;
143
144 // importされている名前空間
145 NamespaceScopesCollection importedNamespaces;
146
147 // 型パラメータ
148 GenericTypes formalGenericTypes;
149
150 // 基底クラス
151 const CClass *pSuperClass;
152
153 // 基底クラスの型パラメータ（実パラメータ）
154 Types superClassActualTypeParameters;
155
156 // Blittable型情報
157 Type blittableType;
158
159 // 実装するインターフェイス
160 Interfaces interfaces;
161
162 // 動的メンバ
163 Members dynamicMembers;
164
165 // 静的メンバ
166 Members staticMembers;
167
168 // 動的メソッド
169 int ConstructorMemberSubIndex;
170 int DestructorMemberSubIndex;
171 int vtblNum; // 仮想関数の数
172
173 // 静的メソッド
174 Methods staticMethods;
175
176 //アラインメント値
177 int fixedAlignment;
178
179 // XMLシリアライズ用
180private:
181 friend class boost::serialization::access;
182 template<class Archive> void serialize(Archive& ar, const unsigned int version)
183 {
184 trace_for_serialize( "serializing - CClass" );
185
186 ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP( ClassPrototype );
187 ar & BOOST_SERIALIZATION_NVP( classType );
188 ar & BOOST_SERIALIZATION_NVP( importedNamespaces );
189 ar & BOOST_SERIALIZATION_NVP( formalGenericTypes );
190 ar & boost::serialization::make_nvp( "pSuperClass", const_cast<CClass *&>(pSuperClass) );
191 ar & BOOST_SERIALIZATION_NVP( superClassActualTypeParameters );
192 ar & BOOST_SERIALIZATION_NVP( blittableType );
193 ar & BOOST_SERIALIZATION_NVP( interfaces );
194 ar & BOOST_SERIALIZATION_NVP( dynamicMembers );
195 ar & BOOST_SERIALIZATION_NVP( staticMembers );
196 ar & BOOST_SERIALIZATION_NVP( ConstructorMemberSubIndex );
197 ar & BOOST_SERIALIZATION_NVP( DestructorMemberSubIndex );
198 ar & BOOST_SERIALIZATION_NVP( vtblNum );
199 ar & BOOST_SERIALIZATION_NVP( staticMethods );
200 ar & BOOST_SERIALIZATION_NVP( fixedAlignment );
201 }
202
203 bool isReady;
204public:
205
206 CClass( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const string &name )
207 : ClassPrototype( namespaceScopes, name )
208 , importedNamespaces( importedNamespaces )
209 , classType( Class )
210 , pSuperClass( NULL )
211 , blittableType( Type() )
212 , isReady( false )
213 , fixedAlignment( 0 )
214 , ConstructorMemberSubIndex( -1 )
215 , DestructorMemberSubIndex( -1 )
216 , vtblNum( 0 )
217 , vtbl_offset( -1 )
218 , comVtblOffset( 0 )
219 , isCompilingConstructor( false )
220 , isCompilingDestructor( false )
221 , pobj_NextClass( NULL )
222 , cacheSize( 0 )
223 {
224 }
225 CClass()
226 : ClassPrototype()
227 , importedNamespaces()
228 , classType()
229 , pSuperClass( NULL )
230 , blittableType( Type() )
231 , isReady( false )
232 , fixedAlignment( 0 )
233 , ConstructorMemberSubIndex( -1 )
234 , DestructorMemberSubIndex( -1 )
235 , vtblNum( 0 )
236 , vtbl_offset( -1 )
237 , comVtblOffset( 0 )
238 , isCompilingConstructor( false )
239 , isCompilingDestructor( false )
240 , pobj_NextClass( NULL )
241 , cacheSize( 0 )
242 {
243 }
244 ~CClass()
245 {
246 // 動的メンバ
247 BOOST_FOREACH( CMember *member, dynamicMembers )
248 {
249 delete member;
250 }
251
252 // 静的メンバ
253 BOOST_FOREACH( CMember *member, staticMembers )
254 {
255 delete member;
256 }
257
258 // インターフェイス
259 BOOST_FOREACH( ::Interface *pInterface, interfaces )
260 {
261 delete pInterface;
262 }
263 }
264
265 virtual const std::string &GetKeyName() const
266 {
267 return GetName();
268 }
269 virtual bool IsDuplication( const CClass *pClass ) const
270 {
271 if( pClass->IsEqualSymbol( *this ) )
272 {
273 return true;
274 }
275 return false;
276 }
277
278 void Readed(){
279 isReady = true;
280 }
281 bool IsReady() const{
282 return isReady;
283 }
284
285 const NamespaceScopesCollection &GetImportedNamespaces() const
286 {
287 return importedNamespaces;
288 }
289
290 // 型パラメータ
291 const GenericTypes &GetFormalGenericTypes() const
292 {
293 return formalGenericTypes;
294 }
295 void AddFormalGenericType( GenericType genericType )
296 {
297 this->formalGenericTypes.push_back( genericType );
298 }
299 int GetFormalGenericTypeParameterIndex( const std::string &name ) const
300 {
301 int i = 0;
302 BOOST_FOREACH( const GenericType &genericType, formalGenericTypes )
303 {
304 if( genericType.GetName() == name )
305 {
306 return i;
307 }
308 i++;
309 }
310 return -1;
311 }
312 bool IsExistFormalGenericTypeParameter( const std::string &name ) const
313 {
314 BOOST_FOREACH( const GenericType &genericType, formalGenericTypes )
315 {
316 if( genericType.GetName() == name )
317 {
318 return true;
319 }
320 }
321 return false;
322 }
323 bool IsGeneric() const
324 {
325 return ( this->formalGenericTypes.size() != 0 );
326 }
327
328 // 継承元クラス
329 bool HasSuperClass() const
330 {
331 return ( pSuperClass != NULL );
332 }
333 const CClass &GetSuperClass() const
334 {
335 return *pSuperClass;
336 }
337 void SetSuperClass( const CClass *pSuperClass )
338 {
339 this->pSuperClass = pSuperClass;
340 }
341 const Types &GetSuperClassActualTypeParameters() const
342 {
343 return superClassActualTypeParameters;
344 }
345 void SetSuperClassActualTypeParameters( const Types &actualTypeParameters )
346 {
347 this->superClassActualTypeParameters = actualTypeParameters;
348 }
349
350 // Blittable型
351 bool IsBlittableType() const
352 {
353 return !blittableType.IsNull();
354 }
355 const Type &GetBlittableType() const
356 {
357 return blittableType;
358 }
359 void SetBlittableType( const Type &type ){
360 blittableType = type;
361 }
362
363 bool IsClass() const;
364 bool IsInterface() const;
365 bool IsComInterface() const;
366 bool IsEnum() const;
367 bool IsDelegate() const;
368 bool IsStructure() const;
369 void SetClassType( ClassType classType )
370 {
371 this->classType = classType;
372 }
373
374
375 //コンストラクタをコンパイルしているかどうかのチェックフラグ
376private:
377 mutable bool isCompilingConstructor;
378public:
379 void NotifyStartConstructorCompile() const;
380 void NotifyFinishConstructorCompile() const;
381 bool IsCompilingConstructor() const;
382
383 //デストラクタをコンパイルしているかどうかのチェックフラグ
384private:
385 mutable bool isCompilingDestructor;
386public:
387 void NotifyStartDestructorCompile() const;
388 void NotifyFinishDestructorCompile() const;
389 bool IsCompilingDestructor() const;
390
391
392 //自身の派生クラスかどうかを確認
393 bool IsSubClass( const CClass *pClass ) const;
394
395 //自身と等しいまたは派生クラスかどうかを確認
396 bool IsEqualsOrSubClass( const CClass *pClass ) const;
397
398 // 自身と等しいまたは派生クラス、基底クラスかどうかを確認
399 bool IsEqualsOrSubClassOrSuperClass( const CClass &objClass ) const;
400
401 // インターフェイス
402 bool HasInterfaces() const
403 {
404 return ( interfaces.size() != 0 );
405 }
406 const Interfaces &GetInterfaces() const
407 {
408 return interfaces;
409 }
410 bool IsInheritsInterface( const CClass *pInterfaceClass ) const;
411
412 // クラス継承
413 bool Inherits( const char *inheritNames, int nowLine );
414 bool InheritsClass( const CClass &inheritsClass, const Types &actualTypeParameters, int nowLine );
415 bool InheritsInterface( const CClass &inheritsClass, int nowLine );
416
417 // インターフェイス実装
418 bool Implements( const CClass &interfaceClass, const Types &actualTypeParameters, int nowLine );
419 bool Implements( const char *interfaceNames, int nowLine );
420
421 //メンバ、メソッドの追加
422 CMember *CreateMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine );
423 void AddMember( Prototype::Accessibility accessibility, bool idConst, bool isRef, char *buffer, int nowLine );
424 void AddStaticMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine );
425
426 void AddMethod(CClass *pobj_c, Prototype::Accessibility accessibility, BOOL bStatic, bool isConst, bool isAbstract,
427 bool isVirtual, bool isOverride, bool isAutoGeneration, char *buffer, int nowLine);
428
429 //重複チェック
430 bool DupliCheckAll(const char *name) const;
431 bool DupliCheckMember(const char *name) const;
432
433 const Members &GetDynamicMembers() const
434 {
435 return dynamicMembers;
436 }
437 const Members &GetStaticMembers() const
438 {
439 return staticMembers;
440 }
441 Members &GetDynamicMembers()
442 {
443 return dynamicMembers;
444 }
445 Members &GetStaticMembers()
446 {
447 return staticMembers;
448 }
449
450 const CMember *FindDynamicMember( const char *memberName ) const;
451 bool HasDynamicMember( const char *memberName ) const
452 {
453 return ( FindDynamicMember( memberName ) != NULL );
454 }
455
456 void EnumDynamicMethodsOrInterfaceMethods( const char *methodName, std::vector<const UserProc *> &subs ) const;
457 const CMethod *GetDynamicMethodOrInterfaceMethod( const UserProc *pUserProc ) const;
458
459 const Methods &GetStaticMethods() const
460 {
461 return staticMethods;
462 }
463 Methods &GetStaticMethods()
464 {
465 return staticMethods;
466 }
467
468 //デフォルト コンストラクタ
469 const CMethod *GetConstructorMethod() const
470 {
471 if( ConstructorMemberSubIndex == -1 ) return NULL;
472 return GetDynamicMethods()[ConstructorMemberSubIndex];
473 }
474 void SetConstructorMemberSubIndex( int constructorMemberSubIndex )
475 {
476 this->ConstructorMemberSubIndex = constructorMemberSubIndex;
477 }
478
479 //デストラクタ メソッドを取得
480 const CMethod *GetDestructorMethod() const
481 {
482 if( DestructorMemberSubIndex == -1 ) return NULL;
483 return GetDynamicMethods()[DestructorMemberSubIndex];
484 }
485 void SetDestructorMemberSubIndex( int destructorMemberSubIndex )
486 {
487 this->DestructorMemberSubIndex = destructorMemberSubIndex;
488 }
489
490 // デリゲート情報を取得
491 const ::Delegate &GetDelegate() const;
492
493 // ユーザ指定のアラインメント固定値
494 int GetFixedAlignment() const
495 {
496 return fixedAlignment;
497 }
498 void SetFixedAlignment( int fixedAlignment )
499 {
500 this->fixedAlignment = fixedAlignment;
501 }
502
503 // メンバの総合サイズを取得
504private:
505 int cacheSize;
506public:
507 int GetSize() const;
508
509 // メンバのオフセットを取得
510 int GetMemberOffset( const char *memberName ) const;
511private:
512 // アラインメント値を取得
513 int GetAlignment() const;
514
515
516 /////////////////////////////////////////////////////////////////
517 // vtbl
518 /////////////////////////////////////////////////////////////////
519public:
520 // vtblに存在する仮想関数の数
521 int GetVtblNum() const
522 {
523 return vtblNum;
524 }
525 void SetVtblNum( int vtblNum )
526 {
527 this->vtblNum = vtblNum;
528 }
529 void AddVtblNum( int vtblNum )
530 {
531 this->vtblNum += vtblNum;
532 }
533 bool IsExistVirtualFunctions() const
534 {
535 // 構造体以外は仮想関数を持つ
536 return !IsStructure();
537 }
538
539private:
540 long vtbl_offset;
541 long comVtblOffset;
542 long vtblMasterListOffset;
543 std::vector<long> vtblMasterList;
544public:
545 void GetVtblMasterListIndexAndVtblIndex( const UserProc *pUserProc, int &vtblMasterListIndex, int &vtblIndex ) const;
546 int GetVtblMasterListIndex( const CClass *pClass ) const;
547 long GetComVtblOffset() const;
548 long GetVtblMasterListOffset() const;
549 void GenerateVTableMasterList( const std::vector<long> &vtableMasterList, long &offset );
550 void GenerateFullVTables();
551 void ActionVtblSchedule( LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection, LONG_PTR MemPos_DataSection );
552 bool IsAbstract() const;
553
554
555 // TypeInfo用
556 mutable int typeInfoDataTableOffset;
557 void SetTypeInfoDataTableOffset( int typeInfoDataTableOffset ) const
558 {
559 this->typeInfoDataTableOffset = typeInfoDataTableOffset;
560 }
561 int GetTypeInfoDataTableOffset() const
562 {
563 return typeInfoDataTableOffset;
564 }
565
566 // 動的型データ用のメンバデータを取得
567 std::string GetStaticDefiningStringAsMemberNames() const;
568 std::string GetStaticDefiningStringAsMemberTypeInfoNames() const;
569 std::string GetStaticDefiningStringAsMemberOffsets() const;
570 void GetReferenceOffsetsInitializeBuffer( std::string &referenceOffsetsBuffer, int &numOfReference, int baseOffset = 0 ) const;
571
572
573 //線形リスト用
574 CClass *pobj_NextClass;
575};
576
577class Classes : public Jenga::Common::Hashmap<CClass>
578{
579 // XMLシリアライズ用
580public:
581 Classes()
582 : pCompilingMethod( NULL )
583 , pStringClass( NULL )
584 , pObjectClass( NULL )
585 , pInterfaceInfo( NULL )
586 {
587 }
588 ~Classes()
589 {
590 }
591
592 virtual CClass *Create( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const char *name);
593 bool Insert( CClass *pClass, int nowLine );
594 CClass *Add( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const char *name,int nowLine);
595 virtual void CollectClassesForNameOnly( const BasicSource &source );
596
597 // vtblを一時的に生成
598 void GenerateVTables();
599
600 // vtblのを正規のオフセットで再構築
601 void ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection, LONG_PTR MemPos_DataSection );
602
603 virtual void InitStaticMember();
604
605private:
606 bool MemberVar_LoopRefCheck(const CClass &objClass);
607public:
608 virtual void GetClass_recur(const char *lpszInheritsClass);
609 void LookaheadClass( const char *className );
610 bool LoopRefCheck( const CClass &objClass );
611 virtual void GetAllClassInfo();
612 virtual void Compile_System_InitializeUserTypes();
613 virtual void Compile_System_InitializeUserTypesForBaseType();
614
615 const CClass *Find( const NamespaceScopes &namespaceScopes, const string &name ) const;
616 const CClass *Find( const string &fullName ) const;
617
618
619 /////////////////////////////
620 // 現在コンパイル中の情報
621 /////////////////////////////
622private:
623 const CMethod *pCompilingMethod;
624public:
625 void StartCompile( const UserProc *pUserProc );
626
627 //現在コンパイル中のメソッド情報を取得
628 const CMethod *GetNowCompilingMethodInfo(){
629 return pCompilingMethod;
630 }
631
632
633 /////////////////////////////
634 // 特殊クラス
635 /////////////////////////////
636 mutable const CClass *pStringClass;
637 mutable const CClass *pObjectClass;
638 mutable const CClass *pInterfaceInfo;
639 const CClass *GetStringClassPtr() const;
640 const CClass *GetObjectClassPtr() const;
641 const CClass *GetInterfaceInfoClassPtr() const;
642};
Note: See TracBrowser for help on using the repository browser.