source: translator/Parser/TypeData.cc@ 0b8cd722

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 stuck-waitfor-destruct with_gc
Last change on this file since 0b8cd722 was 0b8cd722, checked in by Peter A. Buhr <pabuhr@…>, 11 years ago

fix uninitialized value, fix memory reads after frees
  • Property mode set to 100644
File size: 25.6 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::SignedInt:
699 case BasicType::ShortSignedInt:
700 break;
701 case BasicType::Char:
702 ret = BasicType::SignedChar;
703 break;
704 default:
705 throw SemanticError( "invalid type modifer \"signed\" in type: ", this );
706 }
707 }
708 break;
709 case DeclarationNode::Unsigned:
710 if ( !init ) {
711 init = true;
712 ret = BasicType::UnsignedInt;
713 } else if ( sawSigned ) {
714 throw SemanticError( "invalid type modifer \"unsigned\" in type: ", this );
715 } else {
716 switch ( ret ) {
717 case BasicType::LongSignedInt:
718 ret = BasicType::LongUnsignedInt;
719 break;
720 case BasicType::SignedInt:
721 ret = BasicType::UnsignedInt;
722 break;
723 case BasicType::ShortSignedInt:
724 ret = BasicType::ShortUnsignedInt;
725 break;
726 case BasicType::Char:
727 ret = BasicType::UnsignedChar;
728 break;
729 default:
730 throw SemanticError( "invalid type modifer \"unsigned\" in type: ", this );
731 }
732 }
733 break;
734 }
735
736 if ( *i == DeclarationNode::Signed ) {
737 sawSigned = true;
738 }
739 }
740
741 BasicType *bt;
742 if ( !init ) {
743 bt = new BasicType( buildQualifiers(), BasicType::SignedInt );
744 } else {
745 bt = new BasicType( buildQualifiers(), ret );
746 }
747 buildForall( forall, bt->get_forall() );
748 return bt;
749}
750
751
752PointerType *TypeData::buildPointer() const {
753 PointerType *pt;
754 if ( base ) {
755 pt = new PointerType( buildQualifiers(), base->build() );
756 } else {
757 pt = new PointerType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
758 }
759 buildForall( forall, pt->get_forall() );
760 return pt;
761}
762
763ArrayType *TypeData::buildArray() const {
764
765 ArrayType *at;
766 if ( base ) {
767 at = new ArrayType( buildQualifiers(), base->build(), maybeBuild< Expression >( array->dimension ),
768 array->isVarLen, array->isStatic );
769 } else {
770 at = new ArrayType( buildQualifiers(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ),
771 maybeBuild< Expression >( array->dimension ), array->isVarLen, array->isStatic );
772 }
773 buildForall( forall, at->get_forall() );
774 return at;
775}
776
777FunctionType *TypeData::buildFunction() const {
778 assert( kind == Function );
779 bool hasEllipsis = function->params ? function->params->get_hasEllipsis() : true;
780 if ( !function->params ) hasEllipsis = !function->newStyle;
781 FunctionType *ft = new FunctionType( buildQualifiers(), hasEllipsis );
782 buildList( function->params, ft->get_parameters() );
783 buildForall( forall, ft->get_forall() );
784 if ( base ) {
785 switch ( base->kind ) {
786 case Tuple:
787 buildList( base->tuple->members, ft->get_returnVals() );
788 break;
789 default:
790 ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( base->buildDecl( "", Declaration::NoStorageClass, 0, false, LinkageSpec::Cforall ) ) );
791 }
792 } else {
793 ft->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
794 }
795 return ft;
796}
797
798AggregateDecl *TypeData::buildAggregate() const {
799 assert( kind == Aggregate );
800 AggregateDecl *at;
801 switch ( aggregate->kind ) {
802 case DeclarationNode::Struct:
803 at = new StructDecl( aggregate->name );
804 break;
805
806 case DeclarationNode::Union:
807 at = new UnionDecl( aggregate->name );
808 break;
809
810 case DeclarationNode::Context:
811 at = new ContextDecl( aggregate->name );
812 break;
813
814 default:
815 assert( false );
816 }
817
818 buildList( aggregate->params, at->get_parameters() );
819 buildList( aggregate->members, at->get_members() );
820
821 return at;
822}
823
824/// namespace {
825/// Type*
826/// makeType( Declaration* decl )
827/// {
828/// if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {
829/// return dwt->get_type()->clone();
830/// } else {
831/// return 0;
832/// }
833/// }
834/// }
835
836ReferenceToType *TypeData::buildAggInst() const {
837 assert( kind == AggregateInst );
838 std::string name;
839
840 ReferenceToType *ret;
841 if ( aggInst->aggregate->kind == Enum ) {
842 ret = new EnumInstType( buildQualifiers(), aggInst->aggregate->enumeration->name );
843 } else {
844 assert( aggInst->aggregate->kind == Aggregate );
845 switch ( aggInst->aggregate->aggregate->kind ) {
846 case DeclarationNode::Struct:
847 ret = new StructInstType( buildQualifiers(), aggInst->aggregate->aggregate->name );
848 break;
849 case DeclarationNode::Union:
850 ret = new UnionInstType( buildQualifiers(), aggInst->aggregate->aggregate->name );
851 break;
852 case DeclarationNode::Context:
853 ret = new ContextInstType( buildQualifiers(), aggInst->aggregate->aggregate->name );
854 break;
855 default:
856 assert( false );
857 }
858 }
859 buildList( aggInst->params, ret->get_parameters() );
860 buildForall( forall, ret->get_forall() );
861 return ret;
862}
863
864NamedTypeDecl *TypeData::buildSymbolic( const std::string &name, Declaration::StorageClass sc ) const {
865 assert( kind == Symbolic );
866 NamedTypeDecl *ret;
867 if ( symbolic->isTypedef ) {
868 ret = new TypedefDecl( name, sc, maybeBuild< Type >( base ) );
869 } else {
870 ret = new TypeDecl( name, sc, maybeBuild< Type >( base ), TypeDecl::Any );
871 }
872 buildList( symbolic->params, ret->get_parameters() );
873 buildList( symbolic->assertions, ret->get_assertions() );
874 return ret;
875}
876
877TypeDecl *TypeData::buildVariable() const {
878 assert( kind == Variable );
879 static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
880
881 TypeDecl *ret = new TypeDecl( variable->name, Declaration::NoStorageClass, 0, kindMap[ variable->tyClass ] );
882 buildList( variable->assertions, ret->get_assertions() );
883
884 return ret;
885}
886
887EnumDecl *TypeData::buildEnum() const {
888 assert( kind == Enum );
889 EnumDecl *ret = new EnumDecl( enumeration->name );
890 buildList( enumeration->constants, ret->get_members() );
891
892 return ret;
893}
894
895TypeInstType *TypeData::buildSymbolicInst() const {
896 assert( kind == SymbolicInst );
897
898
899 TypeInstType *ret = new TypeInstType( buildQualifiers(), symbolic->name, false );
900 buildList( symbolic->actuals, ret->get_parameters() );
901 buildForall( forall, ret->get_forall() );
902
903 return ret;
904}
905
906TupleType *TypeData::buildTuple() const {
907 assert( kind == Tuple );
908
909
910 TupleType *ret = new TupleType( buildQualifiers() );
911 buildTypeList( tuple->members, ret->get_types() );
912 buildForall( forall, ret->get_forall() );
913
914 return ret;
915}
916
917TypeofType *TypeData::buildTypeof() const {
918 assert( kind == Typeof );
919 assert( typeexpr );
920 assert( typeexpr->expr );
921 TypeofType *ret = new TypeofType( buildQualifiers(), typeexpr->expr->build() );
922
923 return ret;
924}
925
926AttrType *TypeData::buildAttr() const {
927 assert( kind == Attr );
928 assert( attr );
929 AttrType *ret;
930 if ( attr->expr ) {
931 ret = new AttrType( buildQualifiers(), attr->name, attr->expr->build() );
932 } else {
933 assert( attr->type );
934 ret = new AttrType( buildQualifiers(), attr->name, attr->type->buildType() );
935 }
936
937 return ret;
938}
Note: See TracBrowser for help on using the repository browser.