source: src/Parser/TypeData.cc@ 8a2f7f1

ADT ast-experimental
Last change on this file since 8a2f7f1 was c468150, checked in by Andrew Beach <ajbeach@…>, 3 years ago

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