source: src/SynTree/Type.h @ 027c496

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 027c496 was 99b7d4fc, checked in by Rob Schluntz <rschlunt@…>, 7 years ago

Fix isComplete for ArrayType?

  • Property mode set to 100644
File size: 26.1 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, Indenter indent = {} ) 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, Indenter indent = {} ) 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, Indenter indent = {} ) 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, Indenter indent = {} ) 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        // array types are complete if they have a dimension expression or are
301        // VLAs ('*' in parameter declaration), and incomplete otherwise.
302        // See 6.7.6.2
303        virtual bool isComplete() const override { return dimension || isVarLen; }
304
305        virtual ArrayType *clone() const override { return new ArrayType( *this ); }
306        virtual void accept( Visitor & v ) override { v.visit( this ); }
307        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
308        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
309};
310
311class ReferenceType : public Type {
312public:
313        Type *base;
314
315        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
316        ReferenceType( const ReferenceType & );
317        virtual ~ReferenceType();
318
319        Type *get_base() { return base; }
320        void set_base( Type *newValue ) { base = newValue; }
321
322        virtual int referenceDepth() const override;
323
324        // Since reference types act like value types, their size is the size of the base.
325        // This makes it simple to cast the empty tuple to a reference type, since casts that increase
326        // the number of values are disallowed.
327        virtual unsigned size() const override { return base->size(); }
328
329        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
330        virtual void accept( Visitor & v ) override { v.visit( this ); }
331        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
332        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
333};
334
335class FunctionType : public Type {
336  public:
337        std::list<DeclarationWithType*> returnVals;
338        std::list<DeclarationWithType*> parameters;
339
340        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
341        // This could be because of
342        // - an ellipsis in a prototype declaration
343        // - an unprototyped declaration
344        bool isVarArgs;
345
346        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
347        FunctionType( const FunctionType& );
348        virtual ~FunctionType();
349
350        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
351        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
352        bool get_isVarArgs() const { return isVarArgs; }
353        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
354        bool isTtype() const;
355
356        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
357        virtual void accept( Visitor & v ) override { v.visit( this ); }
358        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
359        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
360};
361
362class ReferenceToType : public Type {
363  public:
364        std::list< Expression* > parameters;
365        std::string name;
366        bool hoistType;
367
368        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
369        ReferenceToType( const ReferenceToType & other );
370        virtual ~ReferenceToType();
371
372        const std::string & get_name() const { return name; }
373        void set_name( std::string newValue ) { name = newValue; }
374        std::list< Expression* >& get_parameters() { return parameters; }
375        bool get_hoistType() const { return hoistType; }
376        void set_hoistType( bool newValue ) { hoistType = newValue; }
377
378        virtual ReferenceToType *clone() const override = 0;
379        virtual void accept( Visitor & v ) override = 0;
380        virtual Type *acceptMutator( Mutator & m ) override = 0;
381        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
382
383        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
384  protected:
385        virtual std::string typeString() const = 0;
386};
387
388class StructInstType : public ReferenceToType {
389        typedef ReferenceToType Parent;
390  public:
391        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
392        // where the structure used in this type is actually defined
393        StructDecl *baseStruct;
394
395        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
396        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
397        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
398
399        StructDecl *get_baseStruct() const { return baseStruct; }
400        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
401
402        /// Accesses generic parameters of base struct (NULL if none such)
403        std::list<TypeDecl*> * get_baseParameters();
404
405        virtual bool isComplete() const override;
406
407        /// Looks up the members of this struct named "name" and places them into "foundDecls".
408        /// Clones declarations into "foundDecls", caller responsible for freeing
409        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
410
411        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
412        virtual void accept( Visitor & v ) override { v.visit( this ); }
413        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
414
415        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
416  private:
417        virtual std::string typeString() const override;
418};
419
420class UnionInstType : public ReferenceToType {
421        typedef ReferenceToType Parent;
422  public:
423        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
424        // where the union used in this type is actually defined
425        UnionDecl *baseUnion;
426
427        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
428        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
429        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
430
431        UnionDecl *get_baseUnion() const { return baseUnion; }
432        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
433
434        /// Accesses generic parameters of base union (NULL if none such)
435        std::list< TypeDecl * > * get_baseParameters();
436
437        virtual bool isComplete() const override;
438
439        /// looks up the members of this union named "name" and places them into "foundDecls"
440        /// Clones declarations into "foundDecls", caller responsible for freeing
441        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
442
443        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
444        virtual void accept( Visitor & v ) override { v.visit( this ); }
445        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
446
447        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
448  private:
449        virtual std::string typeString() const override;
450};
451
452class EnumInstType : public ReferenceToType {
453        typedef ReferenceToType Parent;
454  public:
455        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
456        // where the union used in this type is actually defined
457        EnumDecl *baseEnum = nullptr;
458
459        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
460        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
461        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
462
463        EnumDecl *get_baseEnum() const { return baseEnum; }
464        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
465
466        virtual bool isComplete() const override;
467
468        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
469        virtual void accept( Visitor & v ) override { v.visit( this ); }
470        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
471
472        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
473  private:
474        virtual std::string typeString() const override;
475};
476
477class TraitInstType : public ReferenceToType {
478        typedef ReferenceToType Parent;
479  public:
480        // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
481        // where the trait used in this type is actually defined
482        TraitDecl * baseTrait = nullptr;
483
484        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
485        TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
486        TraitInstType( const TraitInstType & other );
487        ~TraitInstType();
488
489        virtual bool isComplete() const override;
490
491        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
492        virtual void accept( Visitor & v ) override { v.visit( this ); }
493        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
494  private:
495        virtual std::string typeString() const override;
496};
497
498class TypeInstType : public ReferenceToType {
499        typedef ReferenceToType Parent;
500  public:
501        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
502        // where the type used here is actually defined
503        TypeDecl *baseType;
504        bool isFtype;
505
506        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
507        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
508        TypeInstType( const TypeInstType & other );
509        ~TypeInstType();
510
511        TypeDecl *get_baseType() const { return baseType; }
512        void set_baseType( TypeDecl *newValue );
513        bool get_isFtype() const { return isFtype; }
514        void set_isFtype( bool newValue ) { isFtype = newValue; }
515
516        virtual bool isComplete() const override;
517
518        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
519        virtual void accept( Visitor & v ) override { v.visit( this ); }
520        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
521        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
522  private:
523        virtual std::string typeString() const override;
524};
525
526class TupleType : public Type {
527  public:
528        std::list<Type *> types;
529        std::list<Declaration *> members;
530
531        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
532        TupleType( const TupleType& );
533        virtual ~TupleType();
534
535        typedef std::list<Type*> value_type;
536        typedef value_type::iterator iterator;
537
538        std::list<Type *> & get_types() { return types; }
539        virtual unsigned size() const override { return types.size(); };
540
541        // For now, this is entirely synthetic -- tuple types always have unnamed members.
542        // Eventually, we may allow named tuples, in which case members should subsume types
543        std::list<Declaration *> & get_members() { return members; }
544
545        iterator begin() { return types.begin(); }
546        iterator end() { return types.end(); }
547
548        virtual Type * getComponent( unsigned i ) override {
549                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
550                return *(begin()+i);
551        }
552
553        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
554
555        virtual TupleType *clone() const override { return new TupleType( *this ); }
556        virtual void accept( Visitor & v ) override { v.visit( this ); }
557        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
558        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
559};
560
561class TypeofType : public Type {
562  public:
563        Expression *expr;
564
565        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
566        TypeofType( const TypeofType& );
567        virtual ~TypeofType();
568
569        Expression *get_expr() const { return expr; }
570        void set_expr( Expression *newValue ) { expr = newValue; }
571
572        virtual bool isComplete() const override { assert( false ); return false; }
573
574        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
575        virtual void accept( Visitor & v ) override { v.visit( this ); }
576        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
577        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
578};
579
580class AttrType : public Type {
581  public:
582        std::string name;
583        Expression *expr;
584        Type *type;
585        bool isType;
586
587        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
588        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
589        AttrType( const AttrType& );
590        virtual ~AttrType();
591
592        const std::string & get_name() const { return name; }
593        void set_name( const std::string & newValue ) { name = newValue; }
594        Expression *get_expr() const { return expr; }
595        void set_expr( Expression *newValue ) { expr = newValue; }
596        Type *get_type() const { return type; }
597        void set_type( Type *newValue ) { type = newValue; }
598        bool get_isType() const { return isType; }
599        void set_isType( bool newValue ) { isType = newValue; }
600
601        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
602
603        virtual AttrType *clone() const override { return new AttrType( *this ); }
604        virtual void accept( Visitor & v ) override { v.visit( this ); }
605        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
606        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
607};
608
609/// Represents the GCC built-in varargs type
610class VarArgsType : public Type {
611  public:
612        VarArgsType();
613        VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
614
615        virtual bool isComplete() const override{ return true; } // xxx - is this right?
616
617        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
618        virtual void accept( Visitor & v ) override { v.visit( this ); }
619        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
620        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
621};
622
623/// Represents a zero constant
624class ZeroType : public Type {
625  public:
626        ZeroType();
627        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
628
629        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
630        virtual void accept( Visitor & v ) override { v.visit( this ); }
631        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
632        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
633};
634
635/// Represents a one constant
636class OneType : public Type {
637  public:
638        OneType();
639        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
640
641        virtual OneType *clone() const override { return new OneType( *this ); }
642        virtual void accept( Visitor & v ) override { v.visit( this ); }
643        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
644        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
645};
646
647// Local Variables: //
648// tab-width: 4 //
649// mode: c++ //
650// compile-command: "make install" //
651// End: //
Note: See TracBrowser for help on using the repository browser.