source: src/SynTree/Type.h@ 871cdb4

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 871cdb4 was 8135d4c, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

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