source: src/SynTree/Type.h@ 6c89ecc

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr no_list persistent-indexer pthread-emulation qualifiedEnum
Last change on this file since 6c89ecc was 2dc6621, checked in by Thierry Delisle <tdelisle@…>, 7 years ago

Removed warning in Type.h
  • Property mode set to 100644
File size: 27.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 : 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() const { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
181
182 virtual TypeSubstitution genericSubstitution() const;
183
184 virtual Type *clone() const = 0;
185 virtual void accept( Visitor & v ) = 0;
186 virtual Type *acceptMutator( Mutator & m ) = 0;
187 virtual void print( std::ostream & os, Indenter indent = {} ) const;
188};
189
190extern const Type::FuncSpecifiers noFuncSpecifiers;
191extern const Type::StorageClasses noStorageClasses;
192extern const Type::Qualifiers noQualifiers; // no qualifiers on constants
193
194class VoidType : public Type {
195 public:
196 VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
197
198 virtual unsigned size() const override { return 0; };
199 virtual bool isComplete() const override { return false; }
200
201 virtual VoidType *clone() const override { return new VoidType( *this ); }
202 virtual void accept( Visitor & v ) override { v.visit( this ); }
203 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
204 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
205};
206
207class BasicType : public Type {
208 public:
209 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() const 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() const 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 AggregateDecl * getAggr() const override;
504
505 virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
506 virtual void accept( Visitor & v ) override { v.visit( this ); }
507 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
508
509 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
510 private:
511 virtual std::string typeString() const override;
512};
513
514class TraitInstType : public ReferenceToType {
515 typedef ReferenceToType Parent;
516 public:
517 // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
518 // where the trait used in this type is actually defined
519 TraitDecl * baseTrait = nullptr;
520
521 TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
522 TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
523 TraitInstType( const TraitInstType & other );
524 ~TraitInstType();
525
526 virtual bool isComplete() const override;
527
528 virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
529 virtual void accept( Visitor & v ) override { v.visit( this ); }
530 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
531 private:
532 virtual std::string typeString() const override;
533};
534
535class TypeInstType : public ReferenceToType {
536 typedef ReferenceToType Parent;
537 public:
538 // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
539 // where the type used here is actually defined
540 TypeDecl *baseType;
541 bool isFtype;
542
543 TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
544 TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
545 TypeInstType( const TypeInstType & other );
546 ~TypeInstType();
547
548 TypeDecl *get_baseType() const { return baseType; }
549 void set_baseType( TypeDecl *newValue );
550 bool get_isFtype() const { return isFtype; }
551 void set_isFtype( bool newValue ) { isFtype = newValue; }
552
553 virtual bool isComplete() const override;
554
555 virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
556 virtual void accept( Visitor & v ) override { v.visit( this ); }
557 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
558 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
559 private:
560 virtual std::string typeString() const override;
561};
562
563class TupleType : public Type {
564 public:
565 std::list<Type *> types;
566 std::list<Declaration *> members;
567
568 TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
569 TupleType( const TupleType& );
570 virtual ~TupleType();
571
572 typedef std::list<Type*> value_type;
573 typedef value_type::iterator iterator;
574
575 std::list<Type *> & get_types() { return types; }
576 virtual unsigned size() const override { return types.size(); };
577
578 // For now, this is entirely synthetic -- tuple types always have unnamed members.
579 // Eventually, we may allow named tuples, in which case members should subsume types
580 std::list<Declaration *> & get_members() { return members; }
581
582 iterator begin() { return types.begin(); }
583 iterator end() { return types.end(); }
584
585 virtual Type * getComponent( unsigned i ) override {
586 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
587 return *(begin()+i);
588 }
589
590 // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
591
592 virtual TupleType *clone() const override { return new TupleType( *this ); }
593 virtual void accept( Visitor & v ) override { v.visit( this ); }
594 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
595 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
596};
597
598class TypeofType : public Type {
599 public:
600 Expression *expr;
601
602 TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
603 TypeofType( const TypeofType& );
604 virtual ~TypeofType();
605
606 Expression *get_expr() const { return expr; }
607 void set_expr( Expression *newValue ) { expr = newValue; }
608
609 virtual bool isComplete() const override { assert( false ); return false; }
610
611 virtual TypeofType *clone() const override { return new TypeofType( *this ); }
612 virtual void accept( Visitor & v ) override { v.visit( this ); }
613 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
614 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
615};
616
617class AttrType : public Type {
618 public:
619 std::string name;
620 Expression *expr;
621 Type *type;
622 bool isType;
623
624 AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
625 AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
626 AttrType( const AttrType& );
627 virtual ~AttrType();
628
629 const std::string & get_name() const { return name; }
630 void set_name( const std::string & newValue ) { name = newValue; }
631 Expression *get_expr() const { return expr; }
632 void set_expr( Expression *newValue ) { expr = newValue; }
633 Type *get_type() const { return type; }
634 void set_type( Type *newValue ) { type = newValue; }
635 bool get_isType() const { return isType; }
636 void set_isType( bool newValue ) { isType = newValue; }
637
638 virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
639
640 virtual AttrType *clone() const override { return new AttrType( *this ); }
641 virtual void accept( Visitor & v ) override { v.visit( this ); }
642 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
643 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
644};
645
646/// Represents the GCC built-in varargs type
647class VarArgsType : public Type {
648 public:
649 VarArgsType();
650 VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
651
652 virtual bool isComplete() const override{ return true; } // xxx - is this right?
653
654 virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
655 virtual void accept( Visitor & v ) override { v.visit( this ); }
656 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
657 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
658};
659
660/// Represents a zero constant
661class ZeroType : public Type {
662 public:
663 ZeroType();
664 ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
665
666 virtual ZeroType *clone() const override { return new ZeroType( *this ); }
667 virtual void accept( Visitor & v ) override { v.visit( this ); }
668 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
669 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
670};
671
672/// Represents a one constant
673class OneType : public Type {
674 public:
675 OneType();
676 OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
677
678 virtual OneType *clone() const override { return new OneType( *this ); }
679 virtual void accept( Visitor & v ) override { v.visit( this ); }
680 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
681 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
682};
683
684class GlobalScopeType : public Type {
685 public:
686 GlobalScopeType();
687
688 virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
689 virtual void accept( Visitor & v ) 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// Local Variables: //
695// tab-width: 4 //
696// mode: c++ //
697// compile-command: "make install" //
698// End: //
Note: See TracBrowser for help on using the repository browser.