Changeset 946bcca for src/SynTree/Type.h


Ignore:
Timestamp:
Mar 17, 2017, 1:14:44 PM (8 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
14a33790, 7c70089, 89d129c
Parents:
b2f5082 (diff), 615a096 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/SynTree/Type.h

    rb2f5082 r946bcca  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 16 12:11:50 2017
    13 // Update Count     : 116
     12// Last Modified On : Fri Mar 17 09:04:03 2017
     13// Update Count     : 147
    1414//
    1515
    … …  
    2121#include "SynTree.h"
    2222#include "Visitor.h"
     23#include <strings.h>                                                                    // ffs
    2324
    2425class Type : public BaseSyntaxNode {
    2526  public:
    26         #define CommonBF( N ) \
     27        // Simulate inheritance because union does not allow it.
     28        // Bug in g++-4.9 prevents static field in union
     29        //static const char * Names[];
     30        #define BFCommon( BFType, N ) \
    2731                bool operator[]( unsigned int i ) const { return val & (1 << i); } \
    2832                bool any() const { return val != 0; } \
    29                 static const char * Names[]; \
     33                void reset() { val = 0; } \
     34                int ffs() { return ::ffs( val ) - 1; } \
     35                BFType operator&=( BFType other ) { \
     36                        val &= other.val; return *this; \
     37                } \
     38                BFType operator&( BFType other ) const { \
     39                        BFType q = other; \
     40                        q &= *this; \
     41                        return q; \
     42                } \
     43                BFType operator|=( BFType other ) { \
     44                        val |= other.val; return *this; \
     45                } \
     46                BFType operator|( BFType other ) const { \
     47                        BFType q = other; \
     48                        q |= *this; \
     49                        return q; \
     50                } \
     51                BFType operator-=( BFType other ) { \
     52                        val &= ~other.val; return *this; \
     53                } \
    3054                void print( std::ostream & os ) const { \
    3155                        if ( (*this).any() ) { \
    3256                                for ( unsigned int i = 0; i < N; i += 1 ) { \
    3357                                        if ( (*this)[i] ) { \
    34                                                 os << Names[i] << ' '; \
     58                                                os << BFType##Names[i] << ' '; \
    3559                                        } \
    3660                                } \
    … …  
    4165
    4266        enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
     67        static const char * FuncSpecifiersNames[];
    4368        union FuncSpecifiers {
    4469                unsigned int val;
    … …  
    5075                FuncSpecifiers() : val( 0 ) {}
    5176                FuncSpecifiers( unsigned int val ) : val( val ) {}
    52                 CommonBF( NumFuncSpecifier )
     77                // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
     78                BFCommon( FuncSpecifiers, NumFuncSpecifier )
    5379        }; // FuncSpecifiers
    5480
    5581        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
     82        static const char * StorageClassesNames[];
    5683        union StorageClasses {
    5784                unsigned int val;
    … …  
    6693                StorageClasses() : val( 0 ) {}
    6794                StorageClasses( unsigned int val ) : val( val ) {}
    68                 CommonBF( NumStorageClass )
     95                // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
     96                BFCommon( StorageClasses, NumStorageClass )
    6997        }; // StorageClasses
    7098
    7199        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
     100        static const char * QualifiersNames[];
    72101        union Qualifiers {
    73102                enum { Mask = ~(Restrict | Lvalue) };
    74103                unsigned int val;
    75104                struct {
    76                         bool isConst : 1;
    77                         bool isRestrict : 1;
    78                         bool isVolatile : 1;
    79                         bool isLvalue : 1;
    80                         bool isMutex : 1;
    81                         bool isAtomic : 1;
     105                        bool is_const : 1;
     106                        bool is_restrict : 1;
     107                        bool is_volatile : 1;
     108                        bool is_lvalue : 1;
     109                        bool is_mutex : 1;
     110                        bool is_atomic : 1;
    82111                };
    83112
    84113                Qualifiers() : val( 0 ) {}
    85114                Qualifiers( unsigned int val ) : val( val ) {}
    86                 bool operator==( Qualifiers other ) const {
    87                         return (val & Mask) == (other.val & Mask);
     115                // Complex comparisons provide implicit qualifier downcasting, e.g., T downcast to const T.
     116                bool operator==( Qualifiers other ) const { return (val & Mask) == (other.val & Mask); }
     117                bool operator!=( Qualifiers other ) const { return (val & Mask) != (other.val & Mask); }
     118                bool operator<=( Qualifiers other ) const {
     119                        return is_const <= other.is_const && is_volatile <= other.is_volatile &&
     120                                is_mutex >= other.is_mutex && is_atomic == other.is_atomic;
    88121                }
    89                 bool operator!=( Qualifiers other ) const {
    90                         return (val & Mask) != (other.val & Mask);
    91                 }
    92                 bool operator<=( Qualifiers other ) const {
    93                         return isConst <= other.isConst && isVolatile <= other.isVolatile &&
    94                                 isMutex == other.isMutex && isAtomic == other.isAtomic;
    95                 }
    96                 bool operator>=( Qualifiers other ) const {
    97                         return isConst >= other.isConst && isVolatile >= other.isVolatile &&
    98                                 isMutex == other.isMutex && isAtomic == other.isAtomic;
    99                 }
    100                 bool operator<( Qualifiers other ) const {
    101                         return *this != other && *this <= other;
    102                 }
    103                 bool operator>( Qualifiers other ) const {
    104                         return *this != other && *this >= other;
    105                 }
    106                 Qualifiers operator&=( Type::Qualifiers other ) {
    107                         val &= other.val; return *this;
    108                 }
    109                 Qualifiers operator+=( Qualifiers other ) {
    110                         val |= other.val; return *this;
    111                 }
    112                 Qualifiers operator-=( Qualifiers other ) {
    113                         val &= ~other.val; return *this;
    114                 }
    115                 Qualifiers operator+( Qualifiers other ) const {
    116                         Qualifiers q = other;
    117                         q += *this;
    118                         return q;
    119                 }
    120                 CommonBF( NumTypeQualifier )
     122                bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
     123                bool operator>=( Qualifiers other ) const { return ! (*this < other); }
     124                bool operator>( Qualifiers other ) const { return *this != other && *this >= other; }
     125                BFCommon( Qualifiers, NumTypeQualifier )
    121126        }; // Qualifiers
    122127
    … …  
    126131
    127132        Qualifiers & get_qualifiers() { return tq; }
    128         bool get_isConst() { return tq.isConst; }
    129         bool get_isVolatile() { return tq.isVolatile; }
    130         bool get_isRestrict() { return tq.isRestrict; }
    131         bool get_isLvalue() { return tq.isLvalue; }
    132         bool get_isAtomic() { return tq.isAtomic; }
    133         void set_isConst( bool newValue ) { tq.isConst = newValue; }
    134         void set_isVolatile( bool newValue ) { tq.isVolatile = newValue; }
    135         void set_isRestrict( bool newValue ) { tq.isRestrict = newValue; }
    136         void set_isLvalue( bool newValue ) { tq.isLvalue = newValue; }
    137         void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }
     133        bool get_const() { return tq.is_const; }
     134        bool get_volatile() { return tq.is_volatile; }
     135        bool get_restrict() { return tq.is_restrict; }
     136        bool get_lvalue() { return tq.is_lvalue; }
     137        bool get_mutex() { return tq.is_mutex; }
     138        bool get_atomic() { return tq.is_atomic; }
     139        void set_const( bool newValue ) { tq.is_const = newValue; }
     140        void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
     141        void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
     142        void set_lvalue( bool newValue ) { tq.is_lvalue = newValue; }
     143        void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
     144        void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
    138145
    139146        typedef std::list<TypeDecl *> ForallList;
    … …  
    147154        virtual bool isVoid() const { return size() == 0; }
    148155        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; }
     156
     157        Type *stripDeclarator();
    149158
    150159        virtual bool isComplete() const { return true; }
Note: See TracChangeset for help on using the changeset viewer.