Changeset 546e712 for src/AST

Timestamp:

Jun 6, 2019, 3:01:46 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

8c0d801, f46bfd2f

Parents:

2a54479

Message:

Fix for 1 bug of N

Location:

src/AST

Files:

• Convert.cpp (modified) (6 diffs)
• Expr.cpp (modified) (1 diff)
• Expr.hpp (modified) (1 diff)
• Node.hpp (modified) (1 diff)

src/AST/Convert.cpp

@@ -148 +148 @@
 
         const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
-                if ( inCache( node ) ) return nullptr;
+                auto&& bfwd = get<Expression>().accept1( node->bitfieldWidth );
+                auto&& type = get<Type>().accept1( node->type );
+                auto&& init = get<Initializer>().accept1( node->init );
+                auto&& attr = get<Attribute>().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<Expression>().accept1( node->bitfieldWidth ),
-                        get<Type>().accept1( node->type ),
-                        get<Initializer>().accept1( node->init ),
-                        get<Attribute>().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 );
         }
@@ -719 +731 @@
 
         const ast::Expr * visit( const ast::VariableExpr * node ) override final {
-                auto expr = visitBaseExpr( node,
-                        new VariableExpr(
-                                get<DeclarationWithType>().accept1(node->var)
-                        )
-                );
+                auto expr = new VariableExpr();
+                visitBaseExpr( node, expr );
+                expr->var = get<DeclarationWithType>().accept1(node->var);
+                Type * type = expr->var->get_type()->clone();
+                type->set_lvalue( true );
+                expr->set_result( type );
                 this->node = expr;
                 return nullptr;
@@ -1356 +1369 @@
                 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<typename NewT, typename OldT>
@@ -1424 +1447 @@
 
         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 +1486 @@
 
                 this->node = decl;
+
+                if( old->name == "tmp" ) {
+                        std::cerr << (void*)old << "(old) created " << (void*)this->node << "(new)" << std::endl;
+                }
         }
 
@@ -2099 +2145 @@
 
         virtual void visit( VariableExpr * old ) override final {
-                this->node = visitBaseExpr( old,
-                        new ast::VariableExpr(
-                                old->location,
-                                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;
         }
 

src/AST/Expr.cpp

@@ -170 +170 @@
 // --- VariableExpr
 
+VariableExpr::VariableExpr( const CodeLocation & loc )
+: Expr( loc ), var( nullptr ) {}
+
 VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
 : Expr( loc ), var( v ) {

src/AST/Expr.hpp

@@ -315 +315 @@
         readonly<DeclWithType> var;
 
+        VariableExpr( const CodeLocation & loc );
         VariableExpr( const CodeLocation & loc, const DeclWithType * v );
 

src/AST/Node.hpp

@@ -191 +191 @@
         /// wrapper for convenient access to strict_dynamic_cast
         template<typename o_node_t>
-        const o_node_t * strict_as() const { return strict_dynamic_cast<const o_node_t *>(node); }
+        const o_node_t * strict_as() const { _check(); return strict_dynamic_cast<const o_node_t *>(node); }
 
         /// Returns a mutable version of the pointer in this node.