source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Class.cpp@ 650

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

リンカの依存関係解決モジュールを製作中
File size: 38.9 KB
Line 
1#include "stdafx.h"
2
3#include "../common.h"
4#ifdef _AMD64_
5#include "../../compiler_x64/opcode.h"
6#else
7#include "../../compiler_x86/opcode.h"
8#endif
9
10using namespace ActiveBasic::Compiler;
11
12
13void LexicalAnalyzer::CollectClassesForNameOnly( const char *source, Classes &classes )
14{
15 int i, i2;
16 char temporary[VN_SIZE];
17
18 // 名前空間管理
19 NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
20 namespaceScopes.clear();
21
22 // Importsされた名前空間の管理
23 NamespaceScopesCollection &importedNamespaces = compiler.GetNamespaceSupporter().GetImportedNamespaces();
24 importedNamespaces.clear();
25
26 for(i=0;;i++){
27 if(source[i]=='\0') break;
28
29 if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
30 for(i+=2,i2=0;;i2++,i++){
31 if( IsCommandDelimitation( source[i] ) ){
32 temporary[i2]=0;
33 break;
34 }
35 temporary[i2]=source[i];
36 }
37 namespaceScopes.push_back( temporary );
38
39 continue;
40 }
41 else if( source[i] == 1 && source[i+1] == ESC_ENDNAMESPACE ){
42 if( namespaceScopes.size() <= 0 ){
43 compiler.errorMessenger.Output(12, "End Namespace", i );
44 }
45 else{
46 namespaceScopes.pop_back();
47 }
48
49 i += 2;
50 continue;
51 }
52 else if( source[i] == 1 && source[i+1] == ESC_IMPORTS ){
53 for(i+=2,i2=0;;i2++,i++){
54 if( IsCommandDelimitation( source[i] ) ){
55 temporary[i2]=0;
56 break;
57 }
58 temporary[i2]=source[i];
59 }
60 if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
61 {
62 compiler.errorMessenger.Output(64,temporary,i );
63 }
64
65 continue;
66 }
67 else if( source[i] == 1 && source[i+1] == ESC_CLEARNAMESPACEIMPORTED ){
68 importedNamespaces.clear();
69 continue;
70 }
71
72 if(source[i]==1&&(
73 source[i+1]==ESC_CLASS||
74 source[i+1]==ESC_TYPE||
75 source[i+1]==ESC_INTERFACE
76 ))
77 {
78 int nowLine = i;
79 i += 2;
80
81 Type blittableType;
82 if(memicmp(source+i,"Align(",6)==0){
83 //アラインメント修飾子
84 i+=6;
85 i=JumpStringInPare(source,i)+1;
86 }
87 else if( memicmp( source + i, "Blittable(", 10 ) == 0 ){
88 // Blittable修飾子
89 i+=10;
90 i+=GetStringInPare_RemovePare(temporary,source+i)+1;
91 compiler.StringToType( temporary, blittableType );
92 }
93
94 bool isEnum = false;
95 bool isDelegate = false;
96 if( source[i] == 1 && source[i+1] == ESC_ENUM ){
97 // 列挙型の場合
98 isEnum = true;
99
100 i += 2;
101 }
102 else if( source[i] == 1 && source[i+1] == ESC_DELEGATE )
103 {
104 // デリゲートの場合
105 isDelegate = true;
106
107 i += 2;
108 }
109
110 for(i2=0;;i++,i2++){
111 if(!IsVariableChar(source[i])){
112 temporary[i2]=0;
113 break;
114 }
115 temporary[i2]=source[i];
116 }
117
118 //クラスを追加
119 CClass *pClass = new CClass( Symbol( namespaceScopes, temporary ), importedNamespaces );
120 if( classes.IsExist( pClass ) )
121 {
122 // 既に存在している
123 compiler.errorMessenger.Output(15,pClass->GetName(), nowLine);
124
125 delete pClass;
126
127 continue;
128 }
129
130 classes.Put( pClass );
131
132 if( source[nowLine+1] == ESC_CLASS )
133 {
134 if( isEnum )
135 {
136 pClass->SetClassType( CClass::Enum );
137 }
138 else if( isDelegate )
139 {
140 pClass->SetClassType( CClass::Delegate );
141 }
142 else{
143 pClass->SetClassType( CClass::Class );
144 }
145 }
146 else if( source[nowLine+1] == ESC_INTERFACE )
147 {
148 pClass->SetClassType( CClass::Interface );
149 }
150 else
151 {
152 pClass->SetClassType( CClass::Structure );
153 }
154
155 // Blittable型の場合
156 if( !blittableType.IsNull() ){
157 pClass->SetBlittableType( blittableType );
158
159 // Blittable型として登録
160 compiler.GetObjectModule().meta.GetBlittableTypes().push_back( BlittableType( blittableType, pClass ) );
161 }
162 }
163 }
164}
165
166
167class CLoopRefCheck{
168 char **names;
169 int num;
170 void init(){
171 int i;
172 for(i=0;i<num;i++){
173 free(names[i]);
174 }
175 free(names);
176 }
177public:
178 CLoopRefCheck()
179 {
180 names=(char **)malloc(1);
181 num=0;
182 }
183 ~CLoopRefCheck()
184 {
185 init();
186 }
187 void add(const char *lpszInheritsClass)
188 {
189 names=(char **)realloc(names,(num+1)*sizeof(char *));
190 names[num]=(char *)malloc(lstrlen(lpszInheritsClass)+1);
191 lstrcpy(names[num],lpszInheritsClass);
192 num++;
193 }
194 void del(const char *lpszInheritsClass)
195 {
196 int i;
197 for(i=0;i<num;i++){
198 if(lstrcmp(names[i],lpszInheritsClass)==0){
199 free(names[i]);
200 break;
201 }
202 }
203 if(i!=num){
204 num--;
205 for(;i<num;i++){
206 names[i]=names[i+1];
207 }
208 }
209 }
210 BOOL check(const CClass &inheritsClass) const
211 {
212 //ループ継承チェック
213 int i;
214 for(i=0;i<num;i++){
215 if( inheritsClass.GetName() == names[i] ){
216 return 1;
217 }
218 }
219 return 0;
220 }
221};
222CLoopRefCheck *pobj_LoopRefCheck;
223
224bool MemberVar_LoopRefCheck(const CClass &objClass){
225 if( objClass.HasSuperClass() )
226 {
227 // 基底クラスをチェック
228 if( MemberVar_LoopRefCheck( objClass.GetSuperClass() ) == false )
229 {
230 return false;
231 }
232 }
233
234 bool result = true;
235 BOOST_FOREACH( Member *pMember, objClass.GetDynamicMembers() ){
236 if(pMember->GetType().IsStruct()){
237 //循環参照でないかをチェック
238 if(pobj_LoopRefCheck->check(pMember->GetType().GetClass())){
239 extern int cp;
240 compiler.errorMessenger.Output(124,pMember->GetType().GetClass().GetName(),cp);
241 return false;
242 }
243
244 pobj_LoopRefCheck->add(objClass.GetName().c_str());
245
246 bool tempResult = MemberVar_LoopRefCheck(pMember->GetType().GetClass());
247 if( result )
248 {
249 result = tempResult;
250 }
251
252 pobj_LoopRefCheck->del(objClass.GetName().c_str());
253 }
254 }
255
256 return result;
257}
258
259void OverrideErrorCheck( const DynamicMethod::OverrideResult &result )
260{
261 switch( result.enumType )
262 {
263 case DynamicMethod::OverrideResult::Successful:
264 break;
265 case DynamicMethod::OverrideResult::NotVirtual:
266 compiler.errorMessenger.Output(136, result.pMethod->GetUserProc().GetName(), cp);
267 break;
268 case DynamicMethod::OverrideResult::NotUseOverrideModifier:
269 compiler.errorMessenger.Output(127, result.pMethod->GetUserProc().GetName(), cp);
270 break;
271 case DynamicMethod::OverrideResult::DifferentAccesibility:
272 compiler.errorMessenger.Output(128, result.pMethod->GetUserProc().GetName(), cp);
273 break;
274 default:
275 throw;
276 }
277}
278
279Member *LexicalAnalyzer::CreateMember( const CClass &_class, Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine )
280{
281 extern int cp;
282
283 //構文を解析
284 char VarName[VN_SIZE];
285 char initBuffer[VN_SIZE];
286 char lpszConstructParameter[VN_SIZE];
287 Subscripts subscripts;
288 Type type;
289 if( !GetDimentionFormat(buffer,VarName,subscripts,type,initBuffer,lpszConstructParameter) )
290 {
291 return NULL;
292 }
293
294 //重複チェック
295 if( _class.DupliCheckAll( VarName ) ){
296 compiler.errorMessenger.Output(15,VarName,cp);
297 }
298
299 Member *pMember = new Member( accessibility, VarName, type, isConst, subscripts, initBuffer, lpszConstructParameter );
300 pMember->source_code_address = nowLine;
301 return pMember;
302}
303
304void LexicalAnalyzer::AddMethod(CClass *pobj_c, UserProc *pUserProc, Prototype::Accessibility accessibility, BOOL bStatic, bool isConst, bool isAbstract,
305 bool isVirtual, bool isOverride, const char *interfaceName, bool isAutoGeneration, int nowLine)
306{
307 if( isAutoGeneration )
308 {
309 // コード自動生成
310 pUserProc->ThisIsAutoGenerationProc();
311 }
312
313
314 ////////////////////////////////////////////////////////////
315 // コンストラクタ、デストラクタの場合の処理
316 ////////////////////////////////////////////////////////////
317 BOOL fConstructor=0,bDestructor=0;
318
319 if( pUserProc->GetName() == pobj_c->GetName() ){
320 //コンストラクタの場合
321
322 //標準コンストラクタ（引数なし）
323 if(pUserProc->Params().size()==0) fConstructor=1;
324
325 //強制的にConst修飾子をつける
326 isConst = true;
327 }
328 else if(pUserProc->GetName()[0]=='~'){
329 //デストラクタの場合はその名前が正しいかチェックを行う
330 if(lstrcmp(pUserProc->GetName().c_str()+1,pobj_c->GetName().c_str())!=0)
331 compiler.errorMessenger.Output(117,NULL,nowLine);
332 else
333 bDestructor=1;
334 }
335 if(fConstructor||bDestructor){
336 // コンストラクタ、デストラクタのアクセシビリティをチェック
337
338 //強制的にConst修飾子をつける
339 isConst = true;
340 }
341
342 if( fConstructor == 1 )
343 pobj_c->SetConstructorMemberSubIndex( (int)pobj_c->GetDynamicMethods().size() );
344 else if( bDestructor )
345 pobj_c->SetDestructorMemberSubIndex( (int)pobj_c->GetDynamicMethods().size() );
346
347
348
349 //////////////////
350 // 重複チェック
351 //////////////////
352
353 if(pobj_c->DupliCheckMember( pUserProc->GetName().c_str() )){
354 compiler.errorMessenger.Output(15,pUserProc->GetName(),nowLine);
355 return;
356 }
357
358 //メソッド
359 BOOST_FOREACH( const CMethod *pMethod, pobj_c->GetDynamicMethods() )
360 {
361 //基底クラスと重複する場合はオーバーライドを行う
362 if( pMethod->GetInheritsClassPtr() ) continue;
363
364 if( pMethod->GetUserProc().IsEqualForOverride( pobj_c->GetSuperClassActualTypeParameters(), pUserProc ) )
365 {
366 //関数名、パラメータ、戻り値が合致したとき
367 compiler.errorMessenger.Output(15,pUserProc->GetName().c_str(),nowLine);
368 return;
369 }
370 }
371
372 //仮想関数の場合
373 if( isAbstract ) pUserProc->CompleteCompile();
374
375 // メソッドのオーバーライド
376 DynamicMethod *pMethodForOverride = pobj_c->GetDynamicMethods().FindForOverride( pobj_c->GetSuperClassActualTypeParameters(), pUserProc );
377 if( pMethodForOverride )
378 {
379 DynamicMethod::OverrideResult result;
380 result.enumType = pMethodForOverride->Override( pUserProc, accessibility, isOverride );
381 result.pMethod = pMethodForOverride;
382 OverrideErrorCheck( result );
383
384 pUserProc->SetMethod( pMethodForOverride );
385 return;
386 }
387 else
388 {
389 // インターフェイス メソッドのオーバーライド
390 BOOST_FOREACH( ::Interface *pInterface, pobj_c->GetInterfaces() )
391 {
392 if( interfaceName[0] )
393 {
394 if( pInterface->GetClass().GetName() != interfaceName )
395 {
396 // 指定されたインターフェイス名と整合しないとき
397 continue;
398 }
399 }
400
401 if( !pInterface->GetClass().IsReady() ){
402 // インターフェイスが未解析のとき
403 LexicalAnalyzer::LookaheadClass(
404 pInterface->GetClass().GetName().c_str(),
405 compiler.GetObjectModule().meta.GetClasses()
406 );
407 }
408
409 DynamicMethod *pMethodForOverride = pInterface->GetDynamicMethods().FindForOverride( pInterface->GetActualTypeParameters(), pUserProc );
410 if( pMethodForOverride )
411 {
412 DynamicMethod::OverrideResult result;
413 result.enumType = pMethodForOverride->Override( pUserProc, accessibility, isOverride );
414 result.pMethod = pMethodForOverride;
415 OverrideErrorCheck( result );
416
417 pUserProc->SetMethod( pMethodForOverride );
418 return;
419 }
420 }
421 }
422
423 if( interfaceName[0] )
424 {
425 compiler.errorMessenger.Output(139,interfaceName,nowLine);
426 }
427
428 if( isVirtual ){
429 pobj_c->AddVtblNum( 1 );
430 }
431
432 if( isOverride ){
433 compiler.errorMessenger.Output(12,"Override",nowLine);
434 }
435
436 if(bStatic){
437 pobj_c->GetStaticMethods().AddStatic( pUserProc, accessibility );
438 }
439 else{
440 pobj_c->GetDynamicMethods().Add(pUserProc, accessibility, isConst, isAbstract, isVirtual);
441 }
442}
443
444bool LexicalAnalyzer::Inherits( CClass &_class, const char *inheritNames, int nowLine ){
445 int i = 0;
446 bool isInheritsClass = false;
447 while( true ){
448
449 char temporary[VN_SIZE];
450 for( int i2=0;; i++, i2++ ){
451 if( inheritNames[i] == '\0' || inheritNames[i] == ',' ){
452 temporary[i2] = 0;
453 break;
454 }
455 temporary[i2] = inheritNames[i];
456 }
457
458 // ジェネリクス構文を分解
459 char className[VN_SIZE];
460 Jenga::Common::Strings typeParameterStrings;
461 SplitGenericClassInstance( temporary, className, typeParameterStrings );
462
463 // 型パラメータ文字列から型データを取得
464 Types actualTypeParameters;
465 BOOST_FOREACH( const std::string &typeParameterStr, typeParameterStrings )
466 {
467 Type type;
468 compiler.StringToType( typeParameterStr, type );
469 actualTypeParameters.push_back( type );
470 }
471
472 //継承元クラスを取得
473 const CClass *pInheritsClass = compiler.GetObjectModule().meta.FindClassSupportedTypeDef(
474 LexicalAnalyzer::FullNameToSymbol( className )
475 );
476 if( !pInheritsClass ){
477 compiler.errorMessenger.Output(106,className,nowLine);
478 return false;
479 }
480
481 if( pInheritsClass->IsClass() ){
482 // クラスを継承する
483 isInheritsClass = true;
484
485 //ループ継承でないかをチェック
486 if( !LexicalAnalyzer::LoopRefCheck(*pInheritsClass) )
487 {
488 compiler.errorMessenger.Output(123,pInheritsClass->GetName(),nowLine);
489 return false;
490 }
491
492 if( !pInheritsClass->IsReady() ){
493 //継承先が読み取られていないとき
494 LexicalAnalyzer::LookaheadClass(
495 pInheritsClass->GetName().c_str(),
496 compiler.GetObjectModule().meta.GetClasses()
497 );
498 }
499
500 if( !_class.InheritsClass( *pInheritsClass, actualTypeParameters, nowLine ) ){
501 return false;
502 }
503 }
504 else{
505 compiler.errorMessenger.Output(135,pInheritsClass->GetFullName().c_str(),nowLine);
506 return false;
507 }
508
509 if( inheritNames[i] == '\0' ){
510 break;
511 }
512 i++;
513 }
514
515 if( !isInheritsClass ){
516 const CClass *pObjectClass = compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr();
517 //ループ継承でないかをチェック
518 if( !LexicalAnalyzer::LoopRefCheck( *pObjectClass ) )
519 {
520 compiler.errorMessenger.Output(123,pObjectClass->GetName(),nowLine);
521 return false;
522 }
523
524 if( !pObjectClass->IsReady() ){
525 //継承先が読み取られていないとき
526 LexicalAnalyzer::LookaheadClass(
527 pObjectClass->GetName().c_str(),
528 compiler.GetObjectModule().meta.GetClasses()
529 );
530 }
531
532 // クラスを一つも継承していないとき
533 if( !_class.InheritsClass( *pObjectClass, Types(), nowLine ) ){
534 return false;
535 }
536 }
537
538 return true;
539}
540
541void LexicalAnalyzer::Implements( CClass &_class, Interface *pInterface, std::vector<DynamicMethod::OverrideResult> &overrideResults )
542{
543 _class.AddInterface( pInterface );
544
545
546 /////////////////////////////////////////////////////////////////
547 // 基底クラスのメソッドからインターフェイスメソッドを再実装する
548 /////////////////////////////////////////////////////////////////
549 BOOST_FOREACH( CMethod *pMethod, _class.GetDynamicMethods() )
550 {
551 DynamicMethod *pMethodForOverride = pInterface->GetDynamicMethods().FindForOverride( pInterface->GetActualTypeParameters(), &pMethod->GetUserProc() );
552 if( pMethodForOverride )
553 {
554 DynamicMethod::OverrideResult result;
555 result.enumType = pMethodForOverride->Override( &pMethod->GetUserProc(), pMethod->GetAccessibility(), false );
556 result.pMethod = pMethod;
557 overrideResults.push_back( result );
558
559 // 実装元になるメソッドは呼び出し不可にしておく（オーバーロードの解決から除外する）
560 pMethod->SetNotUseMark( true );
561 }
562 }
563
564
565 /////////////////////////////////////////////////////////////////
566 // キャストメソッドを追加（内部コードは自動生成すること）
567 // ※COMインターフェイスは除外すること
568 /////////////////////////////////////////////////////////////////
569 if( pInterface->GetClass().IsInterface() )
570 {
571 // Function Operator() As ITest
572
573 char methodName[255] = { 1, ESC_OPERATOR, CALC_AS, '\0' };
574
575 //関数ハッシュへ登録
576 UserProc *pUserProc = new UserProc(
577 Symbol( NamespaceScopes(), methodName ),
578 NamespaceScopesCollection(),
579 Procedure::Function,
580 false,
581 false,
582 false );
583 pUserProc->SetParentClass( &_class );
584
585 Parameters params;
586 params.push_back( new Parameter( "_System_LocalThis", Type( DEF_PTR_VOID ) ) );
587 pUserProc->SetRealParams( params );
588
589 pUserProc->SetReturnType( Type( DEF_OBJECT, pInterface->GetClass() ) );
590 pUserProc->_paramStr = "";
591 pUserProc->Using();
592
593 // 関数を追加
594 if( compiler.GetObjectModule().meta.GetUserProcs().IsExist( pUserProc ) )
595 {
596 // 既に存在している
597 compiler.errorMessenger.Output(15,pUserProc->GetName(),-1);
598
599 delete pUserProc;
600 }
601 else
602 {
603 compiler.GetObjectModule().meta.GetUserProcs().Put( pUserProc );
604 }
605
606 LexicalAnalyzer::AddMethod(
607 &_class,
608 pUserProc,
609 Prototype::Public,
610 0,
611 false, // isConst
612 false, // isAbstract
613 false, // isVirtual
614 false, // isOverride
615 "",
616 true, // isAutoGeneration
617 -1
618 );
619 }
620}
621
622bool LexicalAnalyzer::Implements( CClass &_class, const char *interfaceNames, int nowLine )
623{
624 Jenga::Common::Strings paramStrs;
625 SplitParameter( interfaceNames, paramStrs );
626
627 BOOST_FOREACH( const std::string &paramStr, paramStrs )
628 {
629 char className[VN_SIZE];
630 Jenga::Common::Strings typeParameterStrings;
631 SplitGenericClassInstance( paramStr.c_str(), className, typeParameterStrings );
632
633 Types actualTypeParameters;
634 BOOST_FOREACH( const std::string &typeParameterStr, typeParameterStrings )
635 {
636 Type type;
637 compiler.StringToType( typeParameterStr, type );
638 actualTypeParameters.push_back( type );
639 }
640
641 //継承元クラスを取得
642 const CClass *pInterfaceClass = compiler.GetObjectModule().meta.FindClassSupportedTypeDef(
643 LexicalAnalyzer::FullNameToSymbol( className )
644 );
645 if( !pInterfaceClass ){
646 compiler.errorMessenger.Output(106,paramStr.c_str(),nowLine);
647 continue;
648 }
649
650 if( !pInterfaceClass->IsReady() ){
651 // インターフェイスが未解析のとき
652 LexicalAnalyzer::LookaheadClass(
653 pInterfaceClass->GetName().c_str(),
654 compiler.GetObjectModule().meta.GetClasses()
655 );
656 }
657
658 if( pInterfaceClass->IsInterface() || pInterfaceClass->IsComInterface() )
659 {
660 // インターフェイスを継承する
661 std::vector<DynamicMethod::OverrideResult> overrideResults;
662 Implements(
663 _class,
664 new ::Interface( pInterfaceClass, actualTypeParameters ),
665 overrideResults
666 );
667
668 // エラーチェック
669 BOOST_FOREACH( const DynamicMethod::OverrideResult result, overrideResults )
670 {
671 OverrideErrorCheck( result );
672 }
673 }
674 else
675 {
676 // インターフェイスではないとき
677 compiler.errorMessenger.Output(138,pInterfaceClass->GetName().c_str(),nowLine );
678 }
679 }
680
681 return true;
682}
683
684void GetClass_recur( const char *lpszInheritsClass, Classes &classes )
685{
686 extern char *basbuf;
687 int i,i2,i3,sub_address,top_pos;
688 char temporary[8192];
689
690 // 名前空間管理
691 NamespaceScopes backupNamespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
692 NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
693 namespaceScopes.clear();
694
695 // Importsされた名前空間の管理
696 NamespaceScopesCollection backupImportedNamespaces = compiler.GetNamespaceSupporter().GetImportedNamespaces();
697 compiler.GetNamespaceSupporter().GetImportedNamespaces().clear();
698
699 // 呼び出し元でコンパイル中のクラスポインタをバックアップ
700 const CClass *pBackCompilingClass = compiler.IsCompilingClass()
701 ? &compiler.GetCompilingClass()
702 : NULL;
703
704 for(i=0;;i++){
705 if(basbuf[i]=='\0') break;
706
707
708 // 名前空間
709 if( basbuf[i] == 1 && basbuf[i+1] == ESC_NAMESPACE ){
710 for(i+=2,i2=0;;i2++,i++){
711 if( IsCommandDelimitation( basbuf[i] ) ){
712 temporary[i2]=0;
713 break;
714 }
715 temporary[i2]=basbuf[i];
716 }
717 namespaceScopes.push_back( temporary );
718
719 continue;
720 }
721 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_ENDNAMESPACE ){
722 if( namespaceScopes.size() <= 0 ){
723 compiler.errorMessenger.Output(12, "End Namespace", i );
724 }
725 else{
726 namespaceScopes.pop_back();
727 }
728
729 i += 2;
730 continue;
731 }
732
733 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_IMPORTS ){
734 for(i+=2,i2=0;;i2++,i++){
735 if( IsCommandDelimitation( basbuf[i] ) ){
736 temporary[i2]=0;
737 break;
738 }
739 temporary[i2]=basbuf[i];
740 }
741 if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
742 {
743 compiler.errorMessenger.Output(64,temporary,i );
744 }
745
746 continue;
747 }
748 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_CLEARNAMESPACEIMPORTED ){
749 compiler.GetNamespaceSupporter().GetImportedNamespaces().clear();
750 continue;
751 }
752
753
754
755 if(basbuf[i]==1&&basbuf[i+1]==ESC_INTERFACE){
756 //////////////////////////
757 // インターフェイス
758 //////////////////////////
759
760 top_pos=i;
761
762 i+=2;
763
764 //インターフェイス名を取得
765 GetCommandToken( temporary, basbuf, i );
766
767 char className[VN_SIZE];
768 Jenga::Common::Strings typeParameters;
769 Jenga::Common::Strings typeParameterBaseClassNames;
770 SplitGenericClassInstance( temporary, className, typeParameters, true, &typeParameterBaseClassNames );
771
772 CClass *pobj_c = const_cast<CClass *>( classes.FindEx( Symbol( namespaceScopes, className ) ) );
773 if(!pobj_c) continue;
774
775 compiler.SetCompilingClass( pobj_c );
776
777 if(lpszInheritsClass){
778 if(lstrcmp(lpszInheritsClass,pobj_c->GetName().c_str())!=0){
779 //継承先先読み用
780 continue;
781 }
782 }
783
784 if(pobj_c->IsReady()){
785 //既に先読みされているとき
786 continue;
787 }
788
789 /////////////////////////////////////////////////////////
790 // ☆★☆ ジェネリクスサポート ☆★☆
791 for( i2=0; i2<static_cast<int>(typeParameters.size()); i2++ )
792 {
793 Type baseType( DEF_OBJECT, *classes.GetObjectClassPtr() );
794 if( typeParameterBaseClassNames[i2].size() )
795 {
796 if( !compiler.StringToType( typeParameterBaseClassNames[i2], baseType ) )
797 {
798 compiler.errorMessenger.Output(106,typeParameterBaseClassNames[i2],i);
799 }
800 else if( !baseType.IsObject() )
801 {
802 compiler.errorMessenger.Output(106,typeParameterBaseClassNames[i2],i);
803 }
804 }
805
806 pobj_c->AddFormalGenericType( GenericType( typeParameters[i2], baseType ) );
807 }
808 /////////////////////////////////////////////////////////
809
810 pobj_c->Readed();
811
812 pobj_c->SetConstructorMemberSubIndex( -1 );
813 pobj_c->SetDestructorMemberSubIndex( -1 );
814
815 if( memcmp( basbuf+i+1, "__COM", 5 ) == 0 && IsCommandDelimitation( basbuf[i+1+5] ) )
816 {
817 // COMインターフェイス
818 pobj_c->SetClassType( CClass::ComInterface );
819
820 i += 6;
821 }
822
823 if(basbuf[i+1]==1&&basbuf[i+2]==ESC_INHERITS){
824 //継承を行う場合
825 for(i+=3,i2=0;;i++,i2++){
826 if(IsCommandDelimitation(basbuf[i])){
827 temporary[i2]=0;
828 break;
829 }
830 temporary[i2]=basbuf[i];
831 }
832
833 if(lstrcmpi(temporary,pobj_c->GetName().c_str())==0){
834 compiler.errorMessenger.Output(105,temporary,i);
835 goto Interface_InheritsError;
836 }
837
838 //継承元クラスを取得
839 const CClass *pInheritsClass = compiler.GetObjectModule().meta.FindClassSupportedTypeDef(
840 LexicalAnalyzer::FullNameToSymbol( temporary )
841 );
842 if( !pInheritsClass ){
843 compiler.errorMessenger.Output(106,temporary,i);
844 goto Interface_InheritsError;
845 }
846
847 //ループ継承でないかをチェック
848 if( !LexicalAnalyzer::LoopRefCheck( *pInheritsClass ) )
849 {
850 compiler.errorMessenger.Output(123,pInheritsClass->GetName(),i);
851 goto Interface_InheritsError;
852 }
853
854 //継承させる
855 if( !pobj_c->InheritsClass( *pInheritsClass, Types(), i ) ){
856 goto Interface_InheritsError;
857 }
858 }
859 else{
860 //継承無し
861 if( &pobj_c->GetSuperClass() || pobj_c->GetVtblNum() )
862 {
863 // TODO: ここに来ないことが実証できたらこの分岐は消す
864 Jenga::Throw( "GetClass_recur内の例外" );
865 }
866 }
867Interface_InheritsError:
868
869 //メンバ変数、関数を取得
870 while(1){
871 i++;
872
873 //エラー
874 if(basbuf[i]==1&&(basbuf[i+1]==ESC_CLASS||basbuf[i+1]==ESC_TYPE||basbuf[i+1]==ESC_INTERFACE)){
875 compiler.errorMessenger.Output(22,"Interface",i);
876 i--;
877 break;
878 }
879
880 if(basbuf[i]==1&&basbuf[i+1]==ESC_INHERITS){
881 compiler.errorMessenger.Output(111,NULL,i);
882 break;
883 }
884 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_IMPLEMENTS )
885 {
886 compiler.errorMessenger.Output(137, NULL, i );
887 break;
888 }
889
890 sub_address=i;
891
892 for(i2=0;;i++,i2++){
893 if(IsCommandDelimitation(basbuf[i])){
894 temporary[i2]=0;
895 break;
896 }
897 temporary[i2]=basbuf[i];
898 }
899 if(temporary[0]=='\0'){
900 if(basbuf[i]=='\0'){
901 i--;
902 compiler.errorMessenger.Output(22,"Interface",top_pos);
903 break;
904 }
905 continue;
906 }
907
908 //End Interface記述の場合
909 if(temporary[0]==1&&temporary[1]==ESC_ENDINTERFACE) break;
910
911 if(!(temporary[0]==1&&(
912 temporary[1]==ESC_SUB||temporary[1]==ESC_FUNCTION
913 ))){
914 compiler.errorMessenger.Output(1,NULL,i);
915 break;
916 }
917
918 //関数ハッシュへ登録
919 char interfaceName[VN_SIZE] = "";
920 UserProc *pUserProc = LexicalAnalyzer::ParseUserProc( NamespaceScopes(), NamespaceScopesCollection(), temporary,sub_address,true,pobj_c, false, interfaceName );
921 if( pUserProc )
922 {
923 // 関数を追加
924 if( compiler.GetObjectModule().meta.GetUserProcs().IsExist( pUserProc ) )
925 {
926 // 既に存在している
927 compiler.errorMessenger.Output(15,pUserProc->GetName(),i);
928
929 delete pUserProc;
930 }
931 else
932 {
933 compiler.GetObjectModule().meta.GetUserProcs().Put( pUserProc );
934 }
935
936 //メンバ関数を追加
937 LexicalAnalyzer::AddMethod(pobj_c,
938 pUserProc,
939 Prototype::Public, //Publicアクセス権
940 0, // bStatic
941 false, // isConst
942 true, // isAbstract
943 true, // isVirtual
944 false, // isOverride
945 interfaceName,
946 false, // isAutoGeneration
947 sub_address
948 );
949 }
950 }
951 }
952
953 if(basbuf[i]==1&&(basbuf[i+1]==ESC_CLASS||basbuf[i+1]==ESC_TYPE)){
954 //////////////////////////
955 // クラス
956 //////////////////////////
957
958 top_pos=i;
959
960 const DWORD dwClassType=basbuf[i+1];
961
962 i+=2;
963
964 int iAlign=0;
965 if(memicmp(basbuf+i,"Align(",6)==0){
966 //アラインメント修飾子
967 i+=6;
968 i+=GetStringInPare_RemovePare(temporary,basbuf+i)+1;
969 iAlign=atoi(temporary);
970
971 if( dwClassType != ESC_TYPE )
972 {
973 compiler.errorMessenger.Output(140,NULL,i);
974 }
975
976 if(!(iAlign==1||iAlign==2||iAlign==4||iAlign==8||iAlign==16))
977 compiler.errorMessenger.Output(51,NULL,i);
978 }
979 else if( memicmp( basbuf + i, "Blittable(", 10 ) == 0 ){
980 // Blittable修飾子
981 i+=10;
982 i=JumpStringInPare(basbuf,i)+1;
983
984 if( dwClassType != ESC_CLASS )
985 {
986 compiler.errorMessenger.Output(141,NULL,i);
987 }
988 }
989
990 if( basbuf[i] == 1 && basbuf[i+1] == ESC_ENUM )
991 {
992 // 列挙型の場合
993 i += 2;
994 }
995 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_DELEGATE )
996 {
997 // デリゲートの場合
998 i += 2;
999 }
1000
1001 //クラス名を取得
1002 GetCommandToken( temporary, basbuf, i );
1003
1004 char className[VN_SIZE];
1005 Jenga::Common::Strings typeParameters;
1006 Jenga::Common::Strings typeParameterBaseClassNames;
1007 SplitGenericClassInstance( temporary, className, typeParameters, true, &typeParameterBaseClassNames );
1008
1009 CClass *pobj_c = const_cast<CClass *>( classes.FindEx( Symbol( namespaceScopes, className ) ) );
1010 if(!pobj_c) continue;
1011
1012 compiler.SetCompilingClass( pobj_c );
1013
1014 if(lpszInheritsClass){
1015 if( pobj_c->GetName() != lpszInheritsClass ){
1016 //継承先先読み用
1017 continue;
1018 }
1019 }
1020
1021 if( lstrcmp(className,"Control")==0)
1022 {
1023 int test=0;
1024 }
1025
1026 if(pobj_c->IsReady()){
1027 //既に先読みされているとき
1028 continue;
1029 }
1030
1031
1032 /////////////////////////////////////////////////////////
1033 // ☆★☆ ジェネリクスサポート ☆★☆
1034 for( i2=0; i2<static_cast<int>(typeParameters.size()); i2++ )
1035 {
1036 Type baseType( DEF_OBJECT, *classes.GetObjectClassPtr() );
1037 if( typeParameterBaseClassNames[i2].size() )
1038 {
1039 if( !compiler.StringToType( typeParameterBaseClassNames[i2], baseType ) )
1040 {
1041 compiler.errorMessenger.Output(106,typeParameterBaseClassNames[i2],i);
1042 }
1043 else if( !baseType.IsObject() )
1044 {
1045 compiler.errorMessenger.Output(106,typeParameterBaseClassNames[i2],i);
1046 }
1047 }
1048
1049 pobj_c->AddFormalGenericType( GenericType( typeParameters[i2], baseType ) );
1050 }
1051 /////////////////////////////////////////////////////////
1052
1053
1054 pobj_c->SetFixedAlignment( iAlign );
1055
1056 pobj_c->Readed();
1057
1058 pobj_c->SetConstructorMemberSubIndex( -1 );
1059 pobj_c->SetDestructorMemberSubIndex( -1 );
1060
1061 //アクセス制限の初期値をセット
1062 Prototype::Accessibility accessibility;
1063 if(dwClassType==ESC_CLASS){
1064 accessibility = Prototype::Private;
1065 }
1066 else{
1067 accessibility = Prototype::Public;
1068 }
1069
1070 if( pobj_c->GetName() == "Object"
1071 || dwClassType == ESC_TYPE )
1072 {
1073 // 何も継承しない
1074
1075 if( &pobj_c->GetSuperClass() || pobj_c->GetVtblNum() )
1076 {
1077 // TODO: ここに来ないことが実証できたらこの分岐は消す
1078 Jenga::Throw( "GetClass_recur内の例外" );
1079 }
1080 }
1081 else{
1082 if(basbuf[i+1]==1&&basbuf[i+2]==ESC_INHERITS)
1083 {
1084 // クラス継承先が指定されているとき
1085 i += 3;
1086 GetCommandToken( temporary, basbuf, i );
1087
1088 if(lstrcmpi(temporary,pobj_c->GetName().c_str())==0){
1089 compiler.errorMessenger.Output(105,temporary,i);
1090 goto InheritsError;
1091 }
1092 }
1093 else
1094 {
1095 // 何の指定もないときはObjectクラスを継承する
1096 lstrcpy( temporary, "Object" );
1097 }
1098 LexicalAnalyzer::Inherits( *pobj_c, temporary, i );
1099
1100 if( basbuf[i+1] == 1 && basbuf[i+2] == ESC_IMPLEMENTS )
1101 {
1102 // インターフェイス実装を行う場合
1103 i += 3;
1104 GetCommandToken( temporary, basbuf, i );
1105
1106 LexicalAnalyzer::Implements( *pobj_c, temporary, i );
1107 }
1108 }
1109InheritsError:
1110
1111 //メンバとメソッドを取得
1112 while(1){
1113 i++;
1114
1115 //エラー
1116 if(basbuf[i]==1&&(basbuf[i+1]==ESC_CLASS||basbuf[i+1]==ESC_TYPE)){
1117 compiler.errorMessenger.Output(22,"Class",i);
1118 i--;
1119 break;
1120 }
1121
1122 if(basbuf[i]==1&&basbuf[i+1]==ESC_INHERITS){
1123 compiler.errorMessenger.Output(111,NULL,i);
1124 break;
1125 }
1126 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_IMPLEMENTS )
1127 {
1128 compiler.errorMessenger.Output(137, NULL, i );
1129 break;
1130 }
1131
1132 //Static修飾子
1133 BOOL bStatic;
1134 if(basbuf[i]==1&&basbuf[i+1]==ESC_STATIC){
1135 bStatic=1;
1136 i+=2;
1137 }
1138 else bStatic=0;
1139
1140 //Const修飾子
1141 bool isConst = false;
1142 if( basbuf[i] == 1 && basbuf[i + 1] == ESC_CONST ){
1143 isConst = true;
1144 i += 2;
1145 }
1146
1147 if(basbuf[i]==1&&(
1148 basbuf[i+1]==ESC_ABSTRACT||basbuf[i+1]==ESC_VIRTUAL||basbuf[i+1]==ESC_OVERRIDE||
1149 basbuf[i+1]==ESC_SUB||basbuf[i+1]==ESC_FUNCTION
1150 )){
1151 i3=basbuf[i+1];
1152 sub_address=i;
1153 }
1154 else i3=0;
1155
1156 bool isVirtual = false, isAbstract = false, isOverride = false;
1157 if(i3==ESC_ABSTRACT){
1158 isAbstract=1;
1159 isVirtual=1;
1160 i+=2;
1161
1162 i3=basbuf[i+1];
1163 }
1164 else if(i3==ESC_VIRTUAL){
1165 isAbstract=0;
1166 isVirtual=1;
1167 i+=2;
1168
1169 i3=basbuf[i+1];
1170 }
1171 else if(i3==ESC_OVERRIDE){
1172 isOverride=1;
1173 isVirtual=1;
1174
1175 i+=2;
1176
1177 i3=basbuf[i+1];
1178 }
1179
1180 for(i2=0;;i++,i2++){
1181 if(IsCommandDelimitation(basbuf[i])){
1182 temporary[i2]=0;
1183 break;
1184 }
1185 temporary[i2]=basbuf[i];
1186 }
1187 if(temporary[0]=='\0'){
1188 if(basbuf[i]=='\0'){
1189
1190 if(dwClassType==ESC_CLASS)
1191 compiler.errorMessenger.Output(22,"Class",top_pos);
1192 else
1193 compiler.errorMessenger.Output(22,"Type",top_pos);
1194
1195 i--;
1196 break;
1197 }
1198 continue;
1199 }
1200
1201 //End Class記述の場合
1202 if(temporary[0]==1&&temporary[1]==ESC_ENDCLASS&&dwClassType==ESC_CLASS) break;
1203 if(temporary[0]==1&&temporary[1]==ESC_ENDTYPE&&dwClassType==ESC_TYPE) break;
1204
1205 //アクセスを変更
1206 if(lstrcmpi(temporary,"Private")==0){
1207 accessibility = Prototype::Private;
1208 continue;
1209 }
1210 if(lstrcmpi(temporary,"Public")==0){
1211 accessibility = Prototype::Public;
1212 continue;
1213 }
1214 if(lstrcmpi(temporary,"Protected")==0){
1215 accessibility = Prototype::Protected;
1216 continue;
1217 }
1218
1219 extern int cp;
1220 if(i3==0){
1221 cp=i; //エラー用
1222 Member *pMember = LexicalAnalyzer::CreateMember( *pobj_c, accessibility, isConst, false, temporary, i );
1223 if( pMember )
1224 {
1225 if(bStatic)
1226 {
1227 //静的メンバを追加
1228 pobj_c->AddStaticMember( pMember );
1229 }
1230 else
1231 {
1232 //メンバを追加
1233 pobj_c->AddDynamicMember( pMember );
1234
1235
1236 if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
1237 if( !pobj_c->GetDynamicMembers().back()->GetType().GetClass().IsReady() ){
1238 //参照先が読み取られていないとき
1239 GetClass_recur( pobj_c->GetDynamicMembers().back()->GetType().GetClass().GetName().c_str(), classes );
1240 }
1241 }
1242
1243
1244 if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
1245 //循環参照のチェック
1246 pobj_LoopRefCheck->add(pobj_c->GetName().c_str());
1247 if(!MemberVar_LoopRefCheck(pobj_c->GetDynamicMembers().back()->GetType().GetClass())){
1248 //エラー回避
1249 Type &type = const_cast<Type &>(pobj_c->GetDynamicMembers().back()->GetType());
1250 type.SetBasicType( DEF_PTR_VOID );
1251 }
1252 pobj_LoopRefCheck->del(pobj_c->GetName().c_str());
1253 }
1254 }
1255 }
1256 }
1257 else{
1258 //関数ハッシュへ登録
1259 char interfaceName[VN_SIZE] = "";
1260 UserProc *pUserProc = LexicalAnalyzer::ParseUserProc( NamespaceScopes(), NamespaceScopesCollection(), temporary,sub_address,isVirtual,pobj_c, (bStatic!=0), interfaceName );
1261 if( pUserProc )
1262 {
1263 // 関数を追加
1264 if( compiler.GetObjectModule().meta.GetUserProcs().IsExist( pUserProc ) )
1265 {
1266 // 既に存在している
1267 compiler.errorMessenger.Output(15,pUserProc->GetName(),i);
1268
1269 delete pUserProc;
1270 }
1271 else
1272 {
1273 compiler.GetObjectModule().meta.GetUserProcs().Put( pUserProc );
1274 }
1275
1276 //メソッドを追加
1277 cp=i; //エラー用
1278 LexicalAnalyzer::AddMethod(pobj_c,
1279 pUserProc,
1280 accessibility,
1281 bStatic,
1282 isConst,
1283 isAbstract,
1284 isVirtual,
1285 isOverride,
1286 interfaceName,
1287 false,
1288 sub_address);
1289 }
1290
1291 if( isAbstract ) continue;
1292
1293 for(;;i++){
1294 if(basbuf[i]=='\0'){
1295 i--;
1296 break;
1297 }
1298 if(basbuf[i-1]!='*'&&
1299 basbuf[i]==1&&(
1300 basbuf[i+1]==ESC_SUB||
1301 basbuf[i+1]==ESC_FUNCTION||
1302 basbuf[i+1]==ESC_MACRO||
1303 basbuf[i+1]==ESC_TYPE||
1304 basbuf[i+1]==ESC_CLASS||
1305 basbuf[i+1]==ESC_INTERFACE||
1306 basbuf[i+1]==ESC_ENUM)){
1307 GetDefaultNameFromES(i3,temporary);
1308 compiler.errorMessenger.Output(22,temporary,i);
1309 }
1310 if(basbuf[i]==1&&basbuf[i+1]==GetEndXXXCommand((char)i3)){
1311 i+=2;
1312 break;
1313 }
1314 }
1315 }
1316 }
1317 }
1318 }
1319
1320 // 呼び出し元でコンパイル中のクラスポインタを元に戻す
1321 compiler.SetCompilingClass( pBackCompilingClass );
1322
1323 // 名前空間を元に戻す
1324 compiler.GetNamespaceSupporter().GetLivingNamespaceScopes() = backupNamespaceScopes;
1325
1326 // インポートされた名前空間を元に戻す
1327 compiler.GetNamespaceSupporter().GetImportedNamespaces() = backupImportedNamespaces;
1328}
1329
1330void LexicalAnalyzer::LookaheadClass( const char *className, Classes &classes )
1331{
1332 pobj_LoopRefCheck->add( className );
1333 GetClass_recur( className, classes );
1334 pobj_LoopRefCheck->del( className );
1335}
1336
1337bool LexicalAnalyzer::LoopRefCheck( const CClass &objClass )
1338{
1339 if( pobj_LoopRefCheck->check( objClass ) )
1340 {
1341 return false;
1342 }
1343
1344 return true;
1345}
1346
1347void LexicalAnalyzer::CollectClasses( const char *source, Classes &classes ){
1348 //ループ継承チェック用のクラス
1349 pobj_LoopRefCheck=new CLoopRefCheck();
1350
1351 //クラスを取得
1352 GetClass_recur( 0, classes );
1353
1354 delete pobj_LoopRefCheck;
1355 pobj_LoopRefCheck=0;
1356
1357 // イテレータの準備
1358 classes.Iterator_Init();
1359}
1360
1361void LexicalAnalyzer::TemplateExpand_ResolveMethod( const CMethod *pBaseMethod, const Types &actualTypes, CClass *pNewClass )
1362{
1363 UserProc *pUserProc = new UserProc(
1364 pBaseMethod->GetUserProc(),
1365 pNewClass
1366 );
1367 pUserProc->Using();
1368 pUserProc->GetParameters().clear();
1369 pUserProc->RealParams().clear();
1370
1371 // パラメータのジェネリック型を解決
1372 BOOST_FOREACH( const Parameter *pParam, pBaseMethod->GetUserProc().Params() )
1373 {
1374 Type type = pParam->IsTypeParameter()
1375 ? actualTypes[pParam->GetFormalTypeIndex()]
1376 : *pParam;
1377 type.SetPtrLevel( pParam->PtrLevel() );
1378
1379 pUserProc->GetParameters().push_back( new Parameter( *pParam, type ) );
1380 }
1381 BOOST_FOREACH( const Parameter *pParam, pBaseMethod->GetUserProc().RealParams() )
1382 {
1383 Type type = pParam->IsTypeParameter()
1384 ? actualTypes[pParam->GetFormalTypeIndex()]
1385 : *pParam;
1386 type.SetPtrLevel( pParam->PtrLevel() );
1387
1388 pUserProc->RealParams().push_back( new Parameter( *pParam, type ) );
1389 }
1390
1391 // 戻り値のジェネリック型を解決
1392 if( pUserProc->ReturnType().IsTypeParameter() )
1393 {
1394 Type type = actualTypes[pUserProc->ReturnType().GetFormalTypeIndex()];
1395 type.SetPtrLevel( pUserProc->ReturnType().PtrLevel() );
1396 pUserProc->SetReturnType( type );
1397 }
1398
1399 compiler.GetObjectModule().meta.GetUserProcs().Put( pUserProc );
1400 compiler.GetObjectModule().meta.GetUserProcs().Iterator_Init();
1401
1402 LexicalAnalyzer::AddMethod(
1403 pNewClass,
1404 pUserProc,
1405 pBaseMethod->GetAccessibility(),
1406 pBaseMethod->IsStatic(),
1407 pBaseMethod->IsConst(),
1408 pBaseMethod->IsAbstract(),
1409 pBaseMethod->IsVirtual(),
1410 false,
1411 "",
1412 false,
1413 -1
1414 );
1415}
1416
1417const CClass *LexicalAnalyzer::TemplateExpand( CClass &_class, const Types &actualTypes )
1418{
1419 // 展開済みのクラスがあればそれを返す
1420 BOOST_FOREACH( const ExpandedTemplateClass *pExpandedTemplateClass, _class.expandedTemplateClasses )
1421 {
1422 if( pExpandedTemplateClass->GetActualTypes().IsEquals( actualTypes ) )
1423 {
1424 return &pExpandedTemplateClass->GetClass();
1425 }
1426 }
1427
1428
1429 /////////////////////////////////////////////////////////////////
1430 // 未展開の場合は新たに展開する
1431 /////////////////////////////////////////////////////////////////
1432
1433 // クラスをコピー
1434 CClass *pNewClass = new CClass(
1435 _class,
1436 _class.GetImportedNamespaces(),
1437 _class.GetClassType(),
1438 _class.GetFormalGenericTypes(),
1439 actualTypes,
1440 _class.GetConstructorMemberSubIndex(),
1441 _class.GetDestructorMemberSubIndex(),
1442 0,
1443 _class.GetFixedAlignment()
1444 );
1445
1446 // 基底クラス
1447 pNewClass->SetSuperClass( &_class.GetSuperClass() );
1448
1449 // インターフェイスのジェネリック型を解決
1450 BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
1451 {
1452 pNewClass->AddInterface( new ::Interface( &pInterface->GetClass(), actualTypes ) );
1453 }
1454
1455 // メンバのジェネリック型を解決
1456 BOOST_FOREACH( const Member *pMember, _class.GetDynamicMembers() )
1457 {
1458 Type type = pMember->GetType();
1459 if( type.IsTypeParameter() )
1460 {
1461 // ジェネリック型だったときは値型に変換
1462 type = actualTypes[type.GetFormalTypeIndex()];
1463 type.SetPtrLevel( pMember->GetType().PtrLevel() );
1464 }
1465
1466 pNewClass->GetDynamicMembers().push_back(
1467 new Member( *pMember, type )
1468 );
1469 }
1470
1471 // クラス メソッドのジェネリック型を解決
1472 BOOST_FOREACH( const CMethod *pMethod, _class.GetDynamicMethods() )
1473 {
1474 if( pMethod->GetUserProc().GetParentClassPtr() == &_class )
1475 {
1476 // ターゲットクラス内で実装されるメソッドの場合
1477
1478 TemplateExpand_ResolveMethod( pMethod, actualTypes, pNewClass );
1479 }
1480 else
1481 {
1482 DynamicMethod *pNewDynamicMethod = new DynamicMethod( *pMethod );
1483 pNewClass->GetDynamicMethods().push_back( pNewDynamicMethod );
1484 }
1485 }
1486
1487 // インターフェイス メソッドのジェネリック型を解決
1488 BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
1489 {
1490 BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() )
1491 {
1492 TemplateExpand_ResolveMethod( pMethod, actualTypes, pNewClass );
1493 }
1494 }
1495
1496 pNewClass->SetVtblNum( _class.GetVtblNum() );
1497
1498 // 展開済みクラスとして登録
1499 _class.expandedTemplateClasses.push_back( new ExpandedTemplateClass( pNewClass, actualTypes ) );
1500
1501 pNewClass->Readed();
1502
1503 return pNewClass;
1504}
Note: See TracBrowser for help on using the repository browser.