source: src/SynTree/Type.h@ 1ae06fa

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 resolv-new with_gc
Last change on this file since 1ae06fa was 9236060, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

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