Changeset 615a096 for src/SynTree

Timestamp:

Mar 17, 2017, 9:58:23 AM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

409433da, 946bcca

Parents:

395fc37

Message:

fix BFCommon problem on gcc-4.9, and begin consistent renaming

Location:

src/SynTree

Files:

• ArrayType.cc (modified) (2 diffs)
• Expression.cc (modified) (3 diffs)
• TupleExpr.cc (modified) (2 diffs)
• Type.cc (modified) (2 diffs)
• Type.h (modified) (8 diffs)

src/SynTree/ArrayType.cc ¶

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  1 17:16:29 2017
-// Update Count     : 12
+// Last Modified On : Fri Mar 17 09:40:30 2017
+// Update Count     : 13
 //
 
@@ -21 +21 @@
 ArrayType::ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic, const std::list< Attribute * > & attributes )
         : Type( tq, attributes ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
-        base->set_isLvalue( false );
+        base->set_lvalue( false );
 }
 

src/SynTree/Expression.cc ¶

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Aug  5 14:23:56 2016
-// Update Count     : 49
+// Last Modified On : Fri Mar 17 09:42:04 2017
+// Update Count     : 51
 //
 
@@ -77 +77 @@
         assert( var->get_type() );
         Type * type = var->get_type()->clone();
-        type->set_isLvalue( true );
+        type->set_lvalue( true );
         set_result( type );
 }
@@ -352 +352 @@
         sub.apply( res );
         set_result( res );
-        get_result()->set_isLvalue( true );
+        get_result()->set_lvalue( true );
 }
 

src/SynTree/TupleExpr.cc ¶

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 18 10:59:19 2015
-// Update Count     : 1
+// Last Modified On : Fri Mar 17 09:42:29 2017
+// Update Count     : 3
 //
 
@@ -60 +60 @@
         assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() );
         set_result( (*std::next( type->get_types().begin(), index ))->clone() );
-        get_result()->set_isLvalue( type->get_isLvalue() );
+        get_result()->set_lvalue( type->get_lvalue() );
 }
 

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 Mar 16 16:25:49 2017
-// Update Count     : 27
+// Last Modified On : Fri Mar 17 08:42:47 2017
+// Update Count     : 28
 //
 
@@ -61 +61 @@
 
 // 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" };
+const char * Type::FuncSpecifiersNames[] = { "inline", "fortran", "_Noreturn" };
+const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "_Thread_local" };
+const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };
 
 Type *Type::stripDeclarator() {

src/SynTree/Type.h ¶

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 17:44:11 2017
-// Update Count     : 135
+// Last Modified On : Fri Mar 17 09:04:03 2017
+// Update Count     : 147
 //
 
@@ -26 +26 @@
   public:
         // Simulate inheritance because union does not allow it.
+        // Bug in g++-4.9 prevents static field in union
+        //static const char * Names[];
         #define BFCommon( BFType, N ) \
                 bool operator[]( unsigned int i ) const { return val & (1 << i); } \
@@ -31 +33 @@
                 void reset() { val = 0; } \
                 int ffs() { return ::ffs( val ) - 1; } \
-                static const char * Names[]; \
                 BFType operator&=( BFType other ) { \
                         val &= other.val; return *this; \
@@ -55 +56 @@
                                 for ( unsigned int i = 0; i < N; i += 1 ) { \
                                         if ( (*this)[i] ) { \
-                                                os << Names[i] << ' '; \
+                                                os << BFType##Names[i] << ' '; \
                                         } \
                                 } \
@@ -64 +65 @@
 
         enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
+        static const char * FuncSpecifiersNames[];
         union FuncSpecifiers {
                 unsigned int val;
@@ -73 +75 @@
                 FuncSpecifiers() : val( 0 ) {}
                 FuncSpecifiers( unsigned int val ) : val( val ) {}
-                bool operator==( FuncSpecifiers other ) const { return val == other.val; }
-                bool operator!=( FuncSpecifiers other ) const { return val != other.val; }
+                // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
                 BFCommon( FuncSpecifiers, NumFuncSpecifier )
         }; // FuncSpecifiers
 
         enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
+        static const char * StorageClassesNames[];
         union StorageClasses {
                 unsigned int val;
@@ -91 +93 @@
                 StorageClasses() : val( 0 ) {}
                 StorageClasses( unsigned int val ) : val( val ) {}
-                bool operator==( StorageClasses other ) const { return val == other.val; }
-                bool operator!=( StorageClasses other ) const { return val != other.val; }
+                // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
                 BFCommon( StorageClasses, NumStorageClass )
         }; // StorageClasses
 
         enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
+        static const char * QualifiersNames[];
         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;
+                        bool is_const : 1;
+                        bool is_restrict : 1;
+                        bool is_volatile : 1;
+                        bool is_lvalue : 1;
+                        bool is_mutex : 1;
+                        bool is_atomic : 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);
-                }
+                // Complex comparisons provide implicit qualifier downcasting, e.g., T downcast to const T.
+                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;
+                        return is_const <= other.is_const && is_volatile <= other.is_volatile &&
+                                is_mutex >= other.is_mutex && is_atomic == other.is_atomic;
                 }
                 bool operator<( Qualifiers other ) const { return *this != other && *this <= other; }
@@ -132 +131 @@
 
         Qualifiers & get_qualifiers() { return tq; }
-        bool get_isConst() { return tq.isConst; }
-        bool get_isVolatile() { return tq.isVolatile; }
-        bool get_isRestrict() { return tq.isRestrict; }
-        bool get_isLvalue() { return tq.isLvalue; }
-        bool get_isAtomic() { return tq.isAtomic; }
-        void set_isConst( bool newValue ) { tq.isConst = newValue; }
-        void set_isVolatile( bool newValue ) { tq.isVolatile = newValue; }
-        void set_isRestrict( bool newValue ) { tq.isRestrict = newValue; }
-        void set_isLvalue( bool newValue ) { tq.isLvalue = newValue; }
-        void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }
+        bool get_const() { return tq.is_const; }
+        bool get_volatile() { return tq.is_volatile; }
+        bool get_restrict() { return tq.is_restrict; }
+        bool get_lvalue() { return tq.is_lvalue; }
+        bool get_mutex() { return tq.is_mutex; }
+        bool get_atomic() { return tq.is_atomic; }
+        void set_const( bool newValue ) { tq.is_const = newValue; }
+        void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
+        void set_restrict( bool newValue ) { tq.is_restrict = newValue; }
+        void set_lvalue( bool newValue ) { tq.is_lvalue = newValue; }
+        void set_mutex( bool newValue ) { tq.is_mutex = newValue; }
+        void set_atomic( bool newValue ) { tq.is_atomic = newValue; }
 
         typedef std::list<TypeDecl *> ForallList;