Changes in / [1cb758f2:eca3d10a]


Ignore:
Location:
src
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • src/GenPoly/Box.cc

    r1cb758f2 reca3d10a  
    756756                                Type * newType = arg->get_result()->clone();
    757757                                if ( env ) env->apply( newType );
    758                                 std::unique_ptr<Type> manager( newType );
     758                                std::auto_ptr<Type> manager( newType );
    759759                                if ( isPolyType( newType ) ) {
    760760                                        // if the argument's type is polymorphic, we don't need to box again!
    … …  
    774774                                        newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
    775775                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
    776                                         UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax?
     776                                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
    777777                                        assign->get_args().push_back( new VariableExpr( newObj ) );
    778778                                        assign->get_args().push_back( arg );

  • src/InitTweak/InitTweak.cc

    r1cb758f2 reca3d10a  
    418418                        assertf( ! tuple->get_exprs().empty(), "TupleAssignExpr somehow has empty tuple expr." );
    419419                        return getCallArg( tuple->get_exprs().front(), pos );
    420                 } else if ( ImplicitCopyCtorExpr * copyCtor = dynamic_cast< ImplicitCopyCtorExpr * >( callExpr ) ) {
    421                         return getCallArg( copyCtor->callExpr, pos );
    422420                } else {
    423421                        assertf( false, "Unexpected expression type passed to getCallArg: %s", toString( callExpr ).c_str() );
    … …  
    452450                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( func ) ) {
    453451                                return handleDerefName( appExpr );
    454                         } else if ( ConstructorExpr * ctorExpr = dynamic_cast< ConstructorExpr * >( func ) ) {
    455                                 return funcName( getCallArg( ctorExpr->get_callExpr(), 0 ) );
    456452                        } else {
    457                                 assertf( false, "Unexpected expression type being called as a function in call expression: %s", toString( func ).c_str() );
     453                                assertf( false, "Unexpected expression type being called as a function in call expression" );
    458454                        }
    459455                }

  • src/ResolvExpr/AlternativeFinder.cc

    r1cb758f2 reca3d10a  
    698698
    699699        void AlternativeFinder::visit( UntypedExpr *untypedExpr ) {
     700                bool doneInit = false;
     701                AlternativeFinder funcOpFinder( indexer, env );
     702
     703                AlternativeFinder funcFinder( indexer, env );
     704
    700705                {
    701706                        std::string fname = InitTweak::getFunctionName( untypedExpr );
    … …  
    710715                }
    711716
    712                 AlternativeFinder funcFinder( indexer, env );
    713717                funcFinder.findWithAdjustment( untypedExpr->get_function() );
    714                 // if there are no function alternatives, then proceeding is a waste of time.
    715                 if ( funcFinder.alternatives.empty() ) return;
    716 
    717718                std::list< AlternativeFinder > argAlternatives;
    718719                findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(), back_inserter( argAlternatives ) );
    … …  
    724725                // if not tuple assignment, assignment is taken care of as a normal function call
    725726                Tuples::handleTupleAssignment( *this, untypedExpr, possibilities );
    726 
    727                 // find function operators
    728                 AlternativeFinder funcOpFinder( indexer, env );
    729                 NameExpr *opExpr = new NameExpr( "?()" );
    730                 try {
    731                         funcOpFinder.findWithAdjustment( opExpr );
    732                 } catch( SemanticError &e ) {
    733                         // it's ok if there aren't any defined function ops
    734                 }
    735                 PRINT(
    736                         std::cerr << "known function ops:" << std::endl;
    737                         printAlts( funcOpFinder.alternatives, std::cerr, 8 );
    738                 )
    739727
    740728                AltList candidates;
    … …  
    766754                                                } // if
    767755                                        } // if
    768                                 }
    769 
    770                                 // try each function operator ?() with the current function alternative and each of the argument combinations
    771                                 for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
    772                                         // check if the type is pointer to function
    773                                         if ( PointerType *pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result()->stripReferences() ) ) {
    774                                                 if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
    775                                                         referenceToRvalueConversion( funcOp->expr );
    776                                                         for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
    777                                                                 AltList currentAlt;
    778                                                                 currentAlt.push_back( *func );
    779                                                                 currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() );
    780                                                                 makeFunctionAlternatives( *funcOp, function, currentAlt, std::back_inserter( candidates ) );
    781                                                         } // for
     756                                } else {
     757                                        // seek a function operator that's compatible
     758                                        if ( ! doneInit ) {
     759                                                doneInit = true;
     760                                                NameExpr *opExpr = new NameExpr( "?()" );
     761                                                try {
     762                                                        funcOpFinder.findWithAdjustment( opExpr );
     763                                                } catch( SemanticError &e ) {
     764                                                        // it's ok if there aren't any defined function ops
     765                                                }
     766                                                PRINT(
     767                                                        std::cerr << "known function ops:" << std::endl;
     768                                                        printAlts( funcOpFinder.alternatives, std::cerr, 8 );
     769                                                )
     770                                        }
     771
     772                                        for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
     773                                                // check if the type is pointer to function
     774                                                if ( PointerType *pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result()->stripReferences() ) ) {
     775                                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
     776                                                                referenceToRvalueConversion( funcOp->expr );
     777                                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
     778                                                                        AltList currentAlt;
     779                                                                        currentAlt.push_back( *func );
     780                                                                        currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() );
     781                                                                        makeFunctionAlternatives( *funcOp, function, currentAlt, std::back_inserter( candidates ) );
     782                                                                } // for
     783                                                        } // if
    782784                                                } // if
    783                                         } // if
    784                                 } // for
     785                                        } // for
     786                                } // if
    785787                        } catch ( SemanticError &e ) {
    786788                                errors.append( e );

  • src/ResolvExpr/CastCost.cc

    r1cb758f2 reca3d10a  
    5858                        return Cost::safe;
    5959                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
    60                         return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer & indexer) {
    61                                 return ptrsCastable( t1, t2, env, indexer );
    62                         });
     60                        return convertToReferenceCost( src, refType, indexer, env );
    6361                } else {
    6462                        CastCost converter( dest, indexer, env );

  • src/ResolvExpr/ConversionCost.cc

    r1cb758f2 reca3d10a  
    4040#define PRINT(x)
    4141#endif
     42
    4243        Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    4344                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    … …  
    7778                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
    7879                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
    79                         return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer &){
    80                                 return ptrsAssignable( t1, t2, env );
    81                         });
     80                        return convertToReferenceCost( src, refType, indexer, env );
    8281                } else {
    8382                        ConversionCost converter( dest, indexer, env );
    … …  
    9190        }
    9291
    93         Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
     92        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
    9493                PRINT( std::cerr << "convert to reference cost..." << std::endl; )
    9594                if ( diff > 0 ) {
    9695                        // TODO: document this
    97                         Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
     96                        Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env );
    9897                        cost.incReference();
    9998                        return cost;
    10099                } else if ( diff < -1 ) {
    101100                        // TODO: document this
    102                         Cost cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
     101                        Cost cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env );
    103102                        cost.incReference();
    104103                        return cost;
    … …  
    111110                                        return Cost::safe;
    112111                                } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
    113                                         int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
     112                                        int assignResult = ptrsAssignable( srcAsRef->get_base(), destAsRef->get_base(), env );
    114113                                        PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
    115114                                        if ( assignResult < 0 ) {
    … …  
    158157        }
    159158
    160         Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
     159        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
    161160                int sdepth = src->referenceDepth(), ddepth = dest->referenceDepth();
    162                 return convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env, func );
     161                return convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env );
    163162        }
    164163

  • src/ResolvExpr/ConversionCost.h

    r1cb758f2 reca3d10a  
    1616#pragma once
    1717
    18 #include <functional>         // for function
    19 
    2018#include "Cost.h"             // for Cost
    2119#include "SynTree/Visitor.h"  // for Visitor
    … …  
    2321
    2422namespace SymTab {
    25         class Indexer;
     23class Indexer;
    2624}  // namespace SymTab
    2725
    2826namespace ResolvExpr {
    29         class TypeEnvironment;
     27class TypeEnvironment;
    3028
    3129        class ConversionCost : public Visitor {
    … …  
    5755        };
    5856
    59         typedef std::function<int(Type *, Type *, const TypeEnvironment &, const SymTab::Indexer &)> PtrsFunction;
    60         Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func );
     57        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env );
    6158} // namespace ResolvExpr
    6259

  • src/SymTab/Indexer.cc

    r1cb758f2 reca3d10a  
    345345                leaveScope();
    346346
    347                 debugPrint( "Adding trait " << aggregateDecl->get_name() << std::endl );
     347                debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl );
    348348                addTrait( aggregateDecl );
    349349        }

  • src/SymTab/Validate.cc

    r1cb758f2 reca3d10a  
    467467                        return;
    468468                }
    469 
    470                 // handle other traits
    471469                TraitDecl *traitDecl = indexer->lookupTrait( traitInst->get_name() );
    472470                if ( ! traitDecl ) {

  • src/SynTree/Expression.cc

    r1cb758f2 reca3d10a  
    645645                }
    646646        }
    647         // ensure that StmtExpr has a result type
    648         if ( ! result ) {
    649                 set_result( new VoidType( Type::Qualifiers() ) );
    650         }
    651647}
    652648StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {

  • src/tests/multiDimension.c

    r1cb758f2 reca3d10a  
    5959}
    6060
    61 // ensure constructed const arrays continue to compile
    62 const int global[1] = { -2 };
    63 
    6461int main() {
    6562  X abc[4][4] = {
Note: See TracChangeset for help on using the changeset viewer.