source: src/SynTree/Type.h@ bf26fa5

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 bf26fa5 was 43c89a7, checked in by Rob Schluntz <rschlunt@…>, 9 years ago

add hoistType flag (currently unused)
  • Property mode set to 100644
File size: 22.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 : Thu Feb 23 16:38:53 2017
13// Update Count : 34
14//
15
16#ifndef TYPE_H
17#define TYPE_H
18
19#include "BaseSyntaxNode.h"
20#include "Mutator.h"
21#include "SynTree.h"
22#include "Visitor.h"
23#include "Common/utility.h"
24
25class Type : public BaseSyntaxNode {
26 public:
27 struct Qualifiers {
28 Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ) {}
29 Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ) {}
30
31 Qualifiers &operator&=( const Qualifiers &other );
32 Qualifiers &operator+=( const Qualifiers &other );
33 Qualifiers &operator-=( const Qualifiers &other );
34 Qualifiers operator+( const Type::Qualifiers &other );
35 bool operator==( const Qualifiers &other );
36 bool operator!=( const Qualifiers &other );
37 bool operator<=( const Qualifiers &other );
38 bool operator>=( const Qualifiers &other );
39 bool operator<( const Qualifiers &other );
40 bool operator>( const Qualifiers &other );
41 void print( std::ostream &os, int indent = 0 ) const;
42
43 bool isConst;
44 bool isVolatile;
45 bool isRestrict;
46 bool isLvalue;
47 bool isAtomic;
48 };
49
50 Type( const Qualifiers &tq, const std::list< Attribute * > & attributes );
51 Type( const Type &other );
52 virtual ~Type();
53
54 Qualifiers &get_qualifiers() { return tq; }
55 bool get_isConst() { return tq.isConst; }
56 bool get_isVolatile() { return tq.isVolatile; }
57 bool get_isRestrict() { return tq.isRestrict; }
58 bool get_isLvalue() { return tq.isLvalue; }
59 bool get_isAtomic() { return tq.isAtomic; }
60 void set_isConst( bool newValue ) { tq.isConst = newValue; }
61 void set_isVolatile( bool newValue ) { tq.isVolatile = newValue; }
62 void set_isRestrict( bool newValue ) { tq.isRestrict = newValue; }
63 void set_isLvalue( bool newValue ) { tq.isLvalue = newValue; }
64 void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }
65
66 typedef std::list<TypeDecl *> ForallList;
67 ForallList& get_forall() { return forall; }
68
69 std::list< Attribute * >& get_attributes() { return attributes; }
70 const std::list< Attribute * >& get_attributes() const { return attributes; }
71
72 /// How many elemental types are represented by this type
73 virtual unsigned size() const { return 1; };
74 virtual bool isVoid() const { return size() == 0; }
75 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; }
76
77 virtual bool isComplete() const { return true; }
78
79 virtual Type *clone() const = 0;
80 virtual void accept( Visitor &v ) = 0;
81 virtual Type *acceptMutator( Mutator &m ) = 0;
82 virtual void print( std::ostream &os, int indent = 0 ) const;
83 private:
84 Qualifiers tq;
85 ForallList forall;
86 std::list< Attribute * > attributes;
87};
88
89extern Type::Qualifiers emptyQualifiers; // no qualifiers on constants
90
91class VoidType : public Type {
92 public:
93 VoidType( const Type::Qualifiers &tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
94
95 virtual unsigned size() const { return 0; };
96 virtual bool isComplete() const { return false; }
97
98 virtual VoidType *clone() const { return new VoidType( *this ); }
99 virtual void accept( Visitor &v ) { v.visit( this ); }
100 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
101 virtual void print( std::ostream &os, int indent = 0 ) const;
102};
103
104class BasicType : public Type {
105 public:
106 enum Kind {
107 Bool,
108 Char,
109 SignedChar,
110 UnsignedChar,
111 ShortSignedInt,
112 ShortUnsignedInt,
113 SignedInt,
114 UnsignedInt,
115 LongSignedInt,
116 LongUnsignedInt,
117 LongLongSignedInt,
118 LongLongUnsignedInt,
119 Float,
120 Double,
121 LongDouble,
122 FloatComplex,
123 DoubleComplex,
124 LongDoubleComplex,
125 FloatImaginary,
126 DoubleImaginary,
127 LongDoubleImaginary,
128 NUMBER_OF_BASIC_TYPES
129 };
130
131 static const char *typeNames[]; // string names for basic types, MUST MATCH with Kind
132
133 BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
134
135 Kind get_kind() { return kind; }
136 void set_kind( Kind newValue ) { kind = newValue; }
137
138 virtual BasicType *clone() const { return new BasicType( *this ); }
139 virtual void accept( Visitor &v ) { v.visit( this ); }
140 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
141 virtual void print( std::ostream &os, int indent = 0 ) const;
142
143 bool isInteger() const;
144 private:
145 Kind kind;
146};
147
148class PointerType : public Type {
149 public:
150 PointerType( const Type::Qualifiers &tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
151 PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
152 PointerType( const PointerType& );
153 virtual ~PointerType();
154
155 Type *get_base() { return base; }
156 void set_base( Type *newValue ) { base = newValue; }
157 Expression *get_dimension() { return dimension; }
158 void set_dimension( Expression *newValue ) { dimension = newValue; }
159 bool get_isVarLen() { return isVarLen; }
160 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
161 bool get_isStatic() { return isStatic; }
162 void set_isStatic( bool newValue ) { isStatic = newValue; }
163
164 virtual PointerType *clone() const { return new PointerType( *this ); }
165 virtual void accept( Visitor &v ) { v.visit( this ); }
166 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
167 virtual void print( std::ostream &os, int indent = 0 ) const;
168 private:
169 Type *base;
170
171 // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
172 Expression *dimension;
173 bool isVarLen;
174 bool isStatic;
175};
176
177class ArrayType : public Type {
178 public:
179 ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
180 ArrayType( const ArrayType& );
181 virtual ~ArrayType();
182
183 Type *get_base() { return base; }
184 void set_base( Type *newValue ) { base = newValue; }
185 Expression *get_dimension() { return dimension; }
186 void set_dimension( Expression *newValue ) { dimension = newValue; }
187 bool get_isVarLen() { return isVarLen; }
188 void set_isVarLen( bool newValue ) { isVarLen = newValue; }
189 bool get_isStatic() { return isStatic; }
190 void set_isStatic( bool newValue ) { isStatic = newValue; }
191
192 virtual bool isComplete() const { return ! isVarLen; }
193
194 virtual ArrayType *clone() const { return new ArrayType( *this ); }
195 virtual void accept( Visitor &v ) { v.visit( this ); }
196 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
197 virtual void print( std::ostream &os, int indent = 0 ) const;
198 private:
199 Type *base;
200 Expression *dimension;
201 bool isVarLen;
202 bool isStatic;
203};
204
205class FunctionType : public Type {
206 public:
207 FunctionType( const Type::Qualifiers &tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
208 FunctionType( const FunctionType& );
209 virtual ~FunctionType();
210
211 std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
212 std::list<DeclarationWithType*> & get_parameters() { return parameters; }
213 bool get_isVarArgs() const { return isVarArgs; }
214 void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
215
216 bool isTtype() const;
217
218 virtual FunctionType *clone() const { return new FunctionType( *this ); }
219 virtual void accept( Visitor &v ) { v.visit( this ); }
220 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
221 virtual void print( std::ostream &os, int indent = 0 ) const;
222 private:
223 std::list<DeclarationWithType*> returnVals;
224 std::list<DeclarationWithType*> parameters;
225
226 // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
227 // This could be because of
228 // - an ellipsis in a prototype declaration
229 // - an unprototyped declaration
230 bool isVarArgs;
231};
232
233class ReferenceToType : public Type {
234 public:
235 ReferenceToType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes );
236 ReferenceToType( const ReferenceToType &other );
237 virtual ~ReferenceToType();
238
239 const std::string &get_name() const { return name; }
240 void set_name( std::string newValue ) { name = newValue; }
241 std::list< Expression* >& get_parameters() { return parameters; }
242 bool get_hoistType() const { return hoistType; }
243 void set_hoistType( bool newValue ) { hoistType = newValue; }
244
245 virtual ReferenceToType *clone() const = 0;
246 virtual void accept( Visitor &v ) = 0;
247 virtual Type *acceptMutator( Mutator &m ) = 0;
248 virtual void print( std::ostream &os, int indent = 0 ) const;
249 protected:
250 virtual std::string typeString() const = 0;
251 std::list< Expression* > parameters;
252 std::string name;
253 private:
254 bool hoistType;
255};
256
257class StructInstType : public ReferenceToType {
258 typedef ReferenceToType Parent;
259 public:
260 StructInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
261 StructInstType( const Type::Qualifiers &tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
262 StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
263
264 StructDecl *get_baseStruct() const { return baseStruct; }
265 void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
266
267 /// Accesses generic parameters of base struct (NULL if none such)
268 std::list<TypeDecl*> * get_baseParameters();
269
270 virtual bool isComplete() const;
271
272 /// Looks up the members of this struct named "name" and places them into "foundDecls".
273 /// Clones declarations into "foundDecls", caller responsible for freeing
274 void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
275
276 virtual StructInstType *clone() const { return new StructInstType( *this ); }
277 virtual void accept( Visitor &v ) { v.visit( this ); }
278 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
279
280 virtual void print( std::ostream &os, int indent = 0 ) const;
281 private:
282 virtual std::string typeString() const;
283
284 // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
285 // where the structure used in this type is actually defined
286 StructDecl *baseStruct;
287};
288
289class UnionInstType : public ReferenceToType {
290 typedef ReferenceToType Parent;
291 public:
292 UnionInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
293 UnionInstType( const Type::Qualifiers &tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
294 UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}
295
296 UnionDecl *get_baseUnion() const { return baseUnion; }
297 void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
298
299 /// Accesses generic parameters of base union (NULL if none such)
300 std::list< TypeDecl * > * get_baseParameters();
301
302 virtual bool isComplete() const;
303
304 /// looks up the members of this union named "name" and places them into "foundDecls"
305 /// Clones declarations into "foundDecls", caller responsible for freeing
306 void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
307
308 virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
309 virtual void accept( Visitor &v ) { v.visit( this ); }
310 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
311
312 virtual void print( std::ostream &os, int indent = 0 ) const;
313 private:
314 virtual std::string typeString() const;
315
316 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
317 // where the union used in this type is actually defined
318 UnionDecl *baseUnion;
319};
320
321class EnumInstType : public ReferenceToType {
322 typedef ReferenceToType Parent;
323 public:
324 EnumInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
325 EnumInstType( const Type::Qualifiers &tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
326 EnumInstType( const EnumInstType &other ) : Parent( other ), baseEnum( other.baseEnum ) {}
327
328 EnumDecl *get_baseEnum() const { return baseEnum; }
329 void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
330
331 virtual bool isComplete() const;
332
333 virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
334 virtual void accept( Visitor &v ) { v.visit( this ); }
335 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
336 private:
337 virtual std::string typeString() const;
338
339 // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
340 // where the union used in this type is actually defined
341 EnumDecl *baseEnum = nullptr;
342};
343
344class TraitInstType : public ReferenceToType {
345 typedef ReferenceToType Parent;
346 public:
347 TraitInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >() ) : Parent( tq, name, attributes ) {}
348 TraitInstType( const TraitInstType &other );
349 ~TraitInstType();
350
351 std::list< Declaration* >& get_members() { return members; }
352
353 virtual bool isComplete() const;
354
355 virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
356 virtual void accept( Visitor &v ) { v.visit( this ); }
357 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
358 private:
359 virtual std::string typeString() const;
360
361 // this member is filled in by the validate pass, which instantiates the members of the correponding
362 // aggregate with the actual type parameters specified for this use of the context
363 std::list< Declaration* > members;
364};
365
366class TypeInstType : public ReferenceToType {
367 typedef ReferenceToType Parent;
368 public:
369 TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
370 TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
371 TypeInstType( const TypeInstType &other );
372 ~TypeInstType();
373
374 TypeDecl *get_baseType() const { return baseType; }
375 void set_baseType( TypeDecl *newValue );
376 bool get_isFtype() const { return isFtype; }
377 void set_isFtype( bool newValue ) { isFtype = newValue; }
378
379 virtual bool isComplete() const;
380
381 virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
382 virtual void accept( Visitor &v ) { v.visit( this ); }
383 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
384 virtual void print( std::ostream &os, int indent = 0 ) const;
385 private:
386 virtual std::string typeString() const;
387 // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
388 // where the type used here is actually defined
389 TypeDecl *baseType;
390 bool isFtype;
391};
392
393class TupleType : public Type {
394 public:
395 TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >() );
396 TupleType( const TupleType& );
397 virtual ~TupleType();
398
399 typedef std::list<Type*> value_type;
400 typedef value_type::iterator iterator;
401
402 std::list<Type*>& get_types() { return types; }
403 virtual unsigned size() const { return types.size(); };
404
405 iterator begin() { return types.begin(); }
406 iterator end() { return types.end(); }
407
408 virtual Type * getComponent( unsigned i ) {
409 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
410 return *(begin()+i);
411 }
412
413 // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
414
415 virtual TupleType *clone() const { return new TupleType( *this ); }
416 virtual void accept( Visitor &v ) { v.visit( this ); }
417 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
418 virtual void print( std::ostream &os, int indent = 0 ) const;
419 private:
420 std::list<Type*> types;
421};
422
423class TypeofType : public Type {
424 public:
425 TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
426 TypeofType( const TypeofType& );
427 virtual ~TypeofType();
428
429 Expression *get_expr() const { return expr; }
430 void set_expr( Expression *newValue ) { expr = newValue; }
431
432 virtual bool isComplete() const { assert( false ); return false; }
433
434 virtual TypeofType *clone() const { return new TypeofType( *this ); }
435 virtual void accept( Visitor &v ) { v.visit( this ); }
436 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
437 virtual void print( std::ostream &os, int indent = 0 ) const;
438 private:
439 Expression *expr;
440};
441
442class AttrType : public Type {
443 public:
444 AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
445 AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
446 AttrType( const AttrType& );
447 virtual ~AttrType();
448
449 const std::string &get_name() const { return name; }
450 void set_name( const std::string &newValue ) { name = newValue; }
451 Expression *get_expr() const { return expr; }
452 void set_expr( Expression *newValue ) { expr = newValue; }
453 Type *get_type() const { return type; }
454 void set_type( Type *newValue ) { type = newValue; }
455 bool get_isType() const { return isType; }
456 void set_isType( bool newValue ) { isType = newValue; }
457
458 virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
459
460 virtual AttrType *clone() const { return new AttrType( *this ); }
461 virtual void accept( Visitor &v ) { v.visit( this ); }
462 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
463 virtual void print( std::ostream &os, int indent = 0 ) const;
464 private:
465 std::string name;
466 Expression *expr;
467 Type *type;
468 bool isType;
469};
470
471/// Represents the GCC built-in varargs type
472class VarArgsType : public Type {
473 public:
474 VarArgsType();
475 VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
476
477 virtual bool isComplete() const{ return true; } // xxx - is this right?
478
479 virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
480 virtual void accept( Visitor &v ) { v.visit( this ); }
481 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
482 virtual void print( std::ostream &os, int indent = 0 ) const;
483};
484
485/// Represents a zero constant
486class ZeroType : public Type {
487 public:
488 ZeroType();
489 ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
490
491 virtual ZeroType *clone() const { return new ZeroType( *this ); }
492 virtual void accept( Visitor &v ) { v.visit( this ); }
493 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
494 virtual void print( std::ostream &os, int indent = 0 ) const;
495};
496
497/// Represents a one constant
498class OneType : public Type {
499 public:
500 OneType();
501 OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
502
503 virtual OneType *clone() const { return new OneType( *this ); }
504 virtual void accept( Visitor &v ) { v.visit( this ); }
505 virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
506 virtual void print( std::ostream &os, int indent = 0 ) const;
507};
508
509inline Type::Qualifiers &Type::Qualifiers::operator&=( const Type::Qualifiers &other ) {
510 isConst &= other.isConst;
511 isVolatile &= other.isVolatile;
512 isRestrict &= other.isRestrict;
513 isLvalue &= other.isLvalue;
514 isAtomic &= other.isAtomic;
515 return *this;
516}
517
518inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
519 isConst |= other.isConst;
520 isVolatile |= other.isVolatile;
521 isRestrict |= other.isRestrict;
522 isLvalue |= other.isLvalue;
523 isAtomic |= other.isAtomic;
524 return *this;
525}
526
527inline Type::Qualifiers &Type::Qualifiers::operator-=( const Type::Qualifiers &other ) {
528 if ( other.isConst ) isConst = 0;
529 if ( other.isVolatile ) isVolatile = 0;
530 if ( other.isRestrict ) isRestrict = 0;
531 if ( other.isAtomic ) isAtomic = 0;
532 return *this;
533}
534
535inline Type::Qualifiers Type::Qualifiers::operator+( const Type::Qualifiers &other ) {
536 Qualifiers q = other;
537 q += *this;
538 return q;
539}
540
541inline bool Type::Qualifiers::operator==( const Qualifiers &other ) {
542 return isConst == other.isConst
543 && isVolatile == other.isVolatile
544// && isRestrict == other.isRestrict
545// && isLvalue == other.isLvalue
546 && isAtomic == other.isAtomic;
547}
548
549inline bool Type::Qualifiers::operator!=( const Qualifiers &other ) {
550 return isConst != other.isConst
551 || isVolatile != other.isVolatile
552// || isRestrict != other.isRestrict
553// || isLvalue != other.isLvalue
554 || isAtomic != other.isAtomic;
555}
556
557inline bool Type::Qualifiers::operator<=( const Type::Qualifiers &other ) {
558 return isConst <= other.isConst
559 && isVolatile <= other.isVolatile
560// && isRestrict <= other.isRestrict
561// && isLvalue >= other.isLvalue
562 && isAtomic == other.isAtomic;
563}
564
565inline bool Type::Qualifiers::operator>=( const Type::Qualifiers &other ) {
566 return isConst >= other.isConst
567 && isVolatile >= other.isVolatile
568// && isRestrict >= other.isRestrict
569// && isLvalue <= other.isLvalue
570 && isAtomic == other.isAtomic;
571}
572
573inline bool Type::Qualifiers::operator<( const Type::Qualifiers &other ) {
574 return operator!=( other ) && operator<=( other );
575}
576
577inline bool Type::Qualifiers::operator>( const Type::Qualifiers &other ) {
578 return operator!=( other ) && operator>=( other );
579}
580
581std::ostream & operator<<( std::ostream & out, const Type * type );
582
583#endif // TYPE_H
584
585// Local Variables: //
586// tab-width: 4 //
587// mode: c++ //
588// compile-command: "make install" //
589// End: //
Note: See TracBrowser for help on using the repository browser.