source: src/SynTree/Type.h @ e15853c

aaron-thesisarm-ehcleanup-dtorsenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprpersistent-indexerpthread-emulationqualifiedEnum
Last change on this file since e15853c was e15853c, checked in by Peter A. Buhr <pabuhr@…>, 4 years ago

remove leading underscores in enums for _FloatNN and _Bool

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