Index: src/AST/Convert.cpp =================================================================== --- src/AST/Convert.cpp (revision b7d92b9615536fccd480694cbb6833bd89ffa8f3) +++ src/AST/Convert.cpp (revision 8c0d80188b65e7e883b8e74c821a80c2d8532351) @@ -10,6 +10,6 @@ // Created On : Thu May 09 15::37::05 2019 // Last Modified By : Andrew Beach -// Last Modified On : Wed May 29 17:05:00 2019 -// Update Count : 9 +// Last Modified On : Thu May 06 19:51:00 2019 +// Update Count : 10 // @@ -49,4 +49,5 @@ // This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not) // allow us to use the same stratagy in the new ast. +ast::Type * sizeType = nullptr; ast::FunctionDecl * dereferenceOperator = nullptr; ast::StructDecl * dtorStruct = nullptr; @@ -147,15 +148,27 @@ const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final { - if ( inCache( node ) ) return nullptr; + auto&& bfwd = get().accept1( node->bitfieldWidth ); + auto&& type = get().accept1( node->type ); + auto&& init = get().accept1( node->init ); + auto&& attr = get().acceptL( node->attributes ); + if ( inCache( node ) ) { + if(node->name == "tmp") { + std::cerr << (void*)node << "(new) in cache " << (void*)this->node << "(old)" << std::endl; + } + return nullptr; + } auto decl = new ObjectDecl( node->name, Type::StorageClasses( node->storage.val ), LinkageSpec::Spec( node->linkage.val ), - get().accept1( node->bitfieldWidth ), - get().accept1( node->type ), - get().accept1( node->init ), - get().acceptL( node->attributes ), + bfwd, + type, + init, + attr, Type::FuncSpecifiers( node->funcSpec.val ) ); + if(node->name == "tmp") { + std::cerr << (void*)node << "(new) created " << (void*)decl << "(old)" << std::endl; + } return declWithTypePostamble( decl, node ); } @@ -709,7 +722,5 @@ auto expr = visitBaseExpr( node, new MemberExpr( - inCache(node->member) ? - dynamic_cast(this->node) : - get().accept1(node->member), + get().accept1(node->member), get().accept1(node->aggregate) ) @@ -720,11 +731,10 @@ const ast::Expr * visit( const ast::VariableExpr * node ) override final { - auto expr = visitBaseExpr( node, - new VariableExpr( - inCache(node->var) ? - dynamic_cast(this->node) : - get().accept1(node->var) - ) - ); + auto expr = new VariableExpr(); + visitBaseExpr( node, expr ); + expr->var = get().accept1(node->var); + Type * type = expr->var->get_type()->clone(); + type->set_lvalue( true ); + expr->set_result( type ); this->node = expr; return nullptr; @@ -819,7 +829,5 @@ new OffsetofExpr( get().accept1(node->type), - inCache(node->member) ? - dynamic_cast(this->node) : - get().accept1(node->member) + get().accept1(node->member) ) ); @@ -1082,5 +1090,10 @@ const ast::Type * visit( const ast::BasicType * node ) override final { - this->node = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind }; + auto type = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind }; + // I believe this should always be a BasicType. + if ( sizeType == node ) { + Validate::SizeType = type; + } + this->node = type; return nullptr; } @@ -1356,11 +1369,21 @@ return strict_dynamic_cast< ast::Decl * >( node ); } + + ConverterOldToNew() = default; + ConverterOldToNew(const ConverterOldToNew &) = delete; + ConverterOldToNew(ConverterOldToNew &&) = delete; private: /// conversion output - ast::Node * node; + ast::Node * node = nullptr; /// cache of nodes that might be referenced by readonly<> for de-duplication - std::unordered_map< BaseSyntaxNode *, ast::Node * > cache; + std::unordered_map< BaseSyntaxNode *, ast::Node * > cache = {}; // Local Utilities: + + #define construct(T, key, ...) ({ \ + void * data = ::operator new(sizeof(T)); \ + cache.emplace( key, (T*)data ); \ + new (data) T( __VA_ARGS__ ); \ + }) template @@ -1424,17 +1447,36 @@ virtual void visit( ObjectDecl * old ) override final { - if ( inCache( old ) ) return; + if( old->name == "tmp" ) { + std::cerr << "building parameters for" << (void*)old << std::endl; + } + auto&& type = GET_ACCEPT_1(type, Type); + auto&& init = GET_ACCEPT_1(init, Init); + auto&& bfwd = GET_ACCEPT_1(bitfieldWidth, Expr); + auto&& attr = GET_ACCEPT_V(attributes, Attribute); + if( old->name == "tmp" ) { + std::cerr << "checking cache for " << (void*)old << std::endl; + } + if ( inCache( old ) ) { + if( old->name == "tmp" ) { + std::cerr << (void*)old << "(old) in cache " << (void*)this->node << "(new)" << std::endl; + } + return; + } auto decl = new ast::ObjectDecl( old->location, old->name, - GET_ACCEPT_1(type, Type), - GET_ACCEPT_1(init, Init), + type, + init, { old->get_storageClasses().val }, { old->linkage.val }, - GET_ACCEPT_1(bitfieldWidth, Expr), - GET_ACCEPT_V(attributes, Attribute), + bfwd, + std::move(attr), { old->get_funcSpec().val } ); - cache.emplace( old, decl ); + cache.emplace(old, decl); + if( old->name == "tmp" ) { + std::cerr << (void*)old << "(old) added to cache with " << (void*)decl << "(new)" << std::endl; + } + assert(cache.find( old ) != cache.end()); decl->scopeLevel = old->scopeLevel; decl->mangleName = old->mangleName; @@ -1444,4 +1486,8 @@ this->node = decl; + + if( old->name == "tmp" ) { + std::cerr << (void*)old << "(old) created " << (void*)this->node << "(new)" << std::endl; + } } @@ -2092,7 +2138,5 @@ new ast::MemberExpr( old->location, - inCache(old->member) ? - dynamic_cast(this->node) : - GET_ACCEPT_1(member, DeclWithType), + GET_ACCEPT_1(member, DeclWithType), GET_ACCEPT_1(aggregate, Expr) ) @@ -2101,12 +2145,16 @@ virtual void visit( VariableExpr * old ) override final { - this->node = visitBaseExpr( old, - new ast::VariableExpr( - old->location, - inCache(old->var) ? - dynamic_cast(this->node) : - GET_ACCEPT_1(var, DeclWithType) - ) - ); + auto expr = new ast::VariableExpr( + old->location + ); + + visitBaseExpr( old, + expr + ); + + expr->var = GET_ACCEPT_1(var, DeclWithType); + expr->result = expr->var->get_type(); + add_qualifiers( expr->result, ast::CV::Lvalue ); + this->node = expr; } @@ -2234,7 +2282,5 @@ old->location, GET_ACCEPT_1(type, Type), - inCache(old->member) ? - dynamic_cast(this->node) : - GET_ACCEPT_1(member, DeclWithType) + GET_ACCEPT_1(member, DeclWithType) ) ); @@ -2472,5 +2518,10 @@ virtual void visit( BasicType * old ) override final { - this->node = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) }; + auto type = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) }; + // I believe this should always be a BasicType. + if ( Validate::SizeType == old ) { + sizeType = type; + } + this->node = type; } Index: src/AST/Expr.cpp =================================================================== --- src/AST/Expr.cpp (revision b7d92b9615536fccd480694cbb6833bd89ffa8f3) +++ src/AST/Expr.cpp (revision 8c0d80188b65e7e883b8e74c821a80c2d8532351) @@ -170,4 +170,7 @@ // --- VariableExpr +VariableExpr::VariableExpr( const CodeLocation & loc ) +: Expr( loc ), var( nullptr ) {} + VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v ) : Expr( loc ), var( v ) { Index: src/AST/Expr.hpp =================================================================== --- src/AST/Expr.hpp (revision b7d92b9615536fccd480694cbb6833bd89ffa8f3) +++ src/AST/Expr.hpp (revision 8c0d80188b65e7e883b8e74c821a80c2d8532351) @@ -315,4 +315,5 @@ readonly var; + VariableExpr( const CodeLocation & loc ); VariableExpr( const CodeLocation & loc, const DeclWithType * v ); Index: src/AST/Node.hpp =================================================================== --- src/AST/Node.hpp (revision b7d92b9615536fccd480694cbb6833bd89ffa8f3) +++ src/AST/Node.hpp (revision 8c0d80188b65e7e883b8e74c821a80c2d8532351) @@ -206,5 +206,5 @@ /// wrapper for convenient access to strict_dynamic_cast template - const o_node_t * strict_as() const { return strict_dynamic_cast(node); } + const o_node_t * strict_as() const { _check(); return strict_dynamic_cast(node); } /// Returns a mutable version of the pointer in this node. Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision b7d92b9615536fccd480694cbb6833bd89ffa8f3) +++ src/InitTweak/FixInit.cc (revision 8c0d80188b65e7e883b8e74c821a80c2d8532351) @@ -262,8 +262,4 @@ // unwrap implicit statement wrapper Statement * dtor = input; - if ( ImplicitCtorDtorStmt * implicit = dynamic_cast< ImplicitCtorDtorStmt * >( input ) ) { - // dtor = implicit->callStmt; - // implicit->callStmt = nullptr; - } assert( dtor ); std::list< Expression * > matches; @@ -291,5 +287,11 @@ // wraps the more complicated code. static UniqueName dtorNamer( "__cleanup_dtor" ); - FunctionDecl * dtorFunc = FunctionDecl::newFunction( dtorNamer.newName(), SymTab::genDefaultType( objDecl->type->stripReferences(), false ), new CompoundStmt() ); + std::string name = dtorNamer.newName(); + if(name == "__cleanup_dtor8") { + objDecl->print(std::cerr); + std::cerr << "-----" << std::endl; + dtor->print(std::cerr); + } + FunctionDecl * dtorFunc = FunctionDecl::newFunction( name, SymTab::genDefaultType( objDecl->type->stripReferences(), false ), new CompoundStmt() ); stmtsToAdd.push_back( new DeclStmt( dtorFunc ) ); @@ -304,5 +306,9 @@ replacement = new CastExpr( replacement, base->clone() ); } - DeclReplacer::replace( dtor, { std::make_pair( objDecl, replacement ) } ); + size_t replaced = DeclReplacer::replace( dtor, { std::make_pair( objDecl, replacement ) } ); + if(replaced == 0) { + std::cerr << "Failed to replace " << objDecl << std::endl; + abort(); + } dtorFunc->statements->push_back( strict_dynamic_cast( dtor ) ); Index: src/SynTree/DeclReplacer.h =================================================================== --- src/SynTree/DeclReplacer.h (revision b7d92b9615536fccd480694cbb6833bd89ffa8f3) +++ src/SynTree/DeclReplacer.h (revision 8c0d80188b65e7e883b8e74c821a80c2d8532351) @@ -33,11 +33,13 @@ size_t replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug = false); + template - void replace( T *& node, const ExprMap & exprMap, bool debug = false ) { - if ( ! node ) return; + size_t replace( T *& node, const ExprMap & exprMap, bool debug = false ) { + if ( ! node ) return 0ul; BaseSyntaxNode * arg = node; - replace( arg, exprMap, debug ); + size_t replaced = replace( arg, exprMap, debug ); node = dynamic_cast( arg ); assertf( node, "DeclReplacer fundamentally changed the type of its argument." ); + return replaced; } } Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision b7d92b9615536fccd480694cbb6833bd89ffa8f3) +++ src/SynTree/Expression.cc (revision 8c0d80188b65e7e883b8e74c821a80c2d8532351) @@ -102,4 +102,6 @@ SemanticError( this, "Constant expression of non-integral type " ); } + +VariableExpr::VariableExpr() : Expression(), var( nullptr ) {} VariableExpr::VariableExpr( DeclarationWithType *_var ) : Expression(), var( _var ) { Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision b7d92b9615536fccd480694cbb6833bd89ffa8f3) +++ src/SynTree/Expression.h (revision 8c0d80188b65e7e883b8e74c821a80c2d8532351) @@ -299,4 +299,5 @@ DeclarationWithType * var; + VariableExpr(); VariableExpr( DeclarationWithType * var ); VariableExpr( const VariableExpr & other );