source: src/SynTree/Type.h@ 9706554

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors ctor deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox memory 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 9706554 was 5d125e4, checked in by Peter A. Buhr <pabuhr@…>, 9 years ago

start code allowing structures to no fields
  • 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
330 TypeDecl *get_baseType() const { return baseType; }
331 void set_baseType( TypeDecl *newValue );
332 bool get_isFtype() const { return isFtype; }
333 void set_isFtype( bool newValue ) { isFtype = newValue; }
334
335 virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
336 virtual void accept( Visitor &v ) { v.visit( this ); }
337 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
338 virtual void print( std::ostream &os, int indent = 0 ) const;
339 private:
340 virtual std::string typeString() const;
341 // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
342 // where the type used here is actually defined
343 TypeDecl *baseType;
344 bool isFtype;
345};
346
347class TupleType : public Type {
348 public:
349 TupleType( const Type::Qualifiers &tq );
350 TupleType( const TupleType& );
351 virtual ~TupleType();
352
353 std::list<Type*>& get_types() { return types; }
354
355 virtual TupleType *clone() const { return new TupleType( *this ); }
356 virtual void accept( Visitor &v ) { v.visit( this ); }
357 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
358 virtual void print( std::ostream &os, int indent = 0 ) const;
359 private:
360 std::list<Type*> types;
361};
362
363class TypeofType : public Type {
364 public:
365 TypeofType( const Type::Qualifiers &tq, Expression *expr );
366 TypeofType( const TypeofType& );
367 virtual ~TypeofType();
368
369 Expression *get_expr() const { return expr; }
370 void set_expr( Expression *newValue ) { expr = newValue; }
371
372 virtual TypeofType *clone() const { return new TypeofType( *this ); }
373 virtual void accept( Visitor &v ) { v.visit( this ); }
374 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
375 virtual void print( std::ostream &os, int indent = 0 ) const;
376 private:
377 Expression *expr;
378};
379
380class AttrType : public Type {
381 public:
382 AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr );
383 AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type );
384 AttrType( const AttrType& );
385 virtual ~AttrType();
386
387 const std::string &get_name() const { return name; }
388 void set_name( const std::string &newValue ) { name = newValue; }
389 Expression *get_expr() const { return expr; }
390 void set_expr( Expression *newValue ) { expr = newValue; }
391 Type *get_type() const { return type; }
392 void set_type( Type *newValue ) { type = newValue; }
393 bool get_isType() const { return isType; }
394 void set_isType( bool newValue ) { isType = newValue; }
395
396 virtual AttrType *clone() const { return new AttrType( *this ); }
397 virtual void accept( Visitor &v ) { v.visit( this ); }
398 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
399 virtual void print( std::ostream &os, int indent = 0 ) const;
400 private:
401 std::string name;
402 Expression *expr;
403 Type *type;
404 bool isType;
405};
406
407/// Represents the GCC built-in varargs type
408class VarArgsType : public Type {
409 public:
410 VarArgsType();
411 VarArgsType( Type::Qualifiers tq );
412
413 virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
414 virtual void accept( Visitor &v ) { v.visit( this ); }
415 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
416 virtual void print( std::ostream &os, int indent = 0 ) const;
417};
418
419inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
420 isConst |= other.isConst;
421 isVolatile |= other.isVolatile;
422 isRestrict |= other.isRestrict;
423 isLvalue |= other.isLvalue;
424 isAtomic |= other.isAtomic;
425 return *this;
426}
427
428inline Type::Qualifiers &Type::Qualifiers::operator-=( const Type::Qualifiers &other ) {
429 if ( other.isConst ) isConst = 0;
430 if ( other.isVolatile ) isVolatile = 0;
431 if ( other.isRestrict ) isRestrict = 0;
432 if ( other.isAtomic ) isAtomic = 0;
433 return *this;
434}
435
436inline Type::Qualifiers Type::Qualifiers::operator+( const Type::Qualifiers &other ) {
437 Qualifiers q = other;
438 q += *this;
439 return q;
440}
441
442inline bool Type::Qualifiers::operator==( const Qualifiers &other ) {
443 return isConst == other.isConst
444 && isVolatile == other.isVolatile
445// && isRestrict == other.isRestrict
446// && isLvalue == other.isLvalue
447 && isAtomic == other.isAtomic;
448}
449
450inline bool Type::Qualifiers::operator!=( const Qualifiers &other ) {
451 return isConst != other.isConst
452 || isVolatile != other.isVolatile
453// || isRestrict != other.isRestrict
454// || isLvalue != other.isLvalue
455 || isAtomic != other.isAtomic;
456}
457
458inline bool Type::Qualifiers::operator<=( const Type::Qualifiers &other ) {
459 return isConst <= other.isConst
460 && isVolatile <= other.isVolatile
461// && isRestrict <= other.isRestrict
462// && isLvalue >= other.isLvalue
463 && isAtomic == other.isAtomic;
464}
465
466inline bool Type::Qualifiers::operator>=( const Type::Qualifiers &other ) {
467 return isConst >= other.isConst
468 && isVolatile >= other.isVolatile
469// && isRestrict >= other.isRestrict
470// && isLvalue <= other.isLvalue
471 && isAtomic == other.isAtomic;
472}
473
474inline bool Type::Qualifiers::operator<( const Type::Qualifiers &other ) {
475 return operator!=( other ) && operator<=( other );
476}
477
478inline bool Type::Qualifiers::operator>( const Type::Qualifiers &other ) {
479 return operator!=( other ) && operator>=( other );
480}
481
482std::ostream & operator<<( std::ostream & out, Type * type );
483
484#endif // TYPE_H
485
486// Local Variables: //
487// tab-width: 4 //
488// mode: c++ //
489// compile-command: "make install" //
490// End: //
Note: See TracBrowser for help on using the repository browser.