source: src/SynTree/Type.h @ 231f01c

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

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc
  • Property mode set to 100644
File size: 22.9 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 : Fri Mar 17 09:04:03 2017
13// Update Count     : 147
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        virtual PointerType *clone() const { return new PointerType( *this ); }
250        virtual void accept( Visitor & v ) { v.visit( this ); }
251        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
252        virtual void print( std::ostream & os, int indent = 0 ) const;
253  private:
254        Type *base;
255
256        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
257        Expression *dimension;
258        bool isVarLen;
259        bool isStatic;
260};
261
262class ArrayType : public Type {
263  public:
264        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
265        ArrayType( const ArrayType& );
266        virtual ~ArrayType();
267
268        Type *get_base() { return base; }
269        void set_base( Type *newValue ) { base = newValue; }
270        Expression *get_dimension() { return dimension; }
271        void set_dimension( Expression *newValue ) { dimension = newValue; }
272        bool get_isVarLen() { return isVarLen; }
273        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
274        bool get_isStatic() { return isStatic; }
275        void set_isStatic( bool newValue ) { isStatic = newValue; }
276
277        virtual bool isComplete() const { return ! isVarLen; }
278
279        virtual ArrayType *clone() const { return new ArrayType( *this ); }
280        virtual void accept( Visitor & v ) { v.visit( this ); }
281        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
282        virtual void print( std::ostream & os, int indent = 0 ) const;
283  private:
284        Type *base;
285        Expression *dimension;
286        bool isVarLen;
287        bool isStatic;
288};
289
290class FunctionType : public Type {
291  public:
292        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
293        FunctionType( const FunctionType& );
294        virtual ~FunctionType();
295
296        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
297        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
298        bool get_isVarArgs() const { return isVarArgs; }
299        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
300        bool isTtype() const;
301
302        virtual FunctionType *clone() const { return new FunctionType( *this ); }
303        virtual void accept( Visitor & v ) { v.visit( this ); }
304        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
305        virtual void print( std::ostream & os, int indent = 0 ) const;
306  private:
307        std::list<DeclarationWithType*> returnVals;
308        std::list<DeclarationWithType*> parameters;
309
310        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
311        // This could be because of
312        // - an ellipsis in a prototype declaration
313        // - an unprototyped declaration
314        bool isVarArgs;
315};
316
317class ReferenceToType : public Type {
318  public:
319        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
320        ReferenceToType( const ReferenceToType & other );
321        virtual ~ReferenceToType();
322
323        const std::string & get_name() const { return name; }
324        void set_name( std::string newValue ) { name = newValue; }
325        std::list< Expression* >& get_parameters() { return parameters; }
326        bool get_hoistType() const { return hoistType; }
327        void set_hoistType( bool newValue ) { hoistType = newValue; }
328
329        virtual ReferenceToType *clone() const = 0;
330        virtual void accept( Visitor & v ) = 0;
331        virtual Type *acceptMutator( Mutator & m ) = 0;
332        virtual void print( std::ostream & os, int indent = 0 ) const;
333  protected:
334        virtual std::string typeString() const = 0;
335        std::list< Expression* > parameters;
336        std::string name;
337  private:
338        bool hoistType;
339};
340
341class StructInstType : public ReferenceToType {
342        typedef ReferenceToType Parent;
343  public:
344        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
345        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
346        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
347
348        StructDecl *get_baseStruct() const { return baseStruct; }
349        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
350
351        /// Accesses generic parameters of base struct (NULL if none such)
352        std::list<TypeDecl*> * get_baseParameters();
353
354        virtual bool isComplete() const;
355
356        /// Looks up the members of this struct named "name" and places them into "foundDecls".
357        /// Clones declarations into "foundDecls", caller responsible for freeing
358        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
359
360        virtual StructInstType *clone() const { return new StructInstType( *this ); }
361        virtual void accept( Visitor & v ) { v.visit( this ); }
362        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
363
364        virtual void print( std::ostream & os, int indent = 0 ) const;
365  private:
366        virtual std::string typeString() const;
367
368        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
369        // where the structure used in this type is actually defined
370        StructDecl *baseStruct;
371};
372
373class UnionInstType : public ReferenceToType {
374        typedef ReferenceToType Parent;
375  public:
376        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
377        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
378        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
379
380        UnionDecl *get_baseUnion() const { return baseUnion; }
381        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
382
383        /// Accesses generic parameters of base union (NULL if none such)
384        std::list< TypeDecl * > * get_baseParameters();
385
386        virtual bool isComplete() const;
387
388        /// looks up the members of this union named "name" and places them into "foundDecls"
389        /// Clones declarations into "foundDecls", caller responsible for freeing
390        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
391
392        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
393        virtual void accept( Visitor & v ) { v.visit( this ); }
394        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
395
396        virtual void print( std::ostream & os, int indent = 0 ) const;
397  private:
398        virtual std::string typeString() const;
399
400        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
401        // where the union used in this type is actually defined
402        UnionDecl *baseUnion;
403};
404
405class EnumInstType : public ReferenceToType {
406        typedef ReferenceToType Parent;
407  public:
408        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
409        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
410        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
411
412        EnumDecl *get_baseEnum() const { return baseEnum; }
413        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
414
415        virtual bool isComplete() const;
416
417        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
418        virtual void accept( Visitor & v ) { v.visit( this ); }
419        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
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        EnumDecl *baseEnum = nullptr;
426};
427
428class TraitInstType : public ReferenceToType {
429        typedef ReferenceToType Parent;
430  public:
431        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
432        TraitInstType( const TraitInstType & other );
433        ~TraitInstType();
434
435        std::list< Declaration* >& get_members() { return members; }
436
437        virtual bool isComplete() const;
438
439        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
440        virtual void accept( Visitor & v ) { v.visit( this ); }
441        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
442  private:
443        virtual std::string typeString() const;
444
445        // this member is filled in by the validate pass, which instantiates the members of the correponding
446        // aggregate with the actual type parameters specified for this use of the context
447        std::list< Declaration* > members;
448};
449
450class TypeInstType : public ReferenceToType {
451        typedef ReferenceToType Parent;
452  public:
453        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
454        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
455        TypeInstType( const TypeInstType & other );
456        ~TypeInstType();
457
458        TypeDecl *get_baseType() const { return baseType; }
459        void set_baseType( TypeDecl *newValue );
460        bool get_isFtype() const { return isFtype; }
461        void set_isFtype( bool newValue ) { isFtype = newValue; }
462
463        virtual bool isComplete() const;
464
465        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
466        virtual void accept( Visitor & v ) { v.visit( this ); }
467        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
468        virtual void print( std::ostream & os, int indent = 0 ) const;
469  private:
470        virtual std::string typeString() const;
471        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
472        // where the type used here is actually defined
473        TypeDecl *baseType;
474        bool isFtype;
475};
476
477class TupleType : public Type {
478  public:
479        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
480        TupleType( const TupleType& );
481        virtual ~TupleType();
482
483        typedef std::list<Type*> value_type;
484        typedef value_type::iterator iterator;
485
486        std::list<Type*>& get_types() { return types; }
487        virtual unsigned size() const { return types.size(); };
488
489        iterator begin() { return types.begin(); }
490        iterator end() { return types.end(); }
491
492        virtual Type * getComponent( unsigned i ) {
493                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
494                return *(begin()+i);
495        }
496
497        // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
498
499        virtual TupleType *clone() const { return new TupleType( *this ); }
500        virtual void accept( Visitor & v ) { v.visit( this ); }
501        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
502        virtual void print( std::ostream & os, int indent = 0 ) const;
503  private:
504        std::list<Type*> types;
505};
506
507class TypeofType : public Type {
508  public:
509        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
510        TypeofType( const TypeofType& );
511        virtual ~TypeofType();
512
513        Expression *get_expr() const { return expr; }
514        void set_expr( Expression *newValue ) { expr = newValue; }
515
516        virtual bool isComplete() const { assert( false ); return false; }
517
518        virtual TypeofType *clone() const { return new TypeofType( *this ); }
519        virtual void accept( Visitor & v ) { v.visit( this ); }
520        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
521        virtual void print( std::ostream & os, int indent = 0 ) const;
522  private:
523        Expression *expr;
524};
525
526class AttrType : public Type {
527  public:
528        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
529        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
530        AttrType( const AttrType& );
531        virtual ~AttrType();
532
533        const std::string & get_name() const { return name; }
534        void set_name( const std::string & newValue ) { name = newValue; }
535        Expression *get_expr() const { return expr; }
536        void set_expr( Expression *newValue ) { expr = newValue; }
537        Type *get_type() const { return type; }
538        void set_type( Type *newValue ) { type = newValue; }
539        bool get_isType() const { return isType; }
540        void set_isType( bool newValue ) { isType = newValue; }
541
542        virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
543
544        virtual AttrType *clone() const { return new AttrType( *this ); }
545        virtual void accept( Visitor & v ) { v.visit( this ); }
546        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
547        virtual void print( std::ostream & os, int indent = 0 ) const;
548  private:
549        std::string name;
550        Expression *expr;
551        Type *type;
552        bool isType;
553};
554
555/// Represents the GCC built-in varargs type
556class VarArgsType : public Type {
557  public:
558        VarArgsType();
559        VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
560
561        virtual bool isComplete() const{ return true; } // xxx - is this right?
562
563        virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
564        virtual void accept( Visitor & v ) { v.visit( this ); }
565        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
566        virtual void print( std::ostream & os, int indent = 0 ) const;
567};
568
569/// Represents a zero constant
570class ZeroType : public Type {
571  public:
572        ZeroType();
573        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
574
575        virtual ZeroType *clone() const { return new ZeroType( *this ); }
576        virtual void accept( Visitor & v ) { v.visit( this ); }
577        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
578        virtual void print( std::ostream & os, int indent = 0 ) const;
579};
580
581/// Represents a one constant
582class OneType : public Type {
583  public:
584        OneType();
585        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
586
587        virtual OneType *clone() const { return new OneType( *this ); }
588        virtual void accept( Visitor & v ) { v.visit( this ); }
589        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
590        virtual void print( std::ostream & os, int indent = 0 ) const;
591};
592
593std::ostream & operator<<( std::ostream & out, const Type * type );
594
595#endif // TYPE_H
596
597// Local Variables: //
598// tab-width: 4 //
599// mode: c++ //
600// compile-command: "make install" //
601// End: //
Note: See TracBrowser for help on using the repository browser.