source: src/SynTree/Type.h@ 5805d15

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 stuck-waitfor-destruct with_gc
Last change on this file since 5805d15 was b1e63ac5, checked in by Rob Schluntz <rschlunt@…>, 9 years ago

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