added (initial) handling of "conditional initializers" and also

memset/memcpy

1 files changed, 696 insertions, 503 deletions

diff --git a/safercpp/safercpp-arr.cpp b/safercpp/safercpp-arr.cpp
index 970d130..28419a1 100644
--- a/safercpp/safercpp-arr.cpp
+++ b/safercpp/safercpp-arr.cpp
@@ -298,8 +298,7 @@ public:
 class CDDecl2ReplacementAction : public CReplacementAction {
 public:
 	CDDecl2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR,
-			const CDDeclIndirection& ddecl_indirection) : m_Rewrite(Rewrite), m_MR(MR), m_ddecl_indirection(ddecl_indirection) {
-	}
+			const CDDeclIndirection& ddecl_indirection) : m_Rewrite(Rewrite), m_MR(MR), m_ddecl_indirection(ddecl_indirection) {}
 	virtual ~CDDecl2ReplacementAction() {}
 
 	virtual void do_replacement(CState1& state1) const = 0;
@@ -330,19 +329,12 @@ public:
 	virtual ~CArray2ReplacementAction() {}
 };
 
-class CDynamicArray2ReplacementAction : public CArray2ReplacementAction {
-public:
-	using CArray2ReplacementAction::CArray2ReplacementAction;
-	virtual ~CDynamicArray2ReplacementAction() {}
-};
-
-class CMemsetArray2ReplacementAction : public CDynamicArray2ReplacementAction {
+class CMemsetArray2ReplacementAction : public CArray2ReplacementAction {
 public:
 	CMemsetArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection,
 			const CallExpr* CE, const std::string& ce_replacement_code) :
-				CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr),
-				m_ce_replacement_code(ce_replacement_code) {
-	}
+				CArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr),
+				m_ce_replacement_code(ce_replacement_code) {}
 	virtual ~CMemsetArray2ReplacementAction() {}
 
 	virtual void do_replacement(CState1& state1) const;
@@ -354,40 +346,62 @@ public:
 	std::string m_ce_replacement_code;
 };
 
-class CSetArrayPointerToNull2ReplacementAction : public CDynamicArray2ReplacementAction {
+class CMemcpyArray2ReplacementAction : public CArray2ReplacementAction {
 public:
-	CSetArrayPointerToNull2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection,
-			const BinaryOperator* BO, const std::string& bo_replacement_code) :
-				CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_BO(BO), m_DD(ddecl_indirection.m_ddecl_cptr),
-				m_bo_replacement_code(bo_replacement_code) {
-	}
-	virtual ~CSetArrayPointerToNull2ReplacementAction() {}
+	CMemcpyArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection,
+			const CallExpr* CE, const std::string& ce_replacement_code) :
+				CArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr),
+				m_ce_replacement_code(ce_replacement_code) {}
+	virtual ~CMemcpyArray2ReplacementAction() {}
 
 	virtual void do_replacement(CState1& state1) const;
 
-	const BinaryOperator* m_BO = nullptr;
+	const CallExpr* m_CE = nullptr;
 	//const DeclRefExpr* m_DRE = nullptr;
 	//const MemberExpr* m_ME = nullptr;
 	const DeclaratorDecl* m_DD = nullptr;
-	std::string m_bo_replacement_code;
+	std::string m_ce_replacement_code;
 };
 
-class CFreeDynamicArray2ReplacementAction : public CDynamicArray2ReplacementAction {
+class CAssignedFromArray2ReplacementAction : public CArray2ReplacementAction {
 public:
-	CFreeDynamicArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection,
-			const CallExpr* CE, const std::string& ce_replacement_code) :
-				CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr),
-				m_ce_replacement_code(ce_replacement_code) {
-	}
-	virtual ~CFreeDynamicArray2ReplacementAction() {}
+	CAssignedFromArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection,
+			const CDDeclIndirection& ddecl_indirection2) :
+				CArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_ddecl_indirection2(ddecl_indirection2) {}
+	virtual ~CAssignedFromArray2ReplacementAction() {}
 
 	virtual void do_replacement(CState1& state1) const;
 
-	const CallExpr* m_CE = nullptr;
-	//const DeclRefExpr* m_DRE = nullptr;
-	//const MemberExpr* m_ME = nullptr;
-	const DeclaratorDecl* m_DD = nullptr;
-	std::string m_ce_replacement_code;
+	const CDDeclIndirection m_ddecl_indirection2;
+};
+
+class CDDecl2ReplacementActionMap : public std::multimap<CDDeclIndirection, std::shared_ptr<CDDecl2ReplacementAction>> {
+public:
+	typedef std::multimap<CDDeclIndirection, std::shared_ptr<CDDecl2ReplacementAction>> base_class;
+	iterator insert( const std::shared_ptr<CDDecl2ReplacementAction>& cr_shptr ) {
+		iterator retval(end());
+		if (!cr_shptr) { assert(false); } else {
+			value_type val((*cr_shptr).ddecl_indirection_cref(), cr_shptr);
+			retval = base_class::insert(val);
+		}
+		return retval;
+	}
+	void do_and_dispose_matching_replacements(CState1& state1, const CDDeclIndirection& ddecl_indirection) {
+		/* The base class map may be modified during loop iterations. Maybe. */
+		auto iter = base_class::find(ddecl_indirection);
+		while (base_class::end() != iter) {
+			(*((*iter).second)).do_replacement(state1);
+			base_class::erase(iter);
+
+			iter = base_class::find(ddecl_indirection);
+		}
+	}
+};
+
+class CDynamicArray2ReplacementAction : public CArray2ReplacementAction {
+public:
+	using CArray2ReplacementAction::CArray2ReplacementAction;
+	virtual ~CDynamicArray2ReplacementAction() {}
 };
 
 class CMallocArray2ReplacementAction : public CDynamicArray2ReplacementAction {
@@ -395,8 +409,7 @@ public:
 	CMallocArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection,
 			const BinaryOperator* BO, const std::string& bo_replacement_code) :
 				CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_BO(BO), m_DD(ddecl_indirection.m_ddecl_cptr),
-				m_bo_replacement_code(bo_replacement_code) {
-	}
+				m_bo_replacement_code(bo_replacement_code) {}
 	virtual ~CMallocArray2ReplacementAction() {}
 
 	virtual void do_replacement(CState1& state1) const;
@@ -414,8 +427,7 @@ public:
 	CMallocInitializerArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection,
 			const DeclStmt* DS, const std::string& initializer_info_str) :
 				CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_DS(DS), m_DD(ddecl_indirection.m_ddecl_cptr),
-				m_initializer_info_str(initializer_info_str) {
-	}
+				m_initializer_info_str(initializer_info_str) {}
 	virtual ~CMallocInitializerArray2ReplacementAction() {}
 
 	virtual void do_replacement(CState1& state1) const;
@@ -426,27 +438,38 @@ public:
 	std::string m_initializer_info_str;
 };
 
-class CDDecl2ReplacementActionMap : public std::multimap<CDDeclIndirection, std::shared_ptr<CDDecl2ReplacementAction>> {
+class CFreeDynamicArray2ReplacementAction : public CDynamicArray2ReplacementAction {
 public:
-	typedef std::multimap<CDDeclIndirection, std::shared_ptr<CDDecl2ReplacementAction>> base_class;
-	iterator insert( const std::shared_ptr<CDDecl2ReplacementAction>& cr_shptr ) {
-		iterator retval(end());
-		if (!cr_shptr) { assert(false); } else {
-			value_type val((*cr_shptr).ddecl_indirection_cref(), cr_shptr);
-			retval = base_class::insert(val);
-		}
-		return retval;
-	}
-	void do_and_dispose_matching_replacements(CState1& state1, const CDDeclIndirection& ddecl_indirection) {
-		auto range = base_class::equal_range(ddecl_indirection);
-		while (range.first != range.second) {
-			for (auto iter = range.first; range.second != iter; iter++) {
-				(*((*iter).second)).do_replacement(state1);
-			}
-			base_class::erase(range.first, range.second);
-			range = base_class::equal_range(ddecl_indirection);
-		}
-	}
+	CFreeDynamicArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection,
+			const CallExpr* CE, const std::string& ce_replacement_code) :
+				CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr),
+				m_ce_replacement_code(ce_replacement_code) {}
+	virtual ~CFreeDynamicArray2ReplacementAction() {}
+
+	virtual void do_replacement(CState1& state1) const;
+
+	const CallExpr* m_CE = nullptr;
+	//const DeclRefExpr* m_DRE = nullptr;
+	//const MemberExpr* m_ME = nullptr;
+	const DeclaratorDecl* m_DD = nullptr;
+	std::string m_ce_replacement_code;
+};
+
+class CSetArrayPointerToNull2ReplacementAction : public CDynamicArray2ReplacementAction {
+public:
+	CSetArrayPointerToNull2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection,
+			const BinaryOperator* BO, const std::string& bo_replacement_code) :
+				CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_BO(BO), m_DD(ddecl_indirection.m_ddecl_cptr),
+				m_bo_replacement_code(bo_replacement_code) {}
+	virtual ~CSetArrayPointerToNull2ReplacementAction() {}
+
+	virtual void do_replacement(CState1& state1) const;
+
+	const BinaryOperator* m_BO = nullptr;
+	//const DeclRefExpr* m_DRE = nullptr;
+	//const MemberExpr* m_ME = nullptr;
+	const DeclaratorDecl* m_DD = nullptr;
+	std::string m_bo_replacement_code;
 };
 
 class CDynamicArray2ReplacementActionMap : public CDDecl2ReplacementActionMap {
@@ -623,6 +646,87 @@ const clang::Expr* populateStmtIndirectionStack(std::vector<std::string>& stack,
 	return retval;
 }
 
+void walkTheAST1(const clang::Stmt& stmt, int depth = 0) {
+	const clang::Stmt* ST = &stmt;
+	auto stmt_class = ST->getStmtClass();
+	auto stmt_class_name = ST->getStmtClassName();
+	bool process_children_flag = true;
+	if (clang::Stmt::StmtClass::ArraySubscriptExprClass == stmt_class) {
+		//stack.push_back("ArraySubscriptExpr");
+		process_children_flag = true;
+	} else if (clang::Stmt::StmtClass::UnaryOperatorClass == stmt_class) {
+		auto UO = llvm::cast<const clang::UnaryOperator>(ST);
+		if (UO) {
+			if (clang::UnaryOperatorKind::UO_Deref == UO->getOpcode()) {
+				//stack.push_back("Deref");
+				process_children_flag = true;
+			} else {
+				auto QT = UO->getType();
+				const clang::Type* TP = QT.getTypePtr();
+				if (TP && TP->isPointerType()) {
+					if ((clang::UnaryOperatorKind::UO_PreInc == UO->getOpcode())
+							|| (clang::UnaryOperatorKind::UO_PostInc == UO->getOpcode())
+							|| (clang::UnaryOperatorKind::UO_PreDec == UO->getOpcode())
+							|| (clang::UnaryOperatorKind::UO_PostDec == UO->getOpcode())) {
+						/* Incrementing/decrementing a pointer type is pointer arithmetic and
+						 * implies the pointer is being used as an array iterator. */
+						int q = 5;
+					}
+				}
+			}
+		} else {
+			assert(false);
+		}
+	} else if ((clang::Stmt::StmtClass::ImplicitCastExprClass == stmt_class)) {
+		auto ICE = llvm::cast<const clang::ImplicitCastExpr>(ST);
+		if (ICE) {
+			auto cast_kind_name = ICE->getCastKindName();
+			auto cast_kind = ICE->getCastKind();
+			if ((clang::CK_FunctionToPointerDecay == cast_kind)) {
+				process_children_flag = false;
+			} else {
+				if ((clang::CK_ArrayToPointerDecay == cast_kind) || (clang::CK_LValueToRValue == cast_kind)) {
+					process_children_flag = true;
+				} else {
+					process_children_flag = true;
+				}
+			}
+		} else { assert(false); }
+	} else if ((clang::Stmt::StmtClass::ParenExprClass == stmt_class)) {
+		process_children_flag = true;
+	} else if(clang::Stmt::StmtClass::DeclRefExprClass == stmt_class) {
+		auto DRE = llvm::cast<const clang::DeclRefExpr>(ST);
+		if (DRE) {
+			//retval = DRE;
+			process_children_flag = true;
+		} else {
+			assert(false);
+		}
+	} else if(clang::Stmt::StmtClass::MemberExprClass == stmt_class) {
+		auto ME = llvm::cast<const clang::MemberExpr>(ST);
+		if (ME) {
+			//retval = ME;
+		} else {
+			assert(false);
+		}
+	} else {
+		if (0 == depth) {
+			int q = 5;
+		}
+		int q = 5;
+	}
+	if (process_children_flag) {
+		for (auto child_iter = ST->child_begin(); child_iter != ST->child_end(); child_iter++) {
+			if (nullptr != (*child_iter)) {
+				walkTheAST1(*(*child_iter), depth+1);
+			} else {
+				assert(false);
+			}
+		}
+	}
+	return;
+}
+
 class CDDeclConversionState {
 public:
 	CDDeclConversionState(const clang::DeclaratorDecl& ddecl) : m_ddecl_cptr(&ddecl) {
@@ -989,15 +1093,15 @@ static void update_declaration(const DeclaratorDecl& ddecl, Rewriter &Rewrite, C
 	}
 }
 
-void CFreeDynamicArray2ReplacementAction::do_replacement(CState1& state1) const {
+void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const {
 	Rewriter &Rewrite = m_Rewrite;
 	const MatchFinder::MatchResult &MR = m_MR;
-	const CallExpr* CE = m_CE;
+	const BinaryOperator* BO = m_BO;
 	const DeclaratorDecl* DD = m_DD;
 
-	if ((CE != nullptr) && (DD != nullptr))
+	if ((BO != nullptr) && (DD != nullptr))
 	{
-		auto CESR = nice_source_range(CE->getSourceRange(), Rewrite);
+		auto BOSR = nice_source_range(BO->getSourceRange(), Rewrite);
 		auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite);
 		auto decl_source_location_str = decl_source_range.getBegin().printToString(*MR.SourceManager);
 		std::string decl_source_text;
@@ -1007,14 +1111,14 @@ void CFreeDynamicArray2ReplacementAction::do_replacement(CState1& state1) const
 			return;
 		}
 
-		if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid())) {
+		if (ConvertToSCPP && decl_source_range.isValid() && (BOSR.isValid())) {
 
 			update_declaration(*DD, Rewrite, state1);
 
 			//state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref());
 			//state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref());
 
-			auto res2 = Rewrite.ReplaceText(CESR, m_ce_replacement_code);
+			auto res2 = Rewrite.ReplaceText(BOSR, m_bo_replacement_code);
 			int q = 3;
 		} else {
 			int q = 7;
@@ -1022,15 +1126,14 @@ void CFreeDynamicArray2ReplacementAction::do_replacement(CState1& state1) const
 	}
 }
 
-void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const {
+void CMallocInitializerArray2ReplacementAction::do_replacement(CState1& state1) const {
 	Rewriter &Rewrite = m_Rewrite;
 	const MatchFinder::MatchResult &MR = m_MR;
-	const BinaryOperator* BO = m_BO;
+	const DeclStmt* DS = m_DS;
 	const DeclaratorDecl* DD = m_DD;
 
-	if ((BO != nullptr) && (DD != nullptr))
+	if ((DS != nullptr) && (DD != nullptr))
 	{
-		auto BOSR = nice_source_range(BO->getSourceRange(), Rewrite);
 		auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite);
 		auto decl_source_location_str = decl_source_range.getBegin().printToString(*MR.SourceManager);
 		std::string decl_source_text;
@@ -1040,14 +1143,18 @@ void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const {
 			return;
 		}
 
-		if (ConvertToSCPP && decl_source_range.isValid() && (BOSR.isValid())) {
+		auto res1 = state1.m_ddecl_conversion_state_map.insert(*DD);
+		auto ddcs_map_iter = res1.first;
+		auto& ddcs_ref = (*ddcs_map_iter).second;
+
+		ddcs_ref.m_initializer_info_str = m_initializer_info_str;
 
+		if (ConvertToSCPP && decl_source_range.isValid()) {
 			update_declaration(*DD, Rewrite, state1);
 
 			//state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref());
 			//state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref());
 
-			auto res2 = Rewrite.ReplaceText(BOSR, m_bo_replacement_code);
 			int q = 3;
 		} else {
 			int q = 7;
@@ -1055,14 +1162,15 @@ void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const {
 	}
 }
 
-void CMallocInitializerArray2ReplacementAction::do_replacement(CState1& state1) const {
+void CFreeDynamicArray2ReplacementAction::do_replacement(CState1& state1) const {
 	Rewriter &Rewrite = m_Rewrite;
 	const MatchFinder::MatchResult &MR = m_MR;
-	const DeclStmt* DS = m_DS;
+	const CallExpr* CE = m_CE;
 	const DeclaratorDecl* DD = m_DD;
 
-	if ((DS != nullptr) && (DD != nullptr))
+	if ((CE != nullptr) && (DD != nullptr))
 	{
+		auto CESR = nice_source_range(CE->getSourceRange(), Rewrite);
 		auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite);
 		auto decl_source_location_str = decl_source_range.getBegin().printToString(*MR.SourceManager);
 		std::string decl_source_text;
@@ -1072,18 +1180,14 @@ void CMallocInitializerArray2ReplacementAction::do_replacement(CState1& state1)
 			return;
 		}
 
-		auto res1 = state1.m_ddecl_conversion_state_map.insert(*DD);
-		auto ddcs_map_iter = res1.first;
-		auto& ddcs_ref = (*ddcs_map_iter).second;
-
-		ddcs_ref.m_initializer_info_str = m_initializer_info_str;
+		if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid())) {
 
-		if (ConvertToSCPP && decl_source_range.isValid()) {
 			update_declaration(*DD, Rewrite, state1);
 
 			//state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref());
 			//state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, (*this).ddecl_indirection_cref());
 
+			auto res2 = Rewrite.ReplaceText(CESR, m_ce_replacement_code);
 			int q = 3;
 		} else {
 			int q = 7;
@@ -1151,6 +1255,183 @@ void CMemsetArray2ReplacementAction::do_replacement(CState1& state1) const {
 	}
 }
 
+void CMemcpyArray2ReplacementAction::do_replacement(CState1& state1) const {
+	Rewriter &Rewrite = m_Rewrite;
+	const MatchFinder::MatchResult &MR = m_MR;
+	const CallExpr* CE = m_CE;
+	const DeclaratorDecl* DD = m_DD;
+
+	if ((CE != nullptr) && (DD != nullptr))
+	{
+		auto CESR = nice_source_range(CE->getSourceRange(), Rewrite);
+		auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite);
+		auto decl_source_location_str = decl_source_range.getBegin().printToString(*MR.SourceManager);
+		std::string decl_source_text;
+		if (decl_source_range.isValid()) {
+			decl_source_text = Rewrite.getRewrittenText(decl_source_range);
+		} else {
+			return;
+		}
+
+		if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid())) {
+
+			update_declaration(*DD, Rewrite, state1);
+
+			auto res2 = Rewrite.ReplaceText(CESR, m_ce_replacement_code);
+			int q = 3;
+		} else {
+			int q = 7;
+		}
+	}
+}
+
+void CAssignedFromArray2ReplacementAction::do_replacement(CState1& state1) const {
+	Rewriter &Rewrite = m_Rewrite;
+	const MatchFinder::MatchResult &MR = m_MR;
+
+	auto res1 = state1.m_ddecl_conversion_state_map.insert(*(m_ddecl_indirection2.m_ddecl_cptr));
+	auto ddcs_map_iter = res1.first;
+	auto& ddcs_ref = (*ddcs_map_iter).second;
+	bool update_declaration_flag = res1.second;
+
+	if ("native pointer" == ddcs_ref.m_indirection_state_stack[m_ddecl_indirection2.m_indirection_level].m_current) {
+		ddcs_ref.m_indirection_state_stack[m_ddecl_indirection2.m_indirection_level].m_current = "inferred array";
+		update_declaration_flag = true;
+		state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection2);
+	} else if ("malloc target" == ddcs_ref.m_indirection_state_stack[m_ddecl_indirection2.m_indirection_level].m_current) {
+		ddcs_ref.m_indirection_state_stack[m_ddecl_indirection2.m_indirection_level].m_current = "dynamic array";
+		update_declaration_flag = true;
+		state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection2);
+	} else {
+		int q = 3;
+	}
+
+	if (update_declaration_flag) {
+		update_declaration(*(m_ddecl_indirection2.m_ddecl_cptr), Rewrite, state1);
+	}
+}
+
+struct CArrayInferenceInfo {
+	bool update_declaration_flag = false;
+	bool has_been_determined_to_be_an_array = false;
+	size_t indirection_level = 0;
+	const DeclaratorDecl* ddecl_cptr = nullptr;
+	const clang::Expr* declaration_expr_cptr = nullptr;
+};
+
+CArrayInferenceInfo infer_array_type_info_from_stmt_indirection_stack(CDDeclConversionState& ddcs_ref,
+		const std::vector<std::string>& stmt_indirection_stack, CState1& state1_ref) {
+	CArrayInferenceInfo retval;
+	auto DD = ddcs_ref.m_ddecl_cptr;
+	if (!DD) { assert(false); return retval; }
+	for (size_t i = 0; ((i < ddcs_ref.m_indirection_state_stack.size())
+			&& (i < stmt_indirection_stack.size())); i += 1) {
+		if ("native pointer" == ddcs_ref.m_indirection_state_stack[i].m_current) {
+			if (("ArraySubscriptExpr" == stmt_indirection_stack[i])
+					|| ("pointer arithmetic" == stmt_indirection_stack[i])) {
+				ddcs_ref.m_indirection_state_stack[i].m_current = "inferred array";
+				retval.update_declaration_flag = true;
+				state1_ref.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1_ref, CDDeclIndirection(*DD, i));
+			} else if (("malloc target" == stmt_indirection_stack[i])) {
+				ddcs_ref.m_indirection_state_stack[i].m_current = "malloc target";
+				retval.indirection_level = i;
+			} else if (("set to null" == stmt_indirection_stack[i]) ||
+					("memset/cpy target" == stmt_indirection_stack[i])) {
+				retval.indirection_level = i;
+			}
+		} else if ("malloc target" == ddcs_ref.m_indirection_state_stack[i].m_current) {
+			if (("ArraySubscriptExpr" == stmt_indirection_stack[i])
+					|| ("pointer arithmetic" == stmt_indirection_stack[i])) {
+				ddcs_ref.m_indirection_state_stack[i].m_current = "dynamic array";
+				retval.update_declaration_flag = true;
+				state1_ref.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1_ref, CDDeclIndirection(*DD, i));
+				state1_ref.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1_ref, CDDeclIndirection(*DD, i));
+			}
+		} else if ("inferred array" == ddcs_ref.m_indirection_state_stack[i].m_current) {
+			if (("malloc target" == stmt_indirection_stack[i]) ||
+					("set to null" == stmt_indirection_stack[i])) {
+				ddcs_ref.m_indirection_state_stack[i].m_current = "dynamic array";
+				retval.update_declaration_flag = true;
+				retval.has_been_determined_to_be_an_array = true;
+				retval.indirection_level = i;
+				state1_ref.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1_ref, CDDeclIndirection(*DD, i));
+			} else if (("memset/cpy target" == stmt_indirection_stack[i])) {
+				retval.has_been_determined_to_be_an_array = true;
+				retval.indirection_level = i;
+			}
+		} else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_current) {
+			if (("malloc target" == stmt_indirection_stack[i]) ||
+					("set to null" == stmt_indirection_stack[i])) {
+				retval.has_been_determined_to_be_an_array = true;
+				retval.indirection_level = i;
+			}
+		}
+	}
+	return retval;
+}
+
+/* We are trying to determine, for each and every pointer, whether or not it is being used as an
+ * array iterator. So this function takes an expression using a declared (pointer) variable
+ * and notes when the (pointer) variable, or any dereference of the
+ * (pointer) variable, is being used as an array iterator. So for example, given a declaration,
+ * say, "int*** ptr1;" and an expression, say, "(*(ptr1[3]))[5]", it will note the two levels
+ * of dereference/"indirection" that are being used as array iterators/pointers. Upon determining
+ * that a pointer (or a dereference/indirection of the pointer) is being used as an array iterator,
+ * the function will execute any queued up actions that were contingent on such a determination. */
+CArrayInferenceInfo infer_array_type_info_from_stmt(const clang::Stmt& stmt_cref, const std::string& stmt_array_info_str,
+		CState1& state1_ref, const DeclaratorDecl* DD = nullptr) {
+	CArrayInferenceInfo retval;
+
+	std::vector<std::string> stmt_indirection_stack;
+	const clang::Expr* expr2 = populateStmtIndirectionStack(stmt_indirection_stack, stmt_cref);
+	std::reverse(stmt_indirection_stack.begin(), stmt_indirection_stack.end());
+	stmt_indirection_stack.push_back(stmt_array_info_str);
+	if (expr2) {
+		std::string expr2_stmt_class_name;
+		expr2_stmt_class_name = expr2->getStmtClassName();
+		const DeclaratorDecl* expr2_DD = nullptr;
+		if (clang::Stmt::StmtClass::DeclRefExprClass == expr2->getStmtClass()) {
+			auto expr2_DRE = llvm::cast<const clang::DeclRefExpr>(expr2);
+			if (expr2_DRE) {
+				auto expr2_decl = expr2_DRE->getDecl();
+				expr2_DD = dynamic_cast<const DeclaratorDecl*>(expr2_decl);
+			} else { assert(false); }
+		} else if (clang::Stmt::StmtClass::MemberExprClass == expr2->getStmtClass()) {
+			auto expr2_ME = llvm::cast<const clang::MemberExpr>(expr2);
+			if (expr2_ME) {
+				auto expr2_FD = dynamic_cast<const clang::FieldDecl*>(expr2_ME->getMemberDecl());
+				if (expr2_FD) {
+					expr2_DD = expr2_FD;
+				} else { assert(false); }
+			} else { assert(false); }
+		}
+		if (expr2_DD) {
+			auto expr2_QT = expr2_DD->getType();
+			auto expr2_type_str = expr2_QT.getAsString();
+			std::string expr2_variable_name = expr2_DD->getNameAsString();
+
+			if (nullptr == DD) {
+				DD = expr2_DD;
+			}
+			auto res1 = state1_ref.m_ddecl_conversion_state_map.insert(*DD);
+			auto ddcs_map_iter = res1.first;
+			auto& ddcs_ref = (*ddcs_map_iter).second;
+			bool update_declaration_flag = res1.second;
+
+			auto QT = (*DD).getType();
+			std::string variable_name = (*DD).getNameAsString();
+
+			if ((expr2_QT == QT) && (expr2_variable_name == variable_name)) {
+				retval = infer_array_type_info_from_stmt_indirection_stack(ddcs_ref, stmt_indirection_stack, state1_ref);
+			}
+		}
+		retval.ddecl_cptr = expr2_DD;
+	}
+	retval.declaration_expr_cptr = expr2;
+
+	return retval;
+}
+
 /**********************************************************************************************************************/
 class MCSSSArrayToPointerDecay : public MatchFinder::MatchCallback
 {
@@ -1310,6 +1591,7 @@ public:
 			auto ddcs_map_iter = res1.first;
 			auto& ddcs_ref = (*ddcs_map_iter).second;
 			//bool update_declaration_flag = res1.second;
+
 			for (size_t i = 0; (i < ddcs_ref.m_indirection_state_stack.size()); i += 1) {
 				if ("native array" == ddcs_ref.m_indirection_state_stack[i].m_current) {
 					m_state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i));
@@ -1406,82 +1688,9 @@ public:
 					return;
 				}
 
-				auto res1 = (*this).m_state1.m_ddecl_conversion_state_map.insert(*DD);
-				auto ddcs_map_iter = res1.first;
-				auto& ddcs_ref = (*ddcs_map_iter).second;
-				bool update_declaration_flag = res1.second;
+				auto res2 = infer_array_type_info_from_stmt(*E, "pointer arithmetic", (*this).m_state1, DD);
 
-				const clang::Type* TP = QT.getTypePtr();
-				auto type_str = QT.getAsString();
-
-				auto expr_SR = nice_source_range(E->getSourceRange(), Rewrite);
-				std::string expr_source_location_str;
-				std::string expr_source_text;
-				if (expr_SR.isValid()) {
-					expr_source_location_str = expr_SR.getBegin().printToString(*MR.SourceManager);
-					expr_source_text = Rewrite.getRewrittenText(expr_SR);
-				} else {
-					int q = 3;
-				}
-
-				std::vector<std::string> stmt_indirection_stack;
-				const clang::Expr* expr2 = populateStmtIndirectionStack(stmt_indirection_stack, *E);
-				std::reverse(stmt_indirection_stack.begin(), stmt_indirection_stack.end());
-				stmt_indirection_stack.push_back("pointer arithmetic");
-				if (expr2) {
-					std::string expr2_stmt_class_name;
-					expr2_stmt_class_name = expr2->getStmtClassName();
-					const DeclaratorDecl* expr2_DD = nullptr;
-					if (clang::Stmt::StmtClass::DeclRefExprClass == expr2->getStmtClass()) {
-						auto expr2_DRE = llvm::cast<const clang::DeclRefExpr>(expr2);
-						if (expr2_DRE) {
-							auto expr2_decl = expr2_DRE->getDecl();
-							expr2_DD = dynamic_cast<const DeclaratorDecl*>(expr2_decl);
-						} else { assert(false); }
-					} else if (clang::Stmt::StmtClass::MemberExprClass == expr2->getStmtClass()) {
-						auto expr2_ME = llvm::cast<const clang::MemberExpr>(expr2);
-						if (expr2_ME) {
-							auto expr2_FD = dynamic_cast<const clang::FieldDecl*>(expr2_ME->getMemberDecl());
-							if (expr2_FD) {
-								expr2_DD = expr2_FD;
-							} else { assert(false); }
-						} else { assert(false); }
-					}
-					if (expr2_DD) {
-						auto expr2_QT = expr2_DD->getType();
-						const clang::Type* expr2_TP = expr2_QT.getTypePtr();
-						auto expr2_type_str = clang::QualType::getAsString(expr2_QT.split());
-						std::string expr2_variable_name = expr2_DD->getNameAsString();
-						if ((expr2_QT == QT) && (expr2_variable_name == variable_name)) {
-							for (size_t i = 0; ((i < ddcs_ref.m_indirection_state_stack.size())
-									&& (i < stmt_indirection_stack.size())); i += 1) {
-								if ("native pointer" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-									if (("ArraySubscriptExpr" == stmt_indirection_stack[i])
-											|| ("pointer arithmetic" == stmt_indirection_stack[i])) {
-										ddcs_ref.m_indirection_state_stack[i].m_current = "inferred array";
-										update_declaration_flag = true;
-										m_state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i));
-									}
-								} else if ("malloc target" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-									if (("ArraySubscriptExpr" == stmt_indirection_stack[i])
-											|| ("pointer arithmetic" == stmt_indirection_stack[i])) {
-										ddcs_ref.m_indirection_state_stack[i].m_current = "dynamic array";
-										update_declaration_flag = true;
-										m_state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i));
-										m_state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i));
-									}
-								}
-							}
-						} else {
-							int q = 5;
-						}
-					}
-					int q = 5;
-				} else {
-					return;
-				}
-
-				if (update_declaration_flag) {
+				if (res2.update_declaration_flag) {
 					update_declaration(*DD, Rewrite, m_state1);
 				}
 			}
@@ -1660,95 +1869,9 @@ public:
 										return;
 									}
 
-									auto res1 = (*this).m_state1.m_ddecl_conversion_state_map.insert(*DD);
-									auto ddcs_map_iter = res1.first;
-									auto& ddcs_ref = (*ddcs_map_iter).second;
-									bool update_declaration_flag = res1.second;
-
-									const clang::Type* TP = QT.getTypePtr();
-									auto type_str = QT.getAsString();
-
-									auto expr_SR = nice_source_range(LHS->getSourceRange(), Rewrite);
-									std::string expr_source_location_str;
-									std::string expr_source_text;
-									if (expr_SR.isValid()) {
-										expr_source_location_str = expr_SR.getBegin().printToString(*MR.SourceManager);
-										expr_source_text = Rewrite.getRewrittenText(expr_SR);
-									} else {
-										int q = 3;
-									}
-
-									std::vector<std::string> stmt_indirection_stack;
-									const clang::Expr* expr2 = populateStmtIndirectionStack(stmt_indirection_stack, *LHS);
-									std::reverse(stmt_indirection_stack.begin(), stmt_indirection_stack.end());
-									stmt_indirection_stack.push_back("malloc target");
-									bool lhs_has_been_determined_to_be_an_array = false;
-									size_t indirection_level = 0;
-									if (expr2) {
-										std::string expr2_stmt_class_name;
-										expr2_stmt_class_name = expr2->getStmtClassName();
-										const DeclaratorDecl* expr2_DD = nullptr;
-										if (clang::Stmt::StmtClass::DeclRefExprClass == expr2->getStmtClass()) {
-											auto expr2_DRE = llvm::cast<const clang::DeclRefExpr>(expr2);
-											if (expr2_DRE) {
-												auto expr2_decl = expr2_DRE->getDecl();
-												expr2_DD = dynamic_cast<const DeclaratorDecl*>(expr2_decl);
-											} else { assert(false); }
-										} else if (clang::Stmt::StmtClass::MemberExprClass == expr2->getStmtClass()) {
-											auto expr2_ME = llvm::cast<const clang::MemberExpr>(expr2);
-											if (expr2_ME) {
-												auto expr2_FD = dynamic_cast<const clang::FieldDecl*>(expr2_ME->getMemberDecl());
-												if (expr2_FD) {
-													expr2_DD = expr2_FD;
-												} else { assert(false); }
-											} else { assert(false); }
-										}
-										if (expr2_DD) {
-											auto expr2_QT = expr2_DD->getType();
-											const clang::Type* expr2_TP = expr2_QT.getTypePtr();
-											auto expr2_type_str = clang::QualType::getAsString(expr2_QT.split());
-											std::string expr2_variable_name = expr2_DD->getNameAsString();
-											if ((expr2_QT == QT) && (expr2_variable_name == variable_name)) {
-												for (size_t i = 0; ((i < ddcs_ref.m_indirection_state_stack.size())
-														&& (i < stmt_indirection_stack.size())); i += 1) {
-													if ("native pointer" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-														if (("ArraySubscriptExpr" == stmt_indirection_stack[i])
-																|| ("pointer arithmetic" == stmt_indirection_stack[i])) {
-															ddcs_ref.m_indirection_state_stack[i].m_current = "inferred array";
-															update_declaration_flag = true;
-															m_state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i));
-														} else if (("malloc target" == stmt_indirection_stack[i])) {
-															ddcs_ref.m_indirection_state_stack[i].m_current = "malloc target";
-															indirection_level = i;
-														}
-													} else if ("inferred array" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-														if (("malloc target" == stmt_indirection_stack[i])) {
-															ddcs_ref.m_indirection_state_stack[i].m_current = "dynamic array";
-															update_declaration_flag = true;
-															lhs_has_been_determined_to_be_an_array = true;
-															indirection_level = i;
-															m_state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i));
-														}
-													} else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-														if (("malloc target" == stmt_indirection_stack[i])) {
-															lhs_has_been_determined_to_be_an_array = true;
-															indirection_level = i;
-														}
-													} else {
-														assert(!(("native array" == ddcs_ref.m_indirection_state_stack[i].m_current)
-																&& (("malloc target" == stmt_indirection_stack[i]))));
-													}
-												}
-											} else {
-												int q = 5;
-											}
-										}
-										int q = 5;
-									} else {
-										return;
-									}
+									auto res2 = infer_array_type_info_from_stmt(*LHS, "malloc target", (*this).m_state1, DD);
 
-									if (update_declaration_flag) {
+									if (res2.update_declaration_flag) {
 										update_declaration(*DD, Rewrite, m_state1);
 									}
 
@@ -1799,9 +1922,9 @@ public:
 
 										auto BOSR = clang::SourceRange(BOSL, BOSLE);
 										if (ConvertToSCPP && decl_source_range.isValid() && (BOSR.isValid())) {
-											auto cr_shptr = std::make_shared<CMallocArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, indirection_level), BO, bo_replacement_code);
+											auto cr_shptr = std::make_shared<CMallocArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, res2.indirection_level), BO, bo_replacement_code);
 
-											if (lhs_has_been_determined_to_be_an_array) {
+											if (res2.has_been_determined_to_be_an_array) {
 												(*cr_shptr).do_replacement(m_state1);
 											} else {
 												m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr);
@@ -1936,11 +2059,6 @@ public:
 								 * "sizeof(something) * something_else". So we're just going to assume that
 								 * this is an instance of an array being allocated. */
 								std::string num_elements_text/* = before_str + after_str*/;
-								QualType QT;
-								std::string element_type_str;
-								clang::SourceRange decl_source_range;
-								std::string variable_name;
-								std::string declaration_replacement_code;
 
 								if (nullptr != DD) {
 									auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite);
@@ -1951,8 +2069,8 @@ public:
 									} else {
 										return;
 									}
-									QT = DD->getType();
-									variable_name = DD->getNameAsString();
+									QualType QT = DD->getType();
+									auto variable_name = DD->getNameAsString();
 
 									auto qualified_name = DD->getQualifiedNameAsString();
 									static const std::string mse_namespace_str1 = "mse::";
@@ -1984,6 +2102,7 @@ public:
 									const clang::Type* TP = QT.getTypePtr();
 									auto lhs_type_str = QT.getAsString();
 
+									std::string element_type_str;
 									if (TP->isArrayType()) {
 										auto ATP = llvm::cast<const clang::ArrayType>(TP);
 										assert(nullptr != ATP);
@@ -2147,95 +2266,9 @@ public:
 									return;
 								}
 
-								auto res1 = (*this).m_state1.m_ddecl_conversion_state_map.insert(*DD);
-								auto ddcs_map_iter = res1.first;
-								auto& ddcs_ref = (*ddcs_map_iter).second;
-								bool update_declaration_flag = res1.second;
-
-								const clang::Type* TP = QT.getTypePtr();
-								auto type_str = QT.getAsString();
-
-								auto expr_SR = nice_source_range(CE->getSourceRange(), Rewrite);
-								std::string expr_source_location_str;
-								std::string expr_source_text;
-								if (expr_SR.isValid()) {
-									expr_source_location_str = expr_SR.getBegin().printToString(*MR.SourceManager);
-									expr_source_text = Rewrite.getRewrittenText(expr_SR);
-								} else {
-									int q = 3;
-								}
-
-								std::vector<std::string> stmt_indirection_stack;
-								const clang::Expr* expr2 = populateStmtIndirectionStack(stmt_indirection_stack, *(*(CE->arg_begin())));
-								std::reverse(stmt_indirection_stack.begin(), stmt_indirection_stack.end());
-								stmt_indirection_stack.push_back("malloc target");
-								bool target_has_been_determined_to_be_an_array = false;
-								size_t indirection_level = 0;
-								if (expr2) {
-									std::string expr2_stmt_class_name;
-									expr2_stmt_class_name = expr2->getStmtClassName();
-									const DeclaratorDecl* expr2_DD = nullptr;
-									if (clang::Stmt::StmtClass::DeclRefExprClass == expr2->getStmtClass()) {
-										auto expr2_DRE = llvm::cast<const clang::DeclRefExpr>(expr2);
-										if (expr2_DRE) {
-											auto expr2_decl = expr2_DRE->getDecl();
-											expr2_DD = dynamic_cast<const DeclaratorDecl*>(expr2_decl);
-										} else { assert(false); }
-									} else if (clang::Stmt::StmtClass::MemberExprClass == expr2->getStmtClass()) {
-										auto expr2_ME = llvm::cast<const clang::MemberExpr>(expr2);
-										if (expr2_ME) {
-											auto expr2_FD = dynamic_cast<const clang::FieldDecl*>(expr2_ME->getMemberDecl());
-											if (expr2_FD) {
-												expr2_DD = expr2_FD;
-											} else { assert(false); }
-										} else { assert(false); }
-									}
-									if (expr2_DD) {
-										auto expr2_QT = expr2_DD->getType();
-										const clang::Type* expr2_TP = expr2_QT.getTypePtr();
-										auto expr2_type_str = clang::QualType::getAsString(expr2_QT.split());
-										std::string expr2_variable_name = expr2_DD->getNameAsString();
-										if ((expr2_QT == QT) && (expr2_variable_name == variable_name)) {
-											for (size_t i = 0; ((i < ddcs_ref.m_indirection_state_stack.size())
-													&& (i < stmt_indirection_stack.size())); i += 1) {
-												if ("native pointer" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-													if (("ArraySubscriptExpr" == stmt_indirection_stack[i])
-															|| ("pointer arithmetic" == stmt_indirection_stack[i])) {
-														ddcs_ref.m_indirection_state_stack[i].m_current = "inferred array";
-														update_declaration_flag = true;
-														m_state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i));
-													} else if (("malloc target" == stmt_indirection_stack[i])) {
-														ddcs_ref.m_indirection_state_stack[i].m_current = "malloc target";
-														indirection_level = i;
-													}
-												} else if ("inferred array" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-													if (("malloc target" == stmt_indirection_stack[i])) {
-														ddcs_ref.m_indirection_state_stack[i].m_current = "dynamic array";
-														update_declaration_flag = true;
-														target_has_been_determined_to_be_an_array = true;
-														indirection_level = i;
-														m_state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i));
-													}
-												} else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-													if (("malloc target" == stmt_indirection_stack[i])) {
-														target_has_been_determined_to_be_an_array = true;
-														indirection_level = i;
-													}
-												} else {
-													assert(!(("native array" == ddcs_ref.m_indirection_state_stack[i].m_current)
-															&& (("malloc target" == stmt_indirection_stack[i]))));
-												}
-											}
-										} else {
-											int q = 5;
-										}
-									}
-									int q = 5;
-								} else {
-									return;
-								}
+								auto res2 = infer_array_type_info_from_stmt(*(*(CE->arg_begin())), "malloc target", (*this).m_state1, DD);
 
-								if (update_declaration_flag) {
+								if (res2.update_declaration_flag) {
 									update_declaration(*DD, Rewrite, m_state1);
 								}
 
@@ -2243,9 +2276,9 @@ public:
 								ce_replacement_code += ".resize(0)";
 
 								if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid())) {
-									auto cr_shptr = std::make_shared<CFreeDynamicArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, indirection_level), CE, ce_replacement_code);
+									auto cr_shptr = std::make_shared<CFreeDynamicArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, res2.indirection_level), CE, ce_replacement_code);
 
-									if (target_has_been_determined_to_be_an_array) {
+									if (res2.has_been_determined_to_be_an_array) {
 										(*cr_shptr).do_replacement(m_state1);
 									} else {
 										m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr);
@@ -2364,95 +2397,9 @@ public:
 							return;
 						}
 
-						auto res1 = (*this).m_state1.m_ddecl_conversion_state_map.insert(*DD);
-						auto ddcs_map_iter = res1.first;
-						auto& ddcs_ref = (*ddcs_map_iter).second;
-						bool update_declaration_flag = res1.second;
-
-						const clang::Type* TP = QT.getTypePtr();
-						auto type_str = QT.getAsString();
-
-						auto expr_SR = nice_source_range(LHS->getSourceRange(), Rewrite);
-						std::string expr_source_location_str;
-						std::string expr_source_text;
-						if (expr_SR.isValid()) {
-							expr_source_location_str = expr_SR.getBegin().printToString(*MR.SourceManager);
-							expr_source_text = Rewrite.getRewrittenText(expr_SR);
-						} else {
-							int q = 3;
-						}
-
-						std::vector<std::string> stmt_indirection_stack;
-						const clang::Expr* expr2 = populateStmtIndirectionStack(stmt_indirection_stack, *LHS);
-						std::reverse(stmt_indirection_stack.begin(), stmt_indirection_stack.end());
-						stmt_indirection_stack.push_back("malloc target");
-						bool lhs_has_been_determined_to_be_an_array = false;
-						size_t indirection_level = 0;
-						if (expr2) {
-							std::string expr2_stmt_class_name;
-							expr2_stmt_class_name = expr2->getStmtClassName();
-							const DeclaratorDecl* expr2_DD = nullptr;
-							if (clang::Stmt::StmtClass::DeclRefExprClass == expr2->getStmtClass()) {
-								auto expr2_DRE = llvm::cast<const clang::DeclRefExpr>(expr2);
-								if (expr2_DRE) {
-									auto expr2_decl = expr2_DRE->getDecl();
-									expr2_DD = dynamic_cast<const DeclaratorDecl*>(expr2_decl);
-								} else { assert(false); }
-							} else if (clang::Stmt::StmtClass::MemberExprClass == expr2->getStmtClass()) {
-								auto expr2_ME = llvm::cast<const clang::MemberExpr>(expr2);
-								if (expr2_ME) {
-									auto expr2_FD = dynamic_cast<const clang::FieldDecl*>(expr2_ME->getMemberDecl());
-									if (expr2_FD) {
-										expr2_DD = expr2_FD;
-									} else { assert(false); }
-								} else { assert(false); }
-							}
-							if (expr2_DD) {
-								auto expr2_QT = expr2_DD->getType();
-								const clang::Type* expr2_TP = expr2_QT.getTypePtr();
-								auto expr2_type_str = clang::QualType::getAsString(expr2_QT.split());
-								std::string expr2_variable_name = expr2_DD->getNameAsString();
-								if ((expr2_QT == QT) && (expr2_variable_name == variable_name)) {
-									for (size_t i = 0; ((i < ddcs_ref.m_indirection_state_stack.size())
-											&& (i < stmt_indirection_stack.size())); i += 1) {
-										if ("native pointer" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-											if (("ArraySubscriptExpr" == stmt_indirection_stack[i])
-													|| ("pointer arithmetic" == stmt_indirection_stack[i])) {
-												ddcs_ref.m_indirection_state_stack[i].m_current = "inferred array";
-												update_declaration_flag = true;
-												m_state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i));
-											} else if (("malloc target" == stmt_indirection_stack[i])) {
-												//ddcs_ref.m_indirection_state_stack[i].m_current = "malloc target";
-												indirection_level = i;
-											}
-										} else if ("inferred array" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-											if (("malloc target" == stmt_indirection_stack[i])) {
-												ddcs_ref.m_indirection_state_stack[i].m_current = "dynamic array";
-												update_declaration_flag = true;
-												lhs_has_been_determined_to_be_an_array = true;
-												indirection_level = i;
-												m_state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i));
-											}
-										} else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-											if (("malloc target" == stmt_indirection_stack[i])) {
-												lhs_has_been_determined_to_be_an_array = true;
-												indirection_level = i;
-											}
-										} else {
-											assert(!(("native array" == ddcs_ref.m_indirection_state_stack[i].m_current)
-													&& (("malloc target" == stmt_indirection_stack[i]))));
-										}
-									}
-								} else {
-									int q = 5;
-								}
-							}
-							int q = 5;
-						} else {
-							return;
-						}
+						auto res2 = infer_array_type_info_from_stmt(*LHS, "set to null", (*this).m_state1, DD);
 
-						if (update_declaration_flag) {
+						if (res2.update_declaration_flag) {
 							update_declaration(*DD, Rewrite, m_state1);
 						}
 
@@ -2462,9 +2409,9 @@ public:
 						bo_replacement_code += ".resize(0)";
 
 						if (ConvertToSCPP && decl_source_range.isValid() && (BOSR.isValid())) {
-							auto cr_shptr = std::make_shared<CSetArrayPointerToNull2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, indirection_level), BO, bo_replacement_code);
+							auto cr_shptr = std::make_shared<CSetArrayPointerToNull2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, res2.indirection_level), BO, bo_replacement_code);
 
-							if (lhs_has_been_determined_to_be_an_array) {
+							if (res2.has_been_determined_to_be_an_array) {
 								(*cr_shptr).do_replacement(m_state1);
 							} else {
 								m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr);
@@ -2595,85 +2542,182 @@ public:
 									return;
 								}
 
-								auto res1 = (*this).m_state1.m_ddecl_conversion_state_map.insert(*DD);
-								auto ddcs_map_iter = res1.first;
-								auto& ddcs_ref = (*ddcs_map_iter).second;
-								bool update_declaration_flag = res1.second;
-
-								auto expr_SR = nice_source_range(CE->getSourceRange(), Rewrite);
-								std::string expr_source_location_str;
-								std::string expr_source_text;
-								if (expr_SR.isValid()) {
-									expr_source_location_str = expr_SR.getBegin().printToString(*MR.SourceManager);
-									expr_source_text = Rewrite.getRewrittenText(expr_SR);
-								} else {
-									int q = 3;
+								auto res2 = infer_array_type_info_from_stmt(*(*(CE->arg_begin())), "memset/cpy target", (*this).m_state1, DD);
+
+								if (res2.update_declaration_flag) {
+									update_declaration(*DD, Rewrite, m_state1);
 								}
 
-								std::vector<std::string> stmt_indirection_stack;
-								const clang::Expr* expr2 = populateStmtIndirectionStack(stmt_indirection_stack, *(*(CE->arg_begin())));
-								std::reverse(stmt_indirection_stack.begin(), stmt_indirection_stack.end());
-								stmt_indirection_stack.push_back("memset target");
-								bool target_has_been_determined_to_be_an_array = false;
-								size_t indirection_level = 0;
-								if (expr2) {
-									std::string expr2_stmt_class_name;
-									expr2_stmt_class_name = expr2->getStmtClassName();
-									const DeclaratorDecl* expr2_DD = nullptr;
-									if (clang::Stmt::StmtClass::DeclRefExprClass == expr2->getStmtClass()) {
-										auto expr2_DRE = llvm::cast<const clang::DeclRefExpr>(expr2);
-										if (expr2_DRE) {
-											auto expr2_decl = expr2_DRE->getDecl();
-											expr2_DD = dynamic_cast<const DeclaratorDecl*>(expr2_decl);
-										} else { assert(false); }
-									} else if (clang::Stmt::StmtClass::MemberExprClass == expr2->getStmtClass()) {
-										auto expr2_ME = llvm::cast<const clang::MemberExpr>(expr2);
-										if (expr2_ME) {
-											auto expr2_FD = dynamic_cast<const clang::FieldDecl*>(expr2_ME->getMemberDecl());
-											if (expr2_FD) {
-												expr2_DD = expr2_FD;
-											} else { assert(false); }
-										} else { assert(false); }
+								const clang::Type* arg1_TP = QT.getTypePtr();
+								auto arg1_type_str = QT.getAsString();
+
+								std::string arg1_element_type_str;
+								if (arg1_TP->isArrayType()) {
+									auto ATP = llvm::cast<const clang::ArrayType>(arg1_TP);
+									assert(nullptr != ATP);
+									auto element_type = ATP->getElementType();
+									auto elementSplitQualType = element_type.split();
+									auto type_str = clang::QualType::getAsString(elementSplitQualType);
+									if (("char" != type_str) && ("const char" != type_str)) {
+										arg1_element_type_str = type_str;
 									}
-									if (expr2_DD) {
-										auto expr2_QT = expr2_DD->getType();
-										const clang::Type* expr2_TP = expr2_QT.getTypePtr();
-										auto expr2_type_str = clang::QualType::getAsString(expr2_QT.split());
-										std::string expr2_variable_name = expr2_DD->getNameAsString();
-										if ((expr2_QT == QT) && (expr2_variable_name == variable_name)) {
-											for (size_t i = 0; ((i < ddcs_ref.m_indirection_state_stack.size())
-													&& (i < stmt_indirection_stack.size())); i += 1) {
-												if ("native pointer" == ddcs_ref.m_indirection_state_stack[i].m_current) {
-													if (("ArraySubscriptExpr" == stmt_indirection_stack[i])
-															|| ("pointer arithmetic" == stmt_indirection_stack[i])) {
-														ddcs_ref.m_indirection_state_stack[i].m_current = "inferred array";
-														update_declaration_flag = true;
-														m_state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i));
-													} else if (("memset target" == stmt_indirection_stack[i])) {
-														//ddcs_ref.m_indirection_state_stack[i].m_current = "memset target";
-														indirection_level = i;
-													}
-												} else if (("inferred array" == ddcs_ref.m_indirection_state_stack[i].m_current)
-														|| ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_current)
-														|| ("native array" == ddcs_ref.m_indirection_state_stack[i].m_current)) {
-													if (("memset target" == stmt_indirection_stack[i])) {
-														target_has_been_determined_to_be_an_array = true;
-														indirection_level = i;
-													}
-												} else {
-													int q = 5;
-												}
-											}
+								} else if (arg1_TP->isPointerType()) {
+									auto TPP = llvm::cast<const clang::PointerType>(arg1_TP);
+									assert(nullptr != TPP);
+									auto target_type = TPP->getPointeeType();
+									auto splitQualType = target_type.split();
+									auto type_str = clang::QualType::getAsString(splitQualType);
+									if (("char" != type_str) && ("const char" != type_str)) {
+										arg1_element_type_str = type_str;
+									}
+								}
+								if ("" != arg1_element_type_str) {
+									ce_replacement_code = "for (size_t i = 0; i < (" + arg_source_text3
+											+ ")/sizeof(" + arg1_element_type_str + "); i += 1) { ";
+									ce_replacement_code += "(" + arg_source_text1 + ")[i] = " + arg_source_text2 + "; ";
+									ce_replacement_code += "}";
+
+									if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid())) {
+										auto cr_shptr = std::make_shared<CMemsetArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, res2.indirection_level), CE, ce_replacement_code);
+
+										if (true || res2.has_been_determined_to_be_an_array) {
+											(*cr_shptr).do_replacement(m_state1);
 										} else {
-											int q = 5;
+											m_state1.m_array2_contingent_replacement_map.insert(cr_shptr);
 										}
+									} else {
+										int q = 7;
 									}
-									int q = 5;
+								}
+							}
+							int q = 5;
+						} else {
+							int q = 5;
+						}
+						int q = 5;
+					}
+				}
+
+			}
+		}
+	}
+
+private:
+	Rewriter &Rewrite;
+	CState1& m_state1;
+};
+
+class MCSSSMemcpy : public MatchFinder::MatchCallback
+{
+public:
+	MCSSSMemcpy (Rewriter &Rewrite, CState1& state1) :
+		Rewrite(Rewrite), m_state1(state1) {}
+
+	virtual void run(const MatchFinder::MatchResult &MR)
+	{
+		const CallExpr* CE = MR.Nodes.getNodeAs<clang::CallExpr>("mcsssmemcpy1");
+		const DeclRefExpr* DRE = MR.Nodes.getNodeAs<clang::DeclRefExpr>("mcsssmemcpy2");
+		const MemberExpr* ME = MR.Nodes.getNodeAs<clang::MemberExpr>("mcsssmemcpy3");
+
+		if ((CE != nullptr) && (DRE != nullptr))
+		{
+			auto CESR = nice_source_range(CE->getSourceRange(), Rewrite);
+			SourceLocation CESL = CESR.getBegin();
+			SourceLocation CESLE = CESR.getEnd();
+
+			ASTContext *const ASTC = MR.Context;
+			FullSourceLoc FCESL = ASTC->getFullLoc(CESL);
+
+			SourceManager &SM = ASTC->getSourceManager();
+
+			auto source_location_str = CESL.printToString(*MR.SourceManager);
+			std::string source_text;
+			if (CESL.isValid() && CESLE.isValid()) {
+				source_text = Rewrite.getRewrittenText(SourceRange(CESL, CESLE));
+			} else {
+				return;
+			}
+
+			if (filtered_out_by_location(MR, CESL)) {
+				return void();
+			}
+
+			auto function_decl = CE->getDirectCallee();
+			auto num_args = CE->getNumArgs();
+			if (function_decl && (3 == num_args)) {
+				{
+					std::string function_name = function_decl->getNameAsString();
+					static const std::string memcpy_str = "memcpy";
+					if (memcpy_str == function_name) {
+						auto iter1 = CE->arg_begin();
+						assert((*iter1)->getType().getTypePtrOrNull());
+						auto arg_source_range1 = nice_source_range((*iter1)->getSourceRange(), Rewrite);
+
+						auto iter2 = iter1;
+						iter2++;
+						assert((*iter2)->getType().getTypePtrOrNull());
+						auto arg_source_range2 = nice_source_range((*iter2)->getSourceRange(), Rewrite);
+
+						auto iter3 = iter2;
+						iter3++;
+						assert((*iter3)->getType().getTypePtrOrNull());
+						auto arg_source_range3 = nice_source_range((*iter3)->getSourceRange(), Rewrite);
+
+						std::string arg_source_text1;
+						std::string arg_source_text2;
+						std::string arg_source_text3;
+						if (arg_source_range1.isValid() && arg_source_range2.isValid() && arg_source_range3.isValid()) {
+							arg_source_text1 = Rewrite.getRewrittenText(arg_source_range1);
+							arg_source_text2 = Rewrite.getRewrittenText(arg_source_range2);
+							arg_source_text3 = Rewrite.getRewrittenText(arg_source_range3);
+							QualType QT;
+							std::string element_type_str;
+							clang::SourceRange decl_source_range;
+							std::string variable_name;
+							std::string ce_replacement_code;
+							const clang::DeclaratorDecl* DD = nullptr;
+
+							auto decl = DRE->getDecl();
+							DD = dynamic_cast<const DeclaratorDecl*>(decl);
+							auto VD = dynamic_cast<const VarDecl*>(decl);
+
+							const clang::FieldDecl* FD = nullptr;
+							if (nullptr != ME) {
+								auto member_decl = ME->getMemberDecl();
+								FD = dynamic_cast<const clang::FieldDecl*>(ME->getMemberDecl());
+							}
+							if (nullptr != FD) {
+								DD = FD;
+							} else if (nullptr != VD) {
+								DD = VD;
+							} else {
+								int q = 7;
+							}
+
+							if (nullptr != DD) {
+								auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite);
+								auto decl_source_location_str = decl_source_range.getBegin().printToString(*MR.SourceManager);
+								std::string decl_source_text;
+								if (decl_source_range.isValid()) {
+									decl_source_text = Rewrite.getRewrittenText(decl_source_range);
 								} else {
 									return;
 								}
+								QT = DD->getType();
+								auto qtype_str = QT.getAsString();
+								variable_name = DD->getNameAsString();
 
-								if (update_declaration_flag) {
+								auto qualified_name = DD->getQualifiedNameAsString();
+								static const std::string mse_namespace_str1 = "mse::";
+								static const std::string mse_namespace_str2 = "::mse::";
+								if ((0 == qualified_name.compare(0, mse_namespace_str1.size(), mse_namespace_str1))
+										|| (0 == qualified_name.compare(0, mse_namespace_str2.size(), mse_namespace_str2))) {
+									return;
+								}
+
+								auto res2 = infer_array_type_info_from_stmt(*(*(CE->arg_begin())), "memset/cpy target", (*this).m_state1, DD);
+
+								if (res2.update_declaration_flag) {
 									update_declaration(*DD, Rewrite, m_state1);
 								}
 
@@ -2703,13 +2747,13 @@ public:
 								if ("" != arg1_element_type_str) {
 									ce_replacement_code = "for (size_t i = 0; i < (" + arg_source_text3
 											+ ")/sizeof(" + arg1_element_type_str + "); i += 1) { ";
-									ce_replacement_code += arg_source_text1 + "[i] = " + arg_source_text2 + "; ";
+									ce_replacement_code += "(" + arg_source_text1 + ")[i] = (" + arg_source_text2 + ")[i]; ";
 									ce_replacement_code += "}";
 
 									if (ConvertToSCPP && decl_source_range.isValid() && (CESR.isValid())) {
-										auto cr_shptr = std::make_shared<CMemsetArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, indirection_level), CE, ce_replacement_code);
+										auto cr_shptr = std::make_shared<CMemcpyArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, res2.indirection_level), CE, ce_replacement_code);
 
-										if (target_has_been_determined_to_be_an_array) {
+										if (true || res2.has_been_determined_to_be_an_array) {
 											(*cr_shptr).do_replacement(m_state1);
 										} else {
 											m_state1.m_array2_contingent_replacement_map.insert(cr_shptr);
@@ -2736,6 +2780,129 @@ private:
 	CState1& m_state1;
 };
 
+class MCSSSConditionalInitializer : public MatchFinder::MatchCallback
+{
+public:
+	MCSSSConditionalInitializer (Rewriter &Rewrite, CState1& state1) :
+		Rewrite(Rewrite), m_state1(state1) {}
+
+	virtual void run(const MatchFinder::MatchResult &MR)
+	{
+		const DeclStmt* DS = MR.Nodes.getNodeAs<clang::DeclStmt>("mcsssconditionalinitializer1");
+		const clang::ConditionalOperator* CO = MR.Nodes.getNodeAs<clang::ConditionalOperator>("mcsssconditionalinitializer2");
+		const Expr* LHS = nullptr;
+		const Expr* RHS = nullptr;
+		if (CO) {
+			LHS = CO->getLHS();
+			RHS = CO->getRHS();
+		}
+		const DeclaratorDecl* DD = MR.Nodes.getNodeAs<clang::DeclaratorDecl>("mcsssconditionalinitializer3");
+
+		if ((DS != nullptr) && (LHS != nullptr) && (RHS != nullptr) && (DD != nullptr))
+		{
+			auto DSSR = nice_source_range(DS->getSourceRange(), Rewrite);
+			SourceLocation DSSL = DSSR.getBegin();
+			SourceLocation DSSLE = DSSR.getEnd();
+
+			ASTContext *const ASTC = MR.Context;
+			FullSourceLoc FDSSL = ASTC->getFullLoc(DSSL);
+
+			SourceManager &SM = ASTC->getSourceManager();
+
+			auto source_location_str = DSSL.printToString(*MR.SourceManager);
+			std::string source_text;
+			if (DSSL.isValid() && DSSLE.isValid()) {
+				source_text = Rewrite.getRewrittenText(SourceRange(DSSL, DSSLE));
+			} else {
+				return;
+			}
+
+			if (filtered_out_by_location(MR, DSSL)) {
+				return void();
+			}
+
+			if (std::string::npos != source_location_str.find("73")) {
+				walkTheAST1(*LHS);
+				int q = 5;
+			}
+
+			auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite);
+			auto decl_source_location_str = decl_source_range.getBegin().printToString(*MR.SourceManager);
+			std::string decl_source_text;
+			if (decl_source_range.isValid()) {
+				decl_source_text = Rewrite.getRewrittenText(decl_source_range);
+			} else {
+				return;
+			}
+			QualType QT = DD->getType();
+			auto variable_name = DD->getNameAsString();
+
+			auto qualified_name = DD->getQualifiedNameAsString();
+			static const std::string mse_namespace_str1 = "mse::";
+			static const std::string mse_namespace_str2 = "::mse::";
+			if ((0 == qualified_name.compare(0, mse_namespace_str1.size(), mse_namespace_str1))
+					|| (0 == qualified_name.compare(0, mse_namespace_str2.size(), mse_namespace_str2))) {
+				return;
+			}
+
+			auto res1 = (*this).m_state1.m_ddecl_conversion_state_map.insert(*DD);
+			auto ddcs_map_iter = res1.first;
+			auto& ddcs_ref = (*ddcs_map_iter).second;
+			bool update_declaration_flag = res1.second;
+
+			{
+				auto res2 = infer_array_type_info_from_stmt(*LHS, "", (*this).m_state1);
+				if (res2.ddecl_cptr && res2.declaration_expr_cptr) {
+					std::string variable_name = res2.ddecl_cptr->getNameAsString();
+					auto QT = res2.ddecl_cptr->getType();
+					auto LHS_QT = LHS->getType();
+					if (QT == LHS_QT) {
+
+						if (ConvertToSCPP && decl_source_range.isValid()) {
+							auto cr_shptr = std::make_shared<CAssignedFromArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, 0), CDDeclIndirection(*(res2.ddecl_cptr) , res2.indirection_level));
+
+							if (true || res2.has_been_determined_to_be_an_array) {
+								(*cr_shptr).do_replacement(m_state1);
+							} else {
+								m_state1.m_array2_contingent_replacement_map.insert(cr_shptr);
+							}
+						} else {
+							int q = 7;
+						}
+					}
+				}
+			}
+
+			{
+				auto res2 = infer_array_type_info_from_stmt(*RHS, "", (*this).m_state1);
+				if (res2.ddecl_cptr && res2.declaration_expr_cptr) {
+					std::string variable_name = res2.ddecl_cptr->getNameAsString();
+					auto QT = res2.ddecl_cptr->getType();
+					auto RHS_QT = RHS->getType();
+					if (QT == RHS_QT) {
+
+						if (ConvertToSCPP && decl_source_range.isValid()) {
+							auto cr_shptr = std::make_shared<CAssignedFromArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, 0), CDDeclIndirection(*(res2.ddecl_cptr) , res2.indirection_level));
+
+							if (true || res2.has_been_determined_to_be_an_array) {
+								(*cr_shptr).do_replacement(m_state1);
+							} else {
+								m_state1.m_array2_contingent_replacement_map.insert(cr_shptr);
+							}
+						} else {
+							int q = 7;
+						}
+					}
+				}
+			}
+		}
+	}
+
+private:
+	Rewriter &Rewrite;
+	CState1& m_state1;
+};
+
 /**********************************************************************************************************************/
 class MyASTConsumer : public ASTConsumer {
 
@@ -2743,7 +2910,7 @@ public:
   MyASTConsumer(Rewriter &R) : HandlerForSSSNativePointer(R), HandlerForSSSArrayToPointerDecay(R, m_state1),
 	HandlerForSSSVarDecl2(R, m_state1), HandlerForSSSPointerArithmetic2(R, m_state1), HandlerForSSSMalloc2(R, m_state1),
 	HandlerForSSSMallocInitializer2(R, m_state1), HandlerForSSSFree2(R, m_state1), HandlerForSSSSetToNull2(R, m_state1),
-	HandlerForSSSMemset(R, m_state1)
+	HandlerForSSSMemset(R, m_state1), HandlerForSSSMemcpy(R, m_state1), HandlerForSSSConditionalInitializer(R, m_state1)
   {
 	  Matcher.addMatcher(varDecl(hasType(pointerType())).bind("mcsssnativepointer"), &HandlerForSSSNativePointer);
 
@@ -2830,6 +2997,30 @@ public:
 						argumentCountIs(3),
 						hasAnyArgument(hasType(pointerType()))
 	  		)).bind("mcsssmemset1"), &HandlerForSSSMemset);
+
+	  Matcher.addMatcher(
+	  		callExpr(allOf(
+	  				hasAnyArgument(
+	  				expr(anyOf(
+								memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemcpy2")))).bind("mcsssmemcpy3"),
+								hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemcpy2")))).bind("mcsssmemcpy3")),
+								hasDescendant(declRefExpr().bind("mcsssmemcpy2"))
+						))),
+						argumentCountIs(3),
+						hasAnyArgument(hasType(pointerType()))
+	  		)).bind("mcsssmemcpy1"), &HandlerForSSSMemcpy);
+
+	  Matcher.addMatcher(declStmt(hasDescendant(
+	  		varDecl(hasInitializer(ignoringImpCasts(
+					anyOf(
+							conditionalOperator(has(declRefExpr())).bind("mcsssconditionalinitializer2"),
+							conditionalOperator(hasDescendant(declRefExpr())).bind("mcsssconditionalinitializer2"),
+							cStyleCastExpr(has(conditionalOperator(has(declRefExpr())).bind("mcsssconditionalinitializer2"))),
+							cStyleCastExpr(has(conditionalOperator(hasDescendant(declRefExpr())).bind("mcsssconditionalinitializer2")))
+					)
+	  		))).bind("mcsssconditionalinitializer3")
+				)).bind("mcsssconditionalinitializer1"), &HandlerForSSSConditionalInitializer);
+
   }
 
   void HandleTranslationUnit(ASTContext &Context) override 
@@ -2850,6 +3041,8 @@ private:
   MCSSSFree2 HandlerForSSSFree2;
   MCSSSSetToNull2 HandlerForSSSSetToNull2;
   MCSSSMemset HandlerForSSSMemset;
+  MCSSSMemcpy HandlerForSSSMemcpy;
+  MCSSSConditionalInitializer HandlerForSSSConditionalInitializer;
 
   MatchFinder Matcher;
 };