source: src/SynTree/Type.h@ 101e0bd

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 101e0bd was fa463f1, checked in by Rob Schluntz <rschlunt@…>, 9 years ago

Merge branch 'master' into ctor
  • Property mode set to 100644
File size: 17.0 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 : Wed Jul 13 11:46:54 2016
13// Update Count : 23
14//
15
16#ifndef TYPE_H
17#define TYPE_H
18
19#include "SynTree.h"
20#include "Visitor.h"
21#include "Mutator.h"
22
23class Type {
24 public:
25 struct Qualifiers {
26 Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ), isAttribute( false ) {}
27 Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isAttribute ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isAttribute( isAttribute ) {}
28
29 Qualifiers &operator+=( const Qualifiers &other );
30 Qualifiers &operator-=( const Qualifiers &other );
31 Qualifiers operator+( const Type::Qualifiers &other );
32 bool operator==( const Qualifiers &other );
33 bool operator!=( const Qualifiers &other );
34 bool operator<=( const Qualifiers &other );
35 bool operator>=( const Qualifiers &other );
36 bool operator<( const Qualifiers &other );
37 bool operator>( const Qualifiers &other );
38 void print( std::ostream &os, int indent = 0 ) const;
39
40 bool isConst;
41 bool isVolatile;
42 bool isRestrict;
43 bool isLvalue;
44 bool isAtomic;
45 bool isAttribute;
46 };
47
48 Type( const Qualifiers &tq );
49 Type( const Type &other );
50 virtual ~Type();
51
52 Qualifiers &get_qualifiers() { return tq; }
53 bool get_isConst() { return tq.isConst; }
54 bool get_isVolatile() { return tq.isVolatile; }
55 bool get_isRestrict() { return tq.isRestrict; }
56 bool get_isLvalue() { return tq.isLvalue; }
57 bool get_isAtomic() { return tq.isAtomic; }
58 bool get_isAttribute() { return tq.isAttribute; }
59 void set_isConst( bool newValue ) { tq.isConst = newValue; }
60 void set_isVolatile( bool newValue ) { tq.isVolatile = newValue; }
61 void set_isRestrict( bool newValue ) { tq.isRestrict = newValue; }
62 void set_isLvalue( bool newValue ) { tq.isLvalue = newValue; }
63 void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }
64 void set_isAttribute( bool newValue ) { tq.isAttribute = newValue; }
65 std::list<TypeDecl*>& get_forall() { return forall; }
66
67 virtual Type *clone() const = 0;
68 virtual void accept( Visitor &v ) = 0;
69 virtual Type *acceptMutator( Mutator &m ) = 0;
70 virtual void print( std::ostream &os, int indent = 0 ) const;
71 private:
72 Qualifiers tq;
73 std::list<TypeDecl*> forall;
74};
75
76class VoidType : public Type {
77 public:
78 VoidType( const Type::Qualifiers &tq );
79
80 virtual VoidType *clone() const { return new VoidType( *this ); }
81 virtual void accept( Visitor &v ) { v.visit( this ); }
82 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
83 virtual void print( std::ostream &os, int indent = 0 ) const;
84};
85
86class BasicType : public Type {
87 public:
88 enum Kind {
89 Bool,
90 Char,
91 SignedChar,
92 UnsignedChar,
93 ShortSignedInt,
94 ShortUnsignedInt,
95 SignedInt,
96 UnsignedInt,
97 LongSignedInt,
98 LongUnsignedInt,
99 LongLongSignedInt,
100 LongLongUnsignedInt,
101 Float,
102 Double,
103 LongDouble,
104 FloatComplex,
105 DoubleComplex,
106 LongDoubleComplex,
107 FloatImaginary,
108 DoubleImaginary,
109 LongDoubleImaginary,
110 NUMBER_OF_BASIC_TYPES
111 };
112
113 static const char *typeNames[]; // string names for basic types, MUST MATCH with Kind
114
115 BasicType( const Type::Qualifiers &tq, Kind bt );
116
117 Kind get_kind() { return kind; }
118 void set_kind( Kind newValue ) { kind = newValue; }
119
120 virtual BasicType *clone() const { return new BasicType( *this ); }
121 virtual void accept( Visitor &v ) { v.visit( this ); }
122 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
123 virtual void print( std::ostream &os, int indent = 0 ) const;
124
125 bool isInteger() const;
126 private:
127 Kind kind;
128};
129
130class PointerType : public Type {
131 public:
132 PointerType( const Type::Qualifiers &tq, Type *base );
133 PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
134 PointerType( const PointerType& );
135 virtual ~PointerType();
136
137 Type *get_base() { return base; }
138 void set_base( Type *newValue ) { base = newValue; }
139 Expression *get_dimension() { return dimension; }
140 void set_dimension( Expression *newValue ) { dimension = newValue; }
141 bool get_isVarLen() { return isVarLen; }
142 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
143 bool get_isStatic() { return isStatic; }
144 void set_isStatic( bool newValue ) { isStatic = newValue; }
145
146 virtual PointerType *clone() const { return new PointerType( *this ); }
147 virtual void accept( Visitor &v ) { v.visit( this ); }
148 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
149 virtual void print( std::ostream &os, int indent = 0 ) const;
150 private:
151 Type *base;
152
153 // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
154 Expression *dimension;
155 bool isVarLen;
156 bool isStatic;
157};
158
159class ArrayType : public Type {
160 public:
161 ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
162 ArrayType( const ArrayType& );
163 virtual ~ArrayType();
164
165 Type *get_base() { return base; }
166 void set_base( Type *newValue ) { base = newValue; }
167 Expression *get_dimension() { return dimension; }
168 void set_dimension( Expression *newValue ) { dimension = newValue; }
169 bool get_isVarLen() { return isVarLen; }
170 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
171 bool get_isStatic() { return isStatic; }
172 void set_isStatic( bool newValue ) { isStatic = newValue; }
173
174 virtual ArrayType *clone() const { return new ArrayType( *this ); }
175 virtual void accept( Visitor &v ) { v.visit( this ); }
176 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
177 virtual void print( std::ostream &os, int indent = 0 ) const;
178 private:
179 Type *base;
180 Expression *dimension;
181 bool isVarLen;
182 bool isStatic;
183};
184
185class FunctionType : public Type {
186 public:
187 FunctionType( const Type::Qualifiers &tq, bool isVarArgs );
188 FunctionType( const FunctionType& );
189 virtual ~FunctionType();
190
191 std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
192 std::list<DeclarationWithType*> & get_parameters() { return parameters; }
193 bool get_isVarArgs() { return isVarArgs; }
194 void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
195
196 virtual FunctionType *clone() const { return new FunctionType( *this ); }
197 virtual void accept( Visitor &v ) { v.visit( this ); }
198 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
199 virtual void print( std::ostream &os, int indent = 0 ) const;
200 private:
201 std::list<DeclarationWithType*> returnVals;
202 std::list<DeclarationWithType*> parameters;
203
204 // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
205 // This could be because of
206 // - an ellipsis in a prototype declaration
207 // - an unprototyped declaration
208 bool isVarArgs;
209};
210
211class ReferenceToType : public Type {
212 public:
213 ReferenceToType( const Type::Qualifiers &tq, const std::string &name );
214 ReferenceToType( const ReferenceToType &other );
215 virtual ~ReferenceToType();
216
217 const std::string &get_name() const { return name; }
218 void set_name( std::string newValue ) { name = newValue; }
219 std::list< Expression* >& get_parameters() { return parameters; }
220
221 virtual ReferenceToType *clone() const = 0;
222 virtual void accept( Visitor &v ) = 0;
223 virtual Type *acceptMutator( Mutator &m ) = 0;
224 virtual void print( std::ostream &os, int indent = 0 ) const;
225 protected:
226 virtual std::string typeString() const = 0;
227 std::list< Expression* > parameters;
228 std::string name;
229 private:
230};
231
232class StructInstType : public ReferenceToType {
233 typedef ReferenceToType Parent;
234 public:
235 StructInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseStruct( 0 ) {}
236 StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
237
238 StructDecl *get_baseStruct() const { return baseStruct; }
239 void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
240
241 /// Accesses generic parameters of base struct (NULL if none such)
242 std::list<TypeDecl*> * get_baseParameters();
243
244 /// Looks up the members of this struct named "name" and places them into "foundDecls".
245 /// Clones declarations into "foundDecls", caller responsible for freeing
246 void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
247
248 virtual StructInstType *clone() const { return new StructInstType( *this ); }
249 virtual void accept( Visitor &v ) { v.visit( this ); }
250 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
251
252 virtual void print( std::ostream &os, int indent = 0 ) const;
253 private:
254 virtual std::string typeString() const;
255
256 // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
257 // where the structure used in this type is actually defined
258 StructDecl *baseStruct;
259};
260
261class UnionInstType : public ReferenceToType {
262 typedef ReferenceToType Parent;
263 public:
264 UnionInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseUnion( 0 ) {}
265 UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}
266
267 UnionDecl *get_baseUnion() const { return baseUnion; }
268 void set_baseUnion( UnionDecl *newValue ) { baseUnion = newValue; }
269
270 /// Accesses generic parameters of base union (NULL if none such)
271 std::list<TypeDecl*> * get_baseParameters();
272
273 /// looks up the members of this union named "name" and places them into "foundDecls"
274 /// Clones declarations into "foundDecls", caller responsible for freeing
275 void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
276
277 virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
278 virtual void accept( Visitor &v ) { v.visit( this ); }
279 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
280
281 virtual void print( std::ostream &os, int indent = 0 ) const;
282 private:
283 virtual std::string typeString() const;
284
285 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
286 // where the union used in this type is actually defined
287 UnionDecl *baseUnion;
288};
289
290class EnumInstType : public ReferenceToType {
291 typedef ReferenceToType Parent;
292 public:
293 EnumInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
294 EnumInstType( const EnumInstType &other ) : Parent( other ) {}
295
296 virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
297 virtual void accept( Visitor &v ) { v.visit( this ); }
298 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
299 private:
300 virtual std::string typeString() const;
301};
302
303class TraitInstType : public ReferenceToType {
304 typedef ReferenceToType Parent;
305 public:
306 TraitInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
307 TraitInstType( const TraitInstType &other );
308 ~TraitInstType();
309
310 std::list< Declaration* >& get_members() { return members; }
311
312 virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
313 virtual void accept( Visitor &v ) { v.visit( this ); }
314 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
315 private:
316 virtual std::string typeString() const;
317
318 // this member is filled in by the validate pass, which instantiates the members of the correponding
319 // aggregate with the actual type parameters specified for this use of the context
320 std::list< Declaration* > members;
321};
322
323class TypeInstType : public ReferenceToType {
324 typedef ReferenceToType Parent;
325 public:
326 TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType );
327 TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype );
328 TypeInstType( const TypeInstType &other ) : Parent( other ), baseType( other.baseType ), isFtype( other.isFtype ) {}
329 ~TypeInstType();
330
331 TypeDecl *get_baseType() const { return baseType; }
332 void set_baseType( TypeDecl *newValue );
333 bool get_isFtype() const { return isFtype; }
334 void set_isFtype( bool newValue ) { isFtype = newValue; }
335
336 virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
337 virtual void accept( Visitor &v ) { v.visit( this ); }
338 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
339 virtual void print( std::ostream &os, int indent = 0 ) const;
340 private:
341 virtual std::string typeString() const;
342 // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
343 // where the type used here is actually defined
344 TypeDecl *baseType;
345 bool isFtype;
346};
347
348class TupleType : public Type {
349 public:
350 TupleType( const Type::Qualifiers &tq );
351 TupleType( const TupleType& );
352 virtual ~TupleType();
353
354 std::list<Type*>& get_types() { return types; }
355
356 virtual TupleType *clone() const { return new TupleType( *this ); }
357 virtual void accept( Visitor &v ) { v.visit( this ); }
358 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
359 virtual void print( std::ostream &os, int indent = 0 ) const;
360 private:
361 std::list<Type*> types;
362};
363
364class TypeofType : public Type {
365 public:
366 TypeofType( const Type::Qualifiers &tq, Expression *expr );
367 TypeofType( const TypeofType& );
368 virtual ~TypeofType();
369
370 Expression *get_expr() const { return expr; }
371 void set_expr( Expression *newValue ) { expr = newValue; }
372
373 virtual TypeofType *clone() const { return new TypeofType( *this ); }
374 virtual void accept( Visitor &v ) { v.visit( this ); }
375 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
376 virtual void print( std::ostream &os, int indent = 0 ) const;
377 private:
378 Expression *expr;
379};
380
381class AttrType : public Type {
382 public:
383 AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr );
384 AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type );
385 AttrType( const AttrType& );
386 virtual ~AttrType();
387
388 const std::string &get_name() const { return name; }
389 void set_name( const std::string &newValue ) { name = newValue; }
390 Expression *get_expr() const { return expr; }
391 void set_expr( Expression *newValue ) { expr = newValue; }
392 Type *get_type() const { return type; }
393 void set_type( Type *newValue ) { type = newValue; }
394 bool get_isType() const { return isType; }
395 void set_isType( bool newValue ) { isType = newValue; }
396
397 virtual AttrType *clone() const { return new AttrType( *this ); }
398 virtual void accept( Visitor &v ) { v.visit( this ); }
399 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
400 virtual void print( std::ostream &os, int indent = 0 ) const;
401 private:
402 std::string name;
403 Expression *expr;
404 Type *type;
405 bool isType;
406};
407
408/// Represents the GCC built-in varargs type
409class VarArgsType : public Type {
410 public:
411 VarArgsType();
412 VarArgsType( Type::Qualifiers tq );
413
414 virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
415 virtual void accept( Visitor &v ) { v.visit( this ); }
416 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
417 virtual void print( std::ostream &os, int indent = 0 ) const;
418};
419
420inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
421 isConst |= other.isConst;
422 isVolatile |= other.isVolatile;
423 isRestrict |= other.isRestrict;
424 isLvalue |= other.isLvalue;
425 isAtomic |= other.isAtomic;
426 return *this;
427}
428
429inline Type::Qualifiers &Type::Qualifiers::operator-=( const Type::Qualifiers &other ) {
430 if ( other.isConst ) isConst = 0;
431 if ( other.isVolatile ) isVolatile = 0;
432 if ( other.isRestrict ) isRestrict = 0;
433 if ( other.isAtomic ) isAtomic = 0;
434 return *this;
435}
436
437inline Type::Qualifiers Type::Qualifiers::operator+( const Type::Qualifiers &other ) {
438 Qualifiers q = other;
439 q += *this;
440 return q;
441}
442
443inline bool Type::Qualifiers::operator==( const Qualifiers &other ) {
444 return isConst == other.isConst
445 && isVolatile == other.isVolatile
446// && isRestrict == other.isRestrict
447// && isLvalue == other.isLvalue
448 && isAtomic == other.isAtomic;
449}
450
451inline bool Type::Qualifiers::operator!=( const Qualifiers &other ) {
452 return isConst != other.isConst
453 || isVolatile != other.isVolatile
454// || isRestrict != other.isRestrict
455// || isLvalue != other.isLvalue
456 || isAtomic != other.isAtomic;
457}
458
459inline bool Type::Qualifiers::operator<=( const Type::Qualifiers &other ) {
460 return isConst <= other.isConst
461 && isVolatile <= other.isVolatile
462// && isRestrict <= other.isRestrict
463// && isLvalue >= other.isLvalue
464 && isAtomic == other.isAtomic;
465}
466
467inline bool Type::Qualifiers::operator>=( const Type::Qualifiers &other ) {
468 return isConst >= other.isConst
469 && isVolatile >= other.isVolatile
470// && isRestrict >= other.isRestrict
471// && isLvalue <= other.isLvalue
472 && isAtomic == other.isAtomic;
473}
474
475inline bool Type::Qualifiers::operator<( const Type::Qualifiers &other ) {
476 return operator!=( other ) && operator<=( other );
477}
478
479inline bool Type::Qualifiers::operator>( const Type::Qualifiers &other ) {
480 return operator!=( other ) && operator>=( other );
481}
482
483std::ostream & operator<<( std::ostream & out, const Type * type );
484
485#endif // TYPE_H
486
487// Local Variables: //
488// tab-width: 4 //
489// mode: c++ //
490// compile-command: "make install" //
491// End: //
Note: See TracBrowser for help on using the repository browser.