source: src/SynTree/Type.h @ be9036d

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 be9036d was be9036d, checked in by Rob Schluntz <rschlunt@…>, 7 years ago

Reorganize TraitInstType? and TraitDecl?, add sized trait definition to prelude

Previously, TraitInstType? cloned all of the members of TraitDecl?. This commit changes
TraitInstType? to instead contain a pointer to the base TraitDecl?, analogous to StructInstType?
and StructDecl?, etc. In particular, this makes the code simpler and makes it easier to
fully expand the members of a trait declaration.

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