source: src/SynTree/Type.h@ f53acdf8

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since f53acdf8 was 7870799, checked in by Thierry Delisle <tdelisle@…>, 6 years ago

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