Changeset 906e24d for src/ResolvExpr


Ignore:
Timestamp:
Sep 15, 2016, 10:17:16 AM (9 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
aa8f9df
Parents:
96a10cd
git-author:
Rob Schluntz <rschlunt@…> (09/14/16 22:32:34)
git-committer:
Rob Schluntz <rschlunt@…> (09/15/16 10:17:16)
Message:

replace results list on Expressions with a single Type field

Location:
src/ResolvExpr
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified src/ResolvExpr/Alternative.cc

    r96a10cd r906e24d  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Alternative.cc -- 
     7// Alternative.cc --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1212// Last Modified On : Sat May 16 23:54:23 2015
    1313// Update Count     : 2
    14 // 
     14//
    1515
    1616#include "Alternative.h"
    … …  
    5454                        expr->print( os, indent );
    5555                        os << "(types:" << std::endl;
    56                         printAll( expr->get_results(), os, indent + 4 );
    57                         os << ")" << std::endl;
     56                        os << std::string( indent+4, ' ' );
     57                        expr->get_result()->print( os, indent + 4 );
     58                        os << std::endl << ")" << std::endl;
    5859                } else {
    5960                        os << "Null expression!" << std::endl;

  • TabularUnified src/ResolvExpr/AlternativeFinder.cc

    r96a10cd r906e24d  
    101101                                PruneStruct current( candidate );
    102102                                std::string mangleName;
    103                                 for ( std::list< Type* >::const_iterator retType = candidate->expr->get_results().begin(); retType != candidate->expr->get_results().end(); ++retType ) {
    104                                         Type *newType = (*retType)->clone();
     103                                {
     104                                        Type * newType = candidate->expr->get_result()->clone();
    105105                                        candidate->env.apply( newType );
    106                                         mangleName += SymTab::Mangler::mangle( newType );
     106                                        mangleName = SymTab::Mangler::mangle( newType );
    107107                                        delete newType;
    108108                                }
    … …  
    133133                                if ( ! target->second.isAmbiguous ) {
    134134                                        Alternative &alt = *target->second.candidate;
    135                                         for ( std::list< Type* >::iterator result = alt.expr->get_results().begin(); result != alt.expr->get_results().end(); ++result ) {
    136                                                 alt.env.applyFree( *result );
    137                                         }
     135                                        alt.env.applyFree( alt.expr->get_result() );
    138136                                        *out++ = alt;
    139137                                }
    140138                        }
    141 
    142139                }
    143140
    … …  
    170167
    171168                void renameTypes( Expression *expr ) {
    172                         for ( std::list< Type* >::iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
    173                                 (*i)->accept( global_renamer );
    174                         }
     169                        expr->get_result()->accept( global_renamer );
    175170                }
    176171        }
    … …  
    204199                for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
    205200                        if ( adjust ) {
    206                                 adjustExprTypeList( i->expr->get_results().begin(), i->expr->get_results().end(), i->env, indexer );
     201                                adjustExprType( i->expr->get_result(), i->env, indexer );
    207202                        }
    208203                }
    … …  
    259254
    260255        Cost computeConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
    261                 ApplicationExpr *appExpr = dynamic_cast< ApplicationExpr* >( alt.expr );
    262                 assert( appExpr );
    263                 PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
    264                 assert( pointer );
    265                 FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
    266                 assert( function );
     256                ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
     257                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
     258                FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
    267259
    268260                Cost convCost( 0, 0, 0 );
    … …  
    275267                                (*actualExpr)->print( std::cerr, 8 );
    276268                                std::cerr << "--- results are" << std::endl;
    277                                 printAll( (*actualExpr)->get_results(), std::cerr, 8 );
     269                                (*actualExpr)->get_result()->print( std::cerr, 8 );
    278270                        )
    279271                        std::list< DeclarationWithType* >::iterator startFormal = formal;
    280272                        Cost actualCost;
    281                         for ( std::list< Type* >::iterator actual = (*actualExpr)->get_results().begin(); actual != (*actualExpr)->get_results().end(); ++actual ) {
     273                        // xxx - tuple type matching
     274                        std::list< Type * > flatActualTypes;
     275                        flatten( (*actualExpr)->get_result(), back_inserter( flatActualTypes ) );
     276                        for ( std::list< Type* >::iterator actual = flatActualTypes.begin(); actual != flatActualTypes.end(); ++actual ) {
    282277                                if ( formal == formals.end() ) {
    283278                                        if ( function->get_isVarArgs() ) {
    … …  
    383378                std::list< DeclarationWithType* >::iterator formal = formals.begin();
    384379                for ( AltList::const_iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
    385                         for ( std::list< Type* >::iterator actual = actualExpr->expr->get_results().begin(); actual != actualExpr->expr->get_results().end(); ++actual ) {
     380                        std::list< Type * > flatActualTypes;
     381                        flatten( actualExpr->expr->get_result(), back_inserter( flatActualTypes ) );
     382                        for ( std::list< Type* >::iterator actual = flatActualTypes.begin(); actual != flatActualTypes.end(); ++actual ) {
    386383                                if ( formal == formals.end() ) {
    387384                                        return isVarArgs;
    … …  
    500497                                //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
    501498                                Expression *varExpr = new VariableExpr( candDecl );
    502                                 deleteAll( varExpr->get_results() );
    503                                 varExpr->get_results().clear();
    504                                 varExpr->get_results().push_front( adjType->clone() );
     499                                delete varExpr->get_result();
     500                                varExpr->set_result( adjType->clone() );
    505501                                PRINT(
    506502                                        std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
    … …  
    574570                                PointerType pt( Type::Qualifiers(), v.clone() );
    575571                                UntypedExpr *vexpr = untypedExpr->clone();
    576                                 vexpr->get_results().push_front( pt.clone() );
     572                                vexpr->set_result( pt.clone() );
    577573                                alternatives.push_back( Alternative( vexpr, env, Cost()) );
    578574                                return;
    … …  
    604600                                // check if the type is pointer to function
    605601                                PointerType *pointer;
    606                                 if ( func->expr->get_results().size() == 1 && ( pointer = dynamic_cast< PointerType* >( func->expr->get_results().front() ) ) ) {
     602                                if ( ( pointer = dynamic_cast< PointerType* >( func->expr->get_result() ) ) ) {
    607603                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
    608604                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
    … …  
    640636                                                // check if the type is pointer to function
    641637                                                PointerType *pointer;
    642                                                 if ( funcOp->expr->get_results().size() == 1
    643                                                         && ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_results().front() ) ) ) {
     638                                                if ( ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result() ) ) ) {
    644639                                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
    645640                                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
    … …  
    665660
    666661                        PRINT(
    667                                 ApplicationExpr *appExpr = dynamic_cast< ApplicationExpr* >( withFunc->expr );
    668                                 assert( appExpr );
    669                                 PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
    670                                 assert( pointer );
    671                                 FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
    672                                 assert( function );
     662                                ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( withFunc->expr );
     663                                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
     664                                FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
    673665                                std::cerr << "Case +++++++++++++" << std::endl;
    674666                                std::cerr << "formals are:" << std::endl;
    … …  
    692684
    693685        bool isLvalue( Expression *expr ) {
    694                 for ( std::list< Type* >::const_iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
    695                         if ( !(*i)->get_isLvalue() ) return false;
    696                 } // for
    697                 return true;
     686                // xxx - recurse into tuples?
     687                return expr->has_result() && expr->get_result()->get_isLvalue();
    698688        }
    699689
    … …  
    709699
    710700        void AlternativeFinder::visit( CastExpr *castExpr ) {
    711                 for ( std::list< Type* >::iterator i = castExpr->get_results().begin(); i != castExpr->get_results().end(); ++i ) {
    712                         *i = resolveTypeof( *i, indexer );
    713                         SymTab::validateType( *i, &indexer );
    714                         adjustExprType( *i, env, indexer );
    715                 } // for
     701                Type *& toType = castExpr->get_result();
     702                toType = resolveTypeof( toType, indexer );
     703                SymTab::validateType( toType, &indexer );
     704                adjustExprType( toType, env, indexer );
    716705
    717706                AlternativeFinder finder( indexer, env );
    … …  
    727716                        // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
    728717                        // to.
    729                         int discardedValues = (*i).expr->get_results().size() - castExpr->get_results().size();
     718                        int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size();
    730719                        if ( discardedValues < 0 ) continue;
    731                         std::list< Type* >::iterator candidate_end = (*i).expr->get_results().begin();
    732                         std::advance( candidate_end, castExpr->get_results().size() );
     720                        // xxx - may need to go into tuple types and extract relavent types and use unifyList
    733721                        // unification run for side-effects
    734                         unifyList( castExpr->get_results().begin(), castExpr->get_results().end(),
    735                                            (*i).expr->get_results().begin(), candidate_end,
    736                                    i->env, needAssertions, haveAssertions, openVars, indexer );
    737                         Cost thisCost = castCostList( (*i).expr->get_results().begin(), candidate_end,
    738                                                                                   castExpr->get_results().begin(), castExpr->get_results().end(),
    739                                                                                   indexer, i->env );
     722                        unify( castExpr->get_result(), (*i).expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
     723                        Cost thisCost = castCost( (*i).expr->get_result(), castExpr->get_result(), indexer, i->env );
    740724                        if ( thisCost != Cost::infinity ) {
    741725                                // count one safe conversion for each value that is thrown away
    … …  
    760744
    761745                for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
    762                         if ( agg->expr->get_results().size() == 1 ) {
    763                                 if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) {
    764                                         addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
    765                                 } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) {
    766                                         addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
    767                                 } // if
     746                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) {
     747                                addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
     748                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_result() ) ) {
     749                                addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
    768750                        } // if
    769751                } // for
    … …  
    894876                        alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
    895877                        for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
    896                                 alternatives.back().expr->get_results().push_back( (*i)->get_type()->clone() );
     878                                alternatives.back().expr->set_result( (*i)->get_type()->clone() );
    897879                        } // for
    898880                } // if
    … …  
    917899                                                        finder.find( attrExpr->get_expr() );
    918900                                                        for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
    919                                                                 if ( choice->expr->get_results().size() == 1 ) {
    920                                                                         resolveAttr(*i, function, choice->expr->get_results().front(), choice->env );
     901                                                                if ( choice->expr->get_result()->size() == 1 ) {
     902                                                                        resolveAttr(*i, function, choice->expr->get_result(), choice->env );
    921903                                                                } // fi
    922904                                                        } // for
    … …  
    960942                                        AssertionSet needAssertions, haveAssertions;
    961943                                        Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost );
    962                                         std::list< Type* > commonTypes;
    963                                         if ( unifyList( second->expr->get_results().begin(), second->expr->get_results().end(), third->expr->get_results().begin(), third->expr->get_results().end(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonTypes ) ) {
     944                                        Type* commonType;
     945                                        if ( unify( second->expr->get_result(), third->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
    964946                                                ConditionalExpr *newExpr = new ConditionalExpr( first->expr->clone(), second->expr->clone(), third->expr->clone() );
    965                                                 std::list< Type* >::const_iterator original = second->expr->get_results().begin();
    966                                                 std::list< Type* >::const_iterator commonType = commonTypes.begin();
    967                                                 for ( ; original != second->expr->get_results().end() && commonType != commonTypes.end(); ++original, ++commonType ) {
    968                                                         if ( *commonType ) {
    969                                                                 newExpr->get_results().push_back( *commonType );
    970                                                         } else {
    971                                                                 newExpr->get_results().push_back( (*original)->clone() );
    972                                                         } // if
    973                                                 } // for
     947                                                newExpr->set_result( commonType ? commonType : second->expr->get_result()->clone() );
    974948                                                newAlt.expr = newExpr;
    975949                                                inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );
    … …  
    999973                        TupleExpr *newExpr = new TupleExpr;
    1000974                        makeExprList( *i, newExpr->get_exprs() );
    1001                         for ( std::list< Expression* >::const_iterator resultExpr = newExpr->get_exprs().begin(); resultExpr != newExpr->get_exprs().end(); ++resultExpr ) {
    1002                                 for ( std::list< Type* >::const_iterator resultType = (*resultExpr)->get_results().begin(); resultType != (*resultExpr)->get_results().end(); ++resultType ) {
    1003                                         newExpr->get_results().push_back( (*resultType)->clone() );
    1004                                 } // for
     975                        for ( Expression * resultExpr : newExpr->get_exprs() ) {
     976                                newExpr->set_result( resultExpr->get_result()->clone() );
    1005977                        } // for
    1006978

  • TabularUnified src/ResolvExpr/AlternativePrinter.cc

    r96a10cd r906e24d  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // AlternativePrinter.cc -- 
     7// AlternativePrinter.cc --
    88//
    99// Author           : Richard C. Bilson
    … …  
    3333                for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
    3434                        os << "Alternative " << count++ << " ==============" << std::endl;
    35                         printAll( i->expr->get_results(), os );
     35                        i->expr->get_result()->print( os );
    3636                        //    i->print( os );
    3737                        os << std::endl;

  • TabularUnified src/ResolvExpr/ResolveTypeof.cc

    r96a10cd r906e24d  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ResolveTypeof.cc -- 
     7// ResolveTypeof.cc --
    88//
    99// Author           : Richard C. Bilson
    … …  
    5858                if ( typeofType->get_expr() ) {
    5959                        Expression *newExpr = resolveInVoidContext( typeofType->get_expr(), indexer );
    60                         assert( newExpr->get_results().size() > 0 );
    61                         Type *newType;
    62                         if ( newExpr->get_results().size() > 1 ) {
    63                                 TupleType *tupleType = new TupleType( Type::Qualifiers() );
    64                                 cloneAll( newExpr->get_results(), tupleType->get_types() );
    65                                 newType = tupleType;
    66                         } else {
    67                                 newType = newExpr->get_results().front()->clone();
    68                         } // if
     60                        assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() );
     61                        Type *newType = newExpr->get_result();
    6962                        delete typeofType;
    7063                        return newType;

  • TabularUnified src/ResolvExpr/Resolver.cc

    r96a10cd r906e24d  
    1919#include "RenameVars.h"
    2020#include "ResolveTypeof.h"
     21#include "typeops.h"
    2122#include "SynTree/Statement.h"
    2223#include "SynTree/Type.h"
    … …  
    6768          void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
    6869          void fallbackInit( ConstructorInit * ctorInit );
    69                 std::list< Type * > functionReturn;
     70                Type * functionReturn;
    7071                Type *initContext;
    7172                Type *switchType;
    … …  
    155156                        const TypeEnvironment *newEnv = 0;
    156157                        for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
    157                                 if ( i->expr->get_results().size() == 1 && isIntegralType( i->expr->get_results().front() ) ) {
     158                                if ( i->expr->get_result()->size() == 1 && isIntegralType( i->expr->get_result() ) ) {
    158159                                        if ( newExpr ) {
    159160                                                throw SemanticError( "Too many interpretations for case control expression", untyped );
    … …  
    232233                Type *new_type = resolveTypeof( functionDecl->get_type(), *this );
    233234                functionDecl->set_type( new_type );
    234                 std::list< Type * > oldFunctionReturn = functionReturn;
    235                 functionReturn.clear();
    236                 for ( std::list< DeclarationWithType * >::const_iterator i = functionDecl->get_functionType()->get_returnVals().begin(); i != functionDecl->get_functionType()->get_returnVals().end(); ++i ) {
    237                         functionReturn.push_back( (*i)->get_type() );
    238                 } // for
     235                ValueGuard< Type * > oldFunctionReturn( functionReturn );
     236                functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
    239237                SymTab::Indexer::visit( functionDecl );
    240                 functionReturn = oldFunctionReturn;
    241238        }
    242239
    … …  
    336333        void Resolver::visit( ReturnStmt *returnStmt ) {
    337334                if ( returnStmt->get_expr() ) {
    338                         CastExpr *castExpr = new CastExpr( returnStmt->get_expr() );
    339                         cloneAll( functionReturn, castExpr->get_results() );
     335                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
    340336                        Expression *newExpr = findSingleExpression( castExpr, *this );
    341337                        delete castExpr;
    … …  
    382378                                if ( isCharType( at->get_base() ) ) {
    383379                                        // check if the resolved type is char *
    384                                         if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_results().front() ) ) {
     380                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
    385381                                                if ( isCharType( pt->get_base() ) ) {
    386382                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";

  • TabularUnified src/ResolvExpr/Unify.cc

    r96a10cd r906e24d  
    588588        }
    589589
     590        // xxx - compute once and store in the FunctionType?
     591        Type * extractResultType( FunctionType * function ) {
     592                if ( function->get_returnVals().size() == 0 ) {
     593                        return new VoidType( Type::Qualifiers() );
     594                } else if ( function->get_returnVals().size() == 1 ) {
     595                        return function->get_returnVals().front()->get_type()->clone();
     596                } else {
     597                        TupleType * tupleType = new TupleType( Type::Qualifiers() );
     598                        for ( DeclarationWithType * decl : function->get_returnVals() ) {
     599                                tupleType->get_types().push_back( decl->get_type()->clone() );
     600                        } // for
     601                        return tupleType;
     602                }
     603        }
     604
    590605} // namespace ResolvExpr
    591606

  • TabularUnified src/ResolvExpr/typeops.h

    r96a10cd r906e24d  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // typeops.h -- 
     7// typeops.h --
    88//
    99// Author           : Richard C. Bilson
    … …  
    3030                typedef typename InputIterator::value_type SetType;
    3131                typedef typename std::list< typename SetType::value_type > ListType;
    32  
     32
    3333                if ( begin == end )     {
    3434                        *out++ = ListType();
    3535                        return;
    3636                } // if
    37  
     37
    3838                InputIterator current = begin;
    3939                begin++;
    … …  
    4141                std::list< ListType > recursiveResult;
    4242                combos( begin, end, back_inserter( recursiveResult ) );
    43  
     43
    4444                for ( typename std::list< ListType >::const_iterator i = recursiveResult.begin(); i != recursiveResult.end(); ++i ) {
    4545                        for ( typename ListType::const_iterator j = current->begin(); j != current->end(); ++j ) {
    … …  
    5252                } // for
    5353        }
    54  
     54
    5555        // in AdjustExprType.cc
    5656        /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function
    … …  
    144144        }
    145145
     146        /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
     147        Type * extractResultType( FunctionType * functionType );
     148
    146149        // in CommonType.cc
    147150        Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
    … …  
    152155        // in Occurs.cc
    153156        bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
     157
     158        // flatten tuple type into list of types
     159        template< typename OutputIterator >
     160        void flatten( Type * type, OutputIterator out ) {
     161                if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
     162                        for ( Type * t : tupleType->get_types() ) {
     163                                flatten( t, out );
     164                        }
     165                } else {
     166                        *out++ = type;
     167                }
     168        }
    154169} // namespace ResolvExpr
    155170
Note: See TracChangeset for help on using the changeset viewer.