Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/Common/PassVisitor.h (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -291,17 +291,17 @@ bool_ref * get_visit_children_ptr() { return visit_children_impl(pass, 0); } - void indexerScopeEnter () { indexer_impl_enterScope ( pass, 0 ); } - void indexerScopeLeave () { indexer_impl_leaveScope ( pass, 0 ); } - void indexerAddId ( DeclarationWithType * node ) { indexer_impl_addId ( pass, 0, node ); } - void indexerAddType ( NamedTypeDecl * node ) { indexer_impl_addType ( pass, 0, node ); } - void indexerAddStruct ( const std::string & id ) { indexer_impl_addStruct ( pass, 0, id ); } - void indexerAddStruct ( StructDecl * node ) { indexer_impl_addStruct ( pass, 0, node ); } - void indexerAddStructFwd( StructDecl * node ) { indexer_impl_addStructFwd( pass, 0, node ); } - void indexerAddEnum ( EnumDecl * node ) { indexer_impl_addEnum ( pass, 0, node ); } - void indexerAddUnion ( const std::string & id ) { indexer_impl_addUnion ( pass, 0, id ); } - void indexerAddUnion ( UnionDecl * node ) { indexer_impl_addUnion ( pass, 0, node ); } - void indexerAddUnionFwd ( UnionDecl * node ) { indexer_impl_addUnionFwd ( pass, 0, node ); } - void indexerAddTrait ( TraitDecl * node ) { indexer_impl_addTrait ( pass, 0, node ); } - void indexerAddWith ( WithStmt * node ) { indexer_impl_addWith ( pass, 0, node ); } + void indexerScopeEnter () { indexer_impl_enterScope ( pass, 0 ); } + void indexerScopeLeave () { indexer_impl_leaveScope ( pass, 0 ); } + void indexerAddId ( DeclarationWithType * node ) { indexer_impl_addId ( pass, 0, node ); } + void indexerAddType ( NamedTypeDecl * node ) { indexer_impl_addType ( pass, 0, node ); } + void indexerAddStruct ( const std::string & id ) { indexer_impl_addStruct ( pass, 0, id ); } + void indexerAddStruct ( StructDecl * node ) { indexer_impl_addStruct ( pass, 0, node ); } + void indexerAddStructFwd( StructDecl * node ) { indexer_impl_addStructFwd( pass, 0, node ); } + void indexerAddEnum ( EnumDecl * node ) { indexer_impl_addEnum ( pass, 0, node ); } + void indexerAddUnion ( const std::string & id ) { indexer_impl_addUnion ( pass, 0, id ); } + void indexerAddUnion ( UnionDecl * node ) { indexer_impl_addUnion ( pass, 0, node ); } + void indexerAddUnionFwd ( UnionDecl * node ) { indexer_impl_addUnionFwd ( pass, 0, node ); } + void indexerAddTrait ( TraitDecl * node ) { indexer_impl_addTrait ( pass, 0, node ); } + void indexerAddWith ( std::list< Expression * > & exprs ) { indexer_impl_addWith ( pass, 0, exprs ); } Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/Common/PassVisitor.impl.h (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -365,7 +365,5 @@ maybeAccept_impl ( node->attributes , *this ); - if ( node->name != "" ) { - indexerAddId( node ); - } + indexerAddId( node ); VISIT_END( node ); @@ -381,7 +379,5 @@ maybeMutate_impl ( node->attributes , *this ); - if ( node->name != "" ) { - indexerAddId( node ); - } + indexerAddId( node ); MUTATE_END( DeclarationWithType, node ); @@ -394,20 +390,26 @@ VISIT_START( node ); - if ( node->name != "" ) { - indexerAddId( node ); - } - - { - auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - // implicit add __func__ identifier as specified in the C manual 6.4.2.2 - static ObjectDecl func( - "__func__", noStorageClasses, LinkageSpec::C, nullptr, - new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ), - nullptr - ); - indexerAddId( &func ); - maybeAccept_impl( node->type, *this ); - maybeAccept_impl( node->statements, *this ); - maybeAccept_impl( node->attributes, *this ); + indexerAddId( node ); + + maybeAccept_impl( node->withExprs, *this ); + { + // with clause introduces a level of scope (for the with expression members). + // with clause exprs are added to the indexer before parameters so that parameters + // shadow with exprs and not the other way around. + auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); + indexerAddWith( node->withExprs ); + { + auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); + // implicit add __func__ identifier as specified in the C manual 6.4.2.2 + static ObjectDecl func( + "__func__", noStorageClasses, LinkageSpec::C, nullptr, + new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ), + nullptr + ); + indexerAddId( &func ); + maybeAccept_impl( node->type, *this ); + maybeAccept_impl( node->statements, *this ); + maybeAccept_impl( node->attributes, *this ); + } } @@ -419,20 +421,25 @@ MUTATE_START( node ); - if ( node->name != "" ) { - indexerAddId( node ); - } - - { - auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - // implicit add __func__ identifier as specified in the C manual 6.4.2.2 - static ObjectDecl func( - "__func__", noStorageClasses, LinkageSpec::C, nullptr, - new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ), - nullptr - ); - indexerAddId( &func ); - maybeMutate_impl( node->type, *this ); - maybeMutate_impl( node->statements, *this ); - maybeMutate_impl( node->attributes, *this ); + indexerAddId( node ); + + { + // with clause introduces a level of scope (for the with expression members). + // with clause exprs are added to the indexer before parameters so that parameters + // shadow with exprs and not the other way around. + auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); + indexerAddWith( node->withExprs ); + { + auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); + // implicit add __func__ identifier as specified in the C manual 6.4.2.2 + static ObjectDecl func( + "__func__", noStorageClasses, LinkageSpec::C, nullptr, + new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ), + nullptr + ); + indexerAddId( &func ); + maybeMutate_impl( node->type, *this ); + maybeMutate_impl( node->statements, *this ); + maybeMutate_impl( node->attributes, *this ); + } } @@ -730,10 +737,24 @@ template< typename pass_type > void PassVisitor< pass_type >::visit( AsmStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ) + + maybeAccept_impl( node->instruction, *this ); + maybeAccept_impl( node->output, *this ); + maybeAccept_impl( node->input, *this ); + maybeAccept_impl( node->clobber, *this ); + + VISIT_END( node ); } template< typename pass_type > Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) { - MUTATE_BODY( Statement, node ); + MUTATE_START( node ); + + maybeMutate_impl( node->instruction, *this ); + maybeMutate_impl( node->output, *this ); + maybeMutate_impl( node->input, *this ); + maybeMutate_impl( node->clobber, *this ); + + MUTATE_END( Statement, node ); } @@ -996,5 +1017,5 @@ // catch statements introduce a level of scope (for the caught exception) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - indexerAddWith( node ); + indexerAddWith( node->exprs ); maybeAccept_impl( node->stmt, *this ); } @@ -1009,5 +1030,5 @@ // catch statements introduce a level of scope (for the caught exception) auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); - indexerAddWith( node ); + indexerAddWith( node->exprs ); maybeMutate_impl( node->stmt, *this ); } Index: src/Common/PassVisitor.proto.h =================================================================== --- src/Common/PassVisitor.proto.h (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/Common/PassVisitor.proto.h (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -202,11 +202,11 @@ static inline void indexer_impl_##func ( pass_type &, long, type ) { } \ -INDEXER_FUNC( addId , DeclarationWithType * ); -INDEXER_FUNC( addType , NamedTypeDecl * ); -INDEXER_FUNC( addStruct , StructDecl * ); -INDEXER_FUNC( addEnum , EnumDecl * ); -INDEXER_FUNC( addUnion , UnionDecl * ); -INDEXER_FUNC( addTrait , TraitDecl * ); -INDEXER_FUNC( addWith , WithStmt * ); +INDEXER_FUNC( addId , DeclarationWithType * ); +INDEXER_FUNC( addType , NamedTypeDecl * ); +INDEXER_FUNC( addStruct , StructDecl * ); +INDEXER_FUNC( addEnum , EnumDecl * ); +INDEXER_FUNC( addUnion , UnionDecl * ); +INDEXER_FUNC( addTrait , TraitDecl * ); +INDEXER_FUNC( addWith , std::list< Expression * > & ); Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/Parser/DeclarationNode.cc (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -723,20 +723,10 @@ } -DeclarationNode * DeclarationNode::addFunctionBody( StatementNode * body, StatementNode * with ) { +DeclarationNode * DeclarationNode::addFunctionBody( StatementNode * body, ExpressionNode * withExprs ) { assert( type ); assert( type->kind == TypeData::Function ); assert( ! type->function.body ); - if ( with ) { - // convert - // void f(S s) with (s) { x = 0; } - // to - // void f(S s) { with(s) { x = 0; } } - WithStmt * withStmt = strict_dynamic_cast< WithStmt * >( with->build() ); - withStmt->stmt = body->build(); - delete body; - delete with; - body = new StatementNode( new CompoundStmt( { withStmt } ) ); - } type->function.body = body; + type->function.withExprs = withExprs; return this; } Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/Parser/ParseNode.h (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -262,5 +262,5 @@ DeclarationNode * addBitfield( ExpressionNode * size ); DeclarationNode * addVarArgs(); - DeclarationNode * addFunctionBody( StatementNode * body, StatementNode * with = nullptr ); + DeclarationNode * addFunctionBody( StatementNode * body, ExpressionNode * with = nullptr ); DeclarationNode * addOldDeclList( DeclarationNode * list ); DeclarationNode * setBase( TypeData * newType ); Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/Parser/TypeData.cc (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -55,4 +55,5 @@ function.body = nullptr; function.newStyle = false; + function.withExprs = nullptr; break; // Enum is an Aggregate, so both structures are initialized together. @@ -122,4 +123,5 @@ delete function.oldDeclList; delete function.body; + delete function.withExprs; // delete function; break; @@ -194,4 +196,5 @@ newtype->function.body = maybeClone( function.body ); newtype->function.newStyle = function.newStyle; + newtype->function.withExprs = maybeClone( function.withExprs ); break; case Aggregate: @@ -861,4 +864,5 @@ CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt ); decl = new FunctionDecl( name, scs, linkage, buildFunction( td ), body, attributes, funcSpec ); + buildList( td->function.withExprs, decl->withExprs ); return decl->set_asmName( asmName ); } else if ( td->kind == TypeData::Aggregate ) { Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/Parser/TypeData.h (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -65,4 +65,5 @@ StatementNode * body; bool newStyle; + ExpressionNode * withExprs; // expressions from function's with_clause }; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/Parser/parser.yy (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -259,5 +259,6 @@ %type iteration_statement jump_statement %type expression_statement asm_statement -%type with_statement with_clause_opt +%type with_statement +%type with_clause_opt %type exception_statement handler_clause finally_clause %type handler_key @@ -2417,5 +2418,5 @@ { $$ = nullptr; } | WITH '(' tuple_expression_list ')' - { $$ = new StatementNode( build_with( $3, nullptr ) ); } + { $$ = $3; } ; Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/ResolvExpr/Resolver.cc (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -82,12 +82,11 @@ void previsit( ConstructorInit *ctorInit ); private: - typedef std::list< Initializer * >::iterator InitIterator; + typedef std::list< Initializer * >::iterator InitIterator; template< typename PtrType > void handlePtrType( PtrType * type ); - void resolveAggrInit( ReferenceToType *, InitIterator &, InitIterator & ); - void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator &, TypeSubstitution sub ); - void fallbackInit( ConstructorInit * ctorInit ); + void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ); + void fallbackInit( ConstructorInit * ctorInit ); Type * functionReturn = nullptr; @@ -269,8 +268,18 @@ std::cerr << std::endl; #endif - Type *new_type = resolveTypeof( functionDecl->get_type(), indexer ); + Type *new_type = resolveTypeof( functionDecl->type, indexer ); functionDecl->set_type( new_type ); GuardValue( functionReturn ); - functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() ); + functionReturn = ResolvExpr::extractResultType( functionDecl->type ); + + { + // resolve with-exprs with parameters in scope and add any newly generated declarations to the + // front of the function body. + auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this](){ indexer.leaveScope(); } ); + indexer.addFunctionType( functionDecl->type ); + std::list< Statement * > newStmts; + resolveWithExprs( functionDecl->withExprs, newStmts ); + functionDecl->statements->kids.splice( functionDecl->statements->kids.begin(), newStmts ); + } } @@ -279,9 +288,9 @@ // xxx - it might be necessary to somehow keep the information from this environment, but I can't currently // see how it's useful. - for ( Declaration * d : functionDecl->get_functionType()->get_parameters() ) { + for ( Declaration * d : functionDecl->type->parameters ) { if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( d ) ) { - if ( SingleInit * init = dynamic_cast< SingleInit * >( obj->get_init() ) ) { - delete init->get_value()->get_env(); - init->get_value()->set_env( nullptr ); + if ( SingleInit * init = dynamic_cast< SingleInit * >( obj->init ) ) { + delete init->value->env; + init->value->env = nullptr; } } @@ -584,7 +593,6 @@ } - - void Resolver::previsit( WithStmt * withStmt ) { - for ( Expression *& expr : withStmt->exprs ) { + void Resolver::resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ) { + for ( Expression *& expr : withExprs ) { // only struct- and union-typed expressions are viable candidates findKindExpression( expr, indexer, "with statement", isStructOrUnion ); @@ -595,5 +603,5 @@ ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) ); expr = new VariableExpr( tmp ); - stmtsToAddBefore.push_back( new DeclStmt( tmp ) ); + newStmts.push_back( new DeclStmt( tmp ) ); if ( InitTweak::isConstructable( tmp->type ) ) { // generate ctor/dtor and resolve them @@ -603,4 +611,8 @@ } } + } + + void Resolver::previsit( WithStmt * withStmt ) { + resolveWithExprs( withStmt->exprs, stmtsToAddBefore ); } @@ -716,4 +728,5 @@ PassVisitor resolver( indexer ); stmtExpr->accept( resolver ); + stmtExpr->computeResult(); } Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/SymTab/Indexer.cc (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -409,4 +409,5 @@ void Indexer::addId( DeclarationWithType *decl, Expression * baseExpr ) { + if ( decl->name == "" ) return; debugPrint( "Adding Id " << decl->name << std::endl ); makeWritable(); @@ -588,6 +589,6 @@ } - void Indexer::addWith( WithStmt * stmt ) { - for ( Expression * expr : stmt->exprs ) { + void Indexer::addWith( std::list< Expression * > & withExprs ) { + for ( Expression * expr : withExprs ) { if ( expr->result ) { AggregateDecl * aggr = expr->result->stripReferences()->getAggr(); Index: src/SymTab/Indexer.h =================================================================== --- src/SymTab/Indexer.h (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/SymTab/Indexer.h (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -84,5 +84,5 @@ /// adds all of the IDs from WithStmt exprs - void addWith( WithStmt * ); + void addWith( std::list< Expression * > & withExprs ); /// adds all of the members of the Aggregate (addWith helper) Index: src/SynTree/Declaration.h =================================================================== --- src/SynTree/Declaration.h (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/SynTree/Declaration.h (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -151,4 +151,5 @@ FunctionType *type; CompoundStmt *statements; + std::list< Expression * > withExprs; FunctionDecl( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/SynTree/Expression.cc (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -597,6 +597,20 @@ StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) { + computeResult(); +} +StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) { + cloneAll( other.returnDecls, returnDecls ); + cloneAll( other.dtors, dtors ); +} +StmtExpr::~StmtExpr() { + delete statements; + deleteAll( dtors ); + deleteAll( returnDecls ); +} +void StmtExpr::computeResult() { assert( statements ); - std::list< Statement * > & body = statements->get_kids(); + std::list< Statement * > & body = statements->kids; + delete result; + result = nullptr; if ( ! body.empty() ) { if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) { @@ -608,13 +622,4 @@ result = new VoidType( Type::Qualifiers() ); } -} -StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) { - cloneAll( other.returnDecls, returnDecls ); - cloneAll( other.dtors, dtors ); -} -StmtExpr::~StmtExpr() { - delete statements; - deleteAll( dtors ); - deleteAll( returnDecls ); } void StmtExpr::print( std::ostream &os, Indenter indent ) const { Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/SynTree/Expression.h (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -728,4 +728,7 @@ StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; } + // call to set the result type of this StmtExpr based on its body + void computeResult(); + std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; } std::list< Expression * > & get_dtors() { return dtors; } Index: src/SynTree/FunctionDecl.cc =================================================================== --- src/SynTree/FunctionDecl.cc (revision 23c27039d154516f4cb778bd20b2ac74a513ba2e) +++ src/SynTree/FunctionDecl.cc (revision 295e5071b258274909bae65801c4fa3111bace95) @@ -51,4 +51,5 @@ VarExprReplacer::replace( this, declMap ); } + cloneAll( other.withExprs, withExprs ); } @@ -56,4 +57,5 @@ delete type; delete statements; + deleteAll( withExprs ); }