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, 16 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.