Changeset 1fbab5a for src/SynTree

Timestamp:

Mar 16, 2017, 4:50:08 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:

395fc37, 64ac636, ef42b143

Parents:

2f26687a (diff), d6d747d (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

Location:

src/SynTree

Files:

• AggregateDecl.cc (modified) (2 diffs)
• Declaration.cc (modified) (3 diffs)
• Declaration.h (modified) (12 diffs)
• DeclarationWithType.cc (modified) (2 diffs)
• FunctionDecl.cc (modified) (4 diffs)
• NamedTypeDecl.cc (modified) (4 diffs)
• ObjectDecl.cc (modified) (4 diffs)
• Type.cc (modified) (3 diffs)
• Type.h (modified) (34 diffs)
• TypeDecl.cc (modified) (2 diffs)

src/SynTree/AggregateDecl.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 23:56:39 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:31:47 2017
-// Update Count     : 19
+// Last Modified On : Thu Mar 16 07:49:07 2017
+// Update Count     : 20
 //
 
@@ -20 +20 @@
 
 
-AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes ) : Parent( name, DeclarationNode::StorageClasses(), LinkageSpec::Cforall ), body( false ), attributes( attributes ) {
+AggregateDecl::AggregateDecl( const std::string &name, const std::list< Attribute * > & attributes ) : Parent( name, Type::StorageClasses(), LinkageSpec::Cforall ), body( false ), attributes( attributes ) {
 }
 

src/SynTree/Declaration.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:31:11 2017
-// Update Count     : 23
+// Last Modified On : Thu Mar 16 07:49:18 2017
+// Update Count     : 24
 //
 
@@ -27 +27 @@
 static IdMapType idMap;
 
-Declaration::Declaration( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage )
+Declaration::Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage )
                 : name( name ), storageClasses( scs ), linkage( linkage ), uniqueId( 0 ) {
 }
@@ -66 +66 @@
 
 
-AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", DeclarationNode::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {
+AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {
 }
 

src/SynTree/Declaration.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:40:42 2017
-// Update Count     : 113
+// Last Modified On : Thu Mar 16 08:34:11 2017
+// Update Count     : 118
 //
 
@@ -28 +28 @@
 class Declaration : public BaseSyntaxNode {
   public:
-        Declaration( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage );
+        Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage );
         Declaration( const Declaration &other );
         virtual ~Declaration();
@@ -35 +35 @@
         void set_name( std::string newValue ) { name = newValue; }
 
-        DeclarationNode::StorageClasses get_storageClasses() const { return storageClasses; }
+        Type::StorageClasses get_storageClasses() const { return storageClasses; }
 
         LinkageSpec::Spec get_linkage() const { return linkage; }
@@ -56 +56 @@
   private:
         std::string name;
-        DeclarationNode::StorageClasses storageClasses;
+        Type::StorageClasses storageClasses;
         LinkageSpec::Spec linkage;
         UniqueId uniqueId;
@@ -64 +64 @@
 class DeclarationWithType : public Declaration {
   public:
-        DeclarationWithType( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs );
+        DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs );
         DeclarationWithType( const DeclarationWithType &other );
         virtual ~DeclarationWithType();
@@ -82 +82 @@
         const std::list< Attribute * >& get_attributes() const { return attributes; }
 
-        DeclarationNode::FuncSpecifiers get_funcSpec() const { return fs; }
-        //void set_functionSpecifiers( DeclarationNode::FuncSpecifiers newValue ) { fs = newValue; }
+        Type::FuncSpecifiers get_funcSpec() const { return fs; }
+        //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
 
         virtual DeclarationWithType *clone() const = 0;
@@ -98 +98 @@
         ConstantExpr *asmName;
         std::list< Attribute * > attributes;
-        DeclarationNode::FuncSpecifiers fs;
+        Type::FuncSpecifiers fs;
 };
 
@@ -104 +104 @@
         typedef DeclarationWithType Parent;
   public:
-        ObjectDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
-                                const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpecifiers fs = DeclarationNode::FuncSpecifiers() );
+        ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
+                                const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
         ObjectDecl( const ObjectDecl &other );
         virtual ~ObjectDecl();
@@ -132 +132 @@
         typedef DeclarationWithType Parent;
   public:
-        FunctionDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
-                                  const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpecifiers fs = DeclarationNode::FuncSpecifiers() );
+        FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
+                                  const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
         FunctionDecl( const FunctionDecl &other );
         virtual ~FunctionDecl();
@@ -158 +158 @@
         typedef Declaration Parent;
   public:
-        NamedTypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type );
+        NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *type );
         NamedTypeDecl( const NamedTypeDecl &other );
         virtual ~NamedTypeDecl();
@@ -193 +193 @@
         };
 
-        TypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type, Kind kind );
+        TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind );
         TypeDecl( const TypeDecl &other );
 
@@ -214 +214 @@
         typedef NamedTypeDecl Parent;
   public:
-        TypedefDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type ) : Parent( name, scs, type ) {}
+        TypedefDecl( const std::string &name, Type::StorageClasses scs, Type *type ) : Parent( name, scs, type ) {}
         TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
 

src/SynTree/DeclarationWithType.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:32:14 2017
-// Update Count     : 23
+// Last Modified On : Thu Mar 16 08:34:35 2017
+// Update Count     : 25
 //
 
@@ -19 +19 @@
 #include "Common/utility.h"
 
-DeclarationWithType::DeclarationWithType( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpecifiers fs )
+DeclarationWithType::DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs )
         : Declaration( name, scs, linkage ), asmName( nullptr ), attributes( attributes ), fs( fs ) {
 }

src/SynTree/FunctionDecl.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:54:58 2017
-// Update Count     : 68
+// Last Modified On : Thu Mar 16 08:33:41 2017
+// Update Count     : 74
 //
 
@@ -26 +26 @@
 extern bool translation_unit_nomain;
 
-FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs )
+FunctionDecl::FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::list< Attribute * > attributes, Type::FuncSpecifiers fs )
         : Parent( name, scs, linkage, attributes, fs ), type( type ), statements( statements ) {
         // hack forcing the function "main" to have Cforall linkage to replace main even if it is inside an extern
@@ -65 +65 @@
         printAll( get_attributes(), os, indent );
 
-        DeclarationNode::print_StorageClass( os, get_storageClasses() );
-        DeclarationNode::print_FuncSpec( os, get_funcSpec() );
+        get_storageClasses().print( os );
+        get_funcSpec().print( os );
 
         if ( get_type() ) {
@@ -91 +91 @@
         // xxx - should printShort print attributes?
 
-        DeclarationNode::print_StorageClass( os, get_storageClasses() );
-        DeclarationNode::print_FuncSpec( os, get_funcSpec() );
+        get_storageClasses().print( os );
+        get_funcSpec().print( os );
 
         if ( get_type() ) {

src/SynTree/NamedTypeDecl.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:39:41 2017
-// Update Count     : 10
+// Last Modified On : Thu Mar 16 07:49:44 2017
+// Update Count     : 13
 //
 
@@ -18 +18 @@
 #include "Common/utility.h"
 
-NamedTypeDecl::NamedTypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *base )
+NamedTypeDecl::NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *base )
         : Parent( name, scs, LinkageSpec::Cforall ), base( base ) {}
 
@@ -39 +39 @@
                 os << get_name() << ": ";
         } // if
-        DeclarationNode::print_StorageClass( os, get_storageClasses() );
+        get_storageClasses().print( os );
         os << typeString();
         if ( base ) {
@@ -61 +61 @@
                 os << get_name() << ": ";
         } // if
-        DeclarationNode::print_StorageClass( os, get_storageClasses() );
+        get_storageClasses().print( os );
         os << typeString();
         if ( base ) {

src/SynTree/ObjectDecl.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:55:24 2017
-// Update Count     : 54
+// Last Modified On : Thu Mar 16 08:34:27 2017
+// Update Count     : 59
 //
 
@@ -22 +22 @@
 #include "Statement.h"
 
-ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, DeclarationNode::FuncSpecifiers fs )
+ObjectDecl::ObjectDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, Type::FuncSpecifiers fs )
         : Parent( name, scs, linkage, attributes, fs ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
 }
@@ -47 +47 @@
         printAll( get_attributes(), os, indent );
 
-        DeclarationNode::print_StorageClass( os, get_storageClasses() );
+        get_storageClasses().print( os );
 
         if ( get_type() ) {
@@ -81 +81 @@
         // xxx - should printShort print attributes?
 
-        DeclarationNode::print_StorageClass( os, get_storageClasses() );
+        get_storageClasses().print( os );
 
         if ( get_type() ) {

src/SynTree/Type.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb  2 11:26:24 2017
-// Update Count     : 12
+// Last Modified On : Thu Mar 16 10:25:06 2017
+// Update Count     : 23
 //
 
@@ -59 +59 @@
 }
 
-void Type::Qualifiers::print( std::ostream &os, int indent ) const {
-        if ( isConst ) {
-                os << "const ";
-        } // if
-        if ( isVolatile ) {
-                os << "volatile ";
-        } // if
-        if ( isRestrict ) {
-                os << "restrict ";
-        } // if
-        if ( isLvalue ) {
-                os << "lvalue ";
-        } // if
-        if ( isAtomic ) {
-                os << "_Atomic ";
-        } // if
-}
+// These must remain in the same order as the corresponding bit fields.
+const char * Type::FuncSpecifiers::Names[] = { "inline", "fortran", "_Noreturn" };
+const char * Type::StorageClasses::Names[] = { "extern", "static", "auto", "register", "_Thread_local" };
+const char * Type::Qualifiers::Names[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };
 
 void Type::print( std::ostream &os, int indent ) const {
@@ -89 +76 @@
         } // if
         
-        tq.print( os, indent );
+        tq.print( os );
 }
 

src/SynTree/Type.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  1 09:11:45 2017
-// Update Count     : 41
+// Last Modified On : Thu Mar 16 12:11:50 2017
+// Update Count     : 116
 //
 
@@ -24 +24 @@
 class Type : public BaseSyntaxNode {
   public:
-        struct Qualifiers {
-                Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ), isMutex( false ) {}
-                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 ) {}
-
-                Qualifiers &operator&=( const Qualifiers &other );
-                Qualifiers &operator+=( const Qualifiers &other );
-                Qualifiers &operator-=( const Qualifiers &other );
-                Qualifiers operator+( const Type::Qualifiers &other );
-                bool operator==( const Qualifiers &other );
-                bool operator!=( const Qualifiers &other );
-                bool operator<=( const Qualifiers &other );
-                bool operator>=( const Qualifiers &other );
-                bool operator<( const Qualifiers &other );
-                bool operator>( const Qualifiers &other );
-                void print( std::ostream &os, int indent = 0 ) const;
-
-                bool isConst;
-                bool isVolatile;
-                bool isRestrict;
-                bool isLvalue;
-                bool isAtomic;
-                bool isMutex;
-        };
-
-        Type( const Qualifiers &tq, const std::list< Attribute * > & attributes );
-        Type( const Type &other );
+        #define CommonBF( N ) \
+                bool operator[]( unsigned int i ) const { return val & (1 << i); } \
+                bool any() const { return val != 0; } \
+                static const char * Names[]; \
+                void print( std::ostream & os ) const { \
+                        if ( (*this).any() ) { \
+                                for ( unsigned int i = 0; i < N; i += 1 ) { \
+                                        if ( (*this)[i] ) { \
+                                                os << Names[i] << ' '; \
+                                        } \
+                                } \
+                        } \
+                }
+
+        // enum must remain in the same order as the corresponding bit fields.
+
+        enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
+        union FuncSpecifiers {
+                unsigned int val;
+                struct {
+                        bool is_inline : 1;
+                        bool is_noreturn : 1;
+                        bool is_fortran : 1;
+                };
+                FuncSpecifiers() : val( 0 ) {}
+                FuncSpecifiers( unsigned int val ) : val( val ) {}
+                CommonBF( NumFuncSpecifier )
+        }; // FuncSpecifiers
+
+        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
+        union StorageClasses {
+                unsigned int val;
+                struct {
+                        bool is_extern : 1;
+                        bool is_static : 1;
+                        bool is_auto : 1;
+                        bool is_register : 1;
+                        bool is_threadlocal : 1;
+                };
+
+                StorageClasses() : val( 0 ) {}
+                StorageClasses( unsigned int val ) : val( val ) {}
+                CommonBF( NumStorageClass )
+        }; // StorageClasses
+
+        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
+        union Qualifiers {
+                enum { Mask = ~(Restrict | Lvalue) };
+                unsigned int val;
+                struct {
+                        bool isConst : 1;
+                        bool isRestrict : 1;
+                        bool isVolatile : 1;
+                        bool isLvalue : 1;
+                        bool isMutex : 1;
+                        bool isAtomic : 1;
+                };
+
+                Qualifiers() : val( 0 ) {}
+                Qualifiers( unsigned int val ) : val( val ) {}
+                bool operator==( Qualifiers other ) const {
+                        return (val & Mask) == (other.val & Mask);
+                }
+                bool operator!=( Qualifiers other ) const {
+                        return (val & Mask) != (other.val & Mask);
+                }
+                bool operator<=( Qualifiers other ) const {
+                        return isConst <= other.isConst && isVolatile <= other.isVolatile &&
+                                isMutex == other.isMutex && isAtomic == other.isAtomic;
+                }
+                bool operator>=( Qualifiers other ) const {
+                        return isConst >= other.isConst && isVolatile >= other.isVolatile &&
+                                isMutex == other.isMutex && isAtomic == other.isAtomic;
+                }
+                bool operator<( Qualifiers other ) const {
+                        return *this != other && *this <= other;
+                }
+                bool operator>( Qualifiers other ) const {
+                        return *this != other && *this >= other;
+                }
+                Qualifiers operator&=( Type::Qualifiers other ) {
+                        val &= other.val; return *this;
+                }
+                Qualifiers operator+=( Qualifiers other ) {
+                        val |= other.val; return *this;
+                }
+                Qualifiers operator-=( Qualifiers other ) {
+                        val &= ~other.val; return *this;
+                }
+                Qualifiers operator+( Qualifiers other ) const {
+                        Qualifiers q = other;
+                        q += *this;
+                        return q;
+                }
+                CommonBF( NumTypeQualifier )
+        }; // Qualifiers
+
+        Type( const Qualifiers & tq, const std::list< Attribute * > & attributes );
+        Type( const Type & other );
         virtual ~Type();
 
-        Qualifiers &get_qualifiers() { return tq; }
+        Qualifiers & get_qualifiers() { return tq; }
         bool get_isConst() { return tq.isConst; }
         bool get_isVolatile() { return tq.isVolatile; }
@@ -78 +151 @@
 
         virtual Type *clone() const = 0;
-        virtual void accept( Visitor &v ) = 0;
-        virtual Type *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) = 0;
+        virtual Type *acceptMutator( Mutator & m ) = 0;
+        virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
         Qualifiers tq;
@@ -91 +164 @@
 class VoidType : public Type {
   public:
-        VoidType( const Type::Qualifiers &tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 
         virtual unsigned size() const { return 0; };
@@ -97 +170 @@
 
         virtual VoidType *clone() const { return new VoidType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
 };
 
@@ -131 +204 @@
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
 
-        BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        BasicType( const Type::Qualifiers & tq, Kind bt, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
 
         Kind get_kind() { return kind; }
@@ -137 +210 @@
 
         virtual BasicType *clone() const { return new BasicType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
 
         bool isInteger() const;
@@ -148 +221 @@
 class PointerType : public Type {
   public:
-        PointerType( const Type::Qualifiers &tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
-        PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        PointerType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        PointerType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         PointerType( const PointerType& );
         virtual ~PointerType();
@@ -163 +236 @@
 
         virtual PointerType *clone() const { return new PointerType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
         Type *base;
@@ -177 +250 @@
 class ArrayType : public Type {
   public:
-        ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        ArrayType( const Type::Qualifiers & tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         ArrayType( const ArrayType& );
         virtual ~ArrayType();
@@ -193 +266 @@
 
         virtual ArrayType *clone() const { return new ArrayType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
         Type *base;
@@ -205 +278 @@
 class FunctionType : public Type {
   public:
-        FunctionType( const Type::Qualifiers &tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        FunctionType( const Type::Qualifiers & tq, bool isVarArgs, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         FunctionType( const FunctionType& );
         virtual ~FunctionType();
@@ -216 +289 @@
 
         virtual FunctionType *clone() const { return new FunctionType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
         std::list<DeclarationWithType*> returnVals;
@@ -232 +305 @@
 class ReferenceToType : public Type {
   public:
-        ReferenceToType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes );
-        ReferenceToType( const ReferenceToType &other );
+        ReferenceToType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes );
+        ReferenceToType( const ReferenceToType & other );
         virtual ~ReferenceToType();
 
-        const std::string &get_name() const { return name; }
+        const std::string & get_name() const { return name; }
         void set_name( std::string newValue ) { name = newValue; }
         std::list< Expression* >& get_parameters() { return parameters; }
@@ -243 +316 @@
 
         virtual ReferenceToType *clone() const = 0;
-        virtual void accept( Visitor &v ) = 0;
-        virtual Type *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) = 0;
+        virtual Type *acceptMutator( Mutator & m ) = 0;
+        virtual void print( std::ostream & os, int indent = 0 ) const;
   protected:
         virtual std::string typeString() const = 0;
@@ -257 +330 @@
         typedef ReferenceToType Parent;
   public:
-        StructInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
-        StructInstType( const Type::Qualifiers &tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
+        StructInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseStruct( 0 ) {}
+        StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        StructInstType( const StructInstType & other ) : Parent( other ), baseStruct( other.baseStruct ) {}
 
         StructDecl *get_baseStruct() const { return baseStruct; }
@@ -271 +344 @@
         /// Looks up the members of this struct named "name" and places them into "foundDecls".
         /// Clones declarations into "foundDecls", caller responsible for freeing
-        void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
 
         virtual StructInstType *clone() const { return new StructInstType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+
+        virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
         virtual std::string typeString() const;
@@ -289 +362 @@
         typedef ReferenceToType Parent;
   public:
-        UnionInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
-        UnionInstType( const Type::Qualifiers &tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}
+        UnionInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ), baseUnion( 0 ) {}
+        UnionInstType( const Type::Qualifiers & tq, UnionDecl * baseUnion, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        UnionInstType( const UnionInstType & other ) : Parent( other ), baseUnion( other.baseUnion ) {}
 
         UnionDecl *get_baseUnion() const { return baseUnion; }
@@ -303 +376 @@
         /// looks up the members of this union named "name" and places them into "foundDecls"
         /// Clones declarations into "foundDecls", caller responsible for freeing
-        void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
 
         virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+
+        virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
         virtual std::string typeString() const;
@@ -321 +394 @@
         typedef ReferenceToType Parent;
   public:
-        EnumInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
-        EnumInstType( const Type::Qualifiers &tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        EnumInstType( const EnumInstType &other ) : Parent( other ), baseEnum( other.baseEnum ) {}
+        EnumInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
+        EnumInstType( const Type::Qualifiers & tq, EnumDecl * baseEnum, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        EnumInstType( const EnumInstType & other ) : Parent( other ), baseEnum( other.baseEnum ) {}
 
         EnumDecl *get_baseEnum() const { return baseEnum; }
@@ -331 +404 @@
 
         virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
@@ -344 +417 @@
         typedef ReferenceToType Parent;
   public:
-        TraitInstType( const Type::Qualifiers &tq, const std::string &name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
-        TraitInstType( const TraitInstType &other );
+        TraitInstType( const Type::Qualifiers & tq, const std::string & name, const std::list< Attribute * > & attributes = std::list< Attribute * >()  ) : Parent( tq, name, attributes ) {}
+        TraitInstType( const TraitInstType & other );
         ~TraitInstType();
 
@@ -353 +426 @@
 
         virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
@@ -366 +439 @@
         typedef ReferenceToType Parent;
   public:
-        TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
-        TypeInstType( const TypeInstType &other );
+        TypeInstType( const Type::Qualifiers & tq, const std::string & name, TypeDecl *baseType, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeInstType( const Type::Qualifiers & tq, const std::string & name, bool isFtype, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeInstType( const TypeInstType & other );
         ~TypeInstType();
 
@@ -379 +452 @@
 
         virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
         virtual std::string typeString() const;
@@ -392 +465 @@
 class TupleType : public Type {
   public:
-        TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TupleType( const TupleType& );
         virtual ~TupleType();
@@ -413 +486 @@
 
         virtual TupleType *clone() const { return new TupleType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
         std::list<Type*> types;
@@ -422 +495 @@
 class TypeofType : public Type {
   public:
-        TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         TypeofType( const TypeofType& );
         virtual ~TypeofType();
@@ -432 +505 @@
 
         virtual TypeofType *clone() const { return new TypeofType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
         Expression *expr;
@@ -441 +514 @@
 class AttrType : public Type {
   public:
-        AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
-        AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        AttrType( const Type::Qualifiers & tq, const std::string & name, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        AttrType( const Type::Qualifiers & tq, const std::string & name, Type *type, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         AttrType( const AttrType& );
         virtual ~AttrType();
 
-        const std::string &get_name() const { return name; }
-        void set_name( const std::string &newValue ) { name = newValue; }
+        const std::string & get_name() const { return name; }
+        void set_name( const std::string & newValue ) { name = newValue; }
         Expression *get_expr() const { return expr; }
         void set_expr( Expression *newValue ) { expr = newValue; }
@@ -458 +531 @@
 
         virtual AttrType *clone() const { return new AttrType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
   private:
         std::string name;
@@ -477 +550 @@
 
         virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
 };
 
@@ -489 +562 @@
 
         virtual ZeroType *clone() const { return new ZeroType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
 };
 
@@ -501 +574 @@
 
         virtual OneType *clone() const { return new OneType( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-};
-
-inline Type::Qualifiers &Type::Qualifiers::operator&=( const Type::Qualifiers &other ) {
-        isConst &= other.isConst;
-        isVolatile &= other.isVolatile;
-        isRestrict &= other.isRestrict;
-        isLvalue &= other.isLvalue;
-        isAtomic &= other.isAtomic;
-        isMutex &= other.isMutex;
-        return *this;
-}
-
-inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
-        isConst |= other.isConst;
-        isVolatile |= other.isVolatile;
-        isRestrict |= other.isRestrict;
-        isLvalue |= other.isLvalue;
-        isAtomic |= other.isAtomic;
-        isMutex |= other.isMutex;
-        return *this;
-}
-
-inline Type::Qualifiers &Type::Qualifiers::operator-=( const Type::Qualifiers &other ) {
-        if ( other.isConst ) isConst = 0;
-        if ( other.isVolatile ) isVolatile = 0;
-        if ( other.isRestrict ) isRestrict = 0;
-        if ( other.isAtomic ) isAtomic = 0;
-        if ( other.isMutex ) isMutex = 0;
-        return *this;
-}
-
-inline Type::Qualifiers Type::Qualifiers::operator+( const Type::Qualifiers &other ) {
-        Qualifiers q = other;
-        q += *this;
-        return q;
-}
-
-inline bool Type::Qualifiers::operator==( const Qualifiers &other ) {
-        return isConst == other.isConst
-                && isVolatile == other.isVolatile
-//              && isRestrict == other.isRestrict
-//              && isLvalue == other.isLvalue
-                && isAtomic == other.isAtomic;
-}
-
-inline bool Type::Qualifiers::operator!=( const Qualifiers &other ) {
-        return isConst != other.isConst
-                || isVolatile != other.isVolatile
-//              || isRestrict != other.isRestrict
-//              || isLvalue != other.isLvalue
-                || isAtomic != other.isAtomic;
-}
-
-inline bool Type::Qualifiers::operator<=( const Type::Qualifiers &other ) {
-        return isConst <= other.isConst
-                && isVolatile <= other.isVolatile
-//              && isRestrict <= other.isRestrict
-//              && isLvalue >= other.isLvalue
-                && isAtomic == other.isAtomic;
-}
-
-inline bool Type::Qualifiers::operator>=( const Type::Qualifiers &other ) {
-        return isConst >= other.isConst
-                && isVolatile >= other.isVolatile
-//              && isRestrict >= other.isRestrict
-//              && isLvalue <= other.isLvalue
-                && isAtomic == other.isAtomic;
-}
-
-inline bool Type::Qualifiers::operator<( const Type::Qualifiers &other ) {
-        return operator!=( other ) && operator<=( other );
-}
-
-inline bool Type::Qualifiers::operator>( const Type::Qualifiers &other ) {
-        return operator!=( other ) && operator>=( other );
-}
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+};
 
 std::ostream & operator<<( std::ostream & out, const Type * type );

src/SynTree/TypeDecl.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar  7 07:39:09 2017
-// Update Count     : 4
+// Last Modified On : Thu Mar 16 07:49:58 2017
+// Update Count     : 5
 //
 
@@ -18 +18 @@
 #include "Common/utility.h"
 
-TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClasses scs, Type *type, Kind kind ) : Parent( name, scs, type ), kind( kind ), sized( kind == Any || kind == Ttype ) {
+TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind ) : Parent( name, scs, type ), kind( kind ), sized( kind == Any || kind == Ttype ) {
 }