Changeset 1f44196 for src/SynTree/Expression.cc

Timestamp:

Nov 29, 2016, 3:30:59 PM (9 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:

8e5724e

Parents:

3a2128f (diff), 9129a84 (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 plg2:software/cfa/cfa-cc

Conflicts:

src/Parser/parser.cc

File:

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

src/SynTree/Expression.cc

@@ -31 +31 @@
 
 
-Expression::Expression( Expression *_aname ) : env( 0 ), argName( _aname ) {}
-
-Expression::Expression( const Expression &other ) : env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
-        cloneAll( other.results, results );
+Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
+
+Expression::Expression( const Expression &other ) : result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
 }
 
@@ -40 +39 @@
         delete env;
         delete argName; // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
-        deleteAll( results );
-}
-
-void Expression::add_result( Type *t ) {
-        if ( TupleType *tuple = dynamic_cast< TupleType* >( t ) ) {
-                std::copy( tuple->get_types().begin(), tuple->get_types().end(), back_inserter( results ) );
-        } else {
-                results.push_back(t);
-        } // if
+        delete result;
 }
 
@@ -68 +59 @@
 
 ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
-        add_result( constant.get_type()->clone() );
+        set_result( constant.get_type()->clone() );
 }
 
@@ -85 +76 @@
         assert( var );
         assert( var->get_type() );
-        add_result( var->get_type()->clone() );
-        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
-                (*i)->set_isLvalue( true );
-        } // for
+        Type * type = var->get_type()->clone();
+        type->set_isLvalue( true );
+        set_result( type );
 }
 
@@ -110 +100 @@
 SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
 SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -141 +131 @@
 AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
 AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -172 +162 @@
 UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -197 +187 @@
 OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -229 +219 @@
 
 OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
-        add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+        set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
 }
 
@@ -284 +274 @@
 
 CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
-        add_result(toType);
+        set_result(toType);
 }
 
 CastExpr::CastExpr( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
+        set_result( new VoidType( Type::Qualifiers() ) );
 }
 
@@ -303 +294 @@
         arg->print(os, indent+2);
         os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
-        if ( results.empty() ) {
-                os << std::string( indent+2, ' ' ) << "nothing" << std::endl;
+        os << std::string( indent+2, ' ' );
+        if ( result->isVoid() ) {
+                os << "nothing";
         } else {
-                printAll(results, os, indent+2);
+                result->print( os, indent+2 );
         } // if
-        Expression::print( os, indent );
-}
-
-UntypedMemberExpr::UntypedMemberExpr( std::string _member, Expression *_aggregate, Expression *_aname ) :
+        os << std::endl;
+        Expression::print( os, indent );
+}
+
+UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {}
 
 UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
-                Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
+                Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
 }
 
 UntypedMemberExpr::~UntypedMemberExpr() {
         delete aggregate;
+        delete member;
 }
 
 void UntypedMemberExpr::print( std::ostream &os, int indent ) const {
-        os << "Untyped Member Expression, with field: " << get_member();
+        os << "Untyped Member Expression, with field: " << std::endl;
+        os << std::string( indent+2, ' ' );
+        get_member()->print(os, indent+4);
+        os << std::string( indent+2, ' ' );
 
         Expression *agg = get_aggregate();
-        os << ", from aggregate: ";
+        os << "from aggregate: " << std::endl;
         if (agg != 0) {
-                os << std::string( indent + 2, ' ' );
-                agg->print(os, indent + 2);
+                os << std::string( indent + 4, ' ' );
+                agg->print(os, indent + 4);
         }
         os << std::string( indent+2, ' ' );
@@ -338 +335 @@
 MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {
-        add_result( member->get_type()->clone() );
-        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
-                (*i)->set_isLvalue( true );
-        } // for
+        set_result( member->get_type()->clone() );
+        get_result()->set_isLvalue( true );
 }
 
@@ -372 +367 @@
 }
 
-
-UntypedExpr::UntypedExpr( Expression *_function, Expression *_aname ) : Expression( _aname ), function( _function ) {}
+UntypedExpr::UntypedExpr( Expression *_function, const std::list<Expression *> &_args, Expression *_aname ) :
+                Expression( _aname ), function(_function), args(_args) {}
 
 UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
@@ -380 +375 @@
 }
 
-UntypedExpr::UntypedExpr( Expression *_function, std::list<Expression *> &_args, Expression *_aname ) :
-                Expression( _aname ), function(_function), args(_args) {}
-
 UntypedExpr::~UntypedExpr() {
         delete function;
         deleteAll( args );
 }
+
+UntypedExpr * UntypedExpr::createDeref( Expression * expr ) {
+        UntypedExpr * ret = new UntypedExpr( new NameExpr("*?"), std::list< Expression * >{ expr } );
+        if ( Type * type = expr->get_result() ) {
+                Type * base = InitTweak::getPointerBase( type );
+                if ( ! base ) {
+                        std::cerr << type << std::endl;
+                }
+                assertf( base, "expected pointer type in dereference\n" );
+                ret->set_result( maybeClone( base ) );
+        }
+        return ret;
+}
+
+UntypedExpr * UntypedExpr::createAssign( Expression * arg1, Expression * arg2 ) {
+        assert( arg1 && arg2 );
+        UntypedExpr * ret = new UntypedExpr( new NameExpr( "?=?" ), std::list< Expression * >{ arg1, arg2 } );
+        if ( arg1->get_result() && arg2->get_result() ) {
+                // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
+                // so the result is the type of the RHS
+                ret->set_result( arg2->get_result()->clone() );
+        }
+        return ret;
+}
+
 
 void UntypedExpr::print( std::ostream &os, int indent ) const {
@@ -419 +436 @@
 LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
                 Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
-        add_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+        set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
 }
 
@@ -454 +471 @@
 
 void ConditionalExpr::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) << "Conditional expression on: " << std::endl;
+        os << "Conditional expression on: " << std::endl;
+        os << std::string( indent+2, ' ' );
         arg1->print( os, indent+2 );
         os << std::string( indent, ' ' ) << "First alternative:" << std::endl;
+        os << std::string( indent+2, ' ' );
         arg2->print( os, indent+2 );
         os << std::string( indent, ' ' ) << "Second alternative:" << std::endl;
+        os << std::string( indent+2, ' ' );
         arg3->print( os, indent+2 );
         os << std::endl;
@@ -477 +497 @@
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
         assert( callExpr );
-        cloneAll( callExpr->get_results(), results );
+        assert( callExpr->has_result() );
+        set_result( callExpr->get_result()->clone() );
 }
 
@@ -510 +531 @@
         Expression * arg = InitTweak::getCallArg( callExpr, 0 );
         assert( arg );
-        cloneAll( arg->get_results(), results );
+        set_result( maybeClone( arg->get_result() ) );
 }
 
@@ -530 +551 @@
 
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
-        add_result( type->clone() );
-}
-
-CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
+        assert( type && initializer );
+        set_result( type->clone() );
+}
+
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( other.type->clone() ), initializer( other.initializer->clone() ) {}
 
 CompoundLiteralExpr::~CompoundLiteralExpr() {
@@ -542 +564 @@
 void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
         os << "Compound Literal Expression: " << std::endl;
-        if ( type ) type->print( os, indent + 2 );
-        if ( initializer ) initializer->print( os, indent + 2 );
+        os << std::string( indent+2, ' ' );
+        type->print( os, indent + 2 );
+        os << std::string( indent+2, ' ' );
+        initializer->print( os, indent + 2 );
 }
 
@@ -557 +581 @@
 
 RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
-RangeExpr::RangeExpr( const RangeExpr &other ) : low( other.low->clone() ), high( other.high->clone() ) {}
+RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
 void RangeExpr::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) << "Range Expression: ";
+        os << "Range Expression: ";
         low->print( os, indent );
         os << " ... ";
         high->print( os, indent );
+}
+
+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() ) );
+                }
+        }
+}
+StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {}
+StmtExpr::~StmtExpr() {
+        delete statements;
+}
+void StmtExpr::print( std::ostream &os, int indent ) const {
+        os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
+        statements->print( os, indent+2 );
+}
+
+
+long long UniqueExpr::count = 0;
+UniqueExpr::UniqueExpr( Expression *expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
+        assert( expr );
+        assert( count != -1 );
+        if ( id == -1 ) id = count++;
+        if ( expr->get_result() ) {
+                set_result( expr->get_result()->clone() );
+        }
+}
+UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
+}
+UniqueExpr::~UniqueExpr() {
+        delete expr;
+        delete object;
+        delete var;
+}
+void UniqueExpr::print( std::ostream &os, int indent ) const {
+        os << "Unique Expression with id:" << id << std::endl << std::string( indent+2, ' ' );
+        get_expr()->print( os, indent+2 );
+        if ( get_object() ) {
+                os << " with decl: ";
+                get_object()->printShort( os, indent+2 );
+        }
 }