Changeset b4f8808 for src/SynTree

Timestamp:

Sep 26, 2019, 1:25:49 PM (6 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

70b4ea20, ea2074e

Parents:

849720f

Message:

Removed lvalue from types in the old ast.

Location:

src/SynTree

Files:

• AddressExpr.cc (modified) (1 diff)
• ArrayType.cc (modified) (1 diff)
• CommaExpr.cc (modified) (2 diffs)
• Expression.cc (modified) (5 diffs)
• TupleExpr.cc (modified) (1 diff)
• Type.cc (modified) (1 diff)
• Type.h (modified) (4 diffs)
• module.mk (modified) (1 diff)

src/SynTree/AddressExpr.cc

@@ -53 +53 @@
                         } // if
                 }
-                // result of & is never an lvalue
-                get_result()->set_lvalue( false );
         }
 }

src/SynTree/ArrayType.cc

@@ -26 +26 @@
 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_lvalue( false );
 }
 

src/SynTree/CommaExpr.cc

@@ -23 +23 @@
 CommaExpr::CommaExpr( Expression *arg1, Expression *arg2 )
                 : Expression(), arg1( arg1 ), arg2( arg2 ) {
-        // xxx - result of a comma expression is never an lvalue, so should set lvalue
-        // to false on all result types. Actually doing this causes some strange things
-        // to happen in later passes (particularly, Specialize, Lvalue, and Box). This needs to be looked into.
         set_result( maybeClone( arg2->get_result() ) );
-        // get_type->set_isLvalue( false );
 }
 
@@ -41 +37 @@
 bool CommaExpr::get_lvalue() const {
         // This is wrong by C, but the current implementation uses it.
+        // (ex: Specialize, Lvalue and Box)
         return arg2->get_lvalue();
 }

src/SynTree/Expression.cc

@@ -115 +115 @@
         assert( var->get_type() );
         Type * type = var->get_type()->clone();
-        type->set_lvalue( true );
 
         // xxx - doesn't quite work yet - get different alternatives with the same cost
@@ -125 +124 @@
         //      long long int value;
         //      if ( decl->valueOf( var, value ) ) {
-        //              type->set_lvalue( false );
+        //              type->set_lvalue( false ); // Would have to move to get_lvalue.
         //      }
         // }
@@ -384 +383 @@
         sub.apply( res );
         result = res;
-        result->set_lvalue( true );
         result->get_qualifiers() |= aggregate->result->get_qualifiers();
 }
@@ -433 +431 @@
                         // if references are still allowed in the AST, dereference returns a reference
                         ret->set_result( new ReferenceType( Type::Qualifiers(), ret->get_result() ) );
-                } else {
-                        // references have been removed, in which case dereference returns an lvalue of the base type.
-                        ret->result->set_lvalue( true );
                 }
         }
@@ -591 +586 @@
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) {
         assert( type && initializer );
-        type->set_lvalue( true );
         set_result( type );
 }

src/SynTree/TupleExpr.cc

@@ -71 +71 @@
         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() );
-        // like MemberExpr, TupleIndexExpr is always an lvalue
-        get_result()->set_lvalue( true );
 }
 

src/SynTree/Type.cc

@@ -85 +85 @@
 const char * Type::FuncSpecifiersNames[] = { "inline", "_Noreturn", "fortran" };
 const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "_Thread_local" };
-const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };
+const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "mutex", "_Atomic" };
 
 Type * Type::stripDeclarator() {

src/SynTree/Type.h

@@ -102 +102 @@
         }; // StorageClasses
 
-        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
+        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Mutex = 1 << 3, Atomic = 1 << 4, NumTypeQualifier = 5 };
         static const char * QualifiersNames[];
         union Qualifiers {
-                enum { Mask = ~(Restrict | Lvalue) };
+                enum { Mask = ~Restrict };
                 unsigned int val;
                 struct {
@@ -111 +111 @@
                         bool is_restrict : 1;
                         bool is_volatile : 1;
-                        bool is_lvalue : 1;
                         bool is_mutex : 1;
                         bool is_atomic : 1;
@@ -153 +152 @@
         bool get_volatile() const { return tq.is_volatile; }
         bool get_restrict() const { return tq.is_restrict; }
-        bool get_lvalue() const { return tq.is_lvalue; }
         bool get_mutex() const { return tq.is_mutex; }
         bool get_atomic() const { return tq.is_atomic; }
@@ -159 +157 @@
         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; }

src/SynTree/module.mk

@@ -49 +49 @@
       SynTree/TypeSubstitution.cc \
       SynTree/Attribute.cc \
-      SynTree/DeclReplacer.cc \
-      SynTree/TopLvalue.cc
+      SynTree/DeclReplacer.cc
 
 SRC += $(SRC_SYNTREE)