source: translator/Parser/TypeData.cc@ 643a2e1

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors ctor deferred_resn demangler enum forall-pointer-decay gc_noraii jacob/cs343-translation jenkins-sandbox memory new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new string with_gc
Last change on this file since 643a2e1 was 6c3744e, checked in by Peter A. Buhr <pabuhr@…>, 11 years ago

add list initializer, formatting changes
  • Property mode set to 100644
File size: 25.8 KB
Line 
1#include <cassert>
2#include <algorithm>
3#include <iterator>
4#include "utility.h"
5#include "TypeData.h"
6#include "SynTree/Type.h"
7#include "SynTree/Declaration.h"
8#include "SynTree/Expression.h"
9#include "SynTree/Statement.h"
10
11
12TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) {
13 switch ( kind ) {
14 case Unknown:
15 case Pointer:
16 case EnumConstant:
17 // nothing else to initialize
18 break;
19 case Basic:
20 basic = new Basic_t;
21 break;
22 case Array:
23 array = new Array_t;
24 array->dimension = 0;
25 array->isVarLen = false;
26 array->isStatic = false;
27 break;
28 case Function:
29 function = new Function_t;
30 function->params = 0;
31 function->idList = 0;
32 function->oldDeclList = 0;
33 function->body = 0;
34 function->hasBody = false;
35 function->newStyle = false;
36 break;
37 case Aggregate:
38 aggregate = new Aggregate_t;
39 aggregate->params = 0;
40 aggregate->actuals = 0;
41 aggregate->members = 0;
42 break;
43 case AggregateInst:
44 aggInst = new AggInst_t;
45 aggInst->aggregate = 0;
46 aggInst->params = 0;
47 break;
48 case Enum:
49 enumeration = new Enumeration_t;
50 enumeration->constants = 0;
51 break;
52 case Symbolic:
53 case SymbolicInst:
54 symbolic = new Symbolic_t;
55 symbolic->params = 0;
56 symbolic->actuals = 0;
57 symbolic->assertions = 0;
58 break;
59 case Variable:
60 variable = new Variable_t;
61 variable->tyClass = DeclarationNode::Type;
62 variable->assertions = 0;
63 break;
64 case Tuple:
65 tuple = new Tuple_t;
66 tuple->members = 0;
67 break;
68
69 case Typeof:
70 typeexpr = new Typeof_t;
71 typeexpr->expr = 0;
72 break;
73
74 case Attr:
75 attr = new Attr_t;
76 attr->expr = 0;
77 attr->type = 0;
78 break;
79 }
80}
81
82TypeData::~TypeData() {
83 delete base;
84 delete forall;
85
86 switch ( kind ) {
87 case Unknown:
88 case Pointer:
89 case EnumConstant:
90 // nothing to destroy
91 break;
92 case Basic:
93 delete basic;
94 break;
95 case Array:
96 delete array->dimension;
97 delete array;
98 break;
99 case Function:
100 delete function->params;
101 delete function->idList;
102 delete function->oldDeclList;
103 delete function->body;
104 delete function;
105 break;
106 case Aggregate:
107 delete aggregate->params;
108 delete aggregate->actuals;
109 delete aggregate->members;
110 delete aggregate;
111 break;
112 case AggregateInst:
113 delete aggInst->aggregate;
114 delete aggInst->params;
115 delete aggInst;
116 break;
117 case Enum:
118 delete enumeration->constants;
119 delete enumeration;
120 break;
121 case Symbolic:
122 case SymbolicInst:
123 delete symbolic->params;
124 delete symbolic->actuals;
125 delete symbolic->assertions;
126 delete symbolic;
127 break;
128 case Variable:
129 delete variable->assertions;
130 delete variable;
131 break;
132 case Tuple:
133 delete tuple->members;
134 delete tuple;
135 break;
136
137 case Typeof:
138 delete typeexpr->expr;
139 delete typeexpr;
140 break;
141
142 case Attr:
143 delete attr->expr;
144 delete attr->type;
145 delete attr;
146 break;
147 }
148}
149
150TypeData *TypeData::clone() const {
151 TypeData *newtype = new TypeData( kind );
152 newtype->qualifiers = qualifiers;
153 newtype->base = maybeClone( base );
154 newtype->forall = maybeClone( forall );
155
156 switch ( kind ) {
157 case Unknown:
158 case EnumConstant:
159 case Pointer:
160 // nothing else to copy
161 break;
162 case Basic:
163 newtype->basic->typeSpec = basic->typeSpec;
164 newtype->basic->modifiers = basic->modifiers;
165 break;
166 case Array:
167 newtype->array->dimension = maybeClone( array->dimension );
168 newtype->array->isVarLen = array->isVarLen;
169 newtype->array->isStatic = array->isStatic;
170 break;
171 case Function:
172 newtype->function->params = maybeClone( function->params );
173 newtype->function->idList = maybeClone( function->idList );
174 newtype->function->oldDeclList = maybeClone( function->oldDeclList );
175 newtype->function->body = maybeClone( function->body );
176 newtype->function->hasBody = function->hasBody;
177 newtype->function->newStyle = function->newStyle;
178 break;
179 case Aggregate:
180 newtype->aggregate->params = maybeClone( aggregate->params );
181 newtype->aggregate->actuals = maybeClone( aggregate->actuals );
182 newtype->aggregate->members = maybeClone( aggregate->members );
183 newtype->aggregate->name = aggregate->name;
184 newtype->aggregate->kind = aggregate->kind;
185 break;
186 case AggregateInst:
187 newtype->aggInst->aggregate = maybeClone( aggInst->aggregate );
188 newtype->aggInst->params = maybeClone( aggInst->params );
189 break;
190 case Enum:
191 newtype->enumeration->name = enumeration->name;
192 newtype->enumeration->constants = maybeClone( enumeration->constants );
193 break;
194 case Symbolic:
195 case SymbolicInst:
196 newtype->symbolic->params = maybeClone( symbolic->params );
197 newtype->symbolic->actuals = maybeClone( symbolic->actuals );
198 newtype->symbolic->assertions = maybeClone( symbolic->assertions );
199 newtype->symbolic->isTypedef = symbolic->isTypedef;
200 newtype->symbolic->name = symbolic->name;
201 break;
202 case Variable:
203 newtype->variable->assertions = maybeClone( variable->assertions );
204 newtype->variable->name = variable->name;
205 newtype->variable->tyClass = variable->tyClass;
206 break;
207 case Tuple:
208 newtype->tuple->members = maybeClone( tuple->members );
209 break;
210
211 case Typeof:
212 newtype->typeexpr->expr = maybeClone( typeexpr->expr );
213 break;
214
215 case Attr:
216 newtype->attr->expr = maybeClone( attr->expr );
217 newtype->attr->type = maybeClone( attr->type );
218 break;
219 }
220 return newtype;
221}
222
223void TypeData::print( std::ostream &os, int indent ) const {
224 using std::endl;
225 using std::string;
226
227 printEnums( qualifiers.begin(), qualifiers.end(), DeclarationNode::qualifierName, os );
228
229 if ( forall ) {
230 os << "forall " << endl;
231 forall->printList( os, indent+4 );
232 }
233
234 switch ( kind ) {
235 case Unknown:
236 os << "entity of unknown type ";
237 break;
238 case Pointer:
239 os << "pointer ";
240 if ( base ) {
241 os << "to ";
242 base->print( os, indent );
243 }
244 break;
245 case EnumConstant:
246 os << "enumeration constant ";
247 break;
248 case Basic:
249 printEnums( basic->modifiers.begin(), basic->modifiers.end(), DeclarationNode::modifierName, os );
250 printEnums( basic->typeSpec.begin(), basic->typeSpec.end(), DeclarationNode::basicTypeName, os );
251 break;
252 case Array:
253 if ( array->isStatic ) {
254 os << "static ";
255 }
256 if ( array->dimension ) {
257 os << "array of ";
258 array->dimension->printOneLine( os, indent );
259 } else if ( array->isVarLen ) {
260 os << "variable-length array of ";
261 } else {
262 os << "open array of ";
263 }
264 if ( base ) {
265 base->print( os, indent );
266 }
267 break;
268 case Function:
269 os << "function" << endl;
270 if ( function->params ) {
271 os << string( indent+2, ' ' ) << "with parameters " << endl;
272 function->params->printList( os, indent+4 );
273 } else {
274 os << string( indent+2, ' ' ) << "with no parameters " << endl;
275 }
276 if ( function->idList ) {
277 os << string( indent+2, ' ' ) << "with old-style identifier list " << endl;
278 function->idList->printList( os, indent+4 );
279 }
280 if ( function->oldDeclList ) {
281 os << string( indent+2, ' ' ) << "with old-style declaration list " << endl;
282 function->oldDeclList->printList( os, indent+4 );
283 }
284 os << string( indent+2, ' ' ) << "returning ";
285 if ( base ) {
286 base->print( os, indent+4 );
287 } else {
288 os << "nothing ";
289 }
290 os << endl;
291 if ( function->hasBody ) {
292 os << string( indent+2, ' ' ) << "with body " << endl;
293 }
294 if ( function->body ) {
295 function->body->printList( os, indent+2 );
296 }
297 break;
298 case Aggregate:
299 os << DeclarationNode::tyConName[ aggregate->kind ] << ' ' << aggregate->name << endl;
300 if ( aggregate->params ) {
301 os << string( indent+2, ' ' ) << "with type parameters " << endl;
302 aggregate->params->printList( os, indent+4 );
303 }
304 if ( aggregate->actuals ) {
305 os << string( indent+2, ' ' ) << "instantiated with actual parameters " << endl;
306 aggregate->actuals->printList( os, indent+4 );
307 }
308 if ( aggregate->members ) {
309 os << string( indent+2, ' ' ) << "with members " << endl;
310 aggregate->members->printList( os, indent+4 );
311/// } else {
312/// os << string( indent+2, ' ' ) << "with no members " << endl;
313 }
314 break;
315 case AggregateInst:
316 if ( aggInst->aggregate ) {
317 os << "instance of " ;
318 aggInst->aggregate->print( os, indent );
319 } else {
320 os << "instance of an unspecified aggregate ";
321 }
322 if ( aggInst->params ) {
323 os << string( indent+2, ' ' ) << "with parameters " << endl;
324 aggInst->params->printList( os, indent+2 );
325 }
326 break;
327 case Enum:
328 os << "enumeration ";
329 if ( enumeration->constants ) {
330 os << "with constants" << endl;
331 enumeration->constants->printList( os, indent+2 );
332 }
333 break;
334 case SymbolicInst:
335 os << "instance of type " << symbolic->name;
336 if ( symbolic->actuals ) {
337 os << " with parameters" << endl;
338 symbolic->actuals->printList( os, indent + 2 );
339 }
340 break;
341 case Symbolic:
342 if ( symbolic->isTypedef ) {
343 os << "typedef definition ";
344 } else {
345 os << "type definition ";
346 }
347 if ( symbolic->params ) {
348 os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
349 symbolic->params->printList( os, indent + 2 );
350 }
351 if ( symbolic->assertions ) {
352 os << endl << string( indent+2, ' ' ) << "with assertions" << endl;
353 symbolic->assertions->printList( os, indent + 4 );
354 os << string( indent+2, ' ' );
355 }
356 if ( base ) {
357 os << "for ";
358 base->print( os, indent + 2 );
359 }
360 break;
361 case Variable:
362 os << DeclarationNode::typeClassName[ variable->tyClass ] << " variable ";
363 if ( variable->assertions ) {
364 os << endl << string( indent+2, ' ' ) << "with assertions" << endl;
365 variable->assertions->printList( os, indent + 4 );
366 os << string( indent+2, ' ' );
367 }
368 break;
369 case Tuple:
370 os << "tuple ";
371 if ( tuple->members ) {
372 os << "with members " << endl;
373 tuple->members->printList( os, indent + 2 );
374 }
375 break;
376
377 case Typeof:
378 os << "type-of expression ";
379 if ( typeexpr->expr ) {
380 typeexpr->expr->print( os, indent + 2 );
381 }
382 break;
383
384 case Attr:
385 os << "attribute type decl " << attr->name << " applied to ";
386 if ( attr->expr ) {
387 attr->expr->print( os, indent + 2 );
388 }
389 if ( attr->type ) {
390 attr->type->print( os, indent + 2 );
391 }
392 break;
393 }
394}
395
396TypeData *TypeData::extractAggregate( bool toplevel ) const {
397 TypeData *ret = 0;
398
399 switch ( kind ) {
400 case Aggregate:
401 if ( !toplevel && aggregate->members ) {
402 ret = clone();
403 ret->qualifiers.clear();
404 }
405 break;
406 case Enum:
407 if ( !toplevel && enumeration->constants ) {
408 ret = clone();
409 ret->qualifiers.clear();
410 }
411 break;
412 case AggregateInst:
413 if ( aggInst->aggregate ) {
414 ret = aggInst->aggregate->extractAggregate( false );
415 }
416 break;
417 default:
418 if ( base ) {
419 ret = base->extractAggregate( false );
420 }
421 }
422 return ret;
423}
424
425void buildForall( const DeclarationNode *firstNode, std::list< TypeDecl* > &outputList ) {
426
427 buildList( firstNode, outputList );
428 for ( std::list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
429 if ( (*i)->get_kind() == TypeDecl::Any ) {
430 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
431 assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
432 assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
433 assignType->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
434 (*i)->get_assertions().push_front( new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false ) );
435 }
436 }
437}
438
439Declaration *TypeData::buildDecl( std::string name, Declaration::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init ) const {
440 if ( kind == TypeData::Function ) {
441 FunctionDecl *decl;
442 if ( function->hasBody ) {
443 if ( function->body ) {
444 Statement *stmt = function->body->build();
445 CompoundStmt *body = dynamic_cast< CompoundStmt* >( stmt );
446 assert( body );
447 decl = new FunctionDecl( name, sc, linkage, buildFunction(), body, isInline );
448 } else {
449 // std::list<Label> ls;
450 decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list<Label>() ), isInline );
451 }
452 } else {
453 decl = new FunctionDecl( name, sc, linkage, buildFunction(), 0, isInline );
454 }
455 for ( DeclarationNode *cur = function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_link() ) ) {
456 if ( cur->get_name() != "" ) {
457 decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() );
458 }
459 }
460 buildList( function->oldDeclList, decl->get_oldDecls() );
461 return decl;
462 } else if ( kind == TypeData::Aggregate ) {
463 return buildAggregate();
464 } else if ( kind == TypeData::Enum ) {
465 return buildEnum();
466 } else if ( kind == TypeData::Symbolic ) {
467 return buildSymbolic( name, sc );
468 } else if ( kind == TypeData::Variable ) {
469 return buildVariable();
470 } else {
471 if ( isInline ) {
472 throw SemanticError( "invalid inline specification in declaration of ", this );
473 } else {
474 return new ObjectDecl( name, sc, linkage, bitfieldWidth, build(), init );
475 }
476 }
477 return 0;
478}
479
480Type *TypeData::build() const {
481
482 switch ( kind ) {
483 case Unknown:
484 // fill in implicit int
485 return new BasicType( buildQualifiers(), BasicType::SignedInt );
486
487 case Basic:
488 return buildBasicType();
489
490 case Pointer:
491 return buildPointer();
492
493 case Array:
494 return buildArray();
495
496 case Function:
497 return buildFunction();
498
499 case AggregateInst:
500 return buildAggInst();
501
502 case EnumConstant:
503 // the name gets filled in later -- by SymTab::Validate
504 return new EnumInstType( buildQualifiers(), "" );
505
506 case SymbolicInst:
507 return buildSymbolicInst();;
508
509 case Tuple:
510 return buildTuple();
511
512 case Typeof:
513 return buildTypeof();
514
515 case Attr:
516 return buildAttr();
517
518 case Symbolic:
519 case Enum:
520 case Aggregate:
521 case Variable:
522 assert( false );
523 }
524
525 return 0;
526}
527
528Type::Qualifiers TypeData::buildQualifiers() const {
529 Type::Qualifiers q;
530 for ( std::list< DeclarationNode::Qualifier >::const_iterator i = qualifiers.begin(); i != qualifiers.end(); ++i ) {
531 switch ( *i ) {
532 case DeclarationNode::Const:
533 q.isConst = true;
534 break;
535 case DeclarationNode::Volatile:
536 q.isVolatile = true;
537 break;
538 case DeclarationNode::Restrict:
539 q.isRestrict = true;
540 break;
541 case DeclarationNode::Lvalue:
542 q.isLvalue = true;
543 break;
544 }
545 }
546 return q;
547}
548
549Type *TypeData::buildBasicType() const {
550 static const BasicType::Kind kindMap[] = { BasicType::Char, BasicType::SignedInt, BasicType::Float, BasicType::Double,
551 BasicType::Char /* void */, BasicType::Bool, BasicType::DoubleComplex,
552 BasicType::DoubleImaginary };
553 bool init = false;
554 bool sawDouble = false;
555 bool sawSigned = false;
556 BasicType::Kind ret;
557
558 for ( std::list< DeclarationNode::BasicType >::const_iterator i = basic->typeSpec.begin(); i != basic->typeSpec.end(); ++i ) {
559 if ( !init ) {
560 init = true;
561 if ( *i == DeclarationNode::Void ) {
562 if ( basic->typeSpec.size() != 1 || !basic->modifiers.empty() ) {
563 throw SemanticError( "invalid type specifier \"void\" in type: ", this );
564 } else {
565 return new VoidType( buildQualifiers() );
566 }
567 } else {
568 ret = kindMap[ *i ];
569 }
570 } else {
571 switch ( *i ) {
572 case DeclarationNode::Float:
573 if ( sawDouble ) {
574 throw SemanticError( "invalid type specifier \"float\" in type: ", this );
575 } else {
576 switch ( ret ) {
577 case BasicType::DoubleComplex:
578 ret = BasicType::FloatComplex;
579 break;
580 case BasicType::DoubleImaginary:
581 ret = BasicType::FloatImaginary;
582 break;
583 default:
584 throw SemanticError( "invalid type specifier \"float\" in type: ", this );
585 }
586 }
587 break;
588 case DeclarationNode::Double:
589 if ( sawDouble ) {
590 throw SemanticError( "duplicate type specifier \"double\" in type: ", this );
591 } else {
592 switch ( ret ) {
593 case BasicType::DoubleComplex:
594 case BasicType::DoubleImaginary:
595 break;
596 default:
597 throw SemanticError( "invalid type specifier \"double\" in type: ", this );
598 }
599 }
600 break;
601
602 case DeclarationNode::Complex:
603 switch ( ret ) {
604 case BasicType::Float:
605 ret = BasicType::FloatComplex;
606 break;
607
608 case BasicType::Double:
609 ret = BasicType::DoubleComplex;
610 break;
611 default:
612 throw SemanticError( "invalid type specifier \"_Complex\" in type: ", this );
613 }
614 break;
615
616 case DeclarationNode::Imaginary:
617 switch ( ret ) {
618 case BasicType::Float:
619 ret = BasicType::FloatImaginary;
620 break;
621
622 case BasicType::Double:
623 ret = BasicType::DoubleImaginary;
624 break;
625 default:
626 throw SemanticError( "invalid type specifier \"_Imaginary\" in type: ", this );
627 }
628 break;
629
630 default:
631 throw SemanticError( std::string( "invalid type specifier \"" ) + DeclarationNode::basicTypeName[ *i ] + "\" in type: ", this );
632 }
633 }
634 if ( *i == DeclarationNode::Double ) {
635 sawDouble = true;
636 }
637 }
638
639 for ( std::list< DeclarationNode::Modifier >::const_iterator i = basic->modifiers.begin(); i != basic->modifiers.end(); ++i ) {
640 switch ( *i ) {
641 case DeclarationNode::Long:
642 if ( !init ) {
643 init = true;
644 ret = BasicType::LongSignedInt;
645 } else {
646 switch ( ret ) {
647 case BasicType::SignedInt:
648 ret = BasicType::LongSignedInt;
649 break;
650 case BasicType::UnsignedInt:
651 ret = BasicType::LongUnsignedInt;
652 break;
653 case BasicType::LongSignedInt:
654 ret = BasicType::LongLongSignedInt;
655 break;
656 case BasicType::LongUnsignedInt:
657 ret = BasicType::LongLongUnsignedInt;
658 break;
659 case BasicType::Double:
660 ret = BasicType::LongDouble;
661 break;
662 case BasicType::DoubleComplex:
663 ret = BasicType::LongDoubleComplex;
664 break;
665 case BasicType::DoubleImaginary:
666 ret = BasicType::LongDoubleImaginary;
667 break;
668 default:
669 throw SemanticError( "invalid type modifier \"long\" in type: ", this );
670 }
671 }
672 break;
673 case DeclarationNode::Short:
674 if ( !init ) {
675 init = true;
676 ret = BasicType::ShortSignedInt;
677 } else {
678 switch ( ret ) {
679 case BasicType::SignedInt:
680 ret = BasicType::ShortSignedInt;
681 break;
682 case BasicType::UnsignedInt:
683 ret = BasicType::ShortUnsignedInt;
684 break;
685 default:
686 throw SemanticError( "invalid type modifier \"short\" in type: ", this );
687 }
688 }
689 break;
690 case DeclarationNode::Signed:
691 if ( !init ) {
692 init = true;
693 ret = BasicType::SignedInt;
694 } else if ( sawSigned ) {
695 throw SemanticError( "duplicate type modifer \"signed\" in type: ", this );
696 } else {
697 switch ( ret ) {
698 case BasicType::LongLongSignedInt: // PAB
699 ret = BasicType::LongLongUnsignedInt;
700 break;
701 case BasicType::LongSignedInt:
702 ret = BasicType::LongUnsignedInt;
703 break;
704 case BasicType::SignedInt:
705 case BasicType::ShortSignedInt:
706 break;
707 case BasicType::Char:
708 ret = BasicType::SignedChar;
709 break;
710 default:
711 throw SemanticError( "invalid type modifer \"signed\" in type: ", this );
712 }
713 }
714 break;
715 case DeclarationNode::Unsigned:
716 if ( !init ) {
717 init = true;
718 ret = BasicType::UnsignedInt;
719 } else if ( sawSigned ) {
720 throw SemanticError( "invalid type modifer \"unsigned\" in type: ", this );
721 } else {
722 switch ( ret ) {
723 case BasicType::LongLongSignedInt: // PAB
724 ret = BasicType::LongLongUnsignedInt;
725 break;
726 case BasicType::LongSignedInt:
727 ret = BasicType::LongUnsignedInt;
728 break;
729 case BasicType::SignedInt:
730 ret = BasicType::UnsignedInt;
731 break;
732 case BasicType::ShortSignedInt:
733 ret = BasicType::ShortUnsignedInt;
734 break;
735 case BasicType::Char:
736 ret = BasicType::UnsignedChar;
737 break;
738 default:
739 throw SemanticError( "invalid type modifer \"unsigned\" in type: ", this );
740 }
741 }
742 break;
743 }
744
745 if ( *i == DeclarationNode::Signed ) {
746 sawSigned = true;
747 }
748 }
749
750 BasicType *bt;
751 if ( !init ) {
752 bt = new BasicType( buildQualifiers(), BasicType::SignedInt );
753 } else {
754 bt = new BasicType( buildQualifiers(), ret );
755 }
756 buildForall( forall, bt->get_forall() );
757 return bt;
758}
759
760
761PointerType *TypeData::buildPointer() const {
762 PointerType *pt;
763 if ( base ) {
764 pt = new PointerType( buildQualifiers(), base->build() );
765 } else {
766 pt = new PointerType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
767 }
768 buildForall( forall, pt->get_forall() );
769 return pt;
770}
771
772ArrayType *TypeData::buildArray() const {
773
774 ArrayType *at;
775 if ( base ) {
776 at = new ArrayType( buildQualifiers(), base->build(), maybeBuild< Expression >( array->dimension ),
777 array->isVarLen, array->isStatic );
778 } else {
779 at = new ArrayType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ),
780 maybeBuild< Expression >( array->dimension ), array->isVarLen, array->isStatic );
781 }
782 buildForall( forall, at->get_forall() );
783 return at;
784}
785
786FunctionType *TypeData::buildFunction() const {
787 assert( kind == Function );
788 bool hasEllipsis = function->params ? function->params->get_hasEllipsis() : true;
789 if ( !function->params ) hasEllipsis = !function->newStyle;
790 FunctionType *ft = new FunctionType( buildQualifiers(), hasEllipsis );
791 buildList( function->params, ft->get_parameters() );
792 buildForall( forall, ft->get_forall() );
793 if ( base ) {
794 switch ( base->kind ) {
795 case Tuple:
796 buildList( base->tuple->members, ft->get_returnVals() );
797 break;
798 default:
799 ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( base->buildDecl( "", Declaration::NoStorageClass, 0, false, LinkageSpec::Cforall ) ) );
800 }
801 } else {
802 ft->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
803 }
804 return ft;
805}
806
807AggregateDecl *TypeData::buildAggregate() const {
808 assert( kind == Aggregate );
809 AggregateDecl *at;
810 switch ( aggregate->kind ) {
811 case DeclarationNode::Struct:
812 at = new StructDecl( aggregate->name );
813 break;
814
815 case DeclarationNode::Union:
816 at = new UnionDecl( aggregate->name );
817 break;
818
819 case DeclarationNode::Context:
820 at = new ContextDecl( aggregate->name );
821 break;
822
823 default:
824 assert( false );
825 }
826
827 buildList( aggregate->params, at->get_parameters() );
828 buildList( aggregate->members, at->get_members() );
829
830 return at;
831}
832
833/// namespace {
834/// Type*
835/// makeType( Declaration* decl )
836/// {
837/// if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {
838/// return dwt->get_type()->clone();
839/// } else {
840/// return 0;
841/// }
842/// }
843/// }
844
845ReferenceToType *TypeData::buildAggInst() const {
846 assert( kind == AggregateInst );
847 std::string name;
848
849 ReferenceToType *ret;
850 if ( aggInst->aggregate->kind == Enum ) {
851 ret = new EnumInstType( buildQualifiers(), aggInst->aggregate->enumeration->name );
852 } else {
853 assert( aggInst->aggregate->kind == Aggregate );
854 switch ( aggInst->aggregate->aggregate->kind ) {
855 case DeclarationNode::Struct:
856 ret = new StructInstType( buildQualifiers(), aggInst->aggregate->aggregate->name );
857 break;
858 case DeclarationNode::Union:
859 ret = new UnionInstType( buildQualifiers(), aggInst->aggregate->aggregate->name );
860 break;
861 case DeclarationNode::Context:
862 ret = new ContextInstType( buildQualifiers(), aggInst->aggregate->aggregate->name );
863 break;
864 default:
865 assert( false );
866 }
867 }
868 buildList( aggInst->params, ret->get_parameters() );
869 buildForall( forall, ret->get_forall() );
870 return ret;
871}
872
873NamedTypeDecl *TypeData::buildSymbolic( const std::string &name, Declaration::StorageClass sc ) const {
874 assert( kind == Symbolic );
875 NamedTypeDecl *ret;
876 if ( symbolic->isTypedef ) {
877 ret = new TypedefDecl( name, sc, maybeBuild< Type >( base ) );
878 } else {
879 ret = new TypeDecl( name, sc, maybeBuild< Type >( base ), TypeDecl::Any );
880 }
881 buildList( symbolic->params, ret->get_parameters() );
882 buildList( symbolic->assertions, ret->get_assertions() );
883 return ret;
884}
885
886TypeDecl *TypeData::buildVariable() const {
887 assert( kind == Variable );
888 static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
889
890 TypeDecl *ret = new TypeDecl( variable->name, Declaration::NoStorageClass, 0, kindMap[ variable->tyClass ] );
891 buildList( variable->assertions, ret->get_assertions() );
892
893 return ret;
894}
895
896EnumDecl *TypeData::buildEnum() const {
897 assert( kind == Enum );
898 EnumDecl *ret = new EnumDecl( enumeration->name );
899 buildList( enumeration->constants, ret->get_members() );
900
901 return ret;
902}
903
904TypeInstType *TypeData::buildSymbolicInst() const {
905 assert( kind == SymbolicInst );
906
907
908 TypeInstType *ret = new TypeInstType( buildQualifiers(), symbolic->name, false );
909 buildList( symbolic->actuals, ret->get_parameters() );
910 buildForall( forall, ret->get_forall() );
911
912 return ret;
913}
914
915TupleType *TypeData::buildTuple() const {
916 assert( kind == Tuple );
917
918
919 TupleType *ret = new TupleType( buildQualifiers() );
920 buildTypeList( tuple->members, ret->get_types() );
921 buildForall( forall, ret->get_forall() );
922
923 return ret;
924}
925
926TypeofType *TypeData::buildTypeof() const {
927 assert( kind == Typeof );
928 assert( typeexpr );
929 assert( typeexpr->expr );
930 TypeofType *ret = new TypeofType( buildQualifiers(), typeexpr->expr->build() );
931
932 return ret;
933}
934
935AttrType *TypeData::buildAttr() const {
936 assert( kind == Attr );
937 assert( attr );
938 AttrType *ret;
939 if ( attr->expr ) {
940 ret = new AttrType( buildQualifiers(), attr->name, attr->expr->build() );
941 } else {
942 assert( attr->type );
943 ret = new AttrType( buildQualifiers(), attr->name, attr->type->buildType() );
944 }
945
946 return ret;
947}
Note: See TracBrowser for help on using the repository browser.