source: src/SynTree/Type.h@ 258eb5c9

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors ctor deferred_resn demangler enum forall-pointer-decay gc_noraii jacob/cs343-translation jenkins-sandbox memory new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new string with_gc
Last change on this file since 258eb5c9 was 37a3b8f9, checked in by Aaron Moss <a3moss@…>, 10 years ago

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