source: src/SynTree/Type.h @ ddfd945

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since ddfd945 was ddfd945, checked in by Peter A. Buhr <pabuhr@…>, 6 years ago

move type FuncSpecifiers? from DeclarationNode? to Type

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