aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--safercpp/safercpp-arr.cpp475
1 files changed, 419 insertions, 56 deletions
diff --git a/safercpp/safercpp-arr.cpp b/safercpp/safercpp-arr.cpp
index 98e72e2..970d130 100644
--- a/safercpp/safercpp-arr.cpp
+++ b/safercpp/safercpp-arr.cpp
@@ -336,6 +336,24 @@ public:
virtual ~CDynamicArray2ReplacementAction() {}
};
+class CMemsetArray2ReplacementAction : public CDynamicArray2ReplacementAction {
+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) {
+ }
+ virtual ~CMemsetArray2ReplacementAction() {}
+
+ 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,
@@ -580,6 +598,11 @@ const clang::Expr* populateStmtIndirectionStack(std::vector<std::string>& stack,
} else {
assert(false);
}
+ } else {
+ if (0 == depth) {
+ int q = 5;
+ }
+ int q = 5;
}
if (process_child_flag) {
auto child_iter = ST->child_begin();
@@ -660,6 +683,16 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con
direct_qtype_str = "const bool";
}
+ std::string variable_name = DD->getNameAsString();
+ std::string identifier_name_str;
+ auto pIdentifier = DD->getIdentifier();
+ if (pIdentifier) {
+ identifier_name_str = pIdentifier->getName();
+ }
+ if ("" == variable_name) {
+ int q = 7;
+ }
+
clang::StorageDuration storage_duration = clang::StorageDuration::SD_Automatic;
bool has_dynamic_storage_duration = false;
bool is_a_temporary = false;
@@ -680,11 +713,28 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con
if (ddcs_ref.m_original_initialization_has_been_noted) {
initialization_expr_str = ddcs_ref.m_original_initialization_expr_str;
+ if ("" != ddcs_ref.m_original_initialization_expr_str) {
+ int q = 5;
+ }
} else {
- auto pInitExpr = VD->getInit();
- if (VD->hasInit() && pInitExpr) {
- auto init_expr_source_range = nice_source_range(pInitExpr->getSourceRange(), Rewrite);
- initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range);
+ if (VD->hasInit()) {
+ auto pInitExpr = VD->getInit();
+ if (pInitExpr) {
+ auto init_expr_source_range = nice_source_range(pInitExpr->getSourceRange(), Rewrite);
+ if (init_expr_source_range.isValid()) {
+ initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range);
+ if (variable_name == initialization_expr_str) {
+ /* We encountered a weird bug where the initialization expression sometimes
+ * was indicated as being present and the source range set to the variable name
+ * when actually no initialization expression was present in the original source. */
+ initialization_expr_str = "";
+ }
+ } else {
+ int q = 3;
+ }
+ } else {
+ int q = 3;
+ }
ddcs_ref.m_original_initialization_expr_str = initialization_expr_str;
}
ddcs_ref.m_original_initialization_has_been_noted = true;
@@ -696,11 +746,28 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con
if (ddcs_ref.m_original_initialization_has_been_noted) {
initialization_expr_str = ddcs_ref.m_original_initialization_expr_str;
+ if ("" != ddcs_ref.m_original_initialization_expr_str) {
+ int q = 5;
+ }
} else {
- auto pInitExpr = FD->getInClassInitializer();
- if (FD->hasInClassInitializer() && pInitExpr) {
- auto init_expr_source_range = nice_source_range(pInitExpr->getSourceRange(), Rewrite);
- initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range);
+ if (FD->hasInClassInitializer()) {
+ auto pInitExpr = FD->getInClassInitializer();
+ if (pInitExpr) {
+ auto init_expr_source_range = nice_source_range(pInitExpr->getSourceRange(), Rewrite);
+ if (init_expr_source_range.isValid()) {
+ initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range);
+ if (variable_name == initialization_expr_str) {
+ /* We encountered a weird bug where the initialization expression sometimes
+ * was indicated as being present and the source range set to the variable name
+ * when actually no initialization expression was present in the original source. */
+ initialization_expr_str = "";
+ }
+ } else {
+ int q = 3;
+ }
+ } else {
+ int q = 3;
+ }
ddcs_ref.m_original_initialization_expr_str = initialization_expr_str;
}
ddcs_ref.m_original_initialization_has_been_noted = true;
@@ -709,16 +776,6 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con
}
ddcs_ref.m_original_initialization_has_been_noted = true;
- std::string variable_name = DD->getNameAsString();
- std::string identifier_name_str;
- auto pIdentifier = DD->getIdentifier();
- if (pIdentifier) {
- identifier_name_str = pIdentifier->getName();
- }
- if ("" == variable_name) {
- int q = 7;
- }
-
std::string replacement_code;
std::string prefix_str;
std::string suffix_str;
@@ -932,7 +989,40 @@ static void update_declaration(const DeclaratorDecl& ddecl, Rewriter &Rewrite, C
}
}
-void CSetArrayPointerToNull2ReplacementAction::do_replacement(CState1& state1) const {
+void CFreeDynamicArray2ReplacementAction::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);
+
+ //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;
+ }
+ }
+}
+
+void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const {
Rewriter &Rewrite = m_Rewrite;
const MatchFinder::MatchResult &MR = m_MR;
const BinaryOperator* BO = m_BO;
@@ -965,15 +1055,14 @@ void CSetArrayPointerToNull2ReplacementAction::do_replacement(CState1& state1) c
}
}
-void CFreeDynamicArray2ReplacementAction::do_replacement(CState1& state1) const {
+void CMallocInitializerArray2ReplacementAction::do_replacement(CState1& state1) const {
Rewriter &Rewrite = m_Rewrite;
const MatchFinder::MatchResult &MR = m_MR;
- const CallExpr* CE = m_CE;
+ const DeclStmt* DS = m_DS;
const DeclaratorDecl* DD = m_DD;
- if ((CE != nullptr) && (DD != nullptr))
+ if ((DS != 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;
@@ -983,14 +1072,18 @@ void CFreeDynamicArray2ReplacementAction::do_replacement(CState1& state1) const
return;
}
- if (ConvertToSCPP && decl_source_range.isValid() && (CESR.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(CESR, m_ce_replacement_code);
int q = 3;
} else {
int q = 7;
@@ -998,7 +1091,7 @@ void CFreeDynamicArray2ReplacementAction::do_replacement(CState1& state1) const
}
}
-void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const {
+void CSetArrayPointerToNull2ReplacementAction::do_replacement(CState1& state1) const {
Rewriter &Rewrite = m_Rewrite;
const MatchFinder::MatchResult &MR = m_MR;
const BinaryOperator* BO = m_BO;
@@ -1020,9 +1113,6 @@ void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const {
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 {
@@ -1031,14 +1121,15 @@ void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const {
}
}
-void CMallocInitializerArray2ReplacementAction::do_replacement(CState1& state1) const {
+void CMemsetArray2ReplacementAction::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;
@@ -1048,18 +1139,11 @@ 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;
@@ -1394,7 +1478,7 @@ public:
}
int q = 5;
} else {
- int q = 5;
+ return;
}
if (update_declaration_flag) {
@@ -1414,8 +1498,8 @@ private:
class MCSSSMalloc2 : public MatchFinder::MatchCallback
{
public:
- MCSSSMalloc2 (Rewriter &Rewrite, CState1& state1)
-: Rewrite(Rewrite), m_state1(state1) {}
+ MCSSSMalloc2 (Rewriter &Rewrite, CState1& state1) :
+ Rewrite(Rewrite), m_state1(state1) {}
virtual void run(const MatchFinder::MatchResult &MR)
{
@@ -1645,6 +1729,11 @@ public:
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]))));
@@ -1656,7 +1745,7 @@ public:
}
int q = 5;
} else {
- int q = 5;
+ return;
}
if (update_declaration_flag) {
@@ -1886,6 +1975,8 @@ public:
lhs_has_been_determined_to_be_an_array = true;
//update_declaration_flag = true;
m_state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, 0));
+ } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[0].m_current) {
+ lhs_has_been_determined_to_be_an_array = true;
} else {
assert("native array" != ddcs_ref.m_indirection_state_stack[0].m_current);
}
@@ -1963,8 +2054,8 @@ private:
class MCSSSFree2 : public MatchFinder::MatchCallback
{
public:
- MCSSSFree2 (Rewriter &Rewrite, CState1& state1)
-: Rewrite(Rewrite), m_state1(state1) {}
+ MCSSSFree2 (Rewriter &Rewrite, CState1& state1) :
+ Rewrite(Rewrite), m_state1(state1) {}
virtual void run(const MatchFinder::MatchResult &MR)
{
@@ -2075,10 +2166,10 @@ public:
}
std::vector<std::string> stmt_indirection_stack;
- const clang::Expr* expr2 = populateStmtIndirectionStack(stmt_indirection_stack, *CE);
+ 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 lhs_has_been_determined_to_be_an_array = false;
+ bool target_has_been_determined_to_be_an_array = false;
size_t indirection_level = 0;
if (expr2) {
std::string expr2_stmt_class_name;
@@ -2121,10 +2212,15 @@ public:
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;
+ 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]))));
@@ -2136,7 +2232,7 @@ public:
}
int q = 5;
} else {
- int q = 5;
+ return;
}
if (update_declaration_flag) {
@@ -2149,7 +2245,7 @@ public:
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);
- if (lhs_has_been_determined_to_be_an_array) {
+ if (target_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);
@@ -2178,8 +2274,8 @@ private:
class MCSSSSetToNull2 : public MatchFinder::MatchCallback
{
public:
- MCSSSSetToNull2 (Rewriter &Rewrite, CState1& state1)
-: Rewrite(Rewrite), m_state1(state1) {}
+ MCSSSSetToNull2 (Rewriter &Rewrite, CState1& state1) :
+ Rewrite(Rewrite), m_state1(state1) {}
virtual void run(const MatchFinder::MatchResult &MR)
{
@@ -2337,6 +2433,11 @@ public:
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]))));
@@ -2348,7 +2449,7 @@ public:
}
int q = 5;
} else {
- int q = 5;
+ return;
}
if (update_declaration_flag) {
@@ -2386,6 +2487,254 @@ private:
CState1& m_state1;
};
+class MCSSSMemset : public MatchFinder::MatchCallback
+{
+public:
+ MCSSSMemset (Rewriter &Rewrite, CState1& state1) :
+ Rewrite(Rewrite), m_state1(state1) {}
+
+ virtual void run(const MatchFinder::MatchResult &MR)
+ {
+ const CallExpr* CE = MR.Nodes.getNodeAs<clang::CallExpr>("mcsssmemset1");
+ const DeclRefExpr* DRE = MR.Nodes.getNodeAs<clang::DeclRefExpr>("mcsssmemset2");
+ const MemberExpr* ME = MR.Nodes.getNodeAs<clang::MemberExpr>("mcsssmemset3");
+
+ 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 memset_str = "memset";
+ if (memset_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();
+
+ 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 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("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); }
+ }
+ 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 {
+ int q = 5;
+ }
+ }
+ int q = 5;
+ } else {
+ return;
+ }
+
+ if (update_declaration_flag) {
+ update_declaration(*DD, Rewrite, m_state1);
+ }
+
+ 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;
+ }
+ } 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, indirection_level), CE, ce_replacement_code);
+
+ if (target_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;
+ }
+ }
+ }
+ int q = 5;
+ } else {
+ int q = 5;
+ }
+ int q = 5;
+ }
+ }
+
+ }
+ }
+ }
+
+private:
+ Rewriter &Rewrite;
+ CState1& m_state1;
+};
/**********************************************************************************************************************/
class MyASTConsumer : public ASTConsumer {
@@ -2393,7 +2742,8 @@ class MyASTConsumer : public ASTConsumer {
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)
+ HandlerForSSSMallocInitializer2(R, m_state1), HandlerForSSSFree2(R, m_state1), HandlerForSSSSetToNull2(R, m_state1),
+ HandlerForSSSMemset(R, m_state1)
{
Matcher.addMatcher(varDecl(hasType(pointerType())).bind("mcsssnativepointer"), &HandlerForSSSNativePointer);
@@ -2468,6 +2818,18 @@ public:
)),
hasLHS(expr(hasType(pointerType())))
)).bind("mcssssettonull1"), &HandlerForSSSSetToNull2);
+
+ Matcher.addMatcher(
+ callExpr(allOf(
+ hasAnyArgument(
+ expr(anyOf(
+ memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemset2")))).bind("mcsssmemset3"),
+ hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmemset2")))).bind("mcsssmemset3")),
+ hasDescendant(declRefExpr().bind("mcsssmemset2"))
+ ))),
+ argumentCountIs(3),
+ hasAnyArgument(hasType(pointerType()))
+ )).bind("mcsssmemset1"), &HandlerForSSSMemset);
}
void HandleTranslationUnit(ASTContext &Context) override
@@ -2487,6 +2849,7 @@ private:
MCSSSMallocInitializer2 HandlerForSSSMallocInitializer2;
MCSSSFree2 HandlerForSSSFree2;
MCSSSSetToNull2 HandlerForSSSSetToNull2;
+ MCSSSMemset HandlerForSSSMemset;
MatchFinder Matcher;
};