source: src/Parser/TypeData.cc@ 2bae7307

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 2bae7307 was 843054c2, checked in by Peter A. Buhr <pabuhr@…>, 10 years ago

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