source: src/SynTree/Type.h@ 9737ffe

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

constructor taking an array parameter is now an error
  • Property mode set to 100644
File size: 23.1 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( const std::string & name, 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 = std::list< Type * >(), 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 iterator begin() { return types.begin(); }
494 iterator end() { return types.end(); }
495
496 virtual Type * getComponent( unsigned i ) {
497 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
498 return *(begin()+i);
499 }
500
501 // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
502
503 virtual TupleType *clone() const { return new TupleType( *this ); }
504 virtual void accept( Visitor & v ) { v.visit( this ); }
505 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
506 virtual void print( std::ostream & os, int indent = 0 ) const;
507 private:
508 std::list<Type*> types;
509};
510
511class TypeofType : public Type {
512 public:
513 TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
514 TypeofType( const TypeofType& );
515 virtual ~TypeofType();
516
517 Expression *get_expr() const { return expr; }
518 void set_expr( Expression *newValue ) { expr = newValue; }
519
520 virtual bool isComplete() const { assert( false ); return false; }
521
522 virtual TypeofType *clone() const { return new TypeofType( *this ); }
523 virtual void accept( Visitor & v ) { v.visit( this ); }
524 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
525 virtual void print( std::ostream & os, int indent = 0 ) const;
526 private:
527 Expression *expr;
528};
529
530class AttrType : public Type {
531 public:
532 AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
533 AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
534 AttrType( const AttrType& );
535 virtual ~AttrType();
536
537 const std::string & get_name() const { return name; }
538 void set_name( const std::string & newValue ) { name = newValue; }
539 Expression *get_expr() const { return expr; }
540 void set_expr( Expression *newValue ) { expr = newValue; }
541 Type *get_type() const { return type; }
542 void set_type( Type *newValue ) { type = newValue; }
543 bool get_isType() const { return isType; }
544 void set_isType( bool newValue ) { isType = newValue; }
545
546 virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
547
548 virtual AttrType *clone() const { return new AttrType( *this ); }
549 virtual void accept( Visitor & v ) { v.visit( this ); }
550 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
551 virtual void print( std::ostream & os, int indent = 0 ) const;
552 private:
553 std::string name;
554 Expression *expr;
555 Type *type;
556 bool isType;
557};
558
559/// Represents the GCC built-in varargs type
560class VarArgsType : public Type {
561 public:
562 VarArgsType();
563 VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
564
565 virtual bool isComplete() const{ return true; } // xxx - is this right?
566
567 virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
568 virtual void accept( Visitor & v ) { v.visit( this ); }
569 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
570 virtual void print( std::ostream & os, int indent = 0 ) const;
571};
572
573/// Represents a zero constant
574class ZeroType : public Type {
575 public:
576 ZeroType();
577 ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
578
579 virtual ZeroType *clone() const { return new ZeroType( *this ); }
580 virtual void accept( Visitor & v ) { v.visit( this ); }
581 virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
582 virtual void print( std::ostream & os, int indent = 0 ) const;
583};
584
585/// Represents a one constant
586class OneType : public Type {
587 public:
588 OneType();
589 OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
590
591 virtual OneType *clone() const { return new OneType( *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
597std::ostream & operator<<( std::ostream & out, const Type * type );
598
599#endif // TYPE_H
600
601// Local Variables: //
602// tab-width: 4 //
603// mode: c++ //
604// compile-command: "make install" //
605// End: //
Note: See TracBrowser for help on using the repository browser.