source: src/SynTree/Type.h@ 2890212

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 2890212 was 85dac33, checked in by Andrew Beach <ajbeach@…>, 6 years ago

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