source: src/SynTree/Type.h@ 17238fd

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 new-env no_list persistent-indexer pthread-emulation qualifiedEnum with_gc
Last change on this file since 17238fd was 9bfc9da, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

Refactor makeSub into genericSubstitution
  • Property mode set to 100644
File size: 26.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() { 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 NUMBER_OF_BASIC_TYPES
234 } kind;
235
236 static const char *typeNames[]; // string names for basic types, MUST MATCH with Kind
237
238 BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
239
240 Kind get_kind() { return kind; }
241 void set_kind( Kind newValue ) { kind = newValue; }
242
243 virtual BasicType *clone() const override { return new BasicType( *this ); }
244 virtual void accept( Visitor & v ) override { v.visit( this ); }
245 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
246 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
247
248 bool isInteger() const;
249};
250
251class PointerType : public Type {
252 public:
253 Type *base;
254
255 // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
256 Expression *dimension;
257 bool isVarLen;
258 bool isStatic;
259
260 PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
261 PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
262 PointerType( const PointerType& );
263 virtual ~PointerType();
264
265 Type *get_base() { return base; }
266 void set_base( Type *newValue ) { base = newValue; }
267 Expression *get_dimension() { return dimension; }
268 void set_dimension( Expression *newValue ) { dimension = newValue; }
269 bool get_isVarLen() { return isVarLen; }
270 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
271 bool get_isStatic() { return isStatic; }
272 void set_isStatic( bool newValue ) { isStatic = newValue; }
273
274 bool is_array() const { return isStatic || isVarLen || dimension; }
275
276 virtual bool isComplete() const override { return ! isVarLen; }
277
278 virtual PointerType *clone() const override { return new PointerType( *this ); }
279 virtual void accept( Visitor & v ) override { v.visit( this ); }
280 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
281 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
282};
283
284class ArrayType : public Type {
285 public:
286 Type *base;
287 Expression *dimension;
288 bool isVarLen;
289 bool isStatic;
290
291 ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
292 ArrayType( const ArrayType& );
293 virtual ~ArrayType();
294
295 Type *get_base() { return base; }
296 void set_base( Type *newValue ) { base = newValue; }
297 Expression *get_dimension() { return dimension; }
298 void set_dimension( Expression *newValue ) { dimension = newValue; }
299 bool get_isVarLen() { return isVarLen; }
300 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
301 bool get_isStatic() { return isStatic; }
302 void set_isStatic( bool newValue ) { isStatic = newValue; }
303
304 // array types are complete if they have a dimension expression or are
305 // VLAs ('*' in parameter declaration), and incomplete otherwise.
306 // See 6.7.6.2
307 virtual bool isComplete() const override { return dimension || isVarLen; }
308
309 virtual ArrayType *clone() const override { return new ArrayType( *this ); }
310 virtual void accept( Visitor & v ) override { v.visit( this ); }
311 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
312 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
313};
314
315class ReferenceType : public Type {
316public:
317 Type *base;
318
319 ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
320 ReferenceType( const ReferenceType & );
321 virtual ~ReferenceType();
322
323 Type *get_base() { return base; }
324 void set_base( Type *newValue ) { base = newValue; }
325
326 virtual int referenceDepth() const override;
327
328 // Since reference types act like value types, their size is the size of the base.
329 // This makes it simple to cast the empty tuple to a reference type, since casts that increase
330 // the number of values are disallowed.
331 virtual unsigned size() const override { return base->size(); }
332
333 virtual TypeSubstitution genericSubstitution() const override;
334
335 virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
336 virtual void accept( Visitor & v ) override { v.visit( this ); }
337 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
338 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
339};
340
341class FunctionType : public Type {
342 public:
343 std::list<DeclarationWithType*> returnVals;
344 std::list<DeclarationWithType*> parameters;
345
346 // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
347 // This could be because of
348 // - an ellipsis in a prototype declaration
349 // - an unprototyped declaration
350 bool isVarArgs;
351
352 FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
353 FunctionType( const FunctionType& );
354 virtual ~FunctionType();
355
356 std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
357 std::list<DeclarationWithType*> & get_parameters() { return parameters; }
358 bool get_isVarArgs() const { return isVarArgs; }
359 void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
360 bool isTtype() const;
361
362 bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
363
364 virtual FunctionType *clone() const override { return new FunctionType( *this ); }
365 virtual void accept( Visitor & v ) override { v.visit( this ); }
366 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
367 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
368};
369
370class ReferenceToType : public Type {
371 public:
372 std::list< Expression* > parameters;
373 std::string name;
374 bool hoistType;
375
376 ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
377 ReferenceToType( const ReferenceToType & other );
378 virtual ~ReferenceToType();
379
380 const std::string & get_name() const { return name; }
381 void set_name( std::string newValue ) { name = newValue; }
382 std::list< Expression* >& get_parameters() { return parameters; }
383 bool get_hoistType() const { return hoistType; }
384 void set_hoistType( bool newValue ) { hoistType = newValue; }
385
386 virtual ReferenceToType *clone() const override = 0;
387 virtual void accept( Visitor & v ) override = 0;
388 virtual Type *acceptMutator( Mutator & m ) override = 0;
389 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
390
391 virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
392 protected:
393 virtual std::string typeString() const = 0;
394};
395
396class StructInstType : public ReferenceToType {
397 typedef ReferenceToType Parent;
398 public:
399 // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
400 // where the structure used in this type is actually defined
401 StructDecl *baseStruct;
402
403 StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
404 StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
405 StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
406
407 StructDecl *get_baseStruct() const { return baseStruct; }
408 void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
409
410 /// Accesses generic parameters of base struct (NULL if none such)
411 std::list<TypeDecl*> * get_baseParameters();
412 const std::list<TypeDecl*> * get_baseParameters() const;
413
414 virtual bool isComplete() const override;
415
416 virtual AggregateDecl * getAggr() override;
417
418 virtual TypeSubstitution genericSubstitution() const override;
419
420 /// Looks up the members of this struct named "name" and places them into "foundDecls".
421 /// Clones declarations into "foundDecls", caller responsible for freeing
422 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
423
424 virtual StructInstType *clone() const override { return new StructInstType( *this ); }
425 virtual void accept( Visitor & v ) override { v.visit( this ); }
426 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
427
428 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
429 private:
430 virtual std::string typeString() const override;
431};
432
433class UnionInstType : public ReferenceToType {
434 typedef ReferenceToType Parent;
435 public:
436 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
437 // where the union used in this type is actually defined
438 UnionDecl *baseUnion;
439
440 UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
441 UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
442 UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
443
444 UnionDecl *get_baseUnion() const { return baseUnion; }
445 void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
446
447 /// Accesses generic parameters of base union (NULL if none such)
448 std::list<TypeDecl*> * get_baseParameters();
449 const std::list<TypeDecl*> * get_baseParameters() const;
450
451 virtual bool isComplete() const override;
452
453 virtual AggregateDecl * getAggr() override;
454
455 virtual TypeSubstitution genericSubstitution() const override;
456
457 /// looks up the members of this union named "name" and places them into "foundDecls"
458 /// Clones declarations into "foundDecls", caller responsible for freeing
459 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
460
461 virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
462 virtual void accept( Visitor & v ) override { v.visit( this ); }
463 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
464
465 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
466 private:
467 virtual std::string typeString() const override;
468};
469
470class EnumInstType : public ReferenceToType {
471 typedef ReferenceToType Parent;
472 public:
473 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
474 // where the union used in this type is actually defined
475 EnumDecl *baseEnum = nullptr;
476
477 EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
478 EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
479 EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
480
481 EnumDecl *get_baseEnum() const { return baseEnum; }
482 void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
483
484 virtual bool isComplete() const override;
485
486 virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
487 virtual void accept( Visitor & v ) override { v.visit( this ); }
488 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
489
490 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
491 private:
492 virtual std::string typeString() const override;
493};
494
495class TraitInstType : public ReferenceToType {
496 typedef ReferenceToType Parent;
497 public:
498 // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
499 // where the trait used in this type is actually defined
500 TraitDecl * baseTrait = nullptr;
501
502 TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
503 TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
504 TraitInstType( const TraitInstType & other );
505 ~TraitInstType();
506
507 virtual bool isComplete() const override;
508
509 virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
510 virtual void accept( Visitor & v ) override { v.visit( this ); }
511 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
512 private:
513 virtual std::string typeString() const override;
514};
515
516class TypeInstType : public ReferenceToType {
517 typedef ReferenceToType Parent;
518 public:
519 // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
520 // where the type used here is actually defined
521 TypeDecl *baseType;
522 bool isFtype;
523
524 TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
525 TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
526 TypeInstType( const TypeInstType & other );
527 ~TypeInstType();
528
529 TypeDecl *get_baseType() const { return baseType; }
530 void set_baseType( TypeDecl *newValue );
531 bool get_isFtype() const { return isFtype; }
532 void set_isFtype( bool newValue ) { isFtype = newValue; }
533
534 virtual bool isComplete() const override;
535
536 virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
537 virtual void accept( Visitor & v ) override { v.visit( this ); }
538 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
539 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
540 private:
541 virtual std::string typeString() const override;
542};
543
544class TupleType : public Type {
545 public:
546 std::list<Type *> types;
547 std::list<Declaration *> members;
548
549 TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
550 TupleType( const TupleType& );
551 virtual ~TupleType();
552
553 typedef std::list<Type*> value_type;
554 typedef value_type::iterator iterator;
555
556 std::list<Type *> & get_types() { return types; }
557 virtual unsigned size() const override { return types.size(); };
558
559 // For now, this is entirely synthetic -- tuple types always have unnamed members.
560 // Eventually, we may allow named tuples, in which case members should subsume types
561 std::list<Declaration *> & get_members() { return members; }
562
563 iterator begin() { return types.begin(); }
564 iterator end() { return types.end(); }
565
566 virtual Type * getComponent( unsigned i ) override {
567 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
568 return *(begin()+i);
569 }
570
571 // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
572
573 virtual TupleType *clone() const override { return new TupleType( *this ); }
574 virtual void accept( Visitor & v ) override { v.visit( this ); }
575 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
576 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
577};
578
579class TypeofType : public Type {
580 public:
581 Expression *expr;
582
583 TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
584 TypeofType( const TypeofType& );
585 virtual ~TypeofType();
586
587 Expression *get_expr() const { return expr; }
588 void set_expr( Expression *newValue ) { expr = newValue; }
589
590 virtual bool isComplete() const override { assert( false ); return false; }
591
592 virtual TypeofType *clone() const override { return new TypeofType( *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 AttrType : public Type {
599 public:
600 std::string name;
601 Expression *expr;
602 Type *type;
603 bool isType;
604
605 AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
606 AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
607 AttrType( const AttrType& );
608 virtual ~AttrType();
609
610 const std::string & get_name() const { return name; }
611 void set_name( const std::string & newValue ) { name = newValue; }
612 Expression *get_expr() const { return expr; }
613 void set_expr( Expression *newValue ) { expr = newValue; }
614 Type *get_type() const { return type; }
615 void set_type( Type *newValue ) { type = newValue; }
616 bool get_isType() const { return isType; }
617 void set_isType( bool newValue ) { isType = newValue; }
618
619 virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
620
621 virtual AttrType *clone() const override { return new AttrType( *this ); }
622 virtual void accept( Visitor & v ) 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
627/// Represents the GCC built-in varargs type
628class VarArgsType : public Type {
629 public:
630 VarArgsType();
631 VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
632
633 virtual bool isComplete() const override{ return true; } // xxx - is this right?
634
635 virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
636 virtual void accept( Visitor & v ) override { v.visit( this ); }
637 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
638 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
639};
640
641/// Represents a zero constant
642class ZeroType : public Type {
643 public:
644 ZeroType();
645 ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
646
647 virtual ZeroType *clone() const override { return new ZeroType( *this ); }
648 virtual void accept( Visitor & v ) override { v.visit( this ); }
649 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
650 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
651};
652
653/// Represents a one constant
654class OneType : public Type {
655 public:
656 OneType();
657 OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
658
659 virtual OneType *clone() const override { return new OneType( *this ); }
660 virtual void accept( Visitor & v ) override { v.visit( this ); }
661 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
662 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
663};
664
665// Local Variables: //
666// tab-width: 4 //
667// mode: c++ //
668// compile-command: "make install" //
669// End: //
Note: See TracBrowser for help on using the repository browser.