Changeset 90152a4 for src/SynTree/Expression.cc

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (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' into cleanup-dtors

File:

• src/SynTree/Expression.cc (modified) (10 diffs)

src/SynTree/Expression.cc

@@ -50 +50 @@
 }
 
+void Expression::spliceInferParams( Expression * other ) {
+        if ( ! other ) return;
+        for ( auto p : other->inferParams ) {
+                inferParams[p.first] = std::move( p.second );
+        }
+}
+
 Expression::~Expression() {
         delete env;
@@ -81 +88 @@
         constant.print( os );
         Expression::print( os, indent );
+}
+
+long long int ConstantExpr::intValue() const {
+        if ( BasicType * basicType = dynamic_cast< BasicType * >( result ) ) {
+                if ( basicType->isInteger() ) {
+                        return get_constant()->get_ival();
+                }
+        } else if ( dynamic_cast< OneType * >( result ) ) {
+                return 1;
+        } else if ( dynamic_cast< ZeroType * >( result ) ) {
+                return 0;
+        }
+        SemanticError( this, "Constant expression of non-integral type " );
 }
 
@@ -95 +115 @@
         //      assert( inst->baseEnum );
         //      EnumDecl * decl = inst->baseEnum;
-        //      for ( Declaration * member : decl->members ) {
-        //              if ( member == _var ) {
-        //                      type->set_lvalue( false );
-        //              }
+        //      long long int value;
+        //      if ( decl->valueOf( var, value ) ) {
+        //              type->set_lvalue( false );
         //      }
         // }
@@ -259 +278 @@
 }
 
-CastExpr::CastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
+CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result(toType);
 }
 
-CastExpr::CastExpr( Expression *arg_ ) : Expression(), arg(arg_) {
+CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result( new VoidType( Type::Qualifiers() ) );
 }
 
-CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
 }
 
@@ -287 +306 @@
 }
 
+KeywordCastExpr::KeywordCastExpr( Expression *arg, Target target ) : Expression(), arg(arg), target( target ) {
+}
+
+KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
+}
+
+KeywordCastExpr::~KeywordCastExpr() {
+        delete arg;
+}
+
+const std::string & KeywordCastExpr::targetString() const {
+        static const std::string targetStrs[] = {
+                "coroutine", "thread", "monitor"
+        };
+        static_assert(
+                (sizeof(targetStrs) / sizeof(targetStrs[0])) == ((unsigned long)NUMBER_OF_TARGETS),
+                "Each KeywordCastExpr::Target should have a corresponding string representation"
+        );
+        return targetStrs[(unsigned long)target];
+}
+
+void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Keyword Cast of:" << std::endl << indent+1;
+        arg->print(os, indent+1);
+        os << std::endl << indent << "... to: ";
+        os << targetString();
+        Expression::print( os, indent );
+}
+
 VirtualCastExpr::VirtualCastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
         set_result(toType);
@@ -333 +381 @@
 }
 
-namespace {
-        TypeSubstitution makeSub( Type * t ) {
-                if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( t ) ) {
-                        return makeSub( refType->get_base() );
-                } else if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
-                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
-                } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) {
-                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
-                } else {
-                        assertf( false, "makeSub expects struct or union type for aggregate, but got: %s", toString( t ).c_str() );
-                }
-        }
-}
-
-
 MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
                 Expression(), member(member), aggregate(aggregate) {
         assert( member );
         assert( aggregate );
-
-        TypeSubstitution sub( makeSub( aggregate->get_result() ) );
+        assert( aggregate->result );
+
+        TypeSubstitution sub = aggregate->result->genericSubstitution();
         Type * res = member->get_type()->clone();
         sub.apply( res );
@@ -403 +437 @@
                 } else {
                         // references have been removed, in which case dereference returns an lvalue of the base type.
-                        ret->get_result()->set_lvalue( true );
+                        ret->result->set_lvalue( true );
                 }
         }
@@ -585 +619 @@
 
 StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) {
-        assert( statements );
-        std::list< Statement * > & body = statements->get_kids();
-        if ( ! body.empty() ) {
-                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
-                        set_result( maybeClone( exprStmt->get_expr()->get_result() ) );
-                }
-        }
-        // ensure that StmtExpr has a result type
-        if ( ! result ) {
-                set_result( new VoidType( Type::Qualifiers() ) );
-        }
+        computeResult();
 }
 StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {
@@ -605 +629 @@
         deleteAll( dtors );
         deleteAll( returnDecls );
+}
+void StmtExpr::computeResult() {
+        assert( statements );
+        std::list< Statement * > & body = statements->kids;
+        delete result;
+        result = nullptr;
+        if ( ! returnDecls.empty() ) {
+                // prioritize return decl for result type, since if a return decl exists, then
+                // the StmtExpr is currently in an intermediate state where the body will always
+                // give a void result type.
+                result = returnDecls.front()->get_type()->clone();
+        } else if ( ! body.empty() ) {
+                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
+                        result = maybeClone( exprStmt->expr->result );
+                }
+        }
+        // ensure that StmtExpr has a result type
+        if ( ! result ) {
+                result = new VoidType( Type::Qualifiers() );
+        }
 }
 void StmtExpr::print( std::ostream &os, Indenter indent ) const {
@@ -688 +732 @@
 }
 
+DeletedExpr::DeletedExpr( Expression * expr, BaseSyntaxNode * deleteStmt ) : expr( expr ), deleteStmt( deleteStmt ) {
+        assert( expr->result );
+        result = expr->result->clone();
+}
+DeletedExpr::DeletedExpr( const DeletedExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), deleteStmt( other.deleteStmt ) {}
+DeletedExpr::~DeletedExpr() {
+        delete expr;
+}
+
+void DeletedExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Deleted Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
+        os << std::endl << indent+1 << "... deleted by: ";
+        deleteStmt->print( os, indent+1 );
+}
+
+
+DefaultArgExpr::DefaultArgExpr( Expression * expr ) : expr( expr ) {
+        assert( expr->result );
+        result = expr->result->clone();
+}
+DefaultArgExpr::DefaultArgExpr( const DefaultArgExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ) {}
+DefaultArgExpr::~DefaultArgExpr() {
+        delete expr;
+}
+
+void DefaultArgExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Default Argument Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
+}
+
+GenericExpr::Association::Association( Type * type, Expression * expr ) : type( type ), expr( expr ), isDefault( false ) {}
+GenericExpr::Association::Association( Expression * expr ) : type( nullptr ), expr( expr ), isDefault( true ) {}
+GenericExpr::Association::Association( const Association & other ) : type( maybeClone( other.type ) ), expr( maybeClone( other.expr ) ), isDefault( other.isDefault ) {}
+GenericExpr::Association::~Association() {
+        delete type;
+        delete expr;
+}
+
+GenericExpr::GenericExpr( Expression * control, const std::list<Association> & assoc ) : Expression(), control( control ), associations( assoc ) {}
+GenericExpr::GenericExpr( const GenericExpr & other ) : Expression(other), control( maybeClone( other.control ) ), associations( other.associations ) {
+}
+GenericExpr::~GenericExpr() {
+        delete control;
+}
+
+void GenericExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "C11 _Generic Expression" << std::endl << indent+1;
+        control->print( os, indent+1 );
+        os << std::endl << indent+1 << "... with associations: " << std::endl;
+        for ( const Association & assoc : associations ) {
+                os << indent+1;
+                if (assoc.isDefault) {
+                        os << "... default: ";
+                        assoc.expr->print( os, indent+1 );
+                } else {
+                        os << "... type: ";
+                        assoc.type->print( os, indent+1 );
+                        os << std::endl << indent+1 << "... expression: ";
+                        assoc.expr->print( os, indent+1 );
+                        os << std::endl;
+                }
+                os << std::endl;
+        }
+}
+
 // Local Variables: //
 // tab-width: 4 //