Changes in src/SynTree/Expression.cc [bf32bb8:b6fe7e6]

File:

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

src/SynTree/Expression.cc

@@ -31 +31 @@
 
 
-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 ) {
+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 );
 }
 
@@ -39 +40 @@
         delete env;
         delete argName; // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
-        delete result;
+        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
 }
 
@@ -59 +68 @@
 
 ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
-        set_result( constant.get_type()->clone() );
+        add_result( constant.get_type()->clone() );
 }
 
@@ -76 +85 @@
         assert( var );
         assert( var->get_type() );
-        Type * type = var->get_type()->clone();
-        type->set_isLvalue( true );
-        set_result( 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
 }
 
@@ -100 +110 @@
 SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
 SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -131 +141 @@
 AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
 AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -162 +172 @@
 UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -187 +197 @@
 OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -219 +229 @@
 
 OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
-        set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+        add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
 }
 
@@ -274 +284 @@
 
 CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
-        set_result(toType);
+        add_result(toType);
 }
 
 CastExpr::CastExpr( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
-        set_result( new VoidType( Type::Qualifiers() ) );
 }
 
@@ -294 +303 @@
         arg->print(os, indent+2);
         os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        if ( result->isVoid() ) {
-                os << "nothing";
+        if ( results.empty() ) {
+                os << std::string( indent+2, ' ' ) << "nothing" << std::endl;
         } else {
-                result->print( os, indent+2 );
+                printAll(results, os, indent+2);
         } // if
-        os << std::endl;
-        Expression::print( os, indent );
-}
-
-UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
+        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;
-        os << std::string( indent+2, ' ' );
-        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, ' ' );
@@ -335 +338 @@
 MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {
-        set_result( member->get_type()->clone() );
-        get_result()->set_isLvalue( true );
+        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
 }
 
@@ -367 +372 @@
 }
 
-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 ) :
@@ -374 +379 @@
         cloneAll( other.args, args );
 }
+
+UntypedExpr::UntypedExpr( Expression *_function, std::list<Expression *> &_args, Expression *_aname ) :
+                Expression( _aname ), function(_function), args(_args) {}
 
 UntypedExpr::~UntypedExpr() {
@@ -411 +419 @@
 LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
                 Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
 }
 
@@ -469 +477 @@
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
         assert( callExpr );
-        assert( callExpr->has_result() );
-        set_result( callExpr->get_result()->clone() );
+        cloneAll( callExpr->get_results(), results );
 }
 
@@ -503 +510 @@
         Expression * arg = InitTweak::getCallArg( callExpr, 0 );
         assert( arg );
-        set_result( maybeClone( arg->get_result() ) );
+        cloneAll( arg->get_results(), results );
 }
 
@@ -523 +530 @@
 
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
-        assert( type && initializer );
-        set_result( type->clone() );
-}
-
-CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( other.type->clone() ), initializer( other.initializer->clone() ) {}
+        add_result( type->clone() );
+}
+
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
 
 CompoundLiteralExpr::~CompoundLiteralExpr() {
@@ -536 +542 @@
 void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
         os << "Compound Literal Expression: " << std::endl;
-        os << std::string( indent+2, ' ' );
-        type->print( os, indent + 2 );
-        os << std::string( indent+2, ' ' );
-        initializer->print( os, indent + 2 );
+        if ( type ) type->print( os, indent + 2 );
+        if ( initializer ) initializer->print( os, indent + 2 );
 }
 
@@ -553 +557 @@
 
 RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
-RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
+RangeExpr::RangeExpr( const RangeExpr &other ) : low( other.low->clone() ), high( other.high->clone() ) {}
 void RangeExpr::print( std::ostream &os, int indent ) const {
-        os << "Range Expression: ";
+        os << std::string( indent, ' ' ) << "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( new Expression* ), id( idVal ) {
-        assert( count != -1 );
-        if ( id == -1 ) id = count++;
-        set_expr( expr );
-        assert( expr );
-        if ( expr->get_result() ) {
-                set_result( expr->get_result()->clone() );
-        }
-}
-UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( other.expr ), id( other.id ) {
-}
-UniqueExpr::~UniqueExpr() {
-        if ( expr.unique() ) {
-                delete *expr;
-        }
-}
-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 );
 }