source: src/SynTree/Type.h @ 2f42718

no_list
Last change on this file since 2f42718 was 2f42718, checked in by tdelisle <tdelisle@…>, 3 years ago

Parameters and return value of functions are now vectors (and some related clean-up)

  • Property mode set to 100644
File size: 27.9 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Type.h --
8//
9// Author           : Richard C. Bilson
10// Created On       : Mon May 18 07:44:20 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : 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::vector<DeclarationWithType*> returnVals;
362        std::vector<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        bool get_isVarArgs() const { return isVarArgs; }
375        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
376        bool isTtype() const;
377
378        bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
379
380        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
381        virtual void accept( Visitor & v ) override { v.visit( this ); }
382        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
383        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
384};
385
386class ReferenceToType : public Type {
387  public:
388        std::list< Expression* > parameters;
389        std::string name;
390        bool hoistType;
391
392        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes );
393        ReferenceToType( const ReferenceToType & other );
394        virtual ~ReferenceToType();
395
396        const std::string & get_name() const { return name; }
397        void set_name( std::string newValue ) { name = newValue; }
398        std::list< Expression* >& get_parameters() { return parameters; }
399        bool get_hoistType() const { return hoistType; }
400        void set_hoistType( bool newValue ) { hoistType = newValue; }
401
402        virtual ReferenceToType *clone() const override = 0;
403        virtual void accept( Visitor & v ) override = 0;
404        virtual Type *acceptMutator( Mutator & m ) override = 0;
405        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
406
407        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
408  protected:
409        virtual std::string typeString() const = 0;
410};
411
412class StructInstType : public ReferenceToType {
413        typedef ReferenceToType Parent;
414  public:
415        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
416        // where the structure used in this type is actually defined
417        StructDecl *baseStruct;
418
419        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
420        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
421        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
422
423        StructDecl *get_baseStruct() const { return baseStruct; }
424        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
425
426        /// Accesses generic parameters of base struct (NULL if none such)
427        std::list<TypeDecl*> * get_baseParameters();
428        const std::list<TypeDecl*> * get_baseParameters() const;
429
430        virtual bool isComplete() const override;
431
432        virtual AggregateDecl * getAggr() const override;
433
434        virtual TypeSubstitution genericSubstitution() const override;
435
436        /// Looks up the members of this struct named "name" and places them into "foundDecls".
437        /// Clones declarations into "foundDecls", caller responsible for freeing
438        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
439
440        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
441        virtual void accept( Visitor & v ) override { v.visit( this ); }
442        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
443
444        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
445  private:
446        virtual std::string typeString() const override;
447};
448
449class UnionInstType : public ReferenceToType {
450        typedef ReferenceToType Parent;
451  public:
452        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
453        // where the union used in this type is actually defined
454        UnionDecl *baseUnion;
455
456        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
457        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
458        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
459
460        UnionDecl *get_baseUnion() const { return baseUnion; }
461        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
462
463        /// Accesses generic parameters of base union (NULL if none such)
464        std::list<TypeDecl*> * get_baseParameters();
465        const std::list<TypeDecl*> * get_baseParameters() const;
466
467        virtual bool isComplete() const override;
468
469        virtual AggregateDecl * getAggr() const override;
470
471        virtual TypeSubstitution genericSubstitution() const override;
472
473        /// looks up the members of this union named "name" and places them into "foundDecls"
474        /// Clones declarations into "foundDecls", caller responsible for freeing
475        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
476
477        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
478        virtual void accept( Visitor & v ) override { v.visit( this ); }
479        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
480
481        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
482  private:
483        virtual std::string typeString() const override;
484};
485
486class EnumInstType : public ReferenceToType {
487        typedef ReferenceToType Parent;
488  public:
489        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
490        // where the union used in this type is actually defined
491        EnumDecl *baseEnum = nullptr;
492
493        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  ) : Parent( tq, name, attributes ) {}
494        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
495        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
496
497        EnumDecl *get_baseEnum() const { return baseEnum; }
498        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
499
500        virtual bool isComplete() const override;
501
502        virtual AggregateDecl * getAggr() const override;
503
504        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
505        virtual void accept( Visitor & v ) override { v.visit( this ); }
506        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
507
508        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
509  private:
510        virtual std::string typeString() const override;
511};
512
513class TraitInstType : public ReferenceToType {
514        typedef ReferenceToType Parent;
515  public:
516        // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
517        // where the trait used in this type is actually defined
518        TraitDecl * baseTrait = nullptr;
519
520        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() ) : Parent( tq, name, attributes ) {}
521        TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
522        TraitInstType( const TraitInstType & other );
523        ~TraitInstType();
524
525        virtual bool isComplete() const override;
526
527        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
528        virtual void accept( Visitor & v ) override { v.visit( this ); }
529        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
530  private:
531        virtual std::string typeString() const override;
532};
533
534class TypeInstType : public ReferenceToType {
535        typedef ReferenceToType Parent;
536  public:
537        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
538        // where the type used here is actually defined
539        TypeDecl *baseType;
540        bool isFtype;
541
542        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
543        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
544        TypeInstType( const TypeInstType & other );
545        ~TypeInstType();
546
547        TypeDecl *get_baseType() const { return baseType; }
548        void set_baseType( TypeDecl *newValue );
549        bool get_isFtype() const { return isFtype; }
550        void set_isFtype( bool newValue ) { isFtype = newValue; }
551
552        virtual bool isComplete() const override;
553
554        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
555        virtual void accept( Visitor & v ) override { v.visit( this ); }
556        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
557        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
558  private:
559        virtual std::string typeString() const override;
560};
561
562class TupleType : public Type {
563  public:
564        std::vector<Type *> types;
565        std::list<Declaration *> members;
566
567        TupleType( const Type::Qualifiers & tq, const std::vector< Type * > & types, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
568        TupleType( const TupleType& );
569        virtual ~TupleType();
570
571        typedef std::vector< Type * > value_type;
572        typedef value_type::iterator iterator;
573
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;    ///< expression to take the type of
599        bool is_basetypeof;  ///< true iff is basetypeof type
600
601        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
602        TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
603                const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
604        TypeofType( const TypeofType& );
605        virtual ~TypeofType();
606
607        Expression *get_expr() const { return expr; }
608        void set_expr( Expression *newValue ) { expr = newValue; }
609
610        virtual bool isComplete() const override { assert( false ); return false; }
611
612        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
613        virtual void accept( Visitor & v ) override { v.visit( this ); }
614        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
615        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
616};
617
618class AttrType : public Type {
619  public:
620        std::string name;
621        Expression *expr;
622        Type *type;
623        bool isType;
624
625        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::vector< Attribute * > & attributes = std::vector< Attribute * >() );
626        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
627        AttrType( const AttrType& );
628        virtual ~AttrType();
629
630        const std::string & get_name() const { return name; }
631        void set_name( const std::string & newValue ) { name = newValue; }
632        Expression *get_expr() const { return expr; }
633        void set_expr( Expression *newValue ) { expr = newValue; }
634        Type *get_type() const { return type; }
635        void set_type( Type *newValue ) { type = newValue; }
636        bool get_isType() const { return isType; }
637        void set_isType( bool newValue ) { isType = newValue; }
638
639        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
640
641        virtual AttrType *clone() const override { return new AttrType( *this ); }
642        virtual void accept( Visitor & v ) override { v.visit( this ); }
643        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
644        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
645};
646
647/// Represents the GCC built-in varargs type
648class VarArgsType : public Type {
649  public:
650        VarArgsType();
651        VarArgsType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
652
653        virtual bool isComplete() const override{ return true; } // xxx - is this right?
654
655        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
656        virtual void accept( Visitor & v ) override { v.visit( this ); }
657        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
658        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
659};
660
661/// Represents a zero constant
662class ZeroType : public Type {
663  public:
664        ZeroType();
665        ZeroType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
666
667        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
668        virtual void accept( Visitor & v ) override { v.visit( this ); }
669        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
670        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
671};
672
673/// Represents a one constant
674class OneType : public Type {
675  public:
676        OneType();
677        OneType( Type::Qualifiers tq, const std::vector< Attribute * > & attributes = std::vector< Attribute * >()  );
678
679        virtual OneType *clone() const override { return new OneType( *this ); }
680        virtual void accept( Visitor & v ) override { v.visit( this ); }
681        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
682        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
683};
684
685class GlobalScopeType : public Type {
686  public:
687        GlobalScopeType();
688
689        virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
690        virtual void accept( Visitor & v ) override { v.visit( this ); }
691        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
692        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
693};
694
695// Local Variables: //
696// tab-width: 4 //
697// mode: c++ //
698// compile-command: "make install" //
699// End: //
Note: See TracBrowser for help on using the repository browser.