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

Last change on this file since 723 was 723, checked in by dai, 16 years ago

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