source: src/SynTree/Type.h @ c194661

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprno_listpersistent-indexer
Last change on this file since c194661 was c194661, checked in by Rob Schluntz <rschlunt@…>, 4 years ago

Reorganize QualifiedType? node

  • Property mode set to 100644
File size: 27.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 : Mon Sep 25 14:14:01 2017
13// Update Count     : 154
14//
15
16#pragma once
17
18#include <strings.h>         // for ffs
19#include <cassert>           // for assert, assertf
20#include <list>              // for list, _List_iterator
21#include <ostream>           // for ostream, operator<<, basic_ostream
22#include <string>            // for string
23
24#include "BaseSyntaxNode.h"  // for BaseSyntaxNode
25#include "Common/utility.h"  // for operator+
26#include "Mutator.h"         // for Mutator
27#include "SynTree.h"         // for AST nodes
28#include "Visitor.h"         // for Visitor
29
30class Type : public BaseSyntaxNode {
31  public:
32        // Simulate inheritance because union does not allow it.
33        // Bug in g++-4.9 prevents static field in union
34        //static const char * Names[];
35        #define BFCommon( BFType, N ) \
36                bool operator[]( unsigned int i ) const { return val & (1 << i); } \
37                bool any() const { return val != 0; } \
38                void reset() { val = 0; } \
39                int ffs() { return ::ffs( val ) - 1; } \
40                BFType operator&=( BFType other ) { \
41                        val &= other.val; return *this; \
42                } \
43                BFType operator&( BFType other ) const { \
44                        BFType q = other; \
45                        q &= *this; \
46                        return q; \
47                } \
48                BFType operator|=( BFType other ) { \
49                        val |= other.val; return *this; \
50                } \
51                BFType operator|( BFType other ) const { \
52                        BFType q = other; \
53                        q |= *this; \
54                        return q; \
55                } \
56                BFType operator-=( BFType other ) { \
57                        val &= ~other.val; return *this; \
58                } \
59                void print( std::ostream & os ) const { \
60                        if ( (*this).any() ) { \
61                                for ( unsigned int i = 0; i < N; i += 1 ) { \
62                                        if ( (*this)[i] ) { \
63                                                os << BFType##Names[i] << ' '; \
64                                        } \
65                                } \
66                        } \
67                }
68
69        // enum must remain in the same order as the corresponding bit fields.
70
71        enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
72        static const char * FuncSpecifiersNames[];
73        union FuncSpecifiers {
74                unsigned int val;
75                struct {
76                        bool is_inline : 1;
77                        bool is_noreturn : 1;
78                        bool is_fortran : 1;
79                };
80                FuncSpecifiers() : val( 0 ) {}
81                FuncSpecifiers( unsigned int val ) : val( val ) {}
82                // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
83                BFCommon( FuncSpecifiers, NumFuncSpecifier )
84        }; // FuncSpecifiers
85
86        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
87        static const char * StorageClassesNames[];
88        union StorageClasses {
89                unsigned int val;
90                struct {
91                        bool is_extern : 1;
92                        bool is_static : 1;
93                        bool is_auto : 1;
94                        bool is_register : 1;
95                        bool is_threadlocal : 1;
96                };
97
98                StorageClasses() : val( 0 ) {}
99                StorageClasses( unsigned int val ) : val( val ) {}
100                // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
101                BFCommon( StorageClasses, NumStorageClass )
102        }; // StorageClasses
103
104        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
105        static const char * QualifiersNames[];
106        union Qualifiers {
107                enum { Mask = ~(Restrict | Lvalue) };
108                unsigned int val;
109                struct {
110                        bool is_const : 1;
111                        bool is_restrict : 1;
112                        bool is_volatile : 1;
113                        bool is_lvalue : 1;
114                        bool is_mutex : 1;
115                        bool is_atomic : 1;
116                };
117
118                Qualifiers() : val( 0 ) {}
119                Qualifiers( unsigned int val ) : val( val ) {}
120                // Complex comparisons provide implicit qualifier downcasting, e.g., T downcast to const T.
121                bool operator==( Qualifiers other ) const { return (val & Mask) == (other.val & Mask); }
122                bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
123                bool operator<=( Qualifiers other ) const {
124                        return is_const    <= other.is_const        //Any non-const converts to const without cost
125                                        && is_volatile <= other.is_volatile     //Any non-volatile converts to volatile without cost
126                                        && is_mutex    >= other.is_mutex        //Any mutex converts to non-mutex without cost
127                                        && is_atomic   == other.is_atomic;      //No conversion from atomic to non atomic is free
128                }
129                bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
130                bool operator>=( Qualifiers other ) const { return ! (*this < other); }
131                bool operator>( Qualifiers other ) const { return *this != other && *this >= other; }
132                BFCommon( Qualifiers, NumTypeQualifier )
133        }; // Qualifiers
134
135        typedef std::list<TypeDecl *> ForallList;
136
137        Qualifiers tq;
138        ForallList forall;
139        std::list< Attribute * > attributes;
140
141        Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
142        Type( const Type & other );
143        virtual ~Type();
144
145        Qualifiers & get_qualifiers() { return tq; }
146        bool get_const() { return tq.is_const; }
147        bool get_volatile() { return tq.is_volatile; }
148        bool get_restrict() { return tq.is_restrict; }
149        bool get_lvalue() { return tq.is_lvalue; }
150        bool get_mutex() { return tq.is_mutex; }
151        bool get_atomic() { return tq.is_atomic; }
152        void set_const( bool newValue ) { tq.is_const = newValue; }
153        void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
154        void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
155        void set_lvalue( bool newValue ) { tq.is_lvalue = newValue; }
156        void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
157        void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
158
159        ForallList& get_forall() { return forall; }
160
161        std::list< Attribute * >& get_attributes() { return attributes; }
162        const std::list< Attribute * >& get_attributes() const { return attributes; }
163
164        /// How many elemental types are represented by this type
165        virtual unsigned size() const { return 1; };
166        virtual bool isVoid() const { return size() == 0; }
167        virtual Type * getComponent( unsigned i ) { assertf( size() == 1 && i == 0, "Type::getComponent was called with size %d and index %d\n", size(), i ); return this; }
168
169        /// return type without outer pointers and arrays
170        Type * stripDeclarator();
171
172        /// return type without outer references
173        Type * stripReferences();
174
175        /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
176        virtual int referenceDepth() const;
177
178        virtual bool isComplete() const { return true; }
179
180        virtual AggregateDecl * getAggr() { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
181
182        virtual TypeSubstitution genericSubstitution() const;
183
184        virtual Type *clone() const = 0;
185        virtual void accept( Visitor & v ) = 0;
186        virtual Type *acceptMutator( Mutator & m ) = 0;
187        virtual void print( std::ostream & os, Indenter indent = {} ) const;
188};
189
190extern const Type::FuncSpecifiers noFuncSpecifiers;
191extern const Type::StorageClasses noStorageClasses;
192extern const Type::Qualifiers noQualifiers;                     // no qualifiers on constants
193
194class VoidType : public Type {
195  public:
196        VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
197
198        virtual unsigned size() const override { return 0; };
199        virtual bool isComplete() const override { return false; }
200
201        virtual VoidType *clone() const override { return new VoidType( *this ); }
202        virtual void accept( Visitor & v ) override { v.visit( this ); }
203        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
204        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
205};
206
207class BasicType : public Type {
208  public:
209        enum Kind {
210                Bool,
211                Char,
212                SignedChar,
213                UnsignedChar,
214                ShortSignedInt,
215                ShortUnsignedInt,
216                SignedInt,
217                UnsignedInt,
218                LongSignedInt,
219                LongUnsignedInt,
220                LongLongSignedInt,
221                LongLongUnsignedInt,
222                Float,
223                Double,
224                LongDouble,
225                FloatComplex,
226                DoubleComplex,
227                LongDoubleComplex,
228                FloatImaginary,
229                DoubleImaginary,
230                LongDoubleImaginary,
231                SignedInt128,
232                UnsignedInt128,
233                Float80,
234                Float128,
235                NUMBER_OF_BASIC_TYPES
236        } kind;
237
238        static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
239
240        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
241
242        Kind get_kind() { return kind; }
243        void set_kind( Kind newValue ) { kind = newValue; }
244
245        virtual BasicType *clone() const override { return new BasicType( *this ); }
246        virtual void accept( Visitor & v ) override { v.visit( this ); }
247        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
248        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
249
250        bool isInteger() const;
251};
252
253class PointerType : public Type {
254  public:
255        Type *base;
256
257        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
258        Expression *dimension;
259        bool isVarLen;
260        bool isStatic;
261
262        PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
263        PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
264        PointerType( const PointerType& );
265        virtual ~PointerType();
266
267        Type *get_base() { return base; }
268        void set_base( Type *newValue ) { base = newValue; }
269        Expression *get_dimension() { return dimension; }
270        void set_dimension( Expression *newValue ) { dimension = newValue; }
271        bool get_isVarLen() { return isVarLen; }
272        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
273        bool get_isStatic() { return isStatic; }
274        void set_isStatic( bool newValue ) { isStatic = newValue; }
275
276        bool is_array() const { return isStatic || isVarLen || dimension; }
277
278        virtual bool isComplete() const override { return ! isVarLen; }
279
280        virtual PointerType *clone() const override { return new PointerType( *this ); }
281        virtual void accept( Visitor & v ) override { v.visit( this ); }
282        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
283        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
284};
285
286class ArrayType : public Type {
287  public:
288        Type *base;
289        Expression *dimension;
290        bool isVarLen;
291        bool isStatic;
292
293        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
294        ArrayType( const ArrayType& );
295        virtual ~ArrayType();
296
297        Type *get_base() { return base; }
298        void set_base( Type *newValue ) { base = newValue; }
299        Expression *get_dimension() { return dimension; }
300        void set_dimension( Expression *newValue ) { dimension = newValue; }
301        bool get_isVarLen() { return isVarLen; }
302        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
303        bool get_isStatic() { return isStatic; }
304        void set_isStatic( bool newValue ) { isStatic = newValue; }
305
306        // array types are complete if they have a dimension expression or are
307        // VLAs ('*' in parameter declaration), and incomplete otherwise.
308        // See 6.7.6.2
309        virtual bool isComplete() const override { return dimension || isVarLen; }
310
311        virtual ArrayType *clone() const override { return new ArrayType( *this ); }
312        virtual void accept( Visitor & v ) override { v.visit( this ); }
313        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
314        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
315};
316
317class QualifiedType : public Type {
318public:
319        Type * parent;
320        Type * child;
321
322        QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child );
323        QualifiedType( const QualifiedType & tq );
324        virtual ~QualifiedType();
325
326        virtual QualifiedType *clone() const override { return new QualifiedType( *this ); }
327        virtual void accept( Visitor & v ) override { v.visit( this ); }
328        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
329        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
330};
331
332class ReferenceType : public Type {
333public:
334        Type *base;
335
336        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
337        ReferenceType( const ReferenceType & );
338        virtual ~ReferenceType();
339
340        Type *get_base() { return base; }
341        void set_base( Type *newValue ) { base = newValue; }
342
343        virtual int referenceDepth() const override;
344
345        // Since reference types act like value types, their size is the size of the base.
346        // This makes it simple to cast the empty tuple to a reference type, since casts that increase
347        // the number of values are disallowed.
348        virtual unsigned size() const override { return base->size(); }
349
350        virtual TypeSubstitution genericSubstitution() const override;
351
352        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
353        virtual void accept( Visitor & v ) 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 FunctionType : public Type {
359  public:
360        std::list<DeclarationWithType*> returnVals;
361        std::list<DeclarationWithType*> parameters;
362
363        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
364        // This could be because of
365        // - an ellipsis in a prototype declaration
366        // - an unprototyped declaration
367        bool isVarArgs;
368
369        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
370        FunctionType( const FunctionType& );
371        virtual ~FunctionType();
372
373        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
374        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
375        bool get_isVarArgs() const { return isVarArgs; }
376        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
377        bool isTtype() const;
378
379        bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
380
381        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
382        virtual void accept( Visitor & v ) override { v.visit( this ); }
383        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
384        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
385};
386
387class ReferenceToType : public Type {
388  public:
389        std::list< Expression* > parameters;
390        std::string name;
391        bool hoistType;
392
393        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
394        ReferenceToType( const ReferenceToType & other );
395        virtual ~ReferenceToType();
396
397        const std::string & get_name() const { return name; }
398        void set_name( std::string newValue ) { name = newValue; }
399        std::list< Expression* >& get_parameters() { return parameters; }
400        bool get_hoistType() const { return hoistType; }
401        void set_hoistType( bool newValue ) { hoistType = newValue; }
402
403        virtual ReferenceToType *clone() const override = 0;
404        virtual void accept( Visitor & v ) override = 0;
405        virtual Type *acceptMutator( Mutator & m ) override = 0;
406        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
407
408        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
409  protected:
410        virtual std::string typeString() const = 0;
411};
412
413class StructInstType : public ReferenceToType {
414        typedef ReferenceToType Parent;
415  public:
416        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
417        // where the structure used in this type is actually defined
418        StructDecl *baseStruct;
419
420        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
421        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
422        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
423
424        StructDecl *get_baseStruct() const { return baseStruct; }
425        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
426
427        /// Accesses generic parameters of base struct (NULL if none such)
428        std::list<TypeDecl*> * get_baseParameters();
429        const std::list<TypeDecl*> * get_baseParameters() const;
430
431        virtual bool isComplete() const override;
432
433        virtual AggregateDecl * getAggr() override;
434
435        virtual TypeSubstitution genericSubstitution() const override;
436
437        /// Looks up the members of this struct named "name" and places them into "foundDecls".
438        /// Clones declarations into "foundDecls", caller responsible for freeing
439        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
440
441        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
442        virtual void accept( Visitor & v ) override { v.visit( this ); }
443        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
444
445        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
446  private:
447        virtual std::string typeString() const override;
448};
449
450class UnionInstType : public ReferenceToType {
451        typedef ReferenceToType Parent;
452  public:
453        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
454        // where the union used in this type is actually defined
455        UnionDecl *baseUnion;
456
457        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
458        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
459        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
460
461        UnionDecl *get_baseUnion() const { return baseUnion; }
462        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
463
464        /// Accesses generic parameters of base union (NULL if none such)
465        std::list<TypeDecl*> * get_baseParameters();
466        const std::list<TypeDecl*> * get_baseParameters() const;
467
468        virtual bool isComplete() const override;
469
470        virtual AggregateDecl * getAggr() override;
471
472        virtual TypeSubstitution genericSubstitution() const override;
473
474        /// looks up the members of this union named "name" and places them into "foundDecls"
475        /// Clones declarations into "foundDecls", caller responsible for freeing
476        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
477
478        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
479        virtual void accept( Visitor & v ) override { v.visit( this ); }
480        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
481
482        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
483  private:
484        virtual std::string typeString() const override;
485};
486
487class EnumInstType : public ReferenceToType {
488        typedef ReferenceToType Parent;
489  public:
490        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
491        // where the union used in this type is actually defined
492        EnumDecl *baseEnum = nullptr;
493
494        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
495        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
496        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
497
498        EnumDecl *get_baseEnum() const { return baseEnum; }
499        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
500
501        virtual bool isComplete() const override;
502
503        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
504        virtual void accept( Visitor & v ) override { v.visit( this ); }
505        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
506
507        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
508  private:
509        virtual std::string typeString() const override;
510};
511
512class TraitInstType : public ReferenceToType {
513        typedef ReferenceToType Parent;
514  public:
515        // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
516        // where the trait used in this type is actually defined
517        TraitDecl * baseTrait = nullptr;
518
519        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
520        TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
521        TraitInstType( const TraitInstType & other );
522        ~TraitInstType();
523
524        virtual bool isComplete() const override;
525
526        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
527        virtual void accept( Visitor & v ) override { v.visit( this ); }
528        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
529  private:
530        virtual std::string typeString() const override;
531};
532
533class TypeInstType : public ReferenceToType {
534        typedef ReferenceToType Parent;
535  public:
536        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
537        // where the type used here is actually defined
538        TypeDecl *baseType;
539        bool isFtype;
540
541        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
542        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
543        TypeInstType( const TypeInstType & other );
544        ~TypeInstType();
545
546        TypeDecl *get_baseType() const { return baseType; }
547        void set_baseType( TypeDecl *newValue );
548        bool get_isFtype() const { return isFtype; }
549        void set_isFtype( bool newValue ) { isFtype = newValue; }
550
551        virtual bool isComplete() const override;
552
553        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
554        virtual void accept( Visitor & v ) override { v.visit( this ); }
555        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
556        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
557  private:
558        virtual std::string typeString() const override;
559};
560
561class TupleType : public Type {
562  public:
563        std::list<Type *> types;
564        std::list<Declaration *> members;
565
566        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
567        TupleType( const TupleType& );
568        virtual ~TupleType();
569
570        typedef std::list<Type*> value_type;
571        typedef value_type::iterator iterator;
572
573        std::list<Type *> & get_types() { return types; }
574        virtual unsigned size() const override { return types.size(); };
575
576        // For now, this is entirely synthetic -- tuple types always have unnamed members.
577        // Eventually, we may allow named tuples, in which case members should subsume types
578        std::list<Declaration *> & get_members() { return members; }
579
580        iterator begin() { return types.begin(); }
581        iterator end() { return types.end(); }
582
583        virtual Type * getComponent( unsigned i ) override {
584                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
585                return *(begin()+i);
586        }
587
588        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
589
590        virtual TupleType *clone() const override { return new TupleType( *this ); }
591        virtual void accept( Visitor & v ) override { v.visit( this ); }
592        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
593        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
594};
595
596class TypeofType : public Type {
597  public:
598        Expression *expr;
599
600        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
601        TypeofType( const TypeofType& );
602        virtual ~TypeofType();
603
604        Expression *get_expr() const { return expr; }
605        void set_expr( Expression *newValue ) { expr = newValue; }
606
607        virtual bool isComplete() const override { assert( false ); return false; }
608
609        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
610        virtual void accept( Visitor & v ) override { v.visit( this ); }
611        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
612        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
613};
614
615class AttrType : public Type {
616  public:
617        std::string name;
618        Expression *expr;
619        Type *type;
620        bool isType;
621
622        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
623        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
624        AttrType( const AttrType& );
625        virtual ~AttrType();
626
627        const std::string & get_name() const { return name; }
628        void set_name( const std::string & newValue ) { name = newValue; }
629        Expression *get_expr() const { return expr; }
630        void set_expr( Expression *newValue ) { expr = newValue; }
631        Type *get_type() const { return type; }
632        void set_type( Type *newValue ) { type = newValue; }
633        bool get_isType() const { return isType; }
634        void set_isType( bool newValue ) { isType = newValue; }
635
636        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
637
638        virtual AttrType *clone() const override { return new AttrType( *this ); }
639        virtual void accept( Visitor & v ) override { v.visit( this ); }
640        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
641        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
642};
643
644/// Represents the GCC built-in varargs type
645class VarArgsType : public Type {
646  public:
647        VarArgsType();
648        VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
649
650        virtual bool isComplete() const override{ return true; } // xxx - is this right?
651
652        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
653        virtual void accept( Visitor & v ) override { v.visit( this ); }
654        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
655        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
656};
657
658/// Represents a zero constant
659class ZeroType : public Type {
660  public:
661        ZeroType();
662        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
663
664        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
665        virtual void accept( Visitor & v ) override { v.visit( this ); }
666        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
667        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
668};
669
670/// Represents a one constant
671class OneType : public Type {
672  public:
673        OneType();
674        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
675
676        virtual OneType *clone() const override { return new OneType( *this ); }
677        virtual void accept( Visitor & v ) override { v.visit( this ); }
678        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
679        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
680};
681
682class GlobalScopeType : public Type {
683  public:
684        GlobalScopeType();
685
686        virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
687        virtual void accept( Visitor & v ) override { v.visit( this ); }
688        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
689        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
690};
691
692// Local Variables: //
693// tab-width: 4 //
694// mode: c++ //
695// compile-command: "make install" //
696// End: //
Note: See TracBrowser for help on using the repository browser.