source: dev/trunk/ab5.0/abdev/ab_common/src/Lexical/Type.cpp@ 632

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

ジェネリッククラスの型パラメータに値型が指定されたときに限り、テンプレート展開を行うようにした。

TODO: libファイルを跨ってテンプレート展開ができていないため、ソースコード管理部分に手を加える必要あり。
File size: 11.0 KB
Line 
1#include "stdafx.h"
2
3const int Type::basicTypeList[] = {
4 DEF_BYTE,
5 DEF_SBYTE,
6 DEF_WORD,
7 DEF_INTEGER,
8 DEF_DWORD,
9 DEF_LONG,
10 DEF_QWORD,
11 DEF_INT64,
12
13 DEF_SINGLE,
14 DEF_DOUBLE,
15
16 DEF_BOOLEAN,
17
18 DEF_PTR_VOID,
19
20 DEF_ANY,
21
22 DEF_NON
23};
24
25const std::string Type::basicTypeNameList[] = {
26 "Byte",
27 "SByte",
28 "Word",
29 "Integer",
30 "DWord",
31 "Long",
32 "QWord",
33 "Int64",
34
35 "Single",
36 "Double",
37
38 "Boolean",
39
40 "VoidPtr",
41
42 "Any",
43
44 ""
45};
46
47Type::~Type()
48{
49}
50
51bool Type::StringToBasicType( const std::string &typeName, int &basicType ){
52 for( int i=0; ; i++ ){
53 if( basicTypeList[i] == DEF_NON ){
54 break;
55 }
56 if( basicTypeNameList[i] == typeName ){
57 basicType = basicTypeList[i];
58 return true;
59 }
60 }
61 return false;
62}
63const char *Type::BasicTypeToCharPtr( const Type &type )
64{
65 for( int i=0; ; i++ ){
66 if( basicTypeList[i] == DEF_NON ){
67 break;
68 }
69 if( basicTypeList[i] == type.GetBasicType() ){
70 return basicTypeNameList[i].c_str();
71 }
72 }
73 return NULL;
74}
75
76int Type::GetBasicSize( int basicType )
77{
78
79 // 基本型
80 switch( basicType ){
81 case DEF_SBYTE:
82 case DEF_BYTE:
83 case DEF_BOOLEAN:
84 return sizeof(BYTE);
85
86 case DEF_INTEGER:
87 case DEF_WORD:
88 return sizeof(WORD);
89
90 case DEF_LONG:
91 case DEF_DWORD:
92 return sizeof(DWORD);
93
94 case DEF_INT64:
95 case DEF_QWORD:
96 return sizeof(_int64);
97
98 case DEF_DOUBLE:
99 return sizeof(double);
100 case DEF_SINGLE:
101 return sizeof(float);
102 }
103
104 // ポインタ
105 if(IsPointer( basicType )){
106 return PTR_SIZE;
107 }
108
109 // オブジェクト
110 if(basicType==DEF_OBJECT){
111 return PTR_SIZE;
112 }
113
114 throw;
115
116 return 0;
117}
118
119const CClass &Type::GetClass() const
120{
121 if( !HasMember() )
122 {
123 Jenga::Throw( "クラスまたは構造体でない型に対してGetClassを呼び出した" );
124 }
125
126 return *pClass;
127}
128
129bool Type::Equals( const Type &type ) const
130{
131 if( basicType == type.basicType ){
132 if( NATURAL_TYPE( basicType ) == DEF_OBJECT
133 || NATURAL_TYPE( basicType ) == DEF_STRUCT ){
134
135 if( index == type.index ){
136 return true;
137 }
138
139 }
140 else{
141 return true;
142 }
143 }
144 return false;
145}
146
147bool Type::IsCovariant( const Type &type ) const
148{
149 if( !this->IsObject() || !type.IsObject() )
150 {
151 // 共変性の判別はクラス型のみ
152 return false;
153 }
154
155 return this->GetClass().IsSubClass( &type.GetClass() );
156}
157bool Type::IsContravariant( const Type &type ) const
158{
159 if( !this->IsObject() || !type.IsObject() )
160 {
161 // 反変性の判別はクラス型のみ
162 return false;
163 }
164
165 return type.GetClass().IsSubClass( &this->GetClass() );
166}
167
168int Type::GetBasicSize() const
169{
170 return GetBasicSize( basicType );
171}
172int Type::GetSize() const
173{
174
175 // 基本型
176 switch( basicType ){
177 case DEF_LONG:
178 if(index==LITERAL_NULL||index==LITERAL_M128_0||index==LITERAL_0_255){
179 return sizeof(BYTE);
180 }
181 else if(index==LITERAL_M32768_0||index==LITERAL_0_65535){
182 return sizeof(WORD);
183 }
184 return sizeof(DWORD);
185
186 case DEF_SBYTE:
187 case DEF_BYTE:
188 case DEF_BOOLEAN:
189 return sizeof(BYTE);
190
191 case DEF_INTEGER:
192 case DEF_WORD:
193 return sizeof(WORD);
194
195 case DEF_DWORD:
196 return sizeof(DWORD);
197
198 case DEF_INT64:
199 case DEF_QWORD:
200 return sizeof(_int64);
201
202 case DEF_DOUBLE:
203 return sizeof(double);
204 case DEF_SINGLE:
205 return sizeof(float);
206 }
207
208 // ポインタ
209 if(IsPointer()){
210 return PTR_SIZE;
211 }
212
213 // 構造体
214 if( IsStruct() )
215 {
216 if( !pClass ){
217 throw;
218 }
219
220 return pClass->GetSize();
221 }
222
223 // オブジェクト
224 if( IsObject() )
225 {
226 return PTR_SIZE;
227 }
228
229 throw;
230}
231
232bool Type::IsNull() const{
233 if( basicType == DEF_NON ){
234 return true;
235 }
236 return false;
237}
238
239bool Type::IsByte() const{
240 if( basicType == DEF_BYTE ){
241 return true;
242 }
243 return false;
244}
245bool Type::IsSByte() const{
246 if( basicType == DEF_SBYTE ){
247 return true;
248 }
249 return false;
250}
251bool Type::IsWord() const{
252 if( basicType == DEF_WORD ){
253 return true;
254 }
255 return false;
256}
257bool Type::IsInteger() const{
258 if( basicType == DEF_INTEGER ){
259 return true;
260 }
261 return false;
262}
263bool Type::IsDWord() const{
264 if( basicType == DEF_DWORD ){
265 return true;
266 }
267 return false;
268}
269bool Type::IsLong() const{
270 if( basicType == DEF_LONG ){
271 return true;
272 }
273 return false;
274}
275bool Type::IsQWord() const{
276 if( basicType == DEF_QWORD ){
277 return true;
278 }
279 return false;
280}
281bool Type::IsInt64() const{
282 if( basicType == DEF_INT64 ){
283 return true;
284 }
285 return false;
286}
287bool Type::IsSingle() const{
288 if( basicType == DEF_SINGLE ){
289 return true;
290 }
291 return false;
292}
293bool Type::IsDouble() const{
294 if( basicType == DEF_DOUBLE ){
295 return true;
296 }
297 return false;
298}
299bool Type::IsBoolean() const{
300 if( basicType == DEF_BOOLEAN ){
301 return true;
302 }
303 return false;
304}
305
306bool Type::IsPointer( int basicType )
307{
308 if( basicType == DEF_NON )
309 {
310 return false;
311 }
312
313 if(PTR_LEVEL( basicType )|| basicType == DEF_PTR_VOID || basicType == DEF_PTR_PROC
314 || ( basicType & FLAG_PTR ) ){
315 return true;
316 }
317
318 return false;
319}
320bool Type::IsPointer() const
321{
322 return IsPointer( basicType );
323}
324bool Type::IsSigned() const
325{
326 switch( basicType ){
327 case DEF_SBYTE:
328 case DEF_INTEGER:
329 case DEF_LONG:
330 case DEF_INT64:
331 case DEF_SINGLE:
332 case DEF_DOUBLE:
333 return true;
334 default:
335 break;
336 }
337 return false;
338}
339bool Type::IsNaturalWhole() const
340{
341 switch( basicType ){
342 case DEF_SBYTE:
343 case DEF_BYTE:
344 case DEF_INTEGER:
345 case DEF_WORD:
346 case DEF_LONG:
347 case DEF_DWORD:
348 case DEF_INT64:
349 case DEF_QWORD:
350 return true;
351 default:
352 break;
353 }
354 return false;
355}
356bool Type::IsWhole() const
357{
358 return (
359 IsNaturalWhole()
360 || IsPointer( basicType )
361 || basicType == DEF_BOOLEAN
362 );
363}
364bool Type::IsReal() const
365{
366 switch( basicType ){
367 case DEF_SINGLE:
368 case DEF_DOUBLE:
369 return true;
370 default:
371 break;
372 }
373 return false;
374}
375bool Type::Is64() const
376{
377 switch( basicType ){
378 case DEF_QWORD:
379 case DEF_INT64:
380 return true;
381 default:
382 break;
383 }
384 return false;
385}
386
387bool Type::IsValueType() const
388{
389 return ( IsWhole() || IsReal() );
390}
391
392bool Type::IsProcPtr() const
393{
394 if( basicType == DEF_PTR_PROC ){
395 return true;
396 }
397 return false;
398}
399bool Type::IsStruct() const
400{
401 if( basicType == DEF_STRUCT ){
402 return true;
403 }
404 return false;
405}
406bool Type::IsStructPtr() const
407{
408 if( basicType == DEF_PTR_STRUCT ){
409 return true;
410 }
411 return false;
412}
413bool Type::IsObject() const
414{
415 return (
416 basicType == DEF_OBJECT
417 || basicType == DEF_TYPE_PARAMETER
418 );
419}
420bool Type::IsObjectPtr() const
421{
422 if( basicType == DEF_PTR_OBJECT ){
423 return true;
424 }
425 return false;
426}
427bool Type::IsTypeParameter() const
428{
429 return ( NATURAL_TYPE(basicType) == DEF_TYPE_PARAMETER );
430}
431bool Type::IsObjectClass() const
432{
433 if( basicType == DEF_OBJECT ){
434 if( pClass->GetName() == "Object" ){
435 return true;
436 }
437 }
438 return false;
439}
440bool Type::IsStringClass() const
441{
442 if( basicType == DEF_OBJECT ){
443 if( pClass->GetName() == "String" ){
444 return true;
445 }
446 }
447 return false;
448}
449bool Type::IsVoidPtr() const
450{
451 if( basicType == DEF_PTR_VOID ){
452 return true;
453 }
454 return false;
455}
456
457bool Type::IsAny() const
458{
459 if( basicType == DEF_ANY ){
460 return true;
461 }
462 return false;
463}
464
465bool Type::IsDelegate() const
466{
467 return ( IsObject() && GetClass().IsDelegate() );
468}
469bool Type::IsInterface() const
470{
471 return ( IsObject() && GetClass().IsInterface() );
472}
473bool Type::IsComInterface() const
474{
475 return ( IsObject() && GetClass().IsComInterface() );
476}
477
478
479bool Type::HasMember() const
480{
481 if( NATURAL_TYPE( basicType ) == DEF_OBJECT
482 || NATURAL_TYPE( basicType ) == DEF_STRUCT
483 || NATURAL_TYPE( basicType ) == DEF_TYPE_PARAMETER
484 ){
485 return true;
486 }
487 return false;
488}
489
490const Type &Type::GetActualGenericType( int index ) const
491{
492 return actualGenericTypes[index].GetType();
493}
494bool Type::HasActualGenericType() const
495{
496 return ( actualGenericTypes.size() > 0 );
497}
498
499std::string Type::ToString() const
500{
501 const char *basicTypeName = BasicTypeToCharPtr( *this );
502 if( basicTypeName )
503 {
504 return basicTypeName;
505 }
506
507 if( IsTypeParameter() )
508 {
509 return GetFormalTypeName();
510 }
511
512 std::string typeName = GetClass().GetFullName();
513 if( HasActualGenericType() )
514 {
515 std::string actualGenericTypesName;
516 BOOST_FOREACH( const GenericType &actualGenericType, actualGenericTypes )
517 {
518 if( actualGenericTypesName.size() )
519 {
520 actualGenericTypesName += ",";
521 }
522 actualGenericTypesName += actualGenericType.GetName();
523 }
524
525 typeName += "<" + actualGenericTypesName + ">";
526 }
527 return typeName;
528}
529
530int Type::GetBasicTypeFromSimpleName( const char *variable ){
531 extern char DefIntVari[26],DefSngVari[26],DefStrVari[26],divNum,dsvNum,dStrvNum;
532 int i;
533 char name[VN_SIZE];
534
535 //構造体メンバの場合を考慮
536 for(i=lstrlen(variable);i>0;i--){
537 if(variable[i]=='.'){
538 i++;
539 break;
540 }
541 }
542
543 for(;;i++){
544 if(variable[i]=='('||variable[i]=='\0'){
545 name[i]=0;
546 break;
547 }
548 name[i]=variable[i];
549 }
550 //変数名から選択
551 i--;
552 if(name[i]=='#') return DEF_DOUBLE;
553 if(name[i]=='!') return DEF_SINGLE;
554 if(name[i]=='%') return DEF_INTEGER;
555 return DEF_DOUBLE;
556}
557
558bool Types::IsEquals( const Types &types ) const
559{
560 if( this->size() != types.size() )
561 {
562 // アイテム数が違う
563 return false;
564 }
565
566 const Types &thisTypes = *this;
567 for( int i=0; i<static_cast<int>(this->size()); i++ )
568 {
569 if( !thisTypes[i].Equals( types[i] ) )
570 {
571 return false;
572 }
573 }
574
575 return true;
576}
577
578void ResolveFormalGenericTypeParameter( Type &typeParameter, const Type &classType, const UserProc *pUserProc )
579{
580 if( !typeParameter.IsTypeParameter() )
581 {
582 // ジェネリックな型ではなかったとき
583 return;
584 }
585
586 /////////////////////////////////////////////////////////
587 // ☆★☆ ジェネリクスサポート ☆★☆
588
589 // ポインタレベルを抽出
590 int ptrLevel = PTR_LEVEL( typeParameter.GetBasicType() );
591
592 if( pUserProc )
593 {
594 if( classType.IsObject() )
595 {
596 // 基底クラスでの自己解決
597 const CClass *pClass = &classType.GetClass();
598 while( pClass->HasSuperClass() )
599 {
600 if( pUserProc->GetParentClassPtr() == &pClass->GetSuperClass() )
601 {
602 if( pClass->GetSuperClassActualTypeParameters().size() )
603 {
604 // TODO: 適切な形に実装し直す（暫定的にトップの型を持ってきている）
605 typeParameter = pClass->GetSuperClassActualTypeParameters()[0];
606 }
607 }
608 pClass = &pClass->GetSuperClass();
609 }
610 }
611 }
612
613 if( typeParameter.IsTypeParameter() )
614 {
615 if( classType.HasActualGenericType() )
616 {
617 typeParameter = classType.GetActualGenericType( typeParameter.GetFormalTypeIndex() );
618 }
619 else
620 {
621 // 制約クラス（指定されていないときはObjectクラス）にセットする
622 typeParameter.SetBasicType( DEF_OBJECT );
623 }
624 }
625
626 for( int i=0; i<ptrLevel; i++ )
627 {
628 typeParameter.PtrLevelUp();
629 }
630
631 //
632 /////////////////////////////////////////////////////////
633}
634
635
636const std::string BlittableType::GetCreateStaticMethodFullName() const
637{
638 return pClass->GetNamespaceScopes().ToString() + "." + pClass->GetName() + "._Create";
639}
Note: See TracBrowser for help on using the repository browser.