source: src/SynTree/Type.h @ 7870799

arm-ehjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since 7870799 was 7870799, checked in by Thierry Delisle <tdelisle@…>, 3 years ago

Cast cost and conversion cost now take constant parameters.
This required supporting visiting const node.
The PassVisitor? can now visit const nodes but not when using the Indexer

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