Changeset 937e51d for src/ResolvExpr

Timestamp:

Jun 26, 2015, 4:00:26 PM (10 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

0df292b, e0ff3e6

Parents:

eb50842 (diff), 1869adf (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 pointer to pointer to qualified fix into master

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (23 diffs)
• RenameVars.cc (modified) (2 diffs)
• Resolver.cc (modified) (9 diffs)
• module.mk (modified) (2 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 23:52:08 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat May 16 23:55:30 2015
-// Update Count     : 3
+// Last Modified On : Mon Jun 22 17:19:54 2015
+// Update Count     : 17
 //
 
@@ -108 +108 @@
                                                 PRINT(
                                                         std::cout << "cost " << candidate->cost << " beats " << mapPlace->second.candidate->cost << std::endl;
-                                                        )
+                                                )
                                                 selected[ mangleName ] = current;
                                         } else if ( candidate->cost == mapPlace->second.candidate->cost ) {
                                                 PRINT(
                                                         std::cout << "marking ambiguous" << std::endl;
-                                                        )
+                                                )
                                                 mapPlace->second.isAmbiguous = true;
                                         }
@@ -123 +123 @@
                         PRINT(
                                 std::cout << "there are " << selected.size() << " alternatives before elimination" << std::endl;
-                                )
+                        )
 
                         // accept the alternatives that were unambiguous
@@ -184 +184 @@
                                 std::cout << "findSubExprs" << std::endl;
                                 printAlts( finder.alternatives, std::cout );
-                                )
+                        )
                         *out++ = finder;
                 }
@@ -206 +206 @@
                         std::cout << "alternatives before prune:" << std::endl;
                         printAlts( alternatives, std::cout );
-                        )
+                )
                 AltList::iterator oldBegin = alternatives.begin();
                 pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
                 if ( alternatives.begin() == oldBegin ) {
-                        std::ostrstream stream;
+                        std::ostringstream stream;
                         stream << "Can't choose between alternatives for expression ";
                         expr->print( stream );
@@ -217 +217 @@
                         findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
                         printAlts( winners, stream, 8 );
-                        throw SemanticError( std::string( stream.str(), stream.pcount() ) );
+                        throw SemanticError( stream.str() );
                 }
                 alternatives.erase( oldBegin, alternatives.end() );
                 PRINT(
                         std::cout << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
-                        )
+                )
         }
 
@@ -265 +265 @@
                                 std::cout << "--- results are" << std::endl;
                                 printAll( (*actualExpr)->get_results(), std::cout, 8 );
-                                )
-                                std::list< DeclarationWithType* >::iterator startFormal = formal;
+                        )
+                        std::list< DeclarationWithType* >::iterator startFormal = formal;
                         Cost actualCost;
                         for ( std::list< Type* >::iterator actual = (*actualExpr)->get_results().begin(); actual != (*actualExpr)->get_results().end(); ++actual ) {
@@ -282 +282 @@
                                         std::cout << std::endl << " to ";
                                         (*formal)->get_type()->print( std::cout, 8 );
-                                        )
-                                        Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
+                                )
+                                Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
                                 PRINT(
                                         std::cout << std::endl << "cost is" << newCost << std::endl;
-                                        )
-
-                                        if ( newCost == Cost::infinity ) {
-                                                return newCost;
-                                        }
+                                )
+
+                                if ( newCost == Cost::infinity ) {
+                                        return newCost;
+                                }
                                 convCost += newCost;
                                 actualCost += newCost;
@@ -381 +381 @@
                                         (*actual)->print( std::cerr );
                                         std::cerr << std::endl;
-                                        )
+                                )
                                 if ( ! unify( (*formal)->get_type(), *actual, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
                                         return false;
@@ -429 +429 @@
                                         std::cerr << "recursing with new set:" << std::endl;
                                         printAssertionSet( newNeed, std::cerr, 8 );
-                                        )
+                                )
                                 inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, level+1, indexer, out );
                                 return;
@@ -444 +444 @@
                         curDecl->print( std::cerr );
                         std::cerr << std::endl;
-                        )
+                )
                 std::list< DeclarationWithType* > candidates;
                 decls.lookupId( curDecl->get_name(), candidates );
@@ -453 +453 @@
                                 (*candidate)->print( std::cout );
                                 std::cout << std::endl;
-                                )
+                        )
                         AssertionSet newHave, newerNeed( newNeed );
                         TypeEnvironment newEnv( newAlt.env );
@@ -466 +466 @@
                                 adjType->print( std::cerr );
                                 std::cerr << std::endl;
-                                )
+                        )
                         if ( unify( curDecl->get_type(), adjType, newEnv, newerNeed, newHave, newOpenVars, indexer ) ) {
                                 PRINT(
                                         std::cerr << "success!" << std::endl;
-                                        )
+                                )
                                 SymTab::Indexer newDecls( decls );
                                 addToIndexer( newHave, newDecls );
@@ -486 +486 @@
                                         (*candidate)->print( std::cout );
                                         std::cout << std::endl;
-                                        )
+                                )
                                 ApplicationExpr *appExpr = static_cast< ApplicationExpr* >( newerAlt.expr );
                                 // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
@@ -509 +509 @@
                         std::cout << "============= new indexer" << std::endl;
                         decls.print( std::cout );
-                        )
+                )
                 addToIndexer( have, decls );
                 AssertionSet newNeed;
@@ -533 +533 @@
                                 std::cout << "need assertions:" << std::endl;
                                 printAssertionSet( resultNeed, std::cout, 8 );
-                                )
+                        )
                         inferParameters( resultNeed, resultHave, newAlt, openVars, out );
                 }
@@ -542 +542 @@
                 AlternativeFinder funcOpFinder( indexer, env );
 
-                AlternativeFinder funcFinder( indexer, env );
-
-                {
+                AlternativeFinder funcFinder( indexer, env ); {
                         NameExpr *fname;
                         if ( ( fname = dynamic_cast<NameExpr *>( untypedExpr->get_function()))
-                                 && ( fname->get_name() == std::string("LabAddress")) ) {
-                                alternatives.push_back( Alternative( untypedExpr, env, Cost()) );
+                                 && ( fname->get_name() == std::string("&&")) ) {
+                                alternatives.push_back( Alternative( untypedExpr->clone(), env, Cost()) );
                                 return;
                         }
@@ -562 +560 @@
                 Tuples::TupleAssignSpotter tassign( this );
                 if ( tassign.isTupleAssignment( untypedExpr, possibilities ) ) {
-                        // TODO take care of possible tuple assignments, or discard expression
+                        // take care of possible tuple assignments, or discard expression
                         return;
                 } // else ...
@@ -572 +570 @@
                                 std::cout << "working on alternative: " << std::endl;
                                 func->print( std::cout, 8 );
-                                )
+                        )
                         // check if the type is pointer to function
                         PointerType *pointer;
@@ -605 +603 @@
                                                 std::cout << "known function ops:" << std::endl;
                                                 printAlts( funcOpFinder.alternatives, std::cout, 8 );
-                                                )
+                                        )
                                 }
 
@@ -644 +642 @@
                                 withFunc->env.print( std::cout, 8 );
                                 std::cout << "cost of conversion is:" << cvtCost << std::endl;
-                                )
-                                if ( cvtCost != Cost::infinity ) {
-                                        withFunc->cvtCost = cvtCost;
-                                        alternatives.push_back( *withFunc );
-                                } // if
+                        )
+                        if ( cvtCost != Cost::infinity ) {
+                                withFunc->cvtCost = cvtCost;
+                                alternatives.push_back( *withFunc );
+                        } // if
                 } // for
                 candidates.clear();
@@ -749 +747 @@
                                 newExpr.print( std::cerr );
                                 std::cerr << std::endl;
-                                )
+                        )
                         renameTypes( alternatives.back().expr );
                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
@@ -796 +794 @@
                         argType->print( std::cout );
                         std::cout << std::endl;
-                        )
-                        if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
-                                alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
-                                for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
-                                        alternatives.back().expr->get_results().push_back( (*i)->get_type()->clone() );
-                                } // for
-                        } // if
+                )
+                if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
+                        alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
+                        for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
+                                alternatives.back().expr->get_results().push_back( (*i)->get_type()->clone() );
+                        } // for
+                } // if
         }
 

src/ResolvExpr/RenameVars.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 12:05:18 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 12:07:59 2015
-// Update Count     : 2
+// Last Modified On : Mon Jun  8 14:51:35 2015
+// Update Count     : 4
 //
 
-#include <strstream>
+#include <sstream>
 
 #include "RenameVars.h"
@@ -122 +122 @@
                         // renames all "forall" type names to `_${level}_${name}'
                         for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
-                                std::ostrstream output;
+                                std::ostringstream output;
                                 output << "_" << level << "_" << (*i)->get_name();
-                                std::string newname( output.str(), output.pcount() );
+                                std::string newname( output.str() );
                                 mapStack.front()[ (*i)->get_name() ] = newname;
                                 (*i)->set_name( newname );

src/ResolvExpr/Resolver.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 12:18:17 2015
-// Update Count     : 2
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Jun 24 16:20:35 2015
+// Update Count     : 156
 //
 
@@ -38 +38 @@
                 virtual void visit( TypeDecl *typeDecl );
 
+                virtual void visit( ArrayType * at );
+
                 virtual void visit( ExprStmt *exprStmt );
                 virtual void visit( IfStmt *ifStmt );
@@ -45 +47 @@
                 virtual void visit( ChooseStmt *switchStmt );
                 virtual void visit( CaseStmt *caseStmt );
+                virtual void visit( BranchStmt *branchStmt );
                 virtual void visit( ReturnStmt *returnStmt );
 
@@ -50 +53 @@
                 virtual void visit( ListInit *listInit );
           private:
+        typedef std::list< Initializer * >::iterator InitIterator;
+
+          void resolveAggrInit( AggregateDecl *, InitIterator &, InitIterator & );
+          void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
+
                 std::list< Type * > functionReturn;
                 Type *initContext;
@@ -158 +166 @@
                 SymTab::Indexer::visit( objectDecl );
         }
-  
+
+        void Resolver::visit( ArrayType * at ) {
+                if ( at->get_dimension() ) {
+                        BasicType arrayLenType = BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+                        CastExpr *castExpr = new CastExpr( at->get_dimension(), arrayLenType.clone() );
+                        Expression *newExpr = findSingleExpression( castExpr, *this );
+                        delete at->get_dimension();
+                        at->set_dimension( newExpr );
+                }
+                Visitor::visit( at );
+        }
+
         void Resolver::visit( TypeDecl *typeDecl ) {
                 if ( typeDecl->get_base() ) {
@@ -166 +185 @@
                 SymTab::Indexer::visit( typeDecl );
         }
-  
+
         void Resolver::visit( FunctionDecl *functionDecl ) {
 #if 0
@@ -252 +271 @@
         }
 
+        void Resolver::visit( BranchStmt *branchStmt ) {
+                // must resolve the argument for a computed goto
+                if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement
+                        if ( NameExpr * arg = dynamic_cast< NameExpr * >( branchStmt->get_computedTarget() ) ) {
+                                VoidType v = Type::Qualifiers();                // cast to void * for the alternative finder
+                                PointerType pt( Type::Qualifiers(), v.clone() );
+                                CastExpr * castExpr = new CastExpr( arg, pt.clone() );
+                                Expression * newExpr = findSingleExpression( castExpr, *this ); // find best expression
+                                branchStmt->set_target( newExpr );
+                        } // if
+                } // if
+        }
+
         void Resolver::visit( ReturnStmt *returnStmt ) {
                 if ( returnStmt->get_expr() ) {
@@ -260 +292 @@
                         returnStmt->set_expr( newExpr );
                 } // if
+        }
+
+        template< typename T >
+        bool isCharType( T t ) {
+                if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
+                        return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar || 
+                                bt->get_kind() == BasicType::UnsignedChar;
+                }
+                return false;
         }
 
@@ -286 +327 @@
                         delete castExpr;
                         singleInit->set_value( newExpr );
+
+                        // check if initializing type is char[]
+                        if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
+                                if ( isCharType( at->get_base() ) ) {
+                                        // check if the resolved type is char *
+                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_results().front() ) ) {
+                                                if ( isCharType( pt->get_base() ) ) {
+                                                        // strip cast if we're initializing a char[] with a char *, e.g.
+                                                        // char x[] = "hello";
+                                                        CastExpr *ce = dynamic_cast< CastExpr * >( newExpr );
+                                                        singleInit->set_value( ce->get_arg() );
+                                                        ce->set_arg( NULL );
+                                                        delete ce;                                                                      
+                                                }
+                                        }
+                                }
+                        }
                 } // if
 //      singleInit->get_value()->accept( *this );
         }
 
-        void Resolver::visit( ListInit *listInit ) {
-                Visitor::visit(listInit);
+        void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd ) {
+                DeclarationWithType * dt = dynamic_cast< DeclarationWithType * >( dcl );
+                assert( dt );
+                initContext = dt->get_type();
+                try {
+                        if ( init == initEnd ) return; // stop when there are no more initializers
+                        (*init)->accept( *this );
+                        ++init; // made it past an initializer
+                } catch( SemanticError & ) {
+                        // need to delve deeper, if you can
+                        if ( StructInstType * sit = dynamic_cast< StructInstType * >( dt->get_type() ) ) {
+                                resolveAggrInit( sit->get_baseStruct(), init, initEnd );
+                        } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( dt->get_type() ) ) {
+                                resolveAggrInit( uit->get_baseUnion(), init, initEnd );
+                        } else {
+                                // member is not an aggregate type, so can't go any deeper
+
+                                // might need to rethink what is being thrown
+                                throw;
+                        } // if
+                }
+        }
+
+        void Resolver::resolveAggrInit( AggregateDecl * aggr, InitIterator & init, InitIterator & initEnd ) {
+                if ( StructDecl * st = dynamic_cast< StructDecl * >( aggr ) ) {
+                        // want to resolve each initializer to the members of the struct,
+                        // but if there are more initializers than members we should stop
+                        list< Declaration * >::iterator it = st->get_members().begin();
+                        for ( ; it != st->get_members().end(); ++it) {
+                                resolveSingleAggrInit( *it, init, initEnd );
+                        }
+                } else if ( UnionDecl * un = dynamic_cast< UnionDecl * >( aggr ) ) {
+                        // only resolve to the first member of a union
+                        resolveSingleAggrInit( *un->get_members().begin(), init, initEnd );
+                } // if
+        }
+
+        void Resolver::visit( ListInit * listInit ) {
+                InitIterator iter = listInit->begin_initializers();
+                InitIterator end = listInit->end_initializers();
+
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
+                        // resolve each member to the base type of the array
+                        for ( ; iter != end; ++iter ) {
+                                initContext = at->get_base();
+                                (*iter)->accept( *this );
+                        } // for
+                } else if ( StructInstType * st = dynamic_cast< StructInstType * >( initContext ) ) {
+                        resolveAggrInit( st->get_baseStruct(), iter, end );
+                } else if ( UnionInstType *st = dynamic_cast< UnionInstType * >( initContext ) ) {
+                        resolveAggrInit( st->get_baseUnion(), iter, end );
+                } else {
+                        // basic types are handled here
+                        Visitor::visit( listInit );
+                }
+
 #if 0
                 if ( ArrayType *at = dynamic_cast<ArrayType*>(initContext) ) {

src/ResolvExpr/module.mk

@@ +1 @@
+######################### -*- Mode: Makefile-Gmake -*- ########################
+##
+## Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+##
+## The contents of this file are covered under the licence agreement in the
+## file "LICENCE" distributed with Cforall.
+##
+## module.mk -- 
+##
+## Author           : Richard C. Bilson
+## Created On       : Mon Jun  1 17:49:17 2015
+## Last Modified By : Peter A. Buhr
+## Last Modified On : Mon Jun  1 17:53:28 2015
+## Update Count     : 1
+###############################################################################
+
 SRC += ResolvExpr/AlternativeFinder.cc \
-      ResolvExpr/Alternative.cc \
+       ResolvExpr/Alternative.cc \
        ResolvExpr/Unify.cc \
        ResolvExpr/PtrsAssignable.cc \
@@ -16 +32 @@
        ResolvExpr/Occurs.cc \
        ResolvExpr/TypeEnvironment.cc
-