source: src/SynTree/Type.h@ 699a97d

ADT ast-experimental
Last change on this file since 699a97d was 9feb34b, checked in by Andrew Beach <ajbeach@…>, 2 years ago

Moved toString and toCString to a new header. Updated includes. cassert was somehow getting instances of toString before but that stopped working so I embedded the new smaller include.
  • Property mode set to 100644
File size: 30.6 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Type.h --
8//
9// Author : Richard C. Bilson
10// Created On : Mon May 18 07:44:20 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Sun Feb 19 22:37:10 2023
13// Update Count : 176
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/Iterate.hpp"// 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, ThreadlocalGcc = 1 << 4, ThreadlocalC11 = 1 << 5, NumStorageClass = 6 };
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_threadlocalGcc : 1;
96 bool is_threadlocalC11 : 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
104 bool is_threadlocal_any() { return this->is_threadlocalC11 || this->is_threadlocalGcc; }
105 }; // StorageClasses
106
107 enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Mutex = 1 << 3, Atomic = 1 << 4, NumTypeQualifier = 5 };
108 static const char * QualifiersNames[];
109 union Qualifiers {
110 enum { Mask = ~Restrict };
111 unsigned int val;
112 struct {
113 bool is_const : 1;
114 bool is_restrict : 1;
115 bool is_volatile : 1;
116 bool is_mutex : 1;
117 bool is_atomic : 1;
118 };
119
120 Qualifiers() : val( 0 ) {}
121 Qualifiers( unsigned int val ) : val( val ) {}
122 // Complex comparisons provide implicit qualifier downcasting, e.g., T downcast to const T.
123 bool operator==( Qualifiers other ) const { return (val & Mask) == (other.val & Mask); }
124 bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
125 bool operator<=( Qualifiers other ) const {
126 return is_const <= other.is_const // Any non-const converts to const without cost
127 && is_volatile <= other.is_volatile // Any non-volatile converts to volatile without cost
128 && is_mutex >= other.is_mutex // Any mutex converts to non-mutex without cost
129 && is_atomic == other.is_atomic; // No conversion from atomic to non atomic is free
130 }
131 bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
132 bool operator>=( Qualifiers other ) const { return ! (*this < other); }
133 bool operator>( Qualifiers other ) const { return *this != other && *this >= other; }
134 BFCommon( Qualifiers, NumTypeQualifier )
135
136 Qualifiers unify( Qualifiers const & other ) const {
137 int or_flags = Mask & (val | other.val);
138 int and_flags = val & other.val;
139 return Qualifiers( or_flags | and_flags );
140 }
141 }; // Qualifiers
142
143 typedef std::list<TypeDecl *> ForallList;
144
145 Qualifiers tq;
146 ForallList forall;
147 std::list< Attribute * > attributes;
148
149 Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
150 Type( const Type & other );
151 virtual ~Type();
152
153 Qualifiers & get_qualifiers() { return tq; }
154 bool get_const() const { return tq.is_const; }
155 bool get_volatile() const { return tq.is_volatile; }
156 bool get_restrict() const { return tq.is_restrict; }
157 bool get_mutex() const { return tq.is_mutex; }
158 bool get_atomic() const { return tq.is_atomic; }
159 void set_const( bool newValue ) { tq.is_const = newValue; }
160 void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
161 void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
162 void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
163 void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
164
165 ForallList& get_forall() { return forall; }
166
167 std::list< Attribute * >& get_attributes() { return attributes; }
168 const std::list< Attribute * >& get_attributes() const { return attributes; }
169
170 /// How many elemental types are represented by this type
171 virtual unsigned size() const { return 1; };
172 virtual bool isVoid() const { return size() == 0; }
173 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; }
174
175 /// return type without outer pointers and arrays
176 Type * stripDeclarator();
177
178 /// return type without outer references
179 Type * stripReferences();
180 const Type * stripReferences() const;
181
182 /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
183 virtual int referenceDepth() const;
184
185 virtual bool isComplete() const { return true; }
186
187 virtual AggregateDecl * getAggr() const;
188
189 virtual TypeSubstitution genericSubstitution() const;
190
191 virtual Type * clone() const = 0;
192 virtual void accept( Visitor & v ) = 0;
193 virtual void accept( Visitor & v ) const = 0;
194 virtual Type * acceptMutator( Mutator & m ) = 0;
195 virtual void print( std::ostream & os, Indenter indent = {} ) const;
196};
197
198extern const Type::FuncSpecifiers noFuncSpecifiers;
199extern const Type::StorageClasses noStorageClasses;
200extern const Type::Qualifiers noQualifiers; // no qualifiers on constants
201
202class VoidType : public Type {
203 public:
204 VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
205
206 virtual unsigned size() const override { return 0; };
207 virtual bool isComplete() const override { return false; }
208
209 virtual VoidType * clone() const override { return new VoidType( *this ); }
210 virtual void accept( Visitor & v ) override { v.visit( this ); }
211 virtual void accept( Visitor & v ) const override { v.visit( this ); }
212 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
213 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
214};
215
216class BasicType : public Type {
217 public:
218 // GENERATED START, DO NOT EDIT
219 // GENERATED BY BasicTypes-gen.cc
220 enum Kind {
221 Bool,
222 Char,
223 SignedChar,
224 UnsignedChar,
225 ShortSignedInt,
226 ShortUnsignedInt,
227 SignedInt,
228 UnsignedInt,
229 LongSignedInt,
230 LongUnsignedInt,
231 LongLongSignedInt,
232 LongLongUnsignedInt,
233 SignedInt128,
234 UnsignedInt128,
235 uFloat16,
236 uFloat16Complex,
237 uFloat32,
238 uFloat32Complex,
239 Float,
240 FloatComplex,
241 uFloat32x,
242 uFloat32xComplex,
243 uFloat64,
244 uFloat64Complex,
245 Double,
246 DoubleComplex,
247 uFloat64x,
248 uFloat64xComplex,
249 uuFloat80,
250 uFloat128,
251 uFloat128Complex,
252 uuFloat128,
253 LongDouble,
254 LongDoubleComplex,
255 uFloat128x,
256 uFloat128xComplex,
257 NUMBER_OF_BASIC_TYPES
258 } kind;
259 // GENERATED END
260
261 static const char * typeNames[]; // string names for basic types, MUST MATCH with Kind
262
263 BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
264
265 Kind get_kind() const { return kind; }
266 void set_kind( Kind newValue ) { kind = newValue; }
267
268 virtual BasicType * clone() const override { return new BasicType( *this ); }
269 virtual void accept( Visitor & v ) override { v.visit( this ); }
270 virtual void accept( Visitor & v ) const override { v.visit( this ); }
271 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
272 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
273 bool isInteger() const;
274};
275
276class PointerType : public Type {
277 public:
278 Type * base;
279
280 // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
281 Expression * dimension;
282 bool isVarLen;
283 bool isStatic;
284
285 PointerType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
286 PointerType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
287 PointerType( const PointerType& );
288 virtual ~PointerType();
289
290 Type * get_base() { return base; }
291 void set_base( Type * newValue ) { base = newValue; }
292 Expression * get_dimension() { return dimension; }
293 void set_dimension( Expression * newValue ) { dimension = newValue; }
294 bool get_isVarLen() { return isVarLen; }
295 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
296 bool get_isStatic() { return isStatic; }
297 void set_isStatic( bool newValue ) { isStatic = newValue; }
298
299 bool is_array() const { return isStatic || isVarLen || dimension; }
300
301 virtual bool isComplete() const override { return ! isVarLen; }
302
303 virtual PointerType * clone() const override { return new PointerType( * this ); }
304 virtual void accept( Visitor & v ) override { v.visit( this ); }
305 virtual void accept( Visitor & v ) const override { v.visit( this ); }
306 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
307 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
308};
309
310class ArrayType : public Type {
311 public:
312 Type * base;
313 Expression * dimension;
314 bool isVarLen;
315 bool isStatic;
316
317 ArrayType( const Type::Qualifiers & tq, Type * base, Expression * dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
318 ArrayType( const ArrayType& );
319 virtual ~ArrayType();
320
321 Type * get_base() { return base; }
322 void set_base( Type * newValue ) { base = newValue; }
323 Expression * get_dimension() { return dimension; }
324 void set_dimension( Expression * newValue ) { dimension = newValue; }
325 bool get_isVarLen() { return isVarLen; }
326 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
327 bool get_isStatic() { return isStatic; }
328 void set_isStatic( bool newValue ) { isStatic = newValue; }
329
330 // array types are complete if they have a dimension expression or are
331 // VLAs ('*' in parameter declaration), and incomplete otherwise.
332 // See 6.7.6.2
333 virtual bool isComplete() const override { return dimension || isVarLen; }
334
335 virtual ArrayType * clone() const override { return new ArrayType( *this ); }
336 virtual void accept( Visitor & v ) override { v.visit( this ); }
337 virtual void accept( Visitor & v ) const override { v.visit( this ); }
338 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
339 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
340};
341
342class QualifiedType : public Type {
343public:
344 Type * parent;
345 Type * child;
346 QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child );
347 QualifiedType( const QualifiedType & tq );
348 virtual ~QualifiedType();
349
350 virtual QualifiedType * clone() const override { return new QualifiedType( *this ); }
351 virtual void accept( Visitor & v ) override { v.visit( this ); }
352 virtual void accept( Visitor & v ) const override { v.visit( this ); }
353 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
354 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
355};
356
357class ReferenceType : public Type {
358public:
359 Type * base;
360
361 ReferenceType( const Type::Qualifiers & tq, Type * base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
362 ReferenceType( const ReferenceType & );
363 virtual ~ReferenceType();
364
365 Type * get_base() { return base; }
366 void set_base( Type * newValue ) { base = newValue; }
367
368 virtual int referenceDepth() const override;
369
370 // Since reference types act like value types, their size is the size of the base.
371 // This makes it simple to cast the empty tuple to a reference type, since casts that increase
372 // the number of values are disallowed.
373 virtual unsigned size() const override { return base->size(); }
374
375 virtual TypeSubstitution genericSubstitution() const override;
376
377 virtual ReferenceType * clone() const override { return new ReferenceType( *this ); }
378 virtual void accept( Visitor & v ) override { v.visit( this ); }
379 virtual void accept( Visitor & v ) const override { v.visit( this ); }
380 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
381 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
382};
383
384class FunctionType : public Type {
385 public:
386 std::list<DeclarationWithType*> returnVals;
387 std::list<DeclarationWithType*> parameters;
388
389 // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
390 // This could be because of
391 // - an ellipsis in a prototype declaration
392 // - an unprototyped declaration
393 bool isVarArgs;
394
395 FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
396 FunctionType( const FunctionType& );
397 virtual ~FunctionType();
398
399 std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
400 std::list<DeclarationWithType*> & get_parameters() { return parameters; }
401 bool get_isVarArgs() const { return isVarArgs; }
402 void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
403 bool isTtype() const;
404
405 bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
406
407 virtual FunctionType * clone() const override { return new FunctionType( *this ); }
408 virtual void accept( Visitor & v ) override { v.visit( this ); }
409 virtual void accept( Visitor & v ) const override { v.visit( this ); }
410 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
411 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
412};
413
414class ReferenceToType : public Type {
415 public:
416 std::list< Expression * > parameters;
417 std::string name;
418 bool hoistType;
419
420 ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
421 ReferenceToType( const ReferenceToType & other );
422 virtual ~ReferenceToType();
423
424 const std::string & get_name() const { return name; }
425 void set_name( std::string newValue ) { name = newValue; }
426 std::list< Expression* >& get_parameters() { return parameters; }
427 bool get_hoistType() const { return hoistType; }
428 void set_hoistType( bool newValue ) { hoistType = newValue; }
429
430 virtual ReferenceToType * clone() const override = 0;
431 virtual void accept( Visitor & v ) override = 0;
432 virtual Type * acceptMutator( Mutator & m ) override = 0;
433 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
434
435 virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
436 protected:
437 virtual std::string typeString() const = 0;
438};
439
440class StructInstType : public ReferenceToType {
441 typedef ReferenceToType Parent;
442 public:
443 // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
444 // where the structure used in this type is actually defined
445 StructDecl * baseStruct;
446
447 StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
448 StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
449 StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
450
451 StructDecl * get_baseStruct() const { return baseStruct; }
452 void set_baseStruct( StructDecl * newValue ) { baseStruct = newValue; }
453
454 /// Accesses generic parameters of base struct (NULL if none such)
455 std::list<TypeDecl*> * get_baseParameters();
456 const std::list<TypeDecl*> * get_baseParameters() const;
457
458 virtual bool isComplete() const override;
459
460 virtual AggregateDecl * getAggr() const override;
461
462 virtual TypeSubstitution genericSubstitution() const override;
463
464 /// Looks up the members of this struct named "name" and places them into "foundDecls".
465 /// Clones declarations into "foundDecls", caller responsible for freeing
466 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
467
468 virtual StructInstType * clone() const override { return new StructInstType( *this ); }
469 virtual void accept( Visitor & v ) override { v.visit( this ); }
470 virtual void accept( Visitor & v ) const override { v.visit( this ); }
471 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
472
473 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
474 private:
475 virtual std::string typeString() const override;
476};
477
478class UnionInstType : public ReferenceToType {
479 typedef ReferenceToType Parent;
480 public:
481 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
482 // where the union used in this type is actually defined
483 UnionDecl * baseUnion;
484
485 UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
486 UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
487 UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
488
489 UnionDecl * get_baseUnion() const { return baseUnion; }
490 void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
491
492 /// Accesses generic parameters of base union (NULL if none such)
493 std::list<TypeDecl*> * get_baseParameters();
494 const std::list<TypeDecl*> * get_baseParameters() const;
495
496 virtual bool isComplete() const override;
497
498 virtual AggregateDecl * getAggr() const override;
499
500 virtual TypeSubstitution genericSubstitution() const override;
501
502 /// looks up the members of this union named "name" and places them into "foundDecls"
503 /// Clones declarations into "foundDecls", caller responsible for freeing
504 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
505
506 virtual UnionInstType * clone() const override { return new UnionInstType( *this ); }
507 virtual void accept( Visitor & v ) override { v.visit( this ); }
508 virtual void accept( Visitor & v ) const override { v.visit( this ); }
509 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
510
511 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
512 private:
513 virtual std::string typeString() const override;
514};
515
516class EnumInstType : public ReferenceToType {
517 typedef ReferenceToType Parent;
518 public:
519 // this decl is not "owned" by the enum inst; it is merely a pointer to elsewhere in the tree,
520 // where the enum used in this type is actually defined
521 EnumDecl * baseEnum = nullptr;
522
523 EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
524 EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
525 EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
526
527 EnumDecl * get_baseEnum() const { return baseEnum; }
528 void set_baseEnum( EnumDecl * newValue ) { baseEnum = newValue; }
529
530 virtual bool isComplete() const override;
531
532 virtual AggregateDecl * getAggr() const override;
533
534 virtual EnumInstType * clone() const override { return new EnumInstType( *this ); }
535 virtual void accept( Visitor & v ) override { v.visit( this ); }
536 virtual void accept( Visitor & v ) const override { v.visit( this ); }
537 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
538
539 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
540 private:
541 virtual std::string typeString() const override;
542};
543
544class TraitInstType : public ReferenceToType {
545 typedef ReferenceToType Parent;
546 public:
547 // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
548 // where the trait used in this type is actually defined
549 TraitDecl * baseTrait = nullptr;
550
551 TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
552 TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
553 TraitInstType( const TraitInstType & other );
554 ~TraitInstType();
555
556 virtual bool isComplete() const override;
557
558 virtual TraitInstType * clone() const override { return new TraitInstType( *this ); }
559 virtual void accept( Visitor & v ) override { v.visit( this ); }
560 virtual void accept( Visitor & v ) const override { v.visit( this ); }
561 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
562 private:
563 virtual std::string typeString() const override;
564};
565
566class TypeInstType : public ReferenceToType {
567 typedef ReferenceToType Parent;
568 public:
569 // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
570 // where the type used here is actually defined
571 TypeDecl * baseType;
572 bool isFtype;
573
574 TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl * baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
575 TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
576 TypeInstType( const TypeInstType & other );
577 ~TypeInstType();
578
579 TypeDecl * get_baseType() const { return baseType; }
580 void set_baseType( TypeDecl * newValue );
581 bool get_isFtype() const { return isFtype; }
582 void set_isFtype( bool newValue ) { isFtype = newValue; }
583
584 virtual bool isComplete() const override;
585
586 virtual TypeInstType * clone() const override { return new TypeInstType( *this ); }
587 virtual void accept( Visitor & v ) override { v.visit( this ); }
588 virtual void accept( Visitor & v ) const override { v.visit( this ); }
589 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
590 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
591 private:
592 virtual std::string typeString() const override;
593};
594
595class TupleType : public Type {
596 public:
597 std::list<Type *> types;
598 std::list<Declaration *> members;
599
600 TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
601 TupleType( const TupleType& );
602 virtual ~TupleType();
603
604 typedef std::list<Type*> value_type;
605 typedef value_type::iterator iterator;
606
607 std::list<Type *> & get_types() { return types; }
608 virtual unsigned size() const override { return types.size(); };
609
610 // For now, this is entirely synthetic -- tuple types always have unnamed members.
611 // Eventually, we may allow named tuples, in which case members should subsume types
612 std::list<Declaration *> & get_members() { return members; }
613
614 iterator begin() { return types.begin(); }
615 iterator end() { return types.end(); }
616
617 virtual Type * getComponent( unsigned i ) override {
618 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
619 return *(begin()+i);
620 }
621
622 // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
623
624 virtual TupleType * clone() const override { return new TupleType( *this ); }
625 virtual void accept( Visitor & v ) override { v.visit( this ); }
626 virtual void accept( Visitor & v ) const override { v.visit( this ); }
627 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
628 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
629};
630
631class TypeofType : public Type {
632 public:
633 Expression * expr; ///< expression to take the type of
634 bool is_basetypeof; ///< true iff is basetypeof type
635
636 TypeofType( const Type::Qualifiers & tq, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
637 TypeofType( const Type::Qualifiers & tq, Expression * expr, bool is_basetypeof,
638 const std::list< Attribute * > & attributes = std::list< Attribute * >() );
639 TypeofType( const TypeofType& );
640 virtual ~TypeofType();
641
642 Expression * get_expr() const { return expr; }
643 void set_expr( Expression * newValue ) { expr = newValue; }
644
645 virtual bool isComplete() const override { assert( false ); return false; }
646
647 virtual TypeofType * clone() const override { return new TypeofType( *this ); }
648 virtual void accept( Visitor & v ) override { v.visit( this ); }
649 virtual void accept( Visitor & v ) const override { v.visit( this ); }
650 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
651 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
652};
653
654class VTableType : public Type {
655public:
656 Type * base;
657
658 VTableType( const Type::Qualifiers & tq, Type * base,
659 const std::list< Attribute * > & attributes = std::list< Attribute * >() );
660 VTableType( const VTableType & );
661 virtual ~VTableType();
662
663 Type * get_base() { return base; }
664 void set_base( Type * newValue ) { base = newValue; }
665
666 virtual VTableType * clone() const override { return new VTableType( *this ); }
667 virtual void accept( Visitor & v ) override { v.visit( this ); }
668 virtual void accept( Visitor & v ) const 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
673class AttrType : public Type {
674 public:
675 std::string name;
676 Expression * expr;
677 Type * type;
678 bool isType;
679
680 AttrType( const Type::Qualifiers & tq, const std::string & name, Expression * expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
681 AttrType( const Type::Qualifiers & tq, const std::string & name, Type * type, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
682 AttrType( const AttrType& );
683 virtual ~AttrType();
684
685 const std::string & get_name() const { return name; }
686 void set_name( const std::string & newValue ) { name = newValue; }
687 Expression * get_expr() const { return expr; }
688 void set_expr( Expression * newValue ) { expr = newValue; }
689 Type * get_type() const { return type; }
690 void set_type( Type * newValue ) { type = newValue; }
691 bool get_isType() const { return isType; }
692 void set_isType( bool newValue ) { isType = newValue; }
693
694 virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
695
696 virtual AttrType * clone() const override { return new AttrType( *this ); }
697 virtual void accept( Visitor & v ) override { v.visit( this ); }
698 virtual void accept( Visitor & v ) const override { v.visit( this ); }
699 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
700 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
701};
702
703/// Represents the GCC built-in varargs type
704class VarArgsType : public Type {
705 public:
706 VarArgsType();
707 VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
708
709 virtual bool isComplete() const override{ return true; } // xxx - is this right?
710
711 virtual VarArgsType * clone() const override { return new VarArgsType( *this ); }
712 virtual void accept( Visitor & v ) override { v.visit( this ); }
713 virtual void accept( Visitor & v ) const override { v.visit( this ); }
714 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
715 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
716};
717
718/// Represents a zero constant
719class ZeroType : public Type {
720 public:
721 ZeroType();
722 ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
723
724 virtual ZeroType * clone() const override { return new ZeroType( *this ); }
725 virtual void accept( Visitor & v ) override { v.visit( this ); }
726 virtual void accept( Visitor & v ) const override { v.visit( this ); }
727 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
728 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
729};
730
731/// Represents a one constant
732class OneType : public Type {
733 public:
734 OneType();
735 OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
736
737 virtual OneType * clone() const override { return new OneType( *this ); }
738 virtual void accept( Visitor & v ) override { v.visit( this ); }
739 virtual void accept( Visitor & v ) const override { v.visit( this ); }
740 virtual Type * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
741 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
742};
743
744class GlobalScopeType : public Type {
745 public:
746 GlobalScopeType();
747
748 virtual GlobalScopeType * clone() const override { return new GlobalScopeType( *this ); }
749 virtual void accept( Visitor & v ) override { v.visit( this ); }
750 virtual void accept( Visitor & v ) const 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
756bool isUnboundType(const Type * type);
757bool isUnboundType(const std::string & tname);
758
759// Local Variables: //
760// tab-width: 4 //
761// mode: c++ //
762// compile-command: "make install" //
763// End: //
Note: See TracBrowser for help on using the repository browser.