source: src/SynTree/Type.h @ 80eefcb

no_list
Last change on this file since 80eefcb was 80eefcb, checked in by Thierry Delisle <tdelisle@…>, 3 years ago

Forall list now uses vector

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