source: src/SynTree/Type.h@ eff03a94

new-env
Last change on this file since eff03a94 was 28f3a19, checked in by Aaron Moss <a3moss@…>, 7 years ago

Merge branch 'master' into with_gc
  • Property mode set to 100644
File size: 26.5 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
144 Qualifiers & get_qualifiers() { return tq; }
145 bool get_const() { return tq.is_const; }
146 bool get_volatile() { return tq.is_volatile; }
147 bool get_restrict() { return tq.is_restrict; }
148 bool get_lvalue() { return tq.is_lvalue; }
149 bool get_mutex() { return tq.is_mutex; }
150 bool get_atomic() { return tq.is_atomic; }
151 void set_const( bool newValue ) { tq.is_const = newValue; }
152 void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
153 void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
154 void set_lvalue( bool newValue ) { tq.is_lvalue = newValue; }
155 void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
156 void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
157
158 ForallList& get_forall() { return forall; }
159
160 std::list< Attribute * >& get_attributes() { return attributes; }
161 const std::list< Attribute * >& get_attributes() const { return attributes; }
162
163 /// How many elemental types are represented by this type
164 virtual unsigned size() const { return 1; };
165 virtual bool isVoid() const { return size() == 0; }
166 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; }
167
168 /// return type without outer pointers and arrays
169 Type * stripDeclarator();
170
171 /// return type without outer references
172 Type * stripReferences();
173
174 /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
175 virtual int referenceDepth() const;
176
177 virtual bool isComplete() const { return true; }
178
179 virtual AggregateDecl * getAggr() { assertf( false, "Non-aggregate type: %s", toCString( this ) ); }
180
181 virtual TypeSubstitution genericSubstitution() const;
182
183 virtual Type *clone() const = 0;
184 virtual void accept( Visitor & v ) = 0;
185 virtual Type *acceptMutator( Mutator & m ) = 0;
186 virtual void print( std::ostream & os, Indenter indent = {} ) const;
187};
188
189extern const Type::FuncSpecifiers noFuncSpecifiers;
190extern const Type::StorageClasses noStorageClasses;
191extern const Type::Qualifiers noQualifiers; // no qualifiers on constants
192
193class VoidType : public Type {
194 public:
195 VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
196
197 virtual unsigned size() const override { return 0; };
198 virtual bool isComplete() const override { return false; }
199
200 virtual VoidType *clone() const override { return new VoidType( *this ); }
201 virtual void accept( Visitor & v ) override { v.visit( this ); }
202 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
203 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
204};
205
206class BasicType : public Type {
207 public:
208 enum Kind {
209 Bool,
210 Char,
211 SignedChar,
212 UnsignedChar,
213 ShortSignedInt,
214 ShortUnsignedInt,
215 SignedInt,
216 UnsignedInt,
217 LongSignedInt,
218 LongUnsignedInt,
219 LongLongSignedInt,
220 LongLongUnsignedInt,
221 Float,
222 Double,
223 LongDouble,
224 FloatComplex,
225 DoubleComplex,
226 LongDoubleComplex,
227 FloatImaginary,
228 DoubleImaginary,
229 LongDoubleImaginary,
230 SignedInt128,
231 UnsignedInt128,
232 Float80,
233 Float128,
234 NUMBER_OF_BASIC_TYPES
235 } kind;
236
237 static const char *typeNames[]; // string names for basic types, MUST MATCH with Kind
238
239 BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
240
241 Kind get_kind() { return kind; }
242 void set_kind( Kind newValue ) { kind = newValue; }
243
244 virtual BasicType *clone() const override { return new BasicType( *this ); }
245 virtual void accept( Visitor & v ) override { v.visit( this ); }
246 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
247 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
248
249 bool isInteger() const;
250};
251
252class PointerType : public Type {
253 public:
254 Type *base;
255
256 // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
257 Expression *dimension;
258 bool isVarLen;
259 bool isStatic;
260
261 PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
262 PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
263 PointerType( const PointerType& );
264
265 Type *get_base() { return base; }
266 void set_base( Type *newValue ) { base = newValue; }
267 Expression *get_dimension() { return dimension; }
268 void set_dimension( Expression *newValue ) { dimension = newValue; }
269 bool get_isVarLen() { return isVarLen; }
270 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
271 bool get_isStatic() { return isStatic; }
272 void set_isStatic( bool newValue ) { isStatic = newValue; }
273
274 bool is_array() const { return isStatic || isVarLen || dimension; }
275
276 virtual bool isComplete() const override { return ! isVarLen; }
277
278 virtual PointerType *clone() const override { return new PointerType( *this ); }
279 virtual void accept( Visitor & v ) override { v.visit( this ); }
280 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
281 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
282};
283
284class ArrayType : public Type {
285 public:
286 Type *base;
287 Expression *dimension;
288 bool isVarLen;
289 bool isStatic;
290
291 ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
292 ArrayType( const ArrayType& );
293
294 Type *get_base() { return base; }
295 void set_base( Type *newValue ) { base = newValue; }
296 Expression *get_dimension() { return dimension; }
297 void set_dimension( Expression *newValue ) { dimension = newValue; }
298 bool get_isVarLen() { return isVarLen; }
299 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
300 bool get_isStatic() { return isStatic; }
301 void set_isStatic( bool newValue ) { isStatic = newValue; }
302
303 // array types are complete if they have a dimension expression or are
304 // VLAs ('*' in parameter declaration), and incomplete otherwise.
305 // See 6.7.6.2
306 virtual bool isComplete() const override { return dimension || isVarLen; }
307
308 virtual ArrayType *clone() const override { return new ArrayType( *this ); }
309 virtual void accept( Visitor & v ) override { v.visit( this ); }
310 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
311 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
312};
313
314class ReferenceType : public Type {
315public:
316 Type *base;
317
318 ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
319 ReferenceType( const ReferenceType & );
320
321 Type *get_base() { return base; }
322 void set_base( Type *newValue ) { base = newValue; }
323
324 virtual int referenceDepth() const override;
325
326 // Since reference types act like value types, their size is the size of the base.
327 // This makes it simple to cast the empty tuple to a reference type, since casts that increase
328 // the number of values are disallowed.
329 virtual unsigned size() const override { return base->size(); }
330
331 virtual TypeSubstitution genericSubstitution() const override;
332
333 virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
334 virtual void accept( Visitor & v ) override { v.visit( this ); }
335 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
336 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
337};
338
339class FunctionType : public Type {
340 public:
341 std::list<DeclarationWithType*> returnVals;
342 std::list<DeclarationWithType*> parameters;
343
344 // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
345 // This could be because of
346 // - an ellipsis in a prototype declaration
347 // - an unprototyped declaration
348 bool isVarArgs;
349
350 FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
351 FunctionType( const FunctionType& );
352
353 std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
354 std::list<DeclarationWithType*> & get_parameters() { return parameters; }
355 bool get_isVarArgs() const { return isVarArgs; }
356 void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
357 bool isTtype() const;
358
359 bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
360
361 virtual FunctionType *clone() const override { return new FunctionType( *this ); }
362 virtual void accept( Visitor & v ) override { v.visit( this ); }
363 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
364 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
365};
366
367class ReferenceToType : public Type {
368 public:
369 std::list< Expression* > parameters;
370 std::string name;
371 bool hoistType;
372
373 ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
374 ReferenceToType( const ReferenceToType & other );
375
376 const std::string & get_name() const { return name; }
377 void set_name( std::string newValue ) { name = newValue; }
378 std::list< Expression* >& get_parameters() { return parameters; }
379 bool get_hoistType() const { return hoistType; }
380 void set_hoistType( bool newValue ) { hoistType = newValue; }
381
382 virtual ReferenceToType *clone() const override = 0;
383 virtual void accept( Visitor & v ) override = 0;
384 virtual Type *acceptMutator( Mutator & m ) override = 0;
385 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
386
387 virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
388 protected:
389 virtual std::string typeString() const = 0;
390};
391
392class StructInstType : public ReferenceToType {
393 typedef ReferenceToType Parent;
394 public:
395 // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
396 // where the structure used in this type is actually defined
397 StructDecl *baseStruct;
398
399 StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
400 StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
401 StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
402
403 StructDecl *get_baseStruct() const { return baseStruct; }
404 void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
405
406 /// Accesses generic parameters of base struct (NULL if none such)
407 std::list<TypeDecl*> * get_baseParameters();
408 const std::list<TypeDecl*> * get_baseParameters() const;
409
410 virtual bool isComplete() const override;
411
412 virtual AggregateDecl * getAggr() override;
413
414 virtual TypeSubstitution genericSubstitution() const override;
415
416 /// Looks up the members of this struct named "name" and places them into "foundDecls".
417 /// Clones declarations into "foundDecls", caller responsible for freeing
418 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
419
420 virtual StructInstType *clone() const override { return new StructInstType( *this ); }
421 virtual void accept( Visitor & v ) override { v.visit( this ); }
422 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
423
424 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
425 private:
426 virtual std::string typeString() const override;
427};
428
429class UnionInstType : public ReferenceToType {
430 typedef ReferenceToType Parent;
431 public:
432 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
433 // where the union used in this type is actually defined
434 UnionDecl *baseUnion;
435
436 UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
437 UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
438 UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
439
440 UnionDecl *get_baseUnion() const { return baseUnion; }
441 void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
442
443 /// Accesses generic parameters of base union (NULL if none such)
444 std::list<TypeDecl*> * get_baseParameters();
445 const std::list<TypeDecl*> * get_baseParameters() const;
446
447 virtual bool isComplete() const override;
448
449 virtual AggregateDecl * getAggr() override;
450
451 virtual TypeSubstitution genericSubstitution() const override;
452
453 /// looks up the members of this union named "name" and places them into "foundDecls"
454 /// Clones declarations into "foundDecls", caller responsible for freeing
455 void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
456
457 virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
458 virtual void accept( Visitor & v ) override { v.visit( this ); }
459 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
460
461 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
462 private:
463 virtual std::string typeString() const override;
464};
465
466class EnumInstType : public ReferenceToType {
467 typedef ReferenceToType Parent;
468 public:
469 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
470 // where the union used in this type is actually defined
471 EnumDecl *baseEnum = nullptr;
472
473 EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
474 EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
475 EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
476
477 EnumDecl *get_baseEnum() const { return baseEnum; }
478 void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
479
480 virtual bool isComplete() const override;
481
482 virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
483 virtual void accept( Visitor & v ) override { v.visit( this ); }
484 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
485
486 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
487 private:
488 virtual std::string typeString() const override;
489};
490
491class TraitInstType : public ReferenceToType {
492 typedef ReferenceToType Parent;
493 public:
494 // this decl is not "owned" by the trait inst; it is merely a pointer to elsewhere in the tree,
495 // where the trait used in this type is actually defined
496 TraitDecl * baseTrait = nullptr;
497
498 TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
499 TraitInstType( const Type::Qualifiers & tq, TraitDecl * baseTrait, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
500 TraitInstType( const TraitInstType & other );
501
502 virtual bool isComplete() const override;
503
504 virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
505 virtual void accept( Visitor & v ) override { v.visit( this ); }
506 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
507 private:
508 virtual std::string typeString() const override;
509};
510
511class TypeInstType : public ReferenceToType {
512 typedef ReferenceToType Parent;
513 public:
514 // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
515 // where the type used here is actually defined
516 TypeDecl *baseType;
517 bool isFtype;
518
519 TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
520 TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
521 TypeInstType( const TypeInstType & other );
522
523 TypeDecl *get_baseType() const { return baseType; }
524 void set_baseType( TypeDecl *newValue );
525 bool get_isFtype() const { return isFtype; }
526 void set_isFtype( bool newValue ) { isFtype = newValue; }
527
528 virtual bool isComplete() const override;
529
530 virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
531 virtual void accept( Visitor & v ) override { v.visit( this ); }
532 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
533 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
534 private:
535 virtual std::string typeString() const override;
536};
537
538class TupleType : public Type {
539 public:
540 std::list<Type *> types;
541 std::list<Declaration *> members;
542
543 TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
544 TupleType( const TupleType& );
545
546 typedef std::list<Type*> value_type;
547 typedef value_type::iterator iterator;
548
549 std::list<Type *> & get_types() { return types; }
550 virtual unsigned size() const override { return types.size(); };
551
552 // For now, this is entirely synthetic -- tuple types always have unnamed members.
553 // Eventually, we may allow named tuples, in which case members should subsume types
554 std::list<Declaration *> & get_members() { return members; }
555
556 iterator begin() { return types.begin(); }
557 iterator end() { return types.end(); }
558
559 virtual Type * getComponent( unsigned i ) override {
560 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
561 return *(begin()+i);
562 }
563
564 // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
565
566 virtual TupleType *clone() const override { return new TupleType( *this ); }
567 virtual void accept( Visitor & v ) override { v.visit( this ); }
568 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
569 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
570};
571
572class TypeofType : public Type {
573 public:
574 Expression *expr;
575
576 TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
577 TypeofType( const TypeofType& );
578
579 Expression *get_expr() const { return expr; }
580 void set_expr( Expression *newValue ) { expr = newValue; }
581
582 virtual bool isComplete() const override { assert( false ); return false; }
583
584 virtual TypeofType *clone() const override { return new TypeofType( *this ); }
585 virtual void accept( Visitor & v ) override { v.visit( this ); }
586 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
587 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
588};
589
590class AttrType : public Type {
591 public:
592 std::string name;
593 Expression *expr;
594 Type *type;
595 bool isType;
596
597 AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
598 AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
599 AttrType( const AttrType& );
600
601 const std::string & get_name() const { return name; }
602 void set_name( const std::string & newValue ) { name = newValue; }
603 Expression *get_expr() const { return expr; }
604 void set_expr( Expression *newValue ) { expr = newValue; }
605 Type *get_type() const { return type; }
606 void set_type( Type *newValue ) { type = newValue; }
607 bool get_isType() const { return isType; }
608 void set_isType( bool newValue ) { isType = newValue; }
609
610 virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
611
612 virtual AttrType *clone() const override { return new AttrType( *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 the GCC built-in varargs type
619class VarArgsType : public Type {
620 public:
621 VarArgsType();
622 VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
623
624 virtual bool isComplete() const override{ return true; } // xxx - is this right?
625
626 virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
627 virtual void accept( Visitor & v ) override { v.visit( this ); }
628 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
629 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
630};
631
632/// Represents a zero constant
633class ZeroType : public Type {
634 public:
635 ZeroType();
636 ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
637
638 virtual ZeroType *clone() const override { return new ZeroType( *this ); }
639 virtual void accept( Visitor & v ) override { v.visit( this ); }
640 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
641 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
642};
643
644/// Represents a one constant
645class OneType : public Type {
646 public:
647 OneType();
648 OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
649
650 virtual OneType *clone() const override { return new OneType( *this ); }
651 virtual void accept( Visitor & v ) override { v.visit( this ); }
652 virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
653 virtual void print( std::ostream & os, Indenter indent = {} ) const override;
654};
655
656// Local Variables: //
657// tab-width: 4 //
658// mode: c++ //
659// compile-command: "make install" //
660// End: //
Note: See TracBrowser for help on using the repository browser.