source: src/SynTree/Type.h @ ac10576

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since ac10576 was ac10576, checked in by Andrew Beach <ajbeach@…>, 7 years ago

Replaced emptyQualifiers with noQualifiers for consistancy with noLabels and noAttributes.

  • Property mode set to 100644
File size: 23.3 KB
RevLine 
[0dd3a2f]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//
[ae63a18]7// Type.h --
[0dd3a2f]8//
9// Author           : Richard C. Bilson
10// Created On       : Mon May 18 07:44:20 2015
[ac10576]11// Last Modified By : Andrew Beach
12// Last Modified On : Tus Jul 18 10:06:00 2017
13// Update Count     : 150
[0dd3a2f]14//
15
[51b7345]16#ifndef TYPE_H
17#define TYPE_H
18
[138e29e]19#include "BaseSyntaxNode.h"
20#include "Mutator.h"
[51b7345]21#include "SynTree.h"
22#include "Visitor.h"
[6f95000]23#include <strings.h>                                                                    // ffs
[51b7345]24
[138e29e]25class Type : public BaseSyntaxNode {
[c8ffe20b]26  public:
[6f95000]27        // Simulate inheritance because union does not allow it.
[615a096]28        // Bug in g++-4.9 prevents static field in union
29        //static const char * Names[];
[6f95000]30        #define BFCommon( BFType, N ) \
[d6d747d]31                bool operator[]( unsigned int i ) const { return val & (1 << i); } \
32                bool any() const { return val != 0; } \
[6f95000]33                void reset() { val = 0; } \
34                int ffs() { return ::ffs( val ) - 1; } \
35                BFType operator&=( BFType other ) { \
36                        val &= other.val; return *this; \
37                } \
38                BFType operator&( BFType other ) const { \
39                        BFType q = other; \
40                        q &= *this; \
41                        return q; \
42                } \
43                BFType operator|=( BFType other ) { \
44                        val |= other.val; return *this; \
45                } \
46                BFType operator|( BFType other ) const { \
47                        BFType q = other; \
48                        q |= *this; \
49                        return q; \
50                } \
51                BFType operator-=( BFType other ) { \
52                        val &= ~other.val; return *this; \
53                } \
[d6d747d]54                void print( std::ostream & os ) const { \
55                        if ( (*this).any() ) { \
56                                for ( unsigned int i = 0; i < N; i += 1 ) { \
57                                        if ( (*this)[i] ) { \
[615a096]58                                                os << BFType##Names[i] << ' '; \
[d6d747d]59                                        } \
60                                } \
61                        } \
62                }
63
[68fe077a]64        // enum must remain in the same order as the corresponding bit fields.
65
[ddfd945]66        enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
[615a096]67        static const char * FuncSpecifiersNames[];
[ddfd945]68        union FuncSpecifiers {
69                unsigned int val;
70                struct {
71                        bool is_inline : 1;
72                        bool is_noreturn : 1;
73                        bool is_fortran : 1;
74                };
75                FuncSpecifiers() : val( 0 ) {}
76                FuncSpecifiers( unsigned int val ) : val( val ) {}
[615a096]77                // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
[6f95000]78                BFCommon( FuncSpecifiers, NumFuncSpecifier )
[ddfd945]79        }; // FuncSpecifiers
80
[68fe077a]81        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
[615a096]82        static const char * StorageClassesNames[];
[68fe077a]83        union StorageClasses {
84                unsigned int val;
85                struct {
86                        bool is_extern : 1;
87                        bool is_static : 1;
88                        bool is_auto : 1;
89                        bool is_register : 1;
90                        bool is_threadlocal : 1;
91                };
92
93                StorageClasses() : val( 0 ) {}
94                StorageClasses( unsigned int val ) : val( val ) {}
[615a096]95                // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
[6f95000]96                BFCommon( StorageClasses, NumStorageClass )
[68fe077a]97        }; // StorageClasses
98
[bf4ac09]99        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
[615a096]100        static const char * QualifiersNames[];
[bf4ac09]101        union Qualifiers {
102                enum { Mask = ~(Restrict | Lvalue) };
103                unsigned int val;
104                struct {
[615a096]105                        bool is_const : 1;
106                        bool is_restrict : 1;
107                        bool is_volatile : 1;
108                        bool is_lvalue : 1;
109                        bool is_mutex : 1;
110                        bool is_atomic : 1;
[bf4ac09]111                };
[6e8bd43]112
[bf4ac09]113                Qualifiers() : val( 0 ) {}
114                Qualifiers( unsigned int val ) : val( val ) {}
[615a096]115                // Complex comparisons provide implicit qualifier downcasting, e.g., T downcast to const T.
116                bool operator==( Qualifiers other ) const { return (val & Mask) == (other.val & Mask); }
117                bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
[d6d747d]118                bool operator<=( Qualifiers other ) const {
[e04b636]119                        return is_const    <= other.is_const        //Any non-const converts to const without cost
120                                        && is_volatile <= other.is_volatile     //Any non-volatile converts to volatile without cost
121                                        && is_mutex    >= other.is_mutex        //Any mutex converts to non-mutex without cost
122                                        && is_atomic   == other.is_atomic;      //No conversion from atomic to non atomic is free
[bf4ac09]123                }
[6f95000]124                bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
125                bool operator>=( Qualifiers other ) const { return ! (*this < other); }
126                bool operator>( Qualifiers other ) const { return *this != other && *this >= other; }
127                BFCommon( Qualifiers, NumTypeQualifier )
[bf4ac09]128        }; // Qualifiers
[0dd3a2f]129
[f2e40a9f]130        Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
131        Type( const Type & other );
[0dd3a2f]132        virtual ~Type();
133
[f2e40a9f]134        Qualifiers & get_qualifiers() { return tq; }
[615a096]135        bool get_const() { return tq.is_const; }
136        bool get_volatile() { return tq.is_volatile; }
137        bool get_restrict() { return tq.is_restrict; }
138        bool get_lvalue() { return tq.is_lvalue; }
139        bool get_mutex() { return tq.is_mutex; }
140        bool get_atomic() { return tq.is_atomic; }
141        void set_const( bool newValue ) { tq.is_const = newValue; }
142        void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
143        void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
144        void set_lvalue( bool newValue ) { tq.is_lvalue = newValue; }
145        void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
146        void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
[8c49c0e]147
148        typedef std::list<TypeDecl *> ForallList;
149        ForallList& get_forall() { return forall; }
[0dd3a2f]150
[c0aa336]151        std::list< Attribute * >& get_attributes() { return attributes; }
152        const std::list< Attribute * >& get_attributes() const { return attributes; }
153
[906e24d]154        /// How many elemental types are represented by this type
155        virtual unsigned size() const { return 1; };
156        virtual bool isVoid() const { return size() == 0; }
[7933351]157        virtual Type * getComponent( unsigned i ) { assertf( size() == 1 && i == 0, "Type::getComponent was called with size %d and index %d\n", size(), i ); return this; }
[906e24d]158
[142cf5d]159        /// return type without outer pointers and arrays
[6f95000]160        Type *stripDeclarator();
161
[4a9ccc3]162        virtual bool isComplete() const { return true; }
163
[0dd3a2f]164        virtual Type *clone() const = 0;
[f2e40a9f]165        virtual void accept( Visitor & v ) = 0;
166        virtual Type *acceptMutator( Mutator & m ) = 0;
167        virtual void print( std::ostream & os, int indent = 0 ) const;
[c8ffe20b]168  private:
[0dd3a2f]169        Qualifiers tq;
[8c49c0e]170        ForallList forall;
[c0aa336]171        std::list< Attribute * > attributes;
[51b7345]172};
173
[ac10576]174extern Type::Qualifiers noQualifiers;                           // no qualifiers on constants
[4cb935e]175
[c8ffe20b]176class VoidType : public Type {
177  public:
[f2e40a9f]178        VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
[51b7345]179
[906e24d]180        virtual unsigned size() const { return 0; };
[4a9ccc3]181        virtual bool isComplete() const { return false; }
[906e24d]182
[0dd3a2f]183        virtual VoidType *clone() const { return new VoidType( *this ); }
[f2e40a9f]184        virtual void accept( Visitor & v ) { v.visit( this ); }
185        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
186        virtual void print( std::ostream & os, int indent = 0 ) const;
[51b7345]187};
188
[c8ffe20b]189class BasicType : public Type {
190  public:
[ae63a18]191        enum Kind {
[0dd3a2f]192                Bool,
193                Char,
194                SignedChar,
195                UnsignedChar,
196                ShortSignedInt,
197                ShortUnsignedInt,
198                SignedInt,
199                UnsignedInt,
200                LongSignedInt,
201                LongUnsignedInt,
202                LongLongSignedInt,
203                LongLongUnsignedInt,
204                Float,
205                Double,
206                LongDouble,
207                FloatComplex,
208                DoubleComplex,
209                LongDoubleComplex,
210                FloatImaginary,
211                DoubleImaginary,
212                LongDoubleImaginary,
213                NUMBER_OF_BASIC_TYPES
[ae63a18]214        };
[0dd3a2f]215
[59db689]216        static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
[0dd3a2f]217
[f2e40a9f]218        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
[0dd3a2f]219
220        Kind get_kind() { return kind; }
221        void set_kind( Kind newValue ) { kind = newValue; }
222
223        virtual BasicType *clone() const { return new BasicType( *this ); }
[f2e40a9f]224        virtual void accept( Visitor & v ) { v.visit( this ); }
225        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
226        virtual void print( std::ostream & os, int indent = 0 ) const;
[0dd3a2f]227
228        bool isInteger() const;
[c8ffe20b]229  private:
[0dd3a2f]230        Kind kind;
[51b7345]231};
232
[c8ffe20b]233class PointerType : public Type {
234  public:
[f2e40a9f]235        PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
236        PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
[0dd3a2f]237        PointerType( const PointerType& );
238        virtual ~PointerType();
239
240        Type *get_base() { return base; }
241        void set_base( Type *newValue ) { base = newValue; }
242        Expression *get_dimension() { return dimension; }
243        void set_dimension( Expression *newValue ) { dimension = newValue; }
244        bool get_isVarLen() { return isVarLen; }
245        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
246        bool get_isStatic() { return isStatic; }
247        void set_isStatic( bool newValue ) { isStatic = newValue; }
248
[ed8a0d2]249        bool is_array() const { return isStatic || isVarLen || dimension; }
250
[0dd3a2f]251        virtual PointerType *clone() const { return new PointerType( *this ); }
[f2e40a9f]252        virtual void accept( Visitor & v ) { v.visit( this ); }
253        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
254        virtual void print( std::ostream & os, int indent = 0 ) const;
[c8ffe20b]255  private:
[0dd3a2f]256        Type *base;
[ae63a18]257
[0dd3a2f]258        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
259        Expression *dimension;
260        bool isVarLen;
261        bool isStatic;
[51b7345]262};
263
[c8ffe20b]264class ArrayType : public Type {
265  public:
[f2e40a9f]266        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
[0dd3a2f]267        ArrayType( const ArrayType& );
268        virtual ~ArrayType();
269
270        Type *get_base() { return base; }
271        void set_base( Type *newValue ) { base = newValue; }
272        Expression *get_dimension() { return dimension; }
273        void set_dimension( Expression *newValue ) { dimension = newValue; }
274        bool get_isVarLen() { return isVarLen; }
275        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
276        bool get_isStatic() { return isStatic; }
277        void set_isStatic( bool newValue ) { isStatic = newValue; }
278
[4a9ccc3]279        virtual bool isComplete() const { return ! isVarLen; }
280
[0dd3a2f]281        virtual ArrayType *clone() const { return new ArrayType( *this ); }
[f2e40a9f]282        virtual void accept( Visitor & v ) { v.visit( this ); }
283        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
284        virtual void print( std::ostream & os, int indent = 0 ) const;
[c8ffe20b]285  private:
[0dd3a2f]286        Type *base;
287        Expression *dimension;
288        bool isVarLen;
289        bool isStatic;
[51b7345]290};
291
[c8ffe20b]292class FunctionType : public Type {
293  public:
[f2e40a9f]294        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
[0dd3a2f]295        FunctionType( const FunctionType& );
296        virtual ~FunctionType();
297
[cf16f94]298        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
299        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
[8bf784a]300        bool get_isVarArgs() const { return isVarArgs; }
[0dd3a2f]301        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
[8bf784a]302        bool isTtype() const;
303
[0dd3a2f]304        virtual FunctionType *clone() const { return new FunctionType( *this ); }
[f2e40a9f]305        virtual void accept( Visitor & v ) { v.visit( this ); }
306        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
307        virtual void print( std::ostream & os, int indent = 0 ) const;
[c8ffe20b]308  private:
[0dd3a2f]309        std::list<DeclarationWithType*> returnVals;
310        std::list<DeclarationWithType*> parameters;
311
[839ccbb]312        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
313        // This could be because of
[0dd3a2f]314        // - an ellipsis in a prototype declaration
315        // - an unprototyped declaration
316        bool isVarArgs;
[51b7345]317};
318
[c8ffe20b]319class ReferenceToType : public Type {
320  public:
[f2e40a9f]321        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
322        ReferenceToType( const ReferenceToType & other );
[0dd3a2f]323        virtual ~ReferenceToType();
324
[f2e40a9f]325        const std::string & get_name() const { return name; }
[0dd3a2f]326        void set_name( std::string newValue ) { name = newValue; }
327        std::list< Expression* >& get_parameters() { return parameters; }
[43c89a7]328        bool get_hoistType() const { return hoistType; }
329        void set_hoistType( bool newValue ) { hoistType = newValue; }
[ae63a18]330
[0dd3a2f]331        virtual ReferenceToType *clone() const = 0;
[f2e40a9f]332        virtual void accept( Visitor & v ) = 0;
333        virtual Type *acceptMutator( Mutator & m ) = 0;
334        virtual void print( std::ostream & os, int indent = 0 ) const;
[6013bd7]335
[b3c36f4]336        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
[c8ffe20b]337  protected:
[0dd3a2f]338        virtual std::string typeString() const = 0;
339        std::list< Expression* > parameters;
340        std::string name;
[5d125e4]341  private:
[43c89a7]342        bool hoistType;
[51b7345]343};
344
[c8ffe20b]345class StructInstType : public ReferenceToType {
[0dd3a2f]346        typedef ReferenceToType Parent;
[c8ffe20b]347  public:
[f2e40a9f]348        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
349        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
350        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
[51b7345]351
[0dd3a2f]352        StructDecl *get_baseStruct() const { return baseStruct; }
353        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
[37a3b8f9]354
[ed94eac]355        /// Accesses generic parameters of base struct (NULL if none such)
[839ccbb]356        std::list<TypeDecl*> * get_baseParameters();
[ae63a18]357
[4a9ccc3]358        virtual bool isComplete() const;
359
[37a3b8f9]360        /// Looks up the members of this struct named "name" and places them into "foundDecls".
361        /// Clones declarations into "foundDecls", caller responsible for freeing
[f2e40a9f]362        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
[51b7345]363
[0dd3a2f]364        virtual StructInstType *clone() const { return new StructInstType( *this ); }
[f2e40a9f]365        virtual void accept( Visitor & v ) { v.visit( this ); }
366        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
[5d125e4]367
[f2e40a9f]368        virtual void print( std::ostream & os, int indent = 0 ) const;
[c8ffe20b]369  private:
[0dd3a2f]370        virtual std::string typeString() const;
[ae63a18]371
[0dd3a2f]372        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
373        // where the structure used in this type is actually defined
374        StructDecl *baseStruct;
[51b7345]375};
376
[c8ffe20b]377class UnionInstType : public ReferenceToType {
[0dd3a2f]378        typedef ReferenceToType Parent;
[c8ffe20b]379  public:
[f2e40a9f]380        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
381        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
382        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
[0dd3a2f]383
384        UnionDecl *get_baseUnion() const { return baseUnion; }
[c0aa336]385        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
[37a3b8f9]386
[ed94eac]387        /// Accesses generic parameters of base union (NULL if none such)
[c0aa336]388        std::list< TypeDecl * > * get_baseParameters();
[ae63a18]389
[4a9ccc3]390        virtual bool isComplete() const;
391
[37a3b8f9]392        /// looks up the members of this union named "name" and places them into "foundDecls"
393        /// Clones declarations into "foundDecls", caller responsible for freeing
[f2e40a9f]394        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
[0dd3a2f]395
396        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
[f2e40a9f]397        virtual void accept( Visitor & v ) { v.visit( this ); }
398        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
[5d125e4]399
[f2e40a9f]400        virtual void print( std::ostream & os, int indent = 0 ) const;
[c8ffe20b]401  private:
[0dd3a2f]402        virtual std::string typeString() const;
[ae63a18]403
[0dd3a2f]404        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
405        // where the union used in this type is actually defined
406        UnionDecl *baseUnion;
[51b7345]407};
408
[c8ffe20b]409class EnumInstType : public ReferenceToType {
[0dd3a2f]410        typedef ReferenceToType Parent;
[c8ffe20b]411  public:
[f2e40a9f]412        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
413        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
414        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
[51b7345]415
[c0aa336]416        EnumDecl *get_baseEnum() const { return baseEnum; }
417        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
418
419        virtual bool isComplete() const;
[4a9ccc3]420
[0dd3a2f]421        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
[f2e40a9f]422        virtual void accept( Visitor & v ) { v.visit( this ); }
423        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
[c8ffe20b]424  private:
[0dd3a2f]425        virtual std::string typeString() const;
[c0aa336]426
427        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
428        // where the union used in this type is actually defined
429        EnumDecl *baseEnum = nullptr;
[51b7345]430};
431
[4040425]432class TraitInstType : public ReferenceToType {
[0dd3a2f]433        typedef ReferenceToType Parent;
[c8ffe20b]434  public:
[f2e40a9f]435        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
436        TraitInstType( const TraitInstType & other );
[4040425]437        ~TraitInstType();
[51b7345]438
[0dd3a2f]439        std::list< Declaration* >& get_members() { return members; }
[51b7345]440
[4a9ccc3]441        virtual bool isComplete() const;
442
[4040425]443        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
[f2e40a9f]444        virtual void accept( Visitor & v ) { v.visit( this ); }
445        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
[c8ffe20b]446  private:
[0dd3a2f]447        virtual std::string typeString() const;
[ae63a18]448
[0dd3a2f]449        // this member is filled in by the validate pass, which instantiates the members of the correponding
450        // aggregate with the actual type parameters specified for this use of the context
451        std::list< Declaration* > members;
[51b7345]452};
453
[c8ffe20b]454class TypeInstType : public ReferenceToType {
[0dd3a2f]455        typedef ReferenceToType Parent;
[c8ffe20b]456  public:
[f2e40a9f]457        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
458        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
459        TypeInstType( const TypeInstType & other );
[1e8b02f5]460        ~TypeInstType();
[0dd3a2f]461
462        TypeDecl *get_baseType() const { return baseType; }
463        void set_baseType( TypeDecl *newValue );
464        bool get_isFtype() const { return isFtype; }
465        void set_isFtype( bool newValue ) { isFtype = newValue; }
[ae63a18]466
[4a9ccc3]467        virtual bool isComplete() const;
468
[0dd3a2f]469        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
[f2e40a9f]470        virtual void accept( Visitor & v ) { v.visit( this ); }
471        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
472        virtual void print( std::ostream & os, int indent = 0 ) const;
[c8ffe20b]473  private:
[0dd3a2f]474        virtual std::string typeString() const;
475        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
476        // where the type used here is actually defined
477        TypeDecl *baseType;
478        bool isFtype;
[51b7345]479};
480
[c8ffe20b]481class TupleType : public Type {
482  public:
[62423350]483        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
[0dd3a2f]484        TupleType( const TupleType& );
485        virtual ~TupleType();
[51b7345]486
[0362d42]487        typedef std::list<Type*> value_type;
488        typedef value_type::iterator iterator;
489
[62423350]490        std::list<Type *> & get_types() { return types; }
[906e24d]491        virtual unsigned size() const { return types.size(); };
[51b7345]492
[62423350]493        // For now, this is entirely synthetic -- tuple types always have unnamed members.
494        // Eventually, we may allow named tuples, in which case members should subsume types
495        std::list<Declaration *> & get_members() { return members; }
496
[0362d42]497        iterator begin() { return types.begin(); }
498        iterator end() { return types.end(); }
499
[7933351]500        virtual Type * getComponent( unsigned i ) {
501                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
502                return *(begin()+i);
503        }
504
[4a9ccc3]505        // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
506
[0dd3a2f]507        virtual TupleType *clone() const { return new TupleType( *this ); }
[f2e40a9f]508        virtual void accept( Visitor & v ) { v.visit( this ); }
509        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
510        virtual void print( std::ostream & os, int indent = 0 ) const;
[c8ffe20b]511  private:
[62423350]512        std::list<Type *> types;
513        std::list<Declaration *> members;
[51b7345]514};
515
[c8ffe20b]516class TypeofType : public Type {
517  public:
[f2e40a9f]518        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
[0dd3a2f]519        TypeofType( const TypeofType& );
520        virtual ~TypeofType();
[51b7345]521
[0dd3a2f]522        Expression *get_expr() const { return expr; }
523        void set_expr( Expression *newValue ) { expr = newValue; }
[51b7345]524
[4a9ccc3]525        virtual bool isComplete() const { assert( false ); return false; }
526
[0dd3a2f]527        virtual TypeofType *clone() const { return new TypeofType( *this ); }
[f2e40a9f]528        virtual void accept( Visitor & v ) { v.visit( this ); }
529        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
530        virtual void print( std::ostream & os, int indent = 0 ) const;
[c8ffe20b]531  private:
[0dd3a2f]532        Expression *expr;
[51b7345]533};
534
[c8ffe20b]535class AttrType : public Type {
536  public:
[f2e40a9f]537        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
538        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
[0dd3a2f]539        AttrType( const AttrType& );
540        virtual ~AttrType();
541
[f2e40a9f]542        const std::string & get_name() const { return name; }
543        void set_name( const std::string & newValue ) { name = newValue; }
[0dd3a2f]544        Expression *get_expr() const { return expr; }
545        void set_expr( Expression *newValue ) { expr = newValue; }
546        Type *get_type() const { return type; }
547        void set_type( Type *newValue ) { type = newValue; }
548        bool get_isType() const { return isType; }
549        void set_isType( bool newValue ) { isType = newValue; }
550
[4a9ccc3]551        virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
552
[0dd3a2f]553        virtual AttrType *clone() const { return new AttrType( *this ); }
[f2e40a9f]554        virtual void accept( Visitor & v ) { v.visit( this ); }
555        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
556        virtual void print( std::ostream & os, int indent = 0 ) const;
[c8ffe20b]557  private:
[0dd3a2f]558        std::string name;
559        Expression *expr;
560        Type *type;
561        bool isType;
[51b7345]562};
563
[44b7088]564/// Represents the GCC built-in varargs type
565class VarArgsType : public Type {
[90c3b1c]566  public:
[44b7088]567        VarArgsType();
[c0aa336]568        VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
[44b7088]569
[4a9ccc3]570        virtual bool isComplete() const{ return true; } // xxx - is this right?
571
[44b7088]572        virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
[f2e40a9f]573        virtual void accept( Visitor & v ) { v.visit( this ); }
574        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
575        virtual void print( std::ostream & os, int indent = 0 ) const;
[44b7088]576};
577
[89e6ffc]578/// Represents a zero constant
579class ZeroType : public Type {
580  public:
581        ZeroType();
[c0aa336]582        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
[89e6ffc]583
584        virtual ZeroType *clone() const { return new ZeroType( *this ); }
[f2e40a9f]585        virtual void accept( Visitor & v ) { v.visit( this ); }
586        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
587        virtual void print( std::ostream & os, int indent = 0 ) const;
[89e6ffc]588};
589
590/// Represents a one constant
591class OneType : public Type {
592  public:
593        OneType();
[c0aa336]594        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
[89e6ffc]595
596        virtual OneType *clone() const { return new OneType( *this ); }
[f2e40a9f]597        virtual void accept( Visitor & v ) { v.visit( this ); }
598        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
599        virtual void print( std::ostream & os, int indent = 0 ) const;
[89e6ffc]600};
601
[3906301]602std::ostream & operator<<( std::ostream & out, const Type * type );
[baf7fee]603
[c8ffe20b]604#endif // TYPE_H
[0dd3a2f]605
606// Local Variables: //
607// tab-width: 4 //
608// mode: c++ //
609// compile-command: "make install" //
610// End: //
Note: See TracBrowser for help on using the repository browser.