source: src/SynTree/Type.h@ 4e7a4e6

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 4e7a4e6 was 99b7d4fc, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

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