Changeset e6cf857f

Timestamp:

May 18, 2022, 2:24:48 PM (2 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

288927f

Parents:

767a8ef

Message:

call -> createCall: The template wrapper has been removed and now it is beside similar helper functions.

Location:

src

Files:

• AST/Eval.hpp (deleted)
• AST/Expr.cpp (modified) (5 diffs)
• AST/Expr.hpp (modified) (1 diff)
• AST/module.mk (modified) (1 diff)
• SymTab/Autogen.h (modified) (14 diffs)

src/AST/Expr.cpp

@@ -10 +10 @@
 // Created On       : Wed May 15 17:00:00 2019
 // Last Modified By : Andrew Beach
-// Created On       : Tue Nov 30 14:23:00 2021
-// Update Count     : 7
+// Created On       : Wed May 18 13:56:00 2022
+// Update Count     : 8
 //
 
@@ -21 +21 @@
 
 #include "Copy.hpp"                // for shallowCopy
-#include "Eval.hpp"                // for call
 #include "GenericSubstitution.hpp"
 #include "LinkageSpec.hpp"
@@ -67 +66 @@
 // --- UntypedExpr
 
+bool UntypedExpr::get_lvalue() const {
+        std::string fname = InitTweak::getFunctionName( this );
+        return lvalueFunctionNames.count( fname );
+}
+
 UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, const Expr * arg ) {
         assert( arg );
 
-        UntypedExpr * ret = call( loc, "*?", arg );
+        UntypedExpr * ret = createCall( loc, "*?", { arg } );
         if ( const Type * ty = arg->result ) {
                 const Type * base = InitTweak::getPointerBase( ty );
@@ -87 +91 @@
 }
 
-bool UntypedExpr::get_lvalue() const {
-        std::string fname = InitTweak::getFunctionName( this );
-        return lvalueFunctionNames.count( fname );
-}
-
 UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs ) {
         assert( lhs && rhs );
 
-        UntypedExpr * ret = call( loc, "?=?", lhs, rhs );
+        UntypedExpr * ret = createCall( loc, "?=?", { lhs, rhs } );
         if ( lhs->result && rhs->result ) {
                 // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
@@ -102 +101 @@
         }
         return ret;
+}
+
+UntypedExpr * UntypedExpr::createCall( const CodeLocation & loc,
+                const std::string & name, std::vector<ptr<Expr>> && args ) {
+        return new UntypedExpr( loc,
+                        new NameExpr( loc, name ), std::move( args ) );
 }
 

src/AST/Expr.hpp

@@ -230 +230 @@
         /// Creates a new assignment expression
         static UntypedExpr * createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs );
+        /// Creates a new call of a variable.
+        static UntypedExpr * createCall( const CodeLocation & loc,
+                const std::string & name, std::vector<ptr<Expr>> && args );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/module.mk

@@ -29 +29 @@
         AST/DeclReplacer.cpp \
         AST/DeclReplacer.hpp \
-        AST/Eval.hpp \
         AST/Expr.cpp \
         AST/Expr.hpp \

src/SymTab/Autogen.h

@@ -21 +21 @@
 
 #include "AST/Decl.hpp"
-#include "AST/Eval.hpp"
 #include "AST/Expr.hpp"
 #include "AST/Init.hpp"
@@ -71 +70 @@
         template< typename OutIter >
         ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, OutIter && out,
                 const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
 
@@ -128 +127 @@
         }
 
-        /// inserts into out a generated call expression to function fname with arguments dstParam and 
+        /// inserts into out a generated call expression to function fname with arguments dstParam and
         /// srcParam. Should only be called with non-array types.
-        /// optionally returns a statement which must be inserted prior to the containing loop, if 
+        /// optionally returns a statement which must be inserted prior to the containing loop, if
         /// there is one
         template< typename OutIter >
-        ast::ptr< ast::Stmt > genScalarCall( 
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type, 
+        ast::ptr< ast::Stmt > genScalarCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type,
                 const ast::Type * addCast = nullptr
         ) {
@@ -153 +152 @@
 
                 if ( addCast ) {
-                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and 
-                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue 
-                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an 
+                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and
+                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue
+                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an
                         // lvalue-qualified type, so remove all qualifiers except lvalue.
                         // xxx -- old code actually removed lvalue too...
                         ast::ptr< ast::Type > guard = addCast;  // prevent castType from mutating addCast
                         ast::ptr< ast::Type > castType = addCast;
-                        ast::remove_qualifiers( 
-                                castType, 
+                        ast::remove_qualifiers(
+                                castType,
                                 ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic );
                         dstParam = new ast::CastExpr{ dstParam, new ast::ReferenceType{ castType } };
@@ -181 +180 @@
 
                 srcParam.clearArrayIndices();
-                
+
                 return listInit;
         }
@@ -249 +248 @@
         }
 
-        /// Store in out a loop which calls fname on each element of the array with srcParam and 
+        /// Store in out a loop which calls fname on each element of the array with srcParam and
         /// dstParam as arguments. If forward is true, loop goes from 0 to N-1, else N-1 to 0
         template< typename OutIter >
         void genArrayCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, OutIter && out, 
-                const ast::ArrayType * array, const ast::Type * addCast = nullptr, 
-                LoopDirection forward = LoopForward 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, OutIter && out,
+                const ast::ArrayType * array, const ast::Type * addCast = nullptr,
+                LoopDirection forward = LoopForward
         ) {
                 static UniqueName indexName( "_index" );
@@ -279 +278 @@
                 } else {
                         // generate: for ( int i = N-1; i >= 0; --i )
-                        begin = ast::call( 
-                                loc, "?-?", array->dimension, ast::ConstantExpr::from_int( loc, 1 ) );
+                        begin = ast::UntypedExpr::createCall( loc, "?-?",
+                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } );
                         end = ast::ConstantExpr::from_int( loc, 0 );
                         cmp = "?>=?";
@@ -286 +285 @@
                 }
 
-                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{ 
-                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt }, 
+                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{
+                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt },
                         new ast::SingleInit{ loc, begin } };
                 ast::ptr< ast::Expr > indexVar = new ast::VariableExpr{ loc, index };
-                
-                ast::ptr< ast::Expr > cond = ast::call( loc, cmp, indexVar, end );
-                
-                ast::ptr< ast::Expr > inc = ast::call( loc, update, indexVar );
-                
-                ast::ptr< ast::Expr > dstIndex = ast::call( loc, "?[?]", dstParam, indexVar );
-                
-                // srcParam must keep track of the array indices to build the source parameter and/or 
+
+                ast::ptr< ast::Expr > cond = ast::UntypedExpr::createCall(
+                        loc, cmp, { indexVar, end } );
+
+                ast::ptr< ast::Expr > inc = ast::UntypedExpr::createCall(
+                        loc, update, { indexVar } );
+
+                ast::ptr< ast::Expr > dstIndex = ast::UntypedExpr::createCall(
+                        loc, "?[?]", { dstParam, indexVar } );
+
+                // srcParam must keep track of the array indices to build the source parameter and/or
                 // array list initializer
                 srcParam.addArrayIndex( indexVar, array->dimension );
@@ -303 +305 @@
                 // for stmt's body, eventually containing call
                 ast::CompoundStmt * body = new ast::CompoundStmt{ loc };
-                ast::ptr< ast::Stmt > listInit = genCall( 
-                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast, 
+                ast::ptr< ast::Stmt > listInit = genCall(
+                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast,
                         forward );
-                
+
                 // block containing the stmt and index variable
                 ast::CompoundStmt * block = new ast::CompoundStmt{ loc };
@@ -328 +330 @@
         template< typename OutIter >
         ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, OutIter && out,
                 const ast::Type * type, const ast::Type * addCast, LoopDirection forward
         ) {
                 if ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
-                        genArrayCall( 
-                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast, 
+                        genArrayCall(
+                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast,
                                 forward );
                         return {};
                 } else {
-                        return genScalarCall( 
+                        return genScalarCall(
                                 srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
                 }
@@ -377 +379 @@
         }
 
-        static inline ast::ptr< ast::Stmt > genImplicitCall( 
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj, 
-                LoopDirection forward = LoopForward 
+        static inline ast::ptr< ast::Stmt > genImplicitCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj,
+                LoopDirection forward = LoopForward
         ) {
                 // unnamed bit fields are not copied as they cannot be accessed
@@ -392 +394 @@
 
                 std::vector< ast::ptr< ast::Stmt > > stmts;
-                genCall( 
+                genCall(
                         srcParam, dstParam, loc, fname, back_inserter( stmts ), obj->type, addCast, forward );
 
@@ -400 +402 @@
                         const ast::Stmt * callStmt = stmts.front();
                         if ( addCast ) {
-                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are 
+                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are
                                 // aware they were generated.
                                 callStmt = new ast::ImplicitCtorDtorStmt{ callStmt->location, callStmt };
@@ -417 +419 @@
 // compile-command: "make install" //
 // End: //
-