source: src/SynTree/Type.h@ c194661

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr no_list persistent-indexer pthread-emulation qualifiedEnum stuck-waitfor-destruct
Last change on this file since c194661 was c194661, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

Reorganize QualifiedType node
  • Property mode set to 100644
File size: 27.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 : Mon Sep 25 14:14:01 2017
13// Update Count : 154
14//
15
16#pragma once
17
18#include <strings.h> // for ffs
19#include <cassert> // for assert, assertf
20#include <list> // for list, _List_iterator
21#include <ostream> // for ostream, operator<<, basic_ostream
22#include <string> // for string
23
24#include "BaseSyntaxNode.h" // for BaseSyntaxNode
25#include "Common/utility.h" // for operator+
26#include "Mutator.h" // for Mutator
27#include "SynTree.h" // for AST nodes
28#include "Visitor.h" // for Visitor
29
30class Type : public BaseSyntaxNode {
31 public:
32 // Simulate inheritance because union does not allow it.
33 // Bug in g++-4.9 prevents static field in union
34 //static const char * Names[];
35 #define BFCommon( BFType, N ) \
36 bool operator[]( unsigned int i ) const { return val & (1 << i); } \
37 bool any() const { return val != 0; } \
38 void reset() { val = 0; } \
39 int ffs() { return ::ffs( val ) - 1; } \
40 BFType operator&=( BFType other ) { \
41 val &= other.val; return *this; \
42 } \
43 BFType operator&( BFType other ) const { \
44 BFType q = other; \
45 q &= *this; \
46 return q; \
47 } \
48 BFType operator|=( BFType other ) { \
49 val |= other.val; return *this; \
50 } \
51 BFType operator|( BFType other ) const { \
52 BFType q = other; \
53 q |= *this; \
54 return q; \
55 } \
56 BFType operator-=( BFType other ) { \
57 val &= ~other.val; return *this; \
58 } \
59 void print( std::ostream & os ) const { \
60 if ( (*this).any() ) { \
61 for ( unsigned int i = 0; i < N; i += 1 ) { \
62 if ( (*this)[i] ) { \
63 os << BFType##Names[i] << ' '; \
64 } \
65 } \
66 } \
67 }
68
69 // enum must remain in the same order as the corresponding bit fields.
70
71 enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
72 static const char * FuncSpecifiersNames[];
73 union FuncSpecifiers {
74 unsigned int val;
75 struct {
76 bool is_inline : 1;
77 bool is_noreturn : 1;
78 bool is_fortran : 1;
79 };
80 FuncSpecifiers() : val( 0 ) {}
81 FuncSpecifiers( unsigned int val ) : val( val ) {}
82 // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
83 BFCommon( FuncSpecifiers, NumFuncSpecifier )
84 }; // FuncSpecifiers
85
86 enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
87 static const char * StorageClassesNames[];
88 union StorageClasses {
89 unsigned int val;
90 struct {
91 bool is_extern : 1;
92 bool is_static : 1;
93 bool is_auto : 1;
94 bool is_register : 1;
95 bool is_threadlocal : 1;
96 };
97
98 StorageClasses() : val( 0 ) {}
99 StorageClasses( unsigned int val ) : val( val ) {}
100 // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
101 BFCommon( StorageClasses, NumStorageClass )
102 }; // StorageClasses
103
104 enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
105 static const char * QualifiersNames[];
106 union Qualifiers {
107 enum { Mask = ~(Restrict | Lvalue) };
108 unsigned int val;
109 struct {
110 bool is_const : 1;
111 bool is_restrict : 1;
112 bool is_volatile : 1;
113 bool is_lvalue : 1;
114 bool is_mutex : 1;
115 bool is_atomic : 1;
116 };
117
118 Qualifiers() : val( 0 ) {}
119 Qualifiers( unsigned int val ) : val( val ) {}
120 // Complex comparisons provide implicit qualifier downcasting, e.g., T downcast to const T.
121 bool operator==( Qualifiers other ) const { return (val & Mask) == (other.val & Mask); }
122 bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
123 bool operator<=( Qualifiers other ) const {
124 return is_const <= other.is_const //Any non-const converts to const without cost
125 && is_volatile <= other.is_volatile //Any non-volatile converts to volatile without cost
126 && is_mutex >= other.is_mutex //Any mutex converts to non-mutex without cost
127 && is_atomic == other.is_atomic; //No conversion from atomic to non atomic is free
128 }
129 bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
130 bool operator>=( Qualifiers other ) const { return ! (*this < other); }
131 bool operator>( Qualifiers other ) const { return *this != other && *this >= other; }
132 BFCommon( Qualifiers, NumTypeQualifier )
133 }; // Qualifiers
134
135 typedef std::list<TypeDecl *> ForallList;
136
137 Qualifiers tq;
138 ForallList forall;
139 std::list< Attribute * > attributes;
140
141 Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
142 Type( const Type & other );
143 virtual ~Type();
144
145 Qualifiers & get_qualifiers() { return tq; }
146 bool get_const() { return tq.is_const; }
147 bool get_volatile() { return tq.is_volatile; }
148 bool get_restrict() { return tq.is_restrict; }
149 bool get_lvalue() { return tq.is_lvalue; }
150 bool get_mutex() { return tq.is_mutex; }
151 bool get_atomic() { return tq.is_atomic; }
152 void set_const( bool newValue ) { tq.is_const = newValue; }
153 void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
154 void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
155 void set_lvalue( bool newValue ) { tq.is_lvalue = newValue; }
156 void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
157 void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
158
159 ForallList& get_forall() { return forall; }
160
161 std::list< Attribute * >& get_attributes() { return attributes; }
162 const std::list< Attribute * >& get_attributes() const { return attributes; }
163
164 /// How many elemental types are represented by this type
165 virtual unsigned size() const { return 1; };
166 virtual bool isVoid() const { return size() == 0; }
167 virtual Type * getComponent( unsigned i ) { assertf( size() == 1 && i == 0, "Type::getComponent was called with size %d and index %d\n", size(), i ); return this; }
168
169 /// return type without outer pointers and arrays
170 Type * stripDeclarator();
171
172 /// return type without outer references
173 Type * stripReferences();
174
175 /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
176 virtual int referenceDepth() const;
177
178 virtual bool isComplete() const { return true; }
179
180 virtual AggregateDecl * getAggr() { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
181
182 virtual TypeSubstitution genericSubstitution() const;
183
184 virtual Type *clone() const = 0;
185 virtual void accept( Visitor & v ) = 0;
186 virtual Type *acceptMutator( Mutator & m ) = 0;
187 virtual void print( std::ostream & os, Indenter indent = {} ) const;
188};
189
190extern const Type::FuncSpecifiers noFuncSpecifiers;
191extern const Type::StorageClasses noStorageClasses;
192extern const Type::Qualifiers noQualifiers; // no qualifiers on constants
193
194class VoidType : public Type {
195 public:
196 VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
197
198 virtual unsigned size() const override { return 0; };
199 virtual bool isComplete() const override { return false; }
200
201 virtual VoidType *clone() const override { return new VoidType( *this ); }
202 virtual void accept( Visitor & v ) override { v.visit( this ); }
203 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
204 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
205};
206
207class BasicType : public Type {
208 public:
209 enum Kind {
210 Bool,
211 Char,
212 SignedChar,
213 UnsignedChar,
214 ShortSignedInt,
215 ShortUnsignedInt,
216 SignedInt,
217 UnsignedInt,
218 LongSignedInt,
219 LongUnsignedInt,
220 LongLongSignedInt,
221 LongLongUnsignedInt,
222 Float,
223 Double,
224 LongDouble,
225 FloatComplex,
226 DoubleComplex,
227 LongDoubleComplex,
228 FloatImaginary,
229 DoubleImaginary,
230 LongDoubleImaginary,
231 SignedInt128,
232 UnsignedInt128,
233 Float80,
234 Float128,
235 NUMBER_OF_BASIC_TYPES
236 } kind;
237
238 static const char *typeNames[]; // string names for basic types, MUST MATCH with Kind
239
240 BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
241
242 Kind get_kind() { return kind; }
243 void set_kind( Kind newValue ) { kind = newValue; }
244
245 virtual BasicType *clone() const override { return new BasicType( *this ); }
246 virtual void accept( Visitor & v ) override { v.visit( this ); }
247 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
248 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
249
250 bool isInteger() const;
251};
252
253class PointerType : public Type {
254 public:
255 Type *base;
256
257 // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
258 Expression *dimension;
259 bool isVarLen;
260 bool isStatic;
261
262 PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
263 PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
264 PointerType( const PointerType& );
265 virtual ~PointerType();
266
267 Type *get_base() { return base; }
268 void set_base( Type *newValue ) { base = newValue; }
269 Expression *get_dimension() { return dimension; }
270 void set_dimension( Expression *newValue ) { dimension = newValue; }
271 bool get_isVarLen() { return isVarLen; }
272 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
273 bool get_isStatic() { return isStatic; }
274 void set_isStatic( bool newValue ) { isStatic = newValue; }
275
276 bool is_array() const { return isStatic || isVarLen || dimension; }
277
278 virtual bool isComplete() const override { return ! isVarLen; }
279
280 virtual PointerType *clone() const override { return new PointerType( *this ); }
281 virtual void accept( Visitor & v ) override { v.visit( this ); }
282 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
283 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
284};
285
286class ArrayType : public Type {
287 public:
288 Type *base;
289 Expression *dimension;
290 bool isVarLen;
291 bool isStatic;
292
293 ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
294 ArrayType( const ArrayType& );
295 virtual ~ArrayType();
296
297 Type *get_base() { return base; }
298 void set_base( Type *newValue ) { base = newValue; }
299 Expression *get_dimension() { return dimension; }
300 void set_dimension( Expression *newValue ) { dimension = newValue; }
301 bool get_isVarLen() { return isVarLen; }
302 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
303 bool get_isStatic() { return isStatic; }
304 void set_isStatic( bool newValue ) { isStatic = newValue; }
305
306 // array types are complete if they have a dimension expression or are
307 // VLAs ('*' in parameter declaration), and incomplete otherwise.
308 // See 6.7.6.2
309 virtual bool isComplete() const override { return dimension || isVarLen; }
310
311 virtual ArrayType *clone() const override { return new ArrayType( *this ); }
312 virtual void accept( Visitor & v ) override { v.visit( this ); }
313 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
314 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
315};
316
317class QualifiedType : public Type {
318public:
319 Type * parent;
320 Type * child;
321
322 QualifiedType( const Type::Qualifiers & tq, Type * parent, Type * child );
323 QualifiedType( const QualifiedType & tq );
324 virtual ~QualifiedType();
325
326 virtual QualifiedType *clone() const override { return new QualifiedType( *this ); }
327 virtual void accept( Visitor & v ) override { v.visit( this ); }
328 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
329 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
330};
331
332class ReferenceType : public Type {
333public:
334 Type *base;
335
336 ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
337 ReferenceType( const ReferenceType & );
338 virtual ~ReferenceType();
339
340 Type *get_base() { return base; }
341 void set_base( Type *newValue ) { base = newValue; }
342
343 virtual int referenceDepth() const override;
344
345 // Since reference types act like value types, their size is the size of the base.
346 // This makes it simple to cast the empty tuple to a reference type, since casts that increase
347 // the number of values are disallowed.
348 virtual unsigned size() const override { return base->size(); }
349
350 virtual TypeSubstitution genericSubstitution() const override;
351
352 virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
353 virtual void accept( Visitor & v ) override { v.visit( this ); }
354 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
355 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
356};
357
358class FunctionType : public Type {
359 public:
360 std::list<DeclarationWithType*> returnVals;
361 std::list<DeclarationWithType*> parameters;
362
363 // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
364 // This could be because of
365 // - an ellipsis in a prototype declaration
366 // - an unprototyped declaration
367 bool isVarArgs;
368
369 FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
370 FunctionType( const FunctionType& );
371 virtual ~FunctionType();
372
373 std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
374 std::list<DeclarationWithType*> & get_parameters() { return parameters; }
375 bool get_isVarArgs() const { return isVarArgs; }
376 void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
377 bool isTtype() const;
378
379 bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
380
381 virtual FunctionType *clone() const override { return new FunctionType( *this ); }
382 virtual void accept( Visitor & v ) override { v.visit( this ); }
383 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
384 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
385};
386
387class ReferenceToType : public Type {
388 public:
389 std::list< Expression* > parameters;
390 std::string name;
391 bool hoistType;
392
393 ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
394 ReferenceToType( const ReferenceToType & other );
395 virtual ~ReferenceToType();
396
397 const std::string & get_name() const { return name; }
398 void set_name( std::string newValue ) { name = newValue; }
399 std::list< Expression* >& get_parameters() { return parameters; }
400 bool get_hoistType() const { return hoistType; }
401 void set_hoistType( bool newValue ) { hoistType = newValue; }
402
403 virtual ReferenceToType *clone() const override = 0;
404 virtual void accept( Visitor & v ) override = 0;
405 virtual Type *acceptMutator( Mutator & m ) override = 0;
406 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
407
408 virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
409 protected:
410 virtual std::string typeString() const = 0;
411};
412
413class StructInstType : public ReferenceToType {
414 typedef ReferenceToType Parent;
415 public:
416 // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
417 // where the structure used in this type is actually defined
418 StructDecl *baseStruct;
419
420 StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
421 StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
422 StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
423
424 StructDecl *get_baseStruct() const { return baseStruct; }
425 void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
426
427 /// Accesses generic parameters of base struct (NULL if none such)
428 std::list<TypeDecl*> * get_baseParameters();
429 const std::list<TypeDecl*> * get_baseParameters() const;
430
431 virtual bool isComplete() const override;
432
433 virtual AggregateDecl * getAggr() override;
434
435 virtual TypeSubstitution genericSubstitution() const override;
436
437 /// Looks up the members of this struct named "name" and places them into "foundDecls".
438 /// Clones declarations into "foundDecls", caller responsible for freeing
439 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
440
441 virtual StructInstType *clone() const override { return new StructInstType( *this ); }
442 virtual void accept( Visitor & v ) override { v.visit( this ); }
443 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
444
445 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
446 private:
447 virtual std::string typeString() const override;
448};
449
450class UnionInstType : public ReferenceToType {
451 typedef ReferenceToType Parent;
452 public:
453 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
454 // where the union used in this type is actually defined
455 UnionDecl *baseUnion;
456
457 UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
458 UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
459 UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
460
461 UnionDecl *get_baseUnion() const { return baseUnion; }
462 void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
463
464 /// Accesses generic parameters of base union (NULL if none such)
465 std::list<TypeDecl*> * get_baseParameters();
466 const std::list<TypeDecl*> * get_baseParameters() const;
467
468 virtual bool isComplete() const override;
469
470 virtual AggregateDecl * getAggr() override;
471
472 virtual TypeSubstitution genericSubstitution() const override;
473
474 /// looks up the members of this union named "name" and places them into "foundDecls"
475 /// Clones declarations into "foundDecls", caller responsible for freeing
476 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
477
478 virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
479 virtual void accept( Visitor & v ) override { v.visit( this ); }
480 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
481
482 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
483 private:
484 virtual std::string typeString() const override;
485};
486
487class EnumInstType : public ReferenceToType {
488 typedef ReferenceToType Parent;
489 public:
490 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
491 // where the union used in this type is actually defined
492 EnumDecl *baseEnum = nullptr;
493
494 EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
495 EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
496 EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
497
498 EnumDecl *get_baseEnum() const { return baseEnum; }
499 void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
500
501 virtual bool isComplete() const override;
502
503 virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
504 virtual void accept( Visitor & v ) 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 TraitInstType : public ReferenceToType {
513 typedef ReferenceToType Parent;
514 public:
515 // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
516 // where the trait used in this type is actually defined
517 TraitDecl * baseTrait = nullptr;
518
519 TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
520 TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
521 TraitInstType( const TraitInstType & other );
522 ~TraitInstType();
523
524 virtual bool isComplete() const override;
525
526 virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
527 virtual void accept( Visitor & v ) override { v.visit( this ); }
528 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
529 private:
530 virtual std::string typeString() const override;
531};
532
533class TypeInstType : public ReferenceToType {
534 typedef ReferenceToType Parent;
535 public:
536 // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
537 // where the type used here is actually defined
538 TypeDecl *baseType;
539 bool isFtype;
540
541 TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
542 TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
543 TypeInstType( const TypeInstType & other );
544 ~TypeInstType();
545
546 TypeDecl *get_baseType() const { return baseType; }
547 void set_baseType( TypeDecl *newValue );
548 bool get_isFtype() const { return isFtype; }
549 void set_isFtype( bool newValue ) { isFtype = newValue; }
550
551 virtual bool isComplete() const override;
552
553 virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
554 virtual void accept( Visitor & v ) override { v.visit( this ); }
555 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
556 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
557 private:
558 virtual std::string typeString() const override;
559};
560
561class TupleType : public Type {
562 public:
563 std::list<Type *> types;
564 std::list<Declaration *> members;
565
566 TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
567 TupleType( const TupleType& );
568 virtual ~TupleType();
569
570 typedef std::list<Type*> value_type;
571 typedef value_type::iterator iterator;
572
573 std::list<Type *> & get_types() { return types; }
574 virtual unsigned size() const override { return types.size(); };
575
576 // For now, this is entirely synthetic -- tuple types always have unnamed members.
577 // Eventually, we may allow named tuples, in which case members should subsume types
578 std::list<Declaration *> & get_members() { return members; }
579
580 iterator begin() { return types.begin(); }
581 iterator end() { return types.end(); }
582
583 virtual Type * getComponent( unsigned i ) override {
584 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
585 return *(begin()+i);
586 }
587
588 // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
589
590 virtual TupleType *clone() const override { return new TupleType( *this ); }
591 virtual void accept( Visitor & v ) override { v.visit( this ); }
592 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
593 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
594};
595
596class TypeofType : public Type {
597 public:
598 Expression *expr;
599
600 TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
601 TypeofType( const TypeofType& );
602 virtual ~TypeofType();
603
604 Expression *get_expr() const { return expr; }
605 void set_expr( Expression *newValue ) { expr = newValue; }
606
607 virtual bool isComplete() const override { assert( false ); return false; }
608
609 virtual TypeofType *clone() const override { return new TypeofType( *this ); }
610 virtual void accept( Visitor & v ) override { v.visit( this ); }
611 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
612 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
613};
614
615class AttrType : public Type {
616 public:
617 std::string name;
618 Expression *expr;
619 Type *type;
620 bool isType;
621
622 AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
623 AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
624 AttrType( const AttrType& );
625 virtual ~AttrType();
626
627 const std::string & get_name() const { return name; }
628 void set_name( const std::string & newValue ) { name = newValue; }
629 Expression *get_expr() const { return expr; }
630 void set_expr( Expression *newValue ) { expr = newValue; }
631 Type *get_type() const { return type; }
632 void set_type( Type *newValue ) { type = newValue; }
633 bool get_isType() const { return isType; }
634 void set_isType( bool newValue ) { isType = newValue; }
635
636 virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
637
638 virtual AttrType *clone() const override { return new AttrType( *this ); }
639 virtual void accept( Visitor & v ) override { v.visit( this ); }
640 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
641 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
642};
643
644/// Represents the GCC built-in varargs type
645class VarArgsType : public Type {
646 public:
647 VarArgsType();
648 VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
649
650 virtual bool isComplete() const override{ return true; } // xxx - is this right?
651
652 virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
653 virtual void accept( Visitor & v ) override { v.visit( this ); }
654 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
655 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
656};
657
658/// Represents a zero constant
659class ZeroType : public Type {
660 public:
661 ZeroType();
662 ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
663
664 virtual ZeroType *clone() const override { return new ZeroType( *this ); }
665 virtual void accept( Visitor & v ) override { v.visit( this ); }
666 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
667 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
668};
669
670/// Represents a one constant
671class OneType : public Type {
672 public:
673 OneType();
674 OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
675
676 virtual OneType *clone() const override { return new OneType( *this ); }
677 virtual void accept( Visitor & v ) override { v.visit( this ); }
678 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
679 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
680};
681
682class GlobalScopeType : public Type {
683 public:
684 GlobalScopeType();
685
686 virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
687 virtual void accept( Visitor & v ) override { v.visit( this ); }
688 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
689 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
690};
691
692// Local Variables: //
693// tab-width: 4 //
694// mode: c++ //
695// compile-command: "make install" //
696// End: //
Note: See TracBrowser for help on using the repository browser.