Changeset f7a4f89


Ignore:
Timestamp:
Nov 24, 2017, 9:02:40 PM (4 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
cf966b5
Parents:
88ef2af (diff), 3de176d (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.
Message:

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

Location:
src
Files:
1 added
36 edited

Legend:

Unmodified
Added
Removed
  • src/GenPoly/Box.cc

    r88ef2af rf7a4f89  
    167167                        Expression *postmutate( OffsetofExpr *offsetofExpr );
    168168                        Expression *postmutate( OffsetPackExpr *offsetPackExpr );
     169                        void premutate( StructDecl * );
     170                        void premutate( UnionDecl * );
    169171
    170172                        void beginScope();
     
    178180                        /// adds type parameters to the layout call; will generate the appropriate parameters if needed
    179181                        void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams );
     182                        /// change the type of generic aggregate members to char[]
     183                        void mutateMembers( AggregateDecl * aggrDecl );
    180184
    181185                        /// Enters a new scope for type-variables, adding the type variables from ty
     
    14141418
    14151419                void PolyGenericCalculator::premutate( TypedefDecl *typedefDecl ) {
     1420                        assert(false);
    14161421                        beginTypeScope( typedefDecl->get_base() );
    14171422                }
     
    14601465                }
    14611466
     1467                /// converts polymorphic type T into a suitable monomorphic representation, currently: __attribute__((aligned(8)) char[size_T]
     1468                Type * polyToMonoType( Type * declType ) {
     1469                        Type * charType = new BasicType( Type::Qualifiers(), BasicType::Kind::Char);
     1470                        Expression * size = new NameExpr( sizeofName( mangleType(declType) ) );
     1471                        Attribute * aligned = new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } );
     1472                        return new ArrayType( Type::Qualifiers(), charType, size,
     1473                                true, false, std::list<Attribute *>{ aligned } );
     1474                }
     1475
     1476                void PolyGenericCalculator::mutateMembers( AggregateDecl * aggrDecl ) {
     1477                        std::set< std::string > genericParams;
     1478                        for ( TypeDecl * td : aggrDecl->parameters ) {
     1479                                genericParams.insert( td->name );
     1480                        }
     1481                        for ( Declaration * decl : aggrDecl->members ) {
     1482                                if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( decl ) ) {
     1483                                        Type * ty = replaceTypeInst( field->type, env );
     1484                                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
     1485                                                // do not try to monomorphize generic parameters
     1486                                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() && ! genericParams.count( typeInst->name ) ) {
     1487                                                        // polymorphic aggregate members should be converted into monomorphic members.
     1488                                                        // Using char[size_T] here respects the expected sizing rules of an aggregate type.
     1489                                                        Type * newType = polyToMonoType( field->type );
     1490                                                        delete field->type;
     1491                                                        field->type = newType;
     1492                                                }
     1493                                        }
     1494                                }
     1495                        }
     1496                }
     1497
     1498                void PolyGenericCalculator::premutate( StructDecl * structDecl ) {
     1499                        mutateMembers( structDecl );
     1500                }
     1501
     1502                void PolyGenericCalculator::premutate( UnionDecl * unionDecl ) {
     1503                        mutateMembers( unionDecl );
     1504                }
     1505
    14621506                void PolyGenericCalculator::premutate( DeclStmt *declStmt ) {
    14631507                        if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
     
    14651509                                        // change initialization of a polymorphic value object to allocate via a VLA
    14661510                                        // (alloca was previously used, but can't be safely used in loops)
    1467                                         Type *declType = objectDecl->get_type();
    1468                                         ObjectDecl *newBuf = new ObjectDecl( bufNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0,
    1469                                                 new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Kind::Char), new NameExpr( sizeofName( mangleType(declType) ) ),
    1470                                                 true, false, std::list<Attribute*>{ new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } ) } ), 0 );
     1511                                        ObjectDecl *newBuf = ObjectDecl::newObject( bufNamer.newName(), polyToMonoType( objectDecl->type ), nullptr );
    14711512                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) );
    14721513
  • src/GenPoly/InstantiateGeneric.cc

    r88ef2af rf7a4f89  
    2727#include "Common/utility.h"            // for deleteAll, cloneAll
    2828#include "GenPoly.h"                   // for isPolyType, typesPolyCompatible
     29#include "ResolvExpr/typeops.h"
    2930#include "ScopedSet.h"                 // for ScopedSet, ScopedSet<>::iterator
    3031#include "ScrubTyVars.h"               // for ScrubTyVars
     
    151152                return gt;
    152153        }
     154
     155        /// Add cast to dtype-static member expressions so that type information is not lost in GenericInstantiator
     156        struct FixDtypeStatic final {
     157                Expression * postmutate( MemberExpr * memberExpr );
     158
     159                template<typename AggrInst>
     160                Expression * fixMemberExpr( AggrInst * inst, MemberExpr * memberExpr );
     161        };
    153162
    154163        /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
     
    198207
    199208        void instantiateGeneric( std::list< Declaration* > &translationUnit ) {
     209                PassVisitor<FixDtypeStatic> fixer;
    200210                PassVisitor<GenericInstantiator> instantiator;
     211
     212                mutateAll( translationUnit, fixer );
    201213                mutateAll( translationUnit, instantiator );
     214        }
     215
     216        bool isDtypeStatic( const std::list< TypeDecl* >& baseParams ) {
     217                return std::all_of( baseParams.begin(), baseParams.end(), []( TypeDecl * td ) { return ! td->isComplete(); } );
    202218        }
    203219
     
    479495        }
    480496
     497        template< typename AggrInst >
     498        Expression * FixDtypeStatic::fixMemberExpr( AggrInst * inst, MemberExpr * memberExpr ) {
     499                // need to cast dtype-static member expressions to their actual type before that type is erased.
     500                auto & baseParams = *inst->get_baseParameters();
     501                if ( isDtypeStatic( baseParams ) ) {
     502                        if ( ! ResolvExpr::typesCompatible( memberExpr->result, memberExpr->member->get_type(), SymTab::Indexer() ) ) {
     503                                // type of member and type of expression differ, so add cast to actual type
     504                                return new CastExpr( memberExpr, memberExpr->result->clone() );
     505                        }
     506                }
     507                return memberExpr;
     508        }
     509
     510        Expression * FixDtypeStatic::postmutate( MemberExpr * memberExpr ) {
     511                Type * aggrType = memberExpr->aggregate->result;
     512                if ( isGenericType( aggrType ) ) {
     513                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( aggrType ) ) {
     514                                return fixMemberExpr( inst, memberExpr );
     515                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( aggrType ) ) {
     516                                return fixMemberExpr( inst, memberExpr );
     517                        }
     518                }
     519                return memberExpr;
     520        }
     521
    481522} // namespace GenPoly
    482523
  • src/InitTweak/FixInit.cc

    r88ef2af rf7a4f89  
    393393                        if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
    394394
    395                         // type may involve type variables, so apply type substitution to get temporary variable's actual type.
     395                        // type may involve type variables, so apply type substitution to get temporary variable's actual type,
     396                        // since result type may not be substituted (e.g., if the type does not appear in the parameter list)
    396397                        // Use applyFree so that types bound in function pointers are not substituted, e.g. in forall(dtype T) void (*)(T).
    397                         result = result->clone();
    398398                        env->applyFree( result );
    399399                        ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
     
    570570
    571571                        if ( returnDecl ) {
    572                                 UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) );
    573                                 assign->get_args().push_back( new VariableExpr( returnDecl ) );
    574                                 assign->get_args().push_back( callExpr );
    575                                 // know the result type of the assignment is the type of the LHS (minus the pointer), so
    576                                 // add that onto the assignment expression so that later steps have the necessary information
    577                                 assign->set_result( returnDecl->get_type()->clone() );
    578 
     572                                ApplicationExpr * assign = createBitwiseAssignment( new VariableExpr( returnDecl ), callExpr );
    579573                                Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
    580574                                // move env from callExpr to retExpr
     
    943937                }
    944938
    945                 void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
    946                         for ( auto d : decls ) {
    947                                 indexer.addId( d );
    948                         }
    949                 }
    950 
    951                 void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
    952                         for ( auto td : tds ) {
    953                                 indexer.addType( td );
    954                                 addIds( indexer, td->assertions );
    955                         }
    956                 }
    957 
    958939                void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
    959940                        GuardValue( function );
     
    1012993                                // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors
    1013994                                auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this]() { indexer.leaveScope(); } );
    1014                                 addTypes( indexer, function->type->forall );
    1015                                 addIds( indexer, function->type->returnVals );
    1016                                 addIds( indexer, function->type->parameters );
     995                                indexer.addFunctionType( function->type );
    1017996
    1018997                                // need to iterate through members in reverse in order for
     
    10291008                                        // insert and resolve default/copy constructor call for each field that's unhandled
    10301009                                        std::list< Statement * > stmt;
    1031                                         Expression * arg2 = 0;
     1010                                        Expression * arg2 = nullptr;
    10321011                                        if ( isCopyConstructor( function ) ) {
    10331012                                                // if copy ctor, need to pass second-param-of-this-function.field
     
    11611140                        assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
    11621141
    1163                         // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
    1164                         ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr );
    1165                         declsToAddBefore.push_back( tmp );
    1166 
    11671142                        // xxx - this can be TupleAssignExpr now. Need to properly handle this case.
    11681143                        ApplicationExpr * callExpr = strict_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() );
     
    11701145                        ctorExpr->set_callExpr( nullptr );
    11711146                        ctorExpr->set_env( nullptr );
     1147
     1148                        // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
     1149                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), callExpr->args.front()->result->clone(), nullptr );
     1150                        declsToAddBefore.push_back( tmp );
    11721151                        delete ctorExpr;
    11731152
  • src/InitTweak/InitTweak.cc

    r88ef2af rf7a4f89  
    1212#include "Parser/LinkageSpec.h"    // for Spec, isBuiltin, Intrinsic
    1313#include "ResolvExpr/typeops.h"    // for typesCompatibleIgnoreQualifiers
     14#include "SymTab/Autogen.h"
    1415#include "SymTab/Indexer.h"        // for Indexer
    1516#include "SynTree/Attribute.h"     // for Attribute
     
    524525        }
    525526
     527        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src ) {
     528                static FunctionDecl * assign = nullptr;
     529                if ( ! assign ) {
     530                        // temporary? Generate a fake assignment operator to represent bitwise assignments.
     531                        // This operator could easily exist as a real function, but it's tricky because nothing should resolve to this function.
     532                        TypeDecl * td = new TypeDecl( "T", noStorageClasses, nullptr, TypeDecl::Dtype, true );
     533                        assign = new FunctionDecl( "?=?", noStorageClasses, LinkageSpec::Intrinsic, SymTab::genAssignType( new TypeInstType( noQualifiers, td->name, td ) ), nullptr );
     534                }
     535                if ( dynamic_cast< ReferenceType * >( dst->result ) ) {
     536                        dst = new AddressExpr( dst );
     537                } else {
     538                        dst = new CastExpr( dst, new ReferenceType( noQualifiers, dst->result->clone() ) );
     539                }
     540                if ( dynamic_cast< ReferenceType * >( src->result ) ) {
     541                        src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
     542                }
     543                return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
     544        }
     545
    526546        class ConstExprChecker : public Visitor {
    527547        public:
  • src/InitTweak/InitTweak.h

    r88ef2af rf7a4f89  
    3535        /// returns the first parameter of a constructor/destructor/assignment function
    3636        ObjectDecl * getParamThis( FunctionType * ftype );
     37
     38        /// generate a bitwise assignment operation.
     39        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src );
    3740
    3841        /// transform Initializer into an argument list that can be passed to a call expression
  • src/ResolvExpr/Alternative.h

    r88ef2af rf7a4f89  
    3737                void print( std::ostream &os, Indenter indent = {} ) const;
    3838
     39                /// Returns the stored expression, but released from management of this Alternative
     40                Expression* release_expr() {
     41                        Expression* tmp = expr;
     42                        expr = nullptr;
     43                        return tmp;
     44                }
     45
    3946                Cost cost;
    4047                Cost cvtCost;
  • src/ResolvExpr/AlternativeFinder.cc

    r88ef2af rf7a4f89  
    187187                expr->accept( *this );
    188188                if ( failFast && alternatives.empty() ) {
     189                        PRINT(
     190                                std::cerr << "No reasonable alternatives for expression " << expr << std::endl;
     191                        )
    189192                        throw SemanticError( "No reasonable alternatives for expression ", expr );
    190193                }
     
    579582        /// State to iteratively build a match of parameter expressions to arguments
    580583        struct ArgPack {
    581                 std::size_t parent;                ///< Index of parent pack 
     584                std::size_t parent;                ///< Index of parent pack
    582585                std::unique_ptr<Expression> expr;  ///< The argument stored here
    583586                Cost cost;                         ///< The cost of this argument
     
    590593                unsigned nextExpl;                 ///< Index of next exploded element
    591594                unsigned explAlt;                  ///< Index of alternative for nextExpl > 0
    592                
     595
    593596                ArgPack()
    594597                        : parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0),
     598
    595599                          tupleStart(0), nextExpl(0), explAlt(0) {}
    596                
    597                 ArgPack(const TypeEnvironment& env, const AssertionSet& need, const AssertionSet& have, 
     600
     601                ArgPack(const TypeEnvironment& env, const AssertionSet& need, const AssertionSet& have,
    598602                                const OpenVarSet& openVars)
    599                         : parent(0), expr(), cost(Cost::zero), env(env), need(need), have(have), 
     603                        : parent(0), expr(), cost(Cost::zero), env(env), need(need), have(have),
    600604                          openVars(openVars), nextArg(0), tupleStart(0), nextExpl(0), explAlt(0) {}
    601                
    602                 ArgPack(std::size_t parent, Expression* expr, TypeEnvironment&& env, AssertionSet&& need, 
    603                                 AssertionSet&& have, OpenVarSet&& openVars, unsigned nextArg, 
    604                                 unsigned tupleStart = 0, Cost cost = Cost::zero, unsigned nextExpl = 0, 
     605
     606                ArgPack(std::size_t parent, Expression* expr, TypeEnvironment&& env, AssertionSet&& need,
     607                                AssertionSet&& have, OpenVarSet&& openVars, unsigned nextArg,
     608                                unsigned tupleStart = 0, Cost cost = Cost::zero, unsigned nextExpl = 0,
    605609                                unsigned explAlt = 0 )
    606                         : parent(parent), expr(expr->clone()), cost(cost), env(move(env)), need(move(need)), 
     610                        : parent(parent), expr(expr->clone()), cost(cost), env(move(env)), need(move(need)),
    607611                          have(move(have)), openVars(move(openVars)), nextArg(nextArg), tupleStart(tupleStart),
    608612                          nextExpl(nextExpl), explAlt(explAlt) {}
    609                
    610                 ArgPack(const ArgPack& o, TypeEnvironment&& env, AssertionSet&& need, AssertionSet&& have, 
     613
     614                ArgPack(const ArgPack& o, TypeEnvironment&& env, AssertionSet&& need, AssertionSet&& have,
    611615                                OpenVarSet&& openVars, unsigned nextArg, Cost added )
    612                         : parent(o.parent), expr(o.expr ? o.expr->clone() : nullptr), cost(o.cost + added), 
    613                           env(move(env)), need(move(need)), have(move(have)), openVars(move(openVars)), 
     616                        : parent(o.parent), expr(o.expr ? o.expr->clone() : nullptr), cost(o.cost + added),
     617                          env(move(env)), need(move(need)), have(move(have)), openVars(move(openVars)),
    614618                          nextArg(nextArg), tupleStart(o.tupleStart), nextExpl(0), explAlt(0) {}
    615                
     619
    616620                /// true iff this pack is in the middle of an exploded argument
    617621                bool hasExpl() const { return nextExpl > 0; }
     
    621625                        return args[nextArg-1][explAlt];
    622626                }
    623                          
     627
    624628                /// Ends a tuple expression, consolidating the appropriate actuals
    625629                void endTuple( const std::vector<ArgPack>& packs ) {
     
    641645
    642646        /// Instantiates an argument to match a formal, returns false if no results left
    643         bool instantiateArgument( Type* formalType, Initializer* initializer, 
    644                         const ExplodedArgs& args, std::vector<ArgPack>& results, std::size_t& genStart, 
     647        bool instantiateArgument( Type* formalType, Initializer* initializer,
     648                        const ExplodedArgs& args, std::vector<ArgPack>& results, std::size_t& genStart,
    645649                        const SymTab::Indexer& indexer, unsigned nTuples = 0 ) {
    646650                if ( TupleType* tupleType = dynamic_cast<TupleType*>( formalType ) ) {
     
    649653                        for ( Type* type : *tupleType ) {
    650654                                // xxx - dropping initializer changes behaviour from previous, but seems correct
    651                                 if ( ! instantiateArgument( 
    652                                                 type, nullptr, args, results, genStart, indexer, nTuples ) ) 
     655                                if ( ! instantiateArgument(
     656                                                type, nullptr, args, results, genStart, indexer, nTuples ) )
    653657                                        return false;
    654658                                nTuples = 0;
     
    676680                                        auto nextArg = results[i].nextArg;
    677681
    678                                         // use remainder of exploded tuple if present
     682                                        // use next element of exploded tuple if present
    679683                                        if ( results[i].hasExpl() ) {
    680684                                                const ExplodedActual& expl = results[i].getExpl( args );
    681                                                 const Alternative& actual = expl.alts[results[i].nextExpl];
    682                                                
    683                                                 TypeEnvironment env = results[i].env;
    684                                                 OpenVarSet openVars = results[i].openVars;
    685 
    686                                                 env.addActual( actual.env, openVars );
    687685
    688686                                                unsigned nextExpl = results[i].nextExpl + 1;
    689                                                 if ( nextExpl == expl.alts.size() ) {
     687                                                if ( nextExpl == expl.exprs.size() ) {
    690688                                                        nextExpl = 0;
    691689                                                }
    692690
    693691                                                results.emplace_back(
    694                                                         i, actual.expr, move(env), copy(results[i].need),
    695                                                         copy(results[i].have), move(openVars), nextArg, nTuples,
    696                                                         Cost::zero, nextExpl, results[i].explAlt );
    697                                                
     692                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
     693                                                        copy(results[i].need), copy(results[i].have),
     694                                                        copy(results[i].openVars), nextArg, nTuples, Cost::zero, nextExpl,
     695                                                        results[i].explAlt );
     696
    698697                                                continue;
    699698                                        }
    700                                        
     699
    701700                                        // finish result when out of arguments
    702701                                        if ( nextArg >= args.size() ) {
    703                                                 ArgPack newResult{ 
    704                                                         results[i].env, results[i].need, results[i].have, 
     702                                                ArgPack newResult{
     703                                                        results[i].env, results[i].need, results[i].have,
    705704                                                        results[i].openVars };
    706705                                                newResult.nextArg = nextArg;
     
    722721
    723722                                                        if ( results[i].tupleStart > 0 && Tuples::isTtype( argType ) ) {
    724                                                                 // the case where a ttype value is passed directly is special, 
     723                                                                // the case where a ttype value is passed directly is special,
    725724                                                                // e.g. for argument forwarding purposes
    726                                                                 // xxx - what if passing multiple arguments, last of which is 
     725                                                                // xxx - what if passing multiple arguments, last of which is
    727726                                                                //       ttype?
    728                                                                 // xxx - what would happen if unify was changed so that unifying 
    729                                                                 //       tuple 
    730                                                                 // types flattened both before unifying lists? then pass in 
     727                                                                // xxx - what would happen if unify was changed so that unifying
     728                                                                //       tuple
     729                                                                // types flattened both before unifying lists? then pass in
    731730                                                                // TupleType (ttype) below.
    732731                                                                --newResult.tupleStart;
     
    739738
    740739                                                // check unification for ttype before adding to final
    741                                                 if ( unify( ttype, argType, newResult.env, newResult.need, newResult.have, 
     740                                                if ( unify( ttype, argType, newResult.env, newResult.need, newResult.have,
    742741                                                                newResult.openVars, indexer ) ) {
    743742                                                        finalResults.push_back( move(newResult) );
    744743                                                }
    745                                                
     744
    746745                                                continue;
    747746                                        }
     
    750749                                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
    751750                                                const ExplodedActual& expl = args[nextArg][j];
    752                                        
     751
    753752                                                // fresh copies of parent parameters for this iteration
    754753                                                TypeEnvironment env = results[i].env;
     
    758757
    759758                                                // skip empty tuple arguments by (near-)cloning parent into next gen
    760                                                 if ( expl.alts.empty() ) {
     759                                                if ( expl.exprs.empty() ) {
    761760                                                        results.emplace_back(
    762                                                                 results[i], move(env), copy(results[i].need), 
     761                                                                results[i], move(env), copy(results[i].need),
    763762                                                                copy(results[i].have), move(openVars), nextArg + 1, expl.cost );
    764                                                        
     763
    765764                                                        continue;
    766765                                                }
     
    768767                                                // add new result
    769768                                                results.emplace_back(
    770                                                         i, expl.alts.front().expr, move(env), copy(results[i].need),
    771                                                         copy(results[i].have), move(openVars), nextArg + 1, 
    772                                                         nTuples, expl.cost, expl.alts.size() == 1 ? 0 : 1, j );
     769                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
     770                                                        copy(results[i].have), move(openVars), nextArg + 1,
     771                                                        nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    773772                                        }
    774773                                }
     
    794793                        if ( results[i].hasExpl() ) {
    795794                                const ExplodedActual& expl = results[i].getExpl( args );
    796                                 const Alternative& actual = expl.alts[results[i].nextExpl];
    797                                
     795                                Expression* expr = expl.exprs[results[i].nextExpl].get();
     796
    798797                                TypeEnvironment env = results[i].env;
    799798                                AssertionSet need = results[i].need, have = results[i].have;
    800799                                OpenVarSet openVars = results[i].openVars;
    801800
    802                                 env.addActual( actual.env, openVars );
    803                                 Type* actualType = actual.expr->get_result();
     801                                Type* actualType = expr->get_result();
    804802
    805803                                PRINT(
     
    810808                                        std::cerr << std::endl;
    811809                                )
    812                                
     810
    813811                                if ( unify( formalType, actualType, env, need, have, openVars, indexer ) ) {
    814812                                        unsigned nextExpl = results[i].nextExpl + 1;
    815                                         if ( nextExpl == expl.alts.size() ) {
     813                                        if ( nextExpl == expl.exprs.size() ) {
    816814                                                nextExpl = 0;
    817815                                        }
    818                                        
    819                                         results.emplace_back( 
    820                                                 i, actual.expr, move(env), move(need), move(have), move(openVars),
    821                                                 nextArg, nTuples, Cost::zero, nextExpl, results[i].explAlt );
     816
     817                                        results.emplace_back(
     818                                                i, expr, move(env), move(need), move(have), move(openVars), nextArg,
     819                                                nTuples, Cost::zero, nextExpl, results[i].explAlt );
    822820                                }
    823821
    824822                                continue;
    825823                        }
    826                        
     824
    827825                        // use default initializers if out of arguments
    828826                        if ( nextArg >= args.size() ) {
     
    833831                                                OpenVarSet openVars = results[i].openVars;
    834832
    835                                                 if ( unify( formalType, cnst->get_type(), env, need, have, openVars, 
     833                                                if ( unify( formalType, cnst->get_type(), env, need, have, openVars,
    836834                                                                indexer ) ) {
    837835                                                        results.emplace_back(
    838                                                                 i, cnstExpr, move(env), move(need), move(have), 
     836                                                                i, cnstExpr, move(env), move(need), move(have),
    839837                                                                move(openVars), nextArg, nTuples );
    840838                                                }
     
    855853
    856854                                env.addActual( expl.env, openVars );
    857                                
     855
    858856                                // skip empty tuple arguments by (near-)cloning parent into next gen
    859                                 if ( expl.alts.empty() ) {
     857                                if ( expl.exprs.empty() ) {
    860858                                        results.emplace_back(
    861                                                 results[i], move(env), move(need), move(have), move(openVars), 
     859                                                results[i], move(env), move(need), move(have), move(openVars),
    862860                                                nextArg + 1, expl.cost );
    863861
     
    866864
    867865                                // consider only first exploded actual
    868                                 const Alternative& actual = expl.alts.front();
    869                                 Type* actualType = actual.expr->get_result()->clone();
     866                                Expression* expr = expl.exprs.front().get();
     867                                Type* actualType = expr->get_result()->clone();
    870868
    871869                                PRINT(
     
    881879                                        // add new result
    882880                                        results.emplace_back(
    883                                                 i, actual.expr, move(env), move(need), move(have), move(openVars),
    884                                                 nextArg + 1, nTuples, expl.cost, expl.alts.size() == 1 ? 0 : 1, j );
     881                                                i, expr, move(env), move(need), move(have), move(openVars), nextArg + 1,
     882                                                nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    885883                                }
    886884                        }
     
    889887                // reset for next parameter
    890888                genStart = genEnd;
    891                
     889
    892890                return genEnd != results.size();
    893891        }
    894892
    895893        template<typename OutputIterator>
    896         void AlternativeFinder::validateFunctionAlternative( const Alternative &func, ArgPack& result, 
     894        void AlternativeFinder::validateFunctionAlternative( const Alternative &func, ArgPack& result,
    897895                        const std::vector<ArgPack>& results, OutputIterator out ) {
    898896                ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
     
    944942                for ( DeclarationWithType* formal : funcType->get_parameters() ) {
    945943                        ObjectDecl* obj = strict_dynamic_cast< ObjectDecl* >( formal );
    946                         if ( ! instantiateArgument( 
     944                        if ( ! instantiateArgument(
    947945                                        obj->get_type(), obj->get_init(), args, results, genStart, indexer ) )
    948946                                return;
     
    962960                                        if ( results[i].hasExpl() ) {
    963961                                                const ExplodedActual& expl = results[i].getExpl( args );
    964                                                 const Alternative& actual = expl.alts[results[i].nextExpl];
    965                                                
    966                                                 TypeEnvironment env = results[i].env;
    967                                                 OpenVarSet openVars = results[i].openVars;
    968 
    969                                                 env.addActual( actual.env, openVars );
    970962
    971963                                                unsigned nextExpl = results[i].nextExpl + 1;
    972                                                 if ( nextExpl == expl.alts.size() ) {
     964                                                if ( nextExpl == expl.exprs.size() ) {
    973965                                                        nextExpl = 0;
    974966                                                }
    975967
    976968                                                results.emplace_back(
    977                                                         i, actual.expr, move(env), copy(results[i].need),
    978                                                         copy(results[i].have), move(openVars), nextArg, 0,
    979                                                         Cost::zero, nextExpl, results[i].explAlt );
    980                                                
     969                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
     970                                                        copy(results[i].need), copy(results[i].have),
     971                                                        copy(results[i].openVars), nextArg, 0, Cost::zero, nextExpl,
     972                                                        results[i].explAlt );
     973
    981974                                                continue;
    982975                                        }
     
    1000993
    1001994                                                // skip empty tuple arguments by (near-)cloning parent into next gen
    1002                                                 if ( expl.alts.empty() ) {
    1003                                                         results.emplace_back( 
    1004                                                                 results[i], move(env), copy(results[i].need), 
     995                                                if ( expl.exprs.empty() ) {
     996                                                        results.emplace_back(
     997                                                                results[i], move(env), copy(results[i].need),
    1005998                                                                copy(results[i].have), move(openVars), nextArg + 1, expl.cost );
    1006                                                        
     999
    10071000                                                        continue;
    10081001                                                }
     
    10101003                                                // add new result
    10111004                                                results.emplace_back(
    1012                                                         i, expl.alts.front().expr, move(env), copy(results[i].need),
    1013                                                         copy(results[i].have), move(openVars), nextArg + 1, 0, 
    1014                                                         expl.cost, expl.alts.size() == 1 ? 0 : 1, j );
     1005                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
     1006                                                        copy(results[i].have), move(openVars), nextArg + 1, 0,
     1007                                                        expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    10151008                                        }
    10161009                                }
     
    10611054                        auto& argE = argExpansions.back();
    10621055                        argE.reserve( arg.alternatives.size() );
    1063                        
     1056
    10641057                        for ( const Alternative& actual : arg ) {
    10651058                                argE.emplace_back( actual, indexer );
     
    11611154                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( winners ) );
    11621155
    1163                 // function may return struct or union value, in which case we need to add alternatives 
    1164                 // for implicitconversions to each of the anonymous members, must happen after findMinCost 
     1156                // function may return struct or union value, in which case we need to add alternatives
     1157                // for implicitconversions to each of the anonymous members, must happen after findMinCost
    11651158                // since anon conversions are never the cheapest expression
    11661159                for ( const Alternative & alt : winners ) {
     
    11931186                for ( Alternative& alt : finder.alternatives ) {
    11941187                        if ( isLvalue( alt.expr ) ) {
    1195                                 alternatives.push_back( 
     1188                                alternatives.push_back(
    11961189                                        Alternative{ new AddressExpr( alt.expr->clone() ), alt.env, alt.cost } );
    11971190                        } // if
     
    12421235
    12431236                AltList candidates;
    1244                 for ( Alternative& alt : finder.alternatives ) {
     1237                for ( Alternative & alt : finder.alternatives ) {
    12451238                        AssertionSet needAssertions, haveAssertions;
    12461239                        OpenVarSet openVars;
     
    12551248                        // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
    12561249                        // unification run for side-effects
    1257                         unify( castExpr->get_result(), alt.expr->get_result(), alt.env, needAssertions, 
     1250                        unify( castExpr->get_result(), alt.expr->get_result(), alt.env, needAssertions,
    12581251                                haveAssertions, openVars, indexer );
    1259                         Cost thisCost = castCost( alt.expr->get_result(), castExpr->get_result(), indexer, 
     1252                        Cost thisCost = castCost( alt.expr->get_result(), castExpr->get_result(), indexer,
    12601253                                alt.env );
     1254                        PRINT(
     1255                                std::cerr << "working on cast with result: " << castExpr->result << std::endl;
     1256                                std::cerr << "and expr type: " << alt.expr->result << std::endl;
     1257                                std::cerr << "env: " << alt.env << std::endl;
     1258                        )
    12611259                        if ( thisCost != Cost::infinity ) {
     1260                                PRINT(
     1261                                        std::cerr << "has finite cost." << std::endl;
     1262                                )
    12621263                                // count one safe conversion for each value that is thrown away
    12631264                                thisCost.incSafe( discardedValues );
    1264                                 Alternative newAlt( restructureCast( alt.expr->clone(), toType ), alt.env, 
     1265                                Alternative newAlt( restructureCast( alt.expr->clone(), toType ), alt.env,
    12651266                                        alt.cost, thisCost );
    1266                                 inferParameters( needAssertions, haveAssertions, newAlt, openVars, 
     1267                                inferParameters( needAssertions, haveAssertions, newAlt, openVars,
    12671268                                        back_inserter( candidates ) );
    12681269                        } // if
     
    15531554        void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) {
    15541555                std::vector< AlternativeFinder > subExprAlternatives;
    1555                 findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), 
     1556                findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(),
    15561557                        back_inserter( subExprAlternatives ) );
    15571558                std::vector< AltList > possibilities;
    1558                 combos( subExprAlternatives.begin(), subExprAlternatives.end(), 
     1559                combos( subExprAlternatives.begin(), subExprAlternatives.end(),
    15591560                        back_inserter( possibilities ) );
    15601561                for ( const AltList& alts : possibilities ) {
     
    15641565                        TypeEnvironment compositeEnv;
    15651566                        simpleCombineEnvironments( alts.begin(), alts.end(), compositeEnv );
    1566                         alternatives.push_back( 
     1567                        alternatives.push_back(
    15671568                                Alternative{ new TupleExpr( exprs ), compositeEnv, sumCost( alts ) } );
    15681569                } // for
  • src/ResolvExpr/AlternativeFinder.h

    r88ef2af rf7a4f89  
    3232
    3333namespace ResolvExpr {
    34         class ArgPack;
    35        
    36         /// First index is which argument, second index is which alternative for that argument, 
     34        struct ArgPack;
     35
     36        /// First index is which argument, second index is which alternative for that argument,
    3737        /// third index is which exploded element of that alternative
    3838        using ExplodedArgs = std::vector< std::vector< ExplodedActual > >;
    39        
     39
    4040        class AlternativeFinder : public Visitor {
    4141          public:
     
    4343
    4444                AlternativeFinder( const AlternativeFinder& o )
    45                         : indexer(o.indexer), alternatives(o.alternatives), env(o.env), 
     45                        : indexer(o.indexer), alternatives(o.alternatives), env(o.env),
    4646                          targetType(o.targetType) {}
    47                
     47
    4848                AlternativeFinder( AlternativeFinder&& o )
    49                         : indexer(o.indexer), alternatives(std::move(o.alternatives)), env(o.env), 
     49                        : indexer(o.indexer), alternatives(std::move(o.alternatives)), env(o.env),
    5050                          targetType(o.targetType) {}
    51                
     51
    5252                AlternativeFinder& operator= ( const AlternativeFinder& o ) {
    5353                        if (&o == this) return *this;
    54                        
     54
    5555                        // horrific nasty hack to rebind references...
    5656                        alternatives.~AltList();
     
    6161                AlternativeFinder& operator= ( AlternativeFinder&& o ) {
    6262                        if (&o == this) return *this;
    63                        
     63
    6464                        // horrific nasty hack to rebind references...
    6565                        alternatives.~AltList();
  • src/ResolvExpr/ExplodedActual.cc

    r88ef2af rf7a4f89  
    2020namespace ResolvExpr {
    2121        ExplodedActual::ExplodedActual( const Alternative& actual, const SymTab::Indexer& indexer )
    22                         : env(actual.env), cost(actual.cost), alts() {
    23                 Tuples::explode( actual, indexer, back_inserter( alts ) );
     22                        : env(actual.env), cost(actual.cost), exprs() {
     23                Tuples::explode( actual, indexer, *this );
    2424        }
    2525}
  • src/ResolvExpr/ExplodedActual.h

    r88ef2af rf7a4f89  
    1616#pragma once
    1717
     18#include <memory>
     19#include <vector>
     20
    1821#include "Alternative.h"      // for Alternative, AltList
    1922#include "Cost.h"             // for Cost
     
    2629                TypeEnvironment env;
    2730                Cost cost;
    28                 AltList alts;  // TODO flatten this down to vector<unique_ptr<Expression>>
     31                std::vector< std::unique_ptr<Expression> > exprs;
    2932
    30                 ExplodedActual() : env(), cost(Cost::zero), alts() {}
     33                ExplodedActual() : env(), cost(Cost::zero), exprs() {}
    3134
    32                 ExplodedActual( const Alternative& actual, const SymTab::Indexer& indexer );   
     35                ExplodedActual( const Alternative& actual, const SymTab::Indexer& indexer );
    3336        };
    3437}
  • src/ResolvExpr/PtrsAssignable.cc

    r88ef2af rf7a4f89  
    6868
    6969        void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) {
    70                 if ( ! dynamic_cast< FunctionType* >( dest ) ) {
    71                         // T * = void * is safe for any T that is not a function type.
    72                         // xxx - this should be unsafe...
    73                         result = 1;
    74                 } // if
     70                // T * = void * is disallowed - this is a change from C, where any
     71                // void * can be assigned or passed to a non-void pointer without a cast.
    7572        }
    7673
  • src/ResolvExpr/TypeEnvironment.cc

    r88ef2af rf7a4f89  
    212212        }
    213213
     214        std::ostream & operator<<( std::ostream & out, const TypeEnvironment & env ) {
     215                env.print( out );
     216                return out;
     217        }
    214218} // namespace ResolvExpr
    215219
  • src/ResolvExpr/TypeEnvironment.h

    r88ef2af rf7a4f89  
    8686                TypeEnvironment *clone() const { return new TypeEnvironment( *this ); }
    8787
    88                 /// Iteratively adds the environment of a new actual (with allowWidening = false), 
     88                /// Iteratively adds the environment of a new actual (with allowWidening = false),
    8989                /// and extracts open variables.
    9090                void addActual( const TypeEnvironment& actualEnv, OpenVarSet& openVars );
     
    114114                return sub.applyFree( type );
    115115        }
     116
     117        std::ostream & operator<<( std::ostream & out, const TypeEnvironment & env );
    116118} // namespace ResolvExpr
    117119
  • src/SymTab/Autogen.cc

    r88ef2af rf7a4f89  
    6262                void previsit( FunctionDecl * functionDecl );
    6363
    64                 void previsit( FunctionType * ftype );
    65                 void previsit( PointerType * ptype );
    66 
    6764                void previsit( CompoundStmt * compoundStmt );
    6865
     
    7269                unsigned int functionNesting = 0;     // current level of nested functions
    7370
    74                 InitTweak::ManagedTypes managedTypes;
    7571                std::vector< FuncData > data;
    7672        };
     
    622618        // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
    623619        void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) {
    624                 visit_children = false;
    625620                if ( ! typeDecl->base ) return;
    626621
     
    628623                TypeFuncGenerator gen( typeDecl, &refType, data, functionNesting, indexer );
    629624                generateFunctions( gen, declsToAddAfter );
    630         }
    631 
    632         void AutogenerateRoutines::previsit( FunctionType *) {
    633                 // ensure that we don't add assignment ops for types defined as part of the function
    634                 visit_children = false;
    635         }
    636 
    637         void AutogenerateRoutines::previsit( PointerType *) {
    638                 // ensure that we don't add assignment ops for types defined as part of the pointer
    639                 visit_children = false;
     625
    640626        }
    641627
     
    645631        }
    646632
    647         void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) {
    648                 visit_children = false;
    649                 // record the existence of this function as appropriate
    650                 managedTypes.handleDWT( functionDecl );
    651 
    652                 maybeAccept( functionDecl->type, *visitor );
     633        void AutogenerateRoutines::previsit( FunctionDecl * ) {
     634                // Track whether we're currently in a function.
     635                // Can ignore function type idiosyncrasies, because function type can never
     636                // declare a new type.
    653637                functionNesting += 1;
    654                 maybeAccept( functionDecl->statements, *visitor );
    655                 functionNesting -= 1;
     638                GuardAction( [this]()  { functionNesting -= 1; } );
    656639        }
    657640
    658641        void AutogenerateRoutines::previsit( CompoundStmt * ) {
    659                 GuardScope( managedTypes );
    660642                GuardScope( structsDone );
    661643        }
  • src/SymTab/Autogen.h

    r88ef2af rf7a4f89  
    5656        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
    5757        template< typename OutputIterator >
    58         Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true );
     58        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
    5959
    6060        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
    6161        /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
    6262        template< typename OutputIterator >
    63         Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, bool addCast = false ) {
     63        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
    6464                bool isReferenceCtorDtor = false;
    6565                if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
     
    6868                        fname = "?=?";
    6969                        dstParam = new AddressExpr( dstParam );
    70                         addCast = false;
     70                        addCast = nullptr;
    7171                        isReferenceCtorDtor = true;
    7272                }
     
    8383                        // remove lvalue as a qualifier, this can change to
    8484                        //   type->get_qualifiers() = Type::Qualifiers();
    85                         assert( type );
    86                         Type * castType = type->clone();
     85                        Type * castType = addCast->clone();
    8786                        castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
    8887                        // castType->set_lvalue( true ); // xxx - might not need this
     
    115114        /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
    116115        template< typename OutputIterator >
    117         void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
     116        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
    118117                static UniqueName indexName( "_index" );
    119118
    120119                // for a flexible array member nothing is done -- user must define own assignment
    121                 if ( ! array->get_dimension() ) return ;
     120                if ( ! array->get_dimension() ) return;
     121
     122                if ( addCast ) {
     123                        // peel off array layer from cast
     124                        ArrayType * at = strict_dynamic_cast< ArrayType * >( addCast );
     125                        addCast = at->base;
     126                }
    122127
    123128                Expression * begin, * end, * update, * cmp;
     
    171176
    172177        template< typename OutputIterator >
    173         Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
     178        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
    174179                if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
    175180                        genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
     
    191196                if ( isUnnamedBitfield( obj ) ) return;
    192197
    193                 bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) );
     198                Type * addCast = nullptr;
     199                if ( (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) ) ) {
     200                        assert( dstParam->result );
     201                        addCast = dstParam->result;
     202                }
    194203                std::list< Statement * > stmts;
    195204                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->type, addCast, forward );
  • src/SymTab/Indexer.cc

    r88ef2af rf7a4f89  
    567567        }
    568568
     569        void Indexer::addIds( const std::list< DeclarationWithType * > & decls ) {
     570                for ( auto d : decls ) {
     571                        addId( d );
     572                }
     573        }
     574
     575        void Indexer::addTypes( const std::list< TypeDecl * > & tds ) {
     576                for ( auto td : tds ) {
     577                        addType( td );
     578                        addIds( td->assertions );
     579                }
     580        }
     581
     582        void Indexer::addFunctionType( FunctionType * ftype ) {
     583                addTypes( ftype->forall );
     584                addIds( ftype->returnVals );
     585                addIds( ftype->parameters );
     586        }
     587
    569588        void Indexer::enterScope() {
    570589                ++scope;
  • src/SymTab/Indexer.h

    r88ef2af rf7a4f89  
    7676                void addTrait( TraitDecl *decl );
    7777
     78                /// convenience function for adding a list of Ids to the indexer
     79                void addIds( const std::list< DeclarationWithType * > & decls );
     80
     81                /// convenience function for adding a list of forall parameters to the indexer
     82                void addTypes( const std::list< TypeDecl * > & tds );
     83
     84                /// convenience function for adding all of the declarations in a function type to the indexer
     85                void addFunctionType( FunctionType * ftype );
     86
    7887                bool doDebug = false; ///< Display debugging trace?
    7988          private:
  • src/SymTab/Validate.cc

    r88ef2af rf7a4f89  
    124124
    125125        /// Associates forward declarations of aggregates with their definitions
    126         struct LinkReferenceToTypes final : public WithIndexer {
     126        struct LinkReferenceToTypes final : public WithIndexer, public WithGuards {
    127127                LinkReferenceToTypes( const Indexer *indexer );
    128128                void postvisit( TypeInstType *typeInst );
     
    137137                void postvisit( UnionDecl *unionDecl );
    138138                void postvisit( TraitDecl * traitDecl );
     139
     140                void previsit( StructDecl *structDecl );
     141                void previsit( UnionDecl *unionDecl );
     142
     143                void renameGenericParams( std::list< TypeDecl * > & params );
    139144
    140145          private:
     
    147152                ForwardStructsType forwardStructs;
    148153                ForwardUnionsType forwardUnions;
     154                /// true if currently in a generic type body, so that type parameter instances can be renamed appropriately
     155                bool inGeneric = false;
    149156        };
    150157
     
    561568        }
    562569
     570        void LinkReferenceToTypes::renameGenericParams( std::list< TypeDecl * > & params ) {
     571                // rename generic type parameters uniquely so that they do not conflict with user-defined function forall parameters, e.g.
     572                //   forall(otype T)
     573                //   struct Box {
     574                //     T x;
     575                //   };
     576                //   forall(otype T)
     577                //   void f(Box(T) b) {
     578                //     ...
     579                //   }
     580                // The T in Box and the T in f are different, so internally the naming must reflect that.
     581                GuardValue( inGeneric );
     582                inGeneric = ! params.empty();
     583                for ( TypeDecl * td : params ) {
     584                        td->name = "__" + td->name + "_generic_";
     585                }
     586        }
     587
     588        void LinkReferenceToTypes::previsit( StructDecl * structDecl ) {
     589                renameGenericParams( structDecl->parameters );
     590        }
     591
     592        void LinkReferenceToTypes::previsit( UnionDecl * unionDecl ) {
     593                renameGenericParams( unionDecl->parameters );
     594        }
     595
    563596        void LinkReferenceToTypes::postvisit( StructDecl *structDecl ) {
    564597                // visit struct members first so that the types of self-referencing members are updated properly
     
    588621
    589622        void LinkReferenceToTypes::postvisit( TypeInstType *typeInst ) {
     623                // ensure generic parameter instances are renamed like the base type
     624                if ( inGeneric && typeInst->baseType ) typeInst->name = typeInst->baseType->name;
    590625                if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->get_name() ) ) {
    591626                        if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
  • src/SynTree/Expression.cc

    r88ef2af rf7a4f89  
    8888        Type * type = var->get_type()->clone();
    8989        type->set_lvalue( true );
     90
     91        // xxx - doesn't quite work yet - get different alternatives with the same cost
     92
     93        // // enumerators are not lvalues
     94        // if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( var->get_type() ) ) {
     95        //      assert( inst->baseEnum );
     96        //      EnumDecl * decl = inst->baseEnum;
     97        //      for ( Declaration * member : decl->members ) {
     98        //              if ( member == _var ) {
     99        //                      type->set_lvalue( false );
     100        //              }
     101        //      }
     102        // }
     103
    90104        set_result( type );
    91105}
     
    324338                        return makeSub( refType->get_base() );
    325339                } else if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
    326                         return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
     340                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
    327341                } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) {
    328                         return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
     342                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
    329343                } else {
    330344                        assertf( false, "makeSub expects struct or union type for aggregate, but got: %s", toString( t ).c_str() );
  • src/Tuples/Explode.h

    r88ef2af rf7a4f89  
    1616#pragma once
    1717
    18 #include <iterator>                  // for back_inserter, back_insert_iterator
     18#include <iterator>                     // for back_inserter, back_insert_iterator
     19#include <utility>                      // for forward
    1920
    20 #include "ResolvExpr/Alternative.h"  // for Alternative, AltList
    21 #include "SynTree/Expression.h"      // for Expression, UniqueExpr, AddressExpr
    22 #include "SynTree/Type.h"            // for TupleType, Type
    23 #include "Tuples.h"                  // for maybeImpure
     21#include "ResolvExpr/Alternative.h"     // for Alternative, AltList
     22#include "ResolvExpr/ExplodedActual.h"  // for ExplodedActual
     23#include "SynTree/Expression.h"         // for Expression, UniqueExpr, AddressExpr
     24#include "SynTree/Type.h"               // for TupleType, Type
     25#include "Tuples.h"                     // for maybeImpure
    2426
    2527namespace SymTab {
     
    3941        }
    4042
     43        /// Append alternative to an OutputIterator of Alternatives
     44        template<typename OutputIterator>
     45        void append( OutputIterator out, Expression* expr, const ResolvExpr::TypeEnvironment& env,
     46                        const ResolvExpr::Cost& cost, const ResolvExpr::Cost& cvtCost ) {
     47                *out++ = ResolvExpr::Alternative{ expr, env, cost, cvtCost };
     48        }
     49
     50        /// Append alternative to an ExplodedActual
     51        static inline void append( ResolvExpr::ExplodedActual& ea, Expression* expr,
     52                        const ResolvExpr::TypeEnvironment&, const ResolvExpr::Cost&, const ResolvExpr::Cost& ) {
     53                ea.exprs.emplace_back( expr );
     54                /// xxx -- merge environment, cost?
     55        }
     56
    4157        /// helper function used by explode
    42         template< typename OutputIterator >
    43         void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign ) {
     58        template< typename Output >
     59        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt,
     60                        const SymTab::Indexer & indexer, Output&& out, bool isTupleAssign ) {
    4461                if ( isTupleAssign ) {
    4562                        // tuple assignment needs CastExprs to be recursively exploded to easily get at all of the components
    4663                        if ( CastExpr * castExpr = isReferenceCast( expr ) ) {
    4764                                ResolvExpr::AltList alts;
    48                                 explodeUnique( castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
     65                                explodeUnique(
     66                                        castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
    4967                                for ( ResolvExpr::Alternative & alt : alts ) {
    5068                                        // distribute reference cast over all components
    51                                         alt.expr = distributeReference( alt.expr );
    52                                         *out++ = alt;
     69                                        append( std::forward<Output>(out), distributeReference( alt.release_expr() ),
     70                                                alt.env, alt.cost, alt.cvtCost );
    5371                                }
    5472                                // in tuple assignment, still need to handle the other cases, but only if not already handled here (don't want to output too many alternatives)
     
    6179                                // can open tuple expr and dump its exploded components
    6280                                for ( Expression * expr : tupleExpr->get_exprs() ) {
    63                                         explodeUnique( expr, alt, indexer, out, isTupleAssign );
     81                                        explodeUnique( expr, alt, indexer, std::forward<Output>(out), isTupleAssign );
    6482                                }
    6583                        } else {
     
    7795                                for ( unsigned int i = 0; i < tupleType->size(); i++ ) {
    7896                                        TupleIndexExpr * idx = new TupleIndexExpr( arg->clone(), i );
    79                                         explodeUnique( idx, alt, indexer, out, isTupleAssign );
     97                                        explodeUnique( idx, alt, indexer, std::forward<Output>(out), isTupleAssign );
    8098                                        delete idx;
    8199                                }
     
    84102                } else {
    85103                        // atomic (non-tuple) type - output a clone of the expression in a new alternative
    86                         *out++ = ResolvExpr::Alternative( expr->clone(), alt.env, alt.cost, alt.cvtCost );
     104                        append( std::forward<Output>(out), expr->clone(), alt.env, alt.cost, alt.cvtCost );
    87105                }
    88106        }
    89107
    90108        /// expands a tuple-valued alternative into multiple alternatives, each with a non-tuple-type
    91         template< typename OutputIterator >
    92         void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
    93                 explodeUnique( alt.expr, alt, indexer, out, isTupleAssign );
     109        template< typename Output >
     110        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer,
     111                        Output&& out, bool isTupleAssign = false ) {
     112                explodeUnique( alt.expr, alt, indexer, std::forward<Output>(out), isTupleAssign );
    94113        }
    95114
    96115        // explode list of alternatives
    97         template< typename AltIterator, typename OutputIterator >
    98         void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
     116        template< typename AltIterator, typename Output >
     117        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer,
     118                        Output&& out, bool isTupleAssign = false ) {
    99119                for ( ; altBegin != altEnd; ++altBegin ) {
    100                         explode( *altBegin, indexer, out, isTupleAssign );
     120                        explode( *altBegin, indexer, std::forward<Output>(out), isTupleAssign );
    101121                }
    102122        }
    103123
    104         template< typename OutputIterator >
    105         void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
    106                 explode( alts.begin(), alts.end(), indexer, out, isTupleAssign );
     124        template< typename Output >
     125        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, Output&& out,
     126                        bool isTupleAssign = false ) {
     127                explode( alts.begin(), alts.end(), indexer, std::forward<Output>(out), isTupleAssign );
    107128        }
    108129} // namespace Tuples
  • src/libcfa/concurrency/kernel

    r88ef2af rf7a4f89  
    120120#ifdef __CFA_DEBUG__
    121121        // Last function to enable preemption on this processor
    122         char * last_enable;
     122        const char * last_enable;
    123123#endif
    124124};
  • src/libcfa/concurrency/monitor.c

    r88ef2af rf7a4f89  
    823823                this.monitor_count = thrd->monitors.size;
    824824
    825                 this.monitors = malloc( this.monitor_count * sizeof( *this.monitors ) );
     825                this.monitors = (monitor_desc **)malloc( this.monitor_count * sizeof( *this.monitors ) );
    826826                for( int i = 0; i < this.monitor_count; i++ ) {
    827827                        this.monitors[i] = thrd->monitors.list[i];
  • src/libcfa/stdhdr/stddef.h

    r88ef2af rf7a4f89  
    44// The contents of this file are covered under the licence agreement in the
    55// file "LICENCE" distributed with Cforall.
    6 // 
    7 // stddef.h -- 
    8 // 
     6//
     7// stddef.h --
     8//
    99// Author           : Peter A. Buhr
    1010// Created On       : Mon Jul  4 23:25:26 2016
     
    1212// Last Modified On : Tue Jul  5 20:40:01 2016
    1313// Update Count     : 12
    14 // 
     14//
    1515
    1616extern "C" {
    17 #include_next <stddef.h>                                                                // has internal check for multiple expansion
     17#include_next <stddef.h>                // has internal check for multiple expansion
     18#undef NULL
     19#define NULL 0                          // define NULL as 0 rather than (void*)0 to take advantage of zero_t
    1820} // extern "C"
    1921
  • src/libcfa/stdlib

    r88ef2af rf7a4f89  
    7777        //printf( "X8\n" );
    7878        T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
    79     return memset( ptr, (int)fill, sizeof(T) );                 // initial with fill value
     79    return (T *)memset( ptr, (int)fill, sizeof(T) );                    // initial with fill value
    8080} // alloc
    8181
     
    8787        //printf( "X10\n" );
    8888        T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
    89     return memset( ptr, (int)fill, dim * sizeof(T) );
     89    return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
    9090} // alloc
    9191
    9292static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) {
    9393        //printf( "X11\n" );
    94         return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
     94        return (T *)(void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
    9595} // alloc
    9696forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
     
    103103        //printf( "X14\n" );
    104104    T * ptr = (T *)memalign( align, sizeof(T) );
    105     return memset( ptr, (int)fill, sizeof(T) );
     105    return (T *)memset( ptr, (int)fill, sizeof(T) );
    106106} // align_alloc
    107107
     
    113113        //printf( "X16\n" );
    114114    T * ptr = (T *)memalign( align, dim * sizeof(T) );
    115     return memset( ptr, (int)fill, dim * sizeof(T) );
     115    return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
    116116} // align_alloc
    117117
     
    120120static inline forall( dtype T | sized(T) ) T * memset( T * dest, char c ) {
    121121        //printf( "X17\n" );
    122         return memset( dest, c, sizeof(T) );
     122        return (T *)memset( dest, c, sizeof(T) );
    123123} // memset
    124124extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
    125125static inline forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src ) {
    126126        //printf( "X18\n" );
    127         return memcpy( dest, src, sizeof(T) );
     127        return (T *)memcpy( dest, src, sizeof(T) );
    128128} // memcpy
    129129
     
    131131static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
    132132        //printf( "X19\n" );
    133         return (void *)memset( dest, c, dim * sizeof(T) );      // C memset
     133        return (T *)(void *)memset( dest, c, dim * sizeof(T) ); // C memset
    134134} // memset
    135135static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {
    136136        //printf( "X20\n" );
    137         return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
     137        return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
    138138} // memcpy
    139139
  • src/prelude/prelude.cf

    r88ef2af rf7a4f89  
    403403forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &, const volatile    DT * );
    404404
    405 forall( dtype DT ) DT *                 ?=?(                 DT *          &,                   void * );
    406 forall( dtype DT ) DT *                 ?=?(                 DT * volatile &,                   void * );
    407 forall( dtype DT ) const DT *           ?=?( const           DT *          &,                   void * );
    408 forall( dtype DT ) const DT *           ?=?( const           DT * volatile &,                   void * );
    409 forall( dtype DT ) const DT *           ?=?( const           DT *          &, const             void * );
    410 forall( dtype DT ) const DT *           ?=?( const           DT * volatile &, const             void * );
    411 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          &,                   void * );
    412 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile &,                   void * );
    413 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          &,       volatile    void * );
    414 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile &,       volatile    void * );
    415 
    416 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &,                   void * );
    417 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &,                   void * );
    418 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &, const             void * );
    419 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &, const             void * );
    420 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &,       volatile    void * );
    421 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &,       volatile    void * );
    422 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &, const volatile    void * );
    423 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &, const volatile    void * );
    424 
    425405forall( dtype DT ) void *                ?=?(                void *          &,                 DT * );
    426406forall( dtype DT ) void *                ?=?(                void * volatile &,                 DT * );
     
    441421forall( dtype DT ) const volatile void * ?=?( const volatile void *          &, const volatile  DT * );
    442422forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const volatile  DT * );
    443 
    444 void *                  ?=?(                void *          &,                void * );
    445 void *                  ?=?(                void * volatile &,                void * );
    446 const void *            ?=?( const          void *          &,                void * );
    447 const void *            ?=?( const          void * volatile &,                void * );
    448 const void *            ?=?( const          void *          &, const          void * );
    449 const void *            ?=?( const          void * volatile &, const          void * );
    450 volatile void *         ?=?(       volatile void *          &,                void * );
    451 volatile void *         ?=?(       volatile void * volatile &,                void * );
    452 volatile void *         ?=?(       volatile void *          &,       volatile void * );
    453 volatile void *         ?=?(       volatile void * volatile &,       volatile void * );
    454 const volatile void *   ?=?( const volatile void *          &,                void * );
    455 const volatile void *   ?=?( const volatile void * volatile &,                void * );
    456 const volatile void *   ?=?( const volatile void *          &, const          void * );
    457 const volatile void *   ?=?( const volatile void * volatile &, const          void * );
    458 const volatile void *   ?=?( const volatile void *          &,       volatile void * );
    459 const volatile void *   ?=?( const volatile void * volatile &,       volatile void * );
    460 const volatile void *   ?=?( const volatile void *          &, const volatile void * );
    461 const volatile void *   ?=?( const volatile void * volatile &, const volatile void * );
    462423
    463424//forall( dtype DT ) DT *                       ?=?(                DT *          &, zero_t );
     
    781742forall( dtype DT ) void ?{}( const volatile  DT *          &, const volatile    DT * );
    782743
    783 forall( dtype DT ) void ?{}(                 DT *          &,                   void * );
    784 forall( dtype DT ) void ?{}( const           DT *          &,                   void * );
    785 forall( dtype DT ) void ?{}( const           DT *          &, const             void * );
    786 forall( dtype DT ) void ?{}(       volatile  DT *          &,                   void * );
    787 forall( dtype DT ) void ?{}(       volatile  DT *          &,       volatile    void * );
    788 
    789 forall( dtype DT ) void ?{}( const volatile  DT *          &,                   void * );
    790 forall( dtype DT ) void ?{}( const volatile  DT *          &, const             void * );
    791 forall( dtype DT ) void ?{}( const volatile  DT *          &,       volatile    void * );
    792 forall( dtype DT ) void ?{}( const volatile  DT *          &, const volatile    void * );
    793 
    794744forall( dtype DT ) void ?{}(                 void *          &,                 DT * );
    795745forall( dtype DT ) void ?{}( const           void *          &,                 DT * );
     
    802752forall( dtype DT ) void ?{}( const volatile void *           &, const volatile  DT * );
    803753
    804 void    ?{}(                void *          &,                void * );
    805 void    ?{}( const          void *          &,                void * );
    806 void    ?{}( const          void *          &, const          void * );
    807 void    ?{}(       volatile void *          &,                void * );
    808 void    ?{}(       volatile void *          &,       volatile void * );
    809 void    ?{}( const volatile void *          &,                void * );
    810 void    ?{}( const volatile void *          &, const          void * );
    811 void    ?{}( const volatile void *          &,       volatile void * );
    812 void    ?{}( const volatile void *          &, const volatile void * );
    813 
    814754//forall( dtype DT ) void ?{}(              DT *          &, zero_t );
    815755//forall( dtype DT ) void ?{}(              DT * volatile &, zero_t );
  • src/tests/.expect/completeTypeError.txt

    r88ef2af rf7a4f89  
    1 completeTypeError.c:34:1 error: No reasonable alternatives for expression Applying untyped:
     1completeTypeError.c:33:1 error: No reasonable alternatives for expression Applying untyped:
    22  Name: *?
    33...to:
    44  Name: v
    55
     6completeTypeError.c:34:1 error: No reasonable alternatives for expression Applying untyped:
     7  Name: *?
     8...to:
     9  Name: y
     10
     11completeTypeError.c:35:1 error: No reasonable alternatives for expression Applying untyped:
     12  Name: foo
     13...to:
     14  Name: v
    615
    716completeTypeError.c:36:1 error: No reasonable alternatives for expression Applying untyped:
     
    1019  Name: v
    1120
    12 
    1321completeTypeError.c:37:1 error: No reasonable alternatives for expression Applying untyped:
    1422  Name: quux
    1523...to:
    1624  Name: v
    17 
    1825
    1926completeTypeError.c:58:1 error: No reasonable alternatives for expression Applying untyped:
     
    2229  Name: y
    2330
    24 
    2531completeTypeError.c:59:1 error: No reasonable alternatives for expression Applying untyped:
    2632  Name: quux
    2733...to:
    2834  Name: y
    29 
    3035
    3136completeTypeError.c:60:1 error: No reasonable alternatives for expression Applying untyped:
     
    3439  Name: y
    3540
    36 
    3741completeTypeError.c:72:1 error: No reasonable alternatives for expression Applying untyped:
    3842  Name: baz
     
    4044  Name: z
    4145
    42 
  • src/tests/Makefile.am

    r88ef2af rf7a4f89  
    141141typedefRedef-ERR1: typedefRedef.c @CFA_BINDIR@/@CFA_NAME@
    142142        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     143
     144alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@
     145        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
  • src/tests/Makefile.in

    r88ef2af rf7a4f89  
    895895        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    896896
     897alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@
     898        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     899
    897900# Tell versions [3.59,3.63) of GNU make to not export all variables.
    898901# Otherwise a system limit (for SysV at least) may be exceeded.
  • src/tests/alloc.c

    r88ef2af rf7a4f89  
    3232        // allocation, non-array types
    3333
    34         p = (void *)malloc( sizeof(*p) );                   // C malloc, type unsafe
     34        p = (int *)(void *)malloc( sizeof(*p) );                   // C malloc, type unsafe
    3535        *p = 0xdeadbeef;
    3636        printf( "C   malloc %#x\n", *p );
     
    5454        printf( "\n" );
    5555
    56         p = calloc( dim, sizeof( *p ) );                    // C array calloc, type unsafe
     56        p = (int *)calloc( dim, sizeof( *p ) );                    // C array calloc, type unsafe
    5757        printf( "C   array calloc, fill 0\n" );
    5858        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     
    8383        printf( "\n" );
    8484
    85         p = (void *)realloc( p, dim * sizeof(*p) );         // C realloc
     85        p = (int *)(void *)realloc( p, dim * sizeof(*p) );         // C realloc
    8686        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
    8787        printf( "C   realloc\n" );
     
    256256        stp = malloc();
    257257        printf( "\nSHOULD FAIL\n" );
     258#ifdef ERR1
    258259        p = alloc( stp, dim * sizeof(*stp) );
    259260        p = memset( stp, 10 );
    260261        p = memcpy( &st1, &st );
     262#endif
    261263} // main
    262264
  • src/tests/completeTypeError.c

    r88ef2af rf7a4f89  
    1212        void *v;
    1313
    14         // A * x;
    15         // A * y;
    16         // B * x;
    17         // B * z;
     14        A * x;
     15        A * y;
     16        B * x;
     17        B * z;
    1818
    1919        // okay
    2020        *i;
    21         // *x; // picks B
    22         // *z;
     21        *x; // picks B
     22        *z;
    2323        foo(i);
    2424        bar(i);
     
    2929        bar(v);
    3030        qux(v);
    31         foo(v); // questionable, but works at the moment for C compatibility
    3231
    3332        // bad
    3433        *v;
    35         // *y;
     34        *y;
     35        foo(v);
    3636        baz(v);
    3737        quux(v);
  • src/tests/dtor-early-exit.c

    r88ef2af rf7a4f89  
    2222
    2323struct A {
    24         char * name;
     24        const char * name;
    2525        int * x;
    2626};
  • src/tests/init_once.c

    r88ef2af rf7a4f89  
    7272        insert( &constructed, &x );
    7373
    74         x.x = malloc(sizeof(int));
     74        x.x = (int *)malloc(sizeof(int));
    7575}
    7676
  • src/tests/multiDimension.c

    r88ef2af rf7a4f89  
    77  printf("default constructing\n");
    88  (this.a){ 123 };
    9   this.ptr = malloc(sizeof(int));
     9  this.ptr = (int *)malloc(sizeof(int));
    1010}
    1111
     
    1313  printf("copy constructing\n");
    1414  (this.a){ other.a };
    15   this.ptr = malloc(sizeof(int));
     15  this.ptr = (int *)malloc(sizeof(int));
    1616}
    1717
     
    1919  printf("constructing with %d\n", a);
    2020  (this.a){ a };
    21   this.ptr = malloc(sizeof(int));
     21  this.ptr = (int *)malloc(sizeof(int));
    2222}
    2323
  • src/tests/polymorphism.c

    r88ef2af rf7a4f89  
    1414//
    1515
     16#include <assert.h>
     17#include <inttypes.h>
     18
    1619forall(otype T)
    1720T f(T x, T y) {
     
    2427}
    2528
     29forall( otype T, otype U )
     30size_t struct_size( T i, U j ) {
     31        struct S { T i; U j; };
     32        return sizeof(S);
     33}
     34
     35forall( otype T, otype U )
     36size_t union_size( T i, U j ) {
     37        union B { T i; U j; };
     38        return sizeof(B);
     39}
     40
     41// perform some simple operations on aggregates of T and U
     42forall( otype T | { void print(T); int ?==?(T, T); }, otype U | { void print(U); U ?=?(U&, zero_t); } )
     43U foo(T i, U j) {
     44        struct S { T i; U j; };
     45        union B { T i; U j; };
     46
     47        S s;
     48        s.i = i;
     49        assert(s.i == i);
     50
     51        B b;
     52        b.j = 0;
     53        b.i = s.i;
     54        return b.j;
     55}
     56
    2657int main() {
    27         // ensure that x is not changed by the invocation of a polymorphic function
    28         int x = 123;
    29         int y = 456;
    30         int z = f(x, y);
    31         printf("%d %d %d\n", x, y, z);
     58        {
     59                // ensure that x is not changed by the invocation of a polymorphic function
     60                int x = 123;
     61                int y = 456;
     62                int z = f(x, y);
     63                printf("%d %d %d\n", x, y, z);
     64        }
    3265
    33         // explicitly specialize function
    34         int (*f)(int) = ident;
    35         ((int(*)(int))ident);
    36         printf("%d %d\n", f(5), ((int(*)(int))ident)(5));
     66        {
     67                // explicitly specialize function
     68                int (*f)(int) = ident;
     69                ((int(*)(int))ident);
     70                printf("%d %d\n", f(5), ((int(*)(int))ident)(5));
     71        }
     72
     73        {
     74                // test aggregates with polymorphic members
     75                typedef uint32_t x_type;
     76                typedef uint64_t y_type;
     77
     78                x_type x = 3;
     79                y_type y = 3;
     80
     81                struct S {
     82                        x_type f1;
     83                        y_type f2;
     84                };
     85                union U {
     86                        x_type f1;
     87                        y_type f2;
     88                };
     89                // ensure that the size of aggregates with polymorphic members
     90                // matches the size of the aggregates in a monomorphic context
     91                assert( struct_size(x, y) == sizeof(S) );
     92                assert( union_size(x, y) == sizeof(U) );
     93
     94                y_type ?=?(y_type & this, zero_t) {
     95                        this = (int)0;
     96                        return this;
     97                }
     98
     99                void print(x_type x) {
     100                        printf("%"PRIu32"\n", x);
     101                }
     102
     103                void print(y_type y) {
     104                        printf("%"PRIu64"\n", y);
     105                }
     106
     107                y_type ret = foo(x, y);
     108
     109                // duplicate logic from inside of foo to ensure the same results
     110                U u;
     111                u.f2 = 0;
     112                u.f1 = x;
     113                assert(ret == u.f2);
     114        }
    37115}
    38116
  • src/tests/tupleVariadic.c

    r88ef2af rf7a4f89  
    7373        [a0, a1, a2, a3] = args;
    7474        a.size = 4;
    75         a.data = malloc(sizeof(int)*a.size);
     75        a.data = (int *)malloc(sizeof(int)*a.size);
    7676        a.data[0] = a0;
    7777        a.data[1] = a1;
  • src/tests/vector/vector_int.c

    r88ef2af rf7a4f89  
    2727        vec.last = -1;
    2828        vec.capacity = reserve;
    29         vec.data = malloc( sizeof( int ) * reserve );
     29        vec.data = (int *)malloc( sizeof( int ) * reserve );
    3030}
    3131
     
    3333        vec.last = other.last;
    3434        vec.capacity = other.capacity;
    35         vec.data = malloc( sizeof( int ) * other.capacity );
     35        vec.data = (int *)malloc( sizeof( int ) * other.capacity );
    3636        for (int i = 0; i < vec.last; i++) {
    3737                vec.data[i] = other.data[i];
     
    4545void reserve( vector_int *vec, int reserve ) {
    4646        if ( reserve > vec->capacity ) {
    47                 vec->data = realloc( vec->data, sizeof( int ) * reserve );
     47                vec->data = (int *)realloc( vec->data, sizeof( int ) * reserve );
    4848                vec->capacity = reserve;
    4949        }
     
    5454        if ( vec->last == vec->capacity ) {
    5555                vec->capacity *= 2;
    56                 vec->data = realloc( vec->data, sizeof( int ) * vec->capacity );
     56                vec->data = (int *)realloc( vec->data, sizeof( int ) * vec->capacity );
    5757        }
    5858        vec->data[ vec->last ] = element;
Note: See TracChangeset for help on using the changeset viewer.