source: src/SynTree/Type.h @ aca65621

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

Merge branch 'master' into references
  • Property mode set to 100644
File size: 24.0 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 Mar 23 16:16:36 2017
13// Update Count     : 149
14//
15
16#ifndef TYPE_H
17#define TYPE_H
18
19#include "BaseSyntaxNode.h"
20#include "Mutator.h"
21#include "SynTree.h"
22#include "Visitor.h"
23#include <strings.h>                                                                    // ffs
24
25class Type : public BaseSyntaxNode {
26  public:
27        // Simulate inheritance because union does not allow it.
28        // Bug in g++-4.9 prevents static field in union
29        //static const char * Names[];
30        #define BFCommon( BFType, N ) \
31                bool operator[]( unsigned int i ) const { return val & (1 << i); } \
32                bool any() const { return val != 0; } \
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                } \
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] ) { \
58                                                os << BFType##Names[i] << ' '; \
59                                        } \
60                                } \
61                        } \
62                }
63
64        // enum must remain in the same order as the corresponding bit fields.
65
66        enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
67        static const char * FuncSpecifiersNames[];
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 ) {}
77                // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
78                BFCommon( FuncSpecifiers, NumFuncSpecifier )
79        }; // FuncSpecifiers
80
81        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
82        static const char * StorageClassesNames[];
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 ) {}
95                // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
96                BFCommon( StorageClasses, NumStorageClass )
97        }; // StorageClasses
98
99        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
100        static const char * QualifiersNames[];
101        union Qualifiers {
102                enum { Mask = ~(Restrict | Lvalue) };
103                unsigned int val;
104                struct {
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;
111                };
112
113                Qualifiers() : val( 0 ) {}
114                Qualifiers( unsigned int val ) : val( val ) {}
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); }
118                bool operator<=( Qualifiers other ) const {
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
123                }
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 )
128        }; // Qualifiers
129
130        Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
131        Type( const Type & other );
132        virtual ~Type();
133
134        Qualifiers & get_qualifiers() { return tq; }
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; }
147
148        typedef std::list<TypeDecl *> ForallList;
149        ForallList& get_forall() { return forall; }
150
151        std::list< Attribute * >& get_attributes() { return attributes; }
152        const std::list< Attribute * >& get_attributes() const { return attributes; }
153
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; }
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; }
158
159        /// return type without outer pointers and arrays
160        Type *stripDeclarator();
161
162        virtual bool isComplete() const { return true; }
163
164        virtual Type *clone() const = 0;
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;
168  private:
169        Qualifiers tq;
170        ForallList forall;
171        std::list< Attribute * > attributes;
172};
173
174extern Type::Qualifiers emptyQualifiers;                                // no qualifiers on constants
175
176class VoidType : public Type {
177  public:
178        VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
179
180        virtual unsigned size() const { return 0; };
181        virtual bool isComplete() const { return false; }
182
183        virtual VoidType *clone() const { return new VoidType( *this ); }
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;
187};
188
189class BasicType : public Type {
190  public:
191        enum Kind {
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
214        };
215
216        static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
217
218        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
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 ); }
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;
227
228        bool isInteger() const;
229  private:
230        Kind kind;
231};
232
233class PointerType : public Type {
234  public:
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 * >() );
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
249        bool is_array() const { return isStatic || isVarLen || dimension; }
250
251        virtual bool isComplete() const { return ! isVarLen; }
252
253        virtual PointerType *clone() const { return new PointerType( *this ); }
254        virtual void accept( Visitor & v ) { v.visit( this ); }
255        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
256        virtual void print( std::ostream & os, int indent = 0 ) const;
257  private:
258        Type *base;
259
260        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
261        Expression *dimension;
262        bool isVarLen;
263        bool isStatic;
264};
265
266class ArrayType : public Type {
267  public:
268        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
269        ArrayType( const ArrayType& );
270        virtual ~ArrayType();
271
272        Type *get_base() { return base; }
273        void set_base( Type *newValue ) { base = newValue; }
274        Expression *get_dimension() { return dimension; }
275        void set_dimension( Expression *newValue ) { dimension = newValue; }
276        bool get_isVarLen() { return isVarLen; }
277        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
278        bool get_isStatic() { return isStatic; }
279        void set_isStatic( bool newValue ) { isStatic = newValue; }
280
281        virtual bool isComplete() const { return ! isVarLen; }
282
283        virtual ArrayType *clone() const { return new ArrayType( *this ); }
284        virtual void accept( Visitor & v ) { v.visit( this ); }
285        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
286        virtual void print( std::ostream & os, int indent = 0 ) const;
287  private:
288        Type *base;
289        Expression *dimension;
290        bool isVarLen;
291        bool isStatic;
292};
293
294class ReferenceType : public Type {
295public:
296        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
297        ReferenceType( const ReferenceType & );
298        virtual ~ReferenceType();
299
300        Type *get_base() { return base; }
301        void set_base( Type *newValue ) { base = newValue; }
302
303        virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
304        virtual void accept( Visitor & v ) { v.visit( this ); }
305        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
306        virtual void print( std::ostream & os, int indent = 0 ) const;
307private:
308        Type *base;
309};
310
311class FunctionType : public Type {
312  public:
313        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
314        FunctionType( const FunctionType& );
315        virtual ~FunctionType();
316
317        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
318        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
319        bool get_isVarArgs() const { return isVarArgs; }
320        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
321        bool isTtype() const;
322
323        virtual FunctionType *clone() const { return new FunctionType( *this ); }
324        virtual void accept( Visitor & v ) { v.visit( this ); }
325        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
326        virtual void print( std::ostream & os, int indent = 0 ) const;
327  private:
328        std::list<DeclarationWithType*> returnVals;
329        std::list<DeclarationWithType*> parameters;
330
331        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
332        // This could be because of
333        // - an ellipsis in a prototype declaration
334        // - an unprototyped declaration
335        bool isVarArgs;
336};
337
338class ReferenceToType : public Type {
339  public:
340        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
341        ReferenceToType( const ReferenceToType & other );
342        virtual ~ReferenceToType();
343
344        const std::string & get_name() const { return name; }
345        void set_name( std::string newValue ) { name = newValue; }
346        std::list< Expression* >& get_parameters() { return parameters; }
347        bool get_hoistType() const { return hoistType; }
348        void set_hoistType( bool newValue ) { hoistType = newValue; }
349
350        virtual ReferenceToType *clone() const = 0;
351        virtual void accept( Visitor & v ) = 0;
352        virtual Type *acceptMutator( Mutator & m ) = 0;
353        virtual void print( std::ostream & os, int indent = 0 ) const;
354
355        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
356  protected:
357        virtual std::string typeString() const = 0;
358        std::list< Expression* > parameters;
359        std::string name;
360  private:
361        bool hoistType;
362};
363
364class StructInstType : public ReferenceToType {
365        typedef ReferenceToType Parent;
366  public:
367        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
368        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
369        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
370
371        StructDecl *get_baseStruct() const { return baseStruct; }
372        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
373
374        /// Accesses generic parameters of base struct (NULL if none such)
375        std::list<TypeDecl*> * get_baseParameters();
376
377        virtual bool isComplete() const;
378
379        /// Looks up the members of this struct named "name" and places them into "foundDecls".
380        /// Clones declarations into "foundDecls", caller responsible for freeing
381        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
382
383        virtual StructInstType *clone() const { return new StructInstType( *this ); }
384        virtual void accept( Visitor & v ) { v.visit( this ); }
385        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
386
387        virtual void print( std::ostream & os, int indent = 0 ) const;
388  private:
389        virtual std::string typeString() const;
390
391        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
392        // where the structure used in this type is actually defined
393        StructDecl *baseStruct;
394};
395
396class UnionInstType : public ReferenceToType {
397        typedef ReferenceToType Parent;
398  public:
399        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
400        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
401        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
402
403        UnionDecl *get_baseUnion() const { return baseUnion; }
404        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
405
406        /// Accesses generic parameters of base union (NULL if none such)
407        std::list< TypeDecl * > * get_baseParameters();
408
409        virtual bool isComplete() const;
410
411        /// looks up the members of this union named "name" and places them into "foundDecls"
412        /// Clones declarations into "foundDecls", caller responsible for freeing
413        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
414
415        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
416        virtual void accept( Visitor & v ) { v.visit( this ); }
417        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
418
419        virtual void print( std::ostream & os, int indent = 0 ) const;
420  private:
421        virtual std::string typeString() const;
422
423        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
424        // where the union used in this type is actually defined
425        UnionDecl *baseUnion;
426};
427
428class EnumInstType : public ReferenceToType {
429        typedef ReferenceToType Parent;
430  public:
431        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
432        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
433        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
434
435        EnumDecl *get_baseEnum() const { return baseEnum; }
436        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
437
438        virtual bool isComplete() const;
439
440        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
441        virtual void accept( Visitor & v ) { v.visit( this ); }
442        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
443  private:
444        virtual std::string typeString() const;
445
446        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
447        // where the union used in this type is actually defined
448        EnumDecl *baseEnum = nullptr;
449};
450
451class TraitInstType : public ReferenceToType {
452        typedef ReferenceToType Parent;
453  public:
454        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
455        TraitInstType( const TraitInstType & other );
456        ~TraitInstType();
457
458        std::list< Declaration* >& get_members() { return members; }
459
460        virtual bool isComplete() const;
461
462        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
463        virtual void accept( Visitor & v ) { v.visit( this ); }
464        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
465  private:
466        virtual std::string typeString() const;
467
468        // this member is filled in by the validate pass, which instantiates the members of the correponding
469        // aggregate with the actual type parameters specified for this use of the context
470        std::list< Declaration* > members;
471};
472
473class TypeInstType : public ReferenceToType {
474        typedef ReferenceToType Parent;
475  public:
476        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
477        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
478        TypeInstType( const TypeInstType & other );
479        ~TypeInstType();
480
481        TypeDecl *get_baseType() const { return baseType; }
482        void set_baseType( TypeDecl *newValue );
483        bool get_isFtype() const { return isFtype; }
484        void set_isFtype( bool newValue ) { isFtype = newValue; }
485
486        virtual bool isComplete() const;
487
488        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
489        virtual void accept( Visitor & v ) { v.visit( this ); }
490        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
491        virtual void print( std::ostream & os, int indent = 0 ) const;
492  private:
493        virtual std::string typeString() const;
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};
499
500class TupleType : public Type {
501  public:
502        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
503        TupleType( const TupleType& );
504        virtual ~TupleType();
505
506        typedef std::list<Type*> value_type;
507        typedef value_type::iterator iterator;
508
509        std::list<Type *> & get_types() { return types; }
510        virtual unsigned size() const { return types.size(); };
511
512        // For now, this is entirely synthetic -- tuple types always have unnamed members.
513        // Eventually, we may allow named tuples, in which case members should subsume types
514        std::list<Declaration *> & get_members() { return members; }
515
516        iterator begin() { return types.begin(); }
517        iterator end() { return types.end(); }
518
519        virtual Type * getComponent( unsigned i ) {
520                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
521                return *(begin()+i);
522        }
523
524        // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
525
526        virtual TupleType *clone() const { return new TupleType( *this ); }
527        virtual void accept( Visitor & v ) { v.visit( this ); }
528        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
529        virtual void print( std::ostream & os, int indent = 0 ) const;
530  private:
531        std::list<Type *> types;
532        std::list<Declaration *> members;
533};
534
535class TypeofType : public Type {
536  public:
537        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
538        TypeofType( const TypeofType& );
539        virtual ~TypeofType();
540
541        Expression *get_expr() const { return expr; }
542        void set_expr( Expression *newValue ) { expr = newValue; }
543
544        virtual bool isComplete() const { assert( false ); return false; }
545
546        virtual TypeofType *clone() const { return new TypeofType( *this ); }
547        virtual void accept( Visitor & v ) { v.visit( this ); }
548        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
549        virtual void print( std::ostream & os, int indent = 0 ) const;
550  private:
551        Expression *expr;
552};
553
554class AttrType : public Type {
555  public:
556        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
557        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
558        AttrType( const AttrType& );
559        virtual ~AttrType();
560
561        const std::string & get_name() const { return name; }
562        void set_name( const std::string & newValue ) { name = newValue; }
563        Expression *get_expr() const { return expr; }
564        void set_expr( Expression *newValue ) { expr = newValue; }
565        Type *get_type() const { return type; }
566        void set_type( Type *newValue ) { type = newValue; }
567        bool get_isType() const { return isType; }
568        void set_isType( bool newValue ) { isType = newValue; }
569
570        virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
571
572        virtual AttrType *clone() const { return new AttrType( *this ); }
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;
576  private:
577        std::string name;
578        Expression *expr;
579        Type *type;
580        bool isType;
581};
582
583/// Represents the GCC built-in varargs type
584class VarArgsType : public Type {
585  public:
586        VarArgsType();
587        VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
588
589        virtual bool isComplete() const{ return true; } // xxx - is this right?
590
591        virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
592        virtual void accept( Visitor & v ) { v.visit( this ); }
593        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
594        virtual void print( std::ostream & os, int indent = 0 ) const;
595};
596
597/// Represents a zero constant
598class ZeroType : public Type {
599  public:
600        ZeroType();
601        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
602
603        virtual ZeroType *clone() const { return new ZeroType( *this ); }
604        virtual void accept( Visitor & v ) { v.visit( this ); }
605        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
606        virtual void print( std::ostream & os, int indent = 0 ) const;
607};
608
609/// Represents a one constant
610class OneType : public Type {
611  public:
612        OneType();
613        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
614
615        virtual OneType *clone() const { return new OneType( *this ); }
616        virtual void accept( Visitor & v ) { v.visit( this ); }
617        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
618        virtual void print( std::ostream & os, int indent = 0 ) const;
619};
620
621std::ostream & operator<<( std::ostream & out, const Type * type );
622
623#endif // TYPE_H
624
625// Local Variables: //
626// tab-width: 4 //
627// mode: c++ //
628// compile-command: "make install" //
629// End: //
Note: See TracBrowser for help on using the repository browser.