source: src/SynTree/Type.h@ 999c700

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 with_gc
Last change on this file since 999c700 was 4ee3b0c1, checked in by Rob Schluntz <rschlunt@…>, 7 years ago

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