source: src/SynTree/Type.h @ 4ee3b0c1

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerwith_gc
Last change on this file since 4ee3b0c1 was 4ee3b0c1, checked in by Rob Schluntz <rschlunt@…>, 4 years ago

Push float80/float128 through the system

  • Property mode set to 100644
File size: 26.7 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 ReferenceType : public Type {
318public:
319        Type *base;
320
321        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
322        ReferenceType( const ReferenceType & );
323        virtual ~ReferenceType();
324
325        Type *get_base() { return base; }
326        void set_base( Type *newValue ) { base = newValue; }
327
328        virtual int referenceDepth() const override;
329
330        // Since reference types act like value types, their size is the size of the base.
331        // This makes it simple to cast the empty tuple to a reference type, since casts that increase
332        // the number of values are disallowed.
333        virtual unsigned size() const override { return base->size(); }
334
335        virtual TypeSubstitution genericSubstitution() const override;
336
337        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
338        virtual void accept( Visitor & v ) override { v.visit( this ); }
339        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
340        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
341};
342
343class FunctionType : public Type {
344  public:
345        std::list<DeclarationWithType*> returnVals;
346        std::list<DeclarationWithType*> parameters;
347
348        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
349        // This could be because of
350        // - an ellipsis in a prototype declaration
351        // - an unprototyped declaration
352        bool isVarArgs;
353
354        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
355        FunctionType( const FunctionType& );
356        virtual ~FunctionType();
357
358        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
359        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
360        bool get_isVarArgs() const { return isVarArgs; }
361        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
362        bool isTtype() const;
363
364        bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
365
366        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
367        virtual void accept( Visitor & v ) override { v.visit( this ); }
368        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
369        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
370};
371
372class ReferenceToType : public Type {
373  public:
374        std::list< Expression* > parameters;
375        std::string name;
376        bool hoistType;
377
378        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
379        ReferenceToType( const ReferenceToType & other );
380        virtual ~ReferenceToType();
381
382        const std::string & get_name() const { return name; }
383        void set_name( std::string newValue ) { name = newValue; }
384        std::list< Expression* >& get_parameters() { return parameters; }
385        bool get_hoistType() const { return hoistType; }
386        void set_hoistType( bool newValue ) { hoistType = newValue; }
387
388        virtual ReferenceToType *clone() const override = 0;
389        virtual void accept( Visitor & v ) override = 0;
390        virtual Type *acceptMutator( Mutator & m ) override = 0;
391        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
392
393        virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
394  protected:
395        virtual std::string typeString() const = 0;
396};
397
398class StructInstType : public ReferenceToType {
399        typedef ReferenceToType Parent;
400  public:
401        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
402        // where the structure used in this type is actually defined
403        StructDecl *baseStruct;
404
405        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
406        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
407        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
408
409        StructDecl *get_baseStruct() const { return baseStruct; }
410        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
411
412        /// Accesses generic parameters of base struct (NULL if none such)
413        std::list<TypeDecl*> * get_baseParameters();
414        const std::list<TypeDecl*> * get_baseParameters() const;
415
416        virtual bool isComplete() const override;
417
418        virtual AggregateDecl * getAggr() override;
419
420        virtual TypeSubstitution genericSubstitution() const override;
421
422        /// Looks up the members of this struct named "name" and places them into "foundDecls".
423        /// Clones declarations into "foundDecls", caller responsible for freeing
424        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
425
426        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
427        virtual void accept( Visitor & v ) override { v.visit( this ); }
428        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
429
430        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
431  private:
432        virtual std::string typeString() const override;
433};
434
435class UnionInstType : public ReferenceToType {
436        typedef ReferenceToType Parent;
437  public:
438        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
439        // where the union used in this type is actually defined
440        UnionDecl *baseUnion;
441
442        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
443        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
444        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
445
446        UnionDecl *get_baseUnion() const { return baseUnion; }
447        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
448
449        /// Accesses generic parameters of base union (NULL if none such)
450        std::list<TypeDecl*> * get_baseParameters();
451        const std::list<TypeDecl*> * get_baseParameters() const;
452
453        virtual bool isComplete() const override;
454
455        virtual AggregateDecl * getAggr() override;
456
457        virtual TypeSubstitution genericSubstitution() const override;
458
459        /// looks up the members of this union named "name" and places them into "foundDecls"
460        /// Clones declarations into "foundDecls", caller responsible for freeing
461        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
462
463        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
464        virtual void accept( Visitor & v ) override { v.visit( this ); }
465        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
466
467        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
468  private:
469        virtual std::string typeString() const override;
470};
471
472class EnumInstType : public ReferenceToType {
473        typedef ReferenceToType Parent;
474  public:
475        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
476        // where the union used in this type is actually defined
477        EnumDecl *baseEnum = nullptr;
478
479        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
480        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
481        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
482
483        EnumDecl *get_baseEnum() const { return baseEnum; }
484        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
485
486        virtual bool isComplete() const override;
487
488        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
489        virtual void accept( Visitor & v ) override { v.visit( this ); }
490        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
491
492        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
493  private:
494        virtual std::string typeString() const override;
495};
496
497class TraitInstType : public ReferenceToType {
498        typedef ReferenceToType Parent;
499  public:
500        // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
501        // where the trait used in this type is actually defined
502        TraitDecl * baseTrait = nullptr;
503
504        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
505        TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
506        TraitInstType( const TraitInstType & other );
507        ~TraitInstType();
508
509        virtual bool isComplete() const override;
510
511        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
512        virtual void accept( Visitor & v ) override { v.visit( this ); }
513        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
514  private:
515        virtual std::string typeString() const override;
516};
517
518class TypeInstType : public ReferenceToType {
519        typedef ReferenceToType Parent;
520  public:
521        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
522        // where the type used here is actually defined
523        TypeDecl *baseType;
524        bool isFtype;
525
526        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
527        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
528        TypeInstType( const TypeInstType & other );
529        ~TypeInstType();
530
531        TypeDecl *get_baseType() const { return baseType; }
532        void set_baseType( TypeDecl *newValue );
533        bool get_isFtype() const { return isFtype; }
534        void set_isFtype( bool newValue ) { isFtype = newValue; }
535
536        virtual bool isComplete() const override;
537
538        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
539        virtual void accept( Visitor & v ) override { v.visit( this ); }
540        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
541        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
542  private:
543        virtual std::string typeString() const override;
544};
545
546class TupleType : public Type {
547  public:
548        std::list<Type *> types;
549        std::list<Declaration *> members;
550
551        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
552        TupleType( const TupleType& );
553        virtual ~TupleType();
554
555        typedef std::list<Type*> value_type;
556        typedef value_type::iterator iterator;
557
558        std::list<Type *> & get_types() { return types; }
559        virtual unsigned size() const override { return types.size(); };
560
561        // For now, this is entirely synthetic -- tuple types always have unnamed members.
562        // Eventually, we may allow named tuples, in which case members should subsume types
563        std::list<Declaration *> & get_members() { return members; }
564
565        iterator begin() { return types.begin(); }
566        iterator end() { return types.end(); }
567
568        virtual Type * getComponent( unsigned i ) override {
569                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
570                return *(begin()+i);
571        }
572
573        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
574
575        virtual TupleType *clone() const override { return new TupleType( *this ); }
576        virtual void accept( Visitor & v ) override { v.visit( this ); }
577        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
578        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
579};
580
581class TypeofType : public Type {
582  public:
583        Expression *expr;
584
585        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
586        TypeofType( const TypeofType& );
587        virtual ~TypeofType();
588
589        Expression *get_expr() const { return expr; }
590        void set_expr( Expression *newValue ) { expr = newValue; }
591
592        virtual bool isComplete() const override { assert( false ); return false; }
593
594        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
595        virtual void accept( Visitor & v ) override { v.visit( this ); }
596        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
597        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
598};
599
600class AttrType : public Type {
601  public:
602        std::string name;
603        Expression *expr;
604        Type *type;
605        bool isType;
606
607        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
608        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
609        AttrType( const AttrType& );
610        virtual ~AttrType();
611
612        const std::string & get_name() const { return name; }
613        void set_name( const std::string & newValue ) { name = newValue; }
614        Expression *get_expr() const { return expr; }
615        void set_expr( Expression *newValue ) { expr = newValue; }
616        Type *get_type() const { return type; }
617        void set_type( Type *newValue ) { type = newValue; }
618        bool get_isType() const { return isType; }
619        void set_isType( bool newValue ) { isType = newValue; }
620
621        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
622
623        virtual AttrType *clone() const override { return new AttrType( *this ); }
624        virtual void accept( Visitor & v ) override { v.visit( this ); }
625        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
626        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
627};
628
629/// Represents the GCC built-in varargs type
630class VarArgsType : public Type {
631  public:
632        VarArgsType();
633        VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
634
635        virtual bool isComplete() const override{ return true; } // xxx - is this right?
636
637        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
638        virtual void accept( Visitor & v ) override { v.visit( this ); }
639        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
640        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
641};
642
643/// Represents a zero constant
644class ZeroType : public Type {
645  public:
646        ZeroType();
647        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
648
649        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
650        virtual void accept( Visitor & v ) override { v.visit( this ); }
651        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
652        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
653};
654
655/// Represents a one constant
656class OneType : public Type {
657  public:
658        OneType();
659        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
660
661        virtual OneType *clone() const override { return new OneType( *this ); }
662        virtual void accept( Visitor & v ) override { v.visit( this ); }
663        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
664        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
665};
666
667// Local Variables: //
668// tab-width: 4 //
669// mode: c++ //
670// compile-command: "make install" //
671// End: //
Note: See TracBrowser for help on using the repository browser.