Changes in / [54d4c0e:7c608d5]


Ignore:
Location:
src
Files:
1 deleted
5 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Node.cpp

    r54d4c0e r7c608d5  
    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 
    37 template< typename node_t, enum ast::Node::ref_type ref_t >
    38 void ast::ptr_base<node_t, ref_t>::_check() const { if(node) assert(node->was_ever_strong == false || node->strong_count > 0); }
    3936
    4037template< typename node_t, enum ast::Node::ref_type ref_t >

  • src/AST/Node.hpp

    r54d4c0e r7c608d5  
    4646        };
    4747
    48         bool unique() const { return strong_count == 1; }
    49 
    5048private:
    5149        /// Make a copy of this node; should be overridden in subclass with more precise return type
    … …  
    5856        mutable size_t strong_count = 0;
    5957        mutable size_t weak_count = 0;
    60         mutable bool was_ever_strong = false;
    6158
    6259        void increment(ref_type ref) const {
    6360                switch (ref) {
    64                         case ref_type::strong: strong_count++; was_ever_strong = true; break;
     61                        case ref_type::strong: strong_count++; break;
    6562                        case ref_type::weak  : weak_count  ++; break;
    6663                }
    … …  
    179176        }
    180177
    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; }
     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; }
    186183
    187184        /// wrapper for convenient access to dynamic_cast
    188185        template<typename o_node_t>
    189         const o_node_t * as() const { _check(); return dynamic_cast<const o_node_t *>(node); }
     186        const o_node_t * as() const { return dynamic_cast<const o_node_t *>(node); }
    190187
    191188        /// wrapper for convenient access to strict_dynamic_cast
    … …  
    211208        void _inc( const node_t * other );
    212209        void _dec( const node_t * other );
    213         void _check() const;
    214210
    215211protected:

  • src/ResolvExpr/Resolver.cc

    r54d4c0e r7c608d5  
    2727#include "typeops.h"                     // for extractResultType
    2828#include "Unify.h"                       // for unify
    29 #include "AST/Chain.hpp"
    3029#include "AST/Decl.hpp"
    3130#include "AST/Init.hpp"
    … …  
    408407
    409408        void Resolver_old::previsit( ObjectDecl * objectDecl ) {
    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
     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 
    414413                // retained, so the type on the first analysis is preserved and used for selecting the RHS.
    415414                GuardValue( currentObject );
    … …  
    448447
    449448        void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
    450                 // default value expressions have an environment which shouldn't be there and trips up
     449                // default value expressions have an environment which shouldn't be there and trips up 
    451450                // later passes.
    452451                // xxx - it might be necessary to somehow keep the information from this environment, but I
    … …  
    940939        ///////////////////////////////////////////////////////////////////////////
    941940
    942         class Resolver_new final
    943         : public ast::WithSymbolTable, public ast::WithGuards,
    944           public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
     941        class Resolver_new final 
     942        : public ast::WithSymbolTable, public ast::WithGuards, 
     943          public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting, 
    945944          public ast::WithStmtsToAdd<> {
    946 
     945       
    947946                ast::ptr< ast::Type > functionReturn = nullptr;
    948947                // ast::CurrentObject currentObject = nullptr;
    949948                // bool inEnumDecl = false;
    950949
    951         public:
     950        public: 
    952951                Resolver_new() = default;
    953952                Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
    … …  
    992991
    993992        const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) {
    994                 // default value expressions have an environment which shouldn't be there and trips up
     993                // default value expressions have an environment which shouldn't be there and trips up 
    995994                // later passes.
    996995                ast::ptr< ast::FunctionDecl > ret = functionDecl;
    997996                for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
    998997                        const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
    999 
     998                       
    1000999                        if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
    10011000                                if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) {
    10021001                                        if ( init->value->env == nullptr ) continue;
    10031002                                        // clone initializer minus the initializer environment
    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 );
     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;
    10131008                                }
    10141009                        }

  • src/SynTree/DeclReplacer.cc

    r54d4c0e r7c608d5  
    3030                        bool debug;
    3131                public:
    32                         size_t replaced;
    33 
    34                 public:
    3532                        DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
    3633
    … …  
    4845                        bool debug;
    4946                public:
    50                         size_t replaced;
    51 
    52                 public:
    5347                        ExprDeclReplacer( const ExprMap & exprMap, bool debug = false );
    5448
    … …  
    5852        }
    5953
    60         size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
     54        void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
    6155                PassVisitor<DeclReplacer> replacer( declMap, typeMap, debug );
    6256                maybeAccept( node, replacer );
    63                 return replacer.pass.replaced;
    6457        }
    6558
    66         size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) {
     59        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) {
    6760                TypeMap typeMap;
    68                 return replace( node, declMap, typeMap, debug );
     61                replace( node, declMap, typeMap, debug );
    6962        }
    7063
    71         size_t replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug ) {
     64        void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug ) {
    7265                DeclMap declMap;
    73                 return replace( node, declMap, typeMap, debug );
     66                replace( node, declMap, typeMap, debug );
    7467        }
    7568
    76         size_t replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug ) {
     69        void replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug ) {
    7770                PassVisitor<ExprDeclReplacer> replacer( exprMap, debug );
    7871                node = maybeMutate( node, replacer );
    79                 return replacer.pass.replaced;
    8072        }
    8173
    8274        namespace {
    83                 DeclReplacer::DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug ) : declMap( declMap ), typeMap( typeMap ) , debug( debug ), replaced( 0 ) {}
     75                DeclReplacer::DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug ) : declMap( declMap ), typeMap( typeMap ) , debug( debug ) {}
    8476
    8577                // replace variable with new node from decl map
    … …  
    8779                        // 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)
    8880                        if ( declMap.count( varExpr->var ) ) {
    89                                 replaced++;
    9081                                auto replacement = declMap.at( varExpr->var );
    9182                                if ( debug ) {
    … …  
    9889                void DeclReplacer::previsit( TypeInstType * inst ) {
    9990                        if ( typeMap.count( inst->baseType ) ) {
    100                                 replaced++;
    10191                                auto replacement = typeMap.at( inst->baseType );
    10292                                if ( debug ) {
    … …  
    10797                }
    10898
    109                 ExprDeclReplacer::ExprDeclReplacer( const ExprMap & exprMap, bool debug ) : exprMap( exprMap ), debug( debug ), replaced( 0 ) {}
     99                ExprDeclReplacer::ExprDeclReplacer( const ExprMap & exprMap, bool debug ) : exprMap( exprMap ), debug( debug ) {}
    110100
    111101                Expression * ExprDeclReplacer::postmutate( VariableExpr * varExpr ) {
    112102                        if ( exprMap.count( varExpr->var ) ) {
    113                                 replaced++;
    114103                                Expression * replacement = exprMap.at( varExpr->var )->clone();
    115104                                if ( debug ) {

  • src/SynTree/DeclReplacer.h

    r54d4c0e r7c608d5  
    2828        typedef std::map< DeclarationWithType *, Expression * > ExprMap;
    2929
    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 );
     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 );
    3333
    34         size_t replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug = false);
     34        void 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.