Changes in / [c9b3a41:000ff2c]


Ignore:
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • doc/papers/general/evaluation/cfa-pair.c

    rc9b3a41 r000ff2c  
    22#include "fstream"
    33
    4 forall(otype R, otype S 
     4forall(otype R, otype S
    55        | { int ?==?(R, R); int ?<?(R, R); int ?<?(S, S); })
    66int ?<?(pair(R, S) p, pair(R, S) q) {
     
    88}
    99
    10 forall(otype R, otype S 
     10forall(otype R, otype S
    1111        | { int ?==?(R, R); int ?<?(R, R); int ?<=?(S, S); })
    1212int ?<=?(pair(R, S) p, pair(R, S) q) {
     
    2424}
    2525
    26 forall(otype R, otype S 
     26forall(otype R, otype S
    2727        | { int ?==?(R, R); int ?>?(R, R); int ?>?(S, S); })
    2828int ?>?(pair(R, S) p, pair(R, S) q) {
     
    3030}
    3131
    32 forall(otype R, otype S 
     32forall(otype R, otype S
    3333        | { int ?==?(R, R); int ?>?(R, R); int ?>=?(S, S); })
    3434int ?>=?(pair(R, S) p, pair(R, S) q) {
     
    3737
    3838forall(otype R, otype S)
    39 forall(dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, pair(R, S) ); })
     39forall(dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, R ); ostype & ?|?( ostype &, S ); })
    4040ostype & ?|?( ostype & os, pair(R, S) p ) {
    4141        return os | '[' | p.first | ',' | p.second | ']';
  • doc/papers/general/evaluation/cfa-stack.c

    rc9b3a41 r000ff2c  
    1616        stack_node(T) ** crnt = &s.head;
    1717        for ( stack_node(T) * next = t.head; next; next = next->next ) {
    18             *crnt = new( next->value, 0 );
     18                // *crnt = new( next->value, 0 );
     19                stack_node(T)* new_node = ((stack_node(T)*)malloc());
     20                (*new_node){ next->value }; /***/
     21                *crnt = new_node;
    1922                stack_node(T) * acrnt = *crnt;
    2023                crnt = &acrnt->next;
     
    3538
    3639forall(otype T) void push( stack(T) & s, T value ) {
    37     s.head = new( value, s.head );
     40        // s.head = new( value, s.head );
     41        stack_node(T)* new_node = ((stack_node(T)*)malloc());
     42        (*new_node){ value, s.head }; /***/
     43        s.head = new_node;
    3844}
    3945
     
    4248        s.head = n->next;
    4349        T v = n->value;
    44 //      ^n{};
    45         free( n );
     50        delete( n );
    4651        return v;
    4752}
  • src/InitTweak/FixInit.cc

    rc9b3a41 r000ff2c  
    187187                };
    188188
    189                 class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors> {
     189                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors>, public WithTypeSubstitution {
    190190                  public:
    191191                        FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
     
    448448                        ResolvExpr::findVoidExpression( resolved, indexer );
    449449                        assert( resolved );
    450                         if ( resolved->get_env() ) {
     450                        if ( resolved->env ) {
    451451                                // Extract useful information and discard new environments. Keeping them causes problems in PolyMutator passes.
    452                                 env->add( *resolved->get_env() );
    453                                 delete resolved->get_env();
    454                                 resolved->set_env( nullptr );
     452                                env->add( *resolved->env );
     453                                delete resolved->env;
     454                                resolved->env = nullptr;
    455455                        } // if
    456456                        delete stmt;
     
    636636                                // take relevant bindings from environment
    637637                                assert( ! dtor->env );
    638                                 dtor->env =  TypeSubstitution::newFromExpr( dtor, impCpCtorExpr->env );
     638                                dtor->env =  maybeClone( env );
    639639                                stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
    640640                        } // for
  • src/ResolvExpr/Resolver.cc

    rc9b3a41 r000ff2c  
    788788                stmtExpr->accept( resolver );
    789789                stmtExpr->computeResult();
     790                // xxx - aggregate the environments from all statements? Possibly in AlternativeFinder instead?
    790791        }
    791792
     
    793794                visit_children = false;
    794795                // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
    795                 maybeAccept( ctorInit->get_ctor(), *visitor );
    796                 maybeAccept( ctorInit->get_dtor(), *visitor );
     796                maybeAccept( ctorInit->ctor, *visitor );
     797                maybeAccept( ctorInit->dtor, *visitor );
    797798
    798799                // found a constructor - can get rid of C-style initializer
    799                 delete ctorInit->get_init();
    800                 ctorInit->set_init( NULL );
     800                delete ctorInit->init;
     801                ctorInit->init = nullptr;
    801802
    802803                // intrinsic single parameter constructors and destructors do nothing. Since this was
    803804                // implicitly generated, there's no way for it to have side effects, so get rid of it
    804805                // to clean up generated code.
    805                 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
    806                         delete ctorInit->get_ctor();
    807                         ctorInit->set_ctor( NULL );
    808                 }
    809 
    810                 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_dtor() ) ) {
    811                         delete ctorInit->get_dtor();
    812                         ctorInit->set_dtor( NULL );
     806                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {
     807                        delete ctorInit->ctor;
     808                        ctorInit->ctor = nullptr;
     809                }
     810
     811                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) {
     812                        delete ctorInit->dtor;
     813                        ctorInit->dtor = nullptr;
    813814                }
    814815
  • src/ResolvExpr/TypeEnvironment.cc

    rc9b3a41 r000ff2c  
    118118                        env.push_back( newClass );
    119119                } // for
     120        }
     121
     122        void TypeEnvironment::add( const TypeSubstitution & sub ) {
     123                EqvClass newClass;
     124                for ( auto p : sub ) {
     125                        newClass.vars.insert( p.first );
     126                        newClass.type = p.second->clone();
     127                        newClass.allowWidening = false;
     128                        // Minimal assumptions. Not technically correct, but might be good enough, and
     129                        // is the best we can do at the moment since information is lost in the
     130                        // transition to TypeSubstitution
     131                        newClass.data = TypeDecl::Data{ TypeDecl::Dtype, false };
     132                        add( newClass );
     133                }
    120134        }
    121135
  • src/ResolvExpr/TypeEnvironment.h

    rc9b3a41 r000ff2c  
    7676                void add( const EqvClass &eqvClass );
    7777                void add( const Type::ForallList &tyDecls );
     78                void add( const TypeSubstitution & sub );
    7879                template< typename SynTreeClass > int apply( SynTreeClass *&type ) const;
    7980                template< typename SynTreeClass > int applyFree( SynTreeClass *&type ) const;
  • src/SynTree/TypeSubstitution.h

    rc9b3a41 r000ff2c  
    8282        TypeEnvType typeEnv;
    8383        VarEnvType varEnv;
     84
     85  public:
     86        // has to come after declaration of typeEnv
     87        auto begin()       -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
     88        auto   end()       -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
     89        auto begin() const -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
     90        auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
    8491};
    8592
  • src/Tuples/TupleAssignment.cc

    rc9b3a41 r000ff2c  
    281281        }
    282282
    283         // removes environments from subexpressions within statement exprs, which could throw off later passes like those in Box which rely on PolyMutator.
     283        // removes environments from subexpressions within statement exprs, which could throw off later passes like those in Box which rely on PolyMutator, and adds the bindings to the compositeEnv
    284284        // xxx - maybe this should happen in alternative finder for every StmtExpr?
    285         // xxx - it's possible that these environments could contain some useful information. Maybe the right thing to do is aggregate the environments and pass the aggregate back to be added into the compositeEnv
    286285        struct EnvRemover {
    287286                void previsit( ExprStmt * stmt ) {
    288                         delete stmt->expr->env;
    289                         stmt->expr->env = nullptr;
    290                 }
     287                        assert( compositeEnv );
     288                        if ( stmt->expr->env ) {
     289                                compositeEnv->add( *stmt->expr->env );
     290                                delete stmt->expr->env;
     291                                stmt->expr->env = nullptr;
     292                        }
     293                }
     294
     295                ResolvExpr::TypeEnvironment * compositeEnv = nullptr;
    291296        };
    292297
     
    300305                        ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
    301306                        PassVisitor<EnvRemover> rm; // remove environments from subexpressions of StmtExprs
     307                        rm.pass.compositeEnv = &compositeEnv;
    302308                        ctorInit->accept( rm );
    303309                }
Note: See TracChangeset for help on using the changeset viewer.