Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/CodeGen/CodeGenerator.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -288,16 +288,16 @@ } - void CodeGenerator::printDesignators( std::list< Expression * > & designators ) { - typedef std::list< Expression * > DesignatorList; + void CodeGenerator::visit( Designation * designation ) { + std::list< Expression * > designators = designation->get_designators(); if ( designators.size() == 0 ) return; - for ( DesignatorList::iterator iter = designators.begin(); iter != designators.end(); ++iter ) { - if ( dynamic_cast< NameExpr * >( *iter ) ) { - // if expression is a name, then initializing aggregate member + for ( Expression * des : designators ) { + if ( dynamic_cast< NameExpr * >( des ) || dynamic_cast< VariableExpr * >( des ) ) { + // if expression is a NameExpr or VariableExpr, then initializing aggregate member output << "."; - (*iter)->accept( *this ); + des->accept( *this ); } else { - // if not a simple name, it has to be a constant expression, i.e. an array designator + // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt output << "["; - (*iter)->accept( *this ); + des->accept( *this ); output << "]"; } // if @@ -307,13 +307,24 @@ void CodeGenerator::visit( SingleInit * init ) { - printDesignators( init->get_designators() ); init->get_value()->accept( *this ); } void CodeGenerator::visit( ListInit * init ) { - printDesignators( init->get_designators() ); + auto initBegin = init->begin(); + auto initEnd = init->end(); + auto desigBegin = init->get_designations().begin(); + auto desigEnd = init->get_designations().end(); + output << "{ "; - genCommaList( init->begin(), init->end() ); + for ( ; initBegin != initEnd && desigBegin != desigEnd; ) { + (*desigBegin)->accept( *this ); + (*initBegin)->accept( *this ); + ++initBegin, ++desigBegin; + if ( initBegin != initEnd ) { + output << ", "; + } + } output << " }"; + assertf( initBegin == initEnd && desigBegin == desigEnd, "Initializers and designators not the same length. %s", toString( init ).c_str() ); } @@ -716,6 +727,9 @@ void CodeGenerator::visit( TypeExpr * typeExpr ) { - assertf( ! genC, "TypeExpr should not reach code generation." ); - output<< genType( typeExpr->get_type(), "", pretty, genC ); + // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl; + // assertf( ! genC, "TypeExpr should not reach code generation." ); + if ( ! genC ) { + output<< genType( typeExpr->get_type(), "", pretty, genC ); + } } Index: src/CodeGen/CodeGenerator.h =================================================================== --- src/CodeGen/CodeGenerator.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/CodeGen/CodeGenerator.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -47,4 +47,5 @@ //*** Initializer + virtual void visit( Designation * ); virtual void visit( SingleInit * ); virtual void visit( ListInit * ); @@ -137,5 +138,4 @@ bool lineMarks = false; - void printDesignators( std::list< Expression * > & ); void handleStorageClass( DeclarationWithType *decl ); void handleAggregate( AggregateDecl *aggDecl, const std::string & kind ); Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/Common/PassVisitor.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -12,4 +12,5 @@ #include "SynTree/Expression.h" #include "SynTree/Constant.h" +#include "SynTree/TypeSubstitution.h" #include "PassVisitor.proto.h" @@ -26,5 +27,5 @@ // stmtsToAddBefore or stmtsToAddAfter respectively. // | WithShortCircuiting - provides the ability to skip visiting child nodes; set visit_children to false in pre{visit,mutate} to skip visiting children -// | WithScopes - provides the ability to save/restore data like a LIFO stack; to save, call GuardValue with the variable to save, the variable +// | WithGuards - provides the ability to save/restore data like a LIFO stack; to save, call GuardValue with the variable to save, the variable // will automatically be restored to its previous value after the corresponding postvisit/postmutate teminates. //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @@ -32,5 +33,4 @@ class PassVisitor final : public Visitor, public Mutator { public: - PassVisitor() = default; template< typename... Args > @@ -257,15 +257,4 @@ void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); } - - guard_value_impl init_guard() { - guard_value_impl guard; - auto at_cleanup = at_cleanup_impl(pass, 0); - if( at_cleanup ) { - *at_cleanup = [&guard]( cleanup_func_t && func, void* val ) { - guard.push( std::move( func ), val ); - }; - } - return guard; - } }; @@ -283,5 +272,5 @@ public: - TypeSubstitution * env; + TypeSubstitution * env = nullptr; }; @@ -295,4 +284,15 @@ std::list< Statement* > stmtsToAddAfter; }; + +class WithDeclsToAdd { +protected: + WithDeclsToAdd() = default; + ~WithDeclsToAdd() = default; + +public: + std::list< Declaration* > declsToAddBefore; + std::list< Declaration* > declsToAddAfter; +}; + class WithShortCircuiting { protected: @@ -304,8 +304,8 @@ }; -class WithScopes { -protected: - WithScopes() = default; - ~WithScopes() = default; +class WithGuards { +protected: + WithGuards() = default; + ~WithGuards() = default; public: @@ -318,4 +318,17 @@ }, static_cast< void * >( & val ) ); } + + template< typename T > + void GuardScope( T& val ) { + val.beginScope(); + at_cleanup( []( void * val ) { + static_cast< T * >( val )->endScope(); + }, static_cast< void * >( & val ) ); + } + + template< typename Func > + void GuardAction( Func func ) { + at_cleanup( [func](__attribute__((unused)) void *) { func(); }, nullptr ); + } }; @@ -323,9 +336,9 @@ class WithVisitorRef { protected: - WithVisitorRef() = default; - ~WithVisitorRef() = default; - -public: - PassVisitor * const visitor; + WithVisitorRef() {} + ~WithVisitorRef() {} + +public: + PassVisitor * const visitor = nullptr; }; Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/Common/PassVisitor.impl.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -3,5 +3,5 @@ #define VISIT_START( node ) \ __attribute__((unused)) \ - const auto & guard = init_guard(); \ + guard_value_impl guard( at_cleanup_impl(pass, 0) ); \ bool visit_children = true; \ set_visit_children( visit_children ); \ @@ -15,5 +15,5 @@ #define MUTATE_START( node ) \ __attribute__((unused)) \ - const auto & guard = init_guard(); \ + guard_value_impl guard( at_cleanup_impl(pass, 0) ); \ bool visit_children = true; \ set_visit_children( visit_children ); \ @@ -68,5 +68,5 @@ for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) { // splice in new declarations after previous decl - if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); } + if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); } if ( i == decls.end() ) break; @@ -88,5 +88,5 @@ for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) { // splice in new declarations after previous decl - if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); } + if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); } if ( i == decls.end() ) break; @@ -104,4 +104,10 @@ void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) { SemanticError errors; + + // don't want statements from outer CompoundStmts to be added to this CompoundStmt + ValueGuardPtr< StmtList_t > oldBeforeStmts( get_beforeStmts() ); + ValueGuardPtr< StmtList_t > oldAfterStmts ( get_afterStmts () ); + ValueGuardPtr< DeclList_t > oldBeforeDecls( get_beforeDecls() ); + ValueGuardPtr< DeclList_t > oldAfterDecls ( get_afterDecls () ); StmtList_t* beforeStmts = get_beforeStmts(); @@ -181,5 +187,5 @@ Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) { return handleStatement( stmt, [this]( Statement * stmt ) { - maybeAccept( stmt, *this ); + maybeAccept( stmt, *this ); return stmt; }); @@ -212,5 +218,5 @@ expr->accept( *this ); return expr; - }); + }); } @@ -565,4 +571,7 @@ VISIT_START( node ); + // maybeAccept( node->get_env(), *this ); + maybeAccept( node->get_result(), *this ); + for ( auto expr : node->get_args() ) { visitExpression( expr ); @@ -575,4 +584,7 @@ Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) { MUTATE_START( node ); + + node->set_env( maybeMutate( node->get_env(), *this ) ); + node->set_result( maybeMutate( node->get_result(), *this ) ); for ( auto& expr : node->get_args() ) { Index: src/Common/PassVisitor.proto.h =================================================================== --- src/Common/PassVisitor.proto.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/Common/PassVisitor.proto.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -5,8 +5,15 @@ typedef std::function cleanup_func_t; +typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t; class guard_value_impl { public: - guard_value_impl() = default; + guard_value_impl( at_cleanup_t * at_cleanup ) { + if( at_cleanup ) { + *at_cleanup = [this]( cleanup_func_t && func, void* val ) { + push( std::move( func ), val ); + }; + } + } ~guard_value_impl() { @@ -33,5 +40,4 @@ }; -typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t; class bool_ref { @@ -56,5 +62,5 @@ // Deep magic (a.k.a template meta programming) to make the templated visitor work // Basically the goal is to make 2 previsit_impl -// 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of +// 1 - Use when a pass implements a valid previsit. This uses overloading which means the any overload of // 'pass.previsit( node )' that compiles will be used for that node for that type // This requires that this option only compile for passes that actually define an appropriate visit. Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/Common/utility.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -305,5 +305,5 @@ // for ( val : group_iterate( container1, container2, ... ) ) {} // syntax to have a for each that iterates multiple containers of the same length -// TODO: update to use variadic arguments +// TODO: update to use variadic arguments, perfect forwarding template< typename T1, typename T2 > Index: src/ControlStruct/ExceptTranslate.cc =================================================================== --- src/ControlStruct/ExceptTranslate.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/ControlStruct/ExceptTranslate.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -10,12 +10,17 @@ // Created On : Wed Jun 14 16:49:00 2017 // Last Modified By : Andrew Beach -// Last Modified On : Thr Jun 22 15:57:00 2017 -// Update Count : 0 +// Last Modified On : Fri Jun 30 13:30:00 2017 +// Update Count : 1 // #include "ExceptTranslate.h" #include "Common/PassVisitor.h" - -namespace ControlFlow { +#include "SynTree/Statement.h" +#include "SynTree/Declaration.h" +#include "SynTree/Expression.h" +#include "SynTree/Type.h" +#include "SynTree/Attribute.h" + +namespace ControlStruct { // This (large) section could probably be moved out of the class @@ -24,6 +29,6 @@ // Type(Qualifiers &, false, std::list &) - // void (*function)() - static FunctionType void_func_t(Type::Qualifiers(), false); + // void (*function)(); + static FunctionType try_func_t(Type::Qualifiers(), false); // void (*function)(int, exception); static FunctionType catch_func_t(Type::Qualifiers(), false); @@ -32,28 +37,33 @@ // bool (*function)(exception); static FunctionType handle_func_t(Type::Qualifiers(), false); + // void (*function)(__attribute__((unused)) void *); + static FunctionType finally_func_t(Type::Qualifiers(), false); static void init_func_types() { - static init_complete = false; + static bool init_complete = false; if (init_complete) { return; } ObjectDecl index_obj( - "index_t", + "__handler_index", Type::StorageClasses(), LinkageSpec::Cforall, /*bitfieldWidth*/ NULL, - new BasicType(emptyQualifiers, BasicType::UnsignedInt), + new BasicType( emptyQualifiers, BasicType::SignedInt ), /*init*/ NULL - ); + ); ObjectDecl exception_obj( - "exception_t", + "__exception_inst", Type::StorageClasses(), LinkageSpec::Cforall, /*bitfieldWidth*/ NULL, - new BasicType(emptyQualifiers, BasicType::UnsignedInt), + new PointerType( + emptyQualifiers, + new BasicType( emptyQualifiers, BasicType::SignedInt ) + ), /*init*/ NULL - ); + ); ObjectDecl bool_obj( - "bool_t", + "__ret_bool", Type::StorageClasses(), LinkageSpec::Cforall, @@ -61,12 +71,27 @@ new BasicType(emptyQualifiers, BasicType::Bool), /*init*/ NULL - ); - - catch_func_t.get_parameters().push_back(index_obj.clone()); - catch_func_t.get_parameters().push_back(exception_obj.clone()); - match_func_t.get_returnVals().push_back(index_obj.clone()); - match_func_t.get_parameters().push_back(exception_obj.clone()); - handle_func_t.get_returnVals().push_back(bool_obj.clone()); - handle_func_t.get_parameters().push_back(exception_obj.clone()); + ); + ObjectDecl voidptr_obj( + "__hook", + Type::StorageClasses(), + LinkageSpec::Cforall, + NULL, + new PointerType( + emptyQualifiers, + new VoidType( + emptyQualifiers + ), + std::list{new Attribute("unused")} + ), + NULL + ); + + catch_func_t.get_parameters().push_back( index_obj.clone() ); + catch_func_t.get_parameters().push_back( exception_obj.clone() ); + match_func_t.get_returnVals().push_back( index_obj.clone() ); + match_func_t.get_parameters().push_back( exception_obj.clone() ); + handle_func_t.get_returnVals().push_back( bool_obj.clone() ); + handle_func_t.get_parameters().push_back( exception_obj.clone() ); + finally_func_t.get_parameters().push_back( voidptr_obj.clone() ); init_complete = true; @@ -78,9 +103,9 @@ void split( CatchList& allHandlers, CatchList& terHandlers, - CatchList& resHandlers ) { + CatchList& resHandlers ) { while ( !allHandlers.empty() ) { - Statement * stmt = allHandlers.front(); + CatchStmt * stmt = allHandlers.front(); allHandlers.pop_front(); - if (CaseStmt::Terminate == stmt->get_kind()) { + if (CatchStmt::Terminate == stmt->get_kind()) { terHandlers.push_back(stmt); } else { @@ -92,5 +117,5 @@ template void free_all( std::list &list ) { - std::list::iterator it; + typename std::list::iterator it; for ( it = list.begin() ; it != list.end() ; ++it ) { delete *it; @@ -100,27 +125,44 @@ void appendDeclStmt( CompoundStmt * block, Declaration * item ) { - block->push_back(new DeclStmt(no_labels, item)); - } - - Expression * nameOf( FunctionDecl * function ) { - return new VariableExpr( function ); + block->push_back(new DeclStmt(noLabels, item)); + } + + Expression * nameOf( DeclarationWithType * decl ) { + return new VariableExpr( decl ); } // ThrowStmt Mutation Helpers - Statement * create_terminate_throw( ThrowStmt *throwStmt ) { - // __throw_terminate( EXPR ); - ApplicationExpr * call = new ApplicationExpr( /* ... */ ); - call->get_args.push_back( throwStmt->get_expr() ); - Statement * result = new ExprStmt( throwStmt->get_labels(), call ); + Statement * create_given_throw( + const char * throwFunc, ThrowStmt * throwStmt ) { + // { int NAME = EXPR; throwFunc( &NAME ); } + CompoundStmt * result = new CompoundStmt( noLabels ); + ObjectDecl * local = new ObjectDecl( + "__local_exception_copy", + Type::StorageClasses(), + LinkageSpec::Cforall, + NULL, + new BasicType( emptyQualifiers, BasicType::SignedInt ), + new SingleInit( throwStmt->get_expr() ) + ); + appendDeclStmt( result, local ); + UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) ); + call->get_args().push_back( new AddressExpr( nameOf( local ) ) ); + result->push_back( new ExprStmt( throwStmt->get_labels(), call ) ); throwStmt->set_expr( nullptr ); delete throwStmt; return result; } + + Statement * create_terminate_throw( ThrowStmt *throwStmt ) { + // { int NAME = EXPR; __throw_terminate( &NAME ); } + return create_given_throw( "__cfaehm__throw_termination", throwStmt ); + } Statement * create_terminate_rethrow( ThrowStmt *throwStmt ) { // __rethrow_terminate(); + assert( nullptr == throwStmt->get_expr() ); Statement * result = new ExprStmt( throwStmt->get_labels(), - new ApplicationExpr( /* ... */ ); + new UntypedExpr( new NameExpr( "__cfaehm__rethrow_termination" ) ) ); delete throwStmt; @@ -129,10 +171,5 @@ Statement * create_resume_throw( ThrowStmt *throwStmt ) { // __throw_resume( EXPR ); - ApplicationExpr * call = new ApplicationExpr( /* ... */ ); - call->get_args.push_back( throwStmt->get_expr() ); - Statement * result = new ExprStmt( throwStmt->get_labels(), call ); - throwStmt->set_expr( nullptr ); - delete throwStmt; - return result; + return create_given_throw( "__cfaehm__throw_resumption", throwStmt ); } Statement * create_resume_rethrow( ThrowStmt *throwStmt ) { @@ -140,12 +177,5 @@ Statement * result = new ReturnStmt( throwStmt->get_labels(), - new ConstantExpr( - Constant( - new BasicType( - Type::Qualifiers(), - BasicType::Bool - ), - "0") - ) + new ConstantExpr( Constant::from_bool( false ) ) ); delete throwStmt; @@ -160,14 +190,16 @@ return block; } - FunctionDecl * create_try_wrapper( TryStmt *tryStmt ) { - CompoundStmt * body = base_try->get_block(); - base_try->set_block(nullptr); - - return new FunctionDecl("try", Type::StorageClasses(), - LinkageSpec::Cforall, void_func_t, body); + FunctionDecl * create_try_wrapper( CompoundStmt *body ) { + + return new FunctionDecl( "try", Type::StorageClasses(), + LinkageSpec::Cforall, try_func_t.clone(), body ); } FunctionDecl * create_terminate_catch( CatchList &handlers ) { std::list handler_wrappers; + + FunctionType *func_type = catch_func_t.clone(); + DeclarationWithType * index_obj = func_type->get_parameters().front(); + // DeclarationWithType * except_obj = func_type->get_parameters().back(); // Index 1..{number of handlers} @@ -178,26 +210,33 @@ CatchStmt * handler = *it; - std::list core; - if ( /*the exception is named*/ ) { - ObjectDecl * local_except = /* Dynamic case, same */; - core->push_back( new DeclStmt( noLabel, local_except ) ); - } - // Append the provided statement to the handler. - core->push_back( cur_handler->get_body() ); - // Append return onto the inner block? case stmt list? - CaseStmt * wrapper = new CaseStmt( + // INTEGERconstant Version + // case `index`: + // { + // `handler.body` + // } + // return; + std::list caseBody; + caseBody.push_back( handler->get_body() ); + handler->set_body( nullptr ); + caseBody.push_back( new ReturnStmt( noLabels, nullptr ) ); + + handler_wrappers.push_back( new CaseStmt( noLabels, new ConstantExpr( Constant::from_int( index ) ), - core - ); - handler_wrappers.push_back(wrapper); + caseBody + ) ); } // TODO: Some sort of meaningful error on default perhaps? + + std::list stmt_handlers; + while ( !handler_wrappers.empty() ) { + stmt_handlers.push_back( handler_wrappers.front() ); + handler_wrappers.pop_front(); + } SwitchStmt * handler_lookup = new SwitchStmt( noLabels, - /*parameter 0: index*/, - handler_wrappers, - false + nameOf( index_obj ), + stmt_handlers ); CompoundStmt * body = new CompoundStmt( noLabels ); @@ -205,21 +244,39 @@ return new FunctionDecl("catch", Type::StorageClasses(), - LinkageSpec::Cforall, catch_func_t, body); + LinkageSpec::Cforall, func_type, body); } // Create a single check from a moddified handler. - CompoundStmt *create_single_matcher( CatchStmt * modded_handler ) { - CompoundStmt * block = new CompoundStmt( noLables ); - - appendDeclStmt( block, modded_handler->get_decl() ); - - // TODO: This is not the actual check. - LogicalExpr * cond = new ConstantExpr( Constant::from_bool( false ) ); + // except_obj is referenced, modded_handler will be freed. + CompoundStmt *create_single_matcher( + DeclarationWithType * except_obj, CatchStmt * modded_handler ) { + CompoundStmt * block = new CompoundStmt( noLabels ); + + // INTEGERconstant Version + assert( nullptr == modded_handler->get_decl() ); + ConstantExpr * number = + dynamic_cast( modded_handler->get_cond() ); + assert( number ); + modded_handler->set_cond( nullptr ); + + Expression * cond; + { + std::list args; + args.push_back( number ); + + std::list rhs_args; + rhs_args.push_back( nameOf( except_obj ) ); + Expression * rhs = new UntypedExpr( + new NameExpr( "*?" ), rhs_args ); + args.push_back( rhs ); + + cond = new UntypedExpr( new NameExpr( "?==?" /*???*/), args ); + } if ( modded_handler->get_cond() ) { - cond = new LogicalExpr( cond, modded_handler->get_cond() )q + cond = new LogicalExpr( cond, modded_handler->get_cond() ); } block->push_back( new IfStmt( noLabels, - cond, modded_handler->get_body() ); + cond, modded_handler->get_body(), nullptr ) ); modded_handler->set_decl( nullptr ); @@ -232,4 +289,7 @@ FunctionDecl * create_terminate_match( CatchList &handlers ) { CompoundStmt * body = new CompoundStmt( noLabels ); + + FunctionType * func_type = match_func_t.clone(); + DeclarationWithType * except_obj = func_type->get_parameters().back(); // Index 1..{number of handlers} @@ -240,32 +300,45 @@ CatchStmt * handler = *it; - // body should have been taken by create_terminate_catch. - // assert( nullptr == handler->get_body() ); + // Body should have been taken by create_terminate_catch. + assert( nullptr == handler->get_body() ); + + // Create new body. handler->set_body( new ReturnStmt( noLabels, new ConstantExpr( Constant::from_int( index ) ) ) ); - body->push_back( create_single_matcher( handler ) ); - } + // Create the handler. + body->push_back( create_single_matcher( except_obj, handler ) ); + *it = nullptr; + } + + body->push_back( new ReturnStmt( noLabels, new ConstantExpr( + Constant::from_int( 0 ) ) ) ); return new FunctionDecl("match", Type::StorageClasses(), - LinkageSpec::Cforall, match_func_t, body); - } - - Statement * create_terminate_caller( + LinkageSpec::Cforall, func_type, body); + } + + CompoundStmt * create_terminate_caller( FunctionDecl * try_wrapper, FunctionDecl * terminate_catch, FunctionDecl * terminate_match) { - ApplicationExpr * caller = new ApplicationExpr( /* ... */ ); - std::list& args = caller.get_args(); + UntypedExpr * caller = new UntypedExpr( new NameExpr( + "__cfaehm__try_terminate" ) ); + std::list& args = caller->get_args(); args.push_back( nameOf( try_wrapper ) ); args.push_back( nameOf( terminate_catch ) ); args.push_back( nameOf( terminate_match ) ); - return new ExprStmt( noLabels, caller ); + CompoundStmt * callStmt = new CompoundStmt( noLabels ); + callStmt->push_back( new ExprStmt( noLabels, caller ) ); + return callStmt; } FunctionDecl * create_resume_handler( CatchList &handlers ) { - CompoundStmt * body = new CompountStmt( noLabels ); + CompoundStmt * body = new CompoundStmt( noLabels ); + + FunctionType * func_type = match_func_t.clone(); + DeclarationWithType * except_obj = func_type->get_parameters().back(); CatchList::iterator it; @@ -280,52 +353,58 @@ handling_code->push_back( handler->get_body() ); } - handling_code->push_back( new ReturnStmt( noLabel, + handling_code->push_back( new ReturnStmt( noLabels, new ConstantExpr( Constant::from_bool( false ) ) ) ); handler->set_body( handling_code ); // Create the handler. - body->push_back( create_single_matcher( handler ) ); + body->push_back( create_single_matcher( except_obj, handler ) ); + *it = nullptr; } return new FunctionDecl("handle", Type::StorageClasses(), - LinkageSpec::Cforall, handle_func_t, body); - } - - Statement * create_resume_wrapper( + LinkageSpec::Cforall, func_type, body); + } + + CompoundStmt * create_resume_wrapper( + StructDecl * node_decl, Statement * wraps, FunctionDecl * resume_handler ) { CompoundStmt * body = new CompoundStmt( noLabels ); - // struct node = {current top resume handler, call to resume_handler}; - // __attribute__((cleanup( ... ))); - // set top resume handler to node. - // The wrapped statement. - - ListInit * node_init; - { - std::list field_inits; - field_inits.push_back( new SingleInit( /* ... */ ) ); - field_inits.push_back( new SingleInit( nameOf( resume_handler ) ) ); - node_init = new ListInit( field_inits ); - } + // struct __try_resume_node __resume_node + // __attribute__((cleanup( __cfaehm__try_resume_cleanup ))); + // ** unwinding of the stack here could cause problems ** + // ** however I don't think that can happen currently ** + // __cfaehm__try_resume_setup( &__resume_node, resume_handler ); std::list< Attribute * > attributes; { std::list< Expression * > attr_params; - attr_params.push_back( nameOf( /* ... deconstructor ... */ ) ); - attrributes.push_back( new Attribute( "cleanup", attr_params ) ); - } - - appendDeclStmt( body, - /**/ ObjectDecl( - "resume_node", + attr_params.push_back( new NameExpr( + "__cfaehm__try_resume_cleanup" ) ); + attributes.push_back( new Attribute( "cleanup", attr_params ) ); + } + + ObjectDecl * obj = new ObjectDecl( + "__resume_node", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, - /* Type* = resume_node */, - node_init, + new StructInstType( + Type::Qualifiers(), + node_decl + ), + nullptr, attributes - ) - ); + ); + appendDeclStmt( body, obj ); + + UntypedExpr *setup = new UntypedExpr( new NameExpr( + "__cfaehm__try_resume_setup" ) ); + setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) ); + setup->get_args().push_back( nameOf( resume_handler ) ); + + body->push_back( new ExprStmt( noLabels, setup ) ); + body->push_back( wraps ); return body; @@ -333,13 +412,18 @@ FunctionDecl * create_finally_wrapper( TryStmt * tryStmt ) { - CompoundStmt * body = tryStmt->get_finally(); + FinallyStmt * finally = tryStmt->get_finally(); + CompoundStmt * body = finally->get_block(); + finally->set_block( nullptr ); + delete finally; tryStmt->set_finally( nullptr ); return new FunctionDecl("finally", Type::StorageClasses(), - LinkageSpec::Cforall, void_func_t, body); - } - - ObjectDecl * create_finally_hook( FunctionDecl * finally_wrapper ) { - // struct _cleanup_hook NAME __attribute__((cleanup( ... ))); + LinkageSpec::Cforall, finally_func_t.clone(), body); + } + + ObjectDecl * create_finally_hook( + StructDecl * hook_decl, FunctionDecl * finally_wrapper ) { + // struct __cfaehm__cleanup_hook __finally_hook + // __attribute__((cleanup( finally_wrapper ))); // Make Cleanup Attribute. @@ -348,13 +432,16 @@ std::list< Expression * > attr_params; attr_params.push_back( nameOf( finally_wrapper ) ); - attrributes.push_back( new Attribute( "cleanup", attr_params ) ); - } - - return ObjectDecl( /* ... */ - const std::string &name "finally_hook", + attributes.push_back( new Attribute( "cleanup", attr_params ) ); + } + + return new ObjectDecl( + "__finally_hook", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, - /* ... Type * ... */, + new StructInstType( + emptyQualifiers, + hook_decl + ), nullptr, attributes @@ -363,5 +450,5 @@ - class ExceptionMutatorCore : public WithScoping { + class ExceptionMutatorCore : public WithGuards { enum Context { NoHandler, TerHandler, ResHandler }; @@ -370,5 +457,5 @@ // loop, switch or the goto stays within the function. - Context curContext; + Context cur_context; // We might not need this, but a unique base for each try block's @@ -377,11 +464,15 @@ //unsigned int try_count = 0; + StructDecl *node_decl; + StructDecl *hook_decl; public: ExceptionMutatorCore() : - curContext(NoHandler) + cur_context(NoHandler), + node_decl(nullptr), hook_decl(nullptr) {} - void premutate( CatchStmt *tryStmt ); + void premutate( CatchStmt *catchStmt ); + void premutate( StructDecl *structDecl ); Statement * postmutate( ThrowStmt *throwStmt ); Statement * postmutate( TryStmt *tryStmt ); @@ -393,9 +484,9 @@ if ( throwStmt->get_expr() ) { return create_terminate_throw( throwStmt ); - } else if ( TerHandler == curContext ) { + } else if ( TerHandler == cur_context ) { return create_terminate_rethrow( throwStmt ); } else { assertf(false, "Invalid throw in %s at %i\n", - throwStmt->location.filename, + throwStmt->location.filename.c_str(), throwStmt->location.linenumber); return nullptr; @@ -404,9 +495,9 @@ if ( throwStmt->get_expr() ) { return create_resume_throw( throwStmt ); - } else if ( ResHandler == curContext ) { + } else if ( ResHandler == cur_context ) { return create_resume_rethrow( throwStmt ); } else { assertf(false, "Invalid throwResume in %s at %i\n", - throwStmt->location.filename, + throwStmt->location.filename.c_str(), throwStmt->location.linenumber); return nullptr; @@ -416,8 +507,11 @@ Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) { + assert( node_decl ); + assert( hook_decl ); + // Generate a prefix for the function names? - CompoundStmt * block = new CompoundStmt(); - Statement * inner = take_try_block( tryStmt ); + CompoundStmt * block = new CompoundStmt( noLabels ); + CompoundStmt * inner = take_try_block( tryStmt ); if ( tryStmt->get_finally() ) { @@ -427,13 +521,14 @@ appendDeclStmt( block, finally_block ); // Create and add the finally cleanup hook. - appendDeclStmt( block, create_finally_hook( finally_block ) ); - } - - StatementList termination_handlers; - StatementList resumption_handlers; - split( tryStmt->get_handlers(), - termination_handlers, resumption_handlers ); - - if ( resumeption_handlers.size() ) { + appendDeclStmt( block, + create_finally_hook( hook_decl, finally_block ) ); + } + + CatchList termination_handlers; + CatchList resumption_handlers; + split( tryStmt->get_catchers(), + termination_handlers, resumption_handlers ); + + if ( resumption_handlers.size() ) { // Define the helper function. FunctionDecl * resume_handler = @@ -441,5 +536,5 @@ appendDeclStmt( block, resume_handler ); // Prepare hooks - inner = create_resume_wrapper( inner, resume_handler ); + inner = create_resume_wrapper( node_decl, inner, resume_handler ); } @@ -462,6 +557,6 @@ block->push_back( inner ); - free_all( termination_handlers ); - free_all( resumption_handlers ); + //free_all( termination_handlers ); + //free_all( resumption_handlers ); return block; @@ -469,16 +564,32 @@ void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) { - GuardValue( curContext ); - if ( CatchStmt::Termination == catchStmt->get_kind() ) { - curContext = TerHandler; + GuardValue( cur_context ); + if ( CatchStmt::Terminate == catchStmt->get_kind() ) { + cur_context = TerHandler; } else { - curContext = ResHandler; - } - } - - void translateEHM( std::list< Declaration *> & translationUnit ) { + cur_context = ResHandler; + } + } + + void ExceptionMutatorCore::premutate( StructDecl *structDecl ) { + if ( !structDecl->has_body() ) { + // Skip children? + return; + } else if ( structDecl->get_name() == "__cfaehm__try_resume_node" ) { + assert( nullptr == node_decl ); + node_decl = structDecl; + } else if ( structDecl->get_name() == "__cfaehm__cleanup_hook" ) { + assert( nullptr == hook_decl ); + hook_decl = structDecl; + } + // Later we might get the exception type as well. + } + + void translateEHM( std::list< Declaration *> & translationUnit ) { + init_func_types(); + PassVisitor translator; for ( Declaration * decl : translationUnit ) { - decl->mutate( translator ); + decl->acceptMutator( translator ); } } Index: src/ControlStruct/ExceptTranslate.h =================================================================== --- src/ControlStruct/ExceptTranslate.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/ControlStruct/ExceptTranslate.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -10,6 +10,6 @@ // Created On : Tus Jun 06 10:13:00 2017 // Last Modified By : Andrew Beach -// Last Modified On : Thr Jun 22 15:57:00 2017 -// Update Count : 0 +// Last Modified On : Fri Jun 30 10:20:00 2017 +// Update Count : 2 // @@ -17,5 +17,8 @@ #define EXCEPT_TRANSLATE_H -namespace ControlFlow { +#include +#include "SynTree/SynTree.h" + +namespace ControlStruct { void translateEHM( std::list< Declaration *> & translationUnit ); /* Converts exception handling structures into their underlying C code. Index: src/ControlStruct/module.mk =================================================================== --- src/ControlStruct/module.mk (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/ControlStruct/module.mk (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -10,13 +10,13 @@ ## Author : Richard C. Bilson ## Created On : Mon Jun 1 17:49:17 2015 -## Last Modified By : Peter A. Buhr -## Last Modified On : Thu Aug 4 11:38:06 2016 -## Update Count : 3 +## Last Modified By : Andrew Beach +## Last Modified On : Wed Jun 28 16:15:00 2017 +## Update Count : 4 ############################################################################### SRC += ControlStruct/LabelGenerator.cc \ ControlStruct/LabelFixer.cc \ - ControlStruct/MLEMutator.cc \ + ControlStruct/MLEMutator.cc \ ControlStruct/Mutate.cc \ - ControlStruct/ForExprMutator.cc - + ControlStruct/ForExprMutator.cc \ + ControlStruct/ExceptTranslate.cc Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/GenPoly/Box.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -504,4 +504,5 @@ DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) { if ( functionDecl->get_statements() ) { // empty routine body ? + // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl; doBeginScope(); scopeTyVars.beginScope(); @@ -548,4 +549,5 @@ retval = oldRetval; doEndScope(); + // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl; } // if return functionDecl; @@ -1116,5 +1118,5 @@ Expression *Pass1::mutate( ApplicationExpr *appExpr ) { - // std::cerr << "mutate appExpr: "; + // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl; // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) { // std::cerr << i->first << " "; @@ -1141,8 +1143,17 @@ ReferenceToType *dynRetType = isDynRet( function, exprTyVars ); + // std::cerr << function << std::endl; + // std::cerr << "scopeTyVars: "; + // printTyVarMap( std::cerr, scopeTyVars ); + // std::cerr << "exprTyVars: "; + // printTyVarMap( std::cerr, exprTyVars ); + // std::cerr << "env: " << *env << std::endl; + // std::cerr << needsAdapter( function, scopeTyVars ) << ! needsAdapter( function, exprTyVars) << std::endl; + // NOTE: addDynRetParam needs to know the actual (generated) return type so it can make a temp variable, so pass the result type from the appExpr // passTypeVars needs to know the program-text return type (i.e. the distinction between _conc_T30 and T3(int)) // concRetType may not be a good name in one or both of these places. A more appropriate name change is welcome. if ( dynRetType ) { + // std::cerr << "dynRetType: " << dynRetType << std::endl; Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result(); ret = addDynRetParam( appExpr, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType Index: src/GenPoly/InstantiateGeneric.cc =================================================================== --- src/GenPoly/InstantiateGeneric.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/GenPoly/InstantiateGeneric.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -22,9 +22,12 @@ #include "InstantiateGeneric.h" -#include "DeclMutator.h" #include "GenPoly.h" #include "ScopedSet.h" #include "ScrubTyVars.h" -#include "PolyMutator.h" + +#include "Common/PassVisitor.h" +#include "Common/ScopedMap.h" +#include "Common/UniqueName.h" +#include "Common/utility.h" #include "ResolvExpr/typeops.h" @@ -34,7 +37,7 @@ #include "SynTree/Type.h" -#include "Common/ScopedMap.h" -#include "Common/UniqueName.h" -#include "Common/utility.h" + +#include "InitTweak/InitTweak.h" + namespace GenPoly { @@ -153,23 +156,6 @@ } - // collect the environments of each TypeInstType so that type variables can be replaced - // xxx - possibly temporary solution. Access to type environments is required in GenericInstantiator, but it needs to be a DeclMutator which does not provide easy access to the type environments. - class EnvFinder final : public GenPoly::PolyMutator { - public: - using GenPoly::PolyMutator::mutate; - virtual Type * mutate( TypeInstType * inst ) override { - if ( env ) envMap[inst] = env; - return inst; - } - - // don't want to associate an environment with TypeInstTypes that occur in function types - this may actually only apply to function types belonging to DeclarationWithTypes (or even just FunctionDecl)? - virtual Type * mutate( FunctionType * ftype ) override { - return ftype; - } - std::unordered_map< ReferenceToType *, TypeSubstitution * > envMap; - }; - /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately - class GenericInstantiator final : public DeclMutator { + struct GenericInstantiator final : public WithTypeSubstitution, public WithDeclsToAdd, public WithVisitorRef, public WithGuards { /// Map of (generic type, parameter list) pairs to concrete type instantiations InstantiationMap< AggregateDecl, AggregateDecl > instantiations; @@ -178,15 +164,18 @@ /// Namer for concrete types UniqueName typeNamer; - /// Reference to mapping of environments - const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap; - public: - GenericInstantiator( const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap ) : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_"), envMap( envMap ) {} - - using DeclMutator::mutate; - virtual Type* mutate( StructInstType *inst ) override; - virtual Type* mutate( UnionInstType *inst ) override; - - virtual void doBeginScope() override; - virtual void doEndScope() override; + /// Should not make use of type environment to replace types of function parameter and return values. + bool inFunctionType = false; + GenericInstantiator() : instantiations(), dtypeStatics(), typeNamer("_conc_") {} + + Type* postmutate( StructInstType *inst ); + Type* postmutate( UnionInstType *inst ); + + void premutate( FunctionType * ftype ) { + GuardValue( inFunctionType ); + inFunctionType = true; + } + + void beginScope(); + void endScope(); private: /// Wrap instantiation lookup for structs @@ -207,8 +196,6 @@ void instantiateGeneric( std::list< Declaration* > &translationUnit ) { - EnvFinder finder; - mutateAll( translationUnit, finder ); - GenericInstantiator instantiator( finder.envMap ); - instantiator.mutateDeclarationList( translationUnit ); + PassVisitor instantiator; + mutateAll( translationUnit, instantiator ); } @@ -306,6 +293,5 @@ Type *GenericInstantiator::replaceWithConcrete( Type *type, bool doClone ) { if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) { - if ( envMap.count( typeInst ) ) { - TypeSubstitution * env = envMap.at( typeInst ); + if ( env && ! inFunctionType ) { Type *concrete = env->lookup( typeInst->get_name() ); if ( concrete ) { @@ -331,10 +317,5 @@ - Type* GenericInstantiator::mutate( StructInstType *inst ) { - // mutate subtypes - Type *mutated = Mutator::mutate( inst ); - inst = dynamic_cast< StructInstType* >( mutated ); - if ( ! inst ) return mutated; - + Type* GenericInstantiator::postmutate( StructInstType *inst ) { // exit early if no need for further mutation if ( inst->get_parameters().empty() ) return inst; @@ -368,6 +349,6 @@ substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() ); insert( inst, typeSubs, concDecl ); // must insert before recursion - concDecl->acceptMutator( *this ); // recursively instantiate members - DeclMutator::addDeclaration( concDecl ); // must occur before declaration is added so that member instantiations appear first + concDecl->acceptMutator( *visitor ); // recursively instantiate members + declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first } StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() ); @@ -388,10 +369,5 @@ } - Type* GenericInstantiator::mutate( UnionInstType *inst ) { - // mutate subtypes - Type *mutated = Mutator::mutate( inst ); - inst = dynamic_cast< UnionInstType* >( mutated ); - if ( ! inst ) return mutated; - + Type* GenericInstantiator::postmutate( UnionInstType *inst ) { // exit early if no need for further mutation if ( inst->get_parameters().empty() ) return inst; @@ -423,6 +399,6 @@ substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() ); insert( inst, typeSubs, concDecl ); // must insert before recursion - concDecl->acceptMutator( *this ); // recursively instantiate members - DeclMutator::addDeclaration( concDecl ); // must occur before declaration is added so that member instantiations appear first + concDecl->acceptMutator( *visitor ); // recursively instantiate members + declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first } UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() ); @@ -442,12 +418,10 @@ } - void GenericInstantiator::doBeginScope() { - DeclMutator::doBeginScope(); + void GenericInstantiator::beginScope() { instantiations.beginScope(); dtypeStatics.beginScope(); } - void GenericInstantiator::doEndScope() { - DeclMutator::doEndScope(); + void GenericInstantiator::endScope() { instantiations.endScope(); dtypeStatics.endScope(); Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/InitTweak/FixInit.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -104,5 +104,6 @@ typedef AddStmtVisitor Parent; using Parent::visit; - typedef std::set< ObjectDecl * > ObjectSet; + // use ordered data structure to maintain ordering for set_difference and for consistent error messages + typedef std::list< ObjectDecl * > ObjectSet; virtual void visit( CompoundStmt *compoundStmt ) override; virtual void visit( DeclStmt *stmt ) override; @@ -116,10 +117,13 @@ // debug - struct printSet { - typedef ObjDeclCollector::ObjectSet ObjectSet; - printSet( const ObjectSet & objs ) : objs( objs ) {} + template + struct PrintSet { + PrintSet( const ObjectSet & objs ) : objs( objs ) {} const ObjectSet & objs; }; - std::ostream & operator<<( std::ostream & out, const printSet & set) { + template + PrintSet printSet( const ObjectSet & objs ) { return PrintSet( objs ); } + template + std::ostream & operator<<( std::ostream & out, const PrintSet & set) { out << "{ "; for ( ObjectDecl * obj : set.objs ) { @@ -724,5 +728,5 @@ // static bool __objName_uninitialized = true BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool ); - SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ), noDesignators ); + SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ) ); ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr ); isUninitializedVar->fixUniqueId(); @@ -745,6 +749,6 @@ Statement * dtor = ctorInit->get_dtor(); - objDecl->set_init( NULL ); - ctorInit->set_ctor( NULL ); + objDecl->set_init( nullptr ); + ctorInit->set_ctor( nullptr ); ctorInit->set_dtor( nullptr ); if ( dtor ) { @@ -799,14 +803,14 @@ } else { stmtsToAddAfter.push_back( ctor ); - objDecl->set_init( NULL ); - ctorInit->set_ctor( NULL ); + objDecl->set_init( nullptr ); + ctorInit->set_ctor( nullptr ); } } // if } else if ( Initializer * init = ctorInit->get_init() ) { objDecl->set_init( init ); - ctorInit->set_init( NULL ); + ctorInit->set_init( nullptr ); } else { // no constructor and no initializer, which is okay - objDecl->set_init( NULL ); + objDecl->set_init( nullptr ); } // if delete ctorInit; @@ -816,5 +820,5 @@ void ObjDeclCollector::visit( CompoundStmt * compoundStmt ) { - std::set< ObjectDecl * > prevVars = curVars; + ObjectSet prevVars = curVars; Parent::visit( compoundStmt ); curVars = prevVars; @@ -824,5 +828,5 @@ // keep track of all variables currently in scope if ( ObjectDecl * objDecl = dynamic_cast< ObjectDecl * > ( stmt->get_decl() ) ) { - curVars.insert( objDecl ); + curVars.push_back( objDecl ); } // if Parent::visit( stmt ); @@ -939,9 +943,12 @@ ) if ( ! diff.empty() ) { + // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages. + std::unordered_set needsDestructor( diff.begin(), diff.end() ); + // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor OrderedDecls ordered; for ( OrderedDecls & rdo : reverseDeclOrder ) { // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order. - copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return diff.count( objDecl ); } ); + copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } ); } // for insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAdd ) ); Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/InitTweak/GenInit.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -44,6 +44,5 @@ } - class ReturnFixer : public WithStmtsToAdd, public WithScopes { - public: + struct ReturnFixer : public WithStmtsToAdd, public WithGuards { /// consistently allocates a temporary variable for the return value /// of a function so that anything which the resolver decides can be constructed @@ -59,8 +58,5 @@ }; - class CtorDtor final : public GenPoly::PolyMutator { - public: - typedef GenPoly::PolyMutator Parent; - using Parent::mutate; + struct CtorDtor : public WithGuards, public WithShortCircuiting { /// create constructor and destructor statements for object declarations. /// the actual call statements will be added in after the resolver has run @@ -69,18 +65,19 @@ static void generateCtorDtor( std::list< Declaration * > &translationUnit ); - virtual DeclarationWithType * mutate( ObjectDecl * ) override; - virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override; + void previsit( ObjectDecl * ); + void previsit( FunctionDecl *functionDecl ); + // should not traverse into any of these declarations to find objects // that need to be constructed or destructed - virtual Declaration* mutate( StructDecl *aggregateDecl ) override; - virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; } - virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; } - virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; } - virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; } - virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; } - - virtual Type * mutate( FunctionType *funcType ) override { return funcType; } - - virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override; + void previsit( StructDecl *aggregateDecl ); + void previsit( UnionDecl *aggregateDecl ) { visit_children = false; } + void previsit( EnumDecl *aggregateDecl ) { visit_children = false; } + void previsit( TraitDecl *aggregateDecl ) { visit_children = false; } + void previsit( TypeDecl *typeDecl ) { visit_children = false; } + void previsit( TypedefDecl *typeDecl ) { visit_children = false; } + + void previsit( FunctionType *funcType ) { visit_children = false; } + + void previsit( CompoundStmt * compoundStmt ); private: @@ -211,6 +208,6 @@ void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) { - CtorDtor ctordtor; - mutateAll( translationUnit, ctordtor ); + PassVisitor ctordtor; + acceptAll( translationUnit, ctordtor ); } @@ -289,5 +286,5 @@ } - DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) { + void CtorDtor::previsit( ObjectDecl * objDecl ) { handleDWT( objDecl ); // hands off if @=, extern, builtin, etc. @@ -301,14 +298,13 @@ objDecl->set_init( genCtorInit( objDecl ) ); } - return Parent::mutate( objDecl ); - } - - DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) { - ValueGuard< bool > oldInFunc = inFunction; + } + + void CtorDtor::previsit( FunctionDecl *functionDecl ) { + GuardValue( inFunction ); inFunction = true; handleDWT( functionDecl ); - managedTypes.beginScope(); + GuardScope( managedTypes ); // go through assertions and recursively add seen ctor/dtors for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) { @@ -317,12 +313,14 @@ } } - // parameters should not be constructed and destructed, so don't mutate FunctionType - functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) ); - - managedTypes.endScope(); - return functionDecl; - } - - Declaration* CtorDtor::mutate( StructDecl *aggregateDecl ) { + + PassVisitor newCtorDtor; + newCtorDtor.pass = *this; + maybeAccept( functionDecl->get_statements(), newCtorDtor ); + visit_children = false; // do not try and construct parameters or forall parameters - must happen after maybeAccept + } + + void CtorDtor::previsit( StructDecl *aggregateDecl ) { + visit_children = false; // do not try to construct and destruct aggregate members + // don't construct members, but need to take note if there is a managed member, // because that means that this type is also managed @@ -336,14 +334,9 @@ } } - return aggregateDecl; - } - - CompoundStmt * CtorDtor::mutate( CompoundStmt * compoundStmt ) { - managedTypes.beginScope(); - CompoundStmt * stmt = Parent::mutate( compoundStmt ); - managedTypes.endScope(); - return stmt; - } - + } + + void CtorDtor::previsit( CompoundStmt * compoundStmt ) { + GuardScope( managedTypes ); + } } // namespace InitTweak Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/InitTweak/InitTweak.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -14,11 +14,8 @@ public: bool hasDesignations = false; - template - void handleInit( Init * init ) { - if ( ! init->get_designators().empty() ) hasDesignations = true; - else Visitor::visit( init ); - } - virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); } - virtual void visit( ListInit * listInit ) { handleInit( listInit); } + virtual void visit( Designation * des ) { + if ( ! des->get_designators().empty() ) hasDesignations = true; + else Visitor::visit( des ); + } }; Index: src/MakeLibCfa.cc =================================================================== --- src/MakeLibCfa.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/MakeLibCfa.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -92,5 +92,5 @@ assert( ! objDecl->get_init() ); std::list< Expression* > noDesignators; - objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), noDesignators, false ) ); // cannot be constructed + objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), false ) ); // cannot be constructed newDecls.push_back( objDecl ); } Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/Makefile.in (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -119,4 +119,5 @@ ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT) \ ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT) \ + ControlStruct/driver_cfa_cpp-ExceptTranslate.$(OBJEXT) \ GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \ GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \ @@ -161,4 +162,5 @@ ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT) \ ResolvExpr/driver_cfa_cpp-TypeEnvironment.$(OBJEXT) \ + ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT) \ SymTab/driver_cfa_cpp-Indexer.$(OBJEXT) \ SymTab/driver_cfa_cpp-Mangler.$(OBJEXT) \ @@ -394,5 +396,6 @@ ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \ ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \ - ControlStruct/ForExprMutator.cc GenPoly/Box.cc \ + ControlStruct/ForExprMutator.cc \ + ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \ GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \ GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \ @@ -414,12 +417,12 @@ ResolvExpr/RenameVars.cc ResolvExpr/FindOpenVars.cc \ ResolvExpr/PolyCost.cc ResolvExpr/Occurs.cc \ - ResolvExpr/TypeEnvironment.cc SymTab/Indexer.cc \ - SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \ - SymTab/ImplementationType.cc SymTab/TypeEquality.cc \ - SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \ - SynTree/BasicType.cc SynTree/PointerType.cc \ - SynTree/ArrayType.cc SynTree/FunctionType.cc \ - SynTree/ReferenceToType.cc SynTree/TupleType.cc \ - SynTree/TypeofType.cc SynTree/AttrType.cc \ + ResolvExpr/TypeEnvironment.cc ResolvExpr/CurrentObject.cc \ + SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \ + SymTab/FixFunction.cc SymTab/ImplementationType.cc \ + SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \ + SynTree/VoidType.cc SynTree/BasicType.cc \ + SynTree/PointerType.cc SynTree/ArrayType.cc \ + SynTree/FunctionType.cc SynTree/ReferenceToType.cc \ + SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \ SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \ SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \ @@ -592,4 +595,7 @@ ControlStruct/$(DEPDIR)/$(am__dirstamp) ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT): \ + ControlStruct/$(am__dirstamp) \ + ControlStruct/$(DEPDIR)/$(am__dirstamp) +ControlStruct/driver_cfa_cpp-ExceptTranslate.$(OBJEXT): \ ControlStruct/$(am__dirstamp) \ ControlStruct/$(DEPDIR)/$(am__dirstamp) @@ -721,4 +727,7 @@ ResolvExpr/$(am__dirstamp) \ ResolvExpr/$(DEPDIR)/$(am__dirstamp) +ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT): \ + ResolvExpr/$(am__dirstamp) \ + ResolvExpr/$(DEPDIR)/$(am__dirstamp) SymTab/$(am__dirstamp): @$(MKDIR_P) SymTab @@ -853,4 +862,5 @@ -rm -f Common/driver_cfa_cpp-UniqueName.$(OBJEXT) -rm -f Concurrency/driver_cfa_cpp-Keywords.$(OBJEXT) + -rm -f ControlStruct/driver_cfa_cpp-ExceptTranslate.$(OBJEXT) -rm -f ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT) -rm -f ControlStruct/driver_cfa_cpp-LabelFixer.$(OBJEXT) @@ -890,4 +900,5 @@ -rm -f ResolvExpr/driver_cfa_cpp-CommonType.$(OBJEXT) -rm -f ResolvExpr/driver_cfa_cpp-ConversionCost.$(OBJEXT) + -rm -f ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT) -rm -f ResolvExpr/driver_cfa_cpp-FindOpenVars.$(OBJEXT) -rm -f ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT) @@ -965,4 +976,5 @@ @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/driver_cfa_cpp-Keywords.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-ForExprMutator.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelFixer.Po@am__quote@ @@ -1002,4 +1014,5 @@ @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CommonType.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ConversionCost.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-FindOpenVars.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Occurs.Po@am__quote@ @@ -1355,4 +1368,18 @@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-ForExprMutator.obj `if test -f 'ControlStruct/ForExprMutator.cc'; then $(CYGPATH_W) 'ControlStruct/ForExprMutator.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ForExprMutator.cc'; fi` +ControlStruct/driver_cfa_cpp-ExceptTranslate.o: ControlStruct/ExceptTranslate.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-ExceptTranslate.o -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo -c -o ControlStruct/driver_cfa_cpp-ExceptTranslate.o `test -f 'ControlStruct/ExceptTranslate.cc' || echo '$(srcdir)/'`ControlStruct/ExceptTranslate.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='ControlStruct/ExceptTranslate.cc' object='ControlStruct/driver_cfa_cpp-ExceptTranslate.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-ExceptTranslate.o `test -f 'ControlStruct/ExceptTranslate.cc' || echo '$(srcdir)/'`ControlStruct/ExceptTranslate.cc + +ControlStruct/driver_cfa_cpp-ExceptTranslate.obj: ControlStruct/ExceptTranslate.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-ExceptTranslate.obj -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo -c -o ControlStruct/driver_cfa_cpp-ExceptTranslate.obj `if test -f 'ControlStruct/ExceptTranslate.cc'; then $(CYGPATH_W) 'ControlStruct/ExceptTranslate.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ExceptTranslate.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='ControlStruct/ExceptTranslate.cc' object='ControlStruct/driver_cfa_cpp-ExceptTranslate.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-ExceptTranslate.obj `if test -f 'ControlStruct/ExceptTranslate.cc'; then $(CYGPATH_W) 'ControlStruct/ExceptTranslate.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ExceptTranslate.cc'; fi` + GenPoly/driver_cfa_cpp-Box.o: GenPoly/Box.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-Box.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Tpo -c -o GenPoly/driver_cfa_cpp-Box.o `test -f 'GenPoly/Box.cc' || echo '$(srcdir)/'`GenPoly/Box.cc @@ -1942,4 +1969,18 @@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-TypeEnvironment.obj `if test -f 'ResolvExpr/TypeEnvironment.cc'; then $(CYGPATH_W) 'ResolvExpr/TypeEnvironment.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/TypeEnvironment.cc'; fi` + +ResolvExpr/driver_cfa_cpp-CurrentObject.o: ResolvExpr/CurrentObject.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.o -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.o `test -f 'ResolvExpr/CurrentObject.cc' || echo '$(srcdir)/'`ResolvExpr/CurrentObject.cc + +ResolvExpr/driver_cfa_cpp-CurrentObject.obj: ResolvExpr/CurrentObject.cc +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-CurrentObject.obj -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='ResolvExpr/CurrentObject.cc' object='ResolvExpr/driver_cfa_cpp-CurrentObject.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi` SymTab/driver_cfa_cpp-Indexer.o: SymTab/Indexer.cc Index: src/Parser/InitializerNode.cc =================================================================== --- src/Parser/InitializerNode.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/Parser/InitializerNode.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -74,30 +74,27 @@ InitializerNode *moreInit; - if ( get_next() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) != 0) ) + if ( (moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) ) { moreInit->printOneLine( os ); + } } Initializer *InitializerNode::build() const { if ( aggregate ) { + // steal designators from children + std::list< Designation * > designlist; + InitializerNode * child = next_init(); + for ( ; child != nullptr; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) { + std::list< Expression * > desList; + buildList< Expression, ExpressionNode >( child->designator, desList ); + designlist.push_back( new Designation( desList ) ); + } // for std::list< Initializer * > initlist; buildList< Initializer, InitializerNode >( next_init(), initlist ); - - std::list< Expression * > designlist; - - if ( designator != 0 ) { - buildList< Expression, ExpressionNode >( designator, designlist ); - } // if - return new ListInit( initlist, designlist, maybeConstructed ); } else { - std::list< Expression * > designators; - - if ( designator != 0 ) - buildList< Expression, ExpressionNode >( designator, designators ); - - if ( get_expression() != 0) - return new SingleInit( maybeBuild< Expression >( get_expression() ), designators, maybeConstructed ); + if ( get_expression() != 0) { + return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed ); + } } // if - return 0; } Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/Parser/TypeData.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -760,5 +760,5 @@ if ( cur->has_enumeratorValue() ) { ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members); - member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) ); + member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) ); } // if } // for @@ -777,6 +777,7 @@ TupleType * buildTuple( const TypeData * td ) { assert( td->kind == TypeData::Tuple ); - TupleType * ret = new TupleType( buildQualifiers( td ) ); - buildTypeList( td->tuple, ret->get_types() ); + std::list< Type * > types; + buildTypeList( td->tuple, types ); + TupleType * ret = new TupleType( buildQualifiers( td ), types ); buildForall( td->forall, ret->get_forall() ); return ret; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/Parser/parser.yy (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -9,7 +9,7 @@ // Author : Peter A. Buhr // Created On : Sat Sep 1 20:22:55 2001 -// Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jun 28 22:11:22 2017 -// Update Count : 2414 +// Last Modified By : Andrew Beach +// Last Modified On : Fri Jun 30 15:38:00 2017 +// Update Count : 2415 // @@ -104,4 +104,5 @@ std::string * str; bool flag; + CatchStmt::Kind catch_kind; } @@ -192,4 +193,5 @@ %type switch_clause_list_opt switch_clause_list choose_clause_list_opt choose_clause_list %type /* handler_list */ handler_clause finally_clause +%type handler_key // declarations @@ -958,17 +960,20 @@ handler_clause: // TEMPORARY, TEST EXCEPTIONS - CATCH '(' push push INTEGERconstant pop ')' compound_statement pop - { $$ = new StatementNode( build_catch( CatchStmt::Terminate, nullptr, new ExpressionNode( build_constantInteger( *$5 ) ), $8 ) ); } - | handler_clause CATCH '(' push push INTEGERconstant pop ')' compound_statement pop - { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Terminate, nullptr, new ExpressionNode( build_constantInteger( *$6 ) ), $9 ) ) ); } - - | CATCH '(' push push exception_declaration pop ')' compound_statement pop - { $$ = new StatementNode( build_catch( CatchStmt::Terminate, $5, nullptr, $8 ) ); } - | handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop - { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Terminate, $6, nullptr, $9 ) ) ); } - | CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop - { $$ = new StatementNode( build_catch( CatchStmt::Resume, $5, nullptr, $8 ) ); } - | handler_clause CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop - { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Resume, $6, nullptr, $9 ) ) ); } + handler_key '(' push push INTEGERconstant pop ')' compound_statement pop + { $$ = new StatementNode( build_catch( $1, nullptr, new ExpressionNode( build_constantInteger( *$5 ) ), $8 ) ); } + | handler_clause handler_key '(' push push INTEGERconstant pop ')' compound_statement pop + { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, nullptr, new ExpressionNode( build_constantInteger( *$6 ) ), $9 ) ) ); } + + | handler_key '(' push push exception_declaration pop ')' compound_statement pop + { $$ = new StatementNode( build_catch( $1, $5, nullptr, $8 ) ); } + | handler_clause handler_key '(' push push exception_declaration pop ')' compound_statement pop + { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, nullptr, $9 ) ) ); } + ; + +handler_key: + CATCH + { $$ = CatchStmt::Terminate; } + | CATCHRESUME + { $$ = CatchStmt::Resume; } ; Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/ResolvExpr/AlternativeFinder.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -604,10 +604,10 @@ // ) SymTab::Indexer decls( indexer ); - PRINT( - std::cerr << "============= original indexer" << std::endl; - indexer.print( std::cerr ); - std::cerr << "============= new indexer" << std::endl; - decls.print( std::cerr ); - ) + // PRINT( + // std::cerr << "============= original indexer" << std::endl; + // indexer.print( std::cerr ); + // std::cerr << "============= new indexer" << std::endl; + // decls.print( std::cerr ); + // ) addToIndexer( have, decls ); AssertionSet newNeed; @@ -809,4 +809,30 @@ } + Expression * restructureCast( Expression * argExpr, Type * toType ) { + if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) { + // Argument expression is a tuple and the target type is not void. Cast each member of the tuple + // to its corresponding target type, producing the tuple of those cast expressions. If there are + // more components of the tuple than components in the target type, then excess components do not + // come out in the result expression (but UniqueExprs ensure that side effects will still be done). + if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) { + // expressions which may contain side effects require a single unique instance of the expression. + argExpr = new UniqueExpr( argExpr ); + } + std::list< Expression * > componentExprs; + for ( unsigned int i = 0; i < toType->size(); i++ ) { + // cast each component + TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i ); + componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) ); + } + delete argExpr; + assert( componentExprs.size() > 0 ); + // produce the tuple of casts + return new TupleExpr( componentExprs ); + } else { + // handle normally + return new CastExpr( argExpr, toType->clone() ); + } + } + void AlternativeFinder::visit( CastExpr *castExpr ) { Type *& toType = castExpr->get_result(); @@ -840,28 +866,5 @@ thisCost += Cost( 0, 0, discardedValues ); - Expression * argExpr = i->expr->clone(); - if ( argExpr->get_result()->size() > 1 && ! castExpr->get_result()->isVoid() ) { - // Argument expression is a tuple and the target type is not void. Cast each member of the tuple - // to its corresponding target type, producing the tuple of those cast expressions. If there are - // more components of the tuple than components in the target type, then excess components do not - // come out in the result expression (but UniqueExprs ensure that side effects will still be done). - if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) { - // expressions which may contain side effects require a single unique instance of the expression. - argExpr = new UniqueExpr( argExpr ); - } - std::list< Expression * > componentExprs; - for ( unsigned int i = 0; i < castExpr->get_result()->size(); i++ ) { - // cast each component - TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i ); - componentExprs.push_back( new CastExpr( idx, castExpr->get_result()->getComponent( i )->clone() ) ); - } - delete argExpr; - assert( componentExprs.size() > 0 ); - // produce the tuple of casts - candidates.push_back( Alternative( new TupleExpr( componentExprs ), i->env, i->cost, thisCost ) ); - } else { - // handle normally - candidates.push_back( Alternative( new CastExpr( argExpr->clone(), toType->clone() ), i->env, i->cost, thisCost ) ); - } + candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) ); } // if } // for @@ -1182,4 +1185,51 @@ } + void AlternativeFinder::visit( UntypedInitExpr *initExpr ) { + // handle each option like a cast + AltList candidates; + PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; ) + // O(N^2) checks of d-types with e-types + for ( InitAlternative & initAlt : initExpr->get_initAlts() ) { + Type * toType = resolveTypeof( initAlt.type, indexer ); + SymTab::validateType( toType, &indexer ); + adjustExprType( toType, env, indexer ); + // Ideally the call to findWithAdjustment could be moved out of the loop, but unfortunately it currently has to occur inside or else + // polymorphic return types are not properly bound to the initialization type, since return type variables are only open for the duration of resolving + // the UntypedExpr. This is only actually an issue in initialization contexts that allow more than one possible initialization type, but it is still suboptimal. + AlternativeFinder finder( indexer, env ); + finder.targetType = toType; + finder.findWithAdjustment( initExpr->get_expr() ); + for ( Alternative & alt : finder.get_alternatives() ) { + TypeEnvironment newEnv( alt.env ); + AssertionSet needAssertions, haveAssertions; + OpenVarSet openVars; // find things in env that don't have a "representative type" and claim those are open vars? + PRINT( std::cerr << " @ " << toType << " " << initAlt.designation << std::endl; ) + // It's possible that a cast can throw away some values in a multiply-valued expression. (An example is a + // cast-to-void, which casts from one value to zero.) Figure out the prefix of the subexpression results + // that are cast directly. The candidate is invalid if it has fewer results than there are types to cast + // to. + int discardedValues = alt.expr->get_result()->size() - toType->size(); + if ( discardedValues < 0 ) continue; + // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not + // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3])) + // unification run for side-effects + unify( toType, alt.expr->get_result(), newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type?? + + Cost thisCost = castCost( alt.expr->get_result(), toType, indexer, newEnv ); + if ( thisCost != Cost::infinity ) { + // count one safe conversion for each value that is thrown away + thisCost += Cost( 0, 0, discardedValues ); + candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) ); + } + } + } + + // findMinCost selects the alternatives with the lowest "cost" members, but has the side effect of copying the + // cvtCost member to the cost member (since the old cost is now irrelevant). Thus, calling findMinCost twice + // selects first based on argument cost, then on conversion cost. + AltList minArgCost; + findMinCost( candidates.begin(), candidates.end(), std::back_inserter( minArgCost ) ); + findMinCost( minArgCost.begin(), minArgCost.end(), std::back_inserter( alternatives ) ); + } } // namespace ResolvExpr Index: src/ResolvExpr/AlternativeFinder.h =================================================================== --- src/ResolvExpr/AlternativeFinder.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/ResolvExpr/AlternativeFinder.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -73,4 +73,5 @@ virtual void visit( UniqueExpr *unqExpr ); virtual void visit( StmtExpr *stmtExpr ); + virtual void visit( UntypedInitExpr *initExpr ); /// Runs a new alternative finder on each element in [begin, end) /// and writes each alternative finder to out. Index: src/ResolvExpr/CurrentObject.cc =================================================================== --- src/ResolvExpr/CurrentObject.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) +++ src/ResolvExpr/CurrentObject.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -0,0 +1,587 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// CurrentObject.h -- +// +// Author : Rob Schluntz +// Created On : Tue Jun 13 15:28:32 2017 +// Last Modified By : Rob Schluntz +// Last Modified On : Tue Jun 13 15:28:44 2017 +// Update Count : 2 +// + +#include +#include + +#include "CurrentObject.h" + +#include "SynTree/Declaration.h" +#include "SynTree/Initializer.h" +#include "SynTree/Type.h" +#include "SynTree/TypeSubstitution.h" + +#if 0 +#define PRINT(x) x +#else +#define PRINT(x) +#endif + +namespace ResolvExpr { + long long int getConstValue( ConstantExpr * constExpr ) { + if ( BasicType * basicType = dynamic_cast< BasicType * >( constExpr->get_result() ) ) { + if ( basicType->isInteger() ) { + return constExpr->get_constant()->get_ival(); + } else { + assertf( false, "Non-integer constant expression in getConstValue", toString( constExpr ).c_str() ); // xxx - might be semantic error + } + } else if ( dynamic_cast< OneType * >( constExpr->get_result() ) ) { + return 1; + } else if ( dynamic_cast< ZeroType * >( constExpr->get_result() ) ) { + return 0; + } else { + assertf( false, "unhandled type on getConstValue %s", toString( constExpr->get_result() ).c_str() ); // xxx - might be semantic error + } + } + + struct Indenter { + static const int amt = 2; + unsigned int indent = 0; + + Indenter & operator+=(int nlevels) { indent += amt*nlevels; return *this; } + Indenter & operator-=(int nlevels) { indent -= amt*nlevels; return *this; } + Indenter operator+(int nlevels) { Indenter indenter = *this; return indenter += nlevels; } + Indenter operator-(int nlevels) { Indenter indenter = *this; return indenter -= nlevels; } + Indenter & operator++() { return *this += 1; } + Indenter & operator--() { return *this -= 1; } + }; + std::ostream & operator<<( std::ostream & out, Indenter & indent ) { + return out << std::string(indent.indent, ' '); + } + + template< typename AggrInst > + TypeSubstitution makeGenericSubstitution( AggrInst * inst ) { + assert( inst ); + assert( inst->get_baseParameters() ); + std::list< TypeDecl * > baseParams = *inst->get_baseParameters(); + std::list< Expression * > typeSubs = inst->get_parameters(); + TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() ); + return subs; + } + + TypeSubstitution makeGenericSubstitution( Type * type ) { + if ( StructInstType * inst = dynamic_cast< StructInstType * >( type ) ) { + return makeGenericSubstitution( inst ); + } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( type ) ) { + return makeGenericSubstitution( inst ); + } else { + return TypeSubstitution(); + } + } + + class MemberIterator { + public: + virtual ~MemberIterator() {} + + virtual void setPosition( std::list< Expression * > & designators ) = 0; + virtual std::list operator*() const = 0; + virtual operator bool() const = 0; + virtual MemberIterator & bigStep() = 0; + virtual MemberIterator & smallStep() = 0; + virtual Type * getType() = 0; + virtual Type * getNext() = 0; + + virtual void print( std::ostream & out, Indenter indent ) const = 0; + + virtual std::list first() const = 0; // should be protected + }; + + std::ostream & operator<<(std::ostream & out, const MemberIterator & it) { + Indenter indenter; + it.print( out, indenter ); + return out; + } + + /// create a new MemberIterator that traverses a type correctly + MemberIterator * createMemberIterator( Type * type ); + + /// iterates "other" types, e.g. basic types, pointer types, etc. which do not change at list initializer entry + class SimpleIterator : public MemberIterator { + public: + SimpleIterator( Type * type ) : type( type ) {} + + virtual void setPosition( std::list< Expression * > & designators ) { + assertf( designators.empty(), "simple iterator given non-empty designator..." ); // xxx - might be semantic error + } + + virtual std::list operator*() const { return first(); } + virtual operator bool() const { return type; } + + // big step is the same as small step + virtual MemberIterator & bigStep() { return smallStep(); } + virtual MemberIterator & smallStep() { + type = nullptr; // type is nullified on increment since SimpleIterators do not have members + return *this; + } + + virtual void print( std::ostream & out, Indenter indent ) const { + out << "SimpleIterator(" << type << ")"; + } + + virtual Type * getType() { return type; } + virtual Type * getNext() { return type; } + + protected: + virtual std::list first() const { + if ( type ) return std::list{ { type->clone(), new Designation( {} ) } }; + else return std::list{}; + } + private: + Type * type = nullptr; + }; + + class ArrayIterator : public MemberIterator { + public: + ArrayIterator( ArrayType * at ) : array( at ) { + PRINT( std::cerr << "Creating array iterator: " << at << std::endl; ) + base = at->get_base(); + memberIter = createMemberIterator( base ); + setSize( at->get_dimension() ); + } + + ~ArrayIterator() { + delete memberIter; + } + + private: + void setSize( Expression * expr ) { + if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) { + size = getConstValue( constExpr ); + PRINT( std::cerr << "array type with size: " << size << std::endl; ) + } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { + setSize( castExpr->get_arg() ); // xxx - need to perform the conversion specified by the cast + } else { + assertf( false, "unhandled expression in setSize: %s", toString( expr ).c_str() ); // xxx - if not a constant expression, it's not simple to determine how long the array actually is, which is necessary for initialization to be done correctly -- fix this + } + } + + public: + void setPosition( Expression * expr ) { + // need to permit integer-constant-expressions, including: integer constants, enumeration constants, character constants, sizeof expressions, _Alignof expressions, cast expressions + if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) { + index = getConstValue( constExpr ); + } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { + setPosition( castExpr->get_arg() ); + } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) { + assertf( dynamic_cast ( varExpr->get_result() ), "ArrayIterator given variable that isn't an enum constant", toString( expr ).c_str() ); + index = 0; // xxx - get actual value of enum constant + } else if ( dynamic_cast< SizeofExpr * >( expr ) || dynamic_cast< AlignofExpr * >( expr ) ) { + index = 0; // xxx - get actual sizeof/alignof value? + } else { + assertf( false, "bad designator given to ArrayIterator: %s", toString( expr ).c_str() ); + } + } + + virtual void setPosition( std::list< Expression * > & designators ) { + if ( ! designators.empty() ) { + setPosition( designators.front() ); + designators.pop_front(); + memberIter->setPosition( designators ); + } + } + + virtual std::list operator*() const { + return first(); + } + + virtual operator bool() const { return index < size; } + + virtual MemberIterator & bigStep() { + PRINT( std::cerr << "bigStep in ArrayIterator (" << index << "/" << size << ")" << std::endl; ) + ++index; + delete memberIter; + if ( index < size ) memberIter = createMemberIterator( base ); + else memberIter = nullptr; + return *this; + } + + virtual MemberIterator & smallStep() { + PRINT( std::cerr << "smallStep in ArrayIterator (" << index << "/" << size << ")" << std::endl; ) + if ( memberIter ) { + PRINT( std::cerr << "has member iter: " << *memberIter << std::endl; ) + memberIter->smallStep(); + if ( *memberIter ) { + PRINT( std::cerr << "has valid member iter" << std::endl; ) + return *this; + } + } + return bigStep(); + } + + virtual Type * getType() { return array; } + virtual Type * getNext() { return base; } + + virtual std::list first() const { + PRINT( std::cerr << "first in ArrayIterator (" << index << "/" << size << ")" << std::endl; ) + if ( memberIter && *memberIter ) { + std::list ret = memberIter->first(); + for ( InitAlternative & alt : ret ) { + alt.designation->get_designators().push_front( new ConstantExpr( Constant::from_ulong( index ) ) ); + } + return ret; + } + return std::list(); + } + + virtual void print( std::ostream & out, Indenter indent ) const { + out << "ArrayIterator(Array of " << base << ")"; + if ( memberIter ) { + Indenter childIndent = indent+1; + out << std::endl << childIndent; + memberIter->print( out, childIndent ); + } + } + + private: + ArrayType * array = nullptr; + Type * base = nullptr; + size_t index = 0; + size_t size = 0; + MemberIterator * memberIter = nullptr; + }; + + class AggregateIterator : public MemberIterator { + public: + typedef std::list MemberList; + typedef MemberList::const_iterator iterator; + std::string kind = ""; // for debug + std::string name; + Type * inst = nullptr; + const MemberList & members; + iterator curMember; + bool atbegin = true; // false at first {small,big}Step -- this aggr type is only added to the possibilities at the beginning + Type * curType = nullptr; + MemberIterator * memberIter = nullptr; + mutable TypeSubstitution sub; + + AggregateIterator( const std::string & kind, const std::string & name, Type * inst, const MemberList & members ) : kind( kind ), name( name ), inst( inst ), members( members ), curMember( members.begin() ), sub( makeGenericSubstitution( inst ) ) { + init(); + } + + virtual ~AggregateIterator() { + delete memberIter; + } + + bool init() { + PRINT( std::cerr << "--init()--" << members.size() << std::endl; ) + if ( curMember != members.end() ) { + if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( *curMember ) ) { + PRINT( std::cerr << "incremented to field: " << field << std::endl; ) + curType = field->get_type(); + memberIter = createMemberIterator( curType ); + return true; + } + } + return false; + } + + virtual std::list operator*() const { + if (memberIter && *memberIter) { + std::list ret = memberIter->first(); + PRINT( std::cerr << "sub: " << sub << std::endl; ) + for ( InitAlternative & alt : ret ) { + PRINT( std::cerr << "iterating and adding designators" << std::endl; ) + alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) ); + // need to substitute for generic types, so that casts are to concrete types + PRINT( std::cerr << " type is: " << alt.type; ) + sub.apply( alt.type ); // also apply to designation?? + PRINT( std::cerr << " ==> " << alt.type << std::endl; ) + } + return ret; + } + return std::list(); + } + + virtual void setPosition( std::list< Expression * > & designators ) { + if ( ! designators.empty() ) { + if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( designators.front() ) ) { + for ( curMember = members.begin(); curMember != members.end(); ++curMember ) { + if ( *curMember == varExpr->get_var() ) { + designators.pop_front(); + delete memberIter; + memberIter = createMemberIterator( varExpr->get_result() ); + curType = varExpr->get_result(); + atbegin = curMember == members.begin() && designators.empty(); // xxx - is this the right condition for atbegin?? + memberIter->setPosition( designators ); + return; + } // if + } // for + assertf( false, "could not find member in %s: %s", kind.c_str(), toString( varExpr ).c_str() ); + } else { + assertf( false, "bad designator given to %s: %s", kind.c_str(), toString( designators.front() ).c_str() ); + } // if + } // if + } + + virtual MemberIterator & smallStep() { + PRINT( std::cerr << "smallStep in " << kind << std::endl; ) + atbegin = false; + if ( memberIter ) { + PRINT( std::cerr << "has member iter, incrementing..." << std::endl; ) + memberIter->smallStep(); + if ( *memberIter ) { + PRINT( std::cerr << "success!" << std::endl; ) + return *this; + } + } + return bigStep(); + } + + virtual Type * getType() { return inst; } + virtual Type * getNext() { + if ( memberIter && *memberIter ) return memberIter->getType(); // xxx - ??? recursive call??? + return nullptr; + } + + virtual std::list first() const { + std::list ret; + PRINT( std::cerr << "first " << kind << std::endl; ) + if ( memberIter && *memberIter ) { // might not need *memberIter?? + PRINT( std::cerr << "adding children" << std::endl; ) + ret = memberIter->first(); + for ( InitAlternative & alt : ret ) { + PRINT( std::cerr << "iterating and adding designators" << std::endl; ) + alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) ); + } + } + // if ( curMember == std::next( decl->get_members().begin(), 1 ) ) { // xxx - this never triggers because curMember is incremented immediately on construction + if ( atbegin ) { // xxx - this never triggers because curMember is incremented immediately on construction + // xxx - what about case of empty struct?? + // only add self if at the very beginning of the structure + PRINT( std::cerr << "adding self" << std::endl; ) + ret.push_front( { inst->clone(), new Designation( {} ) } ); + } + return ret; + } + + virtual void print( std::ostream & out, Indenter indent ) const { + out << kind << "(" << name << ")"; + if ( memberIter ) { + Indenter childIndent = indent+1; + out << std::endl << childIndent; + memberIter->print( out, childIndent ); + } + } + }; + + class UnionIterator : public AggregateIterator { + public: + UnionIterator( UnionInstType * inst ) : AggregateIterator( "UnionIterator", inst->get_name(), inst, inst->get_baseUnion()->get_members() ) {} + + virtual operator bool() const { return (memberIter && *memberIter); } + virtual MemberIterator & bigStep() { + // unions only initialize one member + PRINT( std::cerr << "bigStep in " << kind << std::endl; ) + atbegin = false; + delete memberIter; + memberIter = nullptr; + curType = nullptr; + curMember = members.end(); + return *this; + } + virtual std::list first() const { return std::list{}; } + }; + + class StructIterator : public AggregateIterator { + public: + StructIterator( StructInstType * inst ) : AggregateIterator( "StructIterator", inst->get_name(), inst, inst->get_baseStruct()->get_members() ) {} + + virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); } + + virtual MemberIterator & bigStep() { + PRINT( std::cerr << "bigStep in " << kind << std::endl; ) + atbegin = false; + delete memberIter; + memberIter = nullptr; + curType = nullptr; + for ( ; curMember != members.end(); ) { + ++curMember; + if ( init() ) { + return *this; + } + } + return *this; + } + }; + + class TupleIterator : public AggregateIterator { + public: + TupleIterator( TupleType * inst ) : AggregateIterator( "TupleIterator", toString("Tuple", inst->size()), inst, inst->get_members() ) {} + + virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); } + + virtual MemberIterator & bigStep() { + PRINT( std::cerr << "bigStep in " << kind << std::endl; ) + atbegin = false; + delete memberIter; + memberIter = nullptr; + curType = nullptr; + for ( ; curMember != members.end(); ) { + ++curMember; + if ( init() ) { + return *this; + } + } + return *this; + } + }; + + MemberIterator * createMemberIterator( Type * type ) { + if ( ReferenceToType * aggr = dynamic_cast< ReferenceToType * >( type ) ) { + if ( StructInstType * sit = dynamic_cast< StructInstType * >( aggr ) ) { + return new StructIterator( sit ); + } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( aggr ) ) { + return new UnionIterator( uit ); + } else { + assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype" ); + return new SimpleIterator( type ); + } + } else if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { + return new ArrayIterator( at ); + } else if ( TupleType * tt = dynamic_cast< TupleType * >( type ) ) { + return new TupleIterator( tt ); + } else { + return new SimpleIterator( type ); + } + } + + CurrentObject::CurrentObject() {} + CurrentObject::CurrentObject( Type * type ) { + objStack.push( new SimpleIterator( type ) ); + } + + + void CurrentObject::setNext( Designation * designation ) { + assertf( ! objStack.empty(), "obj stack empty in setNext" ); + PRINT( std::cerr << "____setNext" << designation << std::endl; ) + objStack.top()->setPosition( designation->get_designators() ); + } + + Designation * CurrentObject::findNext( Designation * designation ) { + typedef std::list< Expression * > DesignatorChain; + PRINT( std::cerr << "___findNext" << std::endl; ) + // find all the d's + std::list desigAlts{ { } }, newDesigAlts; + std::list curTypes { (objStack.top())->getType() }, newTypes; + for ( Expression * expr : designation->get_designators() ) { + PRINT( std::cerr << "____untyped: " << expr << std::endl; ) + std::list::iterator dit = desigAlts.begin(); + if ( NameExpr * nexpr = dynamic_cast(expr) ) { + for ( Type * t : curTypes ) { + assert( dit != desigAlts.end() ); + DesignatorChain & d = *dit; + PRINT( std::cerr << "____actual: " << t << std::endl; ) + ReferenceToType * refType = dynamic_cast(t); + std::list members; + if ( refType ) { + refType->lookup( nexpr->get_name(), members ); // concatenate identical field name + // xxx - need to also include anonymous members in this somehow... + for ( Declaration * mem: members ) { + if ( ObjectDecl * field = dynamic_cast(mem) ) { + PRINT( std::cerr << "____alt: " << field->get_type() << std::endl; ) + DesignatorChain newD = d; + newD.push_back( new VariableExpr( field ) ); + newDesigAlts.push_back( newD ); + newTypes.push_back( field->get_type() ); + } // if + } // for + } // if + ++dit; + } // for + } else { + for ( Type * t : curTypes ) { + assert( dit != desigAlts.end() ); + DesignatorChain & d = *dit; + if ( ArrayType * at = dynamic_cast< ArrayType * > ( t ) ) { + PRINT( std::cerr << "____alt: " << at->get_base() << std::endl; ) + d.push_back( expr ); + newDesigAlts.push_back( d ); + newTypes.push_back( at->get_base() ); + } + ++dit; + } // for + } // if + desigAlts = newDesigAlts; + newDesigAlts.clear(); + curTypes = newTypes; + newTypes.clear(); + assertf( desigAlts.size() == curTypes.size(), "Designator alternatives (%d) and current types (%d) out of sync", desigAlts.size(), curTypes.size() ); + } // for + if ( desigAlts.size() > 1 ) { + throw SemanticError( toString("Too many alternatives (", desigAlts.size(), ") for designation: "), designation ); + } else if ( desigAlts.size() == 0 ) { + throw SemanticError( "No reasonable alternatives for designation: ", designation ); + } + DesignatorChain & d = desigAlts.back(); + PRINT( for ( Expression * expr : d ) { + std::cerr << "____desig: " << expr << std::endl; + } ) // for + assertf( ! curTypes.empty(), "empty designator chosen"); + + // set new designators + assertf( ! objStack.empty(), "empty object stack when setting designation" ); + Designation * actualDesignation = new Designation( d ); + objStack.top()->setPosition( d ); // destroys d + return actualDesignation; + } + + void CurrentObject::increment() { + PRINT( std::cerr << "____increment" << std::endl; ) + if ( ! objStack.empty() ) { + PRINT( std::cerr << *objStack.top() << std::endl; ) + objStack.top()->smallStep(); + } + } + + void CurrentObject::enterListInit() { + PRINT( std::cerr << "____entering list init" << std::endl; ) + assertf( ! objStack.empty(), "empty obj stack entering list init" ); + Type * type = objStack.top()->getNext(); + if ( type ) { + objStack.push( createMemberIterator( type ) ); + } else { + assertf( false, "not sure about this case..." ); + } + } + + void CurrentObject::exitListInit() { + PRINT( std::cerr << "____exiting list init" << std::endl; ) + assertf( ! objStack.empty(), "objstack empty" ); + delete objStack.top(); + objStack.pop(); + if ( ! objStack.empty() ) { + PRINT( std::cerr << *objStack.top() << std::endl; ) + objStack.top()->bigStep(); + } + } + + std::list< InitAlternative > CurrentObject::getOptions() { + PRINT( std::cerr << "____getting current options" << std::endl; ) + assertf( ! objStack.empty(), "objstack empty in getOptions" ); + return **objStack.top(); + } + + Type * CurrentObject::getCurrentType() { + PRINT( std::cerr << "____getting current type" << std::endl; ) + assertf( ! objStack.empty(), "objstack empty in getCurrentType" ); + return objStack.top()->getNext(); + } +} // namespace ResolvExpr + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/ResolvExpr/CurrentObject.h =================================================================== --- src/ResolvExpr/CurrentObject.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) +++ src/ResolvExpr/CurrentObject.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -0,0 +1,59 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// CurrentObject.h -- +// +// Author : Rob Schluntz +// Created On : Thu Jun 8 11:07:25 2017 +// Last Modified By : Rob Schluntz +// Last Modified On : Thu Jun 8 11:07:41 2017 +// Update Count : 2 +// + +#ifndef CURRENT_OBJECT_H +#define CURRENT_OBJECT_H + +#include + +#include "SynTree/SynTree.h" +#include "SynTree/Expression.h" + +namespace ResolvExpr { + class MemberIterator; + + class CurrentObject { + public: + CurrentObject(); + CurrentObject( Type * type ); + + /// resolves unresolved designation + Designation * findNext( Designation * designation ); + /// sets current position using resolved designation + void setNext( Designation * designation ); + /// steps to next sub-object of current-object + void increment(); + /// sets new current-object for the duration of this brace-enclosed initializer-list + void enterListInit(); + /// restores previous current-object + void exitListInit(); + /// produces a list of alternatives (Type *, Designation *) for the current sub-object's initializer + std::list< InitAlternative > getOptions(); + /// produces the type of the current object but no subobjects + Type * getCurrentType(); + + private: + std::stack< MemberIterator * > objStack; + }; +} // namespace ResolvExpr + +#endif // CURRENT_OBJECT_H + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // + Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/ResolvExpr/Resolver.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -14,20 +14,26 @@ // +#include + +#include "Alternative.h" +#include "AlternativeFinder.h" +#include "CurrentObject.h" +#include "RenameVars.h" #include "Resolver.h" -#include "AlternativeFinder.h" -#include "Alternative.h" -#include "RenameVars.h" #include "ResolveTypeof.h" #include "typeops.h" + +#include "SynTree/Expression.h" +#include "SynTree/Initializer.h" #include "SynTree/Statement.h" #include "SynTree/Type.h" -#include "SynTree/Expression.h" -#include "SynTree/Initializer.h" + +#include "SymTab/Autogen.h" #include "SymTab/Indexer.h" -#include "SymTab/Autogen.h" + #include "Common/utility.h" + #include "InitTweak/InitTweak.h" -#include using namespace std; @@ -39,5 +45,5 @@ if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) { functionReturn = res->functionReturn; - initContext = res->initContext; + currentObject = res->currentObject; inEnumDecl = res->inEnumDecl; } @@ -64,4 +70,5 @@ virtual void visit( BranchStmt *branchStmt ) override; virtual void visit( ReturnStmt *returnStmt ) override; + virtual void visit( ThrowStmt *throwStmt ) override; virtual void visit( SingleInit *singleInit ) override; @@ -79,5 +86,5 @@ Type * functionReturn = nullptr; - Type *initContext = nullptr; + CurrentObject currentObject = nullptr; bool inEnumDecl = false; }; @@ -186,17 +193,16 @@ // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting // the RHS. - Type *temp = initContext; - initContext = new_type; - if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) { + ValueGuard temp( currentObject ); + currentObject = CurrentObject( objectDecl->get_type() ); + if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) { // enumerator initializers should not use the enum type to initialize, since // the enum type is still incomplete at this point. Use signed int instead. - initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt ); + currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ); } Parent::visit( objectDecl ); - if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) { + if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) { // delete newly created signed int type - delete initContext; - } - initContext = temp; + // delete currentObject.getType(); + } } @@ -315,5 +321,5 @@ void Resolver::visit( SwitchStmt *switchStmt ) { - ValueGuard< Type * > oldInitContext( initContext ); + ValueGuard< CurrentObject > oldCurrentObject( currentObject ); Expression *newExpr; newExpr = findIntegralExpression( switchStmt->get_condition(), *this ); @@ -321,5 +327,5 @@ switchStmt->set_condition( newExpr ); - initContext = newExpr->get_result(); + currentObject = CurrentObject( newExpr->get_result() ); Parent::visit( switchStmt ); } @@ -327,6 +333,7 @@ void Resolver::visit( CaseStmt *caseStmt ) { if ( caseStmt->get_condition() ) { - assert( initContext ); - CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initContext->clone() ); + std::list< InitAlternative > initAlts = currentObject.getOptions(); + assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." ); + CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() ); Expression * newExpr = findSingleExpression( castExpr, *this ); castExpr = safe_dynamic_cast< CastExpr * >( newExpr ); @@ -360,4 +367,12 @@ } + void Resolver::visit( ThrowStmt *throwStmt ) { + if ( throwStmt->get_expr() ) { + Expression * wrapped = new CastExpr( throwStmt->get_expr(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ); + Expression * newExpr = findSingleExpression( wrapped, *this ); + throwStmt->set_expr( newExpr ); + } + } + template< typename T > bool isCharType( T t ) { @@ -370,205 +385,75 @@ void Resolver::visit( SingleInit *singleInit ) { - if ( singleInit->get_value() ) { - // // find all the d's - // std::list &designators = singleInit->get_designators(); - // std::list types1{ initContext }, types2; - // for ( Expression * expr: designators ) { - // cerr << expr << endl; - // if ( NameExpr * nexpr = dynamic_cast( expr ) ) { - // for ( Type * type: types1 ) { - // cerr << type << endl; - // ReferenceToType * fred = dynamic_cast(type); - // std::list members; - // if ( fred ) { - // fred->lookup( nexpr->get_name(), members ); // concatenate identical field name - // for ( Declaration * mem: members ) { - // if ( DeclarationWithType * dwt = dynamic_cast(mem) ) { - // types2.push_back( dwt->get_type() ); - // } // if - // } // for - // } // if - // } // for - // types1 = types2; - // types2.clear(); - // } // if - // } // for - // // for ( Type * type: types1 ) { - // // cerr << type << endl; - // // } // for - - // // O(N^2) checks of d-types with f-types - // // find the minimum cost - CastExpr *castExpr = new CastExpr( singleInit->get_value(), initContext->clone() ); - Expression *newExpr = findSingleExpression( castExpr, *this ); - delete castExpr; - singleInit->set_value( newExpr ); - - // check if initializing type is char[] - if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) { - if ( isCharType( at->get_base() ) ) { - // check if the resolved type is char * - if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) { - if ( isCharType( pt->get_base() ) ) { - // strip cast if we're initializing a char[] with a char *, e.g. char x[] = "hello"; - CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ); - singleInit->set_value( ce->get_arg() ); - ce->set_arg( NULL ); - delete ce; - } + // resolve initialization using the possibilities as determined by the currentObject cursor + UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() ); + Expression * newExpr = findSingleExpression( untyped, *this ); + InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr ); + + // move cursor to the object that is actually initialized + currentObject.setNext( initExpr->get_designation() ); + + // discard InitExpr wrapper and retain relevant pieces + newExpr = initExpr->get_expr(); + newExpr->set_env( initExpr->get_env() ); + initExpr->set_expr( nullptr ); + initExpr->set_env( nullptr ); + delete initExpr; + + // get the actual object's type (may not exactly match what comes back from the resolver due to conversions) + Type * initContext = currentObject.getCurrentType(); + + // check if actual object's type is char[] + if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) { + if ( isCharType( at->get_base() ) ) { + // check if the resolved type is char * + if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) { + if ( isCharType( pt->get_base() ) ) { + // strip cast if we're initializing a char[] with a char *, e.g. char x[] = "hello"; + CastExpr *ce = safe_dynamic_cast< CastExpr * >( newExpr ); + newExpr = ce->get_arg(); + ce->set_arg( nullptr ); + delete ce; } } } - } // if - } - - template< typename AggrInst > - TypeSubstitution makeGenericSubstitutuion( AggrInst * inst ) { - assert( inst ); - assert( inst->get_baseParameters() ); - std::list< TypeDecl * > baseParams = *inst->get_baseParameters(); - std::list< Expression * > typeSubs = inst->get_parameters(); - TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() ); - return subs; - } - - ReferenceToType * isStructOrUnion( Type * type ) { - if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) { - return sit; - } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) { - return uit; - } - return nullptr; - } - - void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) { - DeclarationWithType * dt = dynamic_cast< DeclarationWithType * >( dcl ); - assert( dt ); - // need to substitute for generic types, so that casts are to concrete types - initContext = dt->get_type()->clone(); - sub.apply( initContext ); - - try { - if ( init == initEnd ) return; // stop when there are no more initializers - (*init)->accept( *this ); - ++init; // made it past an initializer - } catch( SemanticError & ) { - // need to delve deeper, if you can - if ( ReferenceToType * type = isStructOrUnion( initContext ) ) { - resolveAggrInit( type, init, initEnd ); - } else { - // member is not an aggregate type, so can't go any deeper - - // might need to rethink what is being thrown - throw; - } // if - } - } - - void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) { - if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) { - TypeSubstitution sub = makeGenericSubstitutuion( sit ); - StructDecl * st = sit->get_baseStruct(); - if(st->get_members().empty()) return; - // want to resolve each initializer to the members of the struct, - // but if there are more initializers than members we should stop - list< Declaration * >::iterator it = st->get_members().begin(); - for ( ; it != st->get_members().end(); ++it) { - resolveSingleAggrInit( *it, init, initEnd, sub ); - } - } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) { - TypeSubstitution sub = makeGenericSubstitutuion( uit ); - UnionDecl * un = uit->get_baseUnion(); - if(un->get_members().empty()) return; - // only resolve to the first member of a union - resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub ); - } // if + } + + // set initializer expr to resolved express + singleInit->set_value( newExpr ); + + // move cursor to next object in preparation for next initializer + currentObject.increment(); } void Resolver::visit( ListInit * listInit ) { - InitIterator iter = listInit->begin(); - InitIterator end = listInit->end(); - - if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) { - // resolve each member to the base type of the array - for ( ; iter != end; ++iter ) { - initContext = at->get_base(); - (*iter)->accept( *this ); - } // for - } else if ( TupleType * tt = dynamic_cast< TupleType * > ( initContext ) ) { - for ( Type * t : *tt ) { - if ( iter == end ) break; - initContext = t; - (*iter++)->accept( *this ); - } - } else if ( ReferenceToType * type = isStructOrUnion( initContext ) ) { - resolveAggrInit( type, iter, end ); - } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) { - Type * base = tt->get_baseType()->get_base(); - if ( base ) { - // know the implementation type, so try using that as the initContext - initContext = base; - visit( listInit ); - } else { - // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context - Parent::visit( listInit ); - } - } else { - assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext ) - || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) || dynamic_cast < EnumInstType * > ( initContext ) ); - // basic types are handled here - Parent::visit( listInit ); - } - -#if 0 - if ( ArrayType *at = dynamic_cast(initContext) ) { - std::list::iterator iter( listInit->begin_initializers() ); - for ( ; iter != listInit->end_initializers(); ++iter ) { - initContext = at->get_base(); - (*iter)->accept( *this ); - } // for - } else if ( StructInstType *st = dynamic_cast(initContext) ) { - StructDecl *baseStruct = st->get_baseStruct(); - std::list::iterator iter1( baseStruct->get_members().begin() ); - std::list::iterator iter2( listInit->begin_initializers() ); - for ( ; iter1 != baseStruct->get_members().end() && iter2 != listInit->end_initializers(); ++iter2 ) { - if ( (*iter2)->get_designators().empty() ) { - DeclarationWithType *dt = dynamic_cast( *iter1 ); - initContext = dt->get_type(); - (*iter2)->accept( *this ); - ++iter1; - } else { - StructDecl *st = baseStruct; - iter1 = st->get_members().begin(); - std::list::iterator iter3( (*iter2)->get_designators().begin() ); - for ( ; iter3 != (*iter2)->get_designators().end(); ++iter3 ) { - NameExpr *key = dynamic_cast( *iter3 ); - assert( key ); - for ( ; iter1 != st->get_members().end(); ++iter1 ) { - if ( key->get_name() == (*iter1)->get_name() ) { - (*iter1)->print( cout ); - cout << key->get_name() << endl; - ObjectDecl *fred = dynamic_cast( *iter1 ); - assert( fred ); - StructInstType *mary = dynamic_cast( fred->get_type() ); - assert( mary ); - st = mary->get_baseStruct(); - iter1 = st->get_members().begin(); - break; - } // if - } // for - } // for - ObjectDecl *fred = dynamic_cast( *iter1 ); - assert( fred ); - initContext = fred->get_type(); - (*listInit->begin_initializers())->accept( *this ); - } // if - } // for - } else if ( UnionInstType *st = dynamic_cast(initContext) ) { - DeclarationWithType *dt = dynamic_cast( *st->get_baseUnion()->get_members().begin() ); - initContext = dt->get_type(); - (*listInit->begin_initializers())->accept( *this ); - } // if -#endif + // move cursor into brace-enclosed initializer-list + currentObject.enterListInit(); + // xxx - fix this so that the list isn't copied, iterator should be used to change current element + std::list newDesignations; + for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) { + // iterate designations and initializers in pairs, moving the cursor to the current designated object and resolving + // the initializer against that object. + Designation * des = std::get<0>(p); + Initializer * init = std::get<1>(p); + newDesignations.push_back( currentObject.findNext( des ) ); + init->accept( *this ); + } + // set the set of 'resolved' designations and leave the brace-enclosed initializer-list + listInit->get_designations() = newDesignations; // xxx - memory management + currentObject.exitListInit(); + + // xxx - this part has not be folded into CurrentObject yet + // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) { + // Type * base = tt->get_baseType()->get_base(); + // if ( base ) { + // // know the implementation type, so try using that as the initContext + // ObjectDecl tmpObj( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, base->clone(), nullptr ); + // currentObject = &tmpObj; + // visit( listInit ); + // } else { + // // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context + // Parent::visit( listInit ); + // } + // } else { } Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/ResolvExpr/Unify.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -606,8 +606,8 @@ } else if ( tupleParam ) { // bundle other parameters into tuple to match - TupleType* binder = new TupleType{ paramTy->get_qualifiers() }; + std::list< Type * > binderTypes; do { - binder->get_types().push_back( otherParam->get_type()->clone() ); + binderTypes.push_back( otherParam->get_type()->clone() ); ++jt; @@ -618,12 +618,12 @@ } while (true); - otherParamTy = binder; + otherParamTy = new TupleType{ paramTy->get_qualifiers(), binderTypes }; ++it; // skip ttype parameter for break } else if ( otherTupleParam ) { // bundle parameters into tuple to match other - TupleType* binder = new TupleType{ otherParamTy->get_qualifiers() }; + std::list< Type * > binderTypes; do { - binder->get_types().push_back( param->get_type()->clone() ); + binderTypes.push_back( param->get_type()->clone() ); ++it; @@ -634,5 +634,5 @@ } while (true); - paramTy = binder; + paramTy = new TupleType{ otherParamTy->get_qualifiers(), binderTypes }; ++jt; // skip ttype parameter for break } @@ -756,9 +756,9 @@ return function->get_returnVals().front()->get_type()->clone(); } else { - TupleType * tupleType = new TupleType( Type::Qualifiers() ); + std::list< Type * > types; for ( DeclarationWithType * decl : function->get_returnVals() ) { - tupleType->get_types().push_back( decl->get_type()->clone() ); + types.push_back( decl->get_type()->clone() ); } // for - return tupleType; + return new TupleType( Type::Qualifiers(), types ); } } Index: src/ResolvExpr/module.mk =================================================================== --- src/ResolvExpr/module.mk (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/ResolvExpr/module.mk (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -6,5 +6,5 @@ ## file "LICENCE" distributed with Cforall. ## -## module.mk -- +## module.mk -- ## ## Author : Richard C. Bilson @@ -31,3 +31,4 @@ ResolvExpr/PolyCost.cc \ ResolvExpr/Occurs.cc \ - ResolvExpr/TypeEnvironment.cc + ResolvExpr/TypeEnvironment.cc \ + ResolvExpr/CurrentObject.cc Index: src/SymTab/Autogen.h =================================================================== --- src/SymTab/Autogen.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SymTab/Autogen.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -25,21 +25,21 @@ namespace SymTab { - /// Generates assignment operators, constructors, and destructor for aggregate types as required - void autogenerateRoutines( std::list< Declaration * > &translationUnit ); + /// Generates assignment operators, constructors, and destructor for aggregate types as required + void autogenerateRoutines( std::list< Declaration * > &translationUnit ); - /// returns true if obj's name is the empty string and it has a bitfield width - bool isUnnamedBitfield( ObjectDecl * obj ); + /// returns true if obj's name is the empty string and it has a bitfield width + bool isUnnamedBitfield( ObjectDecl * obj ); - /// size_t type - set when size_t typedef is seen. Useful in a few places, - /// such as in determining array dimension type - extern Type * SizeType; + /// size_t type - set when size_t typedef is seen. Useful in a few places, + /// such as in determining array dimension type + extern Type * SizeType; - /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. - template< typename OutputIterator > + /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. + template< typename OutputIterator > Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true ); - /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types. - /// optionally returns a statement which must be inserted prior to the containing loop, if there is one - template< typename OutputIterator > + /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types. + /// optionally returns a statement which must be inserted prior to the containing loop, if there is one + template< typename OutputIterator > Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) { // want to be able to generate assignment, ctor, and dtor generically, @@ -50,16 +50,15 @@ dstParam = new AddressExpr( dstParam ); if ( addCast ) { - // cast to T* with qualifiers removed, so that qualified objects can be constructed - // and destructed with the same functions as non-qualified objects. - // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument - // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever - // remove lvalue as a qualifier, this can change to - // type->get_qualifiers() = Type::Qualifiers(); - assert( type ); - Type * castType = type->clone(); -// castType->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, false); - castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic ); - castType->set_lvalue( true ); // xxx - might not need this - dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) ); + // cast to T* with qualifiers removed, so that qualified objects can be constructed + // and destructed with the same functions as non-qualified objects. + // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument + // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever + // remove lvalue as a qualifier, this can change to + // type->get_qualifiers() = Type::Qualifiers(); + assert( type ); + Type * castType = type->clone(); + castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic ); + castType->set_lvalue( true ); // xxx - might not need this + dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) ); } fExpr->get_args().push_back( dstParam ); @@ -75,103 +74,103 @@ return listInit; - } - - /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments. - /// If forward is true, loop goes from 0 to N-1, else N-1 to 0 - template< typename OutputIterator > - void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) { - static UniqueName indexName( "_index" ); - - // for a flexible array member nothing is done -- user must define own assignment - if ( ! array->get_dimension() ) return ; - - Expression * begin, * end, * update, * cmp; - if ( forward ) { - // generate: for ( int i = 0; i < N; ++i ) - begin = new ConstantExpr( Constant::from_int( 0 ) ); - end = array->get_dimension()->clone(); - cmp = new NameExpr( "?= 0; --i ) - begin = new UntypedExpr( new NameExpr( "?-?" ) ); - ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() ); - ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) ); - end = new ConstantExpr( Constant::from_int( 0 ) ); - cmp = new NameExpr( "?>=?" ); - update = new NameExpr( "--?" ); } - ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list() ) ); + /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments. + /// If forward is true, loop goes from 0 to N-1, else N-1 to 0 + template< typename OutputIterator > + void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) { + static UniqueName indexName( "_index" ); - UntypedExpr *cond = new UntypedExpr( cmp ); - cond->get_args().push_back( new VariableExpr( index ) ); - cond->get_args().push_back( end ); + // for a flexible array member nothing is done -- user must define own assignment + if ( ! array->get_dimension() ) return ; - UntypedExpr *inc = new UntypedExpr( update ); - inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) ); + Expression * begin, * end, * update, * cmp; + if ( forward ) { + // generate: for ( int i = 0; i < N; ++i ) + begin = new ConstantExpr( Constant::from_int( 0 ) ); + end = array->get_dimension()->clone(); + cmp = new NameExpr( "?= 0; --i ) + begin = new UntypedExpr( new NameExpr( "?-?" ) ); + ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() ); + ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) ); + end = new ConstantExpr( Constant::from_int( 0 ) ); + cmp = new NameExpr( "?>=?" ); + update = new NameExpr( "--?" ); + } - UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) ); - dstIndex->get_args().push_back( dstParam ); - dstIndex->get_args().push_back( new VariableExpr( index ) ); - dstParam = dstIndex; + ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) ); - // srcParam must keep track of the array indices to build the - // source parameter and/or array list initializer - srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() ); + UntypedExpr *cond = new UntypedExpr( cmp ); + cond->get_args().push_back( new VariableExpr( index ) ); + cond->get_args().push_back( end ); - // for stmt's body, eventually containing call - CompoundStmt * body = new CompoundStmt( noLabels ); - Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward ); + UntypedExpr *inc = new UntypedExpr( update ); + inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) ); - // block containing for stmt and index variable - std::list initList; - CompoundStmt * block = new CompoundStmt( noLabels ); - block->get_kids().push_back( new DeclStmt( noLabels, index ) ); - if ( listInit ) block->get_kids().push_back( listInit ); - block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) ); + UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) ); + dstIndex->get_args().push_back( dstParam ); + dstIndex->get_args().push_back( new VariableExpr( index ) ); + dstParam = dstIndex; - *out++ = block; - } + // srcParam must keep track of the array indices to build the + // source parameter and/or array list initializer + srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() ); - template< typename OutputIterator > + // for stmt's body, eventually containing call + CompoundStmt * body = new CompoundStmt( noLabels ); + Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward ); + + // block containing for stmt and index variable + std::list initList; + CompoundStmt * block = new CompoundStmt( noLabels ); + block->get_kids().push_back( new DeclStmt( noLabels, index ) ); + if ( listInit ) block->get_kids().push_back( listInit ); + block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) ); + + *out++ = block; + } + + template< typename OutputIterator > Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) { - if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { - genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward ); - return 0; - } else { - return genScalarCall( srcParam, dstParam, fname, out, type, addCast ); + if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { + genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward ); + return 0; + } else { + return genScalarCall( srcParam, dstParam, fname, out, type, addCast ); + } } - } - /// inserts into out a generated call expression to function fname with arguments dstParam - /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the - /// object being constructed. The function wraps constructor and destructor calls in an - /// ImplicitCtorDtorStmt node. - template< typename OutputIterator > + /// inserts into out a generated call expression to function fname with arguments dstParam + /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the + /// object being constructed. The function wraps constructor and destructor calls in an + /// ImplicitCtorDtorStmt node. + template< typename OutputIterator > void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) { - ObjectDecl *obj = dynamic_cast( decl ); - assert( obj ); - // unnamed bit fields are not copied as they cannot be accessed - if ( isUnnamedBitfield( obj ) ) return; + ObjectDecl *obj = dynamic_cast( decl ); + assert( obj ); + // unnamed bit fields are not copied as they cannot be accessed + if ( isUnnamedBitfield( obj ) ) return; - bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) ); - std::list< Statement * > stmts; - genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward ); + bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) ); + std::list< Statement * > stmts; + genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward ); - // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call - assert( stmts.size() <= 1 ); - if ( stmts.size() == 1 ) { - Statement * callStmt = stmts.front(); - if ( addCast ) { - // implicitly generated ctor/dtor calls should be wrapped - // so that later passes are aware they were generated. - // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield, - // because this causes the address to be taken at codegen, which is illegal in C. - callStmt = new ImplicitCtorDtorStmt( callStmt ); - } - *out++ = callStmt; + // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call + assert( stmts.size() <= 1 ); + if ( stmts.size() == 1 ) { + Statement * callStmt = stmts.front(); + if ( addCast ) { + // implicitly generated ctor/dtor calls should be wrapped + // so that later passes are aware they were generated. + // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield, + // because this causes the address to be taken at codegen, which is illegal in C. + callStmt = new ImplicitCtorDtorStmt( callStmt ); + } + *out++ = callStmt; + } } - } } // namespace SymTab #endif // AUTOGEN_H Index: src/SymTab/ImplementationType.cc =================================================================== --- src/SymTab/ImplementationType.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SymTab/ImplementationType.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// ImplementationType.cc -- +// ImplementationType.cc -- // // Author : Richard C. Bilson @@ -92,11 +92,11 @@ void ImplementationType::visit(TupleType *tupleType) { - TupleType *newType = new TupleType( Type::Qualifiers() ); + std::list< Type * > types; for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) { Type *implType = implementationType( *i, indexer ); implType->get_qualifiers() |= tupleType->get_qualifiers(); - newType->get_types().push_back( implType ); + types.push_back( implType ); } // for - result = newType; + result = new TupleType( Type::Qualifiers(), types ); } Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SymTab/Indexer.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -652,5 +652,5 @@ for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) { // check for C decls with the same name, skipping those with a compatible type (by mangleName) - if ( decl->second->get_linkage() == LinkageSpec::C && decl->first != mangleName ) return true; + if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first != mangleName ) return true; } } @@ -669,5 +669,5 @@ // check for C decls with the same name, skipping // those with an incompatible type (by mangleName) - if ( decl->second->get_linkage() == LinkageSpec::C && decl->first == mangleName ) return true; + if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first == mangleName ) return true; } } @@ -724,5 +724,5 @@ // new definition shadows the autogenerated one, even at the same scope return false; - } else if ( added->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( added->get_type(), existing->get_type(), Indexer() ) ) { + } else if ( LinkageSpec::isMangled( added->get_linkage() ) || ResolvExpr::typesCompatible( added->get_type(), existing->get_type(), Indexer() ) ) { // typesCompatible doesn't really do the right thing here. When checking compatibility of function types, // we should ignore outermost pointer qualifiers, except _Atomic? @@ -765,5 +765,5 @@ // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage - if ( decl->get_linkage() == LinkageSpec::C ) { + if ( ! LinkageSpec::isMangled( decl->get_linkage() ) ) { // NOTE this is broken in Richard's original code in such a way that it never triggers (it // doesn't check decls that have the same manglename, and all C-linkage decls are defined to Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SymTab/Validate.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -106,6 +106,5 @@ /// Fix return types so that every function returns exactly one value - class ReturnTypeFixer { - public: + struct ReturnTypeFixer { static void fix( std::list< Declaration * > &translationUnit ); @@ -115,6 +114,5 @@ /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers. - class EnumAndPointerDecay { - public: + struct EnumAndPointerDecay { void previsit( EnumDecl *aggregateDecl ); void previsit( FunctionType *func ); @@ -159,10 +157,9 @@ }; - class ReturnChecker : public WithScopes { - public: + struct ReturnChecker : public WithGuards { /// Checks that return statements return nothing if their return type is void /// and return something if the return type is non-void. static void checkFunctionReturns( std::list< Declaration * > & translationUnit ); - private: + void previsit( FunctionDecl * functionDecl ); void previsit( ReturnStmt * returnStmt ); @@ -205,6 +202,5 @@ }; - class VerifyCtorDtorAssign { - public: + struct VerifyCtorDtorAssign { /// ensure that constructors, destructors, and assignment have at least one /// parameter, the first of which must be a pointer, and that ctor/dtors have no @@ -216,12 +212,10 @@ /// ensure that generic types have the correct number of type arguments - class ValidateGenericParameters { - public: + struct ValidateGenericParameters { void previsit( StructInstType * inst ); void previsit( UnionInstType * inst ); }; - class ArrayLength { - public: + struct ArrayLength { /// for array types without an explicit length, compute the length and store it so that it /// is known to the rest of the phases. For example, @@ -236,10 +230,9 @@ }; - class CompoundLiteral final : public GenPoly::DeclMutator { + struct CompoundLiteral final : public WithDeclsToAdd, public WithVisitorRef { Type::StorageClasses storageClasses; - using GenPoly::DeclMutator::mutate; - DeclarationWithType * mutate( ObjectDecl *objectDecl ) final; - Expression *mutate( CompoundLiteralExpr *compLitExpr ) final; + void premutate( ObjectDecl *objectDecl ); + Expression * postmutate( CompoundLiteralExpr *compLitExpr ); }; @@ -248,5 +241,5 @@ LinkReferenceToTypes lrt( doDebug, 0 ); ForallPointerDecay fpd( 0 ); - CompoundLiteral compoundliteral; + PassVisitor compoundliteral; PassVisitor genericParams; @@ -263,5 +256,5 @@ Concurrency::implementThreadStarter( translationUnit ); ReturnChecker::checkFunctionReturns( translationUnit ); - compoundliteral.mutateDeclarationList( translationUnit ); + mutateAll( translationUnit, compoundliteral ); acceptAll( translationUnit, fpd ); ArrayLength::computeLength( translationUnit ); @@ -883,22 +876,19 @@ } - DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) { + void CompoundLiteral::premutate( ObjectDecl *objectDecl ) { storageClasses = objectDecl->get_storageClasses(); - DeclarationWithType * temp = Mutator::mutate( objectDecl ); - return temp; - } - - Expression *CompoundLiteral::mutate( CompoundLiteralExpr *compLitExpr ) { + } + + Expression *CompoundLiteral::postmutate( CompoundLiteralExpr *compLitExpr ) { // transform [storage_class] ... (struct S){ 3, ... }; // into [storage_class] struct S temp = { 3, ... }; static UniqueName indexName( "_compLit" ); - ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_result(), compLitExpr->get_initializer() ); - compLitExpr->set_result( 0 ); - compLitExpr->set_initializer( 0 ); + ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() ); + compLitExpr->set_result( nullptr ); + compLitExpr->set_initializer( nullptr ); delete compLitExpr; - DeclarationWithType * newtempvar = mutate( tempvar ); - addDeclaration( newtempvar ); // add modified temporary to current block - return new VariableExpr( newtempvar ); + declsToAddBefore.push_back( tempvar ); // add modified temporary to current block + return new VariableExpr( tempvar ); } Index: src/SynTree/Constant.cc =================================================================== --- src/SynTree/Constant.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/Constant.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// Constant.cc -- +// Constant.cc -- // // Author : Richard C. Bilson @@ -46,4 +46,14 @@ } +unsigned long long Constant::get_ival() const { + assertf( safe_dynamic_cast(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." ); + return val.ival; +} + +double Constant::get_dval() const { + assertf( ! safe_dynamic_cast(type)->isInteger(), "Attempt to retrieve dval from integer constant." ); + return val.dval; +} + void Constant::print( std::ostream &os ) const { os << "(" << rep << " " << val.ival; Index: src/SynTree/Constant.h =================================================================== --- src/SynTree/Constant.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/Constant.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// Constant.h -- +// Constant.h -- // // Author : Richard C. Bilson @@ -32,4 +32,6 @@ std::string & get_value() { return rep; } void set_value( std::string newValue ) { rep = newValue; } + unsigned long long get_ival() const; + double get_dval() const; /// generates a boolean constant of the given bool Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/Expression.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -21,11 +21,15 @@ #include +#include "Declaration.h" +#include "Expression.h" +#include "Initializer.h" +#include "Statement.h" #include "Type.h" -#include "Initializer.h" -#include "Expression.h" -#include "Declaration.h" -#include "Statement.h" #include "TypeSubstitution.h" +#include "VarExprReplacer.h" + #include "Common/utility.h" +#include "Common/PassVisitor.h" + #include "InitTweak/InitTweak.h" @@ -92,5 +96,4 @@ Declaration *decl = get_var(); - // if ( decl != 0) decl->print(os, indent + 2); if ( decl != 0) decl->printShort(os, indent + 2); os << std::endl; @@ -657,4 +660,46 @@ } +InitAlternative::InitAlternative( Type * type, Designation * designation ) : type( type ), designation( designation ) {} +InitAlternative::InitAlternative( const InitAlternative & other ) : type( maybeClone( other.type ) ), designation( maybeClone( other.designation ) ) {} +InitAlternative::~InitAlternative() { + delete type; + delete designation; +} + +UntypedInitExpr::UntypedInitExpr( Expression * expr, const std::list & initAlts ) : expr( expr ), initAlts( initAlts ) {} +UntypedInitExpr::UntypedInitExpr( const UntypedInitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), initAlts( other.initAlts ) {} +UntypedInitExpr::~UntypedInitExpr() { + delete expr; +} + +void UntypedInitExpr::print( std::ostream & os, int indent ) const { + os << "Untyped Init Expression" << std::endl << std::string( indent+2, ' ' ); + expr->print( os, indent+2 ); + if ( ! initAlts.empty() ) { + for ( const InitAlternative & alt : initAlts ) { + os << std::string( indent+2, ' ' ) << "InitAlternative: "; + alt.type->print( os, indent+2 ); + alt.designation->print( os, indent+2 ); + } + } +} + +InitExpr::InitExpr( Expression * expr, Designation * designation ) : expr( expr ), designation( designation ) { + set_result( expr->get_result()->clone() ); +} +InitExpr::InitExpr( const InitExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), designation( maybeClone( other.designation) ) {} +InitExpr::~InitExpr() { + delete expr; + delete designation; +} + +void InitExpr::print( std::ostream & os, int indent ) const { + os << "Init Expression" << std::endl << std::string( indent+2, ' ' ); + expr->print( os, indent+2 ); + os << std::string( indent+2, ' ' ) << "with designation: "; + designation->print( os, indent+2 ); +} + + std::ostream & operator<<( std::ostream & out, const Expression * expr ) { if ( expr ) { Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/Expression.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -744,4 +744,56 @@ }; +struct InitAlternative { +public: + Type * type = nullptr; + Designation * designation = nullptr; + InitAlternative( Type * type, Designation * designation ); + InitAlternative( const InitAlternative & other ); + InitAlternative & operator=( const Initializer & other ) = delete; // at the moment this isn't used, and I don't want to implement it + ~InitAlternative(); +}; + +class UntypedInitExpr : public Expression { +public: + UntypedInitExpr( Expression * expr, const std::list & initAlts ); + UntypedInitExpr( const UntypedInitExpr & other ); + ~UntypedInitExpr(); + + Expression * get_expr() const { return expr; } + UntypedInitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; } + + std::list & get_initAlts() { return initAlts; } + + virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * this ); } + virtual void accept( Visitor & v ) { v.visit( this ); } + virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); } + virtual void print( std::ostream & os, int indent = 0 ) const; +private: + Expression * expr; + std::list initAlts; +}; + +class InitExpr : public Expression { +public: + InitExpr( Expression * expr, Designation * designation ); + InitExpr( const InitExpr & other ); + ~InitExpr(); + + Expression * get_expr() const { return expr; } + InitExpr * set_expr( Expression * newValue ) { expr = newValue; return this; } + + Designation * get_designation() const { return designation; } + InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; } + + virtual InitExpr * clone() const { return new InitExpr( * this ); } + virtual void accept( Visitor & v ) { v.visit( this ); } + virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); } + virtual void print( std::ostream & os, int indent = 0 ) const; +private: + Expression * expr; + Designation * designation; +}; + + std::ostream & operator<<( std::ostream & out, const Expression * expr ); Index: src/SynTree/Initializer.cc =================================================================== --- src/SynTree/Initializer.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/Initializer.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -19,75 +19,82 @@ #include "Common/utility.h" +Designation::Designation( const std::list< Expression * > & designators ) : designators( designators ) {} +Designation::Designation( const Designation & other ) : BaseSyntaxNode( other ) { + // std::cerr << "cloning designation" << std::endl; + cloneAll( other.designators, designators ); + // std::cerr << "finished cloning designation" << std::endl; +} + +Designation::~Designation() { + // std::cerr << "destroying designation" << std::endl; + deleteAll( designators ); + // std::cerr << "finished destroying designation" << std::endl; +} + +void Designation::print( std::ostream &os, int indent ) const { + if ( ! designators.empty() ) { + os << std::string(indent + 2, ' ' ) << "designated by: " << std::endl; + for ( std::list < Expression * >::const_iterator i = designators.begin(); i != designators.end(); i++ ) { + os << std::string(indent + 4, ' ' ); + ( *i )->print(os, indent + 4 ); + } + os << std::endl; + } // if +} + Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {} Initializer::Initializer( const Initializer & other ) : BaseSyntaxNode( other ), maybeConstructed( other.maybeConstructed ) { } - - Initializer::~Initializer() {} -std::string Initializer::designator_name( Expression *des ) { - if ( NameExpr *n = dynamic_cast(des) ) - return n->get_name(); - else - throw 0; -} - -// void Initializer::print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent ) {} - -SingleInit::SingleInit( Expression *v, const std::list< Expression *> &_designators, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ), designators( _designators ) { +SingleInit::SingleInit( Expression *v, bool maybeConstructed ) : Initializer( maybeConstructed ), value ( v ) { } SingleInit::SingleInit( const SingleInit &other ) : Initializer(other), value ( maybeClone( other.value ) ) { - cloneAll(other.designators, designators ); } SingleInit::~SingleInit() { delete value; - deleteAll(designators); } -void SingleInit::print( std::ostream &os, int indent ) { - os << std::endl << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl; +void SingleInit::print( std::ostream &os, int indent ) const { + os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl; os << std::string(indent+4, ' ' ); value->print( os, indent+4 ); - - if ( ! designators.empty() ) { - os << std::endl << std::string(indent + 2, ' ' ) << "designated by: " << std::endl; - for ( std::list < Expression * >::iterator i = designators.begin(); i != designators.end(); i++ ) { - os << std::string(indent + 4, ' ' ); - ( *i )->print(os, indent + 4 ); - } - } // if } -ListInit::ListInit( const std::list &_initializers, const std::list &_designators, bool maybeConstructed ) - : Initializer( maybeConstructed ), initializers( _initializers ), designators( _designators ) { + +ListInit::ListInit( const std::list &inits, const std::list &des, bool maybeConstructed ) + : Initializer( maybeConstructed ), initializers( inits ), designations( des ) { + // handle the common case where a ListInit is created without designations by making a list of empty designations with the same length as the initializer + if ( designations.empty() ) { + for ( auto & i : initializers ) { + (void)i; + designations.push_back( new Designation( {} ) ); + } + } + assertf( initializers.size() == designations.size(), "Created ListInit with mismatching initializers (%d) and designations (%d)", initializers.size(), designations.size() ); } ListInit::ListInit( const ListInit & other ) : Initializer( other ) { cloneAll( other.initializers, initializers ); - cloneAll( other.designators, designators ); + cloneAll( other.designations, designations ); } - ListInit::~ListInit() { deleteAll( initializers ); - deleteAll( designators ); + deleteAll( designations ); } -void ListInit::print( std::ostream &os, int indent ) { - os << std::endl << std::string(indent, ' ') << "Compound initializer: "; - if ( ! designators.empty() ) { - os << std::string(indent + 2, ' ' ) << "designated by: ["; - for ( std::list < Expression * >::iterator i = designators.begin(); - i != designators.end(); i++ ) { - ( *i )->print(os, indent + 4 ); - } // for +void ListInit::print( std::ostream &os, int indent ) const { + os << std::string(indent, ' ') << "Compound initializer: " << std::endl; + for ( Designation * d : designations ) { + d->print( os, indent + 2 ); + } - os << std::string(indent + 2, ' ' ) << "]"; - } // if - - for ( std::list::iterator i = initializers.begin(); i != initializers.end(); i++ ) - (*i)->print( os, indent + 2 ); + for ( const Initializer * init : initializers ) { + init->print( os, indent + 2 ); + os << std::endl; + } } @@ -103,5 +110,5 @@ } -void ConstructorInit::print( std::ostream &os, int indent ) { +void ConstructorInit::print( std::ostream &os, int indent ) const { os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl; if ( ctor ) { @@ -124,6 +131,19 @@ } -std::ostream & operator<<( std::ostream & out, Initializer * init ) { - init->print( out ); +std::ostream & operator<<( std::ostream & out, const Initializer * init ) { + if ( init ) { + init->print( out ); + } else { + out << "nullptr"; + } + return out; +} + +std::ostream & operator<<( std::ostream & out, const Designation * des ) { + if ( des ) { + des->print( out ); + } else { + out << "nullptr"; + } return out; } Index: src/SynTree/Initializer.h =================================================================== --- src/SynTree/Initializer.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/Initializer.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -25,26 +25,29 @@ #include "Visitor.h" -const std::list noDesignators; +// Designation: list of designator (NameExpr, VariableExpr, and ConstantExpr) expressions that specify an object being initialized. +class Designation : public BaseSyntaxNode { +public: + Designation( const std::list< Expression * > & designators ); + Designation( const Designation & other ); + virtual ~Designation(); + + std::list< Expression * > & get_designators() { return designators; } + + virtual Designation * clone() const { return new Designation( *this ); }; + virtual void accept( Visitor &v ) { v.visit( this ); } + virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); } + virtual void print( std::ostream &os, int indent = 0 ) const; +private: + std::list< Expression * > designators; +}; + +const std::list noDesignators; // Initializer: base class for object initializers (provide default values) class Initializer : public BaseSyntaxNode { public: - // Initializer( std::string _name = std::string(""), int _pos = 0 ); Initializer( bool maybeConstructed ); Initializer( const Initializer & other ); virtual ~Initializer(); - - static std::string designator_name( Expression *designator ); - - // void set_name( std::string newValue ) { name = newValue; } - // std::string get_name() const { return name; } - - // void set_pos( int newValue ) { pos = newValue; } - // int get_pos() const { return pos; } - virtual void set_designators( std::list & ) { assert(false); } - virtual std::list &get_designators() { - assert(false); - std::list *ret = 0; return *ret; // never reached - } bool get_maybeConstructed() { return maybeConstructed; } @@ -53,8 +56,6 @@ virtual void accept( Visitor &v ) = 0; virtual Initializer *acceptMutator( Mutator &m ) = 0; - virtual void print( std::ostream &os, int indent = 0 ) = 0; + virtual void print( std::ostream &os, int indent = 0 ) const = 0; private: - // std::string name; - // int pos; bool maybeConstructed; }; @@ -63,5 +64,5 @@ class SingleInit : public Initializer { public: - SingleInit( Expression *value, const std::list< Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false ); + SingleInit( Expression *value, bool maybeConstructed = false ); SingleInit( const SingleInit &other ); virtual ~SingleInit(); @@ -70,15 +71,11 @@ void set_value( Expression *newValue ) { value = newValue; } - std::list &get_designators() { return designators; } - void set_designators( std::list &newValue ) { designators = newValue; } - virtual SingleInit *clone() const { return new SingleInit( *this); } virtual void accept( Visitor &v ) { v.visit( this ); } virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os, int indent = 0 ); + virtual void print( std::ostream &os, int indent = 0 ) const; private: //Constant *value; Expression *value; // has to be a compile-time constant - std::list< Expression * > designators; }; @@ -88,24 +85,25 @@ public: ListInit( const std::list &initializers, - const std::list &designators = std::list< Expression * >(), bool maybeConstructed = false ); + const std::list &designators = {}, bool maybeConstructed = false ); ListInit( const ListInit & other ); virtual ~ListInit(); - void set_designators( std::list &newValue ) { designators = newValue; } - std::list &get_designators() { return designators; } - void set_initializers( std::list &newValue ) { initializers = newValue; } - std::list &get_initializers() { return initializers; } + std::list & get_designations() { return designations; } + std::list & get_initializers() { return initializers; } typedef std::list::iterator iterator; + typedef std::list::const_iterator const_iterator; iterator begin() { return initializers.begin(); } iterator end() { return initializers.end(); } + const_iterator begin() const { return initializers.begin(); } + const_iterator end() const { return initializers.end(); } virtual ListInit *clone() const { return new ListInit( *this ); } virtual void accept( Visitor &v ) { v.visit( this ); } virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os, int indent = 0 ); + virtual void print( std::ostream &os, int indent = 0 ) const; private: - std::list initializers; // order *is* important - std::list designators; + std::list initializers; // order *is* important + std::list designations; // order/length is consistent with initializers }; @@ -130,5 +128,5 @@ virtual void accept( Visitor &v ) { v.visit( this ); } virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); } - virtual void print( std::ostream &os, int indent = 0 ); + virtual void print( std::ostream &os, int indent = 0 ) const; private: @@ -140,5 +138,6 @@ }; -std::ostream & operator<<( std::ostream & out, Initializer * init ); +std::ostream & operator<<( std::ostream & out, const Initializer * init ); +std::ostream & operator<<( std::ostream & out, const Designation * des ); #endif // INITIALIZER_H Index: src/SynTree/Mutator.cc =================================================================== --- src/SynTree/Mutator.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/Mutator.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -433,4 +433,20 @@ } +Expression *Mutator::mutate( UntypedInitExpr * initExpr ) { + initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) ); + initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) ); + initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) ); + // not currently mutating initAlts, but this doesn't matter since this node is only used in the resolver. + return initExpr; +} + +Expression *Mutator::mutate( InitExpr * initExpr ) { + initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) ); + initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) ); + initExpr->set_expr( maybeMutate( initExpr->get_expr(), *this ) ); + initExpr->set_designation( maybeMutate( initExpr->get_designation(), *this ) ); + return initExpr; +} + Type *Mutator::mutate( VoidType *voidType ) { @@ -499,4 +515,5 @@ mutateAll( tupleType->get_forall(), *this ); mutateAll( tupleType->get_types(), *this ); + mutateAll( tupleType->get_members(), *this ); return tupleType; } @@ -535,4 +552,9 @@ +Designation *Mutator::mutate( Designation * designation ) { + mutateAll( designation->get_designators(), *this ); + return designation; +} + Initializer *Mutator::mutate( SingleInit *singleInit ) { singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) ); @@ -541,5 +563,5 @@ Initializer *Mutator::mutate( ListInit *listInit ) { - mutateAll( listInit->get_designators(), *this ); + mutateAll( listInit->get_designations(), *this ); mutateAll( listInit->get_initializers(), *this ); return listInit; Index: src/SynTree/Mutator.h =================================================================== --- src/SynTree/Mutator.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/Mutator.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -85,4 +85,6 @@ virtual Expression* mutate( StmtExpr * stmtExpr ); virtual Expression* mutate( UniqueExpr * uniqueExpr ); + virtual Expression* mutate( UntypedInitExpr * initExpr ); + virtual Expression* mutate( InitExpr * initExpr ); virtual Type* mutate( VoidType *basicType ); @@ -103,4 +105,5 @@ virtual Type* mutate( OneType *oneType ); + virtual Designation* mutate( Designation *designation ); virtual Initializer* mutate( SingleInit *singleInit ); virtual Initializer* mutate( ListInit *listInit ); Index: src/SynTree/SynTree.h =================================================================== --- src/SynTree/SynTree.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/SynTree.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -93,4 +93,6 @@ class StmtExpr; class UniqueExpr; +class UntypedInitExpr; +class InitExpr; class Type; @@ -113,4 +115,5 @@ class OneType; +class Designation; class Initializer; class SingleInit; Index: src/SynTree/TupleType.cc =================================================================== --- src/SynTree/TupleType.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/TupleType.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -14,16 +14,31 @@ // +#include "Declaration.h" +#include "Initializer.h" #include "Type.h" #include "Common/utility.h" +#include "Parser/LinkageSpec.h" TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), types( types ) { + for ( Type * t : *this ) { + // xxx - this is very awkward. TupleTypes should contain objects so that members can be named, but if they don't have an initializer node then + // they end up getting constructors, which end up being inserted causing problems. This happens because the object decls have to be visited so that + // their types are kept in sync with the types list here. Ultimately, the types list here should be eliminated and perhaps replaced with a list-view + // of the object types list, but I digress. The temporary solution here is to make a ListInit with maybeConstructed = false, that way even when the + // object is visited, it is never constructed. Ultimately, a better solution might be either: + // a) to separate TupleType from its declarations, into TupleDecl and Tuple{Inst?}Type, ala StructDecl and StructInstType + // b) separate initializer nodes better, e.g. add a MaybeConstructed node that is replaced by genInit, rather than what currently exists in a bool + members.push_back( new ObjectDecl( "" , Type::StorageClasses(), LinkageSpec::Cforall, nullptr, t->clone(), new ListInit( {}, {}, false ) ) ); + } } TupleType::TupleType( const TupleType& other ) : Type( other ) { cloneAll( other.types, types ); + cloneAll( other.members, members ); } TupleType::~TupleType() { deleteAll( types ); + deleteAll( members ); } Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/Type.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -481,5 +481,5 @@ class TupleType : public Type { public: - TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types = std::list< Type * >(), const std::list< Attribute * > & attributes = std::list< Attribute * >() ); + TupleType( const Type::Qualifiers & tq, const std::list< Type * > & types, const std::list< Attribute * > & attributes = std::list< Attribute * >() ); TupleType( const TupleType& ); virtual ~TupleType(); @@ -488,6 +488,10 @@ typedef value_type::iterator iterator; - std::list& get_types() { return types; } + std::list & get_types() { return types; } virtual unsigned size() const { return types.size(); }; + + // For now, this is entirely synthetic -- tuple types always have unnamed members. + // Eventually, we may allow named tuples, in which case members should subsume types + std::list & get_members() { return members; } iterator begin() { return types.begin(); } @@ -506,5 +510,6 @@ virtual void print( std::ostream & os, int indent = 0 ) const; private: - std::list types; + std::list types; + std::list members; }; Index: src/SynTree/VarExprReplacer.cc =================================================================== --- src/SynTree/VarExprReplacer.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/VarExprReplacer.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -14,14 +14,18 @@ // +#include "Declaration.h" #include "Expression.h" #include "VarExprReplacer.h" -VarExprReplacer::VarExprReplacer( const DeclMap & declMap ) : declMap( declMap ) {} +VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {} // replace variable with new node from decl map void VarExprReplacer::visit( VariableExpr * varExpr ) { - // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are) - if ( declMap.count( varExpr->get_var() ) ) { - varExpr->set_var( declMap.at( varExpr->get_var() ) ); - } + // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are) + if ( declMap.count( varExpr->get_var() ) ) { + if ( debug ) { + std::cerr << "replacing variable reference: " << (void*)varExpr->get_var() << " " << varExpr->get_var() << " with " << (void*)declMap.at( varExpr->get_var() ) << " " << declMap.at( varExpr->get_var() ) << std::endl; + } + varExpr->set_var( declMap.at( varExpr->get_var() ) ); + } } Index: src/SynTree/VarExprReplacer.h =================================================================== --- src/SynTree/VarExprReplacer.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/VarExprReplacer.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -27,6 +27,7 @@ private: const DeclMap & declMap; + bool debug; public: - VarExprReplacer( const DeclMap & declMap ); + VarExprReplacer( const DeclMap & declMap, bool debug = false ); // replace variable with new node from decl map Index: src/SynTree/Visitor.cc =================================================================== --- src/SynTree/Visitor.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/Visitor.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -340,4 +340,16 @@ } +void Visitor::visit( UntypedInitExpr * initExpr ) { + maybeAccept( initExpr->get_result(), *this ); + maybeAccept( initExpr->get_expr(), *this ); + // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver. +} + +void Visitor::visit( InitExpr * initExpr ) { + maybeAccept( initExpr->get_result(), *this ); + maybeAccept( initExpr->get_expr(), *this ); + maybeAccept( initExpr->get_designation(), *this ); +} + void Visitor::visit( VoidType *voidType ) { @@ -395,4 +407,5 @@ acceptAll( tupleType->get_forall(), *this ); acceptAll( tupleType->get_types(), *this ); + acceptAll( tupleType->get_members(), *this ); } @@ -424,4 +437,7 @@ } +void Visitor::visit( Designation * designation ) { + acceptAll( designation->get_designators(), *this ); +} void Visitor::visit( SingleInit *singleInit ) { @@ -430,5 +446,5 @@ void Visitor::visit( ListInit *listInit ) { - acceptAll( listInit->get_designators(), *this ); + acceptAll( listInit->get_designations(), *this ); acceptAll( listInit->get_initializers(), *this ); } Index: src/SynTree/Visitor.h =================================================================== --- src/SynTree/Visitor.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/SynTree/Visitor.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -88,4 +88,6 @@ virtual void visit( StmtExpr * stmtExpr ); virtual void visit( UniqueExpr * uniqueExpr ); + virtual void visit( UntypedInitExpr * initExpr ); + virtual void visit( InitExpr * initExpr ); virtual void visit( VoidType *basicType ); @@ -106,4 +108,5 @@ virtual void visit( OneType *oneType ); + virtual void visit( Designation *designation ); virtual void visit( SingleInit *singleInit ); virtual void visit( ListInit *listInit ); Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/Tuples/TupleExpansion.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -192,5 +192,5 @@ } ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), - new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ), noDesignators ) ); + new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) ); addDeclaration( finished ); // (finished ? _unq_expr_N : (_unq_expr_N = get_expr()>, finished = 1, _unq_expr_N)) @@ -310,20 +310,19 @@ Type * makeTupleType( const std::list< Expression * > & exprs ) { // produce the TupleType which aggregates the types of the exprs - TupleType *tupleType = new TupleType( Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ) ); - Type::Qualifiers &qualifiers = tupleType->get_qualifiers(); + std::list< Type * > types; + Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex ); for ( Expression * expr : exprs ) { assert( expr->get_result() ); if ( expr->get_result()->isVoid() ) { // if the type of any expr is void, the type of the entire tuple is void - delete tupleType; return new VoidType( Type::Qualifiers() ); } Type * type = expr->get_result()->clone(); - tupleType->get_types().push_back( type ); + types.push_back( type ); // the qualifiers on the tuple type are the qualifiers that exist on all component types qualifiers &= type->get_qualifiers(); } // for if ( exprs.empty() ) qualifiers = Type::Qualifiers(); - return tupleType; + return new TupleType( qualifiers, types ); } Index: src/libcfa/Makefile.am =================================================================== --- src/libcfa/Makefile.am (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/libcfa/Makefile.am (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -50,5 +50,5 @@ libobjs = ${headers:=.o} -libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} +libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} exception.c # not all platforms support concurrency, add option do disable it Index: src/libcfa/Makefile.in =================================================================== --- src/libcfa/Makefile.in (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/libcfa/Makefile.in (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -102,5 +102,5 @@ containers/pair.c containers/result.c containers/vector.c \ concurrency/coroutine.c concurrency/thread.c \ - concurrency/kernel.c concurrency/monitor.c \ + concurrency/kernel.c concurrency/monitor.c exception.c \ concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \ concurrency/invoke.c concurrency/preemption.c @@ -126,5 +126,5 @@ libcfa_d_a-interpose.$(OBJEXT) \ libhdr/libcfa_d_a-libdebug.$(OBJEXT) $(am__objects_2) \ - $(am__objects_3) + libcfa_d_a-exception.$(OBJEXT) $(am__objects_3) am_libcfa_d_a_OBJECTS = $(am__objects_4) libcfa_d_a_OBJECTS = $(am_libcfa_d_a_OBJECTS) @@ -136,5 +136,5 @@ containers/pair.c containers/result.c containers/vector.c \ concurrency/coroutine.c concurrency/thread.c \ - concurrency/kernel.c concurrency/monitor.c \ + concurrency/kernel.c concurrency/monitor.c exception.c \ concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \ concurrency/invoke.c concurrency/preemption.c @@ -158,5 +158,5 @@ libcfa_a-interpose.$(OBJEXT) \ libhdr/libcfa_a-libdebug.$(OBJEXT) $(am__objects_6) \ - $(am__objects_7) + libcfa_a-exception.$(OBJEXT) $(am__objects_7) am_libcfa_a_OBJECTS = $(am__objects_8) libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS) @@ -328,5 +328,5 @@ libobjs = ${headers:=.o} libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \ - $(am__append_4) + exception.c $(am__append_4) libcfa_a_SOURCES = ${libsrc} libcfa_a_CFLAGS = -nodebug -O2 @@ -514,4 +514,5 @@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-assert.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-exception.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-fstream.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-interpose.Po@am__quote@ @@ -524,4 +525,5 @@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-stdlib.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-assert.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-exception.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-fstream.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-interpose.Po@am__quote@ @@ -850,4 +852,11 @@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi` +libcfa_d_a-exception.obj: exception.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-exception.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-exception.Tpo -c -o libcfa_d_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-exception.Tpo $(DEPDIR)/libcfa_d_a-exception.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='exception.c' object='libcfa_d_a-exception.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi` + concurrency/libcfa_d_a-alarm.o: concurrency/alarm.c @am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-alarm.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo -c -o concurrency/libcfa_d_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c @@ -1143,4 +1152,11 @@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi` + +libcfa_a-exception.obj: exception.c +@am__fastdepCC_TRUE@ $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-exception.obj -MD -MP -MF $(DEPDIR)/libcfa_a-exception.Tpo -c -o libcfa_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-exception.Tpo $(DEPDIR)/libcfa_a-exception.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='exception.c' object='libcfa_a-exception.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi` concurrency/libcfa_a-alarm.o: concurrency/alarm.c Index: src/libcfa/exception.c =================================================================== --- src/libcfa/exception.c (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/libcfa/exception.c (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -44,16 +44,16 @@ // RESUMPTION ================================================================ -void __cfaehm__throw_resume(exception except) { - - // DEBUG - printf("Throwing resumption exception %d\n", except); - - struct __try_resume_node * original_head = shared_stack.current_resume; - struct __try_resume_node * current = +void __cfaehm__throw_resumption(exception * except) { + + // DEBUG + printf("Throwing resumption exception %d\n", *except); + + struct __cfaehm__try_resume_node * original_head = shared_stack.current_resume; + struct __cfaehm__try_resume_node * current = (original_head) ? original_head->next : shared_stack.top_resume; for ( ; current ; current = current->next) { shared_stack.current_resume = current; - if (current->try_to_handle(except)) { + if (current->handler(except)) { shared_stack.current_resume = original_head; return; @@ -61,9 +61,9 @@ } - printf("Unhandled exception %d\n", except); + printf("Unhandled exception %d\n", *except); shared_stack.current_resume = original_head; // Fall back to termination: - __cfaehm__throw_terminate(except); + __cfaehm__throw_termination(except); // TODO: Default handler for resumption. } @@ -73,12 +73,12 @@ * after the node is built but before it is made the top node. */ -void __try_resume_setup(struct __try_resume_node * node, - bool (*handler)(exception except)) { +void __cfaehm__try_resume_setup(struct __cfaehm__try_resume_node * node, + int (*handler)(exception * except)) { node->next = shared_stack.top_resume; - node->try_to_handle = handler; + node->handler = handler; shared_stack.top_resume = node; } -void __try_resume_cleanup(struct __try_resume_node * node) { +void __cfaehm__try_resume_cleanup(struct __cfaehm__try_resume_node * node) { shared_stack.top_resume = node->next; } @@ -111,10 +111,10 @@ } -void __cfaehm__throw_terminate( int val ) { +void __cfaehm__throw_termination( exception * val ) { // Store the current exception - shared_stack.current_exception = val; - - // DEBUG - printf("Throwing termination exception %d\n", val); + shared_stack.current_exception = *val; + + // DEBUG + printf("Throwing termination exception %d\n", *val); // Call stdlibc to raise the exception @@ -147,9 +147,9 @@ // Nesting this the other way would probably be faster. -void __cfaehm__rethrow_terminate(void) { +void __cfaehm__rethrow_termination(void) { // DEBUG printf("Rethrowing termination exception\n"); - __cfaehm__throw_terminate(shared_stack.current_exception); + __cfaehm__throw_termination(&shared_stack.current_exception); } @@ -322,7 +322,7 @@ // for details __attribute__((noinline)) -void __try_terminate(void (*try_block)(), - void (*catch_block)(int index, exception except), - __attribute__((unused)) int (*match_block)(exception except)) { +void __cfaehm__try_terminate(void (*try_block)(), + void (*catch_block)(int index, exception * except), + __attribute__((unused)) int (*match_block)(exception * except)) { //! volatile int xy = 0; //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy); @@ -364,5 +364,5 @@ // Exception handler catch_block(shared_stack.current_handler_index, - shared_stack.current_exception); + &shared_stack.current_exception); } @@ -384,11 +384,11 @@ // Body uses language specific data and therefore could be modified arbitrarily ".LLSDACSBCFA2:\n" // BODY start - " .uleb128 .TRYSTART-__try_terminate\n" // Handled area start (relative to start of function) + " .uleb128 .TRYSTART-__cfaehm__try_terminate\n" // Handled area start (relative to start of function) " .uleb128 .TRYEND-.TRYSTART\n" // Handled area length - " .uleb128 .CATCH-__try_terminate\n" // Hanlder landing pad adress (relative to start of function) + " .uleb128 .CATCH-__cfaehm__try_terminate\n" // Hanlder landing pad adress (relative to start of function) " .uleb128 1\n" // Action code, gcc seems to use always 0 ".LLSDACSECFA2:\n" // BODY end " .text\n" // TABLE footer - " .size __try_terminate, .-__try_terminate\n" + " .size __cfaehm__try_terminate, .-__cfaehm__try_terminate\n" " .ident \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n" // " .section .note.GNU-stack,\"x\",@progbits\n" Index: src/libcfa/exception.h =================================================================== --- src/libcfa/exception.h (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/libcfa/exception.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -38,13 +38,13 @@ // Data structure creates a list of resume handlers. struct __cfaehm__try_resume_node { - __cfaehm__try_resume_node * next; + struct __cfaehm__try_resume_node * next; int (*handler)(exception * except); }; void __cfaehm__try_resume_setup( - __cfaehm__try_resume_node * node, + struct __cfaehm__try_resume_node * node, int (*handler)(exception * except)); void __cfaehm__try_resume_cleanup( - __cfaehm__try_resume_node * node); + struct __cfaehm__try_resume_node * node); // Check for a standard way to call fake deconstructors. Index: src/libcfa/fstream =================================================================== --- src/libcfa/fstream (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/libcfa/fstream (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 15 18:11:09 2017 -// Update Count : 104 +// Last Modified On : Sat Jul 1 16:37:53 2017 +// Update Count : 112 // @@ -24,4 +24,5 @@ _Bool sepDefault; _Bool sepOnOff; + _Bool lastSepOn; const char * sepCur; char separator[separateSize]; @@ -35,4 +36,5 @@ const char * sepGetCur( ofstream * ); void sepSetCur( ofstream *, const char * ); +_Bool lastSepOn( ofstream * ); // public Index: src/libcfa/fstream.c =================================================================== --- src/libcfa/fstream.c (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/libcfa/fstream.c (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 15 18:11:11 2017 -// Update Count : 234 +// Last Modified On : Sat Jul 1 16:37:54 2017 +// Update Count : 242 // @@ -33,4 +33,5 @@ this->sepDefault = sepDefault; this->sepOnOff = sepOnOff; + this->lastSepOn = false; sepSet( this, separator ); sepSetCur( this, sepGet( this ) ); @@ -39,5 +40,6 @@ // private -_Bool sepPrt( ofstream * os ) { return os->sepOnOff; } +_Bool lastSepOn( ofstream * os ) { return os->lastSepOn; } +_Bool sepPrt( ofstream * os ) { os->lastSepOn = false; return os->sepOnOff; } void sepReset( ofstream * os ) { os->sepOnOff = os->sepDefault; } void sepReset( ofstream * os, _Bool reset ) { os->sepDefault = reset; os->sepOnOff = os->sepDefault; } @@ -46,10 +48,11 @@ // public -void sepOn( ofstream * os ) { os->sepOnOff = 1; } -void sepOff( ofstream * os ) { os->sepOnOff = 0; } +void sepOn( ofstream * os ) { os->lastSepOn = true; os->sepOnOff = true; } +void sepOff( ofstream * os ) { os->lastSepOn = false; os->sepOnOff = 0; } _Bool sepDisable( ofstream *os ) { _Bool temp = os->sepDefault; os->sepDefault = false; + os->lastSepOn = false; sepReset( os ); return temp; @@ -92,5 +95,5 @@ exit( EXIT_FAILURE ); } // if - ?{}( os, file, 1, 0, " ", ", " ); + ?{}( os, file, true, false, " ", ", " ); } // open @@ -132,7 +135,7 @@ } // fmt -static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), 1, 0, " ", ", " }; +static ofstream soutFile = { (FILE *)(&_IO_2_1_stdout_), true, false, " ", ", " }; ofstream *sout = &soutFile; -static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), 1, 0, " ", ", " }; +static ofstream serrFile = { (FILE *)(&_IO_2_1_stderr_), true, false, " ", ", " }; ofstream *serr = &serrFile; Index: src/libcfa/iostream =================================================================== --- src/libcfa/iostream (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/libcfa/iostream (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 15 18:08:44 2017 -// Update Count : 105 +// Last Modified On : Sun Jul 2 08:42:56 2017 +// Update Count : 110 // @@ -26,4 +26,5 @@ const char * sepGetCur( ostype * ); // get current separator string void sepSetCur( ostype *, const char * ); // set current separator string + _Bool lastSepOn( ostype * ); // last manipulator is setOn (context sensitive) // public void sepOn( ostype * ); // turn separator state on @@ -43,9 +44,9 @@ ostype * write( ostype *, const char *, unsigned long int ); int fmt( ostype *, const char fmt[], ... ); -}; +}; // ostream trait writeable( otype T ) { forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T ); -}; +}; // writeable // implement writable for intrinsic types @@ -103,9 +104,9 @@ istype * ungetc( istype *, char ); int fmt( istype *, const char fmt[], ... ); -}; +}; // istream trait readable( otype T ) { forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, T ); -}; +}; // readable forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, char * ); Index: src/libcfa/iostream.c =================================================================== --- src/libcfa/iostream.c (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/libcfa/iostream.c (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 8 18:24:23 2017 -// Update Count : 369 +// Last Modified On : Sun Jul 2 08:54:02 2017 +// Update Count : 375 // @@ -201,6 +201,6 @@ forall( dtype ostype, otype T, ttype Params | ostream( ostype ) | writeable( T ) | { ostype * ?|?( ostype *, Params ); } ) ostype * ?|?( ostype * os, T arg, Params rest ) { + os | arg; // print first argument sepSetCur( os, sepGetTuple( os ) ); // switch to tuple separator - os | arg; // print first argument os | rest; // print remaining arguments sepSetCur( os, sepGet( os ) ); // switch to regular separator @@ -217,4 +217,5 @@ forall( dtype ostype | ostream( ostype ) ) ostype * endl( ostype * os ) { + if ( lastSepOn( os ) ) fmt( os, "%s", sepGetCur( os ) ); os | '\n'; flush( os ); Index: src/libcfa/lsda.h =================================================================== --- src/libcfa/lsda.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) +++ src/libcfa/lsda.h (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -0,0 +1,262 @@ +//This code was stolen from gcc to read exception tables + + +/* If using C++, references to abort have to be qualified with std::. */ +#if __cplusplus +#define __gxx_abort std::abort +#else +#define __gxx_abort abort +#endif + +/* Pointer encodings, from dwarf2.h. */ +#define DW_EH_PE_absptr 0x00 +#define DW_EH_PE_omit 0xff + +#define DW_EH_PE_uleb128 0x01 +#define DW_EH_PE_udata2 0x02 +#define DW_EH_PE_udata4 0x03 +#define DW_EH_PE_udata8 0x04 +#define DW_EH_PE_sleb128 0x09 +#define DW_EH_PE_sdata2 0x0A +#define DW_EH_PE_sdata4 0x0B +#define DW_EH_PE_sdata8 0x0C +#define DW_EH_PE_signed 0x08 + +#define DW_EH_PE_pcrel 0x10 +#define DW_EH_PE_textrel 0x20 +#define DW_EH_PE_datarel 0x30 +#define DW_EH_PE_funcrel 0x40 +#define DW_EH_PE_aligned 0x50 + +#define DW_EH_PE_indirect 0x80 + + + +int handler_found = 0; + +/* Given an encoding, return the number of bytes the format occupies. +This is only defined for fixed-size encodings, and so does not +include leb128. */ +static unsigned int size_of_encoded_value (unsigned char encoding) __attribute__ ((unused)); + +static unsigned int size_of_encoded_value (unsigned char encoding) +{ + if (encoding == DW_EH_PE_omit) return 0; + + switch (encoding & 0x07) { + case DW_EH_PE_absptr: return sizeof (void *); + case DW_EH_PE_udata2: return 2; + case DW_EH_PE_udata4: return 4; + case DW_EH_PE_udata8: return 8; + } + __gxx_abort (); +} + +/* Given an encoding and an _Unwind_Context, return the base to which +the encoding is relative. This base may then be passed to +read_encoded_value_with_base for use when the _Unwind_Context is +not available. */ +static _Unwind_Ptr base_of_encoded_value (unsigned char encoding, struct _Unwind_Context *context) +{ + if (encoding == DW_EH_PE_omit) return 0; + + switch (encoding & 0x70) { + case DW_EH_PE_absptr: + case DW_EH_PE_pcrel: + case DW_EH_PE_aligned: + return 0; + case DW_EH_PE_textrel: + return _Unwind_GetTextRelBase (context); + case DW_EH_PE_datarel: + return _Unwind_GetDataRelBase (context); + case DW_EH_PE_funcrel: + return _Unwind_GetRegionStart (context); + } + __gxx_abort (); +} + +/* Read an unsigned leb128 value from P, store the value in VAL, return +P incremented past the value. We assume that a word is large enough to +hold any value so encoded; if it is smaller than a pointer on some target, +pointers should not be leb128 encoded on that target. */ +static const unsigned char * read_uleb128 (const unsigned char *p, _uleb128_t *val) +{ + unsigned int shift = 0; + unsigned char byte; + _uleb128_t result; + + result = 0; + do + { + byte = *p++; + result |= ((_uleb128_t)byte & 0x7f) << shift; + shift += 7; + } + while (byte & 0x80); + + *val = result; + return p; +} + +/* Similar, but read a signed leb128 value. */ +static const unsigned char * read_sleb128 (const unsigned char *p, _sleb128_t *val) +{ + unsigned int shift = 0; + unsigned char byte; + _uleb128_t result; + + result = 0; + do + { + byte = *p++; + result |= ((_uleb128_t)byte & 0x7f) << shift; + shift += 7; + } + while (byte & 0x80); + + /* Sign-extend a negative value. */ + if (shift < 8 * sizeof(result) && (byte & 0x40) != 0) result |= -(((_uleb128_t)1L) << shift); + + *val = (_sleb128_t) result; + return p; +} + +/* Load an encoded value from memory at P. The value is returned in VAL; +The function returns P incremented past the value. BASE is as given +by base_of_encoded_value for this encoding in the appropriate context. */ + +static const unsigned char * read_encoded_value_with_base (unsigned char encoding, _Unwind_Ptr base, const unsigned char *p, _Unwind_Ptr *val) +{ + union unaligned + { + void *ptr; + unsigned u2 __attribute__ ((mode (HI))); + unsigned u4 __attribute__ ((mode (SI))); + unsigned u8 __attribute__ ((mode (DI))); + signed s2 __attribute__ ((mode (HI))); + signed s4 __attribute__ ((mode (SI))); + signed s8 __attribute__ ((mode (DI))); + } __attribute__((__packed__)); + + const union unaligned *u = (const union unaligned *) p; + _Unwind_Internal_Ptr result; + + if (encoding == DW_EH_PE_aligned) + { + _Unwind_Internal_Ptr a = (_Unwind_Internal_Ptr) p; + a = (a + sizeof (void *) - 1) & - sizeof(void *); + result = *(_Unwind_Internal_Ptr *) a; + p = (const unsigned char *) (_Unwind_Internal_Ptr) (a + sizeof (void *)); + } + else + { + switch (encoding & 0x0f) + { + case DW_EH_PE_absptr: + result = (_Unwind_Internal_Ptr) u->ptr; + p += sizeof (void *); + break; + case DW_EH_PE_uleb128: + { + _uleb128_t tmp; + p = read_uleb128 (p, &tmp); + result = (_Unwind_Internal_Ptr) tmp; + } + break; + + case DW_EH_PE_sleb128: + { + _sleb128_t tmp; + p = read_sleb128 (p, &tmp); + result = (_Unwind_Internal_Ptr) tmp; + } + break; + + case DW_EH_PE_udata2: + result = u->u2; + p += 2; + break; + case DW_EH_PE_udata4: + result = u->u4; + p += 4; + break; + case DW_EH_PE_udata8: + result = u->u8; + p += 8; + break; + case DW_EH_PE_sdata2: + result = u->s2; + p += 2; + break; + case DW_EH_PE_sdata4: + result = u->s4; + p += 4; + break; + case DW_EH_PE_sdata8: + result = u->s8; + p += 8; + break; + default: + __gxx_abort(); + } + + if (result != 0) + { + result += ((encoding & 0x70) == DW_EH_PE_pcrel ? (_Unwind_Internal_Ptr) u : base); + + if (encoding & DW_EH_PE_indirect) result = *(_Unwind_Internal_Ptr *) result; + } + } + + *val = result; + return p; +} + +/* Like read_encoded_value_with_base, but get the base from the context +rather than providing it directly. */ +static inline const unsigned char * read_encoded_value (struct _Unwind_Context *context, unsigned char encoding, const unsigned char *p, _Unwind_Ptr *val) +{ + return read_encoded_value_with_base (encoding, base_of_encoded_value (encoding, context), p, val); +} + +typedef struct +{ + _Unwind_Ptr Start; + _Unwind_Ptr LPStart; + _Unwind_Ptr ttype_base; + const unsigned char *TType; + const unsigned char *action_table; + unsigned char ttype_encoding; + unsigned char call_site_encoding; +} lsda_header_info; + +static const unsigned char * parse_lsda_header (struct _Unwind_Context *context, const unsigned char *p, lsda_header_info *info) +{ + _uleb128_t tmp; + unsigned char lpstart_encoding; + + info->Start = (context ? _Unwind_GetRegionStart (context) : 0); + + /* Find @LPStart, the base to which landing pad offsets are relative. */ + lpstart_encoding = *p++; + if (lpstart_encoding != DW_EH_PE_omit) p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart); + + else info->LPStart = info->Start; + + /* Find @TType, the base of the handler and exception spec type data. */ + info->ttype_encoding = *p++; + if (info->ttype_encoding != DW_EH_PE_omit) + { + p = read_uleb128 (p, &tmp); + info->TType = p + tmp; + } + else info->TType = 0; + + /* The encoding and length of the call-site table; the action table + immediately follows. */ + info->call_site_encoding = *p++; + p = read_uleb128 (p, &tmp); + info->action_table = p + tmp; + + return p; +} Index: src/main.cc =================================================================== --- src/main.cc (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/main.cc (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -11,6 +11,6 @@ // Created On : Fri May 15 23:12:02 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Jun 28 21:56:47 2017 -// Update Count : 440 +// Last Modified On : Thu Jun 29 12:46:50 2017 +// Update Count : 441 // @@ -39,4 +39,5 @@ #include "CodeTools/TrackLoc.h" #include "ControlStruct/Mutate.h" +#include "ControlStruct/ExceptTranslate.h" #include "SymTab/Validate.h" #include "ResolvExpr/AlternativePrinter.h" @@ -290,4 +291,7 @@ Tuples::expandUniqueExpr( translationUnit ); + OPTPRINT( "translateEHM" ); + ControlStruct::translateEHM( translationUnit ); + OPTPRINT( "convertSpecializations" ) // needs to happen before tuple types are expanded GenPoly::convertSpecializations( translationUnit ); @@ -481,5 +485,9 @@ break; case '?': - assertf( false, "Unknown option: '%c'\n", (char)optopt ); + if ( optopt ) { // short option ? + assertf( false, "Unknown option: -%c\n", (char)optopt ); + } else { + assertf( false, "Unknown option: %s\n", argv[optind - 1] ); + } // if default: abort(); Index: src/prelude/Makefile.am =================================================================== --- src/prelude/Makefile.am (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/prelude/Makefile.am (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -23,4 +23,6 @@ noinst_DATA = ../libcfa/libcfa-prelude.c +CC = ${abs_top_srcdir}/src/driver/cfa + $(DEPDIR) : mkdir $(DEPDIR) @@ -45,6 +47,6 @@ # create forward declarations for cfa builtins -builtins.cf : builtins.c - ${AM_V_GEN}@BACKEND_CC@ -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po +builtins.cf : builtins.c ${CC} + ${AM_V_GEN}${CC} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po Index: src/prelude/Makefile.in =================================================================== --- src/prelude/Makefile.in (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/prelude/Makefile.in (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -95,5 +95,5 @@ AWK = @AWK@ BACKEND_CC = @BACKEND_CC@ -CC = @CC@ +CC = ${abs_top_srcdir}/src/driver/cfa CCAS = @CCAS@ CCASDEPMODE = @CCASDEPMODE@ @@ -444,6 +444,6 @@ # create forward declarations for cfa builtins -builtins.cf : builtins.c - ${AM_V_GEN}@BACKEND_CC@ -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po +builtins.cf : builtins.c ${CC} + ${AM_V_GEN}${CC} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po Index: src/tests/.expect/designations.txt =================================================================== --- src/tests/.expect/designations.txt (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) +++ src/tests/.expect/designations.txt (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -0,0 +1,53 @@ +=====A===== +(A){ 2 3 (nil) } +(A){ 2 3 (nil) } +(A){ 0 3 (nil) } +=====A===== + +=====B===== +(B){ + (A){ 5 0 (nil) } + (A){ 0 0 (nil) } +} +(B){ + (A){ 5 2 (nil) } + (A){ 6 0 (nil) } +} +(B){ + (A){ 1 0 (nil) } + (A){ 2 3 (nil) } +} +(B){ + (A){ 1 2 (nil) } + (A){ 4 5 (nil) } +} +(B){ + (A){ 1 0 (nil) } + (A){ 2 3 (nil) } +} +(B){ + (A){ 1 0 (nil) } + (A){ 2 3 (nil) } +} +=====B===== + +=====C===== +(C){ + (int[]{ 2 3 4 } + (B){ + (A){ 5 6 (nil) } + (A){ 7 8 (nil) } + } +} +=====C===== + +=====E===== +(A){ 2 3 (nil) } +(A){ 2 3 (nil) } +(A){ 2 3 (nil) } +(B){ + (A){ 2 3 (nil) } + (A){ 5 6 (nil) } +} +=====E===== + Index: src/tests/.expect/io.txt =================================================================== --- src/tests/.expect/io.txt (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/tests/.expect/io.txt (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -4,6 +4,11 @@ 123 +opening delimiters x (1 x [2 x {3 x =4 x $5 x £6 x ¥7 x ¡8 x ¿9 x «10 -1, x 2. x 3; x 4! x 5? x 6% x 7¢ x 8» x 9) x 10] x 11} x + +closing delimiters +1, x 2. x 3; x 4! x 5? x 6% x 7¢ x 8» x 9) x 10] x 11} x + +opening/closing delimiters x`1`x'2'x"3"x:4:x 5 x 6 x 7 @@ -14,6 +19,12 @@ x 10 -x +x + +override opening/closing delimiters x ( 1 ) x 2 , x 3 :x: 4 + +input bacis types + +output basic types A 1 2 3 4 5 6 7 8 @@ -21,27 +32,47 @@ 1.1+2.3i 1.1-2.3i 1.1-2.3i +tuples +1, 2, 3 3, 4, 5 + +toggle separator 1.11.21.3 1.1+2.3i1.1-2.3i1.1-2.3i - abcxyz -abcxyz + abcxyz +abcxyz +change separator +from " "to " , $" 1.1, $1.2, $1.3 1.1+2.3i, $1.1-2.3i, $1.1-2.3i -abc, $xyz +abc, $xyz, $ +1, 2, 3, $3, 4, 5 -1, 2, 3, 4 -1, $2, $3 ", $" -1 2 3 " " +from ", $"to " " +1.1 1.2 1.3 +1.1+2.3i 1.1-2.3i 1.1-2.3i +abc xyz +1, 2, 3 3, 4, 5 + + 1 2 3 +12 3 1 2 3 -12 3 +1 2 3 + 1 2 3 + 123 1 23 1 2 3 -1 2 3 4 " " -1, 2, 3, 4 ", " -1, 2, 3, 4 +123 +1 2 3 +123 +1 2 3 + +1 2 3 3 4 5 " " +1, 2, 3 3, 4, 5 ", " +1, 2, 3 3, 4, 5 + 3, 4, a, 7.2 3, 4, a, 7.2 3 4 a 7.2 3 4 a 7.234a7.23 4 a 7.2 -3-4-a-7.2^3^4-3-4-a-7.2 +3-4-a-7.2^3^4^3-4-a-7.2 Index: src/tests/designations.c =================================================================== --- src/tests/designations.c (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) +++ src/tests/designations.c (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -0,0 +1,246 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// designations.c -- +// +// Author : Rob Schluntz +// Created On : Thu Jun 29 15:26:36 2017 +// Last Modified By : Rob Schluntz +// Last Modified On : Thu Jun 29 15:27:05 2017 +// Update Count : 2 +// + +// Note: this test case has been crafted so that it compiles with both cfa and with gcc without any modifications. +// In particular, since the syntax for designations in Cforall differs from that of C, preprocessor substitution +// is used for the designation syntax +#ifdef __CFORALL__ +#define DES : +#else +int printf(const char *, ...); +#define DES = +#endif + +const int indentAmt = 2; +void indent(int level) { + for (int i = 0; i < level; ++i) { + printf(" "); + } +} + +// A contains fields with different types (int vs. int *) +struct A { + int x, y; + int * ptr; +}; +void printA(struct A a, int level) { + indent(level); + printf("(A){ %d %d %p }\n", a.x, a.y, a.ptr); +} + +// B contains struct members +struct B { + struct A a0, a1; +}; +void printB(struct B b, int level) { + indent(level); + printf("(B){\n"); + printA(b.a0, level+indentAmt); + printA(b.a1, level+indentAmt); + indent(level); + printf("}\n"); +} + +// C contains an array - tests that after 3 ints, the members of B are initialized. +struct C { + int arr[3]; + struct B b; +}; +void printC(struct C c, int level) { + indent(level); + printf("(C){\n"); + indent(level+indentAmt); + printf("(int[]{ %d %d %d }\n", c.arr[0], c.arr[1], c.arr[2]); + printB(c.b, level+indentAmt); + indent(level); + printf("}\n"); +} + +// D contains an unnamed aggregate - tests that this doesn't interfere with initialization. +struct D { + struct { + int x; + }; +}; +void printD(struct D d, int level) { + indent(level); + printf("(D){ %d }\n", d.x); +} + +// E tests unions +union E { + struct A a; + struct B b; + struct C c; + struct D d; + int i; +}; + +int main() { + // simple designation case - starting from beginning of structure, leaves ptr default-initialized (zero) + struct A y0 = { + .x DES 2, + .y DES 3 + }; + + // simple initializaiton case - initialize all elements explicitly with no designations + struct A y1 = { + 2, 3, 0 + }; + + + // use designation to move to member y, leaving x default-initialized (zero) + struct A y2 = { + .y DES 3, + 0 + }; + +#if ERROR + struct A yErr0 = { + {} // error - empty scalar initializer is illegal + }; +#endif + + printf("=====A=====\n"); + printA(y0, 0); + printA(y1, 0); + printA(y2, 0); + printf("=====A=====\n\n"); + + // initialize only first element (z0.a.x), leaving everything else default-initialized (zero), no nested curly-braces + struct B z0 = { 5 }; + + // some nested curly braces, use designation to 'jump around' within structure, leaving some members default-initialized + struct B z1 = { + { 3 }, // z1.a0 + { 4 }, // z1.a1 + .a0 DES { 5 }, // z1.a0 + { 6 }, // z1.a1 + .a0.y DES 2, // z1.a0.y + 0, // z1.a0.ptr + }; + + // z2.a0.y and z2.a0.ptr default-initialized, everything else explicit + struct B z2 = { + { 1 }, + { 2, 3, 0 } + }; + + // initialize every member, omitting nested curly braces + struct B z3 = { + 1, 2, 0, 4, 5, 0 + }; + + // no initializer - legal C, but garbage values - don't print this one + struct B z4; + + // no curly braces - initialize with object of same type + struct B z5 = z2; + + // z6.a0.y and z6.a0.ptr default-initialized, everything else explicit. + // no curly braces on z6.a1 initializers + struct B z6 = { + { 1 }, + 2, 3, 0 + }; + + printf("=====B=====\n"); + printB(z0, 0); + printB(z1, 0); + printB(z2, 0); + printB(z3, 0); + printB(z5, 0); + printB(z6, 0); + printf("=====B=====\n\n"); + + // TODO: what about extra things in a nested init? are empty structs skipped?? + + // test that initializing 'past array bound' correctly moves to next member. + struct C c1 = { + 2, 3, 4, // arr + 5, 6, 0, // b.a0 + 7, 8, 0, // b.a1 + }; + + printf("=====C=====\n"); + printC(c1, 0); + printf("=====C=====\n\n"); + +#if ERROR + // nested initializer can't refer to same type in C + struct C cErr0 = { c1 }; + + // must use curly braces to initialize members + struct C cErr1 = 2; + + // can't initialize with array compound literal + struct C cErr2 = { + (int[3]) { 1, 2, 3 } // error: array initialized from non-constant array expression + }; +#endif + +#if WARNING + // can't initialize array with array - converts to int* + int cWarn0_arr[3] = { 1, 2, 3 }; + struct C cWarn0 = { + cWarn0_arr // warning: initialization makes integer from ptr without cast + }; +#endif + + // allowed to have 'too many' initialized lists - essentially they are ignored. + int i1 = { 3 }; + + // doesn't work yet. + // designate unnamed object's members + // struct D d = { .x DES 3 }; +#if ERROR + struct D d1 = { .y DES 3 }; +#endif + + // simple union initialization - initialized first member (e0.a) + union E e0 = { + y0 + }; + + // simple union initialization - initializes first member (e1.a) - with nested initializer list + union E e1 = { + { 2, 3, 0 } + }; + + // simple union initialization - initializes first member (e2.a) - without nested initializer list + union E e2 = { + 2, 3, 0 + }; + + // move cursor to e4.b.a0.x and initialize until e3.b.a1.ptr inclusive + union E e3 = { + .b.a0.x DES 2, 3, 0, 5, 6, 0 + }; + + printf("=====E=====\n"); + printA(e0.a, 0); + printA(e1.a, 0); + printA(e2.a, 0); + printB(e3.b, 0); + printf("=====E=====\n\n"); + + // special case of initialization: char[] can be initialized with a string literal + const char * str0 = "hello"; + char str1[] = "hello"; +} + +// Local Variables: // +// tab-width: 4 // +// End: // Index: src/tests/except-0.c =================================================================== --- src/tests/except-0.c (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) +++ src/tests/except-0.c (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -0,0 +1,219 @@ +// Draft of tests for exception handling. + +#include +#include + +struct signal_exit { + const char * area; +}; + +void ?{}(signal_exit * this, const char * area) { + this->area = area; +} + +void ^?{}(signal_exit * this) { + printf("Exiting: %s\n", this->area); +// sout | "Exiting:" | this->area | endl; +} + +void terminate(int except_value) { + signal_exit a = {"terminate function"}; + throw except_value; + printf("terminate returned\n"); +} + +void resume(int except_value) { + signal_exit a = {"resume function"}; + throwResume except_value; + printf("resume returned\n"); +} + +// Termination Test: Two handlers: no catch, catch +void bar() { + signal_exit a = {"bar function"}; + try { + terminate(4); + } catch (3) { + printf("bar caught exception 3.\n"); + } +} + +void foo() { + signal_exit a = {"foo function"}; + try { + bar(); + } catch (4) { + printf("foo caught exception 4.\n"); + } catch (2) { + printf("foo caught exception 2.\n"); + } +} + +// Resumption Two Handler Test: no catch, catch. +void beta() { + signal_exit a = {"beta function"}; + try { + resume(4); + } catchResume (3) { + printf("beta caught exception 3\n"); + } +} + +void alpha() { + signal_exit a = {"alpha function"}; + try { + beta(); + } catchResume (2) { + printf("alpha caught exception 2\n"); + } catchResume (4) { + printf("alpha caught exception 4\n"); + } +} + +// Finally Test: +void farewell(bool jump) { + try { + if (jump) { + printf("jump out of farewell\n"); + goto endoffunction; + } else { + printf("walk out of farewell\n"); + } + } finally { + printf("See you next time\n"); + } + endoffunction: + printf("leaving farewell\n"); +} + +// Resume-to-Terminate Test: +void fallback() { + try { + resume(2); + } catch (2) { + printf("fallback caught termination 2\n"); + } +} + +// Terminate Throw New Exception: +void terminate_swap() { + signal_exit a = {"terminate_swap"}; + try { + terminate(2); + } catch (2) { + terminate(3); + } +} + +void terminate_swapped() { + signal_exit a = {"terminate_swapped"}; + try { + terminate_swap(); + } catch (3) { + printf("terminate_swapped caught exception 3\n"); + } +} + +// Resume Throw New Exception: +void resume_swap() { + signal_exit a = {"terminate_swap"}; + try { + resume(2); + } catchResume (2) { + resume(3); + } +} + +void resume_swapped() { + try { + resume_swap(); + } catchResume (3) { + printf("resume_swapped caught exception 3\n"); + } +} + +// Terminate Rethrow: +void reterminate() { + try { + try { + terminate(2); + } catch (2) { + printf("reterminate 2 caught and " + "will rethrow exception 2\n"); + throw; + } + } catch (2) { + printf("reterminate 1 caught exception 2\n"); + } +} + +// Resume Rethrow: +void reresume() { + try { + try { + resume(2); + } catchResume (2) { + printf("reresume 2 caught and rethrows exception 2\n"); + throwResume; + } + } catchResume (2) { + printf("reresume 1 caught exception 2\n"); + } +} + +// Terminate-Resume interaction: +void fum() { + // terminate block, call resume + try { + resume(3); + } catch (3) { + printf("fum caught exception 3\n"); + } +} + +void foe() { + // resume block, call terminate + try { + terminate(3); + } catchResume (3) { + printf("foe caught exception 3\n"); + } +} + +void fy() { + // terminate block calls fum, call foe + try { + foe(); + } catch (3) { + printf("fy caught exception 3\n"); + fum(); + } +} + +void fee() { + // resume block, call fy + try { + fy(); + } catchResume (3) { + printf("fee caught exception 3\n"); + } +} + + +// main: choose which tests to run +int main(int argc, char * argv[]) { + signal_exit a = {"main function"}; + + foo(); printf("\n"); + alpha(); printf("\n"); + farewell(false); printf("\n"); + farewell(true); printf("\n"); + fallback(); printf("\n"); + terminate_swapped(); printf("\n"); + resume_swapped(); printf("\n"); + reterminate(); printf("\n"); + reresume(); printf("\n"); + fee(); printf("\n"); + // Uncaught termination test. + terminate(7); +} Index: src/tests/exception.c =================================================================== --- src/tests/exception.c (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ (revision ) @@ -1,31 +1,0 @@ -//Testing esceptions syntax -int fred() { - int x; - throw 3; - throw x = 5; - - try { - } catch( int i ) {} - - try { - x/4; - } catch( int ) { - } catch( float x ) { - } catch( struct { int i; } ) { - } catch( struct { int i; } x ) { - } catch( struct { int i; } *x ) { - -// Cforall extensions - - } catch( * struct { int i; } ) { - } catch( * struct { int i; } x ) { - } catch( ... ) { - } finally { - } // try -} - -//Dummy main -int main(int argc, char const *argv[]) -{ - return 0; -} Index: src/tests/io.c =================================================================== --- src/tests/io.c (revision 11dbfe1a3caa7b8b2ac60e61a9bee57433ea08bf) +++ src/tests/io.c (revision 67fa9f99aebe68e73094bddc3ebf1c0d1c2d7844) @@ -10,6 +10,6 @@ // Created On : Wed Mar 2 16:56:02 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Jun 8 09:52:10 2017 -// Update Count : 51 +// Last Modified On : Sun Jul 2 09:40:58 2017 +// Update Count : 68 // @@ -42,6 +42,6 @@ sout | endl; + sout | "opening delimiters" | endl; sout - // opening delimiters | "x (" | 1 | "x [" | 2 @@ -54,7 +54,8 @@ | "x ¿" | 9 | "x «" | 10 - | endl; + | endl | endl; + + sout | "closing delimiters" | endl; sout - // closing delimiters | 1 | ", x" | 2 | ". x" @@ -68,7 +69,8 @@ | 10 | "] x" | 11 | "} x" - | endl; + | endl | endl; + + sout | "opening/closing delimiters" | endl; sout - // opening-closing delimiters | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 @@ -76,11 +78,15 @@ | "\tx\f" | 7 | "\fx\v" | 8 | "\vx\n" | 9 | "\nx\r" | 10 - | "\rx" | - endl; + | "\rx" + | endl | endl; + + sout | "override opening/closing delimiters" | endl; sout | "x ( " | 1 | " ) x" | 2 | " , x" | 3 | " :x: " | 4 | endl; + sout | endl; ifstream in; // create / open file open( &in, "io.data", "r" ); + sout | "input bacis types" | endl; &in | &c // character | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli // integral @@ -88,5 +94,7 @@ | &fc | &dc | &ldc // floating-point complex | cstr( s1 ) | cstr( s2, size ); // C string, length unchecked and checked + sout | endl; + sout | "output basic types" | endl; sout | c | ' ' | endl // character | si | usi | i | ui | li | uli | lli | ulli | endl // integral @@ -94,4 +102,11 @@ | fc | dc | ldc | endl; // complex sout | endl; + + sout | "tuples" | endl; + [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 3, [ 4, 5 ] ]; + sout | t1 | t2 | endl; // print tuple + sout | endl; + + sout | "toggle separator" | endl; sout | f | "" | d | "" | ld | endl // floating point without separator | sepDisable | fc | dc | ldc | sepEnable | endl // complex without separator @@ -100,25 +115,37 @@ sout | endl; + sout | "change separator" | endl; + sout | "from \" " | sepGet( sout ) | "\""; sepSet( sout, ", $" ); // change separator, maximum of 15 characters + sout | "to \" " | sepGet( sout ) | "\"" | endl; sout | f | d | ld | endl | fc | dc | ldc | endl - | s1 | s2 | endl; + | s1 | s2 | endl + | t1 | t2 | endl; // print tuple + sout | endl; + sout | "from \"" | sepGet( sout ) | "\""; + sepSet( sout, " " ); // restore separator + sout | "to \"" | sepGet( sout ) | "\"" | endl; + sout | f | d | ld | endl + | fc | dc | ldc | endl + | s1 | s2 | endl + | t1 | t2 | endl; // print tuple sout | endl; - [int, int] t1 = [1, 2], t2 = [3, 4]; - sout | t1 | t2 | endl; // print tuple - - sepSet( sout, " " ); - sepSet( sout, ", $" ); // set separator from " " to ", $" - sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl; - sepSet( sout, " " ); // reset separator to " " - sout | 1 | 2 | 3 | " \"" | sepGet( sout ) | "\"" | endl; - - sout | sepOn | 1 | 2 | 3 | sepOn | endl; // separator at start of line + sout | sepOn | 1 | 2 | 3 | sepOn | endl; // separator at start/end of line sout | 1 | sepOff | 2 | 3 | endl; // locally turn off implicit separator + sout | sepOn | 1 | 2 | 3 | sepOn | sepOff | endl; // separator at start of line + sout | 1 | 2 | 3 | endl | sepOn; // separator at start of next line + sout | 1 | 2 | 3 | endl; + sout | endl; sout | sepDisable | 1 | 2 | 3 | endl; // globally turn off implicit separation sout | 1 | sepOn | 2 | 3 | endl; // locally turn on implicit separator - sout | sepEnable | 1 | 2 | 3 | endl; // globally turn on implicit separation + sout | sepEnable | 1 | 2 | 3 | endl | sepDisable; // globally turn on/off implicit separation + sout | 1 | 2 | 3 | endl | sepEnable; // globally turn on implicit separation + sout | 1 | 2 | 3 | sepOn | sepDisable | endl; // ignore seperate at end of line + sout | 1 | 2 | 3 | sepOn | sepEnable | endl; // separator at end of line + sout | 1 | 2 | 3 | endl; + sout | endl; sepSetTuple( sout, " " ); // set tuple separator from ", " to " " @@ -126,6 +153,6 @@ sepSetTuple( sout, ", " ); // reset tuple separator to ", " sout | t1 | t2 | " \"" | sepGetTuple( sout ) | "\"" | endl; - sout | t1 | t2 | endl; // print tuple + sout | endl; [int, int, const char *, double] t3 = { 3, 4, "a", 7.2 };