Changes in / [7c608d5:54d4c0e]


Ignore:
Location:
src
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Node.cpp

    r7c608d5 r54d4c0e  
    3434template< typename node_t, enum ast::Node::ref_type ref_t >
    3535void ast::ptr_base<node_t, ref_t>::_dec( const node_t * node ) { node->decrement(ref_t); }
     36
     37template< typename node_t, enum ast::Node::ref_type ref_t >
     38void ast::ptr_base<node_t, ref_t>::_check() const { if(node) assert(node->was_ever_strong == false || node->strong_count > 0); }
    3639
    3740template< typename node_t, enum ast::Node::ref_type ref_t >

  • src/AST/Node.hpp

    r7c608d5 r54d4c0e  
    4646        };
    4747
     48        bool unique() const { return strong_count == 1; }
     49
    4850private:
    4951        /// Make a copy of this node; should be overridden in subclass with more precise return type
    … …  
    5658        mutable size_t strong_count = 0;
    5759        mutable size_t weak_count = 0;
     60        mutable bool was_ever_strong = false;
    5861
    5962        void increment(ref_type ref) const {
    6063                switch (ref) {
    61                         case ref_type::strong: strong_count++; break;
     64                        case ref_type::strong: strong_count++; was_ever_strong = true; break;
    6265                        case ref_type::weak  : weak_count  ++; break;
    6366                }
    … …  
    176179        }
    177180
    178         const node_t * get() const { return  node; }
    179         const node_t * operator->() const { return  node; }
    180         const node_t & operator* () const { return *node; }
    181         explicit operator bool() const { return node; }
    182         operator const node_t * () const { return node; }
     181        const node_t * get() const { _check(); return  node; }
     182        const node_t * operator->() const { _check(); return  node; }
     183        const node_t & operator* () const { _check(); return *node; }
     184        explicit operator bool() const { _check(); return node; }
     185        operator const node_t * () const { _check(); return node; }
    183186
    184187        /// wrapper for convenient access to dynamic_cast
    185188        template<typename o_node_t>
    186         const o_node_t * as() const { return dynamic_cast<const o_node_t *>(node); }
     189        const o_node_t * as() const { _check(); return dynamic_cast<const o_node_t *>(node); }
    187190
    188191        /// wrapper for convenient access to strict_dynamic_cast
    … …  
    208211        void _inc( const node_t * other );
    209212        void _dec( const node_t * other );
     213        void _check() const;
    210214
    211215protected:

  • src/ResolvExpr/Resolver.cc

    r7c608d5 r54d4c0e  
    2727#include "typeops.h"                     // for extractResultType
    2828#include "Unify.h"                       // for unify
     29#include "AST/Chain.hpp"
    2930#include "AST/Decl.hpp"
    3031#include "AST/Init.hpp"
    … …  
    407408
    408409        void Resolver_old::previsit( ObjectDecl * objectDecl ) {
    409                 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that 
    410                 // class-variable initContext is changed multiple time because the LHS is analysed twice. 
    411                 // The second analysis changes initContext because of a function type can contain object 
    412                 // declarations in the return and parameter types. So each value of initContext is 
     410                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
     411                // class-variable initContext is changed multiple time because the LHS is analysed twice.
     412                // The second analysis changes initContext because of a function type can contain object
     413                // declarations in the return and parameter types. So each value of initContext is
    413414                // retained, so the type on the first analysis is preserved and used for selecting the RHS.
    414415                GuardValue( currentObject );
    … …  
    447448
    448449        void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
    449                 // default value expressions have an environment which shouldn't be there and trips up 
     450                // default value expressions have an environment which shouldn't be there and trips up
    450451                // later passes.
    451452                // xxx - it might be necessary to somehow keep the information from this environment, but I
    … …  
    939940        ///////////////////////////////////////////////////////////////////////////
    940941
    941         class Resolver_new final 
    942         : public ast::WithSymbolTable, public ast::WithGuards, 
    943           public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting, 
     942        class Resolver_new final
     943        : public ast::WithSymbolTable, public ast::WithGuards,
     944          public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
    944945          public ast::WithStmtsToAdd<> {
    945        
     946
    946947                ast::ptr< ast::Type > functionReturn = nullptr;
    947948                // ast::CurrentObject currentObject = nullptr;
    948949                // bool inEnumDecl = false;
    949950
    950         public: 
     951        public:
    951952                Resolver_new() = default;
    952953                Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
    … …  
    991992
    992993        const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) {
    993                 // default value expressions have an environment which shouldn't be there and trips up 
     994                // default value expressions have an environment which shouldn't be there and trips up
    994995                // later passes.
    995996                ast::ptr< ast::FunctionDecl > ret = functionDecl;
    996997                for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
    997998                        const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
    998                        
     999
    9991000                        if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
    10001001                                if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) {
    10011002                                        if ( init->value->env == nullptr ) continue;
    10021003                                        // clone initializer minus the initializer environment
    1003                                         strict_dynamic_cast< ast::SingleInit * >(
    1004                                                 strict_dynamic_cast< ast::ObjectDecl * >(
    1005                                                         ret.get_and_mutate()->type.get_and_mutate()->params[i].get_and_mutate()
    1006                                                 )->init.get_and_mutate()
    1007                                         )->value.get_and_mutate()->env = nullptr;
     1004                                        ast::chain_mutate( ret )
     1005                                                ( &ast::FunctionDecl::type )
     1006                                                        ( &ast::FunctionType::params )
     1007                                                                [i]
     1008                                                                ( &ast::ObjectDecl::init )
     1009                                                                        ( &ast::SingleInit::value )->env = nullptr;
     1010
     1011                                        assert( functionDecl != ret.get() || functionDecl->unique() );
     1012                                        assert( ! ret->type->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env );
    10081013                                }
    10091014                        }

  • src/SynTree/DeclReplacer.cc

    r7c608d5 r54d4c0e  
    3030                        bool debug;
    3131                public:
     32                        size_t replaced;
     33
     34                public:
    3235                        DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
    3336
    … …  
    4548                        bool debug;
    4649                public:
     50                        size_t replaced;
     51
     52                public:
    4753                        ExprDeclReplacer( const ExprMap & exprMap, bool debug = false );
    4854
    … …  
    5258        }
    5359
    54         void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
     60        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
    5561                PassVisitor<DeclReplacer> replacer( declMap, typeMap, debug );
    5662                maybeAccept( node, replacer );
     63                return replacer.pass.replaced;
    5764        }
    5865
    59         void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) {
     66        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) {
    6067                TypeMap typeMap;
    61                 replace( node, declMap, typeMap, debug );
     68                return replace( node, declMap, typeMap, debug );
    6269        }
    6370
    64         void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug ) {
     71        size_t replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug ) {
    6572                DeclMap declMap;
    66                 replace( node, declMap, typeMap, debug );
     73                return replace( node, declMap, typeMap, debug );
    6774        }
    6875
    69         void replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug ) {
     76        size_t replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug ) {
    7077                PassVisitor<ExprDeclReplacer> replacer( exprMap, debug );
    7178                node = maybeMutate( node, replacer );
     79                return replacer.pass.replaced;
    7280        }
    7381
    7482        namespace {
    75                 DeclReplacer::DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug ) : declMap( declMap ), typeMap( typeMap ) , debug( debug ) {}
     83                DeclReplacer::DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug ) : declMap( declMap ), typeMap( typeMap ) , debug( debug ), replaced( 0 ) {}
    7684
    7785                // replace variable with new node from decl map
    … …  
    7987                        // 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)
    8088                        if ( declMap.count( varExpr->var ) ) {
     89                                replaced++;
    8190                                auto replacement = declMap.at( varExpr->var );
    8291                                if ( debug ) {
    … …  
    8998                void DeclReplacer::previsit( TypeInstType * inst ) {
    9099                        if ( typeMap.count( inst->baseType ) ) {
     100                                replaced++;
    91101                                auto replacement = typeMap.at( inst->baseType );
    92102                                if ( debug ) {
    … …  
    97107                }
    98108
    99                 ExprDeclReplacer::ExprDeclReplacer( const ExprMap & exprMap, bool debug ) : exprMap( exprMap ), debug( debug ) {}
     109                ExprDeclReplacer::ExprDeclReplacer( const ExprMap & exprMap, bool debug ) : exprMap( exprMap ), debug( debug ), replaced( 0 ) {}
    100110
    101111                Expression * ExprDeclReplacer::postmutate( VariableExpr * varExpr ) {
    102112                        if ( exprMap.count( varExpr->var ) ) {
     113                                replaced++;
    103114                                Expression * replacement = exprMap.at( varExpr->var )->clone();
    104115                                if ( debug ) {

  • src/SynTree/DeclReplacer.h

    r7c608d5 r54d4c0e  
    2828        typedef std::map< DeclarationWithType *, Expression * > ExprMap;
    2929
    30         void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
    31         void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
    32         void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
     30        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
     31        size_t replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
     32        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
    3333
    34         void replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug = false);
     34        size_t replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug = false);
    3535        template<typename T>
    3636                void replace( T *& node, const ExprMap & exprMap, bool debug = false ) {
Note: See TracChangeset for help on using the changeset viewer.