source: src/Parser/TypeData.cc @ b5bfb16

Last change on this file since b5bfb16 was 67467a3, checked in by Andrew Beach <ajbeach@…>, 8 weeks ago

Fused TypeData::Enum and TypeData::Aggregate, an enumeration is a kind of aggregate after all. There will always be some unused fields in Aggregate_t (but less in TypeData? overall) but the code is almost always simpler.
  • Property mode set to 100644
File size: 49.4 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
477TypeData * build_type_qualifier( ast::CV::Qualifiers tq ) {
478        TypeData * type = new TypeData;
479        type->qualifiers = tq;
480        return type;
481}
482
483TypeData * build_basic_type( TypeData::BasicType basic ) {
484        TypeData * type = new TypeData( TypeData::Basic );
485        type->basictype = basic;
486        return type;
487}
488
489TypeData * build_complex_type( TypeData::ComplexType complex ) {
490        TypeData * type = new TypeData( TypeData::Basic );
491        type->complextype = complex;
492        return type;
493}
494
495TypeData * build_signedness( TypeData::Signedness signedness ) {
496        TypeData * type = new TypeData( TypeData::Basic );
497        type->signedness = signedness;
498        return type;
499}
500
501TypeData * build_builtin_type( TypeData::BuiltinType bit ) {
502        TypeData * type = new TypeData( TypeData::Builtin );
503        type->builtintype = bit;
504        return type;
505}
506
507TypeData * build_length( TypeData::Length length ) {
508        TypeData * type = new TypeData( TypeData::Basic );
509        type->length = length;
510        return type;
511}
512
513TypeData * build_forall( DeclarationNode * forall ) {
514        TypeData * type = new TypeData( TypeData::Unknown );
515        type->forall = forall;
516        return type;
517}
518
519TypeData * build_global_scope() {
520        return new TypeData( TypeData::GlobalScope );
521}
522
523TypeData * build_qualified_type( TypeData * parent, TypeData * child ) {
524        TypeData * type = new TypeData( TypeData::Qualified );
525        type->qualified.parent = parent;
526        type->qualified.child = child;
527        return type;
528}
529
530TypeData * build_typedef( const std::string * name ) {
531        TypeData * type = new TypeData( TypeData::SymbolicInst );
532        type->symbolic.name = name;
533        type->symbolic.isTypedef = true;
534        type->symbolic.actuals = nullptr;
535        return type;
536}
537
538TypeData * build_type_gen( const std::string * name, ExpressionNode * params ) {
539        TypeData * type = new TypeData( TypeData::SymbolicInst );
540        type->symbolic.name = name;
541        type->symbolic.isTypedef = false;
542        type->symbolic.actuals = params;
543        return type;
544}
545
546TypeData * build_vtable_type( TypeData * base ) {
547        TypeData * type = new TypeData( TypeData::Vtable );
548        type->base = base;
549        return type;
550}
551
552// Takes ownership of src.
553static void addQualifiersToType( TypeData * dst, TypeData * src ) {
554        if ( dst->base ) {
555                addQualifiersToType( dst->base, src );
556        } else if ( dst->kind == TypeData::Function ) {
557                dst->base = src;
558                src = nullptr;
559    } else {
560                dst->qualifiers |= src->qualifiers;
561                delete src;
562        } // if
563}
564
565// Takes ownership of all arguments, gives ownership of return value.
566TypeData * addQualifiers( TypeData * ltype, TypeData * rtype ) {
567        if ( ltype->forall ) {
568                if ( rtype->forall ) {
569                        rtype->forall->set_last( ltype->forall );
570                } else if ( TypeData::Aggregate != rtype->kind ) {
571                        rtype->forall = ltype->forall;
572                } else if ( rtype->aggregate.params ) {
573                        rtype->aggregate.params->set_last( ltype->forall );
574                } else {
575                        rtype->aggregate.params = ltype->forall;
576                }
577                ltype->forall = nullptr;
578        }
579
580        addQualifiersToType( rtype, ltype );
581        return rtype;
582}
583
584// Helper for addType and cloneBaseType.
585static void addTypeToType( TypeData *& dst, TypeData *& src ) {
586        if ( src->forall && dst->kind == TypeData::Function ) {
587                if ( dst->forall ) {
588                        dst->forall->set_last( src->forall );
589                } else {
590                        dst->forall = src->forall;
591                } // if
592                src->forall = nullptr;
593        } // if
594        if ( dst->base ) {
595                addTypeToType( dst->base, src );
596                return;
597        }
598        switch ( dst->kind ) {
599        case TypeData::Unknown:
600                src->qualifiers |= dst->qualifiers;
601                // LEAKS dst?
602                dst = src;
603                src = nullptr;
604                break;
605        case TypeData::Basic:
606                dst->qualifiers |= src->qualifiers;
607                if ( src->kind != TypeData::Unknown ) {
608                        assert( src->kind == TypeData::Basic );
609
610                        if ( dst->basictype == TypeData::NoBasicType ) {
611                                dst->basictype = src->basictype;
612                        } else if ( src->basictype != TypeData::NoBasicType ) {
613                                SemanticError( yylloc, "multiple declaration types \"%s\" and \"%s\".",
614                                        TypeData::basicTypeNames[ dst->basictype ],
615                                        TypeData::basicTypeNames[ src->basictype ] );
616                        }
617                        if ( dst->complextype == TypeData::NoComplexType ) {
618                                dst->complextype = src->complextype;
619                        } else if ( src->complextype != TypeData::NoComplexType ) {
620                                SemanticError( yylloc, "multiple declaration types \"%s\" and \"%s\".",
621                                        TypeData::complexTypeNames[ src->complextype ],
622                                        TypeData::complexTypeNames[ src->complextype ] );
623                        }
624                        if ( dst->signedness == TypeData::NoSignedness ) {
625                                dst->signedness = src->signedness;
626                        } else if ( src->signedness != TypeData::NoSignedness ) {
627                                SemanticError( yylloc, "conflicting type specifier \"%s\" and \"%s\".",
628                                        TypeData::signednessNames[ dst->signedness ],
629                                        TypeData::signednessNames[ src->signedness ] );
630                        }
631                        if ( dst->length == TypeData::NoLength ) {
632                                dst->length = src->length;
633                        } else if ( dst->length == TypeData::Long && src->length == TypeData::Long ) {
634                                dst->length = TypeData::LongLong;
635                        } else if ( src->length != TypeData::NoLength ) {
636                                SemanticError( yylloc, "conflicting type specifier \"%s\" and \"%s\".",
637                                        TypeData::lengthNames[ dst->length ],
638                                        TypeData::lengthNames[ src->length ] );
639                        }
640                } // if
641                break;
642        default:
643                switch ( src->kind ) {
644                case TypeData::Aggregate:
645                        dst->base = new TypeData( TypeData::AggregateInst );
646                        dst->base->aggInst.aggregate = src;
647                        if ( src->kind == TypeData::Aggregate ) {
648                                dst->base->aggInst.params = maybeCopy( src->aggregate.actuals );
649                        } // if
650                        dst->base->qualifiers |= src->qualifiers;
651                        src = nullptr;
652                        break;
653                default:
654                        if ( dst->forall ) {
655                                dst->forall->set_last( src->forall );
656                        } else {
657                                dst->forall = src->forall;
658                        } // if
659                        src->forall = nullptr;
660                        dst->base = src;
661                        src = nullptr;
662                } // switch
663        } // switch
664}
665
666// Takes ownership of all arguments, gives ownership of return value.
667TypeData * addType( TypeData * ltype, TypeData * rtype, std::vector<ast::ptr<ast::Attribute>> & attributes ) {
668        if ( rtype ) {
669                addTypeToType( rtype, ltype );
670                return rtype;
671        } else {
672                if ( ltype->kind == TypeData::Aggregate ) {
673                        // Hide type information aggregate instances.
674                        rtype = new TypeData( TypeData::AggregateInst );
675                        rtype->aggInst.aggregate = ltype;
676                        rtype->aggInst.aggregate->aggregate.attributes.swap( attributes ); // change ownership
677                        rtype->aggInst.hoistType = ltype->aggregate.body;
678                        rtype->aggInst.params = maybeCopy( ltype->aggregate.actuals );
679                        rtype->qualifiers |= ltype->qualifiers;
680                } else {
681                        rtype = ltype;
682                } // if
683                return rtype;
684        } // if
685}
686
687TypeData * addType( TypeData * ltype, TypeData * rtype ) {
688        std::vector<ast::ptr<ast::Attribute>> attributes;
689        return addType( ltype, rtype, attributes );
690}
691
692// Takes ownership of both arguments, gives ownership of return value.
693TypeData * cloneBaseType( TypeData * type, TypeData * other ) {
694        TypeData * newType = type->getLastBase()->clone();
695        if ( newType->kind == TypeData::AggregateInst ) {
696                // don't duplicate members
697                assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
698                delete newType->aggInst.aggregate->aggregate.fields;
699                newType->aggInst.aggregate->aggregate.fields = nullptr;
700                newType->aggInst.aggregate->aggregate.body = false;
701                // don't hoist twice
702                newType->aggInst.hoistType = false;
703        } // if
704        newType->forall = maybeCopy( type->forall );
705
706        if ( other ) {
707                addTypeToType( other, newType );
708                delete newType;
709                return other;
710        } // if
711        return newType;
712}
713
714TypeData * makeNewBase( TypeData * type ) {
715        switch ( type->kind ) {
716        case TypeData::Aggregate: {
717                TypeData * out = new TypeData( TypeData::AggregateInst );
718                out->aggInst.aggregate = type;
719                if ( TypeData::Aggregate == type->kind ) {
720                        out->aggInst.params = maybeCopy( type->aggregate.actuals );
721                }
722                out->qualifiers |= type->qualifiers;
723                return out;
724        }
725        default:
726                return type;
727        } // switch
728}
729
730
731void buildForall(
732                const DeclarationNode * firstNode,
733                std::vector<ast::ptr<ast::TypeInstType>> &outputList ) {
734        {
735                std::vector<ast::ptr<ast::Type>> tmpList;
736                buildTypeList( firstNode, tmpList );
737                for ( auto tmp : tmpList ) {
738                        outputList.emplace_back(
739                                strict_dynamic_cast<const ast::TypeInstType *>(
740                                        tmp.release() ) );
741                }
742        }
743        auto n = firstNode;
744        for ( auto i = outputList.begin() ;
745                        i != outputList.end() ;
746                        ++i, n = n->next ) {
747                // Only the object type class adds additional assertions.
748                if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
749                        continue;
750                }
751
752                ast::TypeDecl const * td = i->strict_as<ast::TypeDecl>();
753                std::vector<ast::ptr<ast::DeclWithType>> newAssertions;
754                auto mutTypeDecl = ast::mutate( td );
755                const CodeLocation & location = mutTypeDecl->location;
756                *i = mutTypeDecl;
757
758                // add assertion parameters to `type' tyvars in reverse order
759                // add assignment operator:  T * ?=?(T *, T)
760                newAssertions.push_back( new ast::FunctionDecl(
761                        location,
762                        "?=?",
763                        {}, // forall
764                        {}, // assertions
765                        {
766                                new ast::ObjectDecl(
767                                        location,
768                                        "",
769                                        new ast::ReferenceType( i->get() ),
770                                        (ast::Init *)nullptr,
771                                        ast::Storage::Classes(),
772                                        ast::Linkage::Cforall,
773                                        (ast::Expr *)nullptr
774                                ),
775                                new ast::ObjectDecl(
776                                        location,
777                                        "",
778                                        i->get(),
779                                        (ast::Init *)nullptr,
780                                        ast::Storage::Classes(),
781                                        ast::Linkage::Cforall,
782                                        (ast::Expr *)nullptr
783                                ),
784                        }, // params
785                        {
786                                new ast::ObjectDecl(
787                                        location,
788                                        "",
789                                        i->get(),
790                                        (ast::Init *)nullptr,
791                                        ast::Storage::Classes(),
792                                        ast::Linkage::Cforall,
793                                        (ast::Expr *)nullptr
794                                ),
795                        }, // returns
796                        (ast::CompoundStmt *)nullptr,
797                        ast::Storage::Classes(),
798                        ast::Linkage::Cforall
799                ) );
800
801                // add default ctor:  void ?{}(T *)
802                newAssertions.push_back( new ast::FunctionDecl(
803                        location,
804                        "?{}",
805                        {}, // forall
806                        {}, // assertions
807                        {
808                                new ast::ObjectDecl(
809                                        location,
810                                        "",
811                                        new ast::ReferenceType( i->get() ),
812                                        (ast::Init *)nullptr,
813                                        ast::Storage::Classes(),
814                                        ast::Linkage::Cforall,
815                                        (ast::Expr *)nullptr
816                                ),
817                        }, // params
818                        {}, // returns
819                        (ast::CompoundStmt *)nullptr,
820                        ast::Storage::Classes(),
821                        ast::Linkage::Cforall
822                ) );
823
824                // add copy ctor:  void ?{}(T *, T)
825                newAssertions.push_back( new ast::FunctionDecl(
826                        location,
827                        "?{}",
828                        {}, // forall
829                        {}, // assertions
830                        {
831                                new ast::ObjectDecl(
832                                        location,
833                                        "",
834                                        new ast::ReferenceType( i->get() ),
835                                        (ast::Init *)nullptr,
836                                        ast::Storage::Classes(),
837                                        ast::Linkage::Cforall,
838                                        (ast::Expr *)nullptr
839                                ),
840                                new ast::ObjectDecl(
841                                        location,
842                                        "",
843                                        i->get(),
844                                        (ast::Init *)nullptr,
845                                        ast::Storage::Classes(),
846                                        ast::Linkage::Cforall,
847                                        (ast::Expr *)nullptr
848                                ),
849                        }, // params
850                        {}, // returns
851                        (ast::CompoundStmt *)nullptr,
852                        ast::Storage::Classes(),
853                        ast::Linkage::Cforall
854                ) );
855
856                // add dtor:  void ^?{}(T *)
857                newAssertions.push_back( new ast::FunctionDecl(
858                        location,
859                        "^?{}",
860                        {}, // forall
861                        {}, // assertions
862                        {
863                                new ast::ObjectDecl(
864                                        location,
865                                        "",
866                                        new ast::ReferenceType( i->get() ),
867                                        (ast::Init *)nullptr,
868                                        ast::Storage::Classes(),
869                                        ast::Linkage::Cforall,
870                                        (ast::Expr *)nullptr
871                                ),
872                        }, // params
873                        {}, // returns
874                        (ast::CompoundStmt *)nullptr,
875                        ast::Storage::Classes(),
876                        ast::Linkage::Cforall
877                ) );
878
879                spliceBegin( mutTypeDecl->assertions, newAssertions );
880        } // for
881}
882
883
884void buildForall(
885                const DeclarationNode * firstNode,
886                std::vector<ast::ptr<ast::TypeDecl>> &outputForall ) {
887        buildList( firstNode, outputForall );
888        auto n = firstNode;
889        for ( auto i = outputForall.begin() ;
890                        i != outputForall.end() ;
891                        ++i, n = n->next ) {
892                // Only the object type class adds additional assertions.
893                if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
894                        continue;
895                }
896
897                ast::TypeDecl const * td = i->strict_as<ast::TypeDecl>();
898                std::vector<ast::ptr<ast::DeclWithType>> newAssertions;
899                auto mutTypeDecl = ast::mutate( td );
900                const CodeLocation & location = mutTypeDecl->location;
901                *i = mutTypeDecl;
902
903                // add assertion parameters to `type' tyvars in reverse order
904                // add assignment operator:  T * ?=?(T *, T)
905                newAssertions.push_back( new ast::FunctionDecl(
906                        location,
907                        "?=?",
908                        {}, // forall
909                        {}, // assertions
910                        {
911                                new ast::ObjectDecl(
912                                        location,
913                                        "",
914                                        new ast::ReferenceType( new ast::TypeInstType( td->name, *i ) ),
915                                        (ast::Init *)nullptr,
916                                        ast::Storage::Classes(),
917                                        ast::Linkage::Cforall,
918                                        (ast::Expr *)nullptr
919                                ),
920                                new ast::ObjectDecl(
921                                        location,
922                                        "",
923                                        new ast::TypeInstType( td->name, *i ),
924                                        (ast::Init *)nullptr,
925                                        ast::Storage::Classes(),
926                                        ast::Linkage::Cforall,
927                                        (ast::Expr *)nullptr
928                                ),
929                        }, // params
930                        {
931                                new ast::ObjectDecl(
932                                        location,
933                                        "",
934                                        new ast::TypeInstType( td->name, *i ),
935                                        (ast::Init *)nullptr,
936                                        ast::Storage::Classes(),
937                                        ast::Linkage::Cforall,
938                                        (ast::Expr *)nullptr
939                                ),
940                        }, // returns
941                        (ast::CompoundStmt *)nullptr,
942                        ast::Storage::Classes(),
943                        ast::Linkage::Cforall
944                ) );
945
946                // add default ctor:  void ?{}(T *)
947                newAssertions.push_back( new ast::FunctionDecl(
948                        location,
949                        "?{}",
950                        {}, // forall
951                        {}, // assertions
952                        {
953                                new ast::ObjectDecl(
954                                        location,
955                                        "",
956                                        new ast::ReferenceType(
957                                                new ast::TypeInstType( td->name, i->get() ) ),
958                                        (ast::Init *)nullptr,
959                                        ast::Storage::Classes(),
960                                        ast::Linkage::Cforall,
961                                        (ast::Expr *)nullptr
962                                ),
963                        }, // params
964                        {}, // returns
965                        (ast::CompoundStmt *)nullptr,
966                        ast::Storage::Classes(),
967                        ast::Linkage::Cforall
968                ) );
969
970                // add copy ctor:  void ?{}(T *, T)
971                newAssertions.push_back( new ast::FunctionDecl(
972                        location,
973                        "?{}",
974                        {}, // forall
975                        {}, // assertions
976                        {
977                                new ast::ObjectDecl(
978                                        location,
979                                        "",
980                                        new ast::ReferenceType(
981                                                new ast::TypeInstType( td->name, *i ) ),
982                                        (ast::Init *)nullptr,
983                                        ast::Storage::Classes(),
984                                        ast::Linkage::Cforall,
985                                        (ast::Expr *)nullptr
986                                ),
987                                new ast::ObjectDecl(
988                                        location,
989                                        "",
990                                        new ast::TypeInstType( td->name, *i ),
991                                        (ast::Init *)nullptr,
992                                        ast::Storage::Classes(),
993                                        ast::Linkage::Cforall,
994                                        (ast::Expr *)nullptr
995                                ),
996                        }, // params
997                        {}, // returns
998                        (ast::CompoundStmt *)nullptr,
999                        ast::Storage::Classes(),
1000                        ast::Linkage::Cforall
1001                ) );
1002
1003                // add dtor:  void ^?{}(T *)
1004                newAssertions.push_back( new ast::FunctionDecl(
1005                        location,
1006                        "^?{}",
1007                        {}, // forall
1008                        {}, // assertions
1009                        {
1010                                new ast::ObjectDecl(
1011                                        location,
1012                                        "",
1013                                        new ast::ReferenceType(
1014                                                new ast::TypeInstType( i->get() )
1015                                        ),
1016                                        (ast::Init *)nullptr,
1017                                        ast::Storage::Classes(),
1018                                        ast::Linkage::Cforall,
1019                                        (ast::Expr *)nullptr
1020                                ),
1021                        }, // params
1022                        {}, // returns
1023                        (ast::CompoundStmt *)nullptr,
1024                        ast::Storage::Classes(),
1025                        ast::Linkage::Cforall
1026                ) );
1027
1028                spliceBegin( mutTypeDecl->assertions, newAssertions );
1029        } // for
1030} // buildForall
1031
1032
1033ast::Type * typebuild( const TypeData * td ) {
1034        assert( td );
1035        switch ( td->kind ) {
1036        case TypeData::Unknown:
1037                // fill in implicit int
1038                return new ast::BasicType(
1039                        ast::BasicType::SignedInt,
1040                        buildQualifiers( td )
1041                );
1042        case TypeData::Basic:
1043                return buildBasicType( td );
1044        case TypeData::Pointer:
1045                return buildPointer( td );
1046        case TypeData::Array:
1047                return buildArray( td );
1048        case TypeData::Reference:
1049                return buildReference( td );
1050        case TypeData::Function:
1051                return buildFunctionType( td );
1052        case TypeData::AggregateInst:
1053                return buildAggInst( td );
1054        case TypeData::EnumConstant:
1055                return new ast::EnumInstType( "", buildQualifiers( td ) );
1056        case TypeData::SymbolicInst:
1057                return buildSymbolicInst( td );
1058        case TypeData::Tuple:
1059                return buildTuple( td );
1060        case TypeData::Typeof:
1061        case TypeData::Basetypeof:
1062                return buildTypeof( td );
1063        case TypeData::Vtable:
1064                return buildVtable( td );
1065        case TypeData::Builtin:
1066                switch ( td->builtintype ) {
1067                case TypeData::Zero:
1068                        return new ast::ZeroType();
1069                case TypeData::One:
1070                        return new ast::OneType();
1071                default:
1072                        return new ast::VarArgsType( buildQualifiers( td ) );
1073                } // switch
1074        case TypeData::GlobalScope:
1075                return new ast::GlobalScopeType();
1076        case TypeData::Qualified:
1077                return new ast::QualifiedType(
1078                        typebuild( td->qualified.parent ),
1079                        typebuild( td->qualified.child ),
1080                        buildQualifiers( td )
1081                );
1082        case TypeData::Symbolic:
1083        case TypeData::Aggregate:
1084                assert( false );
1085        } // switch
1086
1087        return nullptr;
1088} // typebuild
1089
1090
1091TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) {
1092        TypeData * ret = nullptr;
1093
1094        switch ( td->kind ) {
1095        case TypeData::Aggregate:
1096                if ( ! toplevel && td->aggregate.body ) {
1097                        ret = td->clone();
1098                } // if
1099                break;
1100        case TypeData::AggregateInst:
1101                if ( td->aggInst.aggregate ) {
1102                        ret = typeextractAggregate( td->aggInst.aggregate, false );
1103                } // if
1104                break;
1105        default:
1106                if ( td->base ) {
1107                        ret = typeextractAggregate( td->base, false );
1108                } // if
1109        } // switch
1110        return ret;
1111} // typeextractAggregate
1112
1113
1114ast::CV::Qualifiers buildQualifiers( const TypeData * td ) {
1115        return td->qualifiers;
1116} // buildQualifiers
1117
1118
1119static string genTSError( string msg, TypeData::BasicType basictype ) {
1120        SemanticError( yylloc, "invalid type specifier \"%s\" for type \"%s\".", msg.c_str(), TypeData::basicTypeNames[basictype] );
1121} // genTSError
1122
1123ast::Type * buildBasicType( const TypeData * td ) {
1124        ast::BasicType::Kind ret;
1125
1126        switch ( td->basictype ) {
1127        case TypeData::Void:
1128                if ( td->signedness != TypeData::NoSignedness ) {
1129                        genTSError( TypeData::signednessNames[ td->signedness ], td->basictype );
1130                } // if
1131                if ( td->length != TypeData::NoLength ) {
1132                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1133                } // if
1134                return new ast::VoidType( buildQualifiers( td ) );
1135                break;
1136
1137        case TypeData::Bool:
1138                if ( td->signedness != TypeData::NoSignedness ) {
1139                        genTSError( TypeData::signednessNames[ td->signedness ], td->basictype );
1140                } // if
1141                if ( td->length != TypeData::NoLength ) {
1142                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1143                } // if
1144
1145                ret = ast::BasicType::Bool;
1146                break;
1147
1148        case TypeData::Char:
1149                // C11 Standard 6.2.5.15: The three types char, signed char, and unsigned char are collectively called the
1150                // character types. The implementation shall define char to have the same range, representation, and behavior as
1151                // either signed char or unsigned char.
1152                static ast::BasicType::Kind chartype[] = { ast::BasicType::SignedChar, ast::BasicType::UnsignedChar, ast::BasicType::Char };
1153
1154                if ( td->length != TypeData::NoLength ) {
1155                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1156                } // if
1157
1158                ret = chartype[ td->signedness ];
1159                break;
1160
1161        case TypeData::Int:
1162                static ast::BasicType::Kind inttype[2][4] = {
1163                        { ast::BasicType::ShortSignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, ast::BasicType::SignedInt },
1164                        { ast::BasicType::ShortUnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, ast::BasicType::UnsignedInt },
1165                };
1166
1167        Integral: ;
1168                if ( td->signedness == TypeData::NoSignedness ) {
1169                        const_cast<TypeData *>(td)->signedness = TypeData::Signed;
1170                } // if
1171                ret = inttype[ td->signedness ][ td->length ];
1172                break;
1173
1174        case TypeData::Int128:
1175                ret = td->signedness == TypeData::Unsigned ? ast::BasicType::UnsignedInt128 : ast::BasicType::SignedInt128;
1176                if ( td->length != TypeData::NoLength ) {
1177                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1178                } // if
1179                break;
1180
1181        case TypeData::Float:
1182        case TypeData::Double:
1183        case TypeData::LongDouble:                                      // not set until below
1184        case TypeData::uuFloat80:
1185        case TypeData::uuFloat128:
1186        case TypeData::uFloat16:
1187        case TypeData::uFloat32:
1188        case TypeData::uFloat32x:
1189        case TypeData::uFloat64:
1190        case TypeData::uFloat64x:
1191        case TypeData::uFloat128:
1192        case TypeData::uFloat128x:
1193                static ast::BasicType::Kind floattype[2][12] = {
1194                        { 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, },
1195                        { 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, },
1196                };
1197
1198        FloatingPoint: ;
1199                if ( td->signedness != TypeData::NoSignedness ) {
1200                        genTSError( TypeData::signednessNames[ td->signedness ], td->basictype );
1201                } // if
1202                if ( td->length == TypeData::Short || td->length == TypeData::LongLong ) {
1203                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1204                } // if
1205                if ( td->basictype != TypeData::Double && td->length == TypeData::Long ) {
1206                        genTSError( TypeData::lengthNames[ td->length ], td->basictype );
1207                } // if
1208                if ( td->complextype == TypeData::Imaginary ) {
1209                        genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype );
1210                } // if
1211                if ( (td->basictype == TypeData::uuFloat80 || td->basictype == TypeData::uuFloat128) && td->complextype == TypeData::Complex ) { // gcc unsupported
1212                        genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype );
1213                } // if
1214                if ( td->length == TypeData::Long ) {
1215                        const_cast<TypeData *>(td)->basictype = TypeData::LongDouble;
1216                } // if
1217
1218                ret = floattype[ td->complextype ][ td->basictype - TypeData::Float ];
1219                //printf( "XXXX %d %d %d %d\n", td->complextype, td->basictype, TypeData::Float, ret );
1220                break;
1221
1222        case TypeData::NoBasicType:
1223                // No basic type in declaration => default double for Complex/Imaginary and int type for integral types
1224                if ( td->complextype == TypeData::Complex || td->complextype == TypeData::Imaginary ) {
1225                        const_cast<TypeData *>(td)->basictype = TypeData::Double;
1226                        goto FloatingPoint;
1227                } // if
1228
1229                const_cast<TypeData *>(td)->basictype = TypeData::Int;
1230                goto Integral;
1231        default:
1232                assertf( false, "unknown basic type" );
1233                return nullptr;
1234        } // switch
1235
1236        ast::BasicType * bt = new ast::BasicType( ret, buildQualifiers( td ) );
1237        return bt;
1238} // buildBasicType
1239
1240
1241static ast::Type * buildDefaultType( const TypeData * td ) {
1242        return ( td ) ? typebuild( td ) : new ast::BasicType( ast::BasicType::SignedInt );
1243} // buildDefaultType
1244
1245
1246ast::PointerType * buildPointer( const TypeData * td ) {
1247        return new ast::PointerType(
1248                buildDefaultType( td->base ),
1249                buildQualifiers( td )
1250        );
1251} // buildPointer
1252
1253
1254ast::ArrayType * buildArray( const TypeData * td ) {
1255        return new ast::ArrayType(
1256                buildDefaultType( td->base ),
1257                maybeBuild( td->array.dimension ),
1258                td->array.isVarLen ? ast::VariableLen : ast::FixedLen,
1259                td->array.isStatic ? ast::StaticDim : ast::DynamicDim,
1260                buildQualifiers( td )
1261        );
1262} // buildArray
1263
1264
1265ast::ReferenceType * buildReference( const TypeData * td ) {
1266        return new ast::ReferenceType(
1267                buildDefaultType( td->base ),
1268                buildQualifiers( td )
1269        );
1270} // buildReference
1271
1272
1273ast::AggregateDecl * buildAggregate( const TypeData * td, std::vector<ast::ptr<ast::Attribute>> attributes, ast::Linkage::Spec linkage ) {
1274        assert( td->kind == TypeData::Aggregate );
1275        ast::AggregateDecl * at;
1276        switch ( td->aggregate.kind ) {
1277        case ast::AggregateDecl::Struct:
1278        case ast::AggregateDecl::Coroutine:
1279        case ast::AggregateDecl::Exception:
1280        case ast::AggregateDecl::Generator:
1281        case ast::AggregateDecl::Monitor:
1282        case ast::AggregateDecl::Thread:
1283                at = new ast::StructDecl( td->location,
1284                        *td->aggregate.name,
1285                        td->aggregate.kind,
1286                        std::move( attributes ),
1287                        linkage
1288                );
1289                buildForall( td->aggregate.params, at->params );
1290                break;
1291        case ast::AggregateDecl::Union:
1292                at = new ast::UnionDecl( td->location,
1293                        *td->aggregate.name,
1294                        std::move( attributes ),
1295                        linkage
1296                );
1297                buildForall( td->aggregate.params, at->params );
1298                break;
1299        case ast::AggregateDecl::Enum:
1300                return buildEnum( td, std::move( attributes ), linkage );
1301        case ast::AggregateDecl::Trait:
1302                at = new ast::TraitDecl( td->location,
1303                        *td->aggregate.name,
1304                        std::move( attributes ),
1305                        linkage
1306                );
1307                buildList( td->aggregate.params, at->params );
1308                break;
1309        default:
1310                assert( false );
1311        } // switch
1312
1313        buildList( td->aggregate.fields, at->members );
1314        at->set_body( td->aggregate.body );
1315
1316        return at;
1317} // buildAggregate
1318
1319
1320ast::BaseInstType * buildComAggInst(
1321                const TypeData * td,
1322                std::vector<ast::ptr<ast::Attribute>> && attributes,
1323                ast::Linkage::Spec linkage ) {
1324        switch ( td->kind ) {
1325        case TypeData::Aggregate:
1326                if ( td->aggregate.body ) {
1327                        ast::AggregateDecl * typedecl =
1328                                buildAggregate( td, std::move( attributes ), linkage );
1329                        switch ( td->aggregate.kind ) {
1330                        case ast::AggregateDecl::Struct:
1331                        case ast::AggregateDecl::Coroutine:
1332                        case ast::AggregateDecl::Monitor:
1333                        case ast::AggregateDecl::Thread:
1334                                return new ast::StructInstType(
1335                                        strict_dynamic_cast<ast::StructDecl *>( typedecl ),
1336                                        buildQualifiers( td )
1337                                );
1338                        case ast::AggregateDecl::Union:
1339                                return new ast::UnionInstType(
1340                                        strict_dynamic_cast<ast::UnionDecl *>( typedecl ),
1341                                        buildQualifiers( td )
1342                                );
1343                        case ast::AggregateDecl::Enum:
1344                                return new ast::EnumInstType(
1345                                        strict_dynamic_cast<ast::EnumDecl *>( typedecl ),
1346                                        buildQualifiers( td )
1347                                );
1348                        case ast::AggregateDecl::Trait:
1349                                assert( false );
1350                                break;
1351                        default:
1352                                assert( false );
1353                        } // switch
1354                } else {
1355                        switch ( td->aggregate.kind ) {
1356                        case ast::AggregateDecl::Struct:
1357                        case ast::AggregateDecl::Coroutine:
1358                        case ast::AggregateDecl::Monitor:
1359                        case ast::AggregateDecl::Thread:
1360                                return new ast::StructInstType(
1361                                        *td->aggregate.name,
1362                                        buildQualifiers( td )
1363                                );
1364                        case ast::AggregateDecl::Union:
1365                                return new ast::UnionInstType(
1366                                        *td->aggregate.name,
1367                                        buildQualifiers( td )
1368                                );
1369                        case ast::AggregateDecl::Enum:
1370                                return new ast::EnumInstType(
1371                                        *td->aggregate.name,
1372                                        buildQualifiers( td )
1373                                );
1374                        case ast::AggregateDecl::Trait:
1375                                return new ast::TraitInstType(
1376                                        *td->aggregate.name,
1377                                        buildQualifiers( td )
1378                                );
1379                        default:
1380                                assert( false );
1381                        } // switch
1382                        break;
1383                } // if
1384                break;
1385        default:
1386                assert( false );
1387        } // switch
1388        assert( false );
1389} // buildAggInst
1390
1391
1392ast::BaseInstType * buildAggInst( const TypeData * td ) {
1393        assert( td->kind == TypeData::AggregateInst );
1394
1395        ast::BaseInstType * ret = nullptr;
1396        TypeData * type = td->aggInst.aggregate;
1397        switch ( type->kind ) {
1398        case TypeData::Aggregate:
1399                switch ( type->aggregate.kind ) {
1400                case ast::AggregateDecl::Struct:
1401                case ast::AggregateDecl::Coroutine:
1402                case ast::AggregateDecl::Monitor:
1403                case ast::AggregateDecl::Thread:
1404                        ret = new ast::StructInstType(
1405                                *type->aggregate.name,
1406                                buildQualifiers( type )
1407                        );
1408                        break;
1409                case ast::AggregateDecl::Union:
1410                        ret = new ast::UnionInstType(
1411                                *type->aggregate.name,
1412                                buildQualifiers( type )
1413                        );
1414                        break;
1415                case ast::AggregateDecl::Enum:
1416                        ret = new ast::EnumInstType(
1417                                *type->aggregate.name,
1418                                buildQualifiers( type )
1419                        );
1420                        break;
1421                case ast::AggregateDecl::Trait:
1422                        ret = new ast::TraitInstType(
1423                                *type->aggregate.name,
1424                                buildQualifiers( type )
1425                        );
1426                        break;
1427                default:
1428                        assert( false );
1429                } // switch
1430                break;
1431        default:
1432                assert( false );
1433        } // switch
1434
1435        ret->hoistType = td->aggInst.hoistType;
1436        buildList( td->aggInst.params, ret->params );
1437        return ret;
1438} // buildAggInst
1439
1440
1441ast::NamedTypeDecl * buildSymbolic(
1442                const TypeData * td,
1443                std::vector<ast::ptr<ast::Attribute>> attributes,
1444                const std::string & name,
1445                ast::Storage::Classes scs,
1446                ast::Linkage::Spec linkage ) {
1447        assert( td->kind == TypeData::Symbolic );
1448        ast::NamedTypeDecl * ret;
1449        assert( td->base );
1450        if ( td->symbolic.isTypedef ) {
1451                ret = new ast::TypedefDecl(
1452                        td->location,
1453                        name,
1454                        scs,
1455                        typebuild( td->base ),
1456                        linkage
1457                );
1458        } else {
1459                ret = new ast::TypeDecl(
1460                        td->location,
1461                        name,
1462                        scs,
1463                        typebuild( td->base ),
1464                        ast::TypeDecl::Dtype,
1465                        true
1466                );
1467        } // if
1468        buildList( td->symbolic.assertions, ret->assertions );
1469        splice( ret->base.get_and_mutate()->attributes, attributes );
1470        return ret;
1471} // buildSymbolic
1472
1473
1474ast::EnumDecl * buildEnum(
1475                const TypeData * td,
1476                std::vector<ast::ptr<ast::Attribute>> && attributes,
1477                ast::Linkage::Spec linkage ) {
1478        assert( td->kind == TypeData::Aggregate );
1479        assert( td->aggregate.kind == ast::AggregateDecl::Enum );
1480        ast::Type * baseType = td->base ? typebuild(td->base) : nullptr;
1481        ast::EnumDecl * ret = new ast::EnumDecl(
1482                td->location,
1483                *td->aggregate.name,
1484                td->aggregate.typed,
1485                std::move( attributes ),
1486                linkage,
1487                baseType
1488        );
1489        buildList( td->aggregate.fields, ret->members );
1490        auto members = ret->members.begin();
1491        ret->hide = td->aggregate.hiding == EnumHiding::Hide ? ast::EnumDecl::EnumHiding::Hide : ast::EnumDecl::EnumHiding::Visible;
1492        for ( const DeclarationNode * cur = td->aggregate.fields ; cur != nullptr ; cur = cur->next, ++members ) {
1493                if ( cur->enumInLine ) {
1494                        // Do Nothing
1495                } else if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
1496                        SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
1497                } else if ( cur->has_enumeratorValue() ) {
1498                        ast::Decl * member = members->get_and_mutate();
1499                        ast::ObjectDecl * object = strict_dynamic_cast<ast::ObjectDecl *>( member );
1500                        object->init = new ast::SingleInit(
1501                                td->location,
1502                                maybeMoveBuild( cur->consume_enumeratorValue() ),
1503                                ast::NoConstruct
1504                        );
1505                } else if ( !cur->initializer ) {
1506                        if ( baseType && (!dynamic_cast<ast::BasicType *>(baseType) || !dynamic_cast<ast::BasicType *>(baseType)->isInteger())) {
1507                                SemanticError( td->location, "Enumerators of an non-integer typed enum must be explicitly initialized." );
1508                        }
1509                }
1510                // else cur is a List Initializer and has been set as init in buildList()
1511                // if
1512        } // for
1513        ret->body = td->aggregate.body;
1514        return ret;
1515} // buildEnum
1516
1517
1518ast::TypeInstType * buildSymbolicInst( const TypeData * td ) {
1519        assert( td->kind == TypeData::SymbolicInst );
1520        ast::TypeInstType * ret = new ast::TypeInstType(
1521                *td->symbolic.name,
1522                ast::TypeDecl::Dtype,
1523                buildQualifiers( td )
1524        );
1525        buildList( td->symbolic.actuals, ret->params );
1526        return ret;
1527} // buildSymbolicInst
1528
1529
1530ast::TupleType * buildTuple( const TypeData * td ) {
1531        assert( td->kind == TypeData::Tuple );
1532        std::vector<ast::ptr<ast::Type>> types;
1533        buildTypeList( td->tuple, types );
1534        ast::TupleType * ret = new ast::TupleType(
1535                std::move( types ),
1536                buildQualifiers( td )
1537        );
1538        return ret;
1539} // buildTuple
1540
1541
1542ast::TypeofType * buildTypeof( const TypeData * td ) {
1543        assert( td->kind == TypeData::Typeof || td->kind == TypeData::Basetypeof );
1544        assert( td->typeexpr );
1545        return new ast::TypeofType(
1546                td->typeexpr->build(),
1547                td->kind == TypeData::Typeof
1548                        ? ast::TypeofType::Typeof : ast::TypeofType::Basetypeof,
1549                buildQualifiers( td )
1550        );
1551} // buildTypeof
1552
1553
1554ast::VTableType * buildVtable( const TypeData * td ) {
1555        assert( td->base );
1556        return new ast::VTableType(
1557                typebuild( td->base ),
1558                buildQualifiers( td )
1559        );
1560} // buildVtable
1561
1562
1563ast::FunctionDecl * buildFunctionDecl(
1564                const TypeData * td,
1565                const string &name,
1566                ast::Storage::Classes scs,
1567                ast::Function::Specs funcSpec,
1568                ast::Linkage::Spec linkage,
1569                ast::Expr * asmName,
1570                std::vector<ast::ptr<ast::Attribute>> && attributes ) {
1571        assert( td->kind == TypeData::Function );
1572        // For some reason FunctionDecl takes a bool instead of an ArgumentFlag.
1573        bool isVarArgs = !td->function.params || td->function.params->hasEllipsis;
1574        ast::CV::Qualifiers cvq = buildQualifiers( td );
1575        std::vector<ast::ptr<ast::TypeDecl>> forall;
1576        std::vector<ast::ptr<ast::DeclWithType>> assertions;
1577        std::vector<ast::ptr<ast::DeclWithType>> params;
1578        std::vector<ast::ptr<ast::DeclWithType>> returns;
1579        buildList( td->function.params, params );
1580        buildForall( td->forall, forall );
1581        // Functions do not store their assertions there anymore.
1582        for ( ast::ptr<ast::TypeDecl> & type_param : forall ) {
1583                auto mut = type_param.get_and_mutate();
1584                splice( assertions, mut->assertions );
1585        }
1586        if ( td->base ) {
1587                switch ( td->base->kind ) {
1588                case TypeData::Tuple:
1589                        buildList( td->base->tuple, returns );
1590                        break;
1591                default:
1592                        returns.push_back( dynamic_cast<ast::DeclWithType *>(
1593                                buildDecl(
1594                                        td->base,
1595                                        "",
1596                                        ast::Storage::Classes(),
1597                                        (ast::Expr *)nullptr, // bitfieldWidth
1598                                        ast::Function::Specs(),
1599                                        ast::Linkage::Cforall,
1600                                        (ast::Expr *)nullptr // asmName
1601                                )
1602                        ) );
1603                } // switch
1604        } else {
1605                returns.push_back( new ast::ObjectDecl(
1606                        td->location,
1607                        "",
1608                        new ast::BasicType( ast::BasicType::SignedInt ),
1609                        (ast::Init *)nullptr,
1610                        ast::Storage::Classes(),
1611                        ast::Linkage::Cforall
1612                ) );
1613        } // if
1614        ast::Stmt * stmt = maybeBuild( td->function.body );
1615        ast::CompoundStmt * body = dynamic_cast<ast::CompoundStmt *>( stmt );
1616        ast::FunctionDecl * decl = new ast::FunctionDecl( td->location,
1617                name,
1618                std::move( forall ),
1619                std::move( assertions ),
1620                std::move( params ),
1621                std::move( returns ),
1622                body,
1623                scs,
1624                linkage,
1625                std::move( attributes ),
1626                funcSpec,
1627                (isVarArgs) ? ast::VariableArgs : ast::FixedArgs
1628        );
1629        buildList( td->function.withExprs, decl->withExprs );
1630        decl->asmName = asmName;
1631        // This may be redundant on a declaration.
1632        decl->type.get_and_mutate()->qualifiers = cvq;
1633        return decl;
1634} // buildFunctionDecl
1635
1636
1637ast::Decl * buildDecl(
1638                const TypeData * td,
1639                const string &name,
1640                ast::Storage::Classes scs,
1641                ast::Expr * bitfieldWidth,
1642                ast::Function::Specs funcSpec,
1643                ast::Linkage::Spec linkage,
1644                ast::Expr * asmName,
1645                ast::Init * init,
1646                std::vector<ast::ptr<ast::Attribute>> && attributes ) {
1647        if ( td->kind == TypeData::Function ) {
1648                if ( td->function.idList ) {                                    // KR function ?
1649                        buildKRFunction( td->function );                        // transform into C11 function
1650                } // if
1651
1652                return buildFunctionDecl(
1653                        td, name, scs, funcSpec, linkage,
1654                        asmName, std::move( attributes ) );
1655        } else if ( td->kind == TypeData::Aggregate ) {
1656                return buildAggregate( td, std::move( attributes ), linkage );
1657        } else if ( td->kind == TypeData::Symbolic ) {
1658                return buildSymbolic( td, std::move( attributes ), name, scs, linkage );
1659        } else {
1660                auto ret = new ast::ObjectDecl( td->location,
1661                        name,
1662                        typebuild( td ),
1663                        init,
1664                        scs,
1665                        linkage,
1666                        bitfieldWidth,
1667                        std::move( attributes )
1668                );
1669                ret->asmName = asmName;
1670                return ret;
1671        } // if
1672        return nullptr;
1673} // buildDecl
1674
1675
1676ast::FunctionType * buildFunctionType( const TypeData * td ) {
1677        assert( td->kind == TypeData::Function );
1678        ast::FunctionType * ft = new ast::FunctionType(
1679                ( !td->function.params || td->function.params->hasEllipsis )
1680                        ? ast::VariableArgs : ast::FixedArgs,
1681                buildQualifiers( td )
1682        );
1683        buildTypeList( td->function.params, ft->params );
1684        buildForall( td->forall, ft->forall );
1685        if ( td->base ) {
1686                switch ( td->base->kind ) {
1687                case TypeData::Tuple:
1688                        buildTypeList( td->base->tuple, ft->returns );
1689                        break;
1690                default:
1691                        ft->returns.push_back( typebuild( td->base ) );
1692                        break;
1693                } // switch
1694        } else {
1695                ft->returns.push_back(
1696                        new ast::BasicType( ast::BasicType::SignedInt ) );
1697        } // if
1698        return ft;
1699} // buildFunctionType
1700
1701
1702// Transform KR routine declarations into C99 routine declarations:
1703//
1704//    rtn( a, b, c ) int a, c; double b {}  =>  int rtn( int a, double c, int b ) {}
1705//
1706// The type information for each post-declaration is moved to the corresponding pre-parameter and the post-declaration
1707// is deleted. Note, the order of the parameter names may not be the same as the declaration names. Duplicate names and
1708// extra names are disallowed.
1709//
1710// Note, there is no KR routine-prototype syntax:
1711//
1712//    rtn( a, b, c ) int a, c; double b; // invalid KR prototype
1713//    rtn(); // valid KR prototype
1714
1715void buildKRFunction( const TypeData::Function_t & function ) {
1716        assert( ! function.params );
1717        // loop over declaration first as it is easier to spot errors
1718        for ( DeclarationNode * decl = function.oldDeclList; decl != nullptr; decl = decl->next ) {
1719                // scan ALL parameter names for each declaration name to check for duplicates
1720                for ( DeclarationNode * param = function.idList; param != nullptr; param = param->next ) {
1721                        if ( *decl->name == *param->name ) {
1722                                // type set => parameter name already transformed by a declaration names so there is a duplicate
1723                                // declaration name attempting a second transformation
1724                                if ( param->type ) SemanticError( param->location, "duplicate declaration name \"%s\".", param->name->c_str() );
1725                                // declaration type reset => declaration already transformed by a parameter name so there is a duplicate
1726                                // parameter name attempting a second transformation
1727                                if ( ! decl->type ) SemanticError( param->location, "duplicate parameter name \"%s\".", param->name->c_str() );
1728                                param->type = decl->type;                               // set copy declaration type to parameter type
1729                                decl->type = nullptr;                                   // reset declaration type
1730                                // Copy and reset attributes from declaration to parameter:
1731                                splice( param->attributes, decl->attributes );
1732                        } // if
1733                } // for
1734                // declaration type still set => type not moved to a matching parameter so there is a missing parameter name
1735                if ( decl->type ) SemanticError( decl->location, "missing name in parameter list %s", decl->name->c_str() );
1736        } // for
1737
1738        // Parameter names without a declaration default to type int:
1739        //
1740        //    rtb( a, b, c ) const char * b; {} => int rtn( int a, const char * b, int c ) {}
1741
1742        for ( DeclarationNode * param = function.idList; param != nullptr; param = param->next ) {
1743                if ( ! param->type ) {                                                  // generate type int for empty parameter type
1744                        param->type = new TypeData( TypeData::Basic );
1745                        param->type->basictype = TypeData::Int;
1746                } // if
1747        } // for
1748
1749        function.params = function.idList;                                      // newly modified idList becomes parameters
1750        function.idList = nullptr;                                                      // idList now empty
1751        delete function.oldDeclList;                                            // deletes entire list
1752        function.oldDeclList = nullptr;                                         // reset
1753} // buildKRFunction
1754
1755// Local Variables: //
1756// tab-width: 4 //
1757// mode: c++ //
1758// compile-command: "make install" //
1759// End: //
Note: See TracBrowser for help on using the repository browser.