Changes in src/InitTweak/InitTweak.h [0bd3faf:e01eb4a]

File:

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

src/InitTweak/InitTweak.h

@@ -22 +22 @@
 
 #include "AST/Fwd.hpp"        // for AST nodes
+#include "SynTree/SynTree.h"  // for Visitor Nodes
 
 // helper functions for initialization
 namespace InitTweak {
+        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 isAssignment( const ast::FunctionDecl * decl );
         bool isDestructor( const ast::FunctionDecl * decl );
@@ -32 +38 @@
 
         /// returns the base type of the first parameter to a constructor/destructor/assignment function
+        Type * getTypeofThis( FunctionType * ftype );
         const ast::Type * getTypeofThis( const ast::FunctionType * ftype );
 
         /// returns the first parameter of a constructor/destructor/assignment function
+        ObjectDecl * getParamThis( FunctionType * ftype );
         const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func);
 
         /// generate a bitwise assignment operation.
+        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src );
+
         ast::Expr * createBitwiseAssignment( const ast::Expr * dst, const ast::Expr * src);
 
         /// 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
+        bool tryConstruct( DeclarationWithType * dwt );
         bool tryConstruct( const ast::DeclWithType * dwt );
 
         /// True if the type can have a user-defined constructor
+        bool isConstructable( Type * t );
         bool isConstructable( const ast::Type * t );
 
         /// True if the Initializer contains designations
+        bool isDesignated( Initializer * init );
         bool isDesignated( const ast::Init * init );
 
         /// True if the ObjectDecl's Initializer nesting level is not deeper than the depth of its
         /// type, where the depth of its type is the number of nested ArrayTypes + 1
+        bool checkInitDepth( ObjectDecl * objDecl );
         bool checkInitDepth( const ast::ObjectDecl * objDecl );
+
+        /// 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 );
+
+        /// Non-Null if expr is a call expression whose target function is intrinsic
+        ApplicationExpr * isIntrinsicCallExpr( Expression * expr );
 
         /// True if stmt is a call statement where the function called is intrinsic and takes one parameter.
         /// Intended to be used for default ctor/dtor calls, but might have use elsewhere.
         /// 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.
+        bool isIntrinsicCallStmt( Statement * stmt );
+
         /// get all Ctor/Dtor call expressions from a Statement
+        void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches );
         std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt );
 
+        /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
+        Expression * getCtorDtorCall( Statement * stmt );
+
+        /// returns the name of the function being called
+        std::string getFunctionName( Expression * expr );
+
+        /// returns the argument to a call expression in position N indexed from 0
+        Expression *& getCallArg( Expression * callExpr, unsigned int pos );
+
+        /// returns the base type of a PointerType or ArrayType, else returns NULL
+        Type * getPointerBase( Type * );
+
+        /// returns the argument if it is a PointerType or ArrayType, else returns NULL
+        Type * isPointerType( Type * );
+
         /// returns true if expr is trivially a compile-time constant
+        bool isConstExpr( Expression * expr );
+        bool isConstExpr( Initializer * init );
+
         bool isConstExpr( const ast::Expr * expr );
         bool isConstExpr( const ast::Init * init );
@@ -77 +122 @@
         ///    .section .data#,"a"
         /// to avoid assembler warning "ignoring changed section attributes for .data"
+        void addDataSectionAttribute( ObjectDecl * objDecl );
+
         void addDataSectionAttribute( ast::ObjectDecl * objDecl );
 
-        class InitExpander final {
+        class InitExpander_old {
+        public:
+                // expand by stepping through init to get each list of arguments
+                InitExpander_old( Initializer * init );
+
+                // always expand to expr
+                InitExpander_old( Expression * expr );
+
+                // iterator-like interface
+                std::list< Expression * > operator*();
+                InitExpander_old & 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
+                Statement * buildListInit( UntypedExpr * callExpr );
+                void addArrayIndex( Expression * index, Expression * dimension );
+                void clearArrayIndices();
+                bool addReference();
+
+                class ExpanderImpl;
+
+                typedef std::list< Expression * > IndexList;
+        private:
+                std::shared_ptr< ExpanderImpl > expander;
+                std::list< Expression * > cur;
+
+                // invariant: list of size 2N (elements come in pairs [index, dimension])
+                IndexList indices;
+        };
+
+        class InitExpander_new {
         public:
                 using IndexList = std::vector< ast::ptr< ast::Expr > >;
@@ -92 +169 @@
         public:
                 /// Expand by stepping through init to get each list of arguments
-                InitExpander( const ast::Init * init );
+                InitExpander_new( const ast::Init * init );
 
                 /// Always expand to expression
-                InitExpander( const ast::Expr * expr );
+                InitExpander_new( const ast::Expr * expr );
 
                 std::vector< ast::ptr< ast::Expr > > operator* ();
-                InitExpander & operator++ ();
+                InitExpander_new & operator++ ();
 
                 /// builds statement which has the same semantics as a C-style list initializer (for array
@@ -111 +188 @@
                 bool addReference();
         };
-} // namespace InitTweak
+} // namespace
 
 // Local Variables: //