preliminary auto-conversion of native arrays

1 files changed, 2120 insertions, 1 deletions

diff --git a/safercpp/safercpp-arr.cpp b/safercpp/safercpp-arr.cpp
index f040144..969e551 100644
--- a/safercpp/safercpp-arr.cpp
+++ b/safercpp/safercpp-arr.cpp
@@ -28,6 +28,11 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.*
 /*Standard headers*/
 #include <string>
 #include <iostream>
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <locale>
 /*Clang Headers*/
 #include "clang/AST/AST.h"
 #include "clang/AST/ASTConsumer.h"
@@ -51,13 +56,2114 @@ using namespace clang::driver;
 using namespace clang::tooling;
 /**********************************************************************************************************************/
 static llvm::cl::OptionCategory MatcherSampleCategory("TBD");
+
+cl::opt<bool> CheckSystemHeader("SysHeader", cl::desc("safercpp will run through System Headers"), cl::init(false), cl::cat(MatcherSampleCategory), cl::ZeroOrMore);
+cl::opt<bool> MainFileOnly("MainOnly", cl::desc("safercpp will only report the results that reside in the main file"), cl::init(false), cl::cat(MatcherSampleCategory), cl::ZeroOrMore);
+cl::opt<bool> SafeSubset("SafeSubset", cl::desc("safercpp will check for elements outside of the (memory) safe subset of the language"), cl::init(true), cl::cat(MatcherSampleCategory), cl::ZeroOrMore);
+cl::opt<bool> ConvertToSCPP("ConvertToSCPP", cl::desc("safercpp will translate the source to a (memory) safe subset of the language"), cl::init(false), cl::cat(MatcherSampleCategory), cl::ZeroOrMore);
+/**********************************************************************************************************************/
+
+static std::string with_whitespace_removed(const std::string& str) {
+	std::string retval = str;
+	retval.erase(std::remove_if(retval.begin(), retval.end(), isspace), retval.end());
+	return retval;
+}
+
+static std::string with_newlines_removed(const std::string& str) {
+	std::string retval = str;
+	auto riter1 = retval.rbegin();
+	while (retval.rend() != riter1) {
+		if ('\n' == *riter1) {
+			auto riter2 = riter1;
+			riter2++;
+			retval.erase(riter1.base()--);
+			while (retval.rend() != riter2) {
+				/* look for and remove 'continued on the next line' backslash if present. */
+				if ('\\' == (*riter2)) {
+					riter1++;
+					retval.erase(riter2.base()--);
+					break;
+				} else if (!std::isspace(*riter2)) {
+					break;
+				}
+
+				riter2++;
+			}
+		}
+
+		riter1++;
+	}
+
+	return retval;
+}
+
+static std::vector<std::string> f_declared_object_strings(const std::string& decl_stmt_str) {
+	std::vector<std::string> retval;
+
+	auto nice_decl_stmt_str = with_newlines_removed(decl_stmt_str);
+	auto semicolon_position = std::string::npos;
+	for (size_t pos = 3; pos < nice_decl_stmt_str.size(); pos += 1) {
+		if (';' == nice_decl_stmt_str[pos]) {
+			semicolon_position = pos;
+		}
+	}
+	if (std::string::npos == semicolon_position) {
+		assert(false);
+		return retval;
+	}
+
+	std::vector<size_t> delimiter_positions;
+	for (size_t pos = 3; ((pos < nice_decl_stmt_str.size()) && (pos < semicolon_position)); pos += 1) {
+		if (',' == nice_decl_stmt_str[pos]) {
+			delimiter_positions.push_back(pos);
+		}
+	}
+
+	delimiter_positions.push_back(semicolon_position);
+	auto first_delimiter_pos = delimiter_positions[0];
+
+	{
+		auto pos1 = first_delimiter_pos - 1;
+		auto pos2 = pos1;
+		bool nonspace_found = false;
+		while ((2 <= pos1) && (!nonspace_found)) {
+			if (!std::isspace(nice_decl_stmt_str[pos1])) {
+				pos2 = pos1 + 1;
+				nonspace_found = true;
+			}
+
+			pos1 -= 1;
+		}
+		if (!nonspace_found) {
+			assert(false);
+			return retval;
+		}
+
+		bool space_found = false;
+		while ((1 <= pos1) && (!space_found)) {
+			if (std::isspace(nice_decl_stmt_str[pos1])) {
+				space_found = true;
+			}
+
+			pos1 -= 1;
+		}
+		if (!space_found) {
+			assert(false);
+			return retval;
+		}
+
+		pos1 += 2;
+		std::string first_declaration_string = nice_decl_stmt_str.substr(pos1, pos2 - pos1);
+		retval.push_back(first_declaration_string);
+	}
+
+	{
+		size_t delimiter_index = 0;
+		while (delimiter_positions.size() > (delimiter_index + 1)) {
+			if (!(delimiter_positions[delimiter_index] + 1 < delimiter_positions[(delimiter_index + 1)])) {
+				//assert(false);
+			} else {
+				std::string declaration_string = nice_decl_stmt_str.substr(delimiter_positions[delimiter_index] + 1, delimiter_positions[(delimiter_index + 1)] - (delimiter_positions[delimiter_index] + 1));
+				retval.push_back(declaration_string);
+			}
+
+			delimiter_index += 1;
+		}
+	}
+
+	return retval;
+}
+
+class CDeclReplacementActionRecord {
+public:
+	CDeclReplacementActionRecord(Rewriter &Rewrite, const clang::DeclaratorDecl& ddecl, const std::string& replacement_text
+			, const std::string& action_species)
+		: m_Rewrite_ptr(&Rewrite), m_ddecl_cptr(&ddecl), m_replacement_text(replacement_text), m_action_species(action_species) {
+	}
+	virtual ~CDeclReplacementActionRecord() {}
+	clang::SourceRange source_range() {
+		clang::SourceRange retval = m_ddecl_cptr->getSourceRange();
+		return retval;
+	}
+	clang::SourceLocation start_location() {
+		clang::SourceLocation retval = source_range().getBegin();
+		return retval;
+	}
+	std::string get_var_name() {
+		std::string retval = m_ddecl_cptr->getNameAsString();
+		return retval;
+	}
+	const clang::DeclaratorDecl* get_ddecl_cptr() { return m_ddecl_cptr; }
+	std::string replacement_text() { return m_replacement_text; }
+	std::string action_species() { return m_action_species; }
+
+	Rewriter* m_Rewrite_ptr = nullptr;
+	const clang::DeclaratorDecl* m_ddecl_cptr = nullptr;
+	std::string m_replacement_text;
+	std::string m_action_species;
+};
+
+class CDeclReplacementActionRecordsLog : public std::vector<CDeclReplacementActionRecord> {
+public:
+	CDeclReplacementActionRecordsLog::iterator find(const clang::DeclaratorDecl* ddecl_cptr) {
+		CDeclReplacementActionRecordsLog::iterator retval = (*this).end();
+		CDeclReplacementActionRecordsLog::iterator iter = (*this).begin();
+		for (CDeclReplacementActionRecordsLog::iterator iter = (*this).begin(); (*this).end() != iter; iter++) {
+			if ((*iter).get_ddecl_cptr() == ddecl_cptr) {
+				retval = iter;
+				break;
+			}
+		}
+		return retval;
+	}
+	CDeclReplacementActionRecordsLog::iterator find(const clang::SourceLocation& start_location) {
+		CDeclReplacementActionRecordsLog::iterator retval = (*this).end();
+		for (CDeclReplacementActionRecordsLog::iterator iter = (*this).begin(); (*this).end() != iter; iter++) {
+			auto l_sl = (*iter).start_location();
+			if ((start_location.isValid()) && (l_sl.isValid()) && (start_location == l_sl)) {
+				retval = iter;
+				break;
+			}
+		}
+		return retval;
+	}
+};
+
+class CReplacementAction {
+public:
+	virtual ~CReplacementAction() {}
+	virtual void do_replacement() const = 0;
+};
+
+class CDDeclReplacementAction : public CReplacementAction {
+public:
+	CDDeclReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR,
+			const clang::DeclaratorDecl& ddecl) : m_Rewrite(Rewrite), m_MR(MR), m_ddecl_cptr(&ddecl) {
+	}
+	virtual ~CDDeclReplacementAction() {}
+
+	virtual void do_replacement() const = 0;
+	virtual const clang::DeclaratorDecl* get_ddecl_cptr() const { return m_ddecl_cptr; }
+
+	clang::SourceRange source_range() {
+		clang::SourceRange retval = m_ddecl_cptr->getSourceRange();
+		return retval;
+	}
+	clang::SourceLocation start_location() {
+		clang::SourceLocation retval = source_range().getBegin();
+		return retval;
+	}
+	std::string get_var_name() {
+		std::string retval = m_ddecl_cptr->getNameAsString();
+		return retval;
+	}
+
+	Rewriter& m_Rewrite;
+	const MatchFinder::MatchResult m_MR;
+	const clang::DeclaratorDecl* m_ddecl_cptr = nullptr;
+};
+
+class CDynamicArrayReplacementAction : public CDDeclReplacementAction {
+public:
+	using CDDeclReplacementAction::CDDeclReplacementAction;
+	virtual ~CDynamicArrayReplacementAction() {}
+};
+
+class CSetArrayPointerToNullReplacementAction : public CDynamicArrayReplacementAction {
+public:
+	CSetArrayPointerToNullReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const clang::DeclaratorDecl& ddecl,
+			const BinaryOperator* BO, const DeclRefExpr* DRE, const MemberExpr* ME)
+		: CDynamicArrayReplacementAction(Rewrite, MR, ddecl), m_BO(BO), m_DRE(DRE), m_ME(ME) {
+	}
+	virtual ~CSetArrayPointerToNullReplacementAction() {}
+
+	virtual void do_replacement() const {
+		Rewriter &Rewrite = m_Rewrite;
+		const MatchFinder::MatchResult &MR = m_MR;
+		const BinaryOperator* BO = m_BO;
+		const Expr* RHS = nullptr;
+		const Expr* LHS = nullptr;
+		if (BO != nullptr) {
+			RHS = BO->getRHS();
+			LHS = BO->getLHS();
+		}
+		const DeclRefExpr* DRE = m_DRE;
+		const MemberExpr* ME = m_ME;
+
+		if ((BO != nullptr) && (RHS != nullptr) && (LHS != nullptr) && (DRE != nullptr))
+	    {
+	        SourceLocation BOSL = BO->getLocStart();
+	        SourceLocation BOSLMID;
+
+	        if (BOSL.isMacroID())
+	        {
+	          BOSLMID = Devi::SourceLocationHasMacro(BOSL, Rewrite, "start");
+	        }
+
+	        BOSL = Devi::SourceLocationHasMacro(BOSL, Rewrite, "start");
+	        SourceLocation BOSLE = BO->getLocEnd();
+	        SourceLocation BOSLEMID;
+
+	        if (BOSLE.isMacroID())
+	        {
+	          BOSLEMID = Devi::SourceLocationHasMacro(BOSLE, Rewrite, "end");
+	        }
+
+	        BOSLE = Devi::SourceLocationHasMacro(BOSLE, Rewrite, "end");
+
+	        ASTContext *const ASTC = MR.Context;
+	        FullSourceLoc FBOSL = ASTC->getFullLoc(BOSL);
+
+	        SourceManager &SM = ASTC->getSourceManager();
+
+	        auto source_location_str = BOSL.printToString(*MR.SourceManager);
+	        std::string source_text;
+	        if (BOSL.isValid() && BOSLE.isValid()) {
+	      	  source_text = Rewrite.getRewrittenText(SourceRange(BOSL, BOSLE));
+	        } else {
+	      	  return;
+	        }
+
+	      if (Devi::IsTheMatchInSysHeader(CheckSystemHeader, MR, BOSL))
+	      {
+	        return void();
+	      }
+
+	      if (!Devi::IsTheMatchInMainFile(MainFileOnly, MR, BOSL))
+	      {
+	        return void();
+	      }
+
+	      Expr::NullPointerConstantKind kind = RHS->isNullPointerConstant(*ASTC, Expr::NullPointerConstantValueDependence());
+	      if (clang::Expr::NPCK_NotNull != kind) {
+			  auto lhs_source_range = LHS->getSourceRange();
+			  std::string lhs_source_text;
+			  if (lhs_source_range.isValid()) {
+				  lhs_source_text = Rewrite.getRewrittenText(lhs_source_range);
+				  //auto lhs_source_text_sans_ws = with_whitespace_removed(lhs_source_text);
+
+				  QualType QT;
+				  std::string element_type_str;
+				  clang::SourceRange decl_source_range;
+				  std::string variable_name;
+				  std::string bo_replacement_code;
+				  const clang::DeclaratorDecl* DD = nullptr;
+
+				  auto decl = DRE->getDecl();
+				  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;
+
+					  auto field_decl_source_range = FD->getSourceRange();
+					  auto field_decl_source_location_str = field_decl_source_range.getBegin().printToString(*MR.SourceManager);
+					  std::string field_decl_source_text;
+					  if (field_decl_source_range.isValid()) {
+						  field_decl_source_text = Rewrite.getRewrittenText(field_decl_source_range);
+						  decl_source_range = field_decl_source_range;
+					  } else {
+						  return;
+					  }
+					  QT = FD->getType();
+					  variable_name = FD->getNameAsString();
+				  } else if (nullptr != VD) {
+					  DD = VD;
+					  SourceLocation VDSL = VD->getLocStart();
+					  VDSL = Devi::SourceLocationHasMacro(VDSL, Rewrite, "start");
+					  SourceLocation VDSLE = VD->getLocEnd();
+					  VDSLE = Devi::SourceLocationHasMacro(VDSLE, Rewrite, "end");
+					  decl_source_range = clang::SourceRange(VDSL, VDSLE);
+
+					  auto qualified_name = VD->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;
+					  }
+
+					  QT = VD->getType();
+					  variable_name = VD->getNameAsString();
+				  } else {
+					  int q = 7;
+				  }
+
+				  if (nullptr != DD) {
+					  if (true) {
+						  if (true) {
+							  bo_replacement_code = lhs_source_text;
+							  bo_replacement_code += ".resize(0)";
+
+							  auto BOSR = clang::SourceRange(BOSL, BOSLE);
+							  if (ConvertToSCPP && (BOSR.isValid())) {
+								  auto res2 = Rewrite.ReplaceText(BOSR, bo_replacement_code);
+								  int q = 3;
+							  } else {
+								  int q = 7;
+							  }
+						  } else {
+							  int q = 5;
+						  }
+					  }
+				  }
+				  int q = 5;
+			  } else {
+				  int q = 5;
+			  }
+			  int q = 5;
+	      }
+	    }
+	}
+
+	const BinaryOperator* m_BO;
+	const DeclRefExpr* m_DRE;
+	const MemberExpr* m_ME;
+};
+
+std::string tolowerstr(const std::string& a) {
+	std::string retval;
+	for (const auto& ch : a) {
+		retval += tolower(ch);
+	}
+	return retval;
+}
+
+class CFreeDynamicArrayReplacementAction : public CDynamicArrayReplacementAction {
+public:
+	CFreeDynamicArrayReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const clang::DeclaratorDecl& ddecl,
+			const CallExpr* CE, const DeclRefExpr* DRE, const MemberExpr* ME)
+		: CDynamicArrayReplacementAction(Rewrite, MR, ddecl), m_CE(CE), m_DRE(DRE), m_ME(ME) {
+	}
+	virtual ~CFreeDynamicArrayReplacementAction() {}
+
+	virtual void do_replacement() const {
+		Rewriter &Rewrite = m_Rewrite;
+		const MatchFinder::MatchResult &MR = m_MR;
+		const CallExpr* CE = m_CE;
+		const DeclRefExpr* DRE = m_DRE;
+		const MemberExpr* ME = m_ME;
+
+		if ((CE != nullptr) && (DRE != nullptr))
+	    {
+	        SourceLocation CESL = CE->getLocStart();
+	        SourceLocation CESLMID;
+
+	        if (CESL.isMacroID())
+	        {
+	          CESLMID = Devi::SourceLocationHasMacro(CESL, Rewrite, "start");
+	        }
+
+	        CESL = Devi::SourceLocationHasMacro(CESL, Rewrite, "start");
+	        SourceLocation CESLE = CE->getLocEnd();
+	        SourceLocation CESLEMID;
+
+	        if (CESLE.isMacroID())
+	        {
+	          CESLEMID = Devi::SourceLocationHasMacro(CESLE, Rewrite, "end");
+	        }
+
+	        CESLE = Devi::SourceLocationHasMacro(CESLE, Rewrite, "end");
+
+	        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 (Devi::IsTheMatchInSysHeader(CheckSystemHeader, MR, CESL))
+	      {
+	        return void();
+	      }
+
+	      if (!Devi::IsTheMatchInMainFile(MainFileOnly, MR, CESL))
+	      {
+	        return void();
+	      }
+
+	      auto function_decl = CE->getDirectCallee();
+	      auto num_args = CE->getNumArgs();
+	      if (function_decl && (1 == num_args)) {
+	    	  {
+				  std::string function_name = function_decl->getNameAsString();
+				  static const std::string free_str = "free";
+				  auto lc_function_name = tolowerstr(function_name);
+				  bool ends_with_free = ((lc_function_name.size() >= free_str.size())
+						  && (0 == lc_function_name.compare(lc_function_name.size() - free_str.size(), free_str.size(), free_str)));
+				  if (ends_with_free) {
+					  auto iter = CE->arg_begin();
+					  assert((*iter)->getType().getTypePtrOrNull());
+					  auto arg_source_range = (*iter)->getSourceRange();
+					  std::string arg_source_text;
+					  if (arg_source_range.isValid()) {
+						  arg_source_text = Rewrite.getRewrittenText(arg_source_range);
+						  //auto arg_source_text_sans_ws = with_whitespace_removed(arg_source_text);
+						  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 = DD->getSourceRange();
+							  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();
+							  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;
+							  }
+
+							  if (true) {
+								  ce_replacement_code = arg_source_text;
+								  ce_replacement_code += ".resize(0)";
+
+								  auto CESR = clang::SourceRange(CESL, CESLE);
+								  if (ConvertToSCPP && (CESR.isValid())) {
+									  auto res2 = Rewrite.ReplaceText(CESR, ce_replacement_code);
+									  int q = 3;
+								  } else {
+									  int q = 7;
+								  }
+							  }
+						  }
+						  int q = 5;
+					  } else {
+						  int q = 5;
+					  }
+					  int q = 5;
+				  }
+	    	  }
+
+	      }
+	    }
+	}
+
+	const CallExpr* m_CE;
+	const DeclRefExpr* m_DRE;
+	const MemberExpr* m_ME;
+};
+
+class CDynamicArrayReplacementActionMap : public std::multimap<const clang::DeclaratorDecl*, std::shared_ptr<CDynamicArrayReplacementAction>> {
+public:
+	typedef std::multimap<const clang::DeclaratorDecl*, std::shared_ptr<CDynamicArrayReplacementAction>> base_class;
+	iterator insert( const std::shared_ptr<CDynamicArrayReplacementAction>& cr_shptr ) {
+		iterator retval(end());
+		if (!cr_shptr) { assert(false); } else {
+			value_type val((*cr_shptr).get_ddecl_cptr(), cr_shptr);
+			retval = base_class::insert(val);
+		}
+		return retval;
+	}
+	void do_and_dispose_matching_replacements(const clang::DeclaratorDecl& ddecl) {
+		auto DD = &ddecl;
+		auto range = base_class::equal_range(DD);
+		while (range.first != range.second) {
+			for (auto iter = range.first; range.second != iter; iter++) {
+				(*((*iter).second)).do_replacement();
+			}
+			base_class::erase(range.first, range.second);
+			range = base_class::equal_range(DD);
+		}
+	}
+};
+
+class CState1 {
+public:
+	CDeclReplacementActionRecordsLog m_decl_replacement_action_records_log;
+	CDynamicArrayReplacementActionMap m_dynamic_array_contingent_replacement_map;
+};
+
+/**********************************************************************************************************************/
+class MCSSSArrayToPointerDecay : public MatchFinder::MatchCallback
+{
+public:
+	MCSSSArrayToPointerDecay (Rewriter &Rewrite, CState1& state1)
+		: Rewrite(Rewrite), m_state1(state1) {}
+
+  virtual void run(const MatchFinder::MatchResult &MR)
+  {
+    if (/*SafeSubset && */(MR.Nodes.getNodeAs<clang::CastExpr>("mcsssarraytopointerdecay") != nullptr))
+    {
+      const CastExpr* CE = MR.Nodes.getNodeAs<clang::CastExpr>("mcsssarraytopointerdecay");
+
+      SourceLocation SL = CE->getLocStart();
+      SL = Devi::SourceLocationHasMacro(SL, Rewrite, "start");
+      SourceLocation SLE = CE->getLocEnd();
+      SLE = Devi::SourceLocationHasMacro(SLE, Rewrite, "end");
+
+      ASTContext *const ASTC = MR.Context;
+      FullSourceLoc FSL = ASTC->getFullLoc(SL);
+
+      auto source_location_str = SL.printToString(*MR.SourceManager);
+      std::string source_text;
+      if (SL.isValid() && SLE.isValid()) {
+    	  source_text = Rewrite.getRewrittenText(SourceRange(SL, SLE));
+      } else {
+    	  return;
+      }
+
+      if (Devi::IsTheMatchInSysHeader(CheckSystemHeader, MR, SL))
+      {
+        /*intentionally left blank*/
+      }
+      else
+      {
+        if (Devi::IsTheMatchInMainFile(MainFileOnly, MR, SL))
+        {
+        	if (true) {
+				  std::cout << "sss1.2:" << "array to pointer decay:";
+				  std::cout << SL.printToString(*MR.SourceManager) << ":" << std::endl;
+
+				  //XMLDocOut.XMLAddNode(MR.Context, SL, "sss1.2", "array to pointer decay: ");
+				  //JSONDocOUT.JSONAddElement(MR.Context, SL, "sss1.2", "array to pointer decay: ");
+			}
+        }
+      }
+    }
+  }
+
+private:
+  Rewriter &Rewrite;
+  CState1& m_state1;
+};
+/**********************************************************************************************************************/
+class MCSSSNativePointer : public MatchFinder::MatchCallback
+{
+public:
+	MCSSSNativePointer (Rewriter &Rewrite) : Rewrite(Rewrite) {}
+
+  virtual void run(const MatchFinder::MatchResult &MR)
+  {
+    if (SafeSubset && (MR.Nodes.getNodeAs<clang::VarDecl>("mcsssnativepointer") != nullptr))
+    {
+      const VarDecl *VD = MR.Nodes.getNodeAs<clang::VarDecl>("mcsssnativepointer");
+
+      SourceLocation SL = VD->getLocStart();
+      SL = Devi::SourceLocationHasMacro(SL, Rewrite, "start");
+      SourceLocation SE = VD->getLocEnd();
+      SE = Devi::SourceLocationHasMacro(SE, Rewrite, "end");
+
+      ASTContext* const ASTC = MR.Context;
+      FullSourceLoc FSL = ASTC->getFullLoc(SL);
+
+      auto source_location_str = SL.printToString(*MR.SourceManager);
+      std::string source_text;
+      if (SL.isValid() && SE.isValid()) {
+    	  source_text = Rewrite.getRewrittenText(SourceRange(SL, SE));
+      } else {
+    	  return;
+      }
+
+      if (Devi::IsTheMatchInSysHeader(CheckSystemHeader, MR, SL))
+      {
+        /*intentionally left blank*/
+      }
+      else
+      {
+        if (Devi::IsTheMatchInMainFile(MainFileOnly, MR, SL))
+        {
+        	if (SafeSubset) {
+			  std::cout << "sss1.1:" << "native pointer:";
+			  std::cout << SL.printToString(*MR.SourceManager) << ":" << std::endl;
+
+			  //XMLDocOut.XMLAddNode(MR.Context, SL, "sss1.1", "native pointer: ");
+			  //JSONDocOUT.JSONAddElement(MR.Context, SL, "sss1.1", "native pointer: ");
+        	}
+        }
+      }
+    }
+  }
+
+  virtual void onEndOfTranslationUnit()
+  {
+  }
+
+private:
+  Rewriter &Rewrite;
+};
+/**********************************************************************************************************************/
+class MCSSSVarDecl : public MatchFinder::MatchCallback
+{
+public:
+	MCSSSVarDecl (Rewriter &Rewrite, CState1& state1)
+		: Rewrite(Rewrite), m_state1(state1) {}
+
+  virtual void run(const MatchFinder::MatchResult &MR)
+  {
+    if ((MR.Nodes.getNodeAs<clang::VarDecl>("mcsssvardecl") != nullptr))
+    {
+      const VarDecl* VD = MR.Nodes.getNodeAs<clang::VarDecl>("mcsssvardecl");
+
+      SourceLocation SL = VD->getLocStart();
+      SourceLocation SLMID;
+
+      if (SL.isMacroID())
+      {
+        SLMID = Devi::SourceLocationHasMacro(SL, Rewrite, "start");
+      }
+
+      SL = Devi::SourceLocationHasMacro(SL, Rewrite, "start");
+      SourceLocation SLE = VD->getLocEnd();
+      SourceLocation SLEMID;
+
+      if (SLE.isMacroID())
+      {
+        SLEMID = Devi::SourceLocationHasMacro(SLE, Rewrite, "end");
+      }
+
+      SLE = Devi::SourceLocationHasMacro(SLE, Rewrite, "end");
+
+      QualType QT = VD->getType();
+
+      const clang::Type* TP = QT.getTypePtr();
+
+      ASTContext *const ASTC = MR.Context;
+      FullSourceLoc FSL = ASTC->getFullLoc(SL);
+
+      SourceManager &SM = ASTC->getSourceManager();
+
+      auto source_location_str = SL.printToString(*MR.SourceManager);
+      std::string source_text;
+      if (SL.isValid() && SLE.isValid()) {
+    	  source_text = Rewrite.getRewrittenText(SourceRange(SL, SLE));
+      } else {
+    	  return;
+      }
+
+      auto storage_duration = VD->getStorageDuration();
+      bool has_dynamic_storage_duration = (clang::StorageDuration::SD_Dynamic == storage_duration);
+      bool is_a_temporary = (clang::StorageDuration::SD_FullExpression == storage_duration);
+      bool is_static = (clang::StorageDuration::SD_Static == storage_duration);
+      bool is_a_function_parameter = (VD->isLocalVarDeclOrParm() && (!VD->isLocalVarDecl()));
+
+	  auto variable_name = VD->getName();
+	  auto variable_name2 = VD->getNameAsString();
+	  std::string identifier_name_str;
+	  auto pIdentifier = VD->getIdentifier();
+	  if (pIdentifier) {
+		  identifier_name_str = pIdentifier->getName();
+	  }
+
+	  std::string initialization_expr_str;
+	  auto pInitExpr = VD->getInit();
+	  if (VD->hasInit() && pInitExpr) {
+		  auto init_expr_source_range = pInitExpr->getSourceRange();
+		  initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range);
+	  }
+
+	  if (TP->isArrayType()) {
+    	  auto ATP = static_cast<const clang::ArrayType*>(TP);
+    	  auto element_type = ATP->getElementType();
+    	  auto elementSplitQualType = element_type.split();
+    	  auto element_type_str = clang::QualType::getAsString(elementSplitQualType);
+
+    	  std::string replacement_code;
+    	  if (is_static) {
+    		  replacement_code += "static ";
+    	  }
+    	  replacement_code += "mse::mstd::array<";
+    	  replacement_code += element_type_str;
+    	  replacement_code += ", ";
+
+    	  if (TP->isConstantArrayType()) {
+    		  auto CATP = static_cast<const clang::ConstantArrayType*>(TP);
+    		  if (!CATP) {
+    			  assert(false);
+    		  } else {
+    			  auto array_size = CATP->getSize();
+
+    			  auto left_bracket_pos = source_text.find('[');
+    			  auto right_bracket_pos = source_text.find(']');
+    			  if ((std::string::npos != left_bracket_pos) && (std::string::npos != right_bracket_pos)
+						  && (left_bracket_pos + 1 < right_bracket_pos)) {
+    				  auto array_size_expression_text = source_text.substr(left_bracket_pos + 1, right_bracket_pos - (left_bracket_pos + 1));
+
+    				  replacement_code += array_size_expression_text;
+    				  int q = 3;
+    			  } else {
+    				  int q = 7;
+    			  }
+    			  int q = 5;
+    		  }
+    	  } else if (TP->isVariableArrayType()) {
+    		  auto VATP = static_cast<const clang::VariableArrayType*>(TP);
+    		  if (!VATP) {
+    			  assert(false);
+    		  } else {
+    			  auto size_expr = VATP->getSizeExpr();
+    		  }
+    	  }
+
+    	  replacement_code += "> ";
+    	  std::string new_array_variable_name = variable_name;
+    	  new_array_variable_name += "_array";
+    	  replacement_code += new_array_variable_name;
+    	  if ("" != initialization_expr_str) {
+        	  replacement_code += " = ";
+        	  replacement_code += initialization_expr_str;
+    	  }
+    	  replacement_code += "; \n";
+    	  if (is_static) {
+    		  replacement_code += "static ";
+    	  }
+    	  replacement_code += "auto ";
+    	  replacement_code += variable_name;
+    	  replacement_code += " = ";
+    	  replacement_code += new_array_variable_name;
+    	  replacement_code += ".begin()";
+          if (ConvertToSCPP && SL.isValid() && SLE.isValid()) {
+        	  auto res = Rewrite.ReplaceText(SourceRange(SL, SLE), replacement_code);
+        	  CDeclReplacementActionRecord action_record(Rewrite, *VD, replacement_code, "native to mse array");
+        	  m_state1.m_decl_replacement_action_records_log.push_back(action_record);
+        	  m_state1.m_dynamic_array_contingent_replacement_map.do_and_dispose_matching_replacements(*VD);
+        	  int q = 3;
+          } else {
+        	  int q = 7;
+          }
+          m_state1.m_dynamic_array_contingent_replacement_map.do_and_dispose_matching_replacements(*VD);
+    	  int q = 5;
+      } else {
+    	  ;
+      }
+
+    }
+  }
+
+  virtual void onEndOfTranslationUnit()
+  {
+  }
+
+private:
+  Rewriter &Rewrite;
+  CState1& m_state1;
+};
+
+/**********************************************************************************************************************/
+class CRandomAccessIteratorFromPointerDDeclRetval {
+public:
+	std::string m_replacement_code;
+	std::string m_action_species;
+};
+static CRandomAccessIteratorFromPointerDDeclRetval RandomAccessIteratorFromPointerDDecl(const DeclaratorDecl* DD, Rewriter &Rewrite) {
+	CRandomAccessIteratorFromPointerDDeclRetval retval;
+
+	QualType QT = DD->getType();
+
+    const clang::Type* TP = QT.getTypePtr();
+
+    clang::StorageDuration storage_duration = clang::StorageDuration::SD_Automatic;
+    bool has_dynamic_storage_duration = false;
+    bool is_a_temporary = false;
+    bool is_static = false;
+    bool is_a_function_parameter = false;
+	std::string initialization_expr_str;
+
+	auto VD = dynamic_cast<const clang::VarDecl *>(DD);
+    if (VD) {
+        storage_duration = VD->getStorageDuration();
+        has_dynamic_storage_duration = (clang::StorageDuration::SD_Dynamic == storage_duration);
+        is_a_temporary = (clang::StorageDuration::SD_FullExpression == storage_duration);
+        is_static = (clang::StorageDuration::SD_Static == storage_duration);
+        is_a_function_parameter = (VD->isLocalVarDeclOrParm() && (!VD->isLocalVarDecl()));
+
+    	auto pInitExpr = VD->getInit();
+    	if (VD->hasInit() && pInitExpr) {
+    	  auto init_expr_source_range = pInitExpr->getSourceRange();
+    	  initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range);
+    	}
+    }
+
+	auto variable_name = DD->getNameAsString();
+	std::string identifier_name_str;
+	auto pIdentifier = DD->getIdentifier();
+	if (pIdentifier) {
+	  identifier_name_str = pIdentifier->getName();
+	}
+
+	bool replacement_code_generated = false;
+	if (TP->isPointerType()) {
+	  auto TPP = static_cast<const clang::PointerType*>(TP);
+	  if (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)) {
+			  std::string replacement_code;
+			  if (is_static) {
+				  replacement_code += "static ";
+			  }
+			  replacement_code += "mse::TAnyRandomAccessIterator<";
+			  replacement_code += type_str;
+			  replacement_code += "> ";
+			  replacement_code += variable_name;
+
+			  if ("" != initialization_expr_str) {
+				  replacement_code += " = ";
+				  replacement_code += initialization_expr_str;
+			  }
+			  retval.m_replacement_code = replacement_code;
+			  retval.m_action_species = "pointer to random access iterator";
+			  replacement_code_generated = true;
+		  } else {
+			  int q = 3;
+		  }
+	  } else {
+		  assert(false);
+		  int q = 1;
+	  }
+	}
+
+	if (!replacement_code_generated) {
+		  auto splitQualType = QT.split();
+		  auto type_str = clang::QualType::getAsString(splitQualType);
+
+		  std::string replacement_code;
+		  if (is_static) {
+			  replacement_code += "static ";
+		  }
+		  replacement_code += type_str;
+		  replacement_code += " ";
+		  replacement_code += variable_name;
+
+		  if ("" != initialization_expr_str) {
+			  replacement_code += " = ";
+			  replacement_code += initialization_expr_str;
+		  }
+		  retval.m_replacement_code = replacement_code;
+		  retval.m_action_species = "char*";
+		  replacement_code_generated = true;
+	}
+	return retval;
+}
+
+static std::vector<const DeclaratorDecl*> IndividualDeclaratorDecls(const DeclaratorDecl* VD, Rewriter &Rewrite) {
+	std::vector<const DeclaratorDecl*> retval;
+
+	if (!VD) {
+		assert(false);
+		return retval;
+	}
+	SourceLocation SL = VD->getLocStart();
+    SL = Devi::SourceLocationHasMacro(SL, Rewrite, "start");
+
+    auto decl_context = VD->getDeclContext();
+	if ((!decl_context) || (!SL.isValid())) {
+		assert(false);
+		retval.push_back(VD);
+	} else {
+		for (auto decl_iter = decl_context->decls_begin(); decl_iter != decl_context->decls_end(); decl_iter++) {
+			auto decl = (*decl_iter);
+			auto var_decl = dynamic_cast<const DeclaratorDecl*>(decl);
+			if (var_decl) {
+				SourceLocation l_SL = var_decl->getLocStart();
+				l_SL = Devi::SourceLocationHasMacro(l_SL, Rewrite, "start");
+				if (l_SL == SL) {
+					retval.push_back(var_decl);
+				}
+			}
+		}
+	}
+	if (0 == retval.size()) {
+		assert(false);
+	}
+
+	return retval;
+}
+
+class MCSSSPointerArithmetic : public MatchFinder::MatchCallback
+{
+public:
+	MCSSSPointerArithmetic (Rewriter &Rewrite, CState1& state1)
+		: Rewrite(Rewrite), m_state1(state1) {}
+
+  virtual void run(const MatchFinder::MatchResult &MR)
+  {
+	  const DeclRefExpr* DRE = MR.Nodes.getNodeAs<clang::DeclRefExpr>("mcssspointerarithmetic");
+	  const MemberExpr* ME = MR.Nodes.getNodeAs<clang::MemberExpr>("mcssspointerarithmetic2");
+
+    if (DRE != nullptr)
+    {
+        const DeclRefExpr* DRE = MR.Nodes.getNodeAs<clang::DeclRefExpr>("mcssspointerarithmetic");
+
+        SourceLocation SL = DRE->getLocStart();
+        SourceLocation SLMID;
+
+        if (SL.isMacroID())
+        {
+          SLMID = Devi::SourceLocationHasMacro(SL, Rewrite, "start");
+        }
+
+        SL = Devi::SourceLocationHasMacro(SL, Rewrite, "start");
+        SourceLocation SLE = DRE->getLocEnd();
+        SourceLocation SLEMID;
+
+        if (SLE.isMacroID())
+        {
+          SLEMID = Devi::SourceLocationHasMacro(SLE, Rewrite, "end");
+        }
+
+        SLE = Devi::SourceLocationHasMacro(SLE, Rewrite, "end");
+
+        QualType QT = DRE->getType();
+
+        const clang::Type* TP = QT.getTypePtr();
+
+        ASTContext *const ASTC = MR.Context;
+        FullSourceLoc FSL = ASTC->getFullLoc(SL);
+
+        SourceManager &SM = ASTC->getSourceManager();
+
+        auto source_location_str = SL.printToString(*MR.SourceManager);
+        std::string source_text;
+        if (SL.isValid() && SLE.isValid()) {
+      	  source_text = Rewrite.getRewrittenText(SourceRange(SL, SLE));
+        } else {
+      	  return;
+        }
+
+
+      if (Devi::IsTheMatchInSysHeader(CheckSystemHeader, MR, SL))
+      {
+        return void();
+      }
+
+      if (!Devi::IsTheMatchInMainFile(MainFileOnly, MR, SL))
+      {
+        return void();
+      }
+
+      auto decl = DRE->getDecl();
+      auto DD = dynamic_cast<const DeclaratorDecl*>(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;
+	  }
+
+      if (!DD) {
+    	  return;
+      } else {
+		  auto decl_source_range = DD->getSourceRange();
+		  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();
+		  std::string 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 iter = m_state1.m_decl_replacement_action_records_log.find(DD);
+          if (m_state1.m_decl_replacement_action_records_log.end() != iter) {
+        	  /* This variable declaration has already been processed. Probably. */
+        	  return;
+          }
+
+          auto var_decls = IndividualDeclaratorDecls(DD, Rewrite);
+          if ((1 <= var_decls.size()) && (var_decls.back() == DD)) {
+        	  std::vector<std::string> action_species_list;
+        	  std::string replacement_code;
+        	  for (const auto& var_decl : var_decls) {
+        		  auto res = RandomAccessIteratorFromPointerDDecl(var_decl, Rewrite);
+        		  action_species_list.push_back(res.m_action_species);
+        		  replacement_code += res.m_replacement_code;
+        		  replacement_code += "; \n";
+        	  }
+        	  if (replacement_code.size() >= 3) {
+        		  replacement_code = replacement_code.substr(0, replacement_code.size() - 3);
+        	  }
+
+        	  if (ConvertToSCPP && decl_source_range.isValid() && (3 <= replacement_code.size())) {
+            	  auto res = Rewrite.ReplaceText(decl_source_range, replacement_code);
+
+            	  for (auto var_decl : var_decls) {
+            		  assert(1 <= action_species_list.size());
+					  CDeclReplacementActionRecord action_record(Rewrite, *var_decl, replacement_code, action_species_list.front());
+					  action_species_list.erase(action_species_list.begin());
+					  m_state1.m_decl_replacement_action_records_log.push_back(action_record);
+					  //m_state1.m_dynamic_array_contingent_replacement_map.do_and_dispose_matching_replacements(*var_decl);
+            	  }
+            	  int q = 3;
+              } else {
+            	  int q = 7;
+              }
+          } else {
+        	  int q = 7;
+          }
+      }
+    }
+  }
+
+private:
+  Rewriter &Rewrite;
+  CState1& m_state1;
+};
+
 /**********************************************************************************************************************/
+static std::string IPointerFromPointerDecl(const DeclaratorDecl* DD, Rewriter &Rewrite, bool discard_initializer = false) {
+	std::string retval;
+
+	QualType QT = DD->getType();
+
+    const clang::Type* TP = QT.getTypePtr();
+
+    clang::StorageDuration storage_duration = clang::StorageDuration::SD_Automatic;
+    bool has_dynamic_storage_duration = false;
+    bool is_a_temporary = false;
+    bool is_static = false;
+    bool is_a_function_parameter = false;
+	std::string initialization_expr_str;
+
+	auto FD = dynamic_cast<const clang::FieldDecl *>(DD);
+	auto VD = dynamic_cast<const clang::VarDecl *>(DD);
+    if (VD) {
+        storage_duration = VD->getStorageDuration();
+        has_dynamic_storage_duration = (clang::StorageDuration::SD_Dynamic == storage_duration);
+        is_a_temporary = (clang::StorageDuration::SD_FullExpression == storage_duration);
+        is_static = (clang::StorageDuration::SD_Static == storage_duration);
+        is_a_function_parameter = (VD->isLocalVarDeclOrParm() && (!VD->isLocalVarDecl()));
+
+    	auto pInitExpr = VD->getInit();
+    	if (VD->hasInit() && pInitExpr) {
+    	  auto init_expr_source_range = pInitExpr->getSourceRange();
+    	  initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range);
+    	}
+    } else if (FD) {
+    	/* Just placeholder code for now. Haven't thought about this case yet. */
+    	auto pInitExpr = FD->getInClassInitializer();
+    	if (FD->hasInClassInitializer() && pInitExpr) {
+    	  auto init_expr_source_range = pInitExpr->getSourceRange();
+    	  initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range);
+    	}
+    }
+
+	auto variable_name = DD->getNameAsString();
+	std::string identifier_name_str;
+	auto pIdentifier = DD->getIdentifier();
+	if (pIdentifier) {
+	  identifier_name_str = pIdentifier->getName();
+	}
+
+	bool replacement_code_generated = false;
+	if (TP->isPointerType()) {
+	  auto TPP = static_cast<const clang::PointerType*>(TP);
+	  if (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)) {
+			  std::string replacement_code;
+			  if (is_static) {
+				  replacement_code += "static ";
+			  }
+			  replacement_code += "mse::TIPointerWithBundledVector<";
+			  replacement_code += type_str;
+			  replacement_code += "> ";
+			  replacement_code += variable_name;
+
+			  if (("" != initialization_expr_str) && (!discard_initializer)) {
+				  replacement_code += " = ";
+				  replacement_code += initialization_expr_str;
+			  }
+			  retval = replacement_code;
+			  replacement_code_generated = true;
+		  } else {
+			  int q = 3;
+		  }
+	  } else {
+		  assert(false);
+		  int q = 1;
+	  }
+	}
+
+	if (!replacement_code_generated) {
+		  auto splitQualType = QT.split();
+		  auto type_str = clang::QualType::getAsString(splitQualType);
+
+		  std::string replacement_code;
+		  if (is_static) {
+			  replacement_code += "static ";
+		  }
+		  replacement_code += type_str;
+		  replacement_code += " ";
+		  replacement_code += variable_name;
+
+		  if ("" != initialization_expr_str) {
+			  replacement_code += " = ";
+			  replacement_code += initialization_expr_str;
+		  }
+		  retval = replacement_code;
+		  replacement_code_generated = true;
+	}
+	return retval;
+}
+
+class MCSSSMalloc : public MatchFinder::MatchCallback
+{
+public:
+	MCSSSMalloc (Rewriter &Rewrite, CState1& state1)
+		: Rewrite(Rewrite), m_state1(state1) {}
+
+  virtual void run(const MatchFinder::MatchResult &MR)
+  {
+	const BinaryOperator* BO = MR.Nodes.getNodeAs<clang::BinaryOperator>("mcsssmalloc1");
+	const CallExpr* CE = MR.Nodes.getNodeAs<clang::CallExpr>("mcsssmalloc2");
+	const DeclRefExpr* DRE = MR.Nodes.getNodeAs<clang::DeclRefExpr>("mcsssmalloc3");
+	const MemberExpr* ME = MR.Nodes.getNodeAs<clang::MemberExpr>("mcsssmalloc4");
+
+	if ((BO != nullptr) && (CE != nullptr) && (DRE != nullptr))
+    {
+        SourceLocation BOSL = BO->getLocStart();
+        SourceLocation BOSLMID;
+
+        if (BOSL.isMacroID())
+        {
+          BOSLMID = Devi::SourceLocationHasMacro(BOSL, Rewrite, "start");
+        }
+
+        BOSL = Devi::SourceLocationHasMacro(BOSL, Rewrite, "start");
+        SourceLocation BOSLE = BO->getLocEnd();
+        SourceLocation BOSLEMID;
+
+        if (BOSLE.isMacroID())
+        {
+          BOSLEMID = Devi::SourceLocationHasMacro(BOSLE, Rewrite, "end");
+        }
+
+        BOSLE = Devi::SourceLocationHasMacro(BOSLE, Rewrite, "end");
+
+        ASTContext *const ASTC = MR.Context;
+        FullSourceLoc FBOSL = ASTC->getFullLoc(BOSL);
+
+        SourceManager &SM = ASTC->getSourceManager();
+
+        auto source_location_str = BOSL.printToString(*MR.SourceManager);
+        std::string source_text;
+        if (BOSL.isValid() && BOSLE.isValid()) {
+      	  source_text = Rewrite.getRewrittenText(SourceRange(BOSL, BOSLE));
+        } else {
+      	  return;
+        }
+
+      if (Devi::IsTheMatchInSysHeader(CheckSystemHeader, MR, BOSL))
+      {
+        return void();
+      }
+
+      if (!Devi::IsTheMatchInMainFile(MainFileOnly, MR, BOSL))
+      {
+        return void();
+      }
+
+      auto function_decl = CE->getDirectCallee();
+      auto num_args = CE->getNumArgs();
+      if (function_decl && (1 == num_args)) {
+    	  {
+			  std::string function_name = function_decl->getNameAsString();
+			  static const std::string alloc_str = "alloc";
+			  static const std::string realloc_str = "realloc";
+			  auto lc_function_name = tolowerstr(function_name);
+			  bool ends_with_alloc = ((lc_function_name.size() >= alloc_str.size())
+					  && (0 == lc_function_name.compare(lc_function_name.size() - alloc_str.size(), alloc_str.size(), alloc_str)));
+			  bool ends_with_realloc = (ends_with_alloc && (lc_function_name.size() >= realloc_str.size())
+					  && (0 == lc_function_name.compare(lc_function_name.size() - realloc_str.size(), realloc_str.size(), realloc_str)));
+			  if (ends_with_realloc) {
+				  int q = 5;
+			  } else if (ends_with_alloc) {
+				  auto iter = CE->arg_begin();
+				  auto arg_source_range = (*iter)->getSourceRange();
+				  std::string arg_source_text;
+				  if (arg_source_range.isValid()) {
+					  arg_source_text = Rewrite.getRewrittenText(arg_source_range);
+					  //auto arg_source_text_sans_ws = with_whitespace_removed(arg_source_text);
+					  auto sizeof_start_index = arg_source_text.find("sizeof(");
+					  if (std::string::npos != sizeof_start_index) {
+						  auto sizeof_end_index = arg_source_text.find(")", sizeof_start_index);
+						  if (std::string::npos != sizeof_end_index) {
+							  assert(sizeof_end_index > sizeof_start_index);
+							  std::string before_str = arg_source_text.substr(0, sizeof_start_index);
+							  std::string after_str;
+							  if (sizeof_end_index + 1 < arg_source_text.size()) {
+								  after_str = arg_source_text.substr(sizeof_end_index + 1);
+							  }
+
+							  bool asterisk_found = false;
+							  auto index = before_str.size() - 1;
+							  while (0 <= index) {
+								  if ('*' == before_str[index]) {
+									  asterisk_found = true;
+								  }
+								  if (!std::isspace(before_str[index])) {
+									  break;
+								  }
+
+								  index -= 1;
+							  }
+							  if (asterisk_found) {
+								  before_str = before_str.substr(0, index);
+							  } else {
+								  size_t index2 = 0;
+								  while (after_str.size() > index2) {
+									  if ('*' == after_str[index2]) {
+										  asterisk_found = true;
+									  }
+									  if (!std::isspace(after_str[index2])) {
+										  break;
+									  }
+
+									  index2 += 1;
+								  }
+								  if (asterisk_found) {
+									  after_str = after_str.substr(index2 + 1);
+								  }
+							  }
+							  if (asterisk_found) {
+								  /* The argument is in the form "something * sizeof(something_else)" or
+								   * "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 declaration_replacement_code;
+				            	  std::string variable_name;
+				            	  std::string bo_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 = DD->getSourceRange();
+									  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();
+									  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 decls = IndividualDeclaratorDecls(DD, Rewrite);
+							          if ((1 <= decls.size()) && (decls.back() == DD)) {
+							        	  for (const auto& decl : decls) {
+									          declaration_replacement_code += IPointerFromPointerDecl(decl, Rewrite);
+							        		  declaration_replacement_code += "; \n";
+							        	  }
+							        	  if (declaration_replacement_code.size() >= 3) {
+							        		  declaration_replacement_code = declaration_replacement_code.substr(0, declaration_replacement_code.size() - 3);
+							        	  }
+							          } else {
+							        	  int q = 7;
+							          }
+
+									  const clang::Type* TP = QT.getTypePtr();
+
+					        		  if (TP->isArrayType()) {
+					        	    	  auto ATP = static_cast<const clang::ArrayType*>(TP);
+					        	    	  assert(nullptr != ATP);
+					        	    	  auto element_type = ATP->getElementType();
+					        	    	  auto elementSplitQualType = element_type.split();
+					        	    	  element_type_str = clang::QualType::getAsString(elementSplitQualType);
+					        		  } else if (TP->isPointerType()) {
+					        			  auto TPP = static_cast<const clang::PointerType*>(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)) {
+					        				  element_type_str = type_str;
+					        			  }
+					        		  }
+					        		  if ("" != element_type_str) {
+						            	  auto lhs = BO->getLHS();
+						            	  auto lhs_source_range = lhs->getSourceRange();
+						            	  auto lhs_source_text = Rewrite.getRewrittenText(lhs_source_range);
+						            	  bo_replacement_code += lhs_source_text;
+						            	  bo_replacement_code += ".resize(";
+						            	  bo_replacement_code += num_elements_text;
+						            	  bo_replacement_code += ")";
+
+						                  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;
+						                  }
+
+						                  auto BOSR = clang::SourceRange(BOSL, BOSLE);
+							        	  if (ConvertToSCPP && decl_source_range.isValid() && (BOSR.isValid())) {
+							        		  if ((3 <= declaration_replacement_code.size())) {
+							        			  bool already_replaced_flag = false;
+							        			  size_t replacement_text_length = 0;
+								            	  for (const auto& decl : decls) {
+											          auto iter = m_state1.m_decl_replacement_action_records_log.find(decl);
+											          if (m_state1.m_decl_replacement_action_records_log.end() != iter) {
+											        	  /* This declaration had already been replaced. We'll need to "undo"
+											        	   * the replacement. */
+											        	  already_replaced_flag = true;
+											        	  auto replacement_text = (*iter).replacement_text();
+											        	  if ((*iter).replacement_text().size() > replacement_text_length) {
+											        		  replacement_text_length = (*iter).replacement_text().size();
+											        	  }
+											        	  m_state1.m_decl_replacement_action_records_log.erase(iter);
+											          }
+
+									            	  CDeclReplacementActionRecord action_record(Rewrite, *decl, declaration_replacement_code, "pointer targeting heap allocated array to mse vector iterator");
+									            	  m_state1.m_decl_replacement_action_records_log.push_back(action_record);
+									            	  m_state1.m_dynamic_array_contingent_replacement_map.do_and_dispose_matching_replacements(*decl);
+								            	  }
+								            	  auto adj_decl_source_range = decl_source_range;
+								            	  if (already_replaced_flag) {
+								            		  adj_decl_source_range = clang::SourceRange(decl_source_range.getBegin(), decl_source_range.getBegin().getLocWithOffset(replacement_text_length));
+								            	  }
+								            	  auto adj_decl_source_text = Rewrite.getRewrittenText(adj_decl_source_range);
+								            	  auto res = Rewrite.ReplaceText(decl_source_range, declaration_replacement_code);
+							        		  }
+							            	  auto res2 = Rewrite.ReplaceText(BOSR, bo_replacement_code);
+							            	  int q = 3;
+							              } else {
+							            	  int q = 7;
+							              }
+					        		  }
+					        	  }
+								  int q = 5;
+							  }
+						  }
+					  }
+				  } else {
+					  int q = 5;
+				  }
+				  int q = 5;
+			  }
+    	  }
+
+      }
+    }
+  }
+
+private:
+  Rewriter &Rewrite;
+  CState1& m_state1;
+};
+
+class MCSSSMallocInitializer : public MatchFinder::MatchCallback
+{
+public:
+	MCSSSMallocInitializer (Rewriter &Rewrite, CState1& state1)
+		: Rewrite(Rewrite), m_state1(state1) {}
+
+  virtual void run(const MatchFinder::MatchResult &MR)
+  {
+	const DeclStmt* DS = MR.Nodes.getNodeAs<clang::DeclStmt>("mcsssmallocinitializer1");
+	const CallExpr* CE = MR.Nodes.getNodeAs<clang::CallExpr>("mcsssmallocinitializer2");
+	const DeclaratorDecl* DD = MR.Nodes.getNodeAs<clang::DeclaratorDecl>("mcsssmallocinitializer3");
+
+	if ((DS != nullptr) && (CE != nullptr) && (DD != nullptr))
+    {
+        SourceLocation DSSL = DS->getLocStart();
+        SourceLocation DSSLMID;
+
+        if (DSSL.isMacroID())
+        {
+          DSSLMID = Devi::SourceLocationHasMacro(DSSL, Rewrite, "start");
+        }
+
+        DSSL = Devi::SourceLocationHasMacro(DSSL, Rewrite, "start");
+        SourceLocation DSSLE = DS->getLocEnd();
+        SourceLocation DSSLEMID;
+
+        if (DSSLE.isMacroID())
+        {
+          DSSLEMID = Devi::SourceLocationHasMacro(DSSLE, Rewrite, "end");
+        }
+
+        DSSLE = Devi::SourceLocationHasMacro(DSSLE, Rewrite, "end");
+
+        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 (Devi::IsTheMatchInSysHeader(CheckSystemHeader, MR, DSSL))
+      {
+        return void();
+      }
+
+      if (!Devi::IsTheMatchInMainFile(MainFileOnly, MR, DSSL))
+      {
+        return void();
+      }
+
+      auto function_decl = CE->getDirectCallee();
+      auto num_args = CE->getNumArgs();
+      if (function_decl && (1 == num_args)) {
+    	  {
+			  std::string function_name = function_decl->getNameAsString();
+			  static const std::string alloc_str = "alloc";
+			  static const std::string realloc_str = "realloc";
+			  auto lc_function_name = tolowerstr(function_name);
+			  bool ends_with_alloc = ((lc_function_name.size() >= alloc_str.size())
+					  && (0 == lc_function_name.compare(lc_function_name.size() - alloc_str.size(), alloc_str.size(), alloc_str)));
+			  bool ends_with_realloc = (ends_with_alloc && (lc_function_name.size() >= realloc_str.size())
+					  && (0 == lc_function_name.compare(lc_function_name.size() - realloc_str.size(), realloc_str.size(), realloc_str)));
+			  if (ends_with_realloc) {
+				  int q = 5;
+			  } else if (ends_with_alloc) {
+				  auto iter = CE->arg_begin();
+				  auto arg_source_range = (*iter)->getSourceRange();
+				  std::string arg_source_text;
+				  if (arg_source_range.isValid()) {
+					  arg_source_text = Rewrite.getRewrittenText(arg_source_range);
+					  //auto arg_source_text_sans_ws = with_whitespace_removed(arg_source_text);
+					  auto sizeof_start_index = arg_source_text.find("sizeof(");
+					  if (std::string::npos != sizeof_start_index) {
+						  auto sizeof_end_index = arg_source_text.find(")", sizeof_start_index);
+						  if (std::string::npos != sizeof_end_index) {
+							  assert(sizeof_end_index > sizeof_start_index);
+							  std::string before_str = arg_source_text.substr(0, sizeof_start_index);
+							  std::string after_str;
+							  if (sizeof_end_index + 1 < arg_source_text.size()) {
+								  after_str = arg_source_text.substr(sizeof_end_index + 1);
+							  }
+
+							  bool asterisk_found = false;
+							  auto index = before_str.size() - 1;
+							  while (0 <= index) {
+								  if ('*' == before_str[index]) {
+									  asterisk_found = true;
+								  }
+								  if (!std::isspace(before_str[index])) {
+									  break;
+								  }
+
+								  index -= 1;
+							  }
+							  if (asterisk_found) {
+								  before_str = before_str.substr(0, index);
+							  } else {
+								  size_t index2 = 0;
+								  while (after_str.size() > index2) {
+									  if ('*' == after_str[index2]) {
+										  asterisk_found = true;
+									  }
+									  if (!std::isspace(after_str[index2])) {
+										  break;
+									  }
+
+									  index2 += 1;
+								  }
+								  if (asterisk_found) {
+									  after_str = after_str.substr(index2 + 1);
+								  }
+							  }
+							  if (asterisk_found) {
+								  /* The argument is in the form "something * sizeof(something_else)" or
+								   * "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 declaration_replacement_code;
+				            	  std::string variable_name;
+
+					        	  if (nullptr != DD) {
+									  auto decl_source_range = DD->getSourceRange();
+									  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();
+									  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 decls = IndividualDeclaratorDecls(DD, Rewrite);
+							          if ((1 <= decls.size()) && (decls.back() == DD)) {
+							        	  for (const auto& decl : decls) {
+									          declaration_replacement_code += IPointerFromPointerDecl(decl, Rewrite, true/*discard_initializer*/);
+							        		  declaration_replacement_code += "(";
+							        		  declaration_replacement_code += num_elements_text;
+							        		  declaration_replacement_code += "); \n";
+							        	  }
+							        	  if (declaration_replacement_code.size() >= 3) {
+							        		  declaration_replacement_code = declaration_replacement_code.substr(0, declaration_replacement_code.size() - 3);
+							        	  }
+							          } else {
+							        	  int q = 7;
+							          }
+
+									  const clang::Type* TP = QT.getTypePtr();
+
+					        		  if (TP->isArrayType()) {
+					        	    	  auto ATP = static_cast<const clang::ArrayType*>(TP);
+					        	    	  assert(nullptr != ATP);
+					        	    	  auto element_type = ATP->getElementType();
+					        	    	  auto elementSplitQualType = element_type.split();
+					        	    	  element_type_str = clang::QualType::getAsString(elementSplitQualType);
+					        		  } else if (TP->isPointerType()) {
+					        			  auto TPP = static_cast<const clang::PointerType*>(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)) {
+					        				  element_type_str = type_str;
+					        			  }
+					        		  }
+					        		  if ("" != element_type_str) {
+						                  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;
+						                  }
+
+						                  auto DSSR = clang::SourceRange(DSSL, DSSLE);
+							        	  if (ConvertToSCPP && decl_source_range.isValid() && (DSSR.isValid())) {
+							        		  if ((3 <= declaration_replacement_code.size())) {
+							        			  bool already_replaced_flag = false;
+							        			  size_t replacement_text_length = 0;
+								            	  for (const auto& decl : decls) {
+											          auto iter = m_state1.m_decl_replacement_action_records_log.find(decl);
+											          if (m_state1.m_decl_replacement_action_records_log.end() != iter) {
+											        	  /* This declaration had already been replaced. We'll need to "undo"
+											        	   * the replacement. */
+											        	  already_replaced_flag = true;
+											        	  if ((*iter).replacement_text().size() > replacement_text_length) {
+											        		  replacement_text_length = (*iter).replacement_text().size();
+											        	  }
+											        	  m_state1.m_decl_replacement_action_records_log.erase(iter);
+											          }
+
+									            	  CDeclReplacementActionRecord action_record(Rewrite, *decl, declaration_replacement_code, "pointer targeting heap allocated array to mse vector iterator");
+									            	  m_state1.m_decl_replacement_action_records_log.push_back(action_record);
+									            	  m_state1.m_dynamic_array_contingent_replacement_map.do_and_dispose_matching_replacements(*decl);
+								            	  }
+								            	  auto adj_decl_source_range = decl_source_range;
+								            	  if (already_replaced_flag) {
+								            		  adj_decl_source_range = clang::SourceRange(decl_source_range.getBegin(), decl_source_range.getBegin().getLocWithOffset(replacement_text_length));
+								            	  }
+								            	  auto res = Rewrite.ReplaceText(decl_source_range, declaration_replacement_code);
+							        		  }
+							            	  int q = 3;
+							              } else {
+							            	  int q = 7;
+							              }
+					        		  }
+					        	  }
+								  int q = 5;
+							  }
+						  }
+					  }
+				  } else {
+					  int q = 5;
+				  }
+				  int q = 5;
+			  }
+    	  }
+
+      }
+    }
+  }
+
+private:
+  Rewriter &Rewrite;
+  CState1& m_state1;
+};
+
+class MCSSSFree : public MatchFinder::MatchCallback
+{
+public:
+	MCSSSFree (Rewriter &Rewrite, CState1& state1)
+		: Rewrite(Rewrite), m_state1(state1) {}
+
+  virtual void run(const MatchFinder::MatchResult &MR)
+  {
+	const CallExpr* CE = MR.Nodes.getNodeAs<clang::CallExpr>("mcsssfree1");
+	const DeclRefExpr* DRE = MR.Nodes.getNodeAs<clang::DeclRefExpr>("mcsssfree2");
+	const MemberExpr* ME = MR.Nodes.getNodeAs<clang::MemberExpr>("mcsssfree3");
+
+	if ((CE != nullptr) && (DRE != nullptr))
+    {
+        SourceLocation CESL = CE->getLocStart();
+        SourceLocation CESLMID;
+
+        if (CESL.isMacroID())
+        {
+          CESLMID = Devi::SourceLocationHasMacro(CESL, Rewrite, "start");
+        }
+
+        CESL = Devi::SourceLocationHasMacro(CESL, Rewrite, "start");
+        SourceLocation CESLE = CE->getLocEnd();
+        SourceLocation CESLEMID;
+
+        if (CESLE.isMacroID())
+        {
+          CESLEMID = Devi::SourceLocationHasMacro(CESLE, Rewrite, "end");
+        }
+
+        CESLE = Devi::SourceLocationHasMacro(CESLE, Rewrite, "end");
+
+        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 (Devi::IsTheMatchInSysHeader(CheckSystemHeader, MR, CESL))
+      {
+        return void();
+      }
+
+      if (!Devi::IsTheMatchInMainFile(MainFileOnly, MR, CESL))
+      {
+        return void();
+      }
+
+      auto function_decl = CE->getDirectCallee();
+      auto num_args = CE->getNumArgs();
+      if (function_decl && (1 == num_args)) {
+    	  {
+			  std::string function_name = function_decl->getNameAsString();
+			  static const std::string free_str = "free";
+			  auto lc_function_name = tolowerstr(function_name);
+			  bool ends_with_free = ((lc_function_name.size() >= free_str.size())
+					  && (0 == lc_function_name.compare(lc_function_name.size() - free_str.size(), free_str.size(), free_str)));
+			  if (ends_with_free) {
+				  auto iter = CE->arg_begin();
+				  assert((*iter)->getType().getTypePtrOrNull());
+				  auto arg_source_range = (*iter)->getSourceRange();
+				  std::string arg_source_text;
+				  if (arg_source_range.isValid()) {
+					  arg_source_text = Rewrite.getRewrittenText(arg_source_range);
+					  //auto arg_source_text_sans_ws = with_whitespace_removed(arg_source_text);
+					  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 = DD->getSourceRange();
+						  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();
+						  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 iter = m_state1.m_decl_replacement_action_records_log.find(DD/*decl_source_range.getBegin()*/);
+						  if (m_state1.m_decl_replacement_action_records_log.end() != iter) {
+							  if ("pointer targeting heap allocated array to mse vector iterator" == (*iter).action_species()) {
+								  ce_replacement_code = arg_source_text;
+								  ce_replacement_code += ".resize(0)";
+
+								  auto CESR = clang::SourceRange(CESL, CESLE);
+								  if (ConvertToSCPP && (CESR.isValid())) {
+									  auto res2 = Rewrite.ReplaceText(CESR, ce_replacement_code);
+									  int q = 3;
+								  } else {
+									  int q = 7;
+								  }
+							  }
+						  } else {
+							  auto cr_shptr = std::make_shared<CFreeDynamicArrayReplacementAction>(Rewrite, MR, *DD, CE, DRE, ME);
+							  m_state1.m_dynamic_array_contingent_replacement_map.insert(cr_shptr);
+						  }
+					  }
+					  int q = 5;
+				  } else {
+					  int q = 5;
+				  }
+				  int q = 5;
+			  }
+    	  }
+
+      }
+    }
+  }
+
+private:
+  Rewriter &Rewrite;
+  CState1& m_state1;
+};
+
+class MCSSSSetToNull : public MatchFinder::MatchCallback
+{
+public:
+	MCSSSSetToNull (Rewriter &Rewrite, CState1& state1)
+		: Rewrite(Rewrite), m_state1(state1) {}
+
+  virtual void run(const MatchFinder::MatchResult &MR)
+  {
+	const BinaryOperator* BO = MR.Nodes.getNodeAs<clang::BinaryOperator>("mcssssettonull1");
+	const Expr* RHS = nullptr;
+	const Expr* LHS = nullptr;
+	if (BO != nullptr) {
+		RHS = BO->getRHS();
+		LHS = BO->getLHS();
+	}
+	const DeclRefExpr* DRE = MR.Nodes.getNodeAs<clang::DeclRefExpr>("mcssssettonull3");
+	const MemberExpr* ME = MR.Nodes.getNodeAs<clang::MemberExpr>("mcssssettonull4");
+
+	if ((BO != nullptr) && (RHS != nullptr) && (LHS != nullptr) && (DRE != nullptr))
+    {
+        SourceLocation BOSL = BO->getLocStart();
+        SourceLocation BOSLMID;
+
+        if (BOSL.isMacroID())
+        {
+          BOSLMID = Devi::SourceLocationHasMacro(BOSL, Rewrite, "start");
+        }
+
+        BOSL = Devi::SourceLocationHasMacro(BOSL, Rewrite, "start");
+        SourceLocation BOSLE = BO->getLocEnd();
+        SourceLocation BOSLEMID;
+
+        if (BOSLE.isMacroID())
+        {
+          BOSLEMID = Devi::SourceLocationHasMacro(BOSLE, Rewrite, "end");
+        }
+
+        BOSLE = Devi::SourceLocationHasMacro(BOSLE, Rewrite, "end");
+
+        ASTContext *const ASTC = MR.Context;
+        FullSourceLoc FBOSL = ASTC->getFullLoc(BOSL);
+
+        SourceManager &SM = ASTC->getSourceManager();
+
+        auto source_location_str = BOSL.printToString(*MR.SourceManager);
+        std::string source_text;
+        if (BOSL.isValid() && BOSLE.isValid()) {
+      	  source_text = Rewrite.getRewrittenText(SourceRange(BOSL, BOSLE));
+        } else {
+      	  return;
+        }
+
+      if (Devi::IsTheMatchInSysHeader(CheckSystemHeader, MR, BOSL))
+      {
+        return void();
+      }
+
+      if (!Devi::IsTheMatchInMainFile(MainFileOnly, MR, BOSL))
+      {
+        return void();
+      }
+
+      Expr::NullPointerConstantKind kind = RHS->isNullPointerConstant(*ASTC, Expr::NullPointerConstantValueDependence());
+      if (clang::Expr::NPCK_NotNull != kind) {
+		  auto lhs_source_range = LHS->getSourceRange();
+		  std::string lhs_source_text;
+		  if (lhs_source_range.isValid()) {
+			  lhs_source_text = Rewrite.getRewrittenText(lhs_source_range);
+			  //auto lhs_source_text_sans_ws = with_whitespace_removed(lhs_source_text);
+
+			  QualType QT;
+			  std::string element_type_str;
+			  clang::SourceRange decl_source_range;
+			  std::string variable_name;
+			  std::string bo_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 = DD->getSourceRange();
+				  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();
+				  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;
+				  }
+
+				  if ((DD->getType() == LHS->getType())) {
+					  auto iter = m_state1.m_decl_replacement_action_records_log.find(DD/*decl_source_range.getBegin()*/);
+					  if ((m_state1.m_decl_replacement_action_records_log.end() != iter)
+							  && ("pointer targeting heap allocated array to mse vector iterator" == (*iter).action_species())
+							  && ((*iter).get_ddecl_cptr()->getType() == LHS->getType())) {
+						  if (true) {
+							  bo_replacement_code = lhs_source_text;
+							  bo_replacement_code += ".resize(0)";
+
+							  auto BOSR = clang::SourceRange(BOSL, BOSLE);
+							  if (ConvertToSCPP && (BOSR.isValid())) {
+								  auto res2 = Rewrite.ReplaceText(BOSR, bo_replacement_code);
+								  int q = 3;
+							  } else {
+								  int q = 7;
+							  }
+						  } else {
+							  int q = 5;
+						  }
+					  } else {
+						  auto cr_shptr = std::make_shared<CSetArrayPointerToNullReplacementAction>(Rewrite, MR, *DD, BO, DRE, ME);
+						  m_state1.m_dynamic_array_contingent_replacement_map.insert(cr_shptr);
+					  }
+				  }
+			  }
+			  int q = 5;
+		  } else {
+			  int q = 5;
+		  }
+		  int q = 5;
+      }
+    }
+  }
+
+private:
+  Rewriter &Rewrite;
+  CState1& m_state1;
+};
+
+
 /**********************************************************************************************************************/
 class MyASTConsumer : public ASTConsumer {
 
 public:
-  MyASTConsumer(Rewriter &R) 
+  MyASTConsumer(Rewriter &R) : HandlerForSSSNativePointer(R), HandlerForSSSArrayToPointerDecay(R, m_state1), \
+	HandlerForSSSVarDecl(R, m_state1), HandlerForSSSPointerArithmetic(R, m_state1), \
+	HandlerForSSSMalloc(R, m_state1), HandlerForSSSMallocInitializer(R, m_state1), \
+	HandlerForSSSFree(R, m_state1), HandlerForSSSSetToNull(R, m_state1)
   {
+	  Matcher.addMatcher(varDecl(hasType(pointerType())).bind("mcsssnativepointer"), &HandlerForSSSNativePointer);
+
+	  Matcher.addMatcher(castExpr(allOf(hasCastKind(CK_ArrayToPointerDecay), unless(hasParent(arraySubscriptExpr())))).bind("mcsssarraytopointerdecay"), &HandlerForSSSArrayToPointerDecay);
+
+	  Matcher.addMatcher(varDecl().bind("mcsssvardecl"), &HandlerForSSSVarDecl);
+
+	  Matcher.addMatcher(declRefExpr(allOf(hasParent(expr(anyOf( \
+	  		unaryOperator(hasOperatorName("++")), unaryOperator(hasOperatorName("--")), \
+				binaryOperator(hasOperatorName("+=")), binaryOperator(hasOperatorName("-=")), \
+				hasParent(expr(anyOf( \
+						binaryOperator(hasOperatorName("+")), binaryOperator(hasOperatorName("+=")), \
+						binaryOperator(hasOperatorName("-")), binaryOperator(hasOperatorName("-=")), \
+						binaryOperator(hasOperatorName("<=")), binaryOperator(hasOperatorName("<")), \
+						binaryOperator(hasOperatorName(">=")), binaryOperator(hasOperatorName(">")), \
+						arraySubscriptExpr(), clang::ast_matchers::castExpr(hasParent(arraySubscriptExpr())) \
+				)))))), to(declaratorDecl(hasType(pointerType()))))).bind("mcssspointerarithmetic"), &HandlerForSSSPointerArithmetic);
+
+	  Matcher.addMatcher(memberExpr(allOf(hasDescendant(declRefExpr().bind("mcssspointerarithmetic")), hasParent(expr(anyOf( \
+	  		unaryOperator(hasOperatorName("++")), unaryOperator(hasOperatorName("--")), \
+				binaryOperator(hasOperatorName("+=")), binaryOperator(hasOperatorName("-=")), \
+				hasParent(expr(anyOf( \
+						binaryOperator(hasOperatorName("+")), binaryOperator(hasOperatorName("+=")), \
+						binaryOperator(hasOperatorName("-")), binaryOperator(hasOperatorName("-=")), \
+						binaryOperator(hasOperatorName("<=")), binaryOperator(hasOperatorName("<")), \
+						binaryOperator(hasOperatorName(">=")), binaryOperator(hasOperatorName(">")), \
+						arraySubscriptExpr(), clang::ast_matchers::castExpr(hasParent(arraySubscriptExpr())) \
+				)))))), member(hasType(pointerType())))).bind("mcssspointerarithmetic2"), &HandlerForSSSPointerArithmetic);
+
+	  Matcher.addMatcher(binaryOperator(allOf(
+	  		hasOperatorName("="),
+	  		hasRHS(
+	  				anyOf(
+	  						cStyleCastExpr(has(callExpr().bind("mcsssmalloc2"))),
+								callExpr().bind("mcsssmalloc2")
+	  				)
+				),
+	  		hasLHS(anyOf(
+	  				memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc4"),
+	  				hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc4")),
+						hasDescendant(declRefExpr().bind("mcsssmalloc3")),
+						declRefExpr().bind("mcsssmalloc3")
+				)),
+	  		hasLHS(expr(hasType(pointerType())))
+				)).bind("mcsssmalloc1"), &HandlerForSSSMalloc);
+
+	  Matcher.addMatcher(declStmt(hasDescendant(
+	  		varDecl(hasInitializer(ignoringImpCasts(
+					anyOf(
+							cStyleCastExpr(has(callExpr().bind("mcsssmallocinitializer2"))),
+							callExpr().bind("mcsssmallocinitializer2")
+					)
+	  		))).bind("mcsssmallocinitializer3")
+				)).bind("mcsssmallocinitializer1"), &HandlerForSSSMallocInitializer);
+
+	  Matcher.addMatcher(
+	  		callExpr(allOf(
+	  				hasAnyArgument(
+	  				expr(anyOf(
+								memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssfree2")))).bind("mcsssfree3"),
+								hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssfree2")))).bind("mcsssfree3")),
+								hasDescendant(declRefExpr().bind("mcsssfree2"))
+						))),
+						argumentCountIs(1),
+						hasAnyArgument(hasType(pointerType()))
+	  		)).bind("mcsssfree1"), &HandlerForSSSFree);
+
+	  Matcher.addMatcher(binaryOperator(allOf(
+	  		hasOperatorName("="),
+	  		hasLHS(anyOf(
+	  				memberExpr(expr(hasDescendant(declRefExpr().bind("mcssssettonull3")))).bind("mcssssettonull4"),
+	  				hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcssssettonull3")))).bind("mcssssettonull4")),
+						hasDescendant(declRefExpr().bind("mcssssettonull3"))
+				)),
+				hasLHS(expr(hasType(pointerType())))
+				)).bind("mcssssettonull1"), &HandlerForSSSSetToNull);
   }
 
   void HandleTranslationUnit(ASTContext &Context) override 
@@ -66,8 +2172,21 @@ public:
   }
 
 private:
+
+  CState1 m_state1;
+
+  MCSSSNativePointer HandlerForSSSNativePointer;
+  MCSSSArrayToPointerDecay HandlerForSSSArrayToPointerDecay;
+  MCSSSVarDecl HandlerForSSSVarDecl;
+  MCSSSPointerArithmetic HandlerForSSSPointerArithmetic;
+  MCSSSMalloc HandlerForSSSMalloc;
+  MCSSSMallocInitializer HandlerForSSSMallocInitializer;
+  MCSSSFree HandlerForSSSFree;
+  MCSSSSetToNull HandlerForSSSSetToNull;
+
   MatchFinder Matcher;
 };
+
 /**********************************************************************************************************************/
 class MyFrontendAction : public ASTFrontendAction 
 {