source: translator/Parser/TypeData.cc @ 0b8cd72

aaron-thesisarm-ehcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decaygc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationresolv-newstringwith_gc
Last change on this file since 0b8cd72 was 0b8cd72, checked in by Peter A. Buhr <pabuhr@…>, 8 years ago

fix uninitialized value, fix memory reads after frees

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