source: src/SynTree/Type.h @ d67cdb7

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

merge

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