Changeset 8f98b78 for src/ResolvExpr

Timestamp:

Sep 19, 2017, 3:55:54 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

764e009

Parents:

695e00d

Message:

Now properly resolve the calls to get_monitor

Location:

src/ResolvExpr

Files:

• Resolver.cc (modified) (8 diffs)
• Resolver.h (modified) (1 diff)

src/ResolvExpr/Resolver.cc

@@ -118 +118 @@
         }
 
+        Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                TypeEnvironment env;
+                AlternativeFinder finder( indexer, env );
+                finder.find( untyped );
+                #if 0
+                if ( finder.get_alternatives().size() != 1 ) {
+                        std::cout << "untyped expr is ";
+                        untyped->print( std::cout );
+                        std::cout << std::endl << "alternatives are:";
+                        for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
+                                i->print( std::cout );
+                        } // for
+                } // if
+                #endif
+                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
+                Alternative &choice = finder.get_alternatives().front();
+                Expression *newExpr = choice.expr->clone();
+                finishExpr( newExpr, choice.env );
+                return newExpr;
+        }
+
         namespace {
-                Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.find( untyped );
-#if 0
-                        if ( finder.get_alternatives().size() != 1 ) {
-                                std::cout << "untyped expr is ";
-                                untyped->print( std::cout );
-                                std::cout << std::endl << "alternatives are:";
-                                for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                        i->print( std::cout );
-                                } // for
-                        } // if
-#endif
-                        assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
-                        Alternative &choice = finder.get_alternatives().front();
-                        Expression *newExpr = choice.expr->clone();
-                        finishExpr( newExpr, choice.env );
-                        return newExpr;
-                }
-
                 bool isIntegralType( Type *type ) {
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
@@ -393 +393 @@
         }
 
-        inline void resolveAsIf( Expression *& expr, Resolver & resolver ) {
+        inline void resolveAsIf( Expression *& expr, SymTab::Indexer & indexer ) {
                 if( !expr ) return;
-                Expression * newExpr = findSingleExpression( expr, resolver );
+                Expression * newExpr = findSingleExpression( expr, indexer );
                 delete expr;
                 expr = newExpr;
         }
 
-        inline void resolveAsType( Expression *& expr, Type * type, Resolver & resolver ) {
+        inline void resolveAsType( Expression *& expr, Type * type, SymTab::Indexer & indexer ) {
                 if( !expr ) return;
-                Expression * newExpr = findSingleExpression( new CastExpr( expr, type ), resolver );
+                Expression * newExpr = findSingleExpression( new CastExpr( expr, type ), indexer );
                 delete expr;
                 expr = newExpr;
@@ -417 +417 @@
 
         void Resolver::previsit( WaitForStmt * stmt ) {
+                visit_children = false;
 
                 // Resolve all clauses first
@@ -422 +423 @@
 
                         TypeEnvironment env;
-                        AlternativeFinder funcFinder( *this, env );
+                        AlternativeFinder funcFinder( indexer, env );
 
                         // Find all alternatives for a function in canonical form
@@ -511 +512 @@
 
                                                                 // Check if the argument matches the parameter type in the current scope
-                                                                if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, *this ) ) {
+                                                                if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
                                                                         // Type doesn't match
                                                                         stringstream ss;
@@ -573 +574 @@
                         // Resolve the conditions as if it were an IfStmt
                         // Resolve the statments normally
-                        resolveAsIf( clause.condition, *this );
-                        clause.statement->accept( *this );
+                        resolveAsIf( clause.condition, this->indexer );
+                        clause.statement->accept( *visitor );
                 }
 
@@ -582 +583 @@
                         // Resolve the conditions as if it were an IfStmt
                         // Resolve the statments normally
-                        resolveAsType( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), *this );
-                        resolveAsIf  ( stmt->timeout.condition, *this );
-                        stmt->timeout.statement->accept( *this );
+                        resolveAsType( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
+                        resolveAsIf  ( stmt->timeout.condition, this->indexer );
+                        stmt->timeout.statement->accept( *visitor );
                 }
 
@@ -590 +591 @@
                         // Resolve the conditions as if it were an IfStmt
                         // Resolve the statments normally
-                        resolveAsIf( stmt->orelse.condition, *this );
-                        stmt->orelse.statement->accept( *this );
+                        resolveAsIf( stmt->orelse.condition, this->indexer );
+                        stmt->orelse.statement->accept( *visitor );
                 }
         }

src/ResolvExpr/Resolver.h

@@ -29 +29 @@
         /// Checks types and binds syntactic constructs to typed representations
         void resolve( std::list< Declaration * > translationUnit );
-        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
-        Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
+        Expression * resolveInVoidContext( Expression *expr   , const SymTab::Indexer &indexer );
+        Expression * findVoidExpression  ( Expression *untyped, const SymTab::Indexer &indexer );
+        Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer );
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );