source: src/Parser/TypeData.cc@ bdc8591

Last change on this file since bdc8591 was 057608a, checked in by Andrew Beach <ajbeach@…>, 19 months ago

Parser clean-up: Removed an unused field, added a comment, fixed a memory leak and reformated a function.
  • Property mode set to 100644
File size: 51.0 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 : Fri Feb 23 08:58:30 2024
13// Update Count : 734
14//
15
16#include "TypeData.h"
17
18#include <cassert> // for assert
19#include <ostream> // for operator<<, ostream, basic_ostream
20
21#include "AST/Decl.hpp" // for AggregateDecl, ObjectDecl, TypeDe...
22#include "AST/Attribute.hpp" // for Attribute
23#include "AST/Init.hpp" // for SingleInit, ListInit
24#include "AST/Print.hpp" // for print
25#include "Common/SemanticError.h" // for SemanticError
26#include "Common/utility.h" // for splice, spliceBegin
27#include "Common/Iterate.hpp" // for reverseIterate
28#include "Parser/ExpressionNode.h" // for ExpressionNode
29#include "Parser/StatementNode.h" // for StatementNode
30
31class Attribute;
32
33using namespace std;
34
35// These must harmonize with the corresponding enumerations in the header.
36const char * TypeData::basicTypeNames[] = {
37 "void", "_Bool", "char", "int", "int128",
38 "float", "double", "long double", "float80", "float128",
39 "_float16", "_float32", "_float32x", "_float64", "_float64x", "_float128", "_float128x",
40 "NoBasicTypeNames"
41};
42const char * TypeData::complexTypeNames[] = {
43 "_Complex", "NoComplexTypeNames", "_Imaginary"
44}; // Imaginary unsupported => parse, but make invisible and print error message
45const char * TypeData::signednessNames[] = {
46 "signed", "unsigned", "NoSignednessNames"
47};
48const char * TypeData::lengthNames[] = {
49 "short", "long", "long long", "NoLengthNames"
50};
51const char * TypeData::builtinTypeNames[] = {
52 "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames"
53};
54
55TypeData::TypeData( Kind k ) : location( yylloc ), kind( k ), base( nullptr ), forall( nullptr ) /*, PTR1( (void*)(0xdeadbeefdeadbeef)), PTR2( (void*)(0xdeadbeefdeadbeef) ) */ {
56 switch ( kind ) {
57 case Unknown:
58 case Pointer:
59 case Reference:
60 case EnumConstant:
61 case GlobalScope:
62 case Basic:
63 // No unique data to initialize.
64 break;
65 case Array:
66 array.dimension = nullptr;
67 array.isVarLen = false;
68 array.isStatic = false;
69 break;
70 case Function:
71 function.params = nullptr;
72 function.idList = nullptr;
73 function.oldDeclList = nullptr;
74 function.body = nullptr;
75 function.withExprs = nullptr;
76 break;
77 case Enum:
78 enumeration.name = nullptr;
79 enumeration.constants = nullptr;
80 enumeration.body = false;
81 enumeration.anon = false;
82 break;
83 case Aggregate:
84 aggregate.kind = ast::AggregateDecl::NoAggregate;
85 aggregate.name = nullptr;
86 aggregate.params = nullptr;
87 aggregate.actuals = nullptr;
88 aggregate.fields = nullptr;
89 aggregate.body = false;
90 aggregate.parent = nullptr;
91 aggregate.anon = false;
92 break;
93 case AggregateInst:
94 aggInst.aggregate = nullptr;
95 aggInst.params = nullptr;
96 aggInst.hoistType = false;
97 break;
98 case Symbolic:
99 case SymbolicInst:
100 symbolic.name = nullptr;
101 symbolic.params = nullptr;
102 symbolic.actuals = nullptr;
103 symbolic.assertions = nullptr;
104 break;
105 case Tuple:
106 tuple = nullptr;
107 break;
108 case Typeof:
109 case Basetypeof:
110 typeexpr = nullptr;
111 break;
112 case Vtable:
113 case Builtin:
114 // No unique data to initialize.
115 break;
116 case Qualified:
117 qualified.parent = nullptr;
118 qualified.child = nullptr;
119 break;
120 } // switch
121} // TypeData::TypeData
122
123
124TypeData::~TypeData() {
125 delete base;
126 delete forall;
127
128 switch ( kind ) {
129 case Unknown:
130 case Pointer:
131 case Reference:
132 case EnumConstant:
133 case GlobalScope:
134 case Basic:
135 // No unique data to deconstruct.
136 break;
137 case Array:
138 delete array.dimension;
139 break;
140 case Function:
141 delete function.params;
142 delete function.idList;
143 delete function.oldDeclList;
144 delete function.body;
145 delete function.withExprs;
146 break;
147 case Aggregate:
148 delete aggregate.name;
149 delete aggregate.params;
150 delete aggregate.actuals;
151 delete aggregate.fields;
152 break;
153 case AggregateInst:
154 delete aggInst.aggregate;
155 delete aggInst.params;
156 break;
157 case Enum:
158 delete enumeration.name;
159 delete enumeration.constants;
160 break;
161 case Symbolic:
162 case SymbolicInst:
163 delete symbolic.name;
164 delete symbolic.params;
165 delete symbolic.actuals;
166 delete symbolic.assertions;
167 break;
168 case Tuple:
169 delete tuple;
170 break;
171 case Typeof:
172 case Basetypeof:
173 delete typeexpr;
174 break;
175 case Vtable:
176 case Builtin:
177 // No unique data to deconstruct.
178 break;
179 case Qualified:
180 delete qualified.parent;
181 delete qualified.child;
182 break;
183 } // switch
184} // TypeData::~TypeData
185
186
187TypeData * TypeData::clone() const {
188 TypeData * newtype = new TypeData( kind );
189 newtype->qualifiers = qualifiers;
190 newtype->base = maybeCopy( base );
191 newtype->forall = maybeCopy( forall );
192
193 switch ( kind ) {
194 case Unknown:
195 case EnumConstant:
196 case Pointer:
197 case Reference:
198 case GlobalScope:
199 // nothing else to copy
200 break;
201 case Basic:
202 newtype->basictype = basictype;
203 newtype->complextype = complextype;
204 newtype->signedness = signedness;
205 newtype->length = length;
206 break;
207 case Array:
208 newtype->array.dimension = maybeCopy( array.dimension );
209 newtype->array.isVarLen = array.isVarLen;
210 newtype->array.isStatic = array.isStatic;
211 break;
212 case Function:
213 newtype->function.params = maybeCopy( function.params );
214 newtype->function.idList = maybeCopy( function.idList );
215 newtype->function.oldDeclList = maybeCopy( function.oldDeclList );
216 newtype->function.body = maybeCopy( function.body );
217 newtype->function.withExprs = maybeCopy( function.withExprs );
218 break;
219 case Aggregate:
220 newtype->aggregate.kind = aggregate.kind;
221 newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
222 newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
223 newtype->aggregate.params = maybeCopy( aggregate.params );
224 newtype->aggregate.actuals = maybeCopy( aggregate.actuals );
225 newtype->aggregate.fields = maybeCopy( aggregate.fields );
226 newtype->aggregate.attributes = aggregate.attributes;
227 newtype->aggregate.body = aggregate.body;
228 newtype->aggregate.anon = aggregate.anon;
229 break;
230 case AggregateInst:
231 newtype->aggInst.aggregate = maybeCopy( aggInst.aggregate );
232 newtype->aggInst.params = maybeCopy( aggInst.params );
233 newtype->aggInst.hoistType = aggInst.hoistType;
234 break;
235 case Enum:
236 newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr;
237 newtype->enumeration.constants = maybeCopy( enumeration.constants );
238 newtype->enumeration.body = enumeration.body;
239 newtype->enumeration.anon = enumeration.anon;
240 break;
241 case Symbolic:
242 case SymbolicInst:
243 newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr;
244 newtype->symbolic.params = maybeCopy( symbolic.params );
245 newtype->symbolic.actuals = maybeCopy( symbolic.actuals );
246 newtype->symbolic.assertions = maybeCopy( symbolic.assertions );
247 newtype->symbolic.isTypedef = symbolic.isTypedef;
248 break;
249 case Tuple:
250 newtype->tuple = maybeCopy( tuple );
251 break;
252 case Typeof:
253 case Basetypeof:
254 newtype->typeexpr = maybeCopy( typeexpr );
255 break;
256 case Vtable:
257 break;
258 case Builtin:
259 assert( builtintype == Zero || builtintype == One );
260 newtype->builtintype = builtintype;
261 break;
262 case Qualified:
263 newtype->qualified.parent = maybeCopy( qualified.parent );
264 newtype->qualified.child = maybeCopy( qualified.child );
265 break;
266 } // switch
267 return newtype;
268} // TypeData::clone
269
270
271void TypeData::print( ostream &os, int indent ) const {
272 ast::print( os, qualifiers );
273
274 if ( forall ) {
275 os << "forall " << endl;
276 forall->printList( os, indent + 4 );
277 } // if
278
279 switch ( kind ) {
280 case Basic:
281 if ( signedness != NoSignedness ) os << signednessNames[ signedness ] << " ";
282 if ( length != NoLength ) os << lengthNames[ length ] << " ";
283 if ( complextype != NoComplexType ) os << complexTypeNames[ complextype ] << " ";
284 if ( basictype != NoBasicType ) os << basicTypeNames[ basictype ] << " ";
285 break;
286 case Pointer:
287 os << "pointer ";
288 if ( base ) {
289 os << "to ";
290 base->print( os, indent );
291 } // if
292 break;
293 case Reference:
294 os << "reference ";
295 if ( base ) {
296 os << "to ";
297 base->print( os, indent );
298 } // if
299 break;
300 case Array:
301 if ( array.isStatic ) {
302 os << "static ";
303 } // if
304 if ( array.dimension ) {
305 os << "array of ";
306 array.dimension->printOneLine( os, indent );
307 } else if ( array.isVarLen ) {
308 os << "variable-length array of ";
309 } else {
310 os << "open array of ";
311 } // if
312 if ( base ) {
313 base->print( os, indent );
314 } // if
315 break;
316 case Function:
317 os << "function" << endl;
318 if ( function.params ) {
319 os << string( indent + 2, ' ' ) << "with parameters " << endl;
320 function.params->printList( os, indent + 4 );
321 } else {
322 os << string( indent + 2, ' ' ) << "with no parameters" << endl;
323 } // if
324 if ( function.idList ) {
325 os << string( indent + 2, ' ' ) << "with old-style identifier list " << endl;
326 function.idList->printList( os, indent + 4 );
327 } // if
328 if ( function.oldDeclList ) {
329 os << string( indent + 2, ' ' ) << "with old-style declaration list " << endl;
330 function.oldDeclList->printList( os, indent + 4 );
331 } // if
332 os << string( indent + 2, ' ' ) << "returning ";
333 if ( base ) {
334 base->print( os, indent + 4 );
335 } else {
336 os << "nothing ";
337 } // if
338 os << endl;
339 if ( function.body ) {
340 os << string( indent + 2, ' ' ) << "with body " << endl;
341 function.body->printList( os, indent + 2 );
342 } // if
343 break;
344 case Aggregate:
345 os << ast::AggregateDecl::aggrString( aggregate.kind ) << ' ' << *aggregate.name << endl;
346 if ( aggregate.params ) {
347 os << string( indent + 2, ' ' ) << "with type parameters" << endl;
348 aggregate.params->printList( os, indent + 4 );
349 } // if
350 if ( aggregate.actuals ) {
351 os << string( indent + 2, ' ' ) << "instantiated with actual parameters" << endl;
352 aggregate.actuals->printList( os, indent + 4 );
353 } // if
354 if ( aggregate.fields ) {
355 os << string( indent + 2, ' ' ) << "with members" << endl;
356 aggregate.fields->printList( os, indent + 4 );
357 } // if
358 if ( aggregate.body ) {
359 os << string( indent + 2, ' ' ) << "with body" << endl;
360 } // if
361 if ( ! aggregate.attributes.empty() ) {
362 os << string( indent + 2, ' ' ) << "with attributes" << endl;
363 for ( ast::ptr<ast::Attribute> const & attr : reverseIterate( aggregate.attributes ) ) {
364 os << string( indent + 4, ' ' );
365 ast::print( os, attr, indent + 2 );
366 } // for
367 } // if
368 break;
369 case AggregateInst:
370 if ( aggInst.aggregate ) {
371 os << "instance of " ;
372 aggInst.aggregate->print( os, indent );
373 } else {
374 os << "instance of an unspecified aggregate ";
375 } // if
376 if ( aggInst.params ) {
377 os << string( indent + 2, ' ' ) << "with parameters" << endl;
378 aggInst.params->printList( os, indent + 2 );
379 } // if
380 break;
381 case Enum:
382 os << "enumeration " << *enumeration.name << endl;;
383 if ( enumeration.constants ) {
384 os << "with constants" << endl;
385 enumeration.constants->printList( os, indent + 2 );
386 } // if
387 if ( enumeration.body ) {
388 os << string( indent + 2, ' ' ) << "with body" << endl;
389 } // if
390 if ( base ) {
391 os << "for ";
392 base->print( os, indent + 2 );
393 } // if
394 break;
395 case EnumConstant:
396 os << "enumeration constant ";
397 break;
398 case Symbolic:
399 if ( symbolic.isTypedef ) {
400 os << "typedef definition ";
401 } else {
402 os << "type definition ";
403 } // if
404 if ( symbolic.params ) {
405 os << endl << string( indent + 2, ' ' ) << "with parameters" << endl;
406 symbolic.params->printList( os, indent + 2 );
407 } // if
408 if ( symbolic.assertions ) {
409 os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
410 symbolic.assertions->printList( os, indent + 4 );
411 os << string( indent + 2, ' ' );
412 } // if
413 if ( base ) {
414 os << "for ";
415 base->print( os, indent + 2 );
416 } // if
417 break;
418 case SymbolicInst:
419 os << *symbolic.name;
420 if ( symbolic.actuals ) {
421 os << "(";
422 symbolic.actuals->printList( os, indent + 2 );
423 os << ")";
424 } // if
425 break;
426 case Tuple:
427 os << "tuple ";
428 if ( tuple ) {
429 os << "with members" << endl;
430 tuple->printList( os, indent + 2 );
431 } // if
432 break;
433 case Basetypeof:
434 os << "base-";
435 #if defined(__GNUC__) && __GNUC__ >= 7
436 __attribute__((fallthrough));
437 #endif
438 // FALL THROUGH
439 case Typeof:
440 os << "type-of expression ";
441 if ( typeexpr ) {
442 typeexpr->print( os, indent + 2 );
443 } // if
444 break;
445 case Vtable:
446 os << "vtable";
447 break;
448 case Builtin:
449 os << builtinTypeNames[builtintype];
450 break;
451 case GlobalScope:
452 break;
453 case Qualified:
454 qualified.parent->print( os );
455 os << ".";
456 qualified.child->print( os );
457 break;
458 case Unknown:
459 os << "entity of unknown type ";
460 break;
461 default:
462 os << "internal error: TypeData::print " << kind << endl;
463 assert( false );
464 } // switch
465} // TypeData::print
466
467const std::string * TypeData::leafName() const {
468 switch ( kind ) {
469 case Unknown:
470 case Pointer:
471 case Reference:
472 case EnumConstant:
473 case GlobalScope:
474 case Array:
475 case Basic:
476 case Function:
477 case AggregateInst:
478 case Tuple:
479 case Typeof:
480 case Basetypeof:
481 case Builtin:
482 case Vtable:
483 assertf(false, "Tried to get leaf name from kind without a name: %d", kind);
484 break;
485 case Aggregate:
486 return aggregate.name;
487 case Enum:
488 return enumeration.name;
489 case Symbolic:
490 case SymbolicInst:
491 return symbolic.name;
492 case Qualified:
493 return qualified.child->leafName();
494 } // switch
495 assert(false);
496}
497
498TypeData * TypeData::getLastBase() {
499 TypeData * cur = this;
500 while ( cur->base ) cur = cur->base;
501 return cur;
502}
503
504void TypeData::setLastBase( TypeData * newBase ) {
505 getLastBase()->base = newBase;
506}
507
508
509TypeData * build_type_qualifier( ast::CV::Qualifiers tq ) {
510 TypeData * type = new TypeData;
511 type->qualifiers = tq;
512 return type;
513}
514
515TypeData * build_basic_type( TypeData::BasicType basic ) {
516 TypeData * type = new TypeData( TypeData::Basic );
517 type->basictype = basic;
518 return type;
519}
520
521TypeData * build_complex_type( TypeData::ComplexType complex ) {
522 TypeData * type = new TypeData( TypeData::Basic );
523 type->complextype = complex;
524 return type;
525}
526
527TypeData * build_signedness( TypeData::Signedness signedness ) {
528 TypeData * type = new TypeData( TypeData::Basic );
529 type->signedness = signedness;
530 return type;
531}
532
533TypeData * build_builtin_type( TypeData::BuiltinType bit ) {
534 TypeData * type = new TypeData( TypeData::Builtin );
535 type->builtintype = bit;
536 return type;
537}
538
539TypeData * build_length( TypeData::Length length ) {
540 TypeData * type = new TypeData( TypeData::Basic );
541 type->length = length;
542 return type;
543}
544
545TypeData * build_forall( DeclarationNode * forall ) {
546 TypeData * type = new TypeData( TypeData::Unknown );
547 type->forall = forall;
548 return type;
549}
550
551TypeData * build_global_scope() {
552 return new TypeData( TypeData::GlobalScope );
553}
554
555TypeData * build_qualified_type( TypeData * parent, TypeData * child ) {
556 TypeData * type = new TypeData( TypeData::Qualified );
557 type->qualified.parent = parent;
558 type->qualified.child = child;
559 return type;
560}
561
562TypeData * build_typedef( const std::string * name ) {
563 TypeData * type = new TypeData( TypeData::SymbolicInst );
564 type->symbolic.name = name;
565 type->symbolic.isTypedef = true;
566 type->symbolic.actuals = nullptr;
567 return type;
568}
569
570TypeData * build_type_gen( const std::string * name, ExpressionNode * params ) {
571 TypeData * type = new TypeData( TypeData::SymbolicInst );
572 type->symbolic.name = name;
573 type->symbolic.isTypedef = false;
574 type->symbolic.actuals = params;
575 return type;
576}
577
578TypeData * build_vtable_type( TypeData * base ) {
579 TypeData * type = new TypeData( TypeData::Vtable );
580 type->base = base;
581 return type;
582}
583
584// Takes ownership of src.
585static void addQualifiersToType( TypeData * dst, TypeData * src ) {
586 if ( dst->base ) {
587 addQualifiersToType( dst->base, src );
588 } else if ( dst->kind == TypeData::Function ) {
589 dst->base = src;
590 src = nullptr;
591 } else {
592 dst->qualifiers |= src->qualifiers;
593 delete src;
594 } // if
595}
596
597// Takes ownership of all arguments, gives ownership of return value.
598TypeData * addQualifiers( TypeData * ltype, TypeData * rtype ) {
599 if ( ltype->forall ) {
600 if ( rtype->forall ) {
601 rtype->forall->set_last( ltype->forall );
602 } else if ( TypeData::Aggregate != rtype->kind ) {
603 rtype->forall = ltype->forall;
604 } else if ( rtype->aggregate.params ) {
605 rtype->aggregate.params->set_last( ltype->forall );
606 } else {
607 rtype->aggregate.params = ltype->forall;
608 }
609 ltype->forall = nullptr;
610 }
611
612 addQualifiersToType( rtype, ltype );
613 return rtype;
614}
615
616// Helper for addType and cloneBaseType.
617static void addTypeToType( TypeData *& dst, TypeData *& src ) {
618 if ( src->forall && dst->kind == TypeData::Function ) {
619 if ( dst->forall ) {
620 dst->forall->set_last( src->forall );
621 } else {
622 dst->forall = src->forall;
623 } // if
624 src->forall = nullptr;
625 } // if
626 if ( dst->base ) {
627 addTypeToType( dst->base, src );
628 return;
629 }
630 switch ( dst->kind ) {
631 case TypeData::Unknown:
632 src->qualifiers |= dst->qualifiers;
633 // LEAKS dst?
634 dst = src;
635 src = nullptr;
636 break;
637 case TypeData::Basic:
638 dst->qualifiers |= src->qualifiers;
639 if ( src->kind != TypeData::Unknown ) {
640 assert( src->kind == TypeData::Basic );
641
642 if ( dst->basictype == TypeData::NoBasicType ) {
643 dst->basictype = src->basictype;
644 } else if ( src->basictype != TypeData::NoBasicType ) {
645 SemanticError( yylloc, "multiple declaration types \"%s\" and \"%s\".",
646 TypeData::basicTypeNames[ dst->basictype ],
647 TypeData::basicTypeNames[ src->basictype ] );
648 }
649 if ( dst->complextype == TypeData::NoComplexType ) {
650 dst->complextype = src->complextype;
651 } else if ( src->complextype != TypeData::NoComplexType ) {
652 SemanticError( yylloc, "multiple declaration types \"%s\" and \"%s\".",
653 TypeData::complexTypeNames[ src->complextype ],
654 TypeData::complexTypeNames[ src->complextype ] );
655 }
656 if ( dst->signedness == TypeData::NoSignedness ) {
657 dst->signedness = src->signedness;
658 } else if ( src->signedness != TypeData::NoSignedness ) {
659 SemanticError( yylloc, "conflicting type specifier \"%s\" and \"%s\".",
660 TypeData::signednessNames[ dst->signedness ],
661 TypeData::signednessNames[ src->signedness ] );
662 }
663 if ( dst->length == TypeData::NoLength ) {
664 dst->length = src->length;
665 } else if ( dst->length == TypeData::Long && src->length == TypeData::Long ) {
666 dst->length = TypeData::LongLong;
667 } else if ( src->length != TypeData::NoLength ) {
668 SemanticError( yylloc, "conflicting type specifier \"%s\" and \"%s\".",
669 TypeData::lengthNames[ dst->length ],
670 TypeData::lengthNames[ src->length ] );
671 }
672 } // if
673 break;
674 default:
675 switch ( src->kind ) {
676 case TypeData::Aggregate:
677 case TypeData::Enum:
678 dst->base = new TypeData( TypeData::AggregateInst );
679 dst->base->aggInst.aggregate = src;
680 if ( src->kind == TypeData::Aggregate ) {
681 dst->base->aggInst.params = maybeCopy( src->aggregate.actuals );
682 } // if
683 dst->base->qualifiers |= src->qualifiers;
684 src = nullptr;
685 break;
686 default:
687 if ( dst->forall ) {
688 dst->forall->set_last( src->forall );
689 } else {
690 dst->forall = src->forall;
691 } // if
692 src->forall = nullptr;
693 dst->base = src;
694 src = nullptr;
695 } // switch
696 } // switch
697}
698
699// Takes ownership of all arguments, gives ownership of return value.
700TypeData * addType( TypeData * ltype, TypeData * rtype, std::vector<ast::ptr<ast::Attribute>> & attributes ) {
701 if ( rtype ) {
702 addTypeToType( rtype, ltype );
703 return rtype;
704 } else {
705 if ( ltype->kind == TypeData::Aggregate || ltype->kind == TypeData::Enum ) {
706 // Hide type information aggregate instances.
707 rtype = new TypeData( TypeData::AggregateInst );
708 rtype->aggInst.aggregate = ltype;
709 rtype->aggInst.aggregate->aggregate.attributes.swap( attributes ); // change ownership
710 if ( ltype->kind == TypeData::Aggregate ) {
711 rtype->aggInst.hoistType = ltype->aggregate.body;
712 rtype->aggInst.params = maybeCopy( ltype->aggregate.actuals );
713 } else {
714 rtype->aggInst.hoistType = ltype->enumeration.body;
715 } // if
716 rtype->qualifiers |= ltype->qualifiers;
717 } else {
718 rtype = ltype;
719 } // if
720 return rtype;
721 } // if
722}
723
724TypeData * addType( TypeData * ltype, TypeData * rtype ) {
725 std::vector<ast::ptr<ast::Attribute>> attributes;
726 return addType( ltype, rtype, attributes );
727}
728
729// Takes ownership of both arguments, gives ownership of return value.
730TypeData * cloneBaseType( TypeData * type, TypeData * other ) {
731 TypeData * newType = type->getLastBase()->clone();
732 if ( newType->kind == TypeData::AggregateInst ) {
733 // don't duplicate members
734 if ( newType->aggInst.aggregate->kind == TypeData::Enum ) {
735 delete newType->aggInst.aggregate->enumeration.constants;
736 newType->aggInst.aggregate->enumeration.constants = nullptr;
737 newType->aggInst.aggregate->enumeration.body = false;
738 } else {
739 assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
740 delete newType->aggInst.aggregate->aggregate.fields;
741 newType->aggInst.aggregate->aggregate.fields = nullptr;
742 newType->aggInst.aggregate->aggregate.body = false;
743 } // if
744 // don't hoist twice
745 newType->aggInst.hoistType = false;
746 } // if
747 newType->forall = maybeCopy( type->forall );
748
749 if ( other ) {
750 addTypeToType( other, newType );
751 delete newType;
752 return other;
753 } // if
754 return newType;
755}
756
757TypeData * makeNewBase( TypeData * type ) {
758 switch ( type->kind ) {
759 case TypeData::Aggregate:
760 case TypeData::Enum: {
761 TypeData * out = new TypeData( TypeData::AggregateInst );
762 out->aggInst.aggregate = type;
763 if ( TypeData::Aggregate == type->kind ) {
764 out->aggInst.params = maybeCopy( type->aggregate.actuals );
765 }
766 out->qualifiers |= type->qualifiers;
767 return out;
768 }
769 default:
770 return type;
771 } // switch
772}
773
774
775void buildForall(
776 const DeclarationNode * firstNode,
777 std::vector<ast::ptr<ast::TypeInstType>> &outputList ) {
778 {
779 std::vector<ast::ptr<ast::Type>> tmpList;
780 buildTypeList( firstNode, tmpList );
781 for ( auto tmp : tmpList ) {
782 outputList.emplace_back(
783 strict_dynamic_cast<const ast::TypeInstType *>(
784 tmp.release() ) );
785 }
786 }
787 auto n = firstNode;
788 for ( auto i = outputList.begin() ;
789 i != outputList.end() ;
790 ++i, n = n->next ) {
791 // Only the object type class adds additional assertions.
792 if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
793 continue;
794 }
795
796 ast::TypeDecl const * td = i->strict_as<ast::TypeDecl>();
797 std::vector<ast::ptr<ast::DeclWithType>> newAssertions;
798 auto mutTypeDecl = ast::mutate( td );
799 const CodeLocation & location = mutTypeDecl->location;
800 *i = mutTypeDecl;
801
802 // add assertion parameters to `type' tyvars in reverse order
803 // add assignment operator: T * ?=?(T *, T)
804 newAssertions.push_back( new ast::FunctionDecl(
805 location,
806 "?=?",
807 {}, // forall
808 {}, // assertions
809 {
810 new ast::ObjectDecl(
811 location,
812 "",
813 new ast::ReferenceType( i->get() ),
814 (ast::Init *)nullptr,
815 ast::Storage::Classes(),
816 ast::Linkage::Cforall,
817 (ast::Expr *)nullptr
818 ),
819 new ast::ObjectDecl(
820 location,
821 "",
822 i->get(),
823 (ast::Init *)nullptr,
824 ast::Storage::Classes(),
825 ast::Linkage::Cforall,
826 (ast::Expr *)nullptr
827 ),
828 }, // params
829 {
830 new ast::ObjectDecl(
831 location,
832 "",
833 i->get(),
834 (ast::Init *)nullptr,
835 ast::Storage::Classes(),
836 ast::Linkage::Cforall,
837 (ast::Expr *)nullptr
838 ),
839 }, // returns
840 (ast::CompoundStmt *)nullptr,
841 ast::Storage::Classes(),
842 ast::Linkage::Cforall
843 ) );
844
845 // add default ctor: void ?{}(T *)
846 newAssertions.push_back( new ast::FunctionDecl(
847 location,
848 "?{}",
849 {}, // forall
850 {}, // assertions
851 {
852 new ast::ObjectDecl(
853 location,
854 "",
855 new ast::ReferenceType( i->get() ),
856 (ast::Init *)nullptr,
857 ast::Storage::Classes(),
858 ast::Linkage::Cforall,
859 (ast::Expr *)nullptr
860 ),
861 }, // params
862 {}, // returns
863 (ast::CompoundStmt *)nullptr,
864 ast::Storage::Classes(),
865 ast::Linkage::Cforall
866 ) );
867
868 // add copy ctor: void ?{}(T *, T)
869 newAssertions.push_back( new ast::FunctionDecl(
870 location,
871 "?{}",
872 {}, // forall
873 {}, // assertions
874 {
875 new ast::ObjectDecl(
876 location,
877 "",
878 new ast::ReferenceType( i->get() ),
879 (ast::Init *)nullptr,
880 ast::Storage::Classes(),
881 ast::Linkage::Cforall,
882 (ast::Expr *)nullptr
883 ),
884 new ast::ObjectDecl(
885 location,
886 "",
887 i->get(),
888 (ast::Init *)nullptr,
889 ast::Storage::Classes(),
890 ast::Linkage::Cforall,
891 (ast::Expr *)nullptr
892 ),
893 }, // params
894 {}, // returns
895 (ast::CompoundStmt *)nullptr,
896 ast::Storage::Classes(),
897 ast::Linkage::Cforall
898 ) );
899
900 // add dtor: void ^?{}(T *)
901 newAssertions.push_back( new ast::FunctionDecl(
902 location,
903 "^?{}",
904 {}, // forall
905 {}, // assertions
906 {
907 new ast::ObjectDecl(
908 location,
909 "",
910 new ast::ReferenceType( i->get() ),
911 (ast::Init *)nullptr,
912 ast::Storage::Classes(),
913 ast::Linkage::Cforall,
914 (ast::Expr *)nullptr
915 ),
916 }, // params
917 {}, // returns
918 (ast::CompoundStmt *)nullptr,
919 ast::Storage::Classes(),
920 ast::Linkage::Cforall
921 ) );
922
923 spliceBegin( mutTypeDecl->assertions, newAssertions );
924 } // for
925}
926
927
928void buildForall(
929 const DeclarationNode * firstNode,
930 std::vector<ast::ptr<ast::TypeDecl>> &outputForall ) {
931 buildList( firstNode, outputForall );
932 auto n = firstNode;
933 for ( auto i = outputForall.begin() ;
934 i != outputForall.end() ;
935 ++i, n = n->next ) {
936 // Only the object type class adds additional assertions.
937 if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
938 continue;
939 }
940
941 ast::TypeDecl const * td = i->strict_as<ast::TypeDecl>();
942 std::vector<ast::ptr<ast::DeclWithType>> newAssertions;
943 auto mutTypeDecl = ast::mutate( td );
944 const CodeLocation & location = mutTypeDecl->location;
945 *i = mutTypeDecl;
946
947 // add assertion parameters to `type' tyvars in reverse order
948 // add assignment operator: T * ?=?(T *, T)
949 newAssertions.push_back( new ast::FunctionDecl(
950 location,
951 "?=?",
952 {}, // forall
953 {}, // assertions
954 {
955 new ast::ObjectDecl(
956 location,
957 "",
958 new ast::ReferenceType( new ast::TypeInstType( td->name, *i ) ),
959 (ast::Init *)nullptr,
960 ast::Storage::Classes(),
961 ast::Linkage::Cforall,
962 (ast::Expr *)nullptr
963 ),
964 new ast::ObjectDecl(
965 location,
966 "",
967 new ast::TypeInstType( td->name, *i ),
968 (ast::Init *)nullptr,
969 ast::Storage::Classes(),
970 ast::Linkage::Cforall,
971 (ast::Expr *)nullptr
972 ),
973 }, // params
974 {
975 new ast::ObjectDecl(
976 location,
977 "",
978 new ast::TypeInstType( td->name, *i ),
979 (ast::Init *)nullptr,
980 ast::Storage::Classes(),
981 ast::Linkage::Cforall,
982 (ast::Expr *)nullptr
983 ),
984 }, // returns
985 (ast::CompoundStmt *)nullptr,
986 ast::Storage::Classes(),
987 ast::Linkage::Cforall
988 ) );
989
990 // add default ctor: void ?{}(T *)
991 newAssertions.push_back( new ast::FunctionDecl(
992 location,
993 "?{}",
994 {}, // forall
995 {}, // assertions
996 {
997 new ast::ObjectDecl(
998 location,
999 "",
1000 new ast::ReferenceType(
1001 new ast::TypeInstType( td->name, i->get() ) ),
1002 (ast::Init *)nullptr,
1003 ast::Storage::Classes(),
1004 ast::Linkage::Cforall,
1005 (ast::Expr *)nullptr
1006 ),
1007 }, // params
1008 {}, // returns
1009 (ast::CompoundStmt *)nullptr,
1010 ast::Storage::Classes(),
1011 ast::Linkage::Cforall
1012 ) );
1013
1014 // add copy ctor: void ?{}(T *, T)
1015 newAssertions.push_back( new ast::FunctionDecl(
1016 location,
1017 "?{}",
1018 {}, // forall
1019 {}, // assertions
1020 {
1021 new ast::ObjectDecl(
1022 location,
1023 "",
1024 new ast::ReferenceType(
1025 new ast::TypeInstType( td->name, *i ) ),
1026 (ast::Init *)nullptr,
1027 ast::Storage::Classes(),
1028 ast::Linkage::Cforall,
1029 (ast::Expr *)nullptr
1030 ),
1031 new ast::ObjectDecl(
1032 location,
1033 "",
1034 new ast::TypeInstType( td->name, *i ),
1035 (ast::Init *)nullptr,
1036 ast::Storage::Classes(),
1037 ast::Linkage::Cforall,
1038 (ast::Expr *)nullptr
1039 ),
1040 }, // params
1041 {}, // returns
1042 (ast::CompoundStmt *)nullptr,
1043 ast::Storage::Classes(),
1044 ast::Linkage::Cforall
1045 ) );
1046
1047 // add dtor: void ^?{}(T *)
1048 newAssertions.push_back( new ast::FunctionDecl(
1049 location,
1050 "^?{}",
1051 {}, // forall
1052 {}, // assertions
1053 {
1054 new ast::ObjectDecl(
1055 location,
1056 "",
1057 new ast::ReferenceType(
1058 new ast::TypeInstType( i->get() )
1059 ),
1060 (ast::Init *)nullptr,
1061 ast::Storage::Classes(),
1062 ast::Linkage::Cforall,
1063 (ast::Expr *)nullptr
1064 ),
1065 }, // params
1066 {}, // returns
1067 (ast::CompoundStmt *)nullptr,
1068 ast::Storage::Classes(),
1069 ast::Linkage::Cforall
1070 ) );
1071
1072 spliceBegin( mutTypeDecl->assertions, newAssertions );
1073 } // for
1074} // buildForall
1075
1076
1077ast::Type * typebuild( const TypeData * td ) {
1078 assert( td );
1079 switch ( td->kind ) {
1080 case TypeData::Unknown:
1081 // fill in implicit int
1082 return new ast::BasicType(
1083 ast::BasicType::SignedInt,
1084 buildQualifiers( td )
1085 );
1086 case TypeData::Basic:
1087 return buildBasicType( td );
1088 case TypeData::Pointer:
1089 return buildPointer( td );
1090 case TypeData::Array:
1091 return buildArray( td );
1092 case TypeData::Reference:
1093 return buildReference( td );
1094 case TypeData::Function:
1095 return buildFunctionType( td );
1096 case TypeData::AggregateInst:
1097 return buildAggInst( td );
1098 case TypeData::EnumConstant:
1099 return new ast::EnumInstType( "", buildQualifiers( td ) );
1100 case TypeData::SymbolicInst:
1101 return buildSymbolicInst( td );
1102 case TypeData::Tuple:
1103 return buildTuple( td );
1104 case TypeData::Typeof:
1105 case TypeData::Basetypeof:
1106 return buildTypeof( td );
1107 case TypeData::Vtable:
1108 return buildVtable( td );
1109 case TypeData::Builtin:
1110 switch ( td->builtintype ) {
1111 case TypeData::Zero:
1112 return new ast::ZeroType();
1113 case TypeData::One:
1114 return new ast::OneType();
1115 default:
1116 return new ast::VarArgsType( buildQualifiers( td ) );
1117 } // switch
1118 case TypeData::GlobalScope:
1119 return new ast::GlobalScopeType();
1120 case TypeData::Qualified:
1121 return new ast::QualifiedType(
1122 typebuild( td->qualified.parent ),
1123 typebuild( td->qualified.child ),
1124 buildQualifiers( td )
1125 );
1126 case TypeData::Symbolic:
1127 case TypeData::Enum:
1128 case TypeData::Aggregate:
1129 assert( false );
1130 } // switch
1131
1132 return nullptr;
1133} // typebuild
1134
1135
1136TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) {
1137 TypeData * ret = nullptr;
1138
1139 switch ( td->kind ) {
1140 case TypeData::Aggregate:
1141 if ( ! toplevel && td->aggregate.body ) {
1142 ret = td->clone();
1143 } // if
1144 break;
1145 case TypeData::Enum:
1146 if ( ! toplevel && td->enumeration.body ) {
1147 ret = td->clone();
1148 } // if
1149 break;
1150 case TypeData::AggregateInst:
1151 if ( td->aggInst.aggregate ) {
1152 ret = typeextractAggregate( td->aggInst.aggregate, false );
1153 } // if
1154 break;
1155 default:
1156 if ( td->base ) {
1157 ret = typeextractAggregate( td->base, false );
1158 } // if
1159 } // switch
1160 return ret;
1161} // typeextractAggregate
1162
1163
1164ast::CV::Qualifiers buildQualifiers( const TypeData * td ) {
1165 return td->qualifiers;
1166} // buildQualifiers
1167
1168
1169static string genTSError( string msg, TypeData::BasicType basictype ) {
1170 SemanticError( yylloc, "invalid type specifier \"%s\" for type \"%s\".", msg.c_str(), TypeData::basicTypeNames[basictype] );
1171} // genTSError
1172
1173ast::Type * buildBasicType( const TypeData * td ) {
1174 ast::BasicType::Kind ret;
1175
1176 switch ( td->basictype ) {
1177 case TypeData::Void:
1178 if ( td->signedness != TypeData::NoSignedness ) {
1179 genTSError( TypeData::signednessNames[ td->signedness ], td->basictype );
1180 } // if
1181 if ( td->length != TypeData::NoLength ) {
1182 genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1183 } // if
1184 return new ast::VoidType( buildQualifiers( td ) );
1185 break;
1186
1187 case TypeData::Bool:
1188 if ( td->signedness != TypeData::NoSignedness ) {
1189 genTSError( TypeData::signednessNames[ td->signedness ], td->basictype );
1190 } // if
1191 if ( td->length != TypeData::NoLength ) {
1192 genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1193 } // if
1194
1195 ret = ast::BasicType::Bool;
1196 break;
1197
1198 case TypeData::Char:
1199 // C11 Standard 6.2.5.15: The three types char, signed char, and unsigned char are collectively called the
1200 // character types. The implementation shall define char to have the same range, representation, and behavior as
1201 // either signed char or unsigned char.
1202 static ast::BasicType::Kind chartype[] = { ast::BasicType::SignedChar, ast::BasicType::UnsignedChar, ast::BasicType::Char };
1203
1204 if ( td->length != TypeData::NoLength ) {
1205 genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1206 } // if
1207
1208 ret = chartype[ td->signedness ];
1209 break;
1210
1211 case TypeData::Int:
1212 static ast::BasicType::Kind inttype[2][4] = {
1213 { ast::BasicType::ShortSignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, ast::BasicType::SignedInt },
1214 { ast::BasicType::ShortUnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, ast::BasicType::UnsignedInt },
1215 };
1216
1217 Integral: ;
1218 if ( td->signedness == TypeData::NoSignedness ) {
1219 const_cast<TypeData *>(td)->signedness = TypeData::Signed;
1220 } // if
1221 ret = inttype[ td->signedness ][ td->length ];
1222 break;
1223
1224 case TypeData::Int128:
1225 ret = td->signedness == TypeData::Unsigned ? ast::BasicType::UnsignedInt128 : ast::BasicType::SignedInt128;
1226 if ( td->length != TypeData::NoLength ) {
1227 genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1228 } // if
1229 break;
1230
1231 case TypeData::Float:
1232 case TypeData::Double:
1233 case TypeData::LongDouble: // not set until below
1234 case TypeData::uuFloat80:
1235 case TypeData::uuFloat128:
1236 case TypeData::uFloat16:
1237 case TypeData::uFloat32:
1238 case TypeData::uFloat32x:
1239 case TypeData::uFloat64:
1240 case TypeData::uFloat64x:
1241 case TypeData::uFloat128:
1242 case TypeData::uFloat128x:
1243 static ast::BasicType::Kind floattype[2][12] = {
1244 { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, (ast::BasicType::Kind)-1, (ast::BasicType::Kind)-1, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex, },
1245 { ast::BasicType::Float, ast::BasicType::Double, ast::BasicType::LongDouble, ast::BasicType::uuFloat80, ast::BasicType::uuFloat128, ast::BasicType::uFloat16, ast::BasicType::uFloat32, ast::BasicType::uFloat32x, ast::BasicType::uFloat64, ast::BasicType::uFloat64x, ast::BasicType::uFloat128, ast::BasicType::uFloat128x, },
1246 };
1247
1248 FloatingPoint: ;
1249 if ( td->signedness != TypeData::NoSignedness ) {
1250 genTSError( TypeData::signednessNames[ td->signedness ], td->basictype );
1251 } // if
1252 if ( td->length == TypeData::Short || td->length == TypeData::LongLong ) {
1253 genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1254 } // if
1255 if ( td->basictype != TypeData::Double && td->length == TypeData::Long ) {
1256 genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1257 } // if
1258 if ( td->complextype == TypeData::Imaginary ) {
1259 genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype );
1260 } // if
1261 if ( (td->basictype == TypeData::uuFloat80 || td->basictype == TypeData::uuFloat128) && td->complextype == TypeData::Complex ) { // gcc unsupported
1262 genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype );
1263 } // if
1264 if ( td->length == TypeData::Long ) {
1265 const_cast<TypeData *>(td)->basictype = TypeData::LongDouble;
1266 } // if
1267
1268 ret = floattype[ td->complextype ][ td->basictype - TypeData::Float ];
1269 //printf( "XXXX %d %d %d %d\n", td->complextype, td->basictype, TypeData::Float, ret );
1270 break;
1271
1272 case TypeData::NoBasicType:
1273 // No basic type in declaration => default double for Complex/Imaginary and int type for integral types
1274 if ( td->complextype == TypeData::Complex || td->complextype == TypeData::Imaginary ) {
1275 const_cast<TypeData *>(td)->basictype = TypeData::Double;
1276 goto FloatingPoint;
1277 } // if
1278
1279 const_cast<TypeData *>(td)->basictype = TypeData::Int;
1280 goto Integral;
1281 default:
1282 assertf( false, "unknown basic type" );
1283 return nullptr;
1284 } // switch
1285
1286 ast::BasicType * bt = new ast::BasicType( ret, buildQualifiers( td ) );
1287 return bt;
1288} // buildBasicType
1289
1290
1291static ast::Type * buildDefaultType( const TypeData * td ) {
1292 return ( td ) ? typebuild( td ) : new ast::BasicType( ast::BasicType::SignedInt );
1293} // buildDefaultType
1294
1295
1296ast::PointerType * buildPointer( const TypeData * td ) {
1297 return new ast::PointerType(
1298 buildDefaultType( td->base ),
1299 buildQualifiers( td )
1300 );
1301} // buildPointer
1302
1303
1304ast::ArrayType * buildArray( const TypeData * td ) {
1305 return new ast::ArrayType(
1306 buildDefaultType( td->base ),
1307 maybeBuild( td->array.dimension ),
1308 td->array.isVarLen ? ast::VariableLen : ast::FixedLen,
1309 td->array.isStatic ? ast::StaticDim : ast::DynamicDim,
1310 buildQualifiers( td )
1311 );
1312} // buildArray
1313
1314
1315ast::ReferenceType * buildReference( const TypeData * td ) {
1316 return new ast::ReferenceType(
1317 buildDefaultType( td->base ),
1318 buildQualifiers( td )
1319 );
1320} // buildReference
1321
1322
1323ast::AggregateDecl * buildAggregate( const TypeData * td, std::vector<ast::ptr<ast::Attribute>> attributes, ast::Linkage::Spec linkage ) {
1324 assert( td->kind == TypeData::Aggregate );
1325 ast::AggregateDecl * at;
1326 switch ( td->aggregate.kind ) {
1327 case ast::AggregateDecl::Struct:
1328 case ast::AggregateDecl::Coroutine:
1329 case ast::AggregateDecl::Exception:
1330 case ast::AggregateDecl::Generator:
1331 case ast::AggregateDecl::Monitor:
1332 case ast::AggregateDecl::Thread:
1333 at = new ast::StructDecl( td->location,
1334 *td->aggregate.name,
1335 td->aggregate.kind,
1336 std::move( attributes ),
1337 linkage
1338 );
1339 buildForall( td->aggregate.params, at->params );
1340 break;
1341 case ast::AggregateDecl::Union:
1342 at = new ast::UnionDecl( td->location,
1343 *td->aggregate.name,
1344 std::move( attributes ),
1345 linkage
1346 );
1347 buildForall( td->aggregate.params, at->params );
1348 break;
1349 case ast::AggregateDecl::Trait:
1350 at = new ast::TraitDecl( td->location,
1351 *td->aggregate.name,
1352 std::move( attributes ),
1353 linkage
1354 );
1355 buildList( td->aggregate.params, at->params );
1356 break;
1357 default:
1358 assert( false );
1359 } // switch
1360
1361 buildList( td->aggregate.fields, at->members );
1362 at->set_body( td->aggregate.body );
1363
1364 return at;
1365} // buildAggregate
1366
1367
1368ast::BaseInstType * buildComAggInst(
1369 const TypeData * td,
1370 std::vector<ast::ptr<ast::Attribute>> && attributes,
1371 ast::Linkage::Spec linkage ) {
1372 switch ( td->kind ) {
1373 case TypeData::Enum:
1374 if ( td->enumeration.body ) {
1375 ast::EnumDecl * typedecl =
1376 buildEnum( td, std::move( attributes ), linkage );
1377 return new ast::EnumInstType(
1378 typedecl,
1379 buildQualifiers( td )
1380 );
1381 } else {
1382 return new ast::EnumInstType(
1383 *td->enumeration.name,
1384 buildQualifiers( td )
1385 );
1386 } // if
1387 break;
1388 case TypeData::Aggregate:
1389 if ( td->aggregate.body ) {
1390 ast::AggregateDecl * typedecl =
1391 buildAggregate( td, std::move( attributes ), linkage );
1392 switch ( td->aggregate.kind ) {
1393 case ast::AggregateDecl::Struct:
1394 case ast::AggregateDecl::Coroutine:
1395 case ast::AggregateDecl::Monitor:
1396 case ast::AggregateDecl::Thread:
1397 return new ast::StructInstType(
1398 strict_dynamic_cast<ast::StructDecl *>( typedecl ),
1399 buildQualifiers( td )
1400 );
1401 case ast::AggregateDecl::Union:
1402 return new ast::UnionInstType(
1403 strict_dynamic_cast<ast::UnionDecl *>( typedecl ),
1404 buildQualifiers( td )
1405 );
1406 case ast::AggregateDecl::Trait:
1407 assert( false );
1408 break;
1409 default:
1410 assert( false );
1411 } // switch
1412 } else {
1413 switch ( td->aggregate.kind ) {
1414 case ast::AggregateDecl::Struct:
1415 case ast::AggregateDecl::Coroutine:
1416 case ast::AggregateDecl::Monitor:
1417 case ast::AggregateDecl::Thread:
1418 return new ast::StructInstType(
1419 *td->aggregate.name,
1420 buildQualifiers( td )
1421 );
1422 case ast::AggregateDecl::Union:
1423 return new ast::UnionInstType(
1424 *td->aggregate.name,
1425 buildQualifiers( td )
1426 );
1427 case ast::AggregateDecl::Trait:
1428 return new ast::TraitInstType(
1429 *td->aggregate.name,
1430 buildQualifiers( td )
1431 );
1432 default:
1433 assert( false );
1434 } // switch
1435 break;
1436 } // if
1437 break;
1438 default:
1439 assert( false );
1440 } // switch
1441 assert( false );
1442} // buildAggInst
1443
1444
1445ast::BaseInstType * buildAggInst( const TypeData * td ) {
1446 assert( td->kind == TypeData::AggregateInst );
1447
1448 ast::BaseInstType * ret = nullptr;
1449 TypeData * type = td->aggInst.aggregate;
1450 switch ( type->kind ) {
1451 case TypeData::Enum:
1452 return new ast::EnumInstType(
1453 *type->enumeration.name,
1454 buildQualifiers( type )
1455 );
1456 case TypeData::Aggregate:
1457 switch ( type->aggregate.kind ) {
1458 case ast::AggregateDecl::Struct:
1459 case ast::AggregateDecl::Coroutine:
1460 case ast::AggregateDecl::Monitor:
1461 case ast::AggregateDecl::Thread:
1462 ret = new ast::StructInstType(
1463 *type->aggregate.name,
1464 buildQualifiers( type )
1465 );
1466 break;
1467 case ast::AggregateDecl::Union:
1468 ret = new ast::UnionInstType(
1469 *type->aggregate.name,
1470 buildQualifiers( type )
1471 );
1472 break;
1473 case ast::AggregateDecl::Trait:
1474 ret = new ast::TraitInstType(
1475 *type->aggregate.name,
1476 buildQualifiers( type )
1477 );
1478 break;
1479 default:
1480 assert( false );
1481 } // switch
1482 break;
1483 default:
1484 assert( false );
1485 } // switch
1486
1487 ret->hoistType = td->aggInst.hoistType;
1488 buildList( td->aggInst.params, ret->params );
1489 return ret;
1490} // buildAggInst
1491
1492
1493ast::NamedTypeDecl * buildSymbolic(
1494 const TypeData * td,
1495 std::vector<ast::ptr<ast::Attribute>> attributes,
1496 const std::string & name,
1497 ast::Storage::Classes scs,
1498 ast::Linkage::Spec linkage ) {
1499 assert( td->kind == TypeData::Symbolic );
1500 ast::NamedTypeDecl * ret;
1501 assert( td->base );
1502 if ( td->symbolic.isTypedef ) {
1503 ret = new ast::TypedefDecl(
1504 td->location,
1505 name,
1506 scs,
1507 typebuild( td->base ),
1508 linkage
1509 );
1510 } else {
1511 ret = new ast::TypeDecl(
1512 td->location,
1513 name,
1514 scs,
1515 typebuild( td->base ),
1516 ast::TypeDecl::Dtype,
1517 true
1518 );
1519 } // if
1520 buildList( td->symbolic.assertions, ret->assertions );
1521 splice( ret->base.get_and_mutate()->attributes, attributes );
1522 return ret;
1523} // buildSymbolic
1524
1525
1526ast::EnumDecl * buildEnum(
1527 const TypeData * td,
1528 std::vector<ast::ptr<ast::Attribute>> && attributes,
1529 ast::Linkage::Spec linkage ) {
1530 assert( td->kind == TypeData::Enum );
1531 ast::Type * baseType = td->base ? typebuild(td->base) : nullptr;
1532 ast::EnumDecl * ret = new ast::EnumDecl(
1533 td->location,
1534 *td->enumeration.name,
1535 td->enumeration.typed,
1536 std::move( attributes ),
1537 linkage,
1538 baseType
1539 );
1540 buildList( td->enumeration.constants, ret->members );
1541 auto members = ret->members.begin();
1542 ret->hide = td->enumeration.hiding == EnumHiding::Hide ? ast::EnumDecl::EnumHiding::Hide : ast::EnumDecl::EnumHiding::Visible;
1543 for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = cur->next, ++members ) {
1544 if ( cur->enumInLine ) {
1545 // Do Nothing
1546 } else if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
1547 SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
1548 } else if ( cur->has_enumeratorValue() ) {
1549 ast::Decl * member = members->get_and_mutate();
1550 ast::ObjectDecl * object = strict_dynamic_cast<ast::ObjectDecl *>( member );
1551 object->init = new ast::SingleInit(
1552 td->location,
1553 maybeMoveBuild( cur->consume_enumeratorValue() ),
1554 ast::NoConstruct
1555 );
1556 } else if ( !cur->initializer ) {
1557 if ( baseType && (!dynamic_cast<ast::BasicType *>(baseType) || !dynamic_cast<ast::BasicType *>(baseType)->isInteger())) {
1558 SemanticError( td->location, "Enumerators of an non-integer typed enum must be explicitly initialized." );
1559 }
1560 }
1561 // else cur is a List Initializer and has been set as init in buildList()
1562 // if
1563 } // for
1564 ret->body = td->enumeration.body;
1565 return ret;
1566} // buildEnum
1567
1568
1569ast::TypeInstType * buildSymbolicInst( const TypeData * td ) {
1570 assert( td->kind == TypeData::SymbolicInst );
1571 ast::TypeInstType * ret = new ast::TypeInstType(
1572 *td->symbolic.name,
1573 ast::TypeDecl::Dtype,
1574 buildQualifiers( td )
1575 );
1576 buildList( td->symbolic.actuals, ret->params );
1577 return ret;
1578} // buildSymbolicInst
1579
1580
1581ast::TupleType * buildTuple( const TypeData * td ) {
1582 assert( td->kind == TypeData::Tuple );
1583 std::vector<ast::ptr<ast::Type>> types;
1584 buildTypeList( td->tuple, types );
1585 ast::TupleType * ret = new ast::TupleType(
1586 std::move( types ),
1587 buildQualifiers( td )
1588 );
1589 return ret;
1590} // buildTuple
1591
1592
1593ast::TypeofType * buildTypeof( const TypeData * td ) {
1594 assert( td->kind == TypeData::Typeof || td->kind == TypeData::Basetypeof );
1595 assert( td->typeexpr );
1596 return new ast::TypeofType(
1597 td->typeexpr->build(),
1598 td->kind == TypeData::Typeof
1599 ? ast::TypeofType::Typeof : ast::TypeofType::Basetypeof,
1600 buildQualifiers( td )
1601 );
1602} // buildTypeof
1603
1604
1605ast::VTableType * buildVtable( const TypeData * td ) {
1606 assert( td->base );
1607 return new ast::VTableType(
1608 typebuild( td->base ),
1609 buildQualifiers( td )
1610 );
1611} // buildVtable
1612
1613
1614ast::FunctionDecl * buildFunctionDecl(
1615 const TypeData * td,
1616 const string &name,
1617 ast::Storage::Classes scs,
1618 ast::Function::Specs funcSpec,
1619 ast::Linkage::Spec linkage,
1620 ast::Expr * asmName,
1621 std::vector<ast::ptr<ast::Attribute>> && attributes ) {
1622 assert( td->kind == TypeData::Function );
1623 // For some reason FunctionDecl takes a bool instead of an ArgumentFlag.
1624 bool isVarArgs = !td->function.params || td->function.params->hasEllipsis;
1625 ast::CV::Qualifiers cvq = buildQualifiers( td );
1626 std::vector<ast::ptr<ast::TypeDecl>> forall;
1627 std::vector<ast::ptr<ast::DeclWithType>> assertions;
1628 std::vector<ast::ptr<ast::DeclWithType>> params;
1629 std::vector<ast::ptr<ast::DeclWithType>> returns;
1630 buildList( td->function.params, params );
1631 buildForall( td->forall, forall );
1632 // Functions do not store their assertions there anymore.
1633 for ( ast::ptr<ast::TypeDecl> & type_param : forall ) {
1634 auto mut = type_param.get_and_mutate();
1635 splice( assertions, mut->assertions );
1636 }
1637 if ( td->base ) {
1638 switch ( td->base->kind ) {
1639 case TypeData::Tuple:
1640 buildList( td->base->tuple, returns );
1641 break;
1642 default:
1643 returns.push_back( dynamic_cast<ast::DeclWithType *>(
1644 buildDecl(
1645 td->base,
1646 "",
1647 ast::Storage::Classes(),
1648 (ast::Expr *)nullptr, // bitfieldWidth
1649 ast::Function::Specs(),
1650 ast::Linkage::Cforall,
1651 (ast::Expr *)nullptr // asmName
1652 )
1653 ) );
1654 } // switch
1655 } else {
1656 returns.push_back( new ast::ObjectDecl(
1657 td->location,
1658 "",
1659 new ast::BasicType( ast::BasicType::SignedInt ),
1660 (ast::Init *)nullptr,
1661 ast::Storage::Classes(),
1662 ast::Linkage::Cforall
1663 ) );
1664 } // if
1665 ast::Stmt * stmt = maybeBuild( td->function.body );
1666 ast::CompoundStmt * body = dynamic_cast<ast::CompoundStmt *>( stmt );
1667 ast::FunctionDecl * decl = new ast::FunctionDecl( td->location,
1668 name,
1669 std::move( forall ),
1670 std::move( assertions ),
1671 std::move( params ),
1672 std::move( returns ),
1673 body,
1674 scs,
1675 linkage,
1676 std::move( attributes ),
1677 funcSpec,
1678 (isVarArgs) ? ast::VariableArgs : ast::FixedArgs
1679 );
1680 buildList( td->function.withExprs, decl->withExprs );
1681 decl->asmName = asmName;
1682 // This may be redundant on a declaration.
1683 decl->type.get_and_mutate()->qualifiers = cvq;
1684 return decl;
1685} // buildFunctionDecl
1686
1687
1688ast::Decl * buildDecl(
1689 const TypeData * td,
1690 const string &name,
1691 ast::Storage::Classes scs,
1692 ast::Expr * bitfieldWidth,
1693 ast::Function::Specs funcSpec,
1694 ast::Linkage::Spec linkage,
1695 ast::Expr * asmName,
1696 ast::Init * init,
1697 std::vector<ast::ptr<ast::Attribute>> && attributes ) {
1698 if ( td->kind == TypeData::Function ) {
1699 if ( td->function.idList ) { // KR function ?
1700 buildKRFunction( td->function ); // transform into C11 function
1701 } // if
1702
1703 return buildFunctionDecl(
1704 td, name, scs, funcSpec, linkage,
1705 asmName, std::move( attributes ) );
1706 } else if ( td->kind == TypeData::Aggregate ) {
1707 return buildAggregate( td, std::move( attributes ), linkage );
1708 } else if ( td->kind == TypeData::Enum ) {
1709 return buildEnum( td, std::move( attributes ), linkage );
1710 } else if ( td->kind == TypeData::Symbolic ) {
1711 return buildSymbolic( td, std::move( attributes ), name, scs, linkage );
1712 } else {
1713 auto ret = new ast::ObjectDecl( td->location,
1714 name,
1715 typebuild( td ),
1716 init,
1717 scs,
1718 linkage,
1719 bitfieldWidth,
1720 std::move( attributes )
1721 );
1722 ret->asmName = asmName;
1723 return ret;
1724 } // if
1725 return nullptr;
1726} // buildDecl
1727
1728
1729ast::FunctionType * buildFunctionType( const TypeData * td ) {
1730 assert( td->kind == TypeData::Function );
1731 ast::FunctionType * ft = new ast::FunctionType(
1732 ( !td->function.params || td->function.params->hasEllipsis )
1733 ? ast::VariableArgs : ast::FixedArgs,
1734 buildQualifiers( td )
1735 );
1736 buildTypeList( td->function.params, ft->params );
1737 buildForall( td->forall, ft->forall );
1738 if ( td->base ) {
1739 switch ( td->base->kind ) {
1740 case TypeData::Tuple:
1741 buildTypeList( td->base->tuple, ft->returns );
1742 break;
1743 default:
1744 ft->returns.push_back( typebuild( td->base ) );
1745 break;
1746 } // switch
1747 } else {
1748 ft->returns.push_back(
1749 new ast::BasicType( ast::BasicType::SignedInt ) );
1750 } // if
1751 return ft;
1752} // buildFunctionType
1753
1754
1755// Transform KR routine declarations into C99 routine declarations:
1756//
1757// rtn( a, b, c ) int a, c; double b {} => int rtn( int a, double c, int b ) {}
1758//
1759// The type information for each post-declaration is moved to the corresponding pre-parameter and the post-declaration
1760// is deleted. Note, the order of the parameter names may not be the same as the declaration names. Duplicate names and
1761// extra names are disallowed.
1762//
1763// Note, there is no KR routine-prototype syntax:
1764//
1765// rtn( a, b, c ) int a, c; double b; // invalid KR prototype
1766// rtn(); // valid KR prototype
1767
1768void buildKRFunction( const TypeData::Function_t & function ) {
1769 assert( ! function.params );
1770 // loop over declaration first as it is easier to spot errors
1771 for ( DeclarationNode * decl = function.oldDeclList; decl != nullptr; decl = decl->next ) {
1772 // scan ALL parameter names for each declaration name to check for duplicates
1773 for ( DeclarationNode * param = function.idList; param != nullptr; param = param->next ) {
1774 if ( *decl->name == *param->name ) {
1775 // type set => parameter name already transformed by a declaration names so there is a duplicate
1776 // declaration name attempting a second transformation
1777 if ( param->type ) SemanticError( param->location, "duplicate declaration name \"%s\".", param->name->c_str() );
1778 // declaration type reset => declaration already transformed by a parameter name so there is a duplicate
1779 // parameter name attempting a second transformation
1780 if ( ! decl->type ) SemanticError( param->location, "duplicate parameter name \"%s\".", param->name->c_str() );
1781 param->type = decl->type; // set copy declaration type to parameter type
1782 decl->type = nullptr; // reset declaration type
1783 // Copy and reset attributes from declaration to parameter:
1784 splice( param->attributes, decl->attributes );
1785 } // if
1786 } // for
1787 // declaration type still set => type not moved to a matching parameter so there is a missing parameter name
1788 if ( decl->type ) SemanticError( decl->location, "missing name in parameter list %s", decl->name->c_str() );
1789 } // for
1790
1791 // Parameter names without a declaration default to type int:
1792 //
1793 // rtb( a, b, c ) const char * b; {} => int rtn( int a, const char * b, int c ) {}
1794
1795 for ( DeclarationNode * param = function.idList; param != nullptr; param = param->next ) {
1796 if ( ! param->type ) { // generate type int for empty parameter type
1797 param->type = new TypeData( TypeData::Basic );
1798 param->type->basictype = TypeData::Int;
1799 } // if
1800 } // for
1801
1802 function.params = function.idList; // newly modified idList becomes parameters
1803 function.idList = nullptr; // idList now empty
1804 delete function.oldDeclList; // deletes entire list
1805 function.oldDeclList = nullptr; // reset
1806} // buildKRFunction
1807
1808// Local Variables: //
1809// tab-width: 4 //
1810// mode: c++ //
1811// compile-command: "make install" //
1812// End: //
Note: See TracBrowser for help on using the repository browser.