source: src/SynTree/Type.h @ 37a3b8f

aaron-thesisarm-ehcleanup-dtorsctordeferred_resndemanglergc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newstringwith_gc
Last change on this file since 37a3b8f was 37a3b8f, checked in by Aaron Moss <a3moss@…>, 6 years ago

First code generation for generic types (incorrect)

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