source: src/Parser/TypeData.cc @ 1cfe640

Last change on this file since 1cfe640 was 1cfe640, checked in by Andrew Beach <ajbeach@…>, 3 months ago

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