Changeset b067d9b for src/InitTweak/InitTweak.h

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (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

File:

• src/InitTweak/InitTweak.h (modified) (9 diffs)

src/InitTweak/InitTweak.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// RemoveInit.h --
+// InitTweak.h --
 //
 // Author           : Rob Schluntz
 // Created On       : Fri May 13 11:26:36 2016
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:30:33 2017
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jul 19 14:18:00 2019
+// Update Count     : 6
 //
 
@@ -19 +19 @@
 #include <memory>             // for shared_ptr
 #include <string>             // for string, allocator
+#include <vector>
 
+#include "AST/Fwd.hpp"        // for AST nodes
 #include "SynTree/SynTree.h"  // for Visitor Nodes
 
 // helper functions for initialization
 namespace InitTweak {
-        FunctionDecl * isAssignment( Declaration * decl );
-        FunctionDecl * isDestructor( Declaration * decl );
-        FunctionDecl * isDefaultConstructor( Declaration * decl );
-        FunctionDecl * isCopyConstructor( Declaration * decl );
-        FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname );
+        const FunctionDecl * isAssignment( const Declaration * decl );
+        const FunctionDecl * isDestructor( const Declaration * decl );
+        const FunctionDecl * isDefaultConstructor( const Declaration * decl );
+        const FunctionDecl * isCopyConstructor( const Declaration * decl );
+        const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname );
+        bool isCopyFunction( const ast::FunctionDecl * decl );
 
         /// returns the base type of the first parameter to a constructor/destructor/assignment function
@@ -41 +44 @@
         /// transform Initializer into an argument list that can be passed to a call expression
         std::list< Expression * > makeInitList( Initializer * init );
+        std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init );
 
         /// True if the resolver should try to construct dwt
@@ -57 +61 @@
         /// returns the declaration of the function called by the expr (must be ApplicationExpr or UntypedExpr)
         DeclarationWithType * getFunction( Expression * expr );
+        const DeclarationWithType * getFunction( const Expression * expr );
+        const ast::DeclWithType * getFunction( const ast::Expr * expr );
 
         /// Non-Null if expr is a call expression whose target function is intrinsic
         ApplicationExpr * isIntrinsicCallExpr( Expression * expr );
+        const ast::ApplicationExpr * isIntrinsicCallExpr( const ast::Expr * expr);
 
         /// True if stmt is a call statement where the function called is intrinsic and takes one parameter.
@@ -65 +72 @@
         /// Currently has assertions that make it less than fully general.
         bool isIntrinsicSingleArgCallStmt( Statement * stmt );
+        bool isIntrinsicSingleArgCallStmt( const ast::Stmt * stmt );
 
         /// True if stmt is a call statement where the function called is intrinsic.
@@ -71 +79 @@
         /// get all Ctor/Dtor call expressions from a Statement
         void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches );
+        std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt );
 
         /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
@@ -77 +86 @@
         /// returns the name of the function being called
         std::string getFunctionName( Expression * expr );
+        std::string getFunctionName( const ast::Expr * expr );
 
         /// returns the argument to a call expression in position N indexed from 0
         Expression *& getCallArg( Expression * callExpr, unsigned int pos );
+        const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos );
 
         /// returns the base type of a PointerType or ArrayType, else returns NULL
         Type * getPointerBase( Type * );
+        const ast::Type* getPointerBase( const ast::Type* );
 
         /// returns the argument if it is a PointerType or ArrayType, else returns NULL
@@ -91 +103 @@
         bool isConstExpr( Initializer * init );
 
-        class InitExpander {
+        class InitExpander_old {
         public:
                 // expand by stepping through init to get each list of arguments
-                InitExpander( Initializer * init );
+                InitExpander_old( Initializer * init );
 
                 // always expand to expr
-                InitExpander( Expression * expr );
+                InitExpander_old( Expression * expr );
 
                 // iterator-like interface
                 std::list< Expression * > operator*();
-                InitExpander & operator++();
+                InitExpander_old & operator++();
 
                 // builds statement which has the same semantics as a C-style list initializer
@@ -120 +132 @@
                 IndexList indices;
         };
+
+        class InitExpander_new {
+        public:
+                using IndexList = std::vector< ast::ptr< ast::Expr > >;
+                class ExpanderImpl;
+
+        private:
+                std::shared_ptr< ExpanderImpl > expander;
+                std::vector< ast::ptr< ast::Expr > > crnt;
+                // invariant: list of size 2N (elements come in pairs [index, dimension])
+                IndexList indices;
+
+        public:
+                /// Expand by stepping through init to get each list of arguments
+                InitExpander_new( const ast::Init * init );
+
+                /// Always expand to expression
+                InitExpander_new( const ast::Expr * expr );
+
+                std::vector< ast::ptr< ast::Expr > > operator* ();
+                InitExpander_new & operator++ ();
+
+                /// builds statement which has the same semantics as a C-style list initializer (for array
+                /// initializers) using callExpr as the base expression to perform initialization.
+                /// Mutates callExpr
+                ast::ptr< ast::Stmt > buildListInit( ast::UntypedExpr * callExpr );
+
+                void addArrayIndex( const ast::Expr * index, const ast::Expr * dimension );
+
+                void clearArrayIndices();
+
+                bool addReference();
+        };
 } // namespace