source: src/SynTree/Type.h @ 9bfc9da

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 9bfc9da was 9bfc9da, checked in by Rob Schluntz <rschlunt@…>, 6 years ago

Refactor makeSub into genericSubstitution

  • Property mode set to 100644
File size: 26.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 AggregateDecl * getAggr() { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
181
182        virtual TypeSubstitution genericSubstitution() const;
183
184        virtual Type *clone() const = 0;
185        virtual void accept( Visitor & v ) = 0;
186        virtual Type *acceptMutator( Mutator & m ) = 0;
187        virtual void print( std::ostream & os, Indenter indent = {} ) const;
188};
189
190extern const Type::FuncSpecifiers noFuncSpecifiers;
191extern const Type::StorageClasses noStorageClasses;
192extern const Type::Qualifiers noQualifiers;                     // no qualifiers on constants
193
194class VoidType : public Type {
195  public:
196        VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
197
198        virtual unsigned size() const override { return 0; };
199        virtual bool isComplete() const override { return false; }
200
201        virtual VoidType *clone() const override { return new VoidType( *this ); }
202        virtual void accept( Visitor & v ) override { v.visit( this ); }
203        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
204        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
205};
206
207class BasicType : public Type {
208  public:
209        enum Kind {
210                Bool,
211                Char,
212                SignedChar,
213                UnsignedChar,
214                ShortSignedInt,
215                ShortUnsignedInt,
216                SignedInt,
217                UnsignedInt,
218                LongSignedInt,
219                LongUnsignedInt,
220                LongLongSignedInt,
221                LongLongUnsignedInt,
222                Float,
223                Double,
224                LongDouble,
225                FloatComplex,
226                DoubleComplex,
227                LongDoubleComplex,
228                FloatImaginary,
229                DoubleImaginary,
230                LongDoubleImaginary,
231                SignedInt128,
232                UnsignedInt128,
233                NUMBER_OF_BASIC_TYPES
234        } kind;
235
236        static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
237
238        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
239
240        Kind get_kind() { return kind; }
241        void set_kind( Kind newValue ) { kind = newValue; }
242
243        virtual BasicType *clone() const override { return new BasicType( *this ); }
244        virtual void accept( Visitor & v ) override { v.visit( this ); }
245        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
246        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
247
248        bool isInteger() const;
249};
250
251class PointerType : public Type {
252  public:
253        Type *base;
254
255        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
256        Expression *dimension;
257        bool isVarLen;
258        bool isStatic;
259
260        PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
261        PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
262        PointerType( const PointerType& );
263        virtual ~PointerType();
264
265        Type *get_base() { return base; }
266        void set_base( Type *newValue ) { base = newValue; }
267        Expression *get_dimension() { return dimension; }
268        void set_dimension( Expression *newValue ) { dimension = newValue; }
269        bool get_isVarLen() { return isVarLen; }
270        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
271        bool get_isStatic() { return isStatic; }
272        void set_isStatic( bool newValue ) { isStatic = newValue; }
273
274        bool is_array() const { return isStatic || isVarLen || dimension; }
275
276        virtual bool isComplete() const override { return ! isVarLen; }
277
278        virtual PointerType *clone() const override { return new PointerType( *this ); }
279        virtual void accept( Visitor & v ) override { v.visit( this ); }
280        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
281        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
282};
283
284class ArrayType : public Type {
285  public:
286        Type *base;
287        Expression *dimension;
288        bool isVarLen;
289        bool isStatic;
290
291        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
292        ArrayType( const ArrayType& );
293        virtual ~ArrayType();
294
295        Type *get_base() { return base; }
296        void set_base( Type *newValue ) { base = newValue; }
297        Expression *get_dimension() { return dimension; }
298        void set_dimension( Expression *newValue ) { dimension = newValue; }
299        bool get_isVarLen() { return isVarLen; }
300        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
301        bool get_isStatic() { return isStatic; }
302        void set_isStatic( bool newValue ) { isStatic = newValue; }
303
304        // array types are complete if they have a dimension expression or are
305        // VLAs ('*' in parameter declaration), and incomplete otherwise.
306        // See 6.7.6.2
307        virtual bool isComplete() const override { return dimension || isVarLen; }
308
309        virtual ArrayType *clone() const override { return new ArrayType( *this ); }
310        virtual void accept( Visitor & v ) override { v.visit( this ); }
311        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
312        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
313};
314
315class ReferenceType : public Type {
316public:
317        Type *base;
318
319        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
320        ReferenceType( const ReferenceType & );
321        virtual ~ReferenceType();
322
323        Type *get_base() { return base; }
324        void set_base( Type *newValue ) { base = newValue; }
325
326        virtual int referenceDepth() const override;
327
328        // Since reference types act like value types, their size is the size of the base.
329        // This makes it simple to cast the empty tuple to a reference type, since casts that increase
330        // the number of values are disallowed.
331        virtual unsigned size() const override { return base->size(); }
332
333        virtual TypeSubstitution genericSubstitution() const override;
334
335        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
336        virtual void accept( Visitor & v ) override { v.visit( this ); }
337        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
338        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
339};
340
341class FunctionType : public Type {
342  public:
343        std::list<DeclarationWithType*> returnVals;
344        std::list<DeclarationWithType*> parameters;
345
346        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
347        // This could be because of
348        // - an ellipsis in a prototype declaration
349        // - an unprototyped declaration
350        bool isVarArgs;
351
352        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
353        FunctionType( const FunctionType& );
354        virtual ~FunctionType();
355
356        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
357        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
358        bool get_isVarArgs() const { return isVarArgs; }
359        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
360        bool isTtype() const;
361
362        bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
363
364        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
365        virtual void accept( Visitor & v ) override { v.visit( this ); }
366        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
367        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
368};
369
370class ReferenceToType : public Type {
371  public:
372        std::list< Expression* > parameters;
373        std::string name;
374        bool hoistType;
375
376        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
377        ReferenceToType( const ReferenceToType & other );
378        virtual ~ReferenceToType();
379
380        const std::string & get_name() const { return name; }
381        void set_name( std::string newValue ) { name = newValue; }
382        std::list< Expression* >& get_parameters() { return parameters; }
383        bool get_hoistType() const { return hoistType; }
384        void set_hoistType( bool newValue ) { hoistType = newValue; }
385
386        virtual ReferenceToType *clone() const override = 0;
387        virtual void accept( Visitor & v ) override = 0;
388        virtual Type *acceptMutator( Mutator & m ) override = 0;
389        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
390
391        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
392  protected:
393        virtual std::string typeString() const = 0;
394};
395
396class StructInstType : public ReferenceToType {
397        typedef ReferenceToType Parent;
398  public:
399        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
400        // where the structure used in this type is actually defined
401        StructDecl *baseStruct;
402
403        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
404        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
405        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
406
407        StructDecl *get_baseStruct() const { return baseStruct; }
408        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
409
410        /// Accesses generic parameters of base struct (NULL if none such)
411        std::list<TypeDecl*> * get_baseParameters();
412        const std::list<TypeDecl*> * get_baseParameters() const;
413
414        virtual bool isComplete() const override;
415
416        virtual AggregateDecl * getAggr() override;
417
418        virtual TypeSubstitution genericSubstitution() const override;
419
420        /// Looks up the members of this struct named "name" and places them into "foundDecls".
421        /// Clones declarations into "foundDecls", caller responsible for freeing
422        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
423
424        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
425        virtual void accept( Visitor & v ) override { v.visit( this ); }
426        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
427
428        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
429  private:
430        virtual std::string typeString() const override;
431};
432
433class UnionInstType : public ReferenceToType {
434        typedef ReferenceToType Parent;
435  public:
436        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
437        // where the union used in this type is actually defined
438        UnionDecl *baseUnion;
439
440        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
441        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
442        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
443
444        UnionDecl *get_baseUnion() const { return baseUnion; }
445        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
446
447        /// Accesses generic parameters of base union (NULL if none such)
448        std::list<TypeDecl*> * get_baseParameters();
449        const std::list<TypeDecl*> * get_baseParameters() const;
450
451        virtual bool isComplete() const override;
452
453        virtual AggregateDecl * getAggr() override;
454
455        virtual TypeSubstitution genericSubstitution() const override;
456
457        /// looks up the members of this union named "name" and places them into "foundDecls"
458        /// Clones declarations into "foundDecls", caller responsible for freeing
459        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
460
461        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
462        virtual void accept( Visitor & v ) override { v.visit( this ); }
463        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
464
465        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
466  private:
467        virtual std::string typeString() const override;
468};
469
470class EnumInstType : public ReferenceToType {
471        typedef ReferenceToType Parent;
472  public:
473        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
474        // where the union used in this type is actually defined
475        EnumDecl *baseEnum = nullptr;
476
477        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
478        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
479        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
480
481        EnumDecl *get_baseEnum() const { return baseEnum; }
482        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
483
484        virtual bool isComplete() const override;
485
486        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
487        virtual void accept( Visitor & v ) override { v.visit( this ); }
488        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
489
490        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
491  private:
492        virtual std::string typeString() const override;
493};
494
495class TraitInstType : public ReferenceToType {
496        typedef ReferenceToType Parent;
497  public:
498        // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
499        // where the trait used in this type is actually defined
500        TraitDecl * baseTrait = nullptr;
501
502        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
503        TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
504        TraitInstType( const TraitInstType & other );
505        ~TraitInstType();
506
507        virtual bool isComplete() const override;
508
509        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
510        virtual void accept( Visitor & v ) override { v.visit( this ); }
511        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
512  private:
513        virtual std::string typeString() const override;
514};
515
516class TypeInstType : public ReferenceToType {
517        typedef ReferenceToType Parent;
518  public:
519        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
520        // where the type used here is actually defined
521        TypeDecl *baseType;
522        bool isFtype;
523
524        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
525        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
526        TypeInstType( const TypeInstType & other );
527        ~TypeInstType();
528
529        TypeDecl *get_baseType() const { return baseType; }
530        void set_baseType( TypeDecl *newValue );
531        bool get_isFtype() const { return isFtype; }
532        void set_isFtype( bool newValue ) { isFtype = newValue; }
533
534        virtual bool isComplete() const override;
535
536        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
537        virtual void accept( Visitor & v ) override { v.visit( this ); }
538        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
539        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
540  private:
541        virtual std::string typeString() const override;
542};
543
544class TupleType : public Type {
545  public:
546        std::list<Type *> types;
547        std::list<Declaration *> members;
548
549        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
550        TupleType( const TupleType& );
551        virtual ~TupleType();
552
553        typedef std::list<Type*> value_type;
554        typedef value_type::iterator iterator;
555
556        std::list<Type *> & get_types() { return types; }
557        virtual unsigned size() const override { return types.size(); };
558
559        // For now, this is entirely synthetic -- tuple types always have unnamed members.
560        // Eventually, we may allow named tuples, in which case members should subsume types
561        std::list<Declaration *> & get_members() { return members; }
562
563        iterator begin() { return types.begin(); }
564        iterator end() { return types.end(); }
565
566        virtual Type * getComponent( unsigned i ) override {
567                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
568                return *(begin()+i);
569        }
570
571        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
572
573        virtual TupleType *clone() const override { return new TupleType( *this ); }
574        virtual void accept( Visitor & v ) override { v.visit( this ); }
575        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
576        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
577};
578
579class TypeofType : public Type {
580  public:
581        Expression *expr;
582
583        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
584        TypeofType( const TypeofType& );
585        virtual ~TypeofType();
586
587        Expression *get_expr() const { return expr; }
588        void set_expr( Expression *newValue ) { expr = newValue; }
589
590        virtual bool isComplete() const override { assert( false ); return false; }
591
592        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
593        virtual void accept( Visitor & v ) override { v.visit( this ); }
594        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
595        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
596};
597
598class AttrType : public Type {
599  public:
600        std::string name;
601        Expression *expr;
602        Type *type;
603        bool isType;
604
605        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
606        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
607        AttrType( const AttrType& );
608        virtual ~AttrType();
609
610        const std::string & get_name() const { return name; }
611        void set_name( const std::string & newValue ) { name = newValue; }
612        Expression *get_expr() const { return expr; }
613        void set_expr( Expression *newValue ) { expr = newValue; }
614        Type *get_type() const { return type; }
615        void set_type( Type *newValue ) { type = newValue; }
616        bool get_isType() const { return isType; }
617        void set_isType( bool newValue ) { isType = newValue; }
618
619        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
620
621        virtual AttrType *clone() const override { return new AttrType( *this ); }
622        virtual void accept( Visitor & v ) override { v.visit( this ); }
623        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
624        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
625};
626
627/// Represents the GCC built-in varargs type
628class VarArgsType : public Type {
629  public:
630        VarArgsType();
631        VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
632
633        virtual bool isComplete() const override{ return true; } // xxx - is this right?
634
635        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
636        virtual void accept( Visitor & v ) override { v.visit( this ); }
637        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
638        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
639};
640
641/// Represents a zero constant
642class ZeroType : public Type {
643  public:
644        ZeroType();
645        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
646
647        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
648        virtual void accept( Visitor & v ) override { v.visit( this ); }
649        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
650        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
651};
652
653/// Represents a one constant
654class OneType : public Type {
655  public:
656        OneType();
657        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
658
659        virtual OneType *clone() const override { return new OneType( *this ); }
660        virtual void accept( Visitor & v ) override { v.visit( this ); }
661        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
662        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
663};
664
665// Local Variables: //
666// tab-width: 4 //
667// mode: c++ //
668// compile-command: "make install" //
669// End: //
Note: See TracBrowser for help on using the repository browser.