Changeset f5478c8


Ignore:
Timestamp:
Nov 24, 2017, 8:57:00 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:
2b716ec
Parents:
50abab9 (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:
3 added
41 edited

Legend:

Unmodified
Added
Removed
  • src/GenPoly/Box.cc

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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/Makefile.in

    r50abab9 rf5478c8  
    210210        ResolvExpr/driver_cfa_cpp-TypeEnvironment.$(OBJEXT) \
    211211        ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT) \
     212        ResolvExpr/driver_cfa_cpp-ExplodedActual.$(OBJEXT) \
    212213        SymTab/driver_cfa_cpp-Indexer.$(OBJEXT) \
    213214        SymTab/driver_cfa_cpp-Mangler.$(OBJEXT) \
     
    511512        ResolvExpr/FindOpenVars.cc ResolvExpr/PolyCost.cc \
    512513        ResolvExpr/Occurs.cc ResolvExpr/TypeEnvironment.cc \
    513         ResolvExpr/CurrentObject.cc SymTab/Indexer.cc \
    514         SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \
    515         SymTab/ImplementationType.cc SymTab/TypeEquality.cc \
    516         SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \
    517         SynTree/BasicType.cc SynTree/PointerType.cc \
    518         SynTree/ArrayType.cc SynTree/ReferenceType.cc \
    519         SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
    520         SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
     514        ResolvExpr/CurrentObject.cc ResolvExpr/ExplodedActual.cc \
     515        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
     516        SymTab/FixFunction.cc SymTab/ImplementationType.cc \
     517        SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \
     518        SynTree/VoidType.cc SynTree/BasicType.cc \
     519        SynTree/PointerType.cc SynTree/ArrayType.cc \
     520        SynTree/ReferenceType.cc SynTree/FunctionType.cc \
     521        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
     522        SynTree/TypeofType.cc SynTree/AttrType.cc \
    521523        SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
    522524        SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
     
    825827        ResolvExpr/$(am__dirstamp) \
    826828        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
     829ResolvExpr/driver_cfa_cpp-ExplodedActual.$(OBJEXT):  \
     830        ResolvExpr/$(am__dirstamp) \
     831        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
    827832SymTab/$(am__dirstamp):
    828833        @$(MKDIR_P) SymTab
     
    10221027@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ConversionCost.Po@am__quote@
    10231028@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po@am__quote@
     1029@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Po@am__quote@
    10241030@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-FindOpenVars.Po@am__quote@
    10251031@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Occurs.Po@am__quote@
     
    19641970@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi`
    19651971
     1972ResolvExpr/driver_cfa_cpp-ExplodedActual.o: ResolvExpr/ExplodedActual.cc
     1973@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-ExplodedActual.o -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Tpo -c -o ResolvExpr/driver_cfa_cpp-ExplodedActual.o `test -f 'ResolvExpr/ExplodedActual.cc' || echo '$(srcdir)/'`ResolvExpr/ExplodedActual.cc
     1974@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Po
     1975@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/ExplodedActual.cc' object='ResolvExpr/driver_cfa_cpp-ExplodedActual.o' libtool=no @AMDEPBACKSLASH@
     1976@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1977@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-ExplodedActual.o `test -f 'ResolvExpr/ExplodedActual.cc' || echo '$(srcdir)/'`ResolvExpr/ExplodedActual.cc
     1978
     1979ResolvExpr/driver_cfa_cpp-ExplodedActual.obj: ResolvExpr/ExplodedActual.cc
     1980@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-ExplodedActual.obj -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Tpo -c -o ResolvExpr/driver_cfa_cpp-ExplodedActual.obj `if test -f 'ResolvExpr/ExplodedActual.cc'; then $(CYGPATH_W) 'ResolvExpr/ExplodedActual.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/ExplodedActual.cc'; fi`
     1981@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Po
     1982@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/ExplodedActual.cc' object='ResolvExpr/driver_cfa_cpp-ExplodedActual.obj' libtool=no @AMDEPBACKSLASH@
     1983@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1984@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-ExplodedActual.obj `if test -f 'ResolvExpr/ExplodedActual.cc'; then $(CYGPATH_W) 'ResolvExpr/ExplodedActual.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/ExplodedActual.cc'; fi`
     1985
    19661986SymTab/driver_cfa_cpp-Indexer.o: SymTab/Indexer.cc
    19671987@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-Indexer.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Tpo -c -o SymTab/driver_cfa_cpp-Indexer.o `test -f 'SymTab/Indexer.cc' || echo '$(srcdir)/'`SymTab/Indexer.cc
  • src/ResolvExpr/Alternative.cc

    r50abab9 rf5478c8  
    1818#include <ostream>                       // for operator<<, ostream, basic_o...
    1919#include <string>                        // for operator<<, char_traits, string
     20#include <utility>                       // for move
    2021
    2122#include "Common/utility.h"              // for maybeClone
     
    8182                os << std::endl;
    8283        }
     84
     85        void splice( AltList& dst, AltList& src ) {
     86                dst.reserve( dst.size() + src.size() );
     87                for ( Alternative& alt : src ) {
     88                        dst.push_back( std::move(alt) );
     89                }
     90                src.clear();
     91        }
     92
     93        void spliceBegin( AltList& dst, AltList& src ) {
     94                splice( src, dst );
     95                dst.swap( src );
     96        }
     97
    8398} // namespace ResolvExpr
    8499
  • src/ResolvExpr/Alternative.h

    r50abab9 rf5478c8  
    1717
    1818#include <iosfwd>             // for ostream
    19 #include <list>               // for list
     19#include <vector>             // for vector
    2020
    2121#include "Cost.h"             // for Cost
     
    2525
    2626namespace ResolvExpr {
    27         struct Alternative;
    28 
    29         typedef std::list< Alternative > AltList;
    30 
    3127        struct Alternative {
    3228                Alternative();
     
    4137                void print( std::ostream &os, Indenter indent = {} ) const;
    4238
     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
    4346                Cost cost;
    4447                Cost cvtCost;
     
    4649                TypeEnvironment env;
    4750        };
     51
     52        typedef std::vector< Alternative > AltList;
     53
     54        /// Moves all elements from src to the end of dst
     55        void splice( AltList& dst, AltList& src );
     56
     57        /// Moves all elements from src to the beginning of dst
     58        void spliceBegin( AltList& dst, AltList& src );
    4859} // namespace ResolvExpr
    4960
  • src/ResolvExpr/AlternativeFinder.cc

    r50abab9 rf5478c8  
    1616#include <algorithm>               // for copy
    1717#include <cassert>                 // for strict_dynamic_cast, assert, assertf
     18#include <cstddef>                 // for size_t
    1819#include <iostream>                // for operator<<, cerr, ostream, endl
    1920#include <iterator>                // for back_insert_iterator, back_inserter
    2021#include <list>                    // for _List_iterator, list, _List_const_...
    2122#include <map>                     // for _Rb_tree_iterator, map, _Rb_tree_c...
    22 #include <memory>                  // for allocator_traits<>::value_type
     23#include <memory>                  // for allocator_traits<>::value_type, unique_ptr
    2324#include <utility>                 // for pair
    2425#include <vector>                  // for vector
     
    2930#include "Common/utility.h"        // for deleteAll, printAll, CodeLocation
    3031#include "Cost.h"                  // for Cost, Cost::zero, operator<<, Cost...
     32#include "ExplodedActual.h"        // for ExplodedActual
    3133#include "InitTweak/InitTweak.h"   // for getFunctionName
    3234#include "RenameVars.h"            // for RenameVars, global_renamer
     
    5052#define PRINT( text ) if ( resolvep ) { text }
    5153//#define DEBUG_COST
     54
     55using std::move;
     56
     57/// copies any copyable type
     58template<typename T>
     59T copy(const T& x) { return x; }
    5260
    5361namespace ResolvExpr {
     
    179187                expr->accept( *this );
    180188                if ( failFast && alternatives.empty() ) {
     189                        PRINT(
     190                                std::cerr << "No reasonable alternatives for expression " << expr << std::endl;
     191                        )
    181192                        throw SemanticError( "No reasonable alternatives for expression ", expr );
    182193                }
     
    187198                                printAlts( alternatives, std::cerr );
    188199                        )
    189                         AltList::iterator oldBegin = alternatives.begin();
    190                         pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ) );
    191                         if ( failFast && alternatives.begin() == oldBegin ) {
     200                        AltList pruned;
     201                        pruneAlternatives( alternatives.begin(), alternatives.end(), back_inserter( pruned ) );
     202                        if ( failFast && pruned.empty() ) {
    192203                                std::ostringstream stream;
    193204                                AltList winners;
     
    199210                                throw SemanticError( stream.str() );
    200211                        }
    201                         alternatives.erase( oldBegin, alternatives.end() );
     212                        alternatives = move(pruned);
    202213                        PRINT(
    203214                                std::cerr << "there are " << oldsize << " alternatives before elimination" << std::endl;
     
    571582        /// State to iteratively build a match of parameter expressions to arguments
    572583        struct ArgPack {
    573                 AltList actuals;                 ///< Arguments included in this pack
    574                 TypeEnvironment env;             ///< Environment for this pack
    575                 AssertionSet need;               ///< Assertions outstanding for this pack
    576                 AssertionSet have;               ///< Assertions found for this pack
    577                 OpenVarSet openVars;             ///< Open variables for this pack
    578                 unsigned nextArg;                ///< Index of next argument in arguments list
    579                 std::vector<Alternative> expls;  ///< Exploded actuals left over from last match
    580                 unsigned nextExpl;               ///< Index of next exploded alternative to use
    581                 std::vector<unsigned> tupleEls;  /// Number of elements in current tuple element(s)
     584                std::size_t parent;                ///< Index of parent pack
     585                std::unique_ptr<Expression> expr;  ///< The argument stored here
     586                Cost cost;                         ///< The cost of this argument
     587                TypeEnvironment env;               ///< Environment for this pack
     588                AssertionSet need;                 ///< Assertions outstanding for this pack
     589                AssertionSet have;                 ///< Assertions found for this pack
     590                OpenVarSet openVars;               ///< Open variables for this pack
     591                unsigned nextArg;                  ///< Index of next argument in arguments list
     592                unsigned tupleStart;               ///< Number of tuples that start at this index
     593                unsigned nextExpl;                 ///< Index of next exploded element
     594                unsigned explAlt;                  ///< Index of alternative for nextExpl > 0
     595
     596                ArgPack()
     597                        : parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0),
     598
     599                          tupleStart(0), nextExpl(0), explAlt(0) {}
    582600
    583601                ArgPack(const TypeEnvironment& env, const AssertionSet& need, const AssertionSet& have,
    584602                                const OpenVarSet& openVars)
    585                         : actuals(), env(env), need(need), have(have), openVars(openVars), nextArg(0),
    586                           expls(), nextExpl(0), tupleEls() {}
    587 
    588                 /// Starts a new tuple expression
    589                 void beginTuple() {
    590                         if ( ! tupleEls.empty() ) ++tupleEls.back();
    591                         tupleEls.push_back(0);
     603                        : parent(0), expr(), cost(Cost::zero), env(env), need(need), have(have),
     604                          openVars(openVars), nextArg(0), tupleStart(0), nextExpl(0), explAlt(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,
     609                                unsigned explAlt = 0 )
     610                        : parent(parent), expr(expr->clone()), cost(cost), env(move(env)), need(move(need)),
     611                          have(move(have)), openVars(move(openVars)), nextArg(nextArg), tupleStart(tupleStart),
     612                          nextExpl(nextExpl), explAlt(explAlt) {}
     613
     614                ArgPack(const ArgPack& o, TypeEnvironment&& env, AssertionSet&& need, AssertionSet&& have,
     615                                OpenVarSet&& openVars, unsigned nextArg, Cost added )
     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)),
     618                          nextArg(nextArg), tupleStart(o.tupleStart), nextExpl(0), explAlt(0) {}
     619
     620                /// true iff this pack is in the middle of an exploded argument
     621                bool hasExpl() const { return nextExpl > 0; }
     622
     623                /// Gets the list of exploded alternatives for this pack
     624                const ExplodedActual& getExpl( const ExplodedArgs& args ) const {
     625                        return args[nextArg-1][explAlt];
    592626                }
    593627
    594628                /// Ends a tuple expression, consolidating the appropriate actuals
    595                 void endTuple() {
    596                         // set up new Tuple alternative
     629                void endTuple( const std::vector<ArgPack>& packs ) {
     630                        // add all expressions in tuple to list, summing cost
    597631                        std::list<Expression*> exprs;
    598                         Cost cost = Cost::zero;
    599 
    600                         // transfer elements into alternative
    601                         for (unsigned i = 0; i < tupleEls.back(); ++i) {
    602                                 exprs.push_front( actuals.back().expr );
    603                                 actuals.back().expr = nullptr;
    604                                 cost += actuals.back().cost;
    605                                 actuals.pop_back();
    606                         }
    607                         tupleEls.pop_back();
    608 
    609                         // build new alternative
    610                         actuals.emplace_back( new TupleExpr( exprs ), this->env, cost );
    611                 }
    612 
    613                 /// Clones and adds an actual, returns this
    614                 ArgPack& withArg( Expression* expr, Cost cost = Cost::zero ) {
    615                         actuals.emplace_back( expr->clone(), this->env, cost );
    616                         if ( ! tupleEls.empty() ) ++tupleEls.back();
    617                         return *this;
     632                        const ArgPack* pack = this;
     633                        if ( expr ) { exprs.push_front( expr.release() ); }
     634                        while ( pack->tupleStart == 0 ) {
     635                                pack = &packs[pack->parent];
     636                                exprs.push_front( pack->expr->clone() );
     637                                cost += pack->cost;
     638                        }
     639                        // reset pack to appropriate tuple
     640                        expr.reset( new TupleExpr( exprs ) );
     641                        tupleStart = pack->tupleStart - 1;
     642                        parent = pack->parent;
    618643                }
    619644        };
     
    621646        /// Instantiates an argument to match a formal, returns false if no results left
    622647        bool instantiateArgument( Type* formalType, Initializer* initializer,
    623                         const std::vector< AlternativeFinder >& args,
    624                         std::vector<ArgPack>& results, std::vector<ArgPack>& nextResults,
    625                         const SymTab::Indexer& indexer ) {
     648                        const ExplodedArgs& args, std::vector<ArgPack>& results, std::size_t& genStart,
     649                        const SymTab::Indexer& indexer, unsigned nTuples = 0 ) {
    626650                if ( TupleType* tupleType = dynamic_cast<TupleType*>( formalType ) ) {
    627651                        // formalType is a TupleType - group actuals into a TupleExpr
    628                         for ( ArgPack& result : results ) { result.beginTuple(); }
     652                        ++nTuples;
    629653                        for ( Type* type : *tupleType ) {
    630654                                // xxx - dropping initializer changes behaviour from previous, but seems correct
    631                                 if ( ! instantiateArgument( type, nullptr, args, results, nextResults, indexer ) )
     655                                if ( ! instantiateArgument(
     656                                                type, nullptr, args, results, genStart, indexer, nTuples ) )
    632657                                        return false;
    633                         }
    634                         for ( ArgPack& result : results ) { result.endTuple(); }
     658                                nTuples = 0;
     659                        }
     660                        // re-consititute tuples for final generation
     661                        for ( auto i = genStart; i < results.size(); ++i ) {
     662                                results[i].endTuple( results );
     663                        }
    635664                        return true;
    636665                } else if ( TypeInstType* ttype = Tuples::isTtype( formalType ) ) {
    637666                        // formalType is a ttype, consumes all remaining arguments
    638667                        // xxx - mixing default arguments with variadic??
    639                         std::vector<ArgPack> finalResults{};  /// list of completed tuples
    640                         // start tuples
    641                         for ( ArgPack& result : results ) {
    642                                 result.beginTuple();
    643 
    644                                 // use rest of exploded tuple if present
    645                                 while ( result.nextExpl < result.expls.size() ) {
    646                                         const Alternative& actual = result.expls[result.nextExpl];
    647                                         result.env.addActual( actual.env, result.openVars );
    648                                         result.withArg( actual.expr );
    649                                         ++result.nextExpl;
    650                                 }
    651                         }
     668
     669                        // completed tuples; will be spliced to end of results to finish
     670                        std::vector<ArgPack> finalResults{};
     671
    652672                        // iterate until all results completed
    653                         while ( ! results.empty() ) {
     673                        std::size_t genEnd;
     674                        ++nTuples;
     675                        do {
     676                                genEnd = results.size();
     677
    654678                                // add another argument to results
    655                                 for ( ArgPack& result : results ) {
    656                                         // finish result when out of arguments
    657                                         if ( result.nextArg >= args.size() ) {
    658                                                 Type* argType = result.actuals.back().expr->get_result();
    659                                                 if ( result.tupleEls.back() == 1 && Tuples::isTtype( argType ) ) {
    660                                                         // the case where a ttype value is passed directly is special, e.g. for
    661                                                         // argument forwarding purposes
    662                                                         // xxx - what if passing multiple arguments, last of which is ttype?
    663                                                         // xxx - what would happen if unify was changed so that unifying tuple
    664                                                         // types flattened both before unifying lists? then pass in TupleType
    665                                                         // (ttype) below.
    666                                                         result.tupleEls.pop_back();
    667                                                 } else {
    668                                                         // collapse leftover arguments into tuple
    669                                                         result.endTuple();
    670                                                         argType = result.actuals.back().expr->get_result();
     679                                for ( std::size_t i = genStart; i < genEnd; ++i ) {
     680                                        auto nextArg = results[i].nextArg;
     681
     682                                        // use next element of exploded tuple if present
     683                                        if ( results[i].hasExpl() ) {
     684                                                const ExplodedActual& expl = results[i].getExpl( args );
     685
     686                                                unsigned nextExpl = results[i].nextExpl + 1;
     687                                                if ( nextExpl == expl.exprs.size() ) {
     688                                                        nextExpl = 0;
    671689                                                }
    672                                                 // check unification for ttype before adding to final
    673                                                 if ( unify( ttype, argType, result.env, result.need, result.have,
    674                                                                 result.openVars, indexer ) ) {
    675                                                         finalResults.push_back( std::move(result) );
    676                                                 }
     690
     691                                                results.emplace_back(
     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
    677697                                                continue;
    678698                                        }
    679699
     700                                        // finish result when out of arguments
     701                                        if ( nextArg >= args.size() ) {
     702                                                ArgPack newResult{
     703                                                        results[i].env, results[i].need, results[i].have,
     704                                                        results[i].openVars };
     705                                                newResult.nextArg = nextArg;
     706                                                Type* argType;
     707
     708                                                if ( nTuples > 0 ) {
     709                                                        // first iteration, push empty tuple expression
     710                                                        newResult.parent = i;
     711                                                        std::list<Expression*> emptyList;
     712                                                        newResult.expr.reset( new TupleExpr( emptyList ) );
     713                                                        argType = newResult.expr->get_result();
     714                                                } else {
     715                                                        // clone result to collect tuple
     716                                                        newResult.parent = results[i].parent;
     717                                                        newResult.cost = results[i].cost;
     718                                                        newResult.tupleStart = results[i].tupleStart;
     719                                                        newResult.expr.reset( results[i].expr->clone() );
     720                                                        argType = newResult.expr->get_result();
     721
     722                                                        if ( results[i].tupleStart > 0 && Tuples::isTtype( argType ) ) {
     723                                                                // the case where a ttype value is passed directly is special,
     724                                                                // e.g. for argument forwarding purposes
     725                                                                // xxx - what if passing multiple arguments, last of which is
     726                                                                //       ttype?
     727                                                                // xxx - what would happen if unify was changed so that unifying
     728                                                                //       tuple
     729                                                                // types flattened both before unifying lists? then pass in
     730                                                                // TupleType (ttype) below.
     731                                                                --newResult.tupleStart;
     732                                                        } else {
     733                                                                // collapse leftover arguments into tuple
     734                                                                newResult.endTuple( results );
     735                                                                argType = newResult.expr->get_result();
     736                                                        }
     737                                                }
     738
     739                                                // check unification for ttype before adding to final
     740                                                if ( unify( ttype, argType, newResult.env, newResult.need, newResult.have,
     741                                                                newResult.openVars, indexer ) ) {
     742                                                        finalResults.push_back( move(newResult) );
     743                                                }
     744
     745                                                continue;
     746                                        }
     747
    680748                                        // add each possible next argument
    681                                         for ( const Alternative& actual : args[result.nextArg] ) {
    682                                                 ArgPack aResult = result;  // copy to clone everything
    683                                                 // add details of actual to result
    684                                                 aResult.env.addActual( actual.env, aResult.openVars );
    685                                                 Cost cost = actual.cost;
    686 
    687                                                 // explode argument
    688                                                 std::vector<Alternative> exploded;
    689                                                 Tuples::explode( actual, indexer, back_inserter( exploded ) );
    690 
    691                                                 // add exploded argument to tuple
    692                                                 for ( Alternative& aActual : exploded ) {
    693                                                         aResult.withArg( aActual.expr, cost );
    694                                                         cost = Cost::zero;
     749                                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
     750                                                const ExplodedActual& expl = args[nextArg][j];
     751
     752                                                // fresh copies of parent parameters for this iteration
     753                                                TypeEnvironment env = results[i].env;
     754                                                OpenVarSet openVars = results[i].openVars;
     755
     756                                                env.addActual( expl.env, openVars );
     757
     758                                                // skip empty tuple arguments by (near-)cloning parent into next gen
     759                                                if ( expl.exprs.empty() ) {
     760                                                        results.emplace_back(
     761                                                                results[i], move(env), copy(results[i].need),
     762                                                                copy(results[i].have), move(openVars), nextArg + 1, expl.cost );
     763
     764                                                        continue;
    695765                                                }
    696                                                 ++aResult.nextArg;
    697                                                 nextResults.push_back( std::move(aResult) );
     766
     767                                                // add new result
     768                                                results.emplace_back(
     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 );
    698772                                        }
    699773                                }
    700774
    701775                                // reset for next round
    702                                 results.swap( nextResults );
    703                                 nextResults.clear();
    704                         }
    705                         results.swap( finalResults );
    706                         return ! results.empty();
     776                                genStart = genEnd;
     777                                nTuples = 0;
     778                        } while ( genEnd != results.size() );
     779
     780                        // splice final results onto results
     781                        for ( std::size_t i = 0; i < finalResults.size(); ++i ) {
     782                                results.push_back( move(finalResults[i]) );
     783                        }
     784                        return ! finalResults.empty();
    707785                }
    708786
    709787                // iterate each current subresult
    710                 for ( unsigned iResult = 0; iResult < results.size(); ++iResult ) {
    711                         ArgPack& result = results[iResult];
    712 
    713                         if ( result.nextExpl < result.expls.size() ) {
    714                                 // use remainder of exploded tuple if present
    715                                 const Alternative& actual = result.expls[result.nextExpl];
    716                                 result.env.addActual( actual.env, result.openVars );
    717                                 Type* actualType = actual.expr->get_result();
     788                std::size_t genEnd = results.size();
     789                for ( std::size_t i = genStart; i < genEnd; ++i ) {
     790                        auto nextArg = results[i].nextArg;
     791
     792                        // use remainder of exploded tuple if present
     793                        if ( results[i].hasExpl() ) {
     794                                const ExplodedActual& expl = results[i].getExpl( args );
     795                                Expression* expr = expl.exprs[results[i].nextExpl].get();
     796
     797                                TypeEnvironment env = results[i].env;
     798                                AssertionSet need = results[i].need, have = results[i].have;
     799                                OpenVarSet openVars = results[i].openVars;
     800
     801                                Type* actualType = expr->get_result();
    718802
    719803                                PRINT(
     
    725809                                )
    726810
    727                                 if ( unify( formalType, actualType, result.env, result.need, result.have,
    728                                                 result.openVars, indexer ) ) {
    729                                         ++result.nextExpl;
    730                                         nextResults.push_back( std::move(result.withArg( actual.expr )) );
     811                                if ( unify( formalType, actualType, env, need, have, openVars, indexer ) ) {
     812                                        unsigned nextExpl = results[i].nextExpl + 1;
     813                                        if ( nextExpl == expl.exprs.size() ) {
     814                                                nextExpl = 0;
     815                                        }
     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 );
    731820                                }
    732821
    733822                                continue;
    734                         } else if ( result.nextArg >= args.size() ) {
    735                                 // use default initializers if out of arguments
     823                        }
     824
     825                        // use default initializers if out of arguments
     826                        if ( nextArg >= args.size() ) {
    736827                                if ( ConstantExpr* cnstExpr = getDefaultValue( initializer ) ) {
    737828                                        if ( Constant* cnst = dynamic_cast<Constant*>( cnstExpr->get_constant() ) ) {
    738                                                 if ( unify( formalType, cnst->get_type(), result.env, result.need,
    739                                                                 result.have, result.openVars, indexer ) ) {
    740                                                         nextResults.push_back( std::move(result.withArg( cnstExpr )) );
     829                                                TypeEnvironment env = results[i].env;
     830                                                AssertionSet need = results[i].need, have = results[i].have;
     831                                                OpenVarSet openVars = results[i].openVars;
     832
     833                                                if ( unify( formalType, cnst->get_type(), env, need, have, openVars,
     834                                                                indexer ) ) {
     835                                                        results.emplace_back(
     836                                                                i, cnstExpr, move(env), move(need), move(have),
     837                                                                move(openVars), nextArg, nTuples );
    741838                                                }
    742839                                        }
    743840                                }
     841
    744842                                continue;
    745843                        }
    746844
    747845                        // Check each possible next argument
    748                         for ( const Alternative& actual : args[result.nextArg] ) {
    749                                 ArgPack aResult = result;  // copy to clone everything
    750                                 // add details of actual to result
    751                                 aResult.env.addActual( actual.env, aResult.openVars );
    752 
    753                                 // explode argument
    754                                 std::vector<Alternative> exploded;
    755                                 Tuples::explode( actual, indexer, back_inserter( exploded ) );
    756                                 if ( exploded.empty() ) {
    757                                         // skip empty tuple arguments
    758                                         ++aResult.nextArg;
    759                                         results.push_back( std::move(aResult) );
     846                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
     847                                const ExplodedActual& expl = args[nextArg][j];
     848
     849                                // fresh copies of parent parameters for this iteration
     850                                TypeEnvironment env = results[i].env;
     851                                AssertionSet need = results[i].need, have = results[i].have;
     852                                OpenVarSet openVars = results[i].openVars;
     853
     854                                env.addActual( expl.env, openVars );
     855
     856                                // skip empty tuple arguments by (near-)cloning parent into next gen
     857                                if ( expl.exprs.empty() ) {
     858                                        results.emplace_back(
     859                                                results[i], move(env), move(need), move(have), move(openVars),
     860                                                nextArg + 1, expl.cost );
     861
    760862                                        continue;
    761863                                }
    762864
    763865                                // consider only first exploded actual
    764                                 const Alternative& aActual = exploded.front();
    765                                 Type* actualType = aActual.expr->get_result()->clone();
     866                                Expression* expr = expl.exprs.front().get();
     867                                Type* actualType = expr->get_result()->clone();
    766868
    767869                                PRINT(
     
    774876
    775877                                // attempt to unify types
    776                                 if ( unify( formalType, actualType, aResult.env, aResult.need, aResult.have, aResult.openVars, indexer ) ) {
    777                                         // add argument
    778                                         aResult.withArg( aActual.expr, actual.cost );
    779                                         ++aResult.nextArg;
    780                                         if ( exploded.size() > 1 ) {
    781                                                 // other parts of tuple left over
    782                                                 aResult.expls = std::move( exploded );
    783                                                 aResult.nextExpl = 1;
    784                                         }
    785                                         nextResults.push_back( std::move(aResult) );
     878                                if ( unify( formalType, actualType, env, need, have, openVars, indexer ) ) {
     879                                        // add new result
     880                                        results.emplace_back(
     881                                                i, expr, move(env), move(need), move(have), move(openVars), nextArg + 1,
     882                                                nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    786883                                }
    787884                        }
     
    789886
    790887                // reset for next parameter
    791                 results.swap( nextResults );
    792                 nextResults.clear();
    793 
    794                 return ! results.empty();
     888                genStart = genEnd;
     889
     890                return genEnd != results.size();
     891        }
     892
     893        template<typename OutputIterator>
     894        void AlternativeFinder::validateFunctionAlternative( const Alternative &func, ArgPack& result,
     895                        const std::vector<ArgPack>& results, OutputIterator out ) {
     896                ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
     897                // sum cost and accumulate actuals
     898                std::list<Expression*>& args = appExpr->get_args();
     899                Cost cost = Cost::zero;
     900                const ArgPack* pack = &result;
     901                while ( pack->expr ) {
     902                        args.push_front( pack->expr->clone() );
     903                        cost += pack->cost;
     904                        pack = &results[pack->parent];
     905                }
     906                // build and validate new alternative
     907                Alternative newAlt( appExpr, result.env, cost );
     908                PRINT(
     909                        std::cerr << "instantiate function success: " << appExpr << std::endl;
     910                        std::cerr << "need assertions:" << std::endl;
     911                        printAssertionSet( result.need, std::cerr, 8 );
     912                )
     913                inferParameters( result.need, result.have, newAlt, result.openVars, out );
    795914        }
    796915
    797916        template<typename OutputIterator>
    798917        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func,
    799                         FunctionType *funcType, const std::vector< AlternativeFinder > &args,
    800                         OutputIterator out ) {
     918                        FunctionType *funcType, const ExplodedArgs &args, OutputIterator out ) {
    801919                OpenVarSet funcOpenVars;
    802920                AssertionSet funcNeed, funcHave;
     
    818936
    819937                // iteratively build matches, one parameter at a time
    820                 std::vector<ArgPack> results{ ArgPack{ funcEnv, funcNeed, funcHave, funcOpenVars } };
    821                 std::vector<ArgPack> nextResults{};
     938                std::vector<ArgPack> results;
     939                results.push_back( ArgPack{ funcEnv, funcNeed, funcHave, funcOpenVars } );
     940                std::size_t genStart = 0;
     941
    822942                for ( DeclarationWithType* formal : funcType->get_parameters() ) {
    823943                        ObjectDecl* obj = strict_dynamic_cast< ObjectDecl* >( formal );
    824944                        if ( ! instantiateArgument(
    825                                         obj->get_type(), obj->get_init(), args, results, nextResults, indexer ) )
     945                                        obj->get_type(), obj->get_init(), args, results, genStart, indexer ) )
    826946                                return;
    827947                }
    828948
    829                 // filter out results that don't use all the arguments, and aren't variadic
    830                 std::vector<ArgPack> finalResults{};
    831949                if ( funcType->get_isVarArgs() ) {
    832                         for ( ArgPack& result : results ) {
    833                                 // use rest of exploded tuple if present
    834                                 while ( result.nextExpl < result.expls.size() ) {
    835                                         const Alternative& actual = result.expls[result.nextExpl];
    836                                         result.env.addActual( actual.env, result.openVars );
    837                                         result.withArg( actual.expr );
    838                                         ++result.nextExpl;
    839                                 }
    840                         }
    841 
    842                         while ( ! results.empty() ) {
    843                                 // build combinations for all remaining arguments
    844                                 for ( ArgPack& result : results ) {
    845                                         // keep if used all arguments
    846                                         if ( result.nextArg >= args.size() ) {
    847                                                 finalResults.push_back( std::move(result) );
     950                        // append any unused arguments to vararg pack
     951                        std::size_t genEnd;
     952                        do {
     953                                genEnd = results.size();
     954
     955                                // iterate results
     956                                for ( std::size_t i = genStart; i < genEnd; ++i ) {
     957                                        auto nextArg = results[i].nextArg;
     958
     959                                        // use remainder of exploded tuple if present
     960                                        if ( results[i].hasExpl() ) {
     961                                                const ExplodedActual& expl = results[i].getExpl( args );
     962
     963                                                unsigned nextExpl = results[i].nextExpl + 1;
     964                                                if ( nextExpl == expl.exprs.size() ) {
     965                                                        nextExpl = 0;
     966                                                }
     967
     968                                                results.emplace_back(
     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
    848974                                                continue;
    849975                                        }
    850976
     977                                        // finish result when out of arguments
     978                                        if ( nextArg >= args.size() ) {
     979                                                validateFunctionAlternative( func, results[i], results, out );
     980
     981                                                continue;
     982                                        }
     983
    851984                                        // add each possible next argument
    852                                         for ( const Alternative& actual : args[result.nextArg] ) {
    853                                                 ArgPack aResult = result; // copy to clone everything
    854                                                 // add details of actual to result
    855                                                 aResult.env.addActual( actual.env, aResult.openVars );
    856                                                 Cost cost = actual.cost;
    857 
    858                                                 // explode argument
    859                                                 std::vector<Alternative> exploded;
    860                                                 Tuples::explode( actual, indexer, back_inserter( exploded ) );
    861 
    862                                                 // add exploded argument to arg list
    863                                                 for ( Alternative& aActual : exploded ) {
    864                                                         aResult.withArg( aActual.expr, cost );
    865                                                         cost = Cost::zero;
     985                                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
     986                                                const ExplodedActual& expl = args[nextArg][j];
     987
     988                                                // fresh copies of parent parameters for this iteration
     989                                                TypeEnvironment env = results[i].env;
     990                                                OpenVarSet openVars = results[i].openVars;
     991
     992                                                env.addActual( expl.env, openVars );
     993
     994                                                // skip empty tuple arguments by (near-)cloning parent into next gen
     995                                                if ( expl.exprs.empty() ) {
     996                                                        results.emplace_back(
     997                                                                results[i], move(env), copy(results[i].need),
     998                                                                copy(results[i].have), move(openVars), nextArg + 1, expl.cost );
     999
     1000                                                        continue;
    8661001                                                }
    867                                                 ++aResult.nextArg;
    868                                                 nextResults.push_back( std::move(aResult) );
     1002
     1003                                                // add new result
     1004                                                results.emplace_back(
     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 );
    8691008                                        }
    8701009                                }
    8711010
    872                                 // reset for next round
    873                                 results.swap( nextResults );
    874                                 nextResults.clear();
    875                         }
     1011                                genStart = genEnd;
     1012                        } while ( genEnd != results.size() );
    8761013                } else {
    8771014                        // filter out results that don't use all the arguments
    878                         for ( ArgPack& result : results ) {
    879                                 if ( result.nextExpl >= result.expls.size() && result.nextArg >= args.size() ) {
    880                                         finalResults.push_back( std::move(result) );
     1015                        for ( std::size_t i = genStart; i < results.size(); ++i ) {
     1016                                ArgPack& result = results[i];
     1017                                if ( ! result.hasExpl() && result.nextArg >= args.size() ) {
     1018                                        validateFunctionAlternative( func, result, results, out );
    8811019                                }
    8821020                        }
    883                 }
    884 
    885                 // validate matching combos, add to final result list
    886                 for ( ArgPack& result : finalResults ) {
    887                         ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
    888                         Alternative newAlt( appExpr, result.env, sumCost( result.actuals ) );
    889                         makeExprList( result.actuals, appExpr->get_args() );
    890                         PRINT(
    891                                 std::cerr << "instantiate function success: " << appExpr << std::endl;
    892                                 std::cerr << "need assertions:" << std::endl;
    893                                 printAssertionSet( result.need, std::cerr, 8 );
    894                         )
    895                         inferParameters( result.need, result.have, newAlt, result.openVars, out );
    8961021                }
    8971022        }
     
    9201045                        printAlts( funcOpFinder.alternatives, std::cerr, 1 );
    9211046                )
     1047
     1048                // pre-explode arguments
     1049                ExplodedArgs argExpansions;
     1050                argExpansions.reserve( argAlternatives.size() );
     1051
     1052                for ( const AlternativeFinder& arg : argAlternatives ) {
     1053                        argExpansions.emplace_back();
     1054                        auto& argE = argExpansions.back();
     1055                        argE.reserve( arg.alternatives.size() );
     1056
     1057                        for ( const Alternative& actual : arg ) {
     1058                                argE.emplace_back( actual, indexer );
     1059                        }
     1060                }
    9221061
    9231062                AltList candidates;
     
    9341073                                                Alternative newFunc( *func );
    9351074                                                referenceToRvalueConversion( newFunc.expr );
    936                                                 makeFunctionAlternatives( newFunc, function, argAlternatives,
     1075                                                makeFunctionAlternatives( newFunc, function, argExpansions,
    9371076                                                        std::back_inserter( candidates ) );
    9381077                                        }
     
    9431082                                                        Alternative newFunc( *func );
    9441083                                                        referenceToRvalueConversion( newFunc.expr );
    945                                                         makeFunctionAlternatives( newFunc, function, argAlternatives,
     1084                                                        makeFunctionAlternatives( newFunc, function, argExpansions,
    9461085                                                                std::back_inserter( candidates ) );
    9471086                                                } // if
     
    9551094                // try each function operator ?() with each function alternative
    9561095                if ( ! funcOpFinder.alternatives.empty() ) {
    957                         // add function alternatives to front of argument list
    958                         argAlternatives.insert( argAlternatives.begin(), std::move(funcFinder) );
     1096                        // add exploded function alternatives to front of argument list
     1097                        std::vector<ExplodedActual> funcE;
     1098                        funcE.reserve( funcFinder.alternatives.size() );
     1099                        for ( const Alternative& actual : funcFinder ) {
     1100                                funcE.emplace_back( actual, indexer );
     1101                        }
     1102                        argExpansions.insert( argExpansions.begin(), move(funcE) );
    9591103
    9601104                        for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin();
     
    9681112                                                        Alternative newFunc( *funcOp );
    9691113                                                        referenceToRvalueConversion( newFunc.expr );
    970                                                         makeFunctionAlternatives( newFunc, function, argAlternatives,
     1114                                                        makeFunctionAlternatives( newFunc, function, argExpansions,
    9711115                                                                std::back_inserter( candidates ) );
    9721116                                                }
     
    9821126
    9831127                // compute conversionsion costs
    984                 for ( AltList::iterator withFunc = candidates.begin(); withFunc != candidates.end(); ++withFunc ) {
    985                         Cost cvtCost = computeApplicationConversionCost( *withFunc, indexer );
     1128                for ( Alternative& withFunc : candidates ) {
     1129                        Cost cvtCost = computeApplicationConversionCost( withFunc, indexer );
    9861130
    9871131                        PRINT(
    988                                 ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( withFunc->expr );
     1132                                ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( withFunc.expr );
    9891133                                PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
    9901134                                FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
     
    9951139                                printAll( appExpr->get_args(), std::cerr, 8 );
    9961140                                std::cerr << "bindings are:" << std::endl;
    997                                 withFunc->env.print( std::cerr, 8 );
     1141                                withFunc.env.print( std::cerr, 8 );
    9981142                                std::cerr << "cost of conversion is:" << cvtCost << std::endl;
    9991143                        )
    10001144                        if ( cvtCost != Cost::infinity ) {
    1001                                 withFunc->cvtCost = cvtCost;
    1002                                 alternatives.push_back( *withFunc );
     1145                                withFunc.cvtCost = cvtCost;
     1146                                alternatives.push_back( withFunc );
    10031147                        } // if
    10041148                } // for
    10051149
    1006                 candidates.clear();
    1007                 candidates.splice( candidates.end(), alternatives );
     1150                candidates = move(alternatives);
    10081151
    10091152                // use a new list so that alternatives are not examined by addAnonConversions twice.
     
    10111154                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( winners ) );
    10121155
    1013                 // function may return struct or union value, in which case we need to add alternatives for implicit
    1014                 // conversions to each of the anonymous members, must happen after findMinCost since anon conversions
    1015                 // are never the cheapest expression
     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
     1158                // since anon conversions are never the cheapest expression
    10161159                for ( const Alternative & alt : winners ) {
    10171160                        addAnonConversions( alt );
    10181161                }
    1019                 alternatives.splice( alternatives.begin(), winners );
     1162                spliceBegin( alternatives, winners );
    10201163
    10211164                if ( alternatives.empty() && targetType && ! targetType->isVoid() ) {
     
    10411184                AlternativeFinder finder( indexer, env );
    10421185                finder.find( addressExpr->get_arg() );
    1043                 for ( std::list< Alternative >::iterator i = finder.alternatives.begin(); i != finder.alternatives.end(); ++i ) {
    1044                         if ( isLvalue( i->expr ) ) {
    1045                                 alternatives.push_back( Alternative( new AddressExpr( i->expr->clone() ), i->env, i->cost ) );
     1186                for ( Alternative& alt : finder.alternatives ) {
     1187                        if ( isLvalue( alt.expr ) ) {
     1188                                alternatives.push_back(
     1189                                        Alternative{ new AddressExpr( alt.expr->clone() ), alt.env, alt.cost } );
    10461190                        } // if
    10471191                } // for
     
    10491193
    10501194        void AlternativeFinder::visit( LabelAddressExpr * expr ) {
    1051                 alternatives.push_back( Alternative( expr->clone(), env, Cost::zero) );
     1195                alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } );
    10521196        }
    10531197
     
    10911235
    10921236                AltList candidates;
    1093                 for ( std::list< Alternative >::iterator i = finder.alternatives.begin(); i != finder.alternatives.end(); ++i ) {
     1237                for ( Alternative & alt : finder.alternatives ) {
    10941238                        AssertionSet needAssertions, haveAssertions;
    10951239                        OpenVarSet openVars;
     
    10991243                        // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
    11001244                        // to.
    1101                         int discardedValues = i->expr->get_result()->size() - castExpr->get_result()->size();
     1245                        int discardedValues = alt.expr->get_result()->size() - castExpr->get_result()->size();
    11021246                        if ( discardedValues < 0 ) continue;
    11031247                        // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
    11041248                        // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
    11051249                        // unification run for side-effects
    1106                         unify( castExpr->get_result(), i->expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
    1107                         Cost thisCost = castCost( i->expr->get_result(), castExpr->get_result(), indexer, i->env );
     1250                        unify( castExpr->get_result(), alt.expr->get_result(), alt.env, needAssertions,
     1251                                haveAssertions, openVars, indexer );
     1252                        Cost thisCost = castCost( alt.expr->get_result(), castExpr->get_result(), indexer,
     1253                                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                        )
    11081259                        if ( thisCost != Cost::infinity ) {
     1260                                PRINT(
     1261                                        std::cerr << "has finite cost." << std::endl;
     1262                                )
    11091263                                // count one safe conversion for each value that is thrown away
    11101264                                thisCost.incSafe( discardedValues );
    1111                                 Alternative newAlt( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost );
    1112                                 inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
     1265                                Alternative newAlt( restructureCast( alt.expr->clone(), toType ), alt.env,
     1266                                        alt.cost, thisCost );
     1267                                inferParameters( needAssertions, haveAssertions, newAlt, openVars,
     1268                                        back_inserter( candidates ) );
    11131269                        } // if
    11141270                } // for
     
    13971553
    13981554        void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) {
    1399                 std::list< AlternativeFinder > subExprAlternatives;
    1400                 findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) );
    1401                 std::list< AltList > possibilities;
    1402                 combos( subExprAlternatives.begin(), subExprAlternatives.end(), back_inserter( possibilities ) );
    1403                 for ( std::list< AltList >::const_iterator i = possibilities.begin(); i != possibilities.end(); ++i ) {
     1555                std::vector< AlternativeFinder > subExprAlternatives;
     1556                findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(),
     1557                        back_inserter( subExprAlternatives ) );
     1558                std::vector< AltList > possibilities;
     1559                combos( subExprAlternatives.begin(), subExprAlternatives.end(),
     1560                        back_inserter( possibilities ) );
     1561                for ( const AltList& alts : possibilities ) {
    14041562                        std::list< Expression * > exprs;
    1405                         makeExprList( *i, exprs );
     1563                        makeExprList( alts, exprs );
    14061564
    14071565                        TypeEnvironment compositeEnv;
    1408                         simpleCombineEnvironments( i->begin(), i->end(), compositeEnv );
    1409                         alternatives.push_back( Alternative( new TupleExpr( exprs ) , compositeEnv, sumCost( *i ) ) );
     1566                        simpleCombineEnvironments( alts.begin(), alts.end(), compositeEnv );
     1567                        alternatives.push_back(
     1568                                Alternative{ new TupleExpr( exprs ), compositeEnv, sumCost( alts ) } );
    14101569                } // for
    14111570        }
  • src/ResolvExpr/AlternativeFinder.h

    r50abab9 rf5478c8  
    2121
    2222#include "Alternative.h"                 // for AltList, Alternative
     23#include "ExplodedActual.h"              // for ExplodedActual
    2324#include "ResolvExpr/Cost.h"             // for Cost, Cost::infinity
    2425#include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
     
    3132
    3233namespace ResolvExpr {
     34        struct ArgPack;
     35
     36        /// First index is which argument, second index is which alternative for that argument,
     37        /// third index is which exploded element of that alternative
     38        using ExplodedArgs = std::vector< std::vector< ExplodedActual > >;
     39
    3340        class AlternativeFinder : public Visitor {
    3441          public:
     
    3643
    3744                AlternativeFinder( const AlternativeFinder& o )
    38                         : indexer(o.indexer), alternatives(o.alternatives), env(o.env), 
     45                        : indexer(o.indexer), alternatives(o.alternatives), env(o.env),
    3946                          targetType(o.targetType) {}
    40                
     47
    4148                AlternativeFinder( AlternativeFinder&& o )
    42                         : indexer(o.indexer), alternatives(std::move(o.alternatives)), env(o.env), 
     49                        : indexer(o.indexer), alternatives(std::move(o.alternatives)), env(o.env),
    4350                          targetType(o.targetType) {}
    44                
     51
    4552                AlternativeFinder& operator= ( const AlternativeFinder& o ) {
    4653                        if (&o == this) return *this;
    47                        
     54
    4855                        // horrific nasty hack to rebind references...
    4956                        alternatives.~AltList();
     
    5461                AlternativeFinder& operator= ( AlternativeFinder&& o ) {
    5562                        if (&o == this) return *this;
    56                        
     63
    5764                        // horrific nasty hack to rebind references...
    5865                        alternatives.~AltList();
     
    126133                /// Adds alternatives for offsetof expressions, given the base type and name of the member
    127134                template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
     135                /// Takes a final result and checks if its assertions can be satisfied
    128136                template<typename OutputIterator>
    129                 void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const std::vector< AlternativeFinder >& args, OutputIterator out );
     137                void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector<ArgPack>& results, OutputIterator out );
     138                /// Finds matching alternatives for a function, given a set of arguments
     139                template<typename OutputIterator>
     140                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out );
     141                /// Checks if assertion parameters match for a new alternative
    130142                template< typename OutputIterator >
    131143                void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
  • src/ResolvExpr/PtrsAssignable.cc

    r50abab9 rf5478c8  
    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/Resolver.cc

    r50abab9 rf5478c8  
    1818#include <memory>                        // for allocator, allocator_traits<...
    1919#include <tuple>                         // for get
     20#include <vector>
    2021
    2122#include "Alternative.h"                 // for Alternative, AltList
     
    411412
    412413                        // Find all alternatives for all arguments in canonical form
    413                         std::list< AlternativeFinder > argAlternatives;
     414                        std::vector< AlternativeFinder > argAlternatives;
    414415                        funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) );
    415416
    416417                        // List all combinations of arguments
    417                         std::list< AltList > possibilities;
     418                        std::vector< AltList > possibilities;
    418419                        combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
    419420
  • src/ResolvExpr/TypeEnvironment.cc

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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/ResolvExpr/module.mk

    r50abab9 rf5478c8  
    3232       ResolvExpr/Occurs.cc \
    3333       ResolvExpr/TypeEnvironment.cc \
    34        ResolvExpr/CurrentObject.cc
     34       ResolvExpr/CurrentObject.cc \
     35       ResolvExpr/ExplodedActual.cc
  • src/ResolvExpr/typeops.h

    r50abab9 rf5478c8  
    1616#pragma once
    1717
     18#include <vector>
     19
    1820#include "SynTree/SynTree.h"
    1921#include "SynTree/Type.h"
     
    2830        void combos( InputIterator begin, InputIterator end, OutputIterator out ) {
    2931                typedef typename InputIterator::value_type SetType;
    30                 typedef typename std::list< typename SetType::value_type > ListType;
     32                typedef typename std::vector< typename SetType::value_type > ListType;
    3133
    3234                if ( begin == end )     {
     
    3840                begin++;
    3941
    40                 std::list< ListType > recursiveResult;
     42                std::vector< ListType > recursiveResult;
    4143                combos( begin, end, back_inserter( recursiveResult ) );
    4244
    43                 for ( typename std::list< ListType >::const_iterator i = recursiveResult.begin(); i != recursiveResult.end(); ++i ) {
    44                         for ( typename ListType::const_iterator j = current->begin(); j != current->end(); ++j ) {
    45                                 ListType result;
    46                                 std::back_insert_iterator< ListType > inserter = back_inserter( result );
    47                                 *inserter++ = *j;
    48                                 std::copy( i->begin(), i->end(), inserter );
    49                                 *out++ = result;
    50                         } // for
    51                 } // for
     45                for ( const auto& i : recursiveResult ) for ( const auto& j : *current ) {
     46                        ListType result;
     47                        std::back_insert_iterator< ListType > inserter = back_inserter( result );
     48                        *inserter++ = j;
     49                        std::copy( i.begin(), i.end(), inserter );
     50                        *out++ = result;
     51                }
    5252        }
    5353
  • src/SymTab/Autogen.cc

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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/Tuples/TupleAssignment.cc

    r50abab9 rf5478c8  
    251251                // combine assignment environments into combined expression environment
    252252                simpleCombineEnvironments( current.begin(), current.end(), matcher->compositeEnv );
    253                 currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(
     253                // xxx -- was push_front
     254                currentFinder.get_alternatives().push_back( ResolvExpr::Alternative(
    254255                        new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv,
    255256                        ResolvExpr::sumCost( current ) + matcher->baseCost ) );
  • src/libcfa/concurrency/kernel

    r50abab9 rf5478c8  
    108108#ifdef __CFA_DEBUG__
    109109        // Last function to enable preemption on this processor
    110         char * last_enable;
     110        const char * last_enable;
    111111#endif
    112112};
  • src/libcfa/concurrency/monitor.c

    r50abab9 rf5478c8  
    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[i];
  • src/libcfa/stdhdr/stddef.h

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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/castError.txt

    r50abab9 rf5478c8  
    55  charAlternatives are:
    66Cost ( 1, 0, 0, 0 ): Cast of:
    7      Variable Expression: f: signed int
     7     Variable Expression: f: function
     8       accepting unspecified arguments
     9     ... returning nothing
     10
    811   ... to:
    912     char
     
    2326
    2427Cost ( 1, 0, 0, 0 ): Cast of:
    25      Variable Expression: f: function
    26        accepting unspecified arguments
    27      ... returning nothing
    28 
     28     Variable Expression: f: signed int
    2929   ... to:
    3030     char
  • src/tests/.expect/completeTypeError.txt

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

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

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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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

    r50abab9 rf5478c8  
    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.