Changeset 3cd5fdd


Ignore:
Timestamp:
Jun 5, 2019, 6:07:41 PM (3 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
c6a1e8a, d3b2c32, dd857bb
Parents:
99d4584 (diff), 8568319 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Aaron Moss <a3moss@…> (06/05/19 18:02:23)
git-committer:
Aaron Moss <a3moss@…> (06/05/19 18:07:41)
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
src
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Convert.cpp

    r99d4584 r3cd5fdd  
    749749                        break;
    750750                case ast::ConstantExpr::String:
    751                         rslt = new ConstantExpr{Constant::from_string( node->rep )};
     751                        rslt = new ConstantExpr{Constant{
     752                                get<Type>().accept1( node->result ),
     753                                node->rep,
     754                                (long long unsigned int)0
     755                        }};
    752756                        break;
    753757                }
     
    21502154                                GET_ACCEPT_1(result, Type),
    21512155                                old->constant.get_value(),
    2152                                 (unsigned long long) old->intValue()
     2156                                (unsigned long long) old->intValue(),
     2157                                ast::ConstantExpr::Kind::Integer
    21532158                        );
    21542159                } else if (isFloatlikeConstantType(old->result)) {
     
    21602165                        );
    21612166                } else if (isStringlikeConstantType(old->result)) {
    2162                         rslt = ast::ConstantExpr::from_string(
    2163                                 old->location,
    2164                                 old->constant.get_value()
     2167                        rslt = new ast::ConstantExpr(
     2168                                old->location,
     2169                                GET_ACCEPT_1(result, Type),
     2170                                old->constant.get_value(),
     2171                                0,
     2172                                ast::ConstantExpr::Kind::String
    21652173                        );
    21662174                }
  • src/AST/Node.cpp

    r99d4584 r3cd5fdd  
    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

    r99d4584 r3cd5fdd  
    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

    r99d4584 r3cd5fdd  
    2929#include "typeops.h"                     // for extractResultType
    3030#include "Unify.h"                       // for unify
     31#include "AST/Chain.hpp"
    3132#include "AST/Decl.hpp"
    3233#include "AST/Init.hpp"
     
    410411
    411412        void Resolver_old::previsit( ObjectDecl * objectDecl ) {
    412                 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that 
    413                 // class-variable initContext is changed multiple time because the LHS is analysed twice. 
    414                 // The second analysis changes initContext because of a function type can contain object 
    415                 // declarations in the return and parameter types. So each value of initContext is 
     413                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
     414                // class-variable initContext is changed multiple time because the LHS is analysed twice.
     415                // The second analysis changes initContext because of a function type can contain object
     416                // declarations in the return and parameter types. So each value of initContext is
    416417                // retained, so the type on the first analysis is preserved and used for selecting the RHS.
    417418                GuardValue( currentObject );
     
    450451
    451452        void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
    452                 // default value expressions have an environment which shouldn't be there and trips up 
     453                // default value expressions have an environment which shouldn't be there and trips up
    453454                // later passes.
    454455                // xxx - it might be necessary to somehow keep the information from this environment, but I
     
    11181119        }
    11191120
    1120         class Resolver_new final 
    1121         : public ast::WithSymbolTable, public ast::WithGuards, 
    1122           public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting, 
     1121        class Resolver_new final
     1122        : public ast::WithSymbolTable, public ast::WithGuards,
     1123          public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
    11231124          public ast::WithStmtsToAdd<> {
    1124        
     1125
    11251126                ast::ptr< ast::Type > functionReturn = nullptr;
    11261127                // ast::CurrentObject currentObject = nullptr;
    11271128                bool inEnumDecl = false;
    11281129
    1129         public: 
     1130        public:
    11301131                Resolver_new() = default;
    11311132                Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
     
    11701171
    11711172        const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) {
    1172                 // default value expressions have an environment which shouldn't be there and trips up 
     1173                // default value expressions have an environment which shouldn't be there and trips up
    11731174                // later passes.
    11741175                ast::ptr< ast::FunctionDecl > ret = functionDecl;
    11751176                for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
    11761177                        const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
    1177                        
     1178
    11781179                        if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
    11791180                                if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) {
    11801181                                        if ( init->value->env == nullptr ) continue;
    11811182                                        // clone initializer minus the initializer environment
    1182                                         strict_dynamic_cast< ast::SingleInit * >(
    1183                                                 strict_dynamic_cast< ast::ObjectDecl * >(
    1184                                                         ret.get_and_mutate()->type.get_and_mutate()->params[i].get_and_mutate()
    1185                                                 )->init.get_and_mutate()
    1186                                         )->value.get_and_mutate()->env = nullptr;
     1183                                        ast::chain_mutate( ret )
     1184                                                ( &ast::FunctionDecl::type )
     1185                                                        ( &ast::FunctionType::params )[i]
     1186                                                                ( &ast::ObjectDecl::init )
     1187                                                                        ( &ast::SingleInit::value )->env = nullptr;
     1188
     1189                                        assert( functionDecl != ret.get() || functionDecl->unique() );
     1190                                        assert( ! ret->type->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env );
    11871191                                }
    11881192                        }
  • src/SynTree/BaseSyntaxNode.h

    r99d4584 r3cd5fdd  
    4141  /// * Expressions should not finish with a newline, since the expression's parent has better information.
    4242        virtual void print( std::ostream & os, Indenter indent = {} ) const = 0;
    43   // void print( std::ostream & os, unsigned int indent ) {
    44   //   print( os, Indenter{ indent });
    45   // }
    4643};
    4744
  • src/SynTree/DeclReplacer.cc

    r99d4584 r3cd5fdd  
    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

    r99d4584 r3cd5fdd  
    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 ) {
  • src/main.cc

    r99d4584 r3cd5fdd  
    1010// Created On       : Fri May 15 23:12:02 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri May  3 16:10:52 2019
    13 // Update Count     : 599
     12// Last Modified On : Wed Jun  5 13:48:41 2019
     13// Update Count     : 600
    1414//
    1515
     
    406406
    407407
    408 static const char optstring[] = ":hlLmNn:pP:S:twW:D:F:";
     408static const char optstring[] = ":hlLmNnpP:S:twW:D:F:";
    409409
    410410enum { PreludeDir = 128 };
Note: See TracChangeset for help on using the changeset viewer.