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
RevLine 
[376]1#include "stdafx.h"
2
3#include "../common.h"
4#ifdef _AMD64_
[485]5#include "../../compiler_x64/opcode.h"
[376]6#else
[484]7#include "../../compiler_x86/opcode.h"
[376]8#endif
9
[511]10using namespace ActiveBasic::Compiler;
[376]11
[511]12
[546]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
[668]22 // Imports情報のクリア
23 compiler.GetNamespaceSupporter().ClearImportedNamespaces();
[546]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 }
[668]66 else if( source[i] == 1 && source[i+1] == ESC_CLEARNAMESPACEIMPORTED )
67 {
68 // Imports情報のクリア
69 compiler.GetNamespaceSupporter().ClearImportedNamespaces();
[546]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 //クラスを追加
[668]120 CClass *pClass = new CClass( Symbol( namespaceScopes, temporary ), compiler.GetNamespaceSupporter().GetImportedNamespaces() );
[564]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 );
[546]138 }
[564]139 else if( isDelegate )
140 {
141 pClass->SetClassType( CClass::Delegate );
[546]142 }
143 else{
[564]144 pClass->SetClassType( CClass::Class );
[546]145 }
146 }
[564]147 else if( source[nowLine+1] == ESC_INTERFACE )
148 {
149 pClass->SetClassType( CClass::Interface );
150 }
151 else
152 {
153 pClass->SetClassType( CClass::Structure );
154 }
[546]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
[376]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
[511]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 }
[376]234
[511]235 bool result = true;
[561]236 BOOST_FOREACH( Member *pMember, objClass.GetDynamicMembers() ){
[511]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
[558]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
[561]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;
[632]290 if( !GetDimentionFormat(buffer,VarName,subscripts,type,initBuffer,lpszConstructParameter) )
291 {
292 return NULL;
293 }
[561]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
[511]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)
[376]307{
[511]308 if( isAutoGeneration )
309 {
310 // コード自動生成
311 pUserProc->ThisIsAutoGenerationProc();
312 }
[376]313
314
[511]315 ////////////////////////////////////////////////////////////
316 // コンストラクタ、デストラクタの場合の処理
317 ////////////////////////////////////////////////////////////
318 BOOL fConstructor=0,bDestructor=0;
[376]319
[511]320 if( pUserProc->GetName() == pobj_c->GetName() ){
321 //コンストラクタの場合
[376]322
[511]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 // メソッドのオーバーライド
[558]377 DynamicMethod *pMethodForOverride = pobj_c->GetDynamicMethods().FindForOverride( pobj_c->GetSuperClassActualTypeParameters(), pUserProc );
[511]378 if( pMethodForOverride )
379 {
[558]380 DynamicMethod::OverrideResult result;
381 result.enumType = pMethodForOverride->Override( pUserProc, accessibility, isOverride );
382 result.pMethod = pMethodForOverride;
383 OverrideErrorCheck( result );
384
[511]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;
[376]399 }
400 }
401
[511]402 if( !pInterface->GetClass().IsReady() ){
403 // インターフェイスが未解析のとき
404 LexicalAnalyzer::LookaheadClass(
405 pInterface->GetClass().GetName().c_str(),
406 compiler.GetObjectModule().meta.GetClasses()
407 );
[376]408 }
409
[558]410 DynamicMethod *pMethodForOverride = pInterface->GetDynamicMethods().FindForOverride( pInterface->GetActualTypeParameters(), pUserProc );
[511]411 if( pMethodForOverride )
[376]412 {
[558]413 DynamicMethod::OverrideResult result;
414 result.enumType = pMethodForOverride->Override( pUserProc, accessibility, isOverride );
415 result.pMethod = pMethodForOverride;
416 OverrideErrorCheck( result );
417
[511]418 pUserProc->SetMethod( pMethodForOverride );
419 return;
[376]420 }
[511]421 }
422 }
[376]423
[511]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
[560]445bool LexicalAnalyzer::Inherits( CClass &_class, const char *inheritNames, int nowLine ){
[511]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];
[376]457 }
458
[511]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 )
[376]467 {
[511]468 Type type;
469 compiler.StringToType( typeParameterStr, type );
470 actualTypeParameters.push_back( type );
471 }
[376]472
[511]473 //継承元クラスを取得
[598]474 const CClass *pInheritsClass = compiler.GetObjectModule().meta.FindClassSupportedTypeDef(
475 LexicalAnalyzer::FullNameToSymbol( className )
476 );
[511]477 if( !pInheritsClass ){
478 compiler.errorMessenger.Output(106,className,nowLine);
479 return false;
480 }
[376]481
[511]482 if( pInheritsClass->IsClass() ){
483 // クラスを継承する
484 isInheritsClass = true;
[376]485
[511]486 //ループ継承でないかをチェック
487 if( !LexicalAnalyzer::LoopRefCheck(*pInheritsClass) )
[376]488 {
[511]489 compiler.errorMessenger.Output(123,pInheritsClass->GetName(),nowLine);
490 return false;
[376]491 }
492
[511]493 if( !pInheritsClass->IsReady() ){
494 //継承先が読み取られていないとき
495 LexicalAnalyzer::LookaheadClass(
496 pInheritsClass->GetName().c_str(),
497 compiler.GetObjectModule().meta.GetClasses()
498 );
[376]499 }
500
[560]501 if( !_class.InheritsClass( *pInheritsClass, actualTypeParameters, nowLine ) ){
[511]502 return false;
[376]503 }
[511]504 }
505 else{
506 compiler.errorMessenger.Output(135,pInheritsClass->GetFullName().c_str(),nowLine);
507 return false;
508 }
[376]509
[511]510 if( inheritNames[i] == '\0' ){
511 break;
[376]512 }
[511]513 i++;
[376]514 }
515
[511]516 if( !isInheritsClass ){
517 const CClass *pObjectClass = compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr();
518 //ループ継承でないかをチェック
519 if( !LexicalAnalyzer::LoopRefCheck( *pObjectClass ) )
[409]520 {
[511]521 compiler.errorMessenger.Output(123,pObjectClass->GetName(),nowLine);
[409]522 return false;
523 }
[511]524
525 if( !pObjectClass->IsReady() ){
526 //継承先が読み取られていないとき
527 LexicalAnalyzer::LookaheadClass(
528 pObjectClass->GetName().c_str(),
529 compiler.GetObjectModule().meta.GetClasses()
530 );
531 }
532
533 // クラスを一つも継承していないとき
[560]534 if( !_class.InheritsClass( *pObjectClass, Types(), nowLine ) ){
[511]535 return false;
536 }
[409]537 }
538
[511]539 return true;
540}
[376]541
[560]542void LexicalAnalyzer::Implements( CClass &_class, Interface *pInterface, std::vector<DynamicMethod::OverrideResult> &overrideResults )
[511]543{
[560]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(
[637]578 Symbol( NamespaceScopes(), methodName ),
[560]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
[574]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
[560]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{
[511]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 );
[376]633
[511]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 }
[376]641
[511]642 //継承元クラスを取得
[598]643 const CClass *pInterfaceClass = compiler.GetObjectModule().meta.FindClassSupportedTypeDef(
644 LexicalAnalyzer::FullNameToSymbol( className )
645 );
[511]646 if( !pInterfaceClass ){
647 compiler.errorMessenger.Output(106,paramStr.c_str(),nowLine);
648 continue;
[376]649 }
[511]650
651 if( !pInterfaceClass->IsReady() ){
652 // インターフェイスが未解析のとき
653 LexicalAnalyzer::LookaheadClass(
654 pInterfaceClass->GetName().c_str(),
655 compiler.GetObjectModule().meta.GetClasses()
656 );
657 }
658
[557]659 if( pInterfaceClass->IsInterface() || pInterfaceClass->IsComInterface() )
660 {
661 // インターフェイスを継承する
[558]662 std::vector<DynamicMethod::OverrideResult> overrideResults;
[560]663 Implements(
664 _class,
665 new ::Interface( pInterfaceClass, actualTypeParameters ),
666 overrideResults
667 );
[558]668
669 // エラーチェック
670 BOOST_FOREACH( const DynamicMethod::OverrideResult result, overrideResults )
671 {
672 OverrideErrorCheck( result );
673 }
[557]674 }
675 else
676 {
677 // インターフェイスではないとき
678 compiler.errorMessenger.Output(138,pInterfaceClass->GetName().c_str(),nowLine );
679 }
[376]680 }
681
[511]682 return true;
[376]683}
684
[511]685void GetClass_recur( const char *lpszInheritsClass, Classes &classes )
686{
[376]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();
[668]698 compiler.GetNamespaceSupporter().ClearImportedNamespaces();
[376]699
700 // 呼び出し元でコンパイル中のクラスポインタをバックアップ
[536]701 const CClass *pBackCompilingClass = compiler.IsCompilingClass()
702 ? &compiler.GetCompilingClass()
703 : NULL;
[376]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 ){
[465]724 compiler.errorMessenger.Output(12, "End Namespace", i );
[376]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 {
[465]744 compiler.errorMessenger.Output(64,temporary,i );
[376]745 }
746
747 continue;
748 }
[668]749 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_CLEARNAMESPACEIMPORTED )
750 {
751 // Imports情報のクリア
752 compiler.GetNamespaceSupporter().ClearImportedNamespaces();
[376]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;
[424]772 Jenga::Common::Strings typeParameterBaseClassNames;
773 SplitGenericClassInstance( temporary, className, typeParameters, true, &typeParameterBaseClassNames );
[376]774
[598]775 CClass *pobj_c = const_cast<CClass *>( classes.FindEx( Symbol( namespaceScopes, className ) ) );
[376]776 if(!pobj_c) continue;
777
[536]778 compiler.SetCompilingClass( pobj_c );
[379]779
[376]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 // ☆★☆ ジェネリクスサポート ☆★☆
[424]794 for( i2=0; i2<static_cast<int>(typeParameters.size()); i2++ )
[376]795 {
[511]796 Type baseType( DEF_OBJECT, *classes.GetObjectClassPtr() );
[424]797 if( typeParameterBaseClassNames[i2].size() )
798 {
799 if( !compiler.StringToType( typeParameterBaseClassNames[i2], baseType ) )
800 {
[465]801 compiler.errorMessenger.Output(106,typeParameterBaseClassNames[i2],i);
[424]802 }
803 else if( !baseType.IsObject() )
804 {
[465]805 compiler.errorMessenger.Output(106,typeParameterBaseClassNames[i2],i);
[424]806 }
807 }
808
809 pobj_c->AddFormalGenericType( GenericType( typeParameters[i2], baseType ) );
[376]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
[723]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);
[376]852 goto Interface_InheritsError;
853 }
854
855 //継承元クラスを取得
[598]856 const CClass *pInheritsClass = compiler.GetObjectModule().meta.FindClassSupportedTypeDef(
[723]857 LexicalAnalyzer::FullNameToSymbol( className )
[598]858 );
[376]859 if( !pInheritsClass ){
[723]860 compiler.errorMessenger.Output(106,className,i);
[376]861 goto Interface_InheritsError;
862 }
863
[511]864 //ループ継承でないかをチェック
865 if( !LexicalAnalyzer::LoopRefCheck( *pInheritsClass ) )
866 {
867 compiler.errorMessenger.Output(123,pInheritsClass->GetName(),i);
868 goto Interface_InheritsError;
869 }
870
[376]871 //継承させる
[723]872 if( !pobj_c->InheritsClass( *pInheritsClass, actualTypeParameters, i ) ){
[376]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)){
[465]892 compiler.errorMessenger.Output(22,"Interface",i);
[376]893 i--;
894 break;
895 }
896
897 if(basbuf[i]==1&&basbuf[i+1]==ESC_INHERITS){
[465]898 compiler.errorMessenger.Output(111,NULL,i);
[376]899 break;
900 }
901 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_IMPLEMENTS )
902 {
[465]903 compiler.errorMessenger.Output(137, NULL, i );
[376]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--;
[465]919 compiler.errorMessenger.Output(22,"Interface",top_pos);
[376]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 ))){
[465]931 compiler.errorMessenger.Output(1,NULL,i);
[376]932 break;
933 }
934
[511]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 {
[574]940 // 関数を追加
941 if( compiler.GetObjectModule().meta.GetUserProcs().IsExist( pUserProc ) )
942 {
943 // 既に存在している
944 compiler.errorMessenger.Output(15,pUserProc->GetName(),i);
[511]945
[574]946 delete pUserProc;
947 }
948 else
949 {
950 compiler.GetObjectModule().meta.GetUserProcs().Put( pUserProc );
951 }
952
[511]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 }
[376]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
[409]988 if( dwClassType != ESC_TYPE )
989 {
[465]990 compiler.errorMessenger.Output(140,NULL,i);
[409]991 }
992
[376]993 if(!(iAlign==1||iAlign==2||iAlign==4||iAlign==8||iAlign==16))
[465]994 compiler.errorMessenger.Output(51,NULL,i);
[376]995 }
996 else if( memicmp( basbuf + i, "Blittable(", 10 ) == 0 ){
997 // Blittable修飾子
998 i+=10;
999 i=JumpStringInPare(basbuf,i)+1;
[409]1000
1001 if( dwClassType != ESC_CLASS )
1002 {
[465]1003 compiler.errorMessenger.Output(141,NULL,i);
[409]1004 }
[376]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;
[424]1023 Jenga::Common::Strings typeParameterBaseClassNames;
1024 SplitGenericClassInstance( temporary, className, typeParameters, true, &typeParameterBaseClassNames );
[376]1025
[598]1026 CClass *pobj_c = const_cast<CClass *>( classes.FindEx( Symbol( namespaceScopes, className ) ) );
[376]1027 if(!pobj_c) continue;
1028
[536]1029 compiler.SetCompilingClass( pobj_c );
[376]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 // ☆★☆ ジェネリクスサポート ☆★☆
[424]1046 for( i2=0; i2<static_cast<int>(typeParameters.size()); i2++ )
[376]1047 {
[511]1048 Type baseType( DEF_OBJECT, *classes.GetObjectClassPtr() );
[424]1049 if( typeParameterBaseClassNames[i2].size() )
1050 {
1051 if( !compiler.StringToType( typeParameterBaseClassNames[i2], baseType ) )
1052 {
[465]1053 compiler.errorMessenger.Output(106,typeParameterBaseClassNames[i2],i);
[424]1054 }
1055 else if( !baseType.IsObject() )
1056 {
[465]1057 compiler.errorMessenger.Output(106,typeParameterBaseClassNames[i2],i);
[424]1058 }
1059 }
1060
1061 pobj_c->AddFormalGenericType( GenericType( typeParameters[i2], baseType ) );
[376]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){
[465]1101 compiler.errorMessenger.Output(105,temporary,i);
[376]1102 goto InheritsError;
1103 }
1104 }
1105 else
1106 {
1107 // 何の指定もないときはObjectクラスを継承する
1108 lstrcpy( temporary, "Object" );
1109 }
[511]1110 LexicalAnalyzer::Inherits( *pobj_c, temporary, i );
[376]1111
1112 if( basbuf[i+1] == 1 && basbuf[i+2] == ESC_IMPLEMENTS )
1113 {
1114 // インターフェイス実装を行う場合
1115 i += 3;
1116 GetCommandToken( temporary, basbuf, i );
1117
[511]1118 LexicalAnalyzer::Implements( *pobj_c, temporary, i );
[376]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)){
[465]1129 compiler.errorMessenger.Output(22,"Class",i);
[376]1130 i--;
1131 break;
1132 }
1133
1134 if(basbuf[i]==1&&basbuf[i+1]==ESC_INHERITS){
[465]1135 compiler.errorMessenger.Output(111,NULL,i);
[376]1136 break;
1137 }
1138 else if( basbuf[i] == 1 && basbuf[i+1] == ESC_IMPLEMENTS )
1139 {
[465]1140 compiler.errorMessenger.Output(137, NULL, i );
[376]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)
[465]1203 compiler.errorMessenger.Output(22,"Class",top_pos);
[376]1204 else
[465]1205 compiler.errorMessenger.Output(22,"Type",top_pos);
[376]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){
[632]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 );
[376]1246
1247
[632]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 }
[376]1253 }
1254
1255
[632]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());
[376]1265 }
1266 }
1267 }
1268 }
1269 else{
[511]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 {
[574]1275 // 関数を追加
1276 if( compiler.GetObjectModule().meta.GetUserProcs().IsExist( pUserProc ) )
1277 {
1278 // 既に存在している
1279 compiler.errorMessenger.Output(15,pUserProc->GetName(),i);
[376]1280
[574]1281 delete pUserProc;
1282 }
1283 else
1284 {
1285 compiler.GetObjectModule().meta.GetUserProcs().Put( pUserProc );
1286 }
1287
[511]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
[376]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);
[465]1320 compiler.errorMessenger.Output(22,temporary,i);
[376]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 // 呼び出し元でコンパイル中のクラスポインタを元に戻す
[536]1333 compiler.SetCompilingClass( pBackCompilingClass );
[376]1334
1335 // 名前空間を元に戻す
1336 compiler.GetNamespaceSupporter().GetLivingNamespaceScopes() = backupNamespaceScopes;
1337
1338 // インポートされた名前空間を元に戻す
[668]1339 compiler.GetNamespaceSupporter().SetImportedNamespaces( backupImportedNamespaces );
[376]1340}
1341
[511]1342void LexicalAnalyzer::LookaheadClass( const char *className, Classes &classes )
[376]1343{
1344 pobj_LoopRefCheck->add( className );
[511]1345 GetClass_recur( className, classes );
[376]1346 pobj_LoopRefCheck->del( className );
1347}
1348
[511]1349bool LexicalAnalyzer::LoopRefCheck( const CClass &objClass )
[376]1350{
1351 if( pobj_LoopRefCheck->check( objClass ) )
1352 {
1353 return false;
1354 }
1355
1356 return true;
1357}
1358
[511]1359void LexicalAnalyzer::CollectClasses( const char *source, Classes &classes ){
[376]1360 //ループ継承チェック用のクラス
1361 pobj_LoopRefCheck=new CLoopRefCheck();
1362
1363 //クラスを取得
[511]1364 GetClass_recur( 0, classes );
[376]1365
1366 delete pobj_LoopRefCheck;
1367 pobj_LoopRefCheck=0;
1368
1369 // イテレータの準備
[511]1370 classes.Iterator_Init();
[376]1371}
[632]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(
[637]1447 _class,
[632]1448 _class.GetImportedNamespaces(),
1449 _class.GetClassType(),
1450 _class.GetFormalGenericTypes(),
[672]1451 _class.GetSuperClassActualTypeParameters(),
[632]1452 _class.GetConstructorMemberSubIndex(),
1453 _class.GetDestructorMemberSubIndex(),
1454 0,
[672]1455 _class.GetFixedAlignment(),
1456 actualTypes
[632]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.