source: src/SynTree/Type.h @ d6d747d

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since d6d747d was d6d747d, checked in by Peter A. Buhr <pabuhr@…>, 5 years ago

more cleanup for bit-field type usage

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