source: src/SynTree/Type.h@ 982f95d

new-env
Last change on this file since 982f95d was 68f9c43, checked in by Aaron Moss <a3moss@…>, 8 years ago

First pass at delete removal
  • Property mode set to 100644
File size: 26.5 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
144 Qualifiers & get_qualifiers() { return tq; }
145 bool get_const() { return tq.is_const; }
146 bool get_volatile() { return tq.is_volatile; }
147 bool get_restrict() { return tq.is_restrict; }
148 bool get_lvalue() { return tq.is_lvalue; }
149 bool get_mutex() { return tq.is_mutex; }
150 bool get_atomic() { return tq.is_atomic; }
151 void set_const( bool newValue ) { tq.is_const = newValue; }
152 void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
153 void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
154 void set_lvalue( bool newValue ) { tq.is_lvalue = newValue; }
155 void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
156 void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
157
158 ForallList& get_forall() { return forall; }
159
160 std::list< Attribute * >& get_attributes() { return attributes; }
161 const std::list< Attribute * >& get_attributes() const { return attributes; }
162
163 /// How many elemental types are represented by this type
164 virtual unsigned size() const { return 1; };
165 virtual bool isVoid() const { return size() == 0; }
166 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; }
167
168 /// return type without outer pointers and arrays
169 Type * stripDeclarator();
170
171 /// return type without outer references
172 Type * stripReferences();
173
174 /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
175 virtual int referenceDepth() const;
176
177 virtual bool isComplete() const { return true; }
178
179 virtual AggregateDecl * getAggr() { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
180
181 virtual TypeSubstitution genericSubstitution() const;
182
183 virtual Type *clone() const = 0;
184 virtual void accept( Visitor & v ) = 0;
185 virtual Type *acceptMutator( Mutator & m ) = 0;
186 virtual void print( std::ostream & os, Indenter indent = {} ) const;
187};
188
189extern const Type::FuncSpecifiers noFuncSpecifiers;
190extern const Type::StorageClasses noStorageClasses;
191extern const Type::Qualifiers noQualifiers; // no qualifiers on constants
192
193class VoidType : public Type {
194 public:
195 VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
196
197 virtual unsigned size() const override { return 0; };
198 virtual bool isComplete() const override { return false; }
199
200 virtual VoidType *clone() const override { return new VoidType( *this ); }
201 virtual void accept( Visitor & v ) override { v.visit( this ); }
202 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
203 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
204};
205
206class BasicType : public Type {
207 public:
208 enum Kind {
209 Bool,
210 Char,
211 SignedChar,
212 UnsignedChar,
213 ShortSignedInt,
214 ShortUnsignedInt,
215 SignedInt,
216 UnsignedInt,
217 LongSignedInt,
218 LongUnsignedInt,
219 LongLongSignedInt,
220 LongLongUnsignedInt,
221 Float,
222 Double,
223 LongDouble,
224 FloatComplex,
225 DoubleComplex,
226 LongDoubleComplex,
227 FloatImaginary,
228 DoubleImaginary,
229 LongDoubleImaginary,
230 SignedInt128,
231 UnsignedInt128,
232 NUMBER_OF_BASIC_TYPES
233 } kind;
234
235 static const char *typeNames[]; // string names for basic types, MUST MATCH with Kind
236
237 BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
238
239 Kind get_kind() { return kind; }
240 void set_kind( Kind newValue ) { kind = newValue; }
241
242 virtual BasicType *clone() const override { return new BasicType( *this ); }
243 virtual void accept( Visitor & v ) override { v.visit( this ); }
244 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
245 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
246
247 bool isInteger() const;
248};
249
250class PointerType : public Type {
251 public:
252 Type *base;
253
254 // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
255 Expression *dimension;
256 bool isVarLen;
257 bool isStatic;
258
259 PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
260 PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
261 PointerType( const PointerType& );
262
263 Type *get_base() { return base; }
264 void set_base( Type *newValue ) { base = newValue; }
265 Expression *get_dimension() { return dimension; }
266 void set_dimension( Expression *newValue ) { dimension = newValue; }
267 bool get_isVarLen() { return isVarLen; }
268 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
269 bool get_isStatic() { return isStatic; }
270 void set_isStatic( bool newValue ) { isStatic = newValue; }
271
272 bool is_array() const { return isStatic || isVarLen || dimension; }
273
274 virtual bool isComplete() const override { return ! isVarLen; }
275
276 virtual PointerType *clone() const override { return new PointerType( *this ); }
277 virtual void accept( Visitor & v ) override { v.visit( this ); }
278 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
279 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
280};
281
282class ArrayType : public Type {
283 public:
284 Type *base;
285 Expression *dimension;
286 bool isVarLen;
287 bool isStatic;
288
289 ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
290 ArrayType( const ArrayType& );
291
292 Type *get_base() { return base; }
293 void set_base( Type *newValue ) { base = newValue; }
294 Expression *get_dimension() { return dimension; }
295 void set_dimension( Expression *newValue ) { dimension = newValue; }
296 bool get_isVarLen() { return isVarLen; }
297 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
298 bool get_isStatic() { return isStatic; }
299 void set_isStatic( bool newValue ) { isStatic = newValue; }
300
301 // array types are complete if they have a dimension expression or are
302 // VLAs ('*' in parameter declaration), and incomplete otherwise.
303 // See 6.7.6.2
304 virtual bool isComplete() const override { return dimension || isVarLen; }
305
306 virtual ArrayType *clone() const override { return new ArrayType( *this ); }
307 virtual void accept( Visitor & v ) override { v.visit( this ); }
308 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
309 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
310};
311
312class ReferenceType : public Type {
313public:
314 Type *base;
315
316 ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
317 ReferenceType( const ReferenceType & );
318
319 Type *get_base() { return base; }
320 void set_base( Type *newValue ) { base = newValue; }
321
322 virtual int referenceDepth() const override;
323
324 // Since reference types act like value types, their size is the size of the base.
325 // This makes it simple to cast the empty tuple to a reference type, since casts that increase
326 // the number of values are disallowed.
327 virtual unsigned size() const override { return base->size(); }
328
329 virtual TypeSubstitution genericSubstitution() const override;
330
331 virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
332 virtual void accept( Visitor & v ) 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 FunctionType : public Type {
338 public:
339 std::list<DeclarationWithType*> returnVals;
340 std::list<DeclarationWithType*> parameters;
341
342 // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
343 // This could be because of
344 // - an ellipsis in a prototype declaration
345 // - an unprototyped declaration
346 bool isVarArgs;
347
348 FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
349 FunctionType( const FunctionType& );
350
351 std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
352 std::list<DeclarationWithType*> & get_parameters() { return parameters; }
353 bool get_isVarArgs() const { return isVarArgs; }
354 void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
355 bool isTtype() const;
356
357 bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
358
359 virtual FunctionType *clone() const override { return new FunctionType( *this ); }
360 virtual void accept( Visitor & v ) override { v.visit( this ); }
361 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
362 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
363};
364
365class ReferenceToType : public Type {
366 public:
367 std::list< Expression* > parameters;
368 std::string name;
369 bool hoistType;
370
371 ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
372 ReferenceToType( const ReferenceToType & other );
373
374 const std::string & get_name() const { return name; }
375 void set_name( std::string newValue ) { name = newValue; }
376 std::list< Expression* >& get_parameters() { return parameters; }
377 bool get_hoistType() const { return hoistType; }
378 void set_hoistType( bool newValue ) { hoistType = newValue; }
379
380 virtual ReferenceToType *clone() const override = 0;
381 virtual void accept( Visitor & v ) override = 0;
382 virtual Type *acceptMutator( Mutator & m ) override = 0;
383 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
384
385 virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
386 protected:
387 virtual std::string typeString() const = 0;
388};
389
390class StructInstType : public ReferenceToType {
391 typedef ReferenceToType Parent;
392 public:
393 // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
394 // where the structure used in this type is actually defined
395 StructDecl *baseStruct;
396
397 StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
398 StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
399 StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
400
401 StructDecl *get_baseStruct() const { return baseStruct; }
402 void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
403
404 /// Accesses generic parameters of base struct (NULL if none such)
405 std::list<TypeDecl*> * get_baseParameters();
406 const std::list<TypeDecl*> * get_baseParameters() const;
407
408 virtual bool isComplete() const override;
409
410 virtual AggregateDecl * getAggr() override;
411
412 virtual TypeSubstitution genericSubstitution() const override;
413
414 /// Looks up the members of this struct named "name" and places them into "foundDecls".
415 /// Clones declarations into "foundDecls", caller responsible for freeing
416 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
417
418 virtual StructInstType *clone() const override { return new StructInstType( *this ); }
419 virtual void accept( Visitor & v ) override { v.visit( this ); }
420 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
421
422 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
423 private:
424 virtual std::string typeString() const override;
425};
426
427class UnionInstType : public ReferenceToType {
428 typedef ReferenceToType Parent;
429 public:
430 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
431 // where the union used in this type is actually defined
432 UnionDecl *baseUnion;
433
434 UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
435 UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
436 UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
437
438 UnionDecl *get_baseUnion() const { return baseUnion; }
439 void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
440
441 /// Accesses generic parameters of base union (NULL if none such)
442 std::list<TypeDecl*> * get_baseParameters();
443 const std::list<TypeDecl*> * get_baseParameters() const;
444
445 virtual bool isComplete() const override;
446
447 virtual AggregateDecl * getAggr() override;
448
449 virtual TypeSubstitution genericSubstitution() const override;
450
451 /// looks up the members of this union named "name" and places them into "foundDecls"
452 /// Clones declarations into "foundDecls", caller responsible for freeing
453 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
454
455 virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
456 virtual void accept( Visitor & v ) override { v.visit( this ); }
457 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
458
459 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
460 private:
461 virtual std::string typeString() const override;
462};
463
464class EnumInstType : public ReferenceToType {
465 typedef ReferenceToType Parent;
466 public:
467 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
468 // where the union used in this type is actually defined
469 EnumDecl *baseEnum = nullptr;
470
471 EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
472 EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
473 EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
474
475 EnumDecl *get_baseEnum() const { return baseEnum; }
476 void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
477
478 virtual bool isComplete() const override;
479
480 virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
481 virtual void accept( Visitor & v ) override { v.visit( this ); }
482 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
483
484 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
485 private:
486 virtual std::string typeString() const override;
487};
488
489class TraitInstType : public ReferenceToType {
490 typedef ReferenceToType Parent;
491 public:
492 // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
493 // where the trait used in this type is actually defined
494 TraitDecl * baseTrait = nullptr;
495
496 TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
497 TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
498 TraitInstType( const TraitInstType & other );
499
500 virtual bool isComplete() const override;
501
502 virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
503 virtual void accept( Visitor & v ) override { v.visit( this ); }
504 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
505 private:
506 virtual std::string typeString() const override;
507};
508
509class TypeInstType : public ReferenceToType {
510 typedef ReferenceToType Parent;
511 public:
512 // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
513 // where the type used here is actually defined
514 TypeDecl *baseType;
515 bool isFtype;
516
517 TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
518 TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
519 TypeInstType( const TypeInstType & other );
520
521 TypeDecl *get_baseType() const { return baseType; }
522 void set_baseType( TypeDecl *newValue );
523 bool get_isFtype() const { return isFtype; }
524 void set_isFtype( bool newValue ) { isFtype = newValue; }
525
526 virtual bool isComplete() const override;
527
528 virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
529 virtual void accept( Visitor & v ) override { v.visit( this ); }
530 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
531 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
532 private:
533 virtual std::string typeString() const override;
534};
535
536class TupleType : public Type {
537 public:
538 std::list<Type *> types;
539 std::list<Declaration *> members;
540
541 TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
542 TupleType( const TupleType& );
543
544 typedef std::list<Type*> value_type;
545 typedef value_type::iterator iterator;
546
547 std::list<Type *> & get_types() { return types; }
548 virtual unsigned size() const override { return types.size(); };
549
550 // For now, this is entirely synthetic -- tuple types always have unnamed members.
551 // Eventually, we may allow named tuples, in which case members should subsume types
552 std::list<Declaration *> & get_members() { return members; }
553
554 iterator begin() { return types.begin(); }
555 iterator end() { return types.end(); }
556
557 virtual Type * getComponent( unsigned i ) override {
558 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
559 return *(begin()+i);
560 }
561
562 // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
563
564 virtual TupleType *clone() const override { return new TupleType( *this ); }
565 virtual void accept( Visitor & v ) override { v.visit( this ); }
566 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
567 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
568};
569
570class TypeofType : public Type {
571 public:
572 Expression *expr;
573
574 TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
575 TypeofType( const TypeofType& );
576
577 Expression *get_expr() const { return expr; }
578 void set_expr( Expression *newValue ) { expr = newValue; }
579
580 virtual bool isComplete() const override { assert( false ); return false; }
581
582 virtual TypeofType *clone() const override { return new TypeofType( *this ); }
583 virtual void accept( Visitor & v ) override { v.visit( this ); }
584 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
585 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
586};
587
588class AttrType : public Type {
589 public:
590 std::string name;
591 Expression *expr;
592 Type *type;
593 bool isType;
594
595 AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
596 AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
597 AttrType( const AttrType& );
598
599 const std::string & get_name() const { return name; }
600 void set_name( const std::string & newValue ) { name = newValue; }
601 Expression *get_expr() const { return expr; }
602 void set_expr( Expression *newValue ) { expr = newValue; }
603 Type *get_type() const { return type; }
604 void set_type( Type *newValue ) { type = newValue; }
605 bool get_isType() const { return isType; }
606 void set_isType( bool newValue ) { isType = newValue; }
607
608 virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
609
610 virtual AttrType *clone() const override { return new AttrType( *this ); }
611 virtual void accept( Visitor & v ) override { v.visit( this ); }
612 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
613 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
614};
615
616/// Represents the GCC built-in varargs type
617class VarArgsType : public Type {
618 public:
619 VarArgsType();
620 VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
621
622 virtual bool isComplete() const override{ return true; } // xxx - is this right?
623
624 virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
625 virtual void accept( Visitor & v ) override { v.visit( this ); }
626 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
627 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
628};
629
630/// Represents a zero constant
631class ZeroType : public Type {
632 public:
633 ZeroType();
634 ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
635
636 virtual ZeroType *clone() const override { return new ZeroType( *this ); }
637 virtual void accept( Visitor & v ) override { v.visit( this ); }
638 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
639 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
640};
641
642/// Represents a one constant
643class OneType : public Type {
644 public:
645 OneType();
646 OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
647
648 virtual OneType *clone() const override { return new OneType( *this ); }
649 virtual void accept( Visitor & v ) override { v.visit( this ); }
650 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
651 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
652};
653
654// Local Variables: //
655// tab-width: 4 //
656// mode: c++ //
657// compile-command: "make install" //
658// End: //
Note: See TracBrowser for help on using the repository browser.