source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/Type.cpp @ 523

Last change on this file since 523 was 523, checked in by dai_9181, 15 years ago

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