source: src/SynTree/Type.h@ 1588ffb6

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 1588ffb6 was 50377a4, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

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