source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/Compiler.cpp@ 688

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

#175への対応。型パラメータが値型のジェネリック型（テンプレート展開対象）を戻り値にした場合、戻り値用変数宣言がテンプレート展開前のクラスで行われてしまう不具合を修正。
File size: 12.2 KB
Line 
1#include "stdafx.h"
2
3using namespace ActiveBasic::Compiler;
4
5Compiler compiler;
6
7Compiler::Compiler()
8 : isBuildSuccessful( false )
9 , targetModuleType( ActiveBasic::Common::TargetModuleType::Exe )
10 , isDebug( false )
11 , isUnicode( false )
12 , isCore( false )
13 , currentRelationalObjectModuleIndexForSource( 0 )
14{
15 // 生成先のオブジェクトモジュールを登録
16 ObjectModule *pObjectModule = new ObjectModule();
17 staticLibraries.push_back( pObjectModule );
18 SelectObjectModule( pObjectModule );
19
20 namespaceSupporter.RegistAllNamespaceScopesCollection( &GetObjectModule().meta.GetNamespaces() );
21
22 Symbol::RegistNamespaceSupporter( &namespaceSupporter );
23}
24Compiler::~Compiler()
25{
26 BOOST_FOREACH( ObjectModule *pStaticLibrary, staticLibraries )
27 {
28 delete pStaticLibrary;
29 }
30 staticLibraries.clear();
31}
32
33void Compiler::PreStaticLink( const ObjectModules &staticLibraries )
34{
35 BOOST_FOREACH( const ObjectModule *pStaticLibrary, staticLibraries )
36 {
37 // 関連オブジェクトモジュールの名前リスト
38 this->GetObjectModule().relationalObjectModuleNames.push_back( pStaticLibrary->GetName() );
39 }
40}
41void Compiler::StaticLink( ObjectModules &staticLibraries )
42{
43 BOOST_FOREACH( ObjectModule *pStaticLibrary, staticLibraries )
44 {
45 if( &this->GetObjectModule() == pStaticLibrary )
46 {
47 // 自分自身の場合はリンクしない
48 continue;
49 }
50
51 // メタ情報
52 this->GetObjectModule().StaticLink( *pStaticLibrary, this->IsSll() );
53 }
54}
55
56ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType Compiler::StringToGenericTypeEx( const std::string &typeName, Type &type )
57{
58 // ジェネリッククラスをインスタンス化した型の場合
59 int i = 0;
60 char className[VN_SIZE];
61 GetIdentifierToken( className, typeName.c_str(), i );
62
63 // ジェネリクスクラスを取得
64 const CClass *pGenericClass = this->GetObjectModule().meta.FindClassSupportedTypeDef(
65 LexicalAnalyzer::FullNameToSymbol( className )
66 );
67
68 if( !pGenericClass )
69 {
70 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::NotfoundGenericClass;
71 }
72
73 if( typeName[i] != '<' )
74 {
75 Jenga::Throw( "StringToType内でジェネリクス構文の解析に失敗" );
76 }
77
78 GenericTypes genericTypes;
79 bool isValueType = false;
80 while( true )
81 {
82 i++;
83
84 char typeParameterStr[VN_SIZE];
85 GetIdentifierToken( typeParameterStr, typeName.c_str(), i );
86
87 // 型パラメータの型情報を取得
88 Type typeParameterType;
89 StringToType( typeParameterStr, typeParameterType );
90
91 genericTypes.push_back( GenericType( "(non support)", typeParameterType ) );
92
93 if( typeParameterType.IsValueType() )
94 {
95 // 値型の場合
96 isValueType = true;
97 }
98
99 if( typeName[i] != ',' )
100 {
101 break;
102 }
103 }
104
105 // 基本型をセット
106 type.SetBasicType( DEF_OBJECT );
107
108 if( isValueType )
109 {
110 // 型パラメータに値型が指定された場合
111
112 // 仮型パラメータを実型パラメータに変換
113 Types actualTypes;
114 BOOST_FOREACH( const GenericType &genericType, genericTypes )
115 {
116 actualTypes.push_back( genericType.GetType() );
117 }
118
119 // テンプレートとしてクラスを展開する
120 const CClass *pExpandedClass = LexicalAnalyzer::TemplateExpand( *const_cast<CClass *>(pGenericClass), actualTypes );
121
122 if( pExpandedClass )
123 {
124 // 拡張情報をセット
125 type.SetClassPtr( pExpandedClass );
126 }
127 else
128 {
129 // TODO: 消す
130 goto Generic;
131 }
132 }
133 else
134 {
135Generic:
136 // 型パラメータにクラス型が指定された場合
137
138 // ジェネリック クラスとして利用する
139
140 // 拡張情報をセット
141 type.SetClassPtr( pGenericClass );
142 type.SetActualGenericTypes( genericTypes );
143 }
144
145 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
146}
147ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType Compiler::StringToTypeEx( const std::string &typeName, Type &type, bool isResolveGenerics )
148{
149 type.SetIndex( -1 );
150
151
152 /////////////////////////////////////////////////////////
153 // ☆★☆ ジェネリクスサポート ☆★☆
154
155 if( strstr( typeName.c_str(), "<" ) )
156 {
157 return StringToGenericTypeEx( typeName, type );
158 }
159
160 //
161 /////////////////////////////////////////////////////////
162
163
164 if( typeName[0] == '*' ){
165 if( typeName.size() >= 3
166 && typeName[1] == 1 && ( typeName[2] == ESC_FUNCTION || typeName[2] == ESC_SUB ) )
167 {
168 // 関数ポインタを追加する
169 {
170 DWORD dwProcType = (DWORD)typeName[2];
171 const std::string &paramStr = typeName.substr( 3 );
172
173 Procedure::Kind kind = ( dwProcType == ESC_FUNCTION )
174 ? Procedure::Function
175 : Procedure::Sub;
176
177 ProcPointer *pProcPointer = new ProcPointer( kind );
178
179 //buffer[0]は'('となっている
180 extern int cp;
181 ActiveBasic::Compiler::LexicalAnalyzer::SetParamsAndReturnType( pProcPointer, paramStr.c_str(), false, cp );
182
183 this->GetObjectModule().meta.GetProcPointers().push_back( pProcPointer );
184 }
185
186 //関数ポインタ（*Function）
187 type.SetBasicType( DEF_PTR_PROC );
188 type.SetIndex( this->GetObjectModule().meta.GetProcPointers().size() - 1 );
189 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
190 }
191
192 const std::string &nextTypeName = typeName.substr( 1 );
193
194 ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType result = StringToTypeEx( nextTypeName, type, isResolveGenerics );
195 if( result != ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful )
196 {
197 return result;
198 }
199
200 type.PtrLevelUp();
201
202 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
203 }
204
205 {
206 int basicType;
207 if( Type::StringToBasicType( typeName, basicType ) )
208 {
209 // 基本型だったとき
210 type.SetBasicType( basicType );
211 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
212 }
213 }
214
215 // Object型だったとき
216 if( typeName == "Object" )
217 {
218 type.SetType( DEF_OBJECT, this->GetObjectModule().meta.GetClasses().GetObjectClassPtr() );
219 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
220 }
221
222 // String型だったとき
223 if( typeName == "String" )
224 {
225 type.SetType( DEF_OBJECT, this->GetObjectModule().meta.GetClasses().GetStringClassPtr() );
226 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
227 }
228
229
230 ////////////////////
231 // TypeDefされた型
232 ////////////////////
233 const TypeDef *pTypeDef = this->GetObjectModule().meta.GetTypeDefs().Find( LexicalAnalyzer::FullNameToSymbol( typeName ) );
234 if( pTypeDef )
235 {
236 type = pTypeDef->GetBaseType();
237
238 if( type.IsObject() )
239 {
240 if( isResolveGenerics && !type.HasActualGenericType() )
241 {
242 // ジェネリッククラスの場合
243 trace( "型解決されていない" );
244 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::FailedResolveGenericType;
245 }
246 }
247
248 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
249 }
250
251 //クラス
252 const CClass *pobj_c = this->GetObjectModule().meta.FindClassSupportedTypeDef( LexicalAnalyzer::FullNameToSymbol( typeName ) );
253 if(pobj_c)
254 {
255 if( isResolveGenerics )
256 {
257 if( pobj_c->IsGeneric() )
258 {
259 // ジェネリッククラスの場合
260 trace( "型解決されていない" );
261 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::FailedResolveGenericType;
262 }
263 }
264
265 if( pobj_c->IsStructure() )
266 {
267 type.SetBasicType( DEF_STRUCT );
268 }
269 else
270 {
271 type.SetBasicType( DEF_OBJECT );
272 }
273 type.SetClassPtr( pobj_c );
274 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
275 }
276
277
278 /////////////////////////////////////////////////////////
279 // ☆★☆ ジェネリクスサポート ☆★☆
280
281 // 型パラメータ
282 if( this->IsCompilingClass() )
283 {
284 // クラスに属するメソッドをコンパイルしているとき
285 int formalTypeIndex = this->GetCompilingClass().GetFormalGenericTypeParameterIndex( typeName );
286 if( formalTypeIndex != -1 )
287 {
288 // コンパイル中クラスにおけるジェネリクス用の型パラメータのとき
289 type.SetBasicType( DEF_TYPE_PARAMETER );
290 type.SetClassPtr( &this->GetCompilingClass().GetFormalGenericTypes()[formalTypeIndex].GetType().GetClass() );
291 type.SetFormalTypeName( typeName );
292 type.SetFormalTypeIndex( formalTypeIndex );
293 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
294 }
295 }
296
297 //
298 /////////////////////////////////////////////////////////
299
300 return ActiveBasic::Compiler::Error::StringToTypeErrorCode::NotfoundType;
301}
302
303bool Compiler::StringToType( const std::string &typeName, Type &type )
304{
305 return ( StringToTypeEx( typeName, type, false ) == ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful );
306}
307
308const std::string Compiler::TypeToString( const Type &type )
309{
310 if( PTR_LEVEL( type.GetBasicType() ) ){
311 //ポインタレベルが1以上の場合
312 Type tempType( type );
313 tempType.PtrLevelDown();
314
315 return (std::string)"*" + TypeToString( tempType );
316 }
317 else if( type.IsObject() || type.IsStruct() )
318 {
319 //オブジェクトまたは構造体
320
321 if( !( type.GetIndex() == 0 || type.GetIndex() == -1 ) )
322 {
323 std::string result = type.GetClass().GetName();
324 if( type.GetClass().GetNamespaceScopes().size() >= 1 )
325 {
326 result = type.GetClass().GetNamespaceScopes().ToString()
327 + "."
328 + result;
329 }
330
331 if( type.GetClass().IsExpanded() )
332 {
333 // テンプレート展開済みのクラスの場合
334 std::string actualGenericTypesName;
335 BOOST_FOREACH( const Type &typeParameter, type.GetClass().expandedClassActualTypeParameters )
336 {
337 if( actualGenericTypesName.size() )
338 {
339 actualGenericTypesName += ",";
340 }
341 actualGenericTypesName += typeParameter.ToString();
342 }
343
344 result += "<" + actualGenericTypesName + ">";
345 }
346
347 return result;
348 }
349 }
350 else if( type.IsProcPtr() ){
351 if( type.GetIndex() == 0 || type.GetIndex() == -1 ){
352 return "VoidPtr";
353 }
354 else{
355 if( this->GetObjectModule().meta.GetProcPointers()[type.GetIndex()]->ReturnType().IsNull() ){
356 return "*Sub";
357 }
358 return "*Function";
359 }
360 }
361 else{
362 // 基本型
363 const char *lpszTypeName = Type::BasicTypeToCharPtr( type );
364 if( lpszTypeName )
365 {
366 return (const std::string)lpszTypeName;
367 }
368 }
369
370 compiler.errorMessenger.Output(1, NULL, cp);
371
372 return (std::string)"(null)";
373}
374
375int Compiler::SizeOf( const Type &type )
376{
377 Type tempType( type );
378 if( this->IsCompilingClass() )
379 {
380 if( this->pCompilingClass->IsExpanded() && tempType.IsTypeParameter() )
381 {
382 // 現在コンパイル中のクラスがテンプレート展開済みのクラスで、
383 // 尚且つターゲットとなる型が型パラメータだったとき
384
385 // テンプレート展開情報を用いて型解決を行う
386 this->pCompilingClass->ResolveExpandedClassActualTypeParameter( tempType );
387 }
388 }
389 return tempType.GetSize();
390}
391
392void Compiler::ClearCompilingUserProcAndClass()
393{
394 this->pCompilingUserProc = NULL;
395 this->pCompilingClass = NULL;
396}
397
398void Compiler::SetCompilingClass( const CClass *pClass )
399{
400 this->pCompilingClass = pClass;
401}
402
403void Compiler::SetCompilingUserProc( const UserProc *pUserProc )
404{
405 this->pCompilingUserProc = pUserProc;
406
407 this->SetCompilingClass( pUserProc->GetParentClassPtr() );
408}
409
410void Compiler::StartGlobalAreaCompile()
411{
412 ClearCompilingUserProcAndClass();
413}
414
415void Compiler::StartProcedureCompile( const UserProc *pUserProc )
416{
417 //コンパイル中の関数
418 this->SetCompilingUserProc( pUserProc );
419
420 if( pUserProc->HasParentClass() )
421 {
422 // クラスの使用チェック
423 pUserProc->GetParentClass().Using();
424 }
425
426 // コンパイル中の関数が属する名前空間
427 this->GetNamespaceSupporter().SetLivingNamespaceScopes( pUserProc->GetNamespaceScopes() );
428
429 // コンパイル中の関数でImportsされている名前空間
430 this->GetNamespaceSupporter().SetImportedNamespaces( pUserProc->GetImportedNamespaces() );
431
432 // コード生成対象を選択
433 this->codeGenerator.Select( (const_cast<UserProc *>(pUserProc))->GetNativeCode() );
434}
435void Compiler::FinishProcedureCompile()
436{
437 this->pCompilingUserProc = NULL;
438 this->pCompilingClass = NULL;
439}
440
441bool Compiler::IsGlobalAreaCompiling()
442{
443 if( pCompilingUserProc == NULL )
444 {
445 return true;
446 }
447 return ( pCompilingUserProc->GetName() == this->globalAreaProcName );
448}
449bool Compiler::IsLocalAreaCompiling()
450{
451 return !IsGlobalAreaCompiling();
452}
453const UserProc &Compiler::GetCompilingUserProc()
454{
455 if( pCompilingUserProc == NULL )
456 {
457 _ASSERTE( false );
458 throw;
459 }
460 return *pCompilingUserProc;
461}
462
463bool Compiler::IsCompilingClass()
464{
465 return ( pCompilingClass != NULL );
466}
467const CClass &Compiler::GetCompilingClass()
468{
469 if( this->IsCompilingClass() )
470 {
471 return *pCompilingClass;
472 }
473
474 throw;
475}
Note: See TracBrowser for help on using the repository browser.