Changes in src/SynTree/Expression.cc [6eb8948:906e24d]

File:

• src/SynTree/Expression.cc (modified) (19 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( Expression * _member, Expression *_aggregate, Expression *_aname ) :
+        os << std::endl;
+        Expression::print( os, indent );
+}
+
+UntypedMemberExpr::UntypedMemberExpr( std::string _member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {}
 
 UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
-                Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
+                Expression( other ), member( 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: " << std::endl;
-        get_member()->print(os, indent+4);
-        os << std::string( indent+2, ' ' );
+        os << "Untyped Member Expression, with field: " << get_member();
 
         Expression *agg = get_aggregate();
-        os << "from aggregate: " << std::endl;
+        os << ", from aggregate: ";
         if (agg != 0) {
-                os << std::string( indent + 4, ' ' );
-                agg->print(os, indent + 4);
+                os << std::string( indent + 2, ' ' );
+                agg->print(os, indent + 2);
         }
         os << std::string( indent+2, ' ' );
@@ -341 +331 @@
 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 );
 }
 
@@ -375 +363 @@
 }
 
-UntypedExpr::UntypedExpr( Expression *_function, const std::list<Expression *> &_args, Expression *_aname ) :
-                Expression( _aname ), function(_function), args(_args) {}
+
+UntypedExpr::UntypedExpr( Expression *_function, Expression *_aname ) : Expression( _aname ), function( _function ) {}
 
 UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
@@ -382 +370 @@
         cloneAll( other.args, args );
 }
+
+UntypedExpr::UntypedExpr( Expression *_function, std::list<Expression *> &_args, Expression *_aname ) :
+                Expression( _aname ), function(_function), args(_args) {}
 
 UntypedExpr::~UntypedExpr() {
@@ -419 +410 @@
 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 ) );
 }
 
@@ -477 +468 @@
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
         assert( callExpr );
-        cloneAll( callExpr->get_results(), results );
+        assert( callExpr->has_result() );
+        set_result( callExpr->get_result()->clone() );
 }
 
@@ -510 +502 @@
         Expression * arg = InitTweak::getCallArg( callExpr, 0 );
         assert( arg );
-        cloneAll( arg->get_results(), results );
+        set_result( maybeClone( arg->get_result() ) );
 }
 
@@ -530 +522 @@
 
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
-        add_result( type->clone() );
+        set_result( type->clone() );
 }
 
@@ -565 +557 @@
 }
 
-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() ) ) {
-                        cloneAll( exprStmt->get_expr()->get_results(), get_results() );
-                }
-        }
-}
-StmtExpr::StmtExpr( const StmtExpr &other ) : statements( other.statements->clone() ) {}
-StmtExpr::~StmtExpr() {
-        delete statements;
-}
-void StmtExpr::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) << "Statement Expression: " << std::endl;
-        statements->print( os, indent+2 );
-}
-
 std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
         expr->print( out );