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

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 6d267ca was e6cee92, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

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