source: src/SynTree/Type.h@ 85d44c6

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr persistent-indexer pthread-emulation qualifiedEnum
Last change on this file since 85d44c6 was e15853c, checked in by Peter A. Buhr <pabuhr@…>, 7 years ago

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