source: src/SynTree/Type.h @ c54b0b4

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since c54b0b4 was c54b0b4, checked in by Thierry Delisle <tdelisle@…>, 5 years ago

Added isMutex qualifier

  • Property mode set to 100644
File size: 22.2 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 : Wed Mar  1 09:11:45 2017
13// Update Count     : 41
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
24class Type : public BaseSyntaxNode {
25  public:
26        struct Qualifiers {
27                Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ), isMutex( false ) {}
28                Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isMutex ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isMutex( isMutex ) {}
29
30                Qualifiers &operator&=( const Qualifiers &other );
31                Qualifiers &operator+=( const Qualifiers &other );
32                Qualifiers &operator-=( const Qualifiers &other );
33                Qualifiers operator+( const Type::Qualifiers &other );
34                bool operator==( const 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                void print( std::ostream &os, int indent = 0 ) const;
41
42                bool isConst;
43                bool isVolatile;
44                bool isRestrict;
45                bool isLvalue;
46                bool isAtomic;
47                bool isMutex;
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        bool isTtype() const;
216
217        virtual FunctionType *clone() const { return new FunctionType( *this ); }
218        virtual void accept( Visitor &v ) { v.visit( this ); }
219        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
220        virtual void print( std::ostream &os, int indent = 0 ) const;
221  private:
222        std::list<DeclarationWithType*> returnVals;
223        std::list<DeclarationWithType*> parameters;
224
225        // Does the function accept a variable number of arguments following the arguments specified in the parameters list.
226        // This could be because of
227        // - an ellipsis in a prototype declaration
228        // - an unprototyped declaration
229        bool isVarArgs;
230};
231
232class ReferenceToType : public Type {
233  public:
234        ReferenceToType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes );
235        ReferenceToType( const ReferenceToType &other );
236        virtual ~ReferenceToType();
237
238        const std::string &get_name() const { return name; }
239        void set_name( std::string newValue ) { name = newValue; }
240        std::list< Expression* >& get_parameters() { return parameters; }
241        bool get_hoistType() const { return hoistType; }
242        void set_hoistType( bool newValue ) { hoistType = newValue; }
243
244        virtual ReferenceToType *clone() const = 0;
245        virtual void accept( Visitor &v ) = 0;
246        virtual Type *acceptMutator( Mutator &m ) = 0;
247        virtual void print( std::ostream &os, int indent = 0 ) const;
248  protected:
249        virtual std::string typeString() const = 0;
250        std::list< Expression* > parameters;
251        std::string name;
252  private:
253        bool hoistType;
254};
255
256class StructInstType : public ReferenceToType {
257        typedef ReferenceToType Parent;
258  public:
259        StructInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
260        StructInstType( const Type::Qualifiers &tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
261        StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
262
263        StructDecl *get_baseStruct() const { return baseStruct; }
264        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
265
266        /// Accesses generic parameters of base struct (NULL if none such)
267        std::list<TypeDecl*> * get_baseParameters();
268
269        virtual bool isComplete() const;
270
271        /// Looks up the members of this struct named "name" and places them into "foundDecls".
272        /// Clones declarations into "foundDecls", caller responsible for freeing
273        void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
274
275        virtual StructInstType *clone() const { return new StructInstType( *this ); }
276        virtual void accept( Visitor &v ) { v.visit( this ); }
277        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
278
279        virtual void print( std::ostream &os, int indent = 0 ) const;
280  private:
281        virtual std::string typeString() const;
282
283        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
284        // where the structure used in this type is actually defined
285        StructDecl *baseStruct;
286};
287
288class UnionInstType : public ReferenceToType {
289        typedef ReferenceToType Parent;
290  public:
291        UnionInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
292        UnionInstType( const Type::Qualifiers &tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
293        UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}
294
295        UnionDecl *get_baseUnion() const { return baseUnion; }
296        void set_baseUnion( UnionDecl * newValue ) { baseUnion = newValue; }
297
298        /// Accesses generic parameters of base union (NULL if none such)
299        std::list< TypeDecl * > * get_baseParameters();
300
301        virtual bool isComplete() const;
302
303        /// looks up the members of this union named "name" and places them into "foundDecls"
304        /// Clones declarations into "foundDecls", caller responsible for freeing
305        void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
306
307        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
308        virtual void accept( Visitor &v ) { v.visit( this ); }
309        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
310
311        virtual void print( std::ostream &os, int indent = 0 ) const;
312  private:
313        virtual std::string typeString() const;
314
315        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
316        // where the union used in this type is actually defined
317        UnionDecl *baseUnion;
318};
319
320class EnumInstType : public ReferenceToType {
321        typedef ReferenceToType Parent;
322  public:
323        EnumInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
324        EnumInstType( const Type::Qualifiers &tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
325        EnumInstType( const EnumInstType &other ) : Parent( other ), baseEnum( other.baseEnum ) {}
326
327        EnumDecl *get_baseEnum() const { return baseEnum; }
328        void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
329
330        virtual bool isComplete() const;
331
332        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
333        virtual void accept( Visitor &v ) { v.visit( this ); }
334        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
335  private:
336        virtual std::string typeString() const;
337
338        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
339        // where the union used in this type is actually defined
340        EnumDecl *baseEnum = nullptr;
341};
342
343class TraitInstType : public ReferenceToType {
344        typedef ReferenceToType Parent;
345  public:
346        TraitInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
347        TraitInstType( const TraitInstType &other );
348        ~TraitInstType();
349
350        std::list< Declaration* >& get_members() { return members; }
351
352        virtual bool isComplete() const;
353
354        virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
355        virtual void accept( Visitor &v ) { v.visit( this ); }
356        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
357  private:
358        virtual std::string typeString() const;
359
360        // this member is filled in by the validate pass, which instantiates the members of the correponding
361        // aggregate with the actual type parameters specified for this use of the context
362        std::list< Declaration* > members;
363};
364
365class TypeInstType : public ReferenceToType {
366        typedef ReferenceToType Parent;
367  public:
368        TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
369        TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
370        TypeInstType( const TypeInstType &other );
371        ~TypeInstType();
372
373        TypeDecl *get_baseType() const { return baseType; }
374        void set_baseType( TypeDecl *newValue );
375        bool get_isFtype() const { return isFtype; }
376        void set_isFtype( bool newValue ) { isFtype = newValue; }
377
378        virtual bool isComplete() const;
379
380        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
381        virtual void accept( Visitor &v ) { v.visit( this ); }
382        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
383        virtual void print( std::ostream &os, int indent = 0 ) const;
384  private:
385        virtual std::string typeString() const;
386        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
387        // where the type used here is actually defined
388        TypeDecl *baseType;
389        bool isFtype;
390};
391
392class TupleType : public Type {
393  public:
394        TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
395        TupleType( const TupleType& );
396        virtual ~TupleType();
397
398        typedef std::list<Type*> value_type;
399        typedef value_type::iterator iterator;
400
401        std::list<Type*>& get_types() { return types; }
402        virtual unsigned size() const { return types.size(); };
403
404        iterator begin() { return types.begin(); }
405        iterator end() { return types.end(); }
406
407        virtual Type * getComponent( unsigned i ) {
408                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
409                return *(begin()+i);
410        }
411
412        // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
413
414        virtual TupleType *clone() const { return new TupleType( *this ); }
415        virtual void accept( Visitor &v ) { v.visit( this ); }
416        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
417        virtual void print( std::ostream &os, int indent = 0 ) const;
418  private:
419        std::list<Type*> types;
420};
421
422class TypeofType : public Type {
423  public:
424        TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
425        TypeofType( const TypeofType& );
426        virtual ~TypeofType();
427
428        Expression *get_expr() const { return expr; }
429        void set_expr( Expression *newValue ) { expr = newValue; }
430
431        virtual bool isComplete() const { assert( false ); return false; }
432
433        virtual TypeofType *clone() const { return new TypeofType( *this ); }
434        virtual void accept( Visitor &v ) { v.visit( this ); }
435        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
436        virtual void print( std::ostream &os, int indent = 0 ) const;
437  private:
438        Expression *expr;
439};
440
441class AttrType : public Type {
442  public:
443        AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
444        AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
445        AttrType( const AttrType& );
446        virtual ~AttrType();
447
448        const std::string &get_name() const { return name; }
449        void set_name( const std::string &newValue ) { name = newValue; }
450        Expression *get_expr() const { return expr; }
451        void set_expr( Expression *newValue ) { expr = newValue; }
452        Type *get_type() const { return type; }
453        void set_type( Type *newValue ) { type = newValue; }
454        bool get_isType() const { return isType; }
455        void set_isType( bool newValue ) { isType = newValue; }
456
457        virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
458
459        virtual AttrType *clone() const { return new AttrType( *this ); }
460        virtual void accept( Visitor &v ) { v.visit( this ); }
461        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
462        virtual void print( std::ostream &os, int indent = 0 ) const;
463  private:
464        std::string name;
465        Expression *expr;
466        Type *type;
467        bool isType;
468};
469
470/// Represents the GCC built-in varargs type
471class VarArgsType : public Type {
472  public:
473        VarArgsType();
474        VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
475
476        virtual bool isComplete() const{ return true; } // xxx - is this right?
477
478        virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
479        virtual void accept( Visitor &v ) { v.visit( this ); }
480        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
481        virtual void print( std::ostream &os, int indent = 0 ) const;
482};
483
484/// Represents a zero constant
485class ZeroType : public Type {
486  public:
487        ZeroType();
488        ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
489
490        virtual ZeroType *clone() const { return new ZeroType( *this ); }
491        virtual void accept( Visitor &v ) { v.visit( this ); }
492        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
493        virtual void print( std::ostream &os, int indent = 0 ) const;
494};
495
496/// Represents a one constant
497class OneType : public Type {
498  public:
499        OneType();
500        OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
501
502        virtual OneType *clone() const { return new OneType( *this ); }
503        virtual void accept( Visitor &v ) { v.visit( this ); }
504        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
505        virtual void print( std::ostream &os, int indent = 0 ) const;
506};
507
508inline Type::Qualifiers &Type::Qualifiers::operator&=( const Type::Qualifiers &other ) {
509        isConst &= other.isConst;
510        isVolatile &= other.isVolatile;
511        isRestrict &= other.isRestrict;
512        isLvalue &= other.isLvalue;
513        isAtomic &= other.isAtomic;
514        isMutex &= other.isMutex;
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        isMutex |= other.isMutex;
525        return *this;
526}
527
528inline Type::Qualifiers &Type::Qualifiers::operator-=( const Type::Qualifiers &other ) {
529        if ( other.isConst ) isConst = 0;
530        if ( other.isVolatile ) isVolatile = 0;
531        if ( other.isRestrict ) isRestrict = 0;
532        if ( other.isAtomic ) isAtomic = 0;
533        if ( other.isMutex ) isMutex = 0;
534        return *this;
535}
536
537inline Type::Qualifiers Type::Qualifiers::operator+( const Type::Qualifiers &other ) {
538        Qualifiers q = other;
539        q += *this;
540        return q;
541}
542
543inline bool Type::Qualifiers::operator==( const Qualifiers &other ) {
544        return isConst == other.isConst
545                && isVolatile == other.isVolatile
546//              && isRestrict == other.isRestrict
547//              && isLvalue == other.isLvalue
548                && isAtomic == other.isAtomic;
549}
550
551inline bool Type::Qualifiers::operator!=( const Qualifiers &other ) {
552        return isConst != other.isConst
553                || isVolatile != other.isVolatile
554//              || isRestrict != other.isRestrict
555//              || isLvalue != other.isLvalue
556                || isAtomic != other.isAtomic;
557}
558
559inline bool Type::Qualifiers::operator<=( const Type::Qualifiers &other ) {
560        return isConst <= other.isConst
561                && isVolatile <= other.isVolatile
562//              && isRestrict <= other.isRestrict
563//              && isLvalue >= other.isLvalue
564                && isAtomic == other.isAtomic;
565}
566
567inline bool Type::Qualifiers::operator>=( const Type::Qualifiers &other ) {
568        return isConst >= other.isConst
569                && isVolatile >= other.isVolatile
570//              && isRestrict >= other.isRestrict
571//              && isLvalue <= other.isLvalue
572                && isAtomic == other.isAtomic;
573}
574
575inline bool Type::Qualifiers::operator<( const Type::Qualifiers &other ) {
576        return operator!=( other ) && operator<=( other );
577}
578
579inline bool Type::Qualifiers::operator>( const Type::Qualifiers &other ) {
580        return operator!=( other ) && operator>=( other );
581}
582
583std::ostream & operator<<( std::ostream & out, const Type * type );
584
585#endif // TYPE_H
586
587// Local Variables: //
588// tab-width: 4 //
589// mode: c++ //
590// compile-command: "make install" //
591// End: //
Note: See TracBrowser for help on using the repository browser.