source: src/SynTree/Type.h@ d6ff3ff

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

Big push on designations and initialization: works with generic types, tuples, arrays, tests pass.
Refactor guard_value_impl.
Add list of declarations to TupleType.
  • Property mode set to 100644
File size: 23.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 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 PointerType *clone() const { return new PointerType( *this ); }
252 virtual void accept( Visitor & v ) { v.visit( this ); }
253 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
254 virtual void print( std::ostream & os, int indent = 0 ) const;
255 private:
256 Type *base;
257
258 // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
259 Expression *dimension;
260 bool isVarLen;
261 bool isStatic;
262};
263
264class ArrayType : public Type {
265 public:
266 ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
267 ArrayType( const ArrayType& );
268 virtual ~ArrayType();
269
270 Type *get_base() { return base; }
271 void set_base( Type *newValue ) { base = newValue; }
272 Expression *get_dimension() { return dimension; }
273 void set_dimension( Expression *newValue ) { dimension = newValue; }
274 bool get_isVarLen() { return isVarLen; }
275 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
276 bool get_isStatic() { return isStatic; }
277 void set_isStatic( bool newValue ) { isStatic = newValue; }
278
279 virtual bool isComplete() const { return ! isVarLen; }
280
281 virtual ArrayType *clone() const { return new ArrayType( *this ); }
282 virtual void accept( Visitor & v ) { v.visit( this ); }
283 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
284 virtual void print( std::ostream & os, int indent = 0 ) const;
285 private:
286 Type *base;
287 Expression *dimension;
288 bool isVarLen;
289 bool isStatic;
290};
291
292class FunctionType : public Type {
293 public:
294 FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
295 FunctionType( const FunctionType& );
296 virtual ~FunctionType();
297
298 std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
299 std::list<DeclarationWithType*> & get_parameters() { return parameters; }
300 bool get_isVarArgs() const { return isVarArgs; }
301 void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
302 bool isTtype() const;
303
304 virtual FunctionType *clone() const { return new FunctionType( *this ); }
305 virtual void accept( Visitor & v ) { v.visit( this ); }
306 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
307 virtual void print( std::ostream & os, int indent = 0 ) const;
308 private:
309 std::list<DeclarationWithType*> returnVals;
310 std::list<DeclarationWithType*> parameters;
311
312 // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
313 // This could be because of
314 // - an ellipsis in a prototype declaration
315 // - an unprototyped declaration
316 bool isVarArgs;
317};
318
319class ReferenceToType : public Type {
320 public:
321 ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
322 ReferenceToType( const ReferenceToType & other );
323 virtual ~ReferenceToType();
324
325 const std::string & get_name() const { return name; }
326 void set_name( std::string newValue ) { name = newValue; }
327 std::list< Expression* >& get_parameters() { return parameters; }
328 bool get_hoistType() const { return hoistType; }
329 void set_hoistType( bool newValue ) { hoistType = newValue; }
330
331 virtual ReferenceToType *clone() const = 0;
332 virtual void accept( Visitor & v ) = 0;
333 virtual Type *acceptMutator( Mutator & m ) = 0;
334 virtual void print( std::ostream & os, int indent = 0 ) const;
335
336 virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
337 protected:
338 virtual std::string typeString() const = 0;
339 std::list< Expression* > parameters;
340 std::string name;
341 private:
342 bool hoistType;
343};
344
345class StructInstType : public ReferenceToType {
346 typedef ReferenceToType Parent;
347 public:
348 StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
349 StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
350 StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
351
352 StructDecl *get_baseStruct() const { return baseStruct; }
353 void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
354
355 /// Accesses generic parameters of base struct (NULL if none such)
356 std::list<TypeDecl*> * get_baseParameters();
357
358 virtual bool isComplete() const;
359
360 /// Looks up the members of this struct named "name" and places them into "foundDecls".
361 /// Clones declarations into "foundDecls", caller responsible for freeing
362 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
363
364 virtual StructInstType *clone() const { return new StructInstType( *this ); }
365 virtual void accept( Visitor & v ) { v.visit( this ); }
366 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
367
368 virtual void print( std::ostream & os, int indent = 0 ) const;
369 private:
370 virtual std::string typeString() const;
371
372 // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
373 // where the structure used in this type is actually defined
374 StructDecl *baseStruct;
375};
376
377class UnionInstType : public ReferenceToType {
378 typedef ReferenceToType Parent;
379 public:
380 UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
381 UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
382 UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
383
384 UnionDecl *get_baseUnion() const { return baseUnion; }
385 void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
386
387 /// Accesses generic parameters of base union (NULL if none such)
388 std::list< TypeDecl * > * get_baseParameters();
389
390 virtual bool isComplete() const;
391
392 /// looks up the members of this union named "name" and places them into "foundDecls"
393 /// Clones declarations into "foundDecls", caller responsible for freeing
394 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
395
396 virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
397 virtual void accept( Visitor & v ) { v.visit( this ); }
398 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
399
400 virtual void print( std::ostream & os, int indent = 0 ) const;
401 private:
402 virtual std::string typeString() const;
403
404 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
405 // where the union used in this type is actually defined
406 UnionDecl *baseUnion;
407};
408
409class EnumInstType : public ReferenceToType {
410 typedef ReferenceToType Parent;
411 public:
412 EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
413 EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
414 EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
415
416 EnumDecl *get_baseEnum() const { return baseEnum; }
417 void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
418
419 virtual bool isComplete() const;
420
421 virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
422 virtual void accept( Visitor & v ) { v.visit( this ); }
423 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
424 private:
425 virtual std::string typeString() const;
426
427 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
428 // where the union used in this type is actually defined
429 EnumDecl *baseEnum = nullptr;
430};
431
432class TraitInstType : public ReferenceToType {
433 typedef ReferenceToType Parent;
434 public:
435 TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
436 TraitInstType( const TraitInstType & other );
437 ~TraitInstType();
438
439 std::list< Declaration* >& get_members() { return members; }
440
441 virtual bool isComplete() const;
442
443 virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
444 virtual void accept( Visitor & v ) { v.visit( this ); }
445 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
446 private:
447 virtual std::string typeString() const;
448
449 // this member is filled in by the validate pass, which instantiates the members of the correponding
450 // aggregate with the actual type parameters specified for this use of the context
451 std::list< Declaration* > members;
452};
453
454class TypeInstType : public ReferenceToType {
455 typedef ReferenceToType Parent;
456 public:
457 TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
458 TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
459 TypeInstType( const TypeInstType & other );
460 ~TypeInstType();
461
462 TypeDecl *get_baseType() const { return baseType; }
463 void set_baseType( TypeDecl *newValue );
464 bool get_isFtype() const { return isFtype; }
465 void set_isFtype( bool newValue ) { isFtype = newValue; }
466
467 virtual bool isComplete() const;
468
469 virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
470 virtual void accept( Visitor & v ) { v.visit( this ); }
471 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
472 virtual void print( std::ostream & os, int indent = 0 ) const;
473 private:
474 virtual std::string typeString() const;
475 // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
476 // where the type used here is actually defined
477 TypeDecl *baseType;
478 bool isFtype;
479};
480
481class TupleType : public Type {
482 public:
483 TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
484 TupleType( const TupleType& );
485 virtual ~TupleType();
486
487 typedef std::list<Type*> value_type;
488 typedef value_type::iterator iterator;
489
490 std::list<Type *> & get_types() { return types; }
491 virtual unsigned size() const { return types.size(); };
492
493 // For now, this is entirely synthetic -- tuple types always have unnamed members.
494 // Eventually, we may allow named tuples, in which case members should subsume types
495 std::list<Declaration *> & get_members() { return members; }
496
497 iterator begin() { return types.begin(); }
498 iterator end() { return types.end(); }
499
500 virtual Type * getComponent( unsigned i ) {
501 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
502 return *(begin()+i);
503 }
504
505 // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
506
507 virtual TupleType *clone() const { return new TupleType( *this ); }
508 virtual void accept( Visitor & v ) { v.visit( this ); }
509 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
510 virtual void print( std::ostream & os, int indent = 0 ) const;
511 private:
512 std::list<Type *> types;
513 std::list<Declaration *> members;
514};
515
516class TypeofType : public Type {
517 public:
518 TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
519 TypeofType( const TypeofType& );
520 virtual ~TypeofType();
521
522 Expression *get_expr() const { return expr; }
523 void set_expr( Expression *newValue ) { expr = newValue; }
524
525 virtual bool isComplete() const { assert( false ); return false; }
526
527 virtual TypeofType *clone() const { return new TypeofType( *this ); }
528 virtual void accept( Visitor & v ) { v.visit( this ); }
529 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
530 virtual void print( std::ostream & os, int indent = 0 ) const;
531 private:
532 Expression *expr;
533};
534
535class AttrType : public Type {
536 public:
537 AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
538 AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
539 AttrType( const AttrType& );
540 virtual ~AttrType();
541
542 const std::string & get_name() const { return name; }
543 void set_name( const std::string & newValue ) { name = newValue; }
544 Expression *get_expr() const { return expr; }
545 void set_expr( Expression *newValue ) { expr = newValue; }
546 Type *get_type() const { return type; }
547 void set_type( Type *newValue ) { type = newValue; }
548 bool get_isType() const { return isType; }
549 void set_isType( bool newValue ) { isType = newValue; }
550
551 virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
552
553 virtual AttrType *clone() const { return new AttrType( *this ); }
554 virtual void accept( Visitor & v ) { v.visit( this ); }
555 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
556 virtual void print( std::ostream & os, int indent = 0 ) const;
557 private:
558 std::string name;
559 Expression *expr;
560 Type *type;
561 bool isType;
562};
563
564/// Represents the GCC built-in varargs type
565class VarArgsType : public Type {
566 public:
567 VarArgsType();
568 VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
569
570 virtual bool isComplete() const{ return true; } // xxx - is this right?
571
572 virtual VarArgsType *clone() const { return new VarArgsType( *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};
577
578/// Represents a zero constant
579class ZeroType : public Type {
580 public:
581 ZeroType();
582 ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
583
584 virtual ZeroType *clone() const { return new ZeroType( *this ); }
585 virtual void accept( Visitor & v ) { v.visit( this ); }
586 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
587 virtual void print( std::ostream & os, int indent = 0 ) const;
588};
589
590/// Represents a one constant
591class OneType : public Type {
592 public:
593 OneType();
594 OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
595
596 virtual OneType *clone() const { return new OneType( *this ); }
597 virtual void accept( Visitor & v ) { v.visit( this ); }
598 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
599 virtual void print( std::ostream & os, int indent = 0 ) const;
600};
601
602std::ostream & operator<<( std::ostream & out, const Type * type );
603
604#endif // TYPE_H
605
606// Local Variables: //
607// tab-width: 4 //
608// mode: c++ //
609// compile-command: "make install" //
610// End: //
Note: See TracBrowser for help on using the repository browser.