source: src/SynTree/Type.h @ 6eb8948

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since 6eb8948 was 6eb8948, checked in by Rob Schluntz <rschlunt@…>, 6 years ago

make TupleAssignment? generate temporaries, add StmtExpr? for GCC statement expressions, expand tuple assignment expressions, collapse SolvedTupleExpr?, MassAssignExpr?, and MultipleAssignExpr? into TupleAssignExpr?

  • Property mode set to 100644
File size: 17.2 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// Type.h --
8//
9// Author           : Richard C. Bilson
10// Created On       : Mon May 18 07:44:20 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Wed Jul 13 11:46:54 2016
13// Update Count     : 23
14//
15
16#ifndef TYPE_H
17#define TYPE_H
18
19#include "SynTree.h"
20#include "Visitor.h"
21#include "Mutator.h"
22
23class Type {
24  public:
25        struct Qualifiers {
26                Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ), isAttribute( false ) {}
27                Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isAttribute ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isAttribute( isAttribute ) {}
28
29                Qualifiers &operator+=( const Qualifiers &other );
30                Qualifiers &operator-=( const Qualifiers &other );
31                Qualifiers operator+( const Type::Qualifiers &other );
32                bool operator==( const Qualifiers &other );
33                bool operator!=( const Qualifiers &other );
34                bool operator<=( const Qualifiers &other );
35                bool operator>=( const Qualifiers &other );
36                bool operator<( const Qualifiers &other );
37                bool operator>( const Qualifiers &other );
38                void print( std::ostream &os, int indent = 0 ) const;
39
40                bool isConst;
41                bool isVolatile;
42                bool isRestrict;
43                bool isLvalue;
44                bool isAtomic;
45                bool isAttribute;
46        };
47
48        Type( const Qualifiers &tq );
49        Type( const Type &other );
50        virtual ~Type();
51
52        Qualifiers &get_qualifiers() { return tq; }
53        bool get_isConst() { return tq.isConst; }
54        bool get_isVolatile() { return tq.isVolatile; }
55        bool get_isRestrict() { return tq.isRestrict; }
56        bool get_isLvalue() { return tq.isLvalue; }
57        bool get_isAtomic() { return tq.isAtomic; }
58        bool get_isAttribute() { return tq.isAttribute; }
59        void set_isConst( bool newValue ) { tq.isConst = newValue; }
60        void set_isVolatile( bool newValue ) { tq.isVolatile = newValue; }
61        void set_isRestrict( bool newValue ) { tq.isRestrict = newValue; }
62        void set_isLvalue( bool newValue ) { tq.isLvalue = newValue; }
63        void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }
64        void set_isAttribute( bool newValue ) { tq.isAttribute = newValue; }
65        std::list<TypeDecl*>& get_forall() { return forall; }
66
67        virtual Type *clone() const = 0;
68        virtual void accept( Visitor &v ) = 0;
69        virtual Type *acceptMutator( Mutator &m ) = 0;
70        virtual void print( std::ostream &os, int indent = 0 ) const;
71  private:
72        Qualifiers tq;
73        std::list<TypeDecl*> forall;
74};
75
76class VoidType : public Type {
77  public:
78        VoidType( const Type::Qualifiers &tq );
79
80        virtual VoidType *clone() const { return new VoidType( *this ); }
81        virtual void accept( Visitor &v ) { v.visit( this ); }
82        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
83        virtual void print( std::ostream &os, int indent = 0 ) const;
84};
85
86class BasicType : public Type {
87  public:
88        enum Kind {
89                Bool,
90                Char,
91                SignedChar,
92                UnsignedChar,
93                ShortSignedInt,
94                ShortUnsignedInt,
95                SignedInt,
96                UnsignedInt,
97                LongSignedInt,
98                LongUnsignedInt,
99                LongLongSignedInt,
100                LongLongUnsignedInt,
101                Float,
102                Double,
103                LongDouble,
104                FloatComplex,
105                DoubleComplex,
106                LongDoubleComplex,
107                FloatImaginary,
108                DoubleImaginary,
109                LongDoubleImaginary,
110                NUMBER_OF_BASIC_TYPES
111        };
112
113        static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
114
115        BasicType( const Type::Qualifiers &tq, Kind bt );
116
117        Kind get_kind() { return kind; }
118        void set_kind( Kind newValue ) { kind = newValue; }
119
120        virtual BasicType *clone() const { return new BasicType( *this ); }
121        virtual void accept( Visitor &v ) { v.visit( this ); }
122        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
123        virtual void print( std::ostream &os, int indent = 0 ) const;
124
125        bool isInteger() const;
126  private:
127        Kind kind;
128};
129
130class PointerType : public Type {
131  public:
132        PointerType( const Type::Qualifiers &tq, Type *base );
133        PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
134        PointerType( const PointerType& );
135        virtual ~PointerType();
136
137        Type *get_base() { return base; }
138        void set_base( Type *newValue ) { base = newValue; }
139        Expression *get_dimension() { return dimension; }
140        void set_dimension( Expression *newValue ) { dimension = newValue; }
141        bool get_isVarLen() { return isVarLen; }
142        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
143        bool get_isStatic() { return isStatic; }
144        void set_isStatic( bool newValue ) { isStatic = newValue; }
145
146        virtual PointerType *clone() const { return new PointerType( *this ); }
147        virtual void accept( Visitor &v ) { v.visit( this ); }
148        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
149        virtual void print( std::ostream &os, int indent = 0 ) const;
150  private:
151        Type *base;
152
153        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
154        Expression *dimension;
155        bool isVarLen;
156        bool isStatic;
157};
158
159class ArrayType : public Type {
160  public:
161        ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
162        ArrayType( const ArrayType& );
163        virtual ~ArrayType();
164
165        Type *get_base() { return base; }
166        void set_base( Type *newValue ) { base = newValue; }
167        Expression *get_dimension() { return dimension; }
168        void set_dimension( Expression *newValue ) { dimension = newValue; }
169        bool get_isVarLen() { return isVarLen; }
170        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
171        bool get_isStatic() { return isStatic; }
172        void set_isStatic( bool newValue ) { isStatic = newValue; }
173
174        virtual ArrayType *clone() const { return new ArrayType( *this ); }
175        virtual void accept( Visitor &v ) { v.visit( this ); }
176        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
177        virtual void print( std::ostream &os, int indent = 0 ) const;
178  private:
179        Type *base;
180        Expression *dimension;
181        bool isVarLen;
182        bool isStatic;
183};
184
185class FunctionType : public Type {
186  public:
187        FunctionType( const Type::Qualifiers &tq, bool isVarArgs );
188        FunctionType( const FunctionType& );
189        virtual ~FunctionType();
190
191        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
192        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
193        bool get_isVarArgs() { return isVarArgs; }
194        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
195
196        virtual FunctionType *clone() const { return new FunctionType( *this ); }
197        virtual void accept( Visitor &v ) { v.visit( this ); }
198        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
199        virtual void print( std::ostream &os, int indent = 0 ) const;
200  private:
201        std::list<DeclarationWithType*> returnVals;
202        std::list<DeclarationWithType*> parameters;
203
204        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
205        // This could be because of
206        // - an ellipsis in a prototype declaration
207        // - an unprototyped declaration
208        bool isVarArgs;
209};
210
211class ReferenceToType : public Type {
212  public:
213        ReferenceToType( const Type::Qualifiers &tq, const std::string &name );
214        ReferenceToType( const ReferenceToType &other );
215        virtual ~ReferenceToType();
216
217        const std::string &get_name() const { return name; }
218        void set_name( std::string newValue ) { name = newValue; }
219        std::list< Expression* >& get_parameters() { return parameters; }
220
221        virtual ReferenceToType *clone() const = 0;
222        virtual void accept( Visitor &v ) = 0;
223        virtual Type *acceptMutator( Mutator &m ) = 0;
224        virtual void print( std::ostream &os, int indent = 0 ) const;
225  protected:
226        virtual std::string typeString() const = 0;
227        std::list< Expression* > parameters;
228        std::string name;
229  private:
230};
231
232class StructInstType : public ReferenceToType {
233        typedef ReferenceToType Parent;
234  public:
235        StructInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseStruct( 0 ) {}
236        StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
237
238        StructDecl *get_baseStruct() const { return baseStruct; }
239        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
240
241        /// Accesses generic parameters of base struct (NULL if none such)
242        std::list<TypeDecl*> * get_baseParameters();
243
244        /// Looks up the members of this struct named "name" and places them into "foundDecls".
245        /// Clones declarations into "foundDecls", caller responsible for freeing
246        void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
247
248        virtual StructInstType *clone() const { return new StructInstType( *this ); }
249        virtual void accept( Visitor &v ) { v.visit( this ); }
250        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
251
252        virtual void print( std::ostream &os, int indent = 0 ) const;
253  private:
254        virtual std::string typeString() const;
255
256        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
257        // where the structure used in this type is actually defined
258        StructDecl *baseStruct;
259};
260
261class UnionInstType : public ReferenceToType {
262        typedef ReferenceToType Parent;
263  public:
264        UnionInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseUnion( 0 ) {}
265        UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}
266
267        UnionDecl *get_baseUnion() const { return baseUnion; }
268        void set_baseUnion( UnionDecl *newValue ) { baseUnion = newValue; }
269
270        /// Accesses generic parameters of base union (NULL if none such)
271        std::list<TypeDecl*> * get_baseParameters();
272
273        /// looks up the members of this union named "name" and places them into "foundDecls"
274        /// Clones declarations into "foundDecls", caller responsible for freeing
275        void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
276
277        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
278        virtual void accept( Visitor &v ) { v.visit( this ); }
279        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
280
281        virtual void print( std::ostream &os, int indent = 0 ) const;
282  private:
283        virtual std::string typeString() const;
284
285        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
286        // where the union used in this type is actually defined
287        UnionDecl *baseUnion;
288};
289
290class EnumInstType : public ReferenceToType {
291        typedef ReferenceToType Parent;
292  public:
293        EnumInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
294        EnumInstType( const EnumInstType &other ) : Parent( other ) {}
295
296        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
297        virtual void accept( Visitor &v ) { v.visit( this ); }
298        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
299  private:
300        virtual std::string typeString() const;
301};
302
303class TraitInstType : public ReferenceToType {
304        typedef ReferenceToType Parent;
305  public:
306        TraitInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
307        TraitInstType( const TraitInstType &other );
308        ~TraitInstType();
309
310        std::list< Declaration* >& get_members() { return members; }
311
312        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
313        virtual void accept( Visitor &v ) { v.visit( this ); }
314        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
315  private:
316        virtual std::string typeString() const;
317
318        // this member is filled in by the validate pass, which instantiates the members of the correponding
319        // aggregate with the actual type parameters specified for this use of the context
320        std::list< Declaration* > members;
321};
322
323class TypeInstType : public ReferenceToType {
324        typedef ReferenceToType Parent;
325  public:
326        TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType );
327        TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype );
328        TypeInstType( const TypeInstType &other ) : Parent( other ), baseType( other.baseType ), isFtype( other.isFtype ) {}
329        ~TypeInstType();
330
331        TypeDecl *get_baseType() const { return baseType; }
332        void set_baseType( TypeDecl *newValue );
333        bool get_isFtype() const { return isFtype; }
334        void set_isFtype( bool newValue ) { isFtype = newValue; }
335
336        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
337        virtual void accept( Visitor &v ) { v.visit( this ); }
338        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
339        virtual void print( std::ostream &os, int indent = 0 ) const;
340  private:
341        virtual std::string typeString() const;
342        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
343        // where the type used here is actually defined
344        TypeDecl *baseType;
345        bool isFtype;
346};
347
348class TupleType : public Type {
349  public:
350        TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types = std::list< Type * >() );
351        TupleType( const TupleType& );
352        virtual ~TupleType();
353
354        typedef std::list<Type*> value_type;
355        typedef value_type::iterator iterator;
356
357        std::list<Type*>& get_types() { return types; }
358
359        iterator begin() { return types.begin(); }
360        iterator end() { return types.end(); }
361
362        virtual TupleType *clone() const { return new TupleType( *this ); }
363        virtual void accept( Visitor &v ) { v.visit( this ); }
364        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
365        virtual void print( std::ostream &os, int indent = 0 ) const;
366  private:
367        std::list<Type*> types;
368};
369
370class TypeofType : public Type {
371  public:
372        TypeofType( const Type::Qualifiers &tq, Expression *expr );
373        TypeofType( const TypeofType& );
374        virtual ~TypeofType();
375
376        Expression *get_expr() const { return expr; }
377        void set_expr( Expression *newValue ) { expr = newValue; }
378
379        virtual TypeofType *clone() const { return new TypeofType( *this ); }
380        virtual void accept( Visitor &v ) { v.visit( this ); }
381        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
382        virtual void print( std::ostream &os, int indent = 0 ) const;
383  private:
384        Expression *expr;
385};
386
387class AttrType : public Type {
388  public:
389        AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr );
390        AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type );
391        AttrType( const AttrType& );
392        virtual ~AttrType();
393
394        const std::string &get_name() const { return name; }
395        void set_name( const std::string &newValue ) { name = newValue; }
396        Expression *get_expr() const { return expr; }
397        void set_expr( Expression *newValue ) { expr = newValue; }
398        Type *get_type() const { return type; }
399        void set_type( Type *newValue ) { type = newValue; }
400        bool get_isType() const { return isType; }
401        void set_isType( bool newValue ) { isType = newValue; }
402
403        virtual AttrType *clone() const { return new AttrType( *this ); }
404        virtual void accept( Visitor &v ) { v.visit( this ); }
405        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
406        virtual void print( std::ostream &os, int indent = 0 ) const;
407  private:
408        std::string name;
409        Expression *expr;
410        Type *type;
411        bool isType;
412};
413
414/// Represents the GCC built-in varargs type
415class VarArgsType : public Type {
416  public:
417        VarArgsType();
418        VarArgsType( Type::Qualifiers tq );
419
420        virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
421        virtual void accept( Visitor &v ) { v.visit( this ); }
422        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
423        virtual void print( std::ostream &os, int indent = 0 ) const;
424};
425
426inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
427        isConst |= other.isConst;
428        isVolatile |= other.isVolatile;
429        isRestrict |= other.isRestrict;
430        isLvalue |= other.isLvalue;
431        isAtomic |= other.isAtomic;
432        return *this;
433}
434
435inline Type::Qualifiers &Type::Qualifiers::operator-=( const Type::Qualifiers &other ) {
436        if ( other.isConst ) isConst = 0;
437        if ( other.isVolatile ) isVolatile = 0;
438        if ( other.isRestrict ) isRestrict = 0;
439        if ( other.isAtomic ) isAtomic = 0;
440        return *this;
441}
442
443inline Type::Qualifiers Type::Qualifiers::operator+( const Type::Qualifiers &other ) {
444        Qualifiers q = other;
445        q += *this;
446        return q;
447}
448
449inline bool Type::Qualifiers::operator==( const Qualifiers &other ) {
450        return isConst == other.isConst
451                && isVolatile == other.isVolatile
452//              && isRestrict == other.isRestrict
453//              && isLvalue == other.isLvalue
454                && isAtomic == other.isAtomic;
455}
456
457inline bool Type::Qualifiers::operator!=( const Qualifiers &other ) {
458        return isConst != other.isConst
459                || isVolatile != other.isVolatile
460//              || isRestrict != other.isRestrict
461//              || isLvalue != other.isLvalue
462                || isAtomic != other.isAtomic;
463}
464
465inline bool Type::Qualifiers::operator<=( const Type::Qualifiers &other ) {
466        return isConst <= other.isConst
467                && isVolatile <= other.isVolatile
468//              && isRestrict <= other.isRestrict
469//              && isLvalue >= other.isLvalue
470                && isAtomic == other.isAtomic;
471}
472
473inline bool Type::Qualifiers::operator>=( const Type::Qualifiers &other ) {
474        return isConst >= other.isConst
475                && isVolatile >= other.isVolatile
476//              && isRestrict >= other.isRestrict
477//              && isLvalue <= other.isLvalue
478                && isAtomic == other.isAtomic;
479}
480
481inline bool Type::Qualifiers::operator<( const Type::Qualifiers &other ) {
482        return operator!=( other ) && operator<=( other );
483}
484
485inline bool Type::Qualifiers::operator>( const Type::Qualifiers &other ) {
486        return operator!=( other ) && operator>=( other );
487}
488
489std::ostream & operator<<( std::ostream & out, const Type * type );
490
491#endif // TYPE_H
492
493// Local Variables: //
494// tab-width: 4 //
495// mode: c++ //
496// compile-command: "make install" //
497// End: //
Note: See TracBrowser for help on using the repository browser.