source: translator/SynTree/Type.h@ 643a2e1

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 643a2e1 was 17cd4eb, checked in by Peter A. Buhr <pabuhr@…>, 11 years ago

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