source: src/SynTree/Type.h

Last change on this file was 4520b77e, checked in by JiadaL <j82liang@…>, 3 months ago

Merge to Master Sept 19

  • Property mode set to 100644
File size: 30.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 : Andrew Beach
12// Last Modified On : Wed Jul 14 15:40:00 2021
13// Update Count     : 171
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, ThreadlocalGcc = 1 << 4, ThreadlocalC11 = 1 << 5, NumStorageClass = 6 };
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_threadlocalGcc : 1;
96                        bool is_threadlocalC11 : 1;
97                };
98
99                StorageClasses() : val( 0 ) {}
100                StorageClasses( unsigned int val ) : val( val ) {}
101                // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
102                BFCommon( StorageClasses, NumStorageClass )
103
104                bool is_threadlocal_any() { return this->is_threadlocalC11 || this->is_threadlocalGcc; }
105        }; // StorageClasses
106
107        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Mutex = 1 << 3, Atomic = 1 << 4, NumTypeQualifier = 5 };
108        static const char * QualifiersNames[];
109        union Qualifiers {
110                enum { Mask = ~Restrict };
111                unsigned int val;
112                struct {
113                        bool is_const : 1;
114                        bool is_restrict : 1;
115                        bool is_volatile : 1;
116                        bool is_mutex : 1;
117                        bool is_atomic : 1;
118                };
119
120                Qualifiers() : val( 0 ) {}
121                Qualifiers( unsigned int val ) : val( val ) {}
122                // Complex comparisons provide implicit qualifier downcasting, e.g., T downcast to const T.
123                bool operator==( Qualifiers other ) const { return (val & Mask) == (other.val & Mask); }
124                bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
125                bool operator<=( Qualifiers other ) const {
126                        return is_const    <= other.is_const        //Any non-const converts to const without cost
127                                        && is_volatile <= other.is_volatile     //Any non-volatile converts to volatile without cost
128                                        && is_mutex    >= other.is_mutex        //Any mutex converts to non-mutex without cost
129                                        && is_atomic   == other.is_atomic;      //No conversion from atomic to non atomic is free
130                }
131                bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
132                bool operator>=( Qualifiers other ) const { return ! (*this < other); }
133                bool operator>( Qualifiers other ) const { return *this != other && *this >= other; }
134                BFCommon( Qualifiers, NumTypeQualifier )
135
136                Qualifiers unify( Qualifiers const & other ) const {
137                        int or_flags = Mask & (val | other.val);
138                        int and_flags = val & other.val;
139                        return Qualifiers( or_flags | and_flags );
140                }
141        }; // Qualifiers
142
143        typedef std::list<TypeDecl *> ForallList;
144
145        Qualifiers tq;
146        ForallList forall;
147        std::list< Attribute * > attributes;
148
149        Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
150        Type( const Type & other );
151        virtual ~Type();
152
153        Qualifiers & get_qualifiers() { return tq; }
154        bool get_const() const { return tq.is_const; }
155        bool get_volatile() const { return tq.is_volatile; }
156        bool get_restrict() const { return tq.is_restrict; }
157        bool get_mutex() const { return tq.is_mutex; }
158        bool get_atomic() const { return tq.is_atomic; }
159        void set_const( bool newValue ) { tq.is_const = newValue; }
160        void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
161        void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
162        void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
163        void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
164
165        ForallList& get_forall() { return forall; }
166
167        std::list< Attribute * >& get_attributes() { return attributes; }
168        const std::list< Attribute * >& get_attributes() const { return attributes; }
169
170        /// How many elemental types are represented by this type
171        virtual unsigned size() const { return 1; };
172        virtual bool isVoid() const { return size() == 0; }
173        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; }
174
175        /// return type without outer pointers and arrays
176        Type * stripDeclarator();
177
178        /// return type without outer references
179        Type * stripReferences();
180        const Type * stripReferences() const;
181
182        /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
183        virtual int referenceDepth() const;
184
185        virtual bool isComplete() const { return true; }
186
187        virtual AggregateDecl * getAggr() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
188
189        virtual TypeSubstitution genericSubstitution() const;
190
191        virtual Type *clone() const = 0;
192        virtual void accept( Visitor & v ) = 0;
193        virtual void accept( Visitor & v ) const = 0;
194        virtual Type *acceptMutator( Mutator & m ) = 0;
195        virtual void print( std::ostream & os, Indenter indent = {} ) const;
196};
197
198extern const Type::FuncSpecifiers noFuncSpecifiers;
199extern const Type::StorageClasses noStorageClasses;
200extern const Type::Qualifiers noQualifiers;                     // no qualifiers on constants
201
202class VoidType : public Type {
203  public:
204        VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
205
206        virtual unsigned size() const override { return 0; };
207        virtual bool isComplete() const override { return false; }
208
209        virtual VoidType *clone() const override { return new VoidType( *this ); }
210        virtual void accept( Visitor & v ) override { v.visit( this ); }
211        virtual void accept( Visitor & v ) const override { v.visit( this ); }
212        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
213        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
214};
215
216class BasicType : public Type {
217  public:
218        // GENERATED START, DO NOT EDIT
219        // GENERATED BY BasicTypes-gen.cc
220        enum Kind {
221                Bool,
222                Char,
223                SignedChar,
224                UnsignedChar,
225                ShortSignedInt,
226                ShortUnsignedInt,
227                SignedInt,
228                UnsignedInt,
229                LongSignedInt,
230                LongUnsignedInt,
231                LongLongSignedInt,
232                LongLongUnsignedInt,
233                SignedInt128,
234                UnsignedInt128,
235                uFloat16,
236                uFloat16Complex,
237                uFloat32,
238                uFloat32Complex,
239                Float,
240                FloatComplex,
241                uFloat32x,
242                uFloat32xComplex,
243                uFloat64,
244                uFloat64Complex,
245                Double,
246                DoubleComplex,
247                uFloat64x,
248                uFloat64xComplex,
249                uuFloat80,
250                uFloat128,
251                uFloat128Complex,
252                uuFloat128,
253                LongDouble,
254                LongDoubleComplex,
255                uFloat128x,
256                uFloat128xComplex,
257                NUMBER_OF_BASIC_TYPES
258        } kind;
259        // GENERATED END
260
261        static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
262
263        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
264
265        Kind get_kind() const { return kind; }
266        void set_kind( Kind newValue ) { kind = newValue; }
267
268        virtual BasicType *clone() const override { return new BasicType( *this ); }
269        virtual void accept( Visitor & v ) override { v.visit( this ); }
270        virtual void accept( Visitor & v ) const override { v.visit( this ); }
271        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
272        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
273        bool isWholeNumber() const;
274        bool isInteger() const;
275};
276
277class PointerType : public Type {
278  public:
279        Type * base;
280
281        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
282        Expression *dimension;
283        bool isVarLen;
284        bool isStatic;
285
286        PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
287        PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
288        PointerType( const PointerType& );
289        virtual ~PointerType();
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        bool is_array() const { return isStatic || isVarLen || dimension; }
301
302        virtual bool isComplete() const override { return ! isVarLen; }
303
304        virtual PointerType *clone() const override { return new PointerType( *this ); }
305        virtual void accept( Visitor & v ) override { v.visit( this ); }
306        virtual void accept( Visitor & v ) const 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 ArrayType : public Type {
312  public:
313        Type *base;
314        Expression *dimension;
315        bool isVarLen;
316        bool isStatic;
317
318        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
319        ArrayType( const ArrayType& );
320        virtual ~ArrayType();
321
322        Type *get_base() { return base; }
323        void set_base( Type *newValue ) { base = newValue; }
324        Expression *get_dimension() { return dimension; }
325        void set_dimension( Expression *newValue ) { dimension = newValue; }
326        bool get_isVarLen() { return isVarLen; }
327        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
328        bool get_isStatic() { return isStatic; }
329        void set_isStatic( bool newValue ) { isStatic = newValue; }
330
331        // array types are complete if they have a dimension expression or are
332        // VLAs ('*' in parameter declaration), and incomplete otherwise.
333        // See 6.7.6.2
334        virtual bool isComplete() const override { return dimension || isVarLen; }
335
336        virtual ArrayType *clone() const override { return new ArrayType( *this ); }
337        virtual void accept( Visitor & v ) override { v.visit( this ); }
338        virtual void accept( Visitor & v ) const override { v.visit( this ); }
339        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
340        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
341};
342
343class QualifiedType : public Type {
344public:
345        Type * parent;
346        Type * child;
347        QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child );
348        QualifiedType( const QualifiedType & tq );
349        virtual ~QualifiedType();
350
351        virtual QualifiedType *clone() const override { return new QualifiedType( *this ); }
352        virtual void accept( Visitor & v ) override { v.visit( this ); }
353        virtual void accept( Visitor & v ) const override { v.visit( this ); }
354        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
355        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
356};
357
358class ReferenceType : public Type {
359public:
360        Type *base;
361
362        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
363        ReferenceType( const ReferenceType & );
364        virtual ~ReferenceType();
365
366        Type *get_base() { return base; }
367        void set_base( Type *newValue ) { base = newValue; }
368
369        virtual int referenceDepth() const override;
370
371        // Since reference types act like value types, their size is the size of the base.
372        // This makes it simple to cast the empty tuple to a reference type, since casts that increase
373        // the number of values are disallowed.
374        virtual unsigned size() const override { return base->size(); }
375
376        virtual TypeSubstitution genericSubstitution() const override;
377
378        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
379        virtual void accept( Visitor & v ) override { v.visit( this ); }
380        virtual void accept( Visitor & v ) const override { v.visit( this ); }
381        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
382        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
383};
384
385class FunctionType : public Type {
386  public:
387        std::list<DeclarationWithType*> returnVals;
388        std::list<DeclarationWithType*> parameters;
389
390        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
391        // This could be because of
392        // - an ellipsis in a prototype declaration
393        // - an unprototyped declaration
394        bool isVarArgs;
395
396        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
397        FunctionType( const FunctionType& );
398        virtual ~FunctionType();
399
400        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
401        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
402        bool get_isVarArgs() const { return isVarArgs; }
403        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
404        bool isTtype() const;
405
406        bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
407
408        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
409        virtual void accept( Visitor & v ) override { v.visit( this ); }
410        virtual void accept( Visitor & v ) const override { v.visit( this ); }
411        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
412        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
413};
414
415class ReferenceToType : public Type {
416  public:
417        std::list< Expression* > parameters;
418        std::string name;
419        bool hoistType;
420
421        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
422        ReferenceToType( const ReferenceToType & other );
423        virtual ~ReferenceToType();
424
425        const std::string & get_name() const { return name; }
426        void set_name( std::string newValue ) { name = newValue; }
427        std::list< Expression* >& get_parameters() { return parameters; }
428        bool get_hoistType() const { return hoistType; }
429        void set_hoistType( bool newValue ) { hoistType = newValue; }
430
431        virtual ReferenceToType *clone() const override = 0;
432        virtual void accept( Visitor & v ) override = 0;
433        virtual Type *acceptMutator( Mutator & m ) override = 0;
434        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
435
436        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
437  protected:
438        virtual std::string typeString() const = 0;
439};
440
441class StructInstType : public ReferenceToType {
442        typedef ReferenceToType Parent;
443  public:
444        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
445        // where the structure used in this type is actually defined
446        StructDecl *baseStruct;
447
448        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
449        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
450        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
451
452        StructDecl *get_baseStruct() const { return baseStruct; }
453        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
454
455        /// Accesses generic parameters of base struct (NULL if none such)
456        std::list<TypeDecl*> * get_baseParameters();
457        const std::list<TypeDecl*> * get_baseParameters() const;
458
459        virtual bool isComplete() const override;
460
461        virtual AggregateDecl * getAggr() const override;
462
463        virtual TypeSubstitution genericSubstitution() const override;
464
465        /// Looks up the members of this struct named "name" and places them into "foundDecls".
466        /// Clones declarations into "foundDecls", caller responsible for freeing
467        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
468
469        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
470        virtual void accept( Visitor & v ) override { v.visit( this ); }
471        virtual void accept( Visitor & v ) const override { v.visit( this ); }
472        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
473
474        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
475  private:
476        virtual std::string typeString() const override;
477};
478
479class UnionInstType : public ReferenceToType {
480        typedef ReferenceToType Parent;
481  public:
482        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
483        // where the union used in this type is actually defined
484        UnionDecl *baseUnion;
485
486        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
487        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
488        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
489
490        UnionDecl *get_baseUnion() const { return baseUnion; }
491        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
492
493        /// Accesses generic parameters of base union (NULL if none such)
494        std::list<TypeDecl*> * get_baseParameters();
495        const std::list<TypeDecl*> * get_baseParameters() const;
496
497        virtual bool isComplete() const override;
498
499        virtual AggregateDecl * getAggr() const override;
500
501        virtual TypeSubstitution genericSubstitution() const override;
502
503        /// looks up the members of this union named "name" and places them into "foundDecls"
504        /// Clones declarations into "foundDecls", caller responsible for freeing
505        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
506
507        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
508        virtual void accept( Visitor & v ) override { v.visit( this ); }
509        virtual void accept( Visitor & v ) const override { v.visit( this ); }
510        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
511
512        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
513  private:
514        virtual std::string typeString() const override;
515};
516
517class EnumInstType : public ReferenceToType {
518        typedef ReferenceToType Parent;
519  public:
520        // this decl is not "owned" by the enum inst; it is merely a pointer to elsewhere in the tree,
521        // where the enum used in this type is actually defined
522        EnumDecl *baseEnum = nullptr;
523
524        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
525        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
526        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
527
528        EnumDecl *get_baseEnum() const { return baseEnum; }
529        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
530
531        virtual bool isComplete() const override;
532
533        virtual AggregateDecl * getAggr() const override;
534
535        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
536        virtual void accept( Visitor & v ) override { v.visit( this ); }
537        virtual void accept( Visitor & v ) const override { v.visit( this ); }
538        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
539
540        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
541  private:
542        virtual std::string typeString() const override;
543};
544
545class TraitInstType : public ReferenceToType {
546        typedef ReferenceToType Parent;
547  public:
548        // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
549        // where the trait used in this type is actually defined
550        TraitDecl * baseTrait = nullptr;
551
552        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
553        TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
554        TraitInstType( const TraitInstType & other );
555        ~TraitInstType();
556
557        virtual bool isComplete() const override;
558
559        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
560        virtual void accept( Visitor & v ) override { v.visit( this ); }
561        virtual void accept( Visitor & v ) const override { v.visit( this ); }
562        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
563  private:
564        virtual std::string typeString() const override;
565};
566
567class TypeInstType : public ReferenceToType {
568        typedef ReferenceToType Parent;
569  public:
570        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
571        // where the type used here is actually defined
572        TypeDecl *baseType;
573        bool isFtype;
574
575        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
576        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
577        TypeInstType( const TypeInstType & other );
578        ~TypeInstType();
579
580        TypeDecl *get_baseType() const { return baseType; }
581        void set_baseType( TypeDecl *newValue );
582        bool get_isFtype() const { return isFtype; }
583        void set_isFtype( bool newValue ) { isFtype = newValue; }
584
585        virtual bool isComplete() const override;
586
587        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
588        virtual void accept( Visitor & v ) override { v.visit( this ); }
589        virtual void accept( Visitor & v ) const override { v.visit( this ); }
590        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
591        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
592  private:
593        virtual std::string typeString() const override;
594};
595
596class TupleType : public Type {
597  public:
598        std::list<Type *> types;
599        std::list<Declaration *> members;
600
601        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
602        TupleType( const TupleType& );
603        virtual ~TupleType();
604
605        typedef std::list<Type*> value_type;
606        typedef value_type::iterator iterator;
607
608        std::list<Type *> & get_types() { return types; }
609        virtual unsigned size() const override { return types.size(); };
610
611        // For now, this is entirely synthetic -- tuple types always have unnamed members.
612        // Eventually, we may allow named tuples, in which case members should subsume types
613        std::list<Declaration *> & get_members() { return members; }
614
615        iterator begin() { return types.begin(); }
616        iterator end() { return types.end(); }
617
618        virtual Type * getComponent( unsigned i ) override {
619                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
620                return *(begin()+i);
621        }
622
623        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
624
625        virtual TupleType *clone() const override { return new TupleType( *this ); }
626        virtual void accept( Visitor & v ) override { v.visit( this ); }
627        virtual void accept( Visitor & v ) const override { v.visit( this ); }
628        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
629        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
630};
631
632class TypeofType : public Type {
633  public:
634        Expression *expr;    ///< expression to take the type of
635        bool is_basetypeof;  ///< true iff is basetypeof type
636
637        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
638        TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
639                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
640        TypeofType( const TypeofType& );
641        virtual ~TypeofType();
642
643        Expression *get_expr() const { return expr; }
644        void set_expr( Expression *newValue ) { expr = newValue; }
645
646        virtual bool isComplete() const override { assert( false ); return false; }
647
648        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
649        virtual void accept( Visitor & v ) override { v.visit( this ); }
650        virtual void accept( Visitor & v ) const override { v.visit( this ); }
651        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
652        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
653};
654
655class VTableType : public Type {
656public:
657        Type *base;
658
659        VTableType( const Type::Qualifiers & tq, Type *base,
660                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
661        VTableType( const VTableType & );
662        virtual ~VTableType();
663
664        Type *get_base() { return base; }
665        void set_base( Type *newValue ) { base = newValue; }
666
667        virtual VTableType *clone() const override { return new VTableType( *this ); }
668        virtual void accept( Visitor & v ) override { v.visit( this ); }
669        virtual void accept( Visitor & v ) const override { v.visit( this ); }
670        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
671        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
672};
673
674class AttrType : public Type {
675  public:
676        std::string name;
677        Expression *expr;
678        Type *type;
679        bool isType;
680
681        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
682        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
683        AttrType( const AttrType& );
684        virtual ~AttrType();
685
686        const std::string & get_name() const { return name; }
687        void set_name( const std::string & newValue ) { name = newValue; }
688        Expression *get_expr() const { return expr; }
689        void set_expr( Expression *newValue ) { expr = newValue; }
690        Type *get_type() const { return type; }
691        void set_type( Type *newValue ) { type = newValue; }
692        bool get_isType() const { return isType; }
693        void set_isType( bool newValue ) { isType = newValue; }
694
695        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
696
697        virtual AttrType *clone() const override { return new AttrType( *this ); }
698        virtual void accept( Visitor & v ) override { v.visit( this ); }
699        virtual void accept( Visitor & v ) const override { v.visit( this ); }
700        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
701        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
702};
703
704/// Represents the GCC built-in varargs type
705class VarArgsType : public Type {
706  public:
707        VarArgsType();
708        VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
709
710        virtual bool isComplete() const override{ return true; } // xxx - is this right?
711
712        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
713        virtual void accept( Visitor & v ) override { v.visit( this ); }
714        virtual void accept( Visitor & v ) const override { v.visit( this ); }
715        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
716        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
717};
718
719/// Represents a zero constant
720class ZeroType : public Type {
721  public:
722        ZeroType();
723        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
724
725        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
726        virtual void accept( Visitor & v ) override { v.visit( this ); }
727        virtual void accept( Visitor & v ) const override { v.visit( this ); }
728        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
729        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
730};
731
732/// Represents a one constant
733class OneType : public Type {
734  public:
735        OneType();
736        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
737
738        virtual OneType *clone() const override { return new OneType( *this ); }
739        virtual void accept( Visitor & v ) override { v.visit( this ); }
740        virtual void accept( Visitor & v ) const override { v.visit( this ); }
741        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
742        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
743};
744
745class GlobalScopeType : public Type {
746  public:
747        GlobalScopeType();
748
749        virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
750        virtual void accept( Visitor & v ) override { v.visit( this ); }
751        virtual void accept( Visitor & v ) const override { v.visit( this ); }
752        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
753        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
754};
755
756
757bool isUnboundType(const Type * type);
758bool isUnboundType(const std::string & tname);
759
760// Local Variables: //
761// tab-width: 4 //
762// mode: c++ //
763// compile-command: "make install" //
764// End: //
Note: See TracBrowser for help on using the repository browser.