source: src/SynTree/Type.h@ fe1b6a4

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 fe1b6a4 was 168c007, checked in by Rob Schluntz <rschlunt@…>, 9 years ago

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