Changeset b78c54f for src

Timestamp:

Apr 12, 2024, 7:49:21 AM (18 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

3e1cd17, 90320ac

Parents:

feb999f (diff), ab780e6 (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 branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/Pass.proto.hpp (modified) (3 diffs)
• Parser/StatementNode.cc (modified) (10 diffs)
• Parser/module.mk (modified) (1 diff)
• Parser/parserutility.cc (deleted)
• Parser/parserutility.h (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (4 diffs)
• ResolvExpr/CandidateFinder.hpp (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (7 diffs)

src/AST/Pass.proto.hpp

@@ -226 +226 @@
                 // Now the original containers should still have the unchanged values
                 // but also contain the new values.
-        }
-};
-
-/// Used by previsit implementation
-/// We need to reassign the result to 'node', unless the function
-/// returns void, then we just leave 'node' unchanged
-template<bool is_void>
-struct __assign;
-
-template<>
-struct __assign<true> {
-        template<typename core_t, typename node_t>
-        static inline void result( core_t & core, const node_t * & node ) {
-                core.previsit( node );
-        }
-};
-
-template<>
-struct __assign<false> {
-        template<typename core_t, typename node_t>
-        static inline void result( core_t & core, const node_t * & node ) {
-                node = core.previsit( node );
-                assertf(node, "Previsit must not return NULL");
-        }
-};
-
-/// Used by postvisit implementation
-/// We need to return the result unless the function
-/// returns void, then we just return the original node
-template<bool is_void>
-struct __return;
-
-template<>
-struct __return<true> {
-        template<typename core_t, typename node_t>
-        static inline const node_t * result( core_t & core, const node_t * & node ) {
-                core.postvisit( node );
-                return node;
-        }
-};
-
-template<>
-struct __return<false> {
-        template<typename core_t, typename node_t>
-        static inline auto result( core_t & core, const node_t * & node ) {
-                return core.postvisit( node );
         }
 };
@@ -297 +251 @@
         );
 
-        __assign<
-                std::is_void<
-                        decltype( core.previsit( node ) )
-                >::value
-        >::result( core, node );
+        // We need to reassign the result to 'node', unless the function
+        // returns void, then we just leave 'node' unchanged
+        if constexpr ( std::is_void_v<decltype( core.previsit( node ) )> ) {
+                core.previsit( node );
+        } else {
+                node = core.previsit( node );
+                assertf(node, "Previsit must not return NULL");
+        }
 }
 
@@ -312 +269 @@
         decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
 {
-        return __return<
-                std::is_void<
-                        decltype( core.postvisit( node ) )
-                >::value
-        >::result( core, node );
+        // We need to return the result unless the function
+        // returns void, then we just return the original node
+        if constexpr ( std::is_void_v<decltype( core.postvisit( node ) )> ) {
+                core.postvisit( node );
+                return node;
+        } else {
+                return core.postvisit( node );
+        }
 }
 

src/Parser/StatementNode.cc

@@ -122 +122 @@
         ast::Expr * cond = nullptr;
         if ( ctl->condition ) {
-                // compare the provided condition against 0
-                cond = notZeroExpr( maybeMoveBuild( ctl->condition ) );
+                cond = maybeMoveBuild( ctl->condition );
         } else {
                 for ( ast::ptr<ast::Stmt> & stmt : inits ) {
@@ -129 +128 @@
                         auto declStmt = stmt.strict_as<ast::DeclStmt>();
                         auto dwt = declStmt->decl.strict_as<ast::DeclWithType>();
-                        ast::Expr * nze = notZeroExpr( new ast::VariableExpr( dwt->location, dwt ) );
+                        ast::Expr * nze = new ast::VariableExpr( dwt->location, dwt );
                         cond = cond ? new ast::LogicalExpr( dwt->location, cond, nze, ast::AndExpr ) : nze;
                 }
@@ -200 +199 @@
         // do-while cannot have declarations in the contitional, so init is always empty
         return new ast::WhileDoStmt( location,
-                notZeroExpr( maybeMoveBuild( ctl ) ),
+                maybeMoveBuild( ctl ),
                 buildMoveSingle( stmt ),
                 buildMoveOptional( else_ ),
@@ -213 +212 @@
 
         ast::Expr * astcond = nullptr;                                          // maybe empty
-        astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) );
+        astcond = maybeMoveBuild( forctl->condition );
 
         ast::Expr * astincr = nullptr;                                          // maybe empty
@@ -330 +329 @@
         clause->target = maybeBuild( targetExpr );
         clause->stmt = maybeMoveBuild( stmt );
-        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+        clause->when_cond = maybeMoveBuild( when );
 
         ExpressionNode * next = targetExpr->next;
@@ -345 +344 @@
 ast::WaitForStmt * build_waitfor_else( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, StatementNode * stmt ) {
         existing->else_stmt = maybeMoveBuild( stmt );
-        existing->else_cond = notZeroExpr( maybeMoveBuild( when ) );
+        existing->else_cond = maybeMoveBuild( when );
 
         (void)location;
@@ -354 +353 @@
         existing->timeout_time = maybeMoveBuild( timeout );
         existing->timeout_stmt = maybeMoveBuild( stmt );
-        existing->timeout_cond = notZeroExpr( maybeMoveBuild( when ) );
+        existing->timeout_cond = maybeMoveBuild( when );
 
         (void)location;
@@ -362 +361 @@
 ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
         ast::WhenClause * clause = new ast::WhenClause( loc );
-        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+        clause->when_cond = maybeMoveBuild( when );
         clause->stmt = maybeMoveBuild( stmt );
         clause->target = maybeMoveBuild( targetExpr );
@@ -369 +368 @@
 ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation & loc, ExpressionNode * when, StatementNode * stmt ) {
         ast::WhenClause * clause = new ast::WhenClause( loc );
-        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+        clause->when_cond = maybeMoveBuild( when );
         clause->stmt = maybeMoveBuild( stmt );
         return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::ELSE, clause );
@@ -508 +507 @@
 
         ast::Expr * astcond = nullptr;                                          // maybe empty
-        astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) );
+        astcond = maybeMoveBuild( forctl->condition );
 
         ast::Expr * astincr = nullptr;                                          // maybe empty

src/Parser/module.mk

@@ -31 +31 @@
        Parser/parser.yy \
        Parser/ParserTypes.h \
-       Parser/parserutility.cc \
        Parser/parserutility.h \
        Parser/RunParser.cpp \

src/Parser/parserutility.h

@@ -17 +17 @@
 
 #include "AST/Copy.hpp"            // for shallowCopy
-namespace ast {
-        class Expr;
-}
-
-ast::Expr * notZeroExpr( const ast::Expr *orig );
 
 template< typename T >

src/ResolvExpr/CandidateFinder.cpp

@@ -46 +46 @@
 #include "AST/Type.hpp"
 #include "Common/utility.h"       // for move, copy
-#include "Parser/parserutility.h" // for notZeroExpr
 #include "SymTab/Mangler.h"
 #include "Tuples/Tuples.h"        // for handleTupleAssignment
@@ -1587 +1586 @@
         void Finder::postvisit( const ast::LogicalExpr * logicalExpr ) {
                 CandidateFinder finder1( context, tenv );
-                ast::ptr<ast::Expr> arg1 = notZeroExpr( logicalExpr->arg1 );
+                ast::ptr<ast::Expr> arg1 = createCondExpr( logicalExpr->arg1 );
                 finder1.find( arg1, ResolveMode::withAdjustment() );
                 if ( finder1.candidates.empty() ) return;
 
                 CandidateFinder finder2( context, tenv );
-                ast::ptr<ast::Expr> arg2 = notZeroExpr( logicalExpr->arg2 );
+                ast::ptr<ast::Expr> arg2 = createCondExpr( logicalExpr->arg2 );
                 finder2.find( arg2, ResolveMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
@@ -1618 +1617 @@
         void Finder::postvisit( const ast::ConditionalExpr * conditionalExpr ) {
                 // candidates for condition
-                ast::ptr<ast::Expr> arg1 = notZeroExpr( conditionalExpr->arg1 );
+                ast::ptr<ast::Expr> arg1 = createCondExpr( conditionalExpr->arg1 );
                 CandidateFinder finder1( context, tenv );
                 finder1.find( arg1, ResolveMode::withAdjustment() );
@@ -2201 +2200 @@
 }
 
+const ast::Expr * createCondExpr( const ast::Expr * expr ) {
+        assert( expr );
+        return new ast::CastExpr( expr->location,
+                ast::UntypedExpr::createCall( expr->location,
+                        "?!=?",
+                        {
+                                expr,
+                                new ast::ConstantExpr( expr->location,
+                                        new ast::ZeroType(), "0", std::make_optional( 0ull )
+                                ),
+                        }
+                ),
+                new ast::BasicType( ast::BasicType::SignedInt )
+        );
+}
+
 } // namespace ResolvExpr
 

src/ResolvExpr/CandidateFinder.hpp

@@ -70 +70 @@
         const ast::Expr * expr, Cost & cost );
 
+/// Wrap an expression to convert the result to a conditional result.
+const ast::Expr * createCondExpr( const ast::Expr * expr );
+
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -340 +340 @@
         }
 
+        ast::ptr< ast::Expr > findCondExpression(
+                const ast::Expr * untyped, const ResolveContext & context
+        ) {
+                if ( nullptr == untyped ) return untyped;
+                ast::ptr<ast::Expr> condExpr = createCondExpr( untyped );
+                return findIntegralExpression( condExpr, context );
+        }
+
         /// check if a type is a character type
         bool isCharType( const ast::Type * t ) {
@@ -356 +364 @@
                 return it != end;
         }
-}
+} // anonymous namespace
 
 class Resolver final
@@ -729 +737 @@
 const ast::IfStmt * Resolver::previsit( const ast::IfStmt * ifStmt ) {
         return ast::mutate_field(
-                ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, context ) );
+                ifStmt, &ast::IfStmt::cond, findCondExpression( ifStmt->cond, context ) );
 }
 
 const ast::WhileDoStmt * Resolver::previsit( const ast::WhileDoStmt * whileDoStmt ) {
         return ast::mutate_field(
-                whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, context ) );
+                whileDoStmt, &ast::WhileDoStmt::cond, findCondExpression( whileDoStmt->cond, context ) );
 }
 
@@ -740 +748 @@
         if ( forStmt->cond ) {
                 forStmt = ast::mutate_field(
-                        forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, context ) );
+                        forStmt, &ast::ForStmt::cond, findCondExpression( forStmt->cond, context ) );
         }
 
@@ -1075 +1083 @@
 
                 // Resolve the conditions as if it were an IfStmt, statements normally
-                clause2->when_cond = findSingleExpression( clause.when_cond, context );
+                clause2->when_cond = findCondExpression( clause.when_cond, context );
                 clause2->stmt = clause.stmt->accept( *visitor );
 
@@ -1089 +1097 @@
                         new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
                 auto timeout_time = findSingleExpression( stmt->timeout_time, target, context );
-                auto timeout_cond = findSingleExpression( stmt->timeout_cond, context );
+                auto timeout_cond = findCondExpression( stmt->timeout_cond, context );
                 auto timeout_stmt = stmt->timeout_stmt->accept( *visitor );
 
@@ -1102 +1110 @@
         if ( stmt->else_stmt ) {
                 // resolve the condition like IfStmt, stmts normally
-                auto else_cond = findSingleExpression( stmt->else_cond, context );
+                auto else_cond = findCondExpression( stmt->else_cond, context );
                 auto else_stmt = stmt->else_stmt->accept( *visitor );