Changes in / [261fd34:8762501]


Ignore:
Location:
src
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • src/GenPoly/Box.cc

    r261fd34 r8762501  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Box.cc -- 
     7// Box.cc --
    88//
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Dec 15 15:30:31 2015
    13 // Update Count     : 215
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Fri Dec 18 14:53:08 2015
     13// Update Count     : 217
    1414//
    1515
    … …  
    6565                        virtual Type *mutate( PointerType *pointerType );
    6666                        virtual Type * mutate( FunctionType *functionType );
    67  
     67
    6868                        virtual void doBeginScope();
    6969                        virtual void doEndScope();
    … …  
    103103                  private:
    104104                        void addAdapters( FunctionType *functionType );
    105  
     105
    106106                        std::map< UniqueId, std::string > adapterName;
    107107                };
    … …  
    151151                        // the correct thing in some situations. It's not clear to me why this wasn't working.
    152152
    153                         // if the return type or a parameter type involved polymorphic types, then the adapter will need 
    154                         // to take those polymorphic types as pointers. Therefore, there can be two different functions 
     153                        // if the return type or a parameter type involved polymorphic types, then the adapter will need
     154                        // to take those polymorphic types as pointers. Therefore, there can be two different functions
    155155                        // with the same mangled name, so we need to further mangle the names.
    156156                        for ( std::list< DeclarationWithType *>::iterator retval = function->get_returnVals().begin(); retval != function->get_returnVals().end(); ++retval ) {
    … …  
    167167                                        name << "P";
    168168                                } else {
    169                                         name << "M";                           
     169                                        name << "M";
    170170                                }
    171171                        } // for
    … …  
    185185                }
    186186
     187                // returns true if the given declaration is: (*?=?)(T *, T) for some T (return not checked, but maybe should be)
    187188                bool checkAssignment( DeclarationWithType *decl, std::string &name ) {
    188189                        if ( decl->get_name() == "?=?" ) {
    … …  
    233234                                if ( isPolyRet( functionDecl->get_functionType(), typeName ) && functionDecl->get_linkage() == LinkageSpec::Cforall ) {
    234235                                        retval = functionDecl->get_functionType()->get_returnVals().front();
    235  
     236
    236237                                        // give names to unnamed return values
    237238                                        if ( retval->get_name() == "" ) {
    … …  
    240241                                        } // if
    241242                                } // if
    242        
     243
    243244                                FunctionType *functionType = functionDecl->get_functionType();
    244245                                makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
    … …  
    265266
    266267                                functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
    267  
     268
    268269                                scopeTyVars = oldtyVars;
    269270                                assignOps = oldassignOps;
    … …  
    328329                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_results().front() );
    329330                        assert( funcType );
    330                        
     331
    331332                        std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin();
    332333                        std::list< Expression* >::const_iterator fnArg = arg;
    … …  
    405406                        appExpr->get_args().push_front( appExpr->get_function() );
    406407                        appExpr->set_function( new NameExpr( adapterName ) );
    407  
     408
    408409                        return ret;
    409410                }
    … …  
    528529                        ApplicationExpr *adapteeApp = new ApplicationExpr( new CastExpr( new VariableExpr( adapteeDecl ), new PointerType( Type::Qualifiers(), realType ) ) );
    529530                        Statement *bodyStmt;
    530  
     531
    531532                        std::list< TypeDecl *>::iterator tyArg = realType->get_forall().begin();
    532533                        std::list< TypeDecl *>::iterator tyParam = adapterType->get_forall().begin();
    … …  
    542543                                } // for
    543544                        } // for
    544  
     545
    545546                        std::list< DeclarationWithType *>::iterator arg = realType->get_parameters().begin();
    546547                        std::list< DeclarationWithType *>::iterator param = adapterType->get_parameters().begin();
    … …  
    599600                                if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
    600601                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
    601                                        
     602
    602603                                        // apply substitution to type variables to figure out what the adapter's type should look like
    603604                                        assert( env );
    604605                                        env->apply( realFunction );
    605                                         mangleName = SymTab::Mangler::mangle( realFunction ); 
     606                                        mangleName = SymTab::Mangler::mangle( realFunction );
    606607                                        mangleName += makePolyMonoSuffix( originalFunction, exprTyVars );
    607608
    … …  
    654655                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), scopeTyVars, env );
    655656                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), scopeTyVars, env );
    656                                                 assert( ! baseType1 || ! baseType2 );
     657                                                assert( ! baseType1 || ! baseType2 ); // the arguments cannot both be polymorphic pointers
    657658                                                UntypedExpr *ret = 0;
    658                                                 if ( baseType1 || baseType2 ) {
     659                                                if ( baseType1 || baseType2 ) { // one of the arguments is a polymorphic pointer
    659660                                                        ret = new UntypedExpr( new NameExpr( "?+?" ) );
    660661                                                } // if
    … …  
    777778                        mutateAll( appExpr->get_args(), *this );
    778779                        useRetval = oldUseRetval;
    779  
     780
    780781                        assert( ! appExpr->get_function()->get_results().empty() );
    781782                        PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
    … …  
    783784                        FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
    784785                        assert( function );
    785  
     786
    786787                        if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
    787788                                return newExpr;
    788789                        } // if
    789  
     790
    790791                        Expression *ret = appExpr;
    791  
     792
    792793                        std::list< Expression *>::iterator arg = appExpr->get_args().begin();
    793794                        std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
    794  
     795
    795796                        std::string typeName;
    796797                        if ( isPolyRet( function, typeName ) ) {
    … …  
    806807                        } // if
    807808                        arg = appExpr->get_args().begin();
    808  
     809
    809810                        TyVarMap exprTyVars;
    810811                        makeTyVarMap( function, exprTyVars );
    811  
     812
    812813                        passTypeVars( appExpr, arg, exprTyVars );
    813814                        addInferredParams( appExpr, function, arg, exprTyVars );
    814815
    815816                        arg = paramBegin;
    816  
     817
    817818                        boxParams( appExpr, function, arg, exprTyVars );
    818819
    … …  
    874875                                // ***** Code Removal ***** After introducing a temporary variable for all return expressions, the following code appears superfluous.
    875876                                // if ( returnStmt->get_expr()->get_results().front()->get_isLvalue() ) {
    876                                 // a cast expr on a polymorphic return value is either redundant or invalid
     877                                // by this point, a cast expr on a polymorphic return value is redundant
    877878                                while ( CastExpr *castExpr = dynamic_cast< CastExpr *>( returnStmt->get_expr() ) ) {
    878879                                        returnStmt->set_expr( castExpr->get_arg() );
    … …  
    909910                        TyVarMap oldtyVars = scopeTyVars;
    910911                        makeTyVarMap( pointerType, scopeTyVars );
    911  
     912
    912913                        Type *ret = Mutator::mutate( pointerType );
    913  
     914
    914915                        scopeTyVars = oldtyVars;
    915916                        return ret;
    … …  
    919920                        TyVarMap oldtyVars = scopeTyVars;
    920921                        makeTyVarMap( functionType, scopeTyVars );
    921  
     922
    922923                        Type *ret = Mutator::mutate( functionType );
    923  
     924
    924925                        scopeTyVars = oldtyVars;
    925926                        return ret;
    … …  
    988989                        TyVarMap oldtyVars = scopeTyVars;
    989990                        makeTyVarMap( pointerType, scopeTyVars );
    990  
     991
    991992                        Type *ret = Mutator::mutate( pointerType );
    992  
     993
    993994                        scopeTyVars = oldtyVars;
    994995                        return ret;
    … …  
    10181019                                if ( (*tyParm)->get_kind() == TypeDecl::Any ) {
    10191020                                        TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm );
    1020                                        
     1021
    10211022                                        sizeParm = newObj.clone();
    10221023                                        sizeParm->set_name( sizeofName( &parmType ) );
    … …  
    10441045                                        std::string sizeName = sizeofName( parmType );
    10451046                                        if ( seenTypes.count( sizeName ) ) continue;
    1046                                        
     1047
    10471048                                        ObjectDecl *sizeParm, *alignParm;
    10481049                                        sizeParm = newObj.clone();
    … …  
    10651066                        mutateAll( funcType->get_returnVals(), *this );
    10661067                        mutateAll( funcType->get_parameters(), *this );
    1067  
     1068
    10681069                        scopeTyVars = oldtyVars;
    10691070                        return funcType;
    … …  
    10761077                        TyVarMap oldtyVars = scopeTyVars;
    10771078                        makeTyVarMap( type, scopeTyVars );
    1078  
     1079
    10791080                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
    10801081                        ScrubTyVars::scrub( decl, scopeTyVars );
    … …  
    11121113                        TyVarMap oldtyVars = scopeTyVars;
    11131114                        makeTyVarMap( pointerType, scopeTyVars );
    1114  
     1115
    11151116                        Type *ret = Mutator::mutate( pointerType );
    1116  
     1117
    11171118                        scopeTyVars = oldtyVars;
    11181119                        return ret;
    … …  
    11221123                        TyVarMap oldtyVars = scopeTyVars;
    11231124                        makeTyVarMap( functionType, scopeTyVars );
    1124  
     1125
    11251126                        Type *ret = Mutator::mutate( functionType );
    1126  
     1127
    11271128                        scopeTyVars = oldtyVars;
    11281129                        return ret;

  • src/GenPoly/PolyMutator.h

    r261fd34 r8762501  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Rob Schluntz
    12 // Last Modified On : Fri Aug 14 15:27:38 2015
    13 // Update Count     : 4
     12// Last Modified On : Tue Dec 08 15:19:05 2015
     13// Update Count     : 5
    1414//
    1515
    … …  
    5151                virtual void doBeginScope() {}
    5252                virtual void doEndScope() {}
     53               
     54                static void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
    5355          protected:
    5456                void mutateStatementList( std::list< Statement* > &statements );
    5557                Statement* mutateStatement( Statement *stmt );
    5658                Expression* mutateExpression( Expression *expr );
    57                 static void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
    5859 
    5960                TyVarMap scopeTyVars;

  • src/SynTree/Declaration.cc

    r261fd34 r8762501  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jul 13 17:58:38 2015
    13 // Update Count     : 10
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Wed Dec 09 14:08:29 2015
     13// Update Count     : 12
    1414//
    1515
    … …  
    5555}
    5656
     57std::ostream & operator<<( std::ostream & out, Declaration * decl ) {
     58        decl->print( out );
     59        return out;
     60}
     61
     62
    5763// Local Variables: //
    5864// tab-width: 4 //

  • src/SynTree/Declaration.h

    r261fd34 r8762501  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jul 13 18:15:59 2015
    13 // Update Count     : 28
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Wed Dec 09 14:08:22 2015
     13// Update Count     : 32
    1414//
    1515
    … …  
    259259};
    260260
     261std::ostream & operator<<( std::ostream & out, Declaration * decl );
     262
    261263#endif // DECLARATION_H
    262264

  • src/SynTree/Expression.cc

    r261fd34 r8762501  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Sep 02 12:07:10 2015
    13 // Update Count     : 33
     12// Last Modified On : Wed Dec 09 14:10:29 2015
     13// Update Count     : 34
    1414//
    1515
    … …  
    376376}
    377377
     378std::ostream & operator<<( std::ostream & out, Expression * expr ) {
     379        expr->print( out );
     380        return out;
     381}
     382
    378383// Local Variables: //
    379384// tab-width: 4 //

  • src/SynTree/Expression.h

    r261fd34 r8762501  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 24 13:49:28 2015
    13 // Update Count     : 18
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Wed Dec 09 14:10:21 2015
     13// Update Count     : 19
    1414//
    1515
    … …  
    512512};
    513513
     514std::ostream & operator<<( std::ostream & out, Expression * expr );
     515
    514516#endif // EXPRESSION_H
    515517

  • src/SynTree/Statement.cc

    r261fd34 r8762501  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 25 12:19:50 2015
    13 // Update Count     : 53
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Wed Dec 09 14:09:34 2015
     13// Update Count     : 54
    1414//
    1515
    … …  
    337337}
    338338
     339std::ostream & operator<<( std::ostream & out, Statement * statement ) {
     340        statement->print( out );
     341        return out;
     342}
     343
    339344// Local Variables: //
    340345// tab-width: 4 //

  • src/SynTree/Statement.h

    r261fd34 r8762501  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 25 18:25:37 2015
    13 // Update Count     : 44
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Wed Dec 09 14:09:24 2015
     13// Update Count     : 46
    1414//
    1515
    … …  
    396396};
    397397
     398std::ostream & operator<<( std::ostream & out, Statement * statement );
     399
    398400#endif // STATEMENT_H
    399401

  • src/SynTree/Type.cc

    r261fd34 r8762501  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul  9 16:45:13 2015
    13 // Update Count     : 3
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Wed Dec 09 14:08:48 2015
     13// Update Count     : 4
    1414//
    1515
    … …  
    8080}
    8181
     82std::ostream & operator<<( std::ostream & out, Type * type ) {
     83        type->print( out );
     84        return out;
     85}
     86
    8287// Local Variables: //
    8388// tab-width: 4 //

  • src/SynTree/Type.h

    r261fd34 r8762501  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Type.h -- 
     7// Type.h --
    88//
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Nov 27 17:54:31 2015
    13 // Update Count     : 16
     11// Last Modified By : Rob Schluntz
     12// Last Modified On : Fri Dec 18 14:46:18 2015
     13// Update Count     : 18
    1414//
    1515
    … …  
    2323class Type {
    2424  public:
    25         struct Qualifiers { 
     25        struct Qualifiers {
    2626                Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ), isAttribute( false ) {}
    2727                Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isAttribute ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isAttribute( isAttribute ) {}
    28        
     28
    2929                Qualifiers &operator+=( const Qualifiers &other );
    3030                Qualifiers &operator-=( const Qualifiers &other );
    … …  
    3636                bool operator<( const Qualifiers &other );
    3737                bool operator>( const Qualifiers &other );
    38        
     38
    3939                bool isConst;
    4040                bool isVolatile;
    … …  
    4343                bool isAtomic;
    4444                bool isAttribute;
    45         };     
     45        };
    4646
    4747        Type( const Qualifiers &tq );
    … …  
    8585class BasicType : public Type {
    8686  public:
    87         enum Kind { 
     87        enum Kind {
    8888                Bool,
    8989                Char,
    … …  
    108108                LongDoubleImaginary,
    109109                NUMBER_OF_BASIC_TYPES
    110         }; 
     110        };
    111111
    112112        static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
    … …  
    149149  private:
    150150        Type *base;
    151        
     151
    152152        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
    153153        Expression *dimension;
    … …  
    217217        void set_name( std::string newValue ) { name = newValue; }
    218218        std::list< Expression* >& get_parameters() { return parameters; }
    219        
     219
    220220        virtual ReferenceToType *clone() const = 0;
    221221        virtual void accept( Visitor &v ) = 0;
    … …  
    240240        /// Accesses generic parameters of base struct (NULL if none such)
    241241        std::list<TypeDecl*> * get_baseParameters();
    242        
     242
    243243        /// Looks up the members of this struct named "name" and places them into "foundDecls".
    244244        /// Clones declarations into "foundDecls", caller responsible for freeing
    … …  
    250250  private:
    251251        virtual std::string typeString() const;
    252        
     252
    253253        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
    254254        // where the structure used in this type is actually defined
    … …  
    267267        /// Accesses generic parameters of base union (NULL if none such)
    268268        std::list<TypeDecl*> * get_baseParameters();
    269        
     269
    270270        /// looks up the members of this union named "name" and places them into "foundDecls"
    271271        /// Clones declarations into "foundDecls", caller responsible for freeing
    … …  
    277277  private:
    278278        virtual std::string typeString() const;
    279        
     279
    280280        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
    281281        // where the union used in this type is actually defined
    … …  
    310310  private:
    311311        virtual std::string typeString() const;
    312        
     312
    313313        // this member is filled in by the validate pass, which instantiates the members of the correponding
    314314        // aggregate with the actual type parameters specified for this use of the context
    … …  
    327327        bool get_isFtype() const { return isFtype; }
    328328        void set_isFtype( bool newValue ) { isFtype = newValue; }
    329        
     329
    330330        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
    331331        virtual void accept( Visitor &v ) { v.visit( this ); }
    … …  
    463463}
    464464
     465std::ostream & operator<<( std::ostream & out, Type * type );
     466
    465467#endif // TYPE_H
    466468
Note: See TracChangeset for help on using the changeset viewer.