diff options
Diffstat (limited to 'safercpp')
| -rw-r--r-- | safercpp/safercpp-arr.cpp | 3242 |
1 files changed, 1808 insertions, 1434 deletions
diff --git a/safercpp/safercpp-arr.cpp b/safercpp/safercpp-arr.cpp index 0b0b6a3..b2b81dd 100644 --- a/safercpp/safercpp-arr.cpp +++ b/safercpp/safercpp-arr.cpp @@ -64,14 +64,14 @@ cl::opt<bool> ConvertToSCPP("ConvertToSCPP", cl::desc("safercpp will translate t /**********************************************************************************************************************/ SourceRange nice_source_range(const SourceRange& sr, Rewriter &Rewrite) { - SourceLocation SL = sr.getBegin(); - SourceLocation SLE = sr.getEnd(); - if (SL.isMacroID() || SLE.isMacroID()) { - int q = 5; - } - SL = Devi::SourceLocationHasMacro(SL, Rewrite, "start"); - SLE = Devi::SourceLocationHasMacro(SLE, Rewrite, "end"); - return SourceRange(SL, SLE); + SourceLocation SL = sr.getBegin(); + SourceLocation SLE = sr.getEnd(); + if (SL.isMacroID() || SLE.isMacroID()) { + int q = 5; + } + SL = Devi::SourceLocationHasMacro(SL, Rewrite, "start"); + SLE = Devi::SourceLocationHasMacro(SLE, Rewrite, "end"); + return SourceRange(SL, SLE); } bool filtered_out_by_location(const ast_matchers::MatchFinder::MatchResult &MR, SourceLocation SL) { @@ -195,11 +195,13 @@ static std::vector<std::string> f_declared_object_strings(const std::string& dec return retval; } +class CState1; + 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) { +: m_Rewrite_ptr(&Rewrite), m_ddecl_cptr(&ddecl), m_replacement_text(replacement_text), m_action_species(action_species) { } virtual ~CDeclReplacementActionRecord() {} clang::SourceRange source_range() { @@ -253,7 +255,7 @@ public: class CReplacementAction { public: virtual ~CReplacementAction() {} - virtual void do_replacement() const = 0; + virtual void do_replacement(CState1& state1) const = 0; }; class CDDeclReplacementAction : public CReplacementAction { @@ -263,7 +265,7 @@ public: } virtual ~CDDeclReplacementAction() {} - virtual void do_replacement() const = 0; + virtual void do_replacement(CState1& state1) const = 0; virtual const clang::DeclaratorDecl* get_ddecl_cptr() const { return m_ddecl_cptr; } clang::SourceRange source_range() { @@ -284,9 +286,15 @@ public: const clang::DeclaratorDecl* m_ddecl_cptr = nullptr; }; -class CDynamicArrayReplacementAction : public CDDeclReplacementAction { +class CArrayReplacementAction : public CDDeclReplacementAction { public: using CDDeclReplacementAction::CDDeclReplacementAction; + virtual ~CArrayReplacementAction() {} +}; + +class CDynamicArrayReplacementAction : public CArrayReplacementAction { +public: + using CArrayReplacementAction::CArrayReplacementAction; virtual ~CDynamicArrayReplacementAction() {} }; @@ -294,11 +302,11 @@ class CSetArrayPointerToNullReplacementAction : public CDynamicArrayReplacementA 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) { +: CDynamicArrayReplacementAction(Rewrite, MR, ddecl), m_BO(BO), m_DRE(DRE), m_ME(ME) { } virtual ~CSetArrayPointerToNullReplacementAction() {} - virtual void do_replacement() const { + virtual void do_replacement(CState1& state1) const { Rewriter &Rewrite = m_Rewrite; const MatchFinder::MatchResult &MR = m_MR; const BinaryOperator* BO = m_BO; @@ -312,108 +320,108 @@ public: const MemberExpr* ME = m_ME; if ((BO != nullptr) && (RHS != nullptr) && (LHS != nullptr) && (DRE != nullptr)) - { - auto BOSR = nice_source_range(BO->getSourceRange(), Rewrite); - SourceLocation BOSL = BOSR.getBegin(); - SourceLocation BOSLE = BOSR.getEnd(); - - 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 (filtered_out_by_location(MR, BOSL)) { - return void(); - } - - Expr::NullPointerConstantKind kind = RHS->isNullPointerConstant(*ASTC, Expr::NullPointerConstantValueDependence()); - if (clang::Expr::NPCK_NotNull != kind) { - auto lhs_source_range = nice_source_range(LHS->getSourceRange(), Rewrite); - 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 = nice_source_range(FD->getSourceRange(), Rewrite); - 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; - auto decl_source_range = nice_source_range(VD->getSourceRange(), Rewrite); - - 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; - } - } + { + auto BOSR = nice_source_range(BO->getSourceRange(), Rewrite); + SourceLocation BOSL = BOSR.getBegin(); + SourceLocation BOSLE = BOSR.getEnd(); + + 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 (filtered_out_by_location(MR, BOSL)) { + return void(); + } + + Expr::NullPointerConstantKind kind = RHS->isNullPointerConstant(*ASTC, Expr::NullPointerConstantValueDependence()); + if (clang::Expr::NPCK_NotNull != kind) { + auto lhs_source_range = nice_source_range(LHS->getSourceRange(), Rewrite); + 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 = nice_source_range(FD->getSourceRange(), Rewrite); + 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; + auto decl_source_range = nice_source_range(VD->getSourceRange(), Rewrite); + + 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; @@ -433,11 +441,11 @@ 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) { +: CDynamicArrayReplacementAction(Rewrite, MR, ddecl), m_CE(CE), m_DRE(DRE), m_ME(ME) { } virtual ~CFreeDynamicArrayReplacementAction() {} - virtual void do_replacement() const { + virtual void do_replacement(CState1& state1) const { Rewriter &Rewrite = m_Rewrite; const MatchFinder::MatchResult &MR = m_MR; const CallExpr* CE = m_CE; @@ -445,112 +453,112 @@ public: const MemberExpr* ME = m_ME; 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 && (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 = nice_source_range((*iter)->getSourceRange(), Rewrite); - 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 = 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(); - 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; - } - } - - } - } + { + 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 && (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 = nice_source_range((*iter)->getSourceRange(), Rewrite); + 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 = 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(); + 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; @@ -558,10 +566,63 @@ public: const MemberExpr* m_ME; }; -class CDynamicArrayReplacementActionMap : public std::multimap<const clang::DeclaratorDecl*, std::shared_ptr<CDynamicArrayReplacementAction>> { +static std::vector<const DeclaratorDecl*> IndividualDeclaratorDecls(const DeclaratorDecl* VD, Rewriter &Rewrite) { + std::vector<const DeclaratorDecl*> retval; + + if (!VD) { + assert(false); + return retval; + } + auto SR = nice_source_range(VD->getSourceRange(), Rewrite); + SourceLocation SL = SR.getBegin(); + + 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) { + auto VDSR = nice_source_range(var_decl->getSourceRange(), Rewrite); + SourceLocation l_SL = VDSR.getBegin(); + if (l_SL == SL) { + retval.push_back(var_decl); + } + } + } + } + if (0 == retval.size()) { + assert(false); + } + + return retval; +} + +class CMallocArrayReplacementAction : public CArrayReplacementAction { +public: + CMallocArrayReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const clang::DeclaratorDecl& ddecl, + const BinaryOperator* BO, const std::string& bo_replacement_code, const std::string& declaration_replacement_code) +: CArrayReplacementAction(Rewrite, MR, ddecl), m_BO(BO), m_DD(&ddecl), m_bo_replacement_code(bo_replacement_code), m_declaration_replacement_code(declaration_replacement_code) { + } + virtual ~CMallocArrayReplacementAction() {} + + virtual void do_replacement(CState1& state1) const; + + const BinaryOperator* m_BO = nullptr; + const CallExpr* m_CE = nullptr; + const DeclRefExpr* m_DRE = nullptr; + const MemberExpr* m_ME = nullptr; + const DeclaratorDecl* m_DD = nullptr; + std::string m_bo_replacement_code; + std::string m_declaration_replacement_code; +}; + +class CDDeclReplacementActionMap : public std::multimap<const clang::DeclaratorDecl*, std::shared_ptr<CDDeclReplacementAction>> { public: - typedef std::multimap<const clang::DeclaratorDecl*, std::shared_ptr<CDynamicArrayReplacementAction>> base_class; - iterator insert( const std::shared_ptr<CDynamicArrayReplacementAction>& cr_shptr ) { + typedef std::multimap<const clang::DeclaratorDecl*, std::shared_ptr<CDDeclReplacementAction>> base_class; + iterator insert( const std::shared_ptr<CDDeclReplacementAction>& cr_shptr ) { iterator retval(end()); if (!cr_shptr) { assert(false); } else { value_type val((*cr_shptr).get_ddecl_cptr(), cr_shptr); @@ -569,12 +630,12 @@ public: } return retval; } - void do_and_dispose_matching_replacements(const clang::DeclaratorDecl& ddecl) { + void do_and_dispose_matching_replacements(CState1& state1, 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(); + (*((*iter).second)).do_replacement(state1); } base_class::erase(range.first, range.second); range = base_class::equal_range(DD); @@ -582,62 +643,121 @@ public: } }; +class CDynamicArrayReplacementActionMap : public CDDeclReplacementActionMap { +public: + iterator insert( const std::shared_ptr<CDynamicArrayReplacementAction>& cr_shptr ) { + return CDDeclReplacementActionMap::insert(static_cast<std::shared_ptr<CDDeclReplacementAction> >(cr_shptr)); + } +}; + +class CArrayReplacementActionMap : public CDDeclReplacementActionMap { +public: + iterator insert( const std::shared_ptr<CArrayReplacementAction>& cr_shptr ) { + return CDDeclReplacementActionMap::insert(static_cast<std::shared_ptr<CDDeclReplacementAction> >(cr_shptr)); + } +}; + class CState1 { public: CDeclReplacementActionRecordsLog m_decl_replacement_action_records_log; CDynamicArrayReplacementActionMap m_dynamic_array_contingent_replacement_map; + CArrayReplacementActionMap m_array_contingent_replacement_map; }; +void CMallocArrayReplacementAction::do_replacement(CState1& state1) const { + Rewriter &Rewrite = m_Rewrite; + const MatchFinder::MatchResult &MR = m_MR; + const BinaryOperator* BO = m_BO; + const DeclaratorDecl* DD = m_DD; + + if ((BO != nullptr) && (DD != nullptr)) + { + auto BOSR = nice_source_range(BO->getSourceRange(), Rewrite); + auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite); + auto decl_source_location_str = decl_source_range.getBegin().printToString(*MR.SourceManager); + std::string decl_source_text; + if (decl_source_range.isValid()) { + decl_source_text = Rewrite.getRewrittenText(decl_source_range); + } else { + return; + } + + auto decls = IndividualDeclaratorDecls(DD, Rewrite); + + if (ConvertToSCPP && decl_source_range.isValid() && (BOSR.isValid())) { + if ((3 <= m_declaration_replacement_code.size())) { + for (const auto& decl : decls) { + auto iter = state1.m_decl_replacement_action_records_log.find(decl); + if (state1.m_decl_replacement_action_records_log.end() != iter) { + /* This declaration had already been replaced. We're just going to + * overwrite it. */ + state1.m_decl_replacement_action_records_log.erase(iter); + } + + CDeclReplacementActionRecord action_record(Rewrite, *decl, m_declaration_replacement_code, "pointer targeting heap allocated array to mse vector iterator"); + state1.m_decl_replacement_action_records_log.push_back(action_record); + state1.m_dynamic_array_contingent_replacement_map.do_and_dispose_matching_replacements(state1, *decl); + } + auto res = Rewrite.ReplaceText(decl_source_range, m_declaration_replacement_code); + } + auto res2 = Rewrite.ReplaceText(BOSR, m_bo_replacement_code); + int q = 3; + } else { + int q = 7; + } + } +} + /**********************************************************************************************************************/ class MCSSSArrayToPointerDecay : public MatchFinder::MatchCallback { public: MCSSSArrayToPointerDecay (Rewriter &Rewrite, CState1& state1) - : Rewrite(Rewrite), m_state1(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"); - - auto SR = nice_source_range(CE->getSourceRange(), Rewrite); - SourceLocation SL = SR.getBegin(); - SourceLocation SLE = SR.getEnd(); - - 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 (filtered_out_by_location(MR, SL)) - { - /*intentionally left blank*/ - } - else - { - { - if (false) { - 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: "); + 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"); + + auto SR = nice_source_range(CE->getSourceRange(), Rewrite); + SourceLocation SL = SR.getBegin(); + SourceLocation SLE = SR.getEnd(); + + 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 (filtered_out_by_location(MR, SL)) + { + /*intentionally left blank*/ + } + else + { + { + if (false) { + 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; + Rewriter &Rewrite; + CState1& m_state1; }; /**********************************************************************************************************************/ class MCSSSNativePointer : public MatchFinder::MatchCallback @@ -645,197 +765,197 @@ 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"); - - auto SR = nice_source_range(VD->getSourceRange(), Rewrite); - SourceLocation SL = SR.getBegin(); - SourceLocation SLE = SR.getEnd(); - - 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 (filtered_out_by_location(MR, SL)) - { - /*intentionally left blank*/ - } - else - { - { - if (false && 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 run(const MatchFinder::MatchResult &MR) + { + if (SafeSubset && (MR.Nodes.getNodeAs<clang::VarDecl>("mcsssnativepointer") != nullptr)) + { + const VarDecl *VD = MR.Nodes.getNodeAs<clang::VarDecl>("mcsssnativepointer"); - virtual void onEndOfTranslationUnit() - { - } + auto SR = nice_source_range(VD->getSourceRange(), Rewrite); + SourceLocation SL = SR.getBegin(); + SourceLocation SLE = SR.getEnd(); + + 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 (filtered_out_by_location(MR, SL)) + { + /*intentionally left blank*/ + } + else + { + { + if (false && 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; + Rewriter &Rewrite; }; /**********************************************************************************************************************/ class MCSSSVarDecl : public MatchFinder::MatchCallback { public: MCSSSVarDecl (Rewriter &Rewrite, CState1& state1) - : Rewrite(Rewrite), m_state1(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"); - - auto SR = nice_source_range(VD->getSourceRange(), Rewrite); - SourceLocation SL = SR.getBegin(); - SourceLocation SLE = SR.getEnd(); - - 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; - } - - if (filtered_out_by_location(MR, SL)) { - return void(); - } - - 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(); - } + virtual void run(const MatchFinder::MatchResult &MR) + { + if ((MR.Nodes.getNodeAs<clang::VarDecl>("mcsssvardecl") != nullptr)) + { + const VarDecl* VD = MR.Nodes.getNodeAs<clang::VarDecl>("mcsssvardecl"); - std::string initialization_expr_str; - 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); - } + auto SR = nice_source_range(VD->getSourceRange(), Rewrite); + SourceLocation SL = SR.getBegin(); + SourceLocation SLE = SR.getEnd(); - 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 { - ; - } - - } - } + QualType QT = VD->getType(); - virtual void onEndOfTranslationUnit() - { - } + 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 (filtered_out_by_location(MR, SL)) { + return void(); + } + + 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 = nice_source_range(pInitExpr->getSourceRange(), Rewrite); + 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(m_state1, *VD); + int q = 3; + } else { + int q = 7; + } + m_state1.m_dynamic_array_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, *VD); + int q = 5; + } else { + ; + } + + } + } + + virtual void onEndOfTranslationUnit() + { + } private: - Rewriter &Rewrite; - CState1& m_state1; + Rewriter &Rewrite; + CState1& m_state1; }; /**********************************************************************************************************************/ @@ -849,126 +969,92 @@ static CRandomAccessIteratorFromPointerDDeclRetval RandomAccessIteratorFromPoint QualType QT = DD->getType(); - const clang::Type* TP = QT.getTypePtr(); + 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; + 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 = nice_source_range(pInitExpr->getSourceRange(), Rewrite); - initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range); - } - } + 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 = nice_source_range(pInitExpr->getSourceRange(), Rewrite); + 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(); + 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::TNullableAnyRandomAccessIterator<"; - 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; - } - } + auto TPP = static_cast<const clang::PointerType*>(TP); + if (TPP) { + auto target_type = TPP->getPointeeType(); - 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; + auto splitQualType = target_type.split(); + auto type_str = clang::QualType::getAsString(splitQualType); - if (!VD) { - assert(false); - return retval; - } - auto SR = nice_source_range(VD->getSourceRange(), Rewrite); - SourceLocation SL = SR.getBegin(); - - 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) { - auto VDSR = nice_source_range(var_decl->getSourceRange(), Rewrite); - SourceLocation l_SL = VDSR.getBegin(); - if (l_SL == SL) { - retval.push_back(var_decl); + if (("char" != type_str) && ("const char" != type_str)) { + std::string replacement_code; + if (is_static) { + replacement_code += "static "; + } + replacement_code += "mse::TNullableAnyRandomAccessIterator<"; + 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 (0 == retval.size()) { - assert(false); - } + 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; } @@ -976,220 +1062,455 @@ class MCSSSPointerArithmetic : public MatchFinder::MatchCallback { public: MCSSSPointerArithmetic (Rewriter &Rewrite, CState1& state1) - : Rewrite(Rewrite), m_state1(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"); + 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"); + if (DRE != nullptr) + { + const DeclRefExpr* DRE = MR.Nodes.getNodeAs<clang::DeclRefExpr>("mcssspointerarithmetic"); - auto SR = nice_source_range(DRE->getSourceRange(), Rewrite); - SourceLocation SL = SR.getBegin(); - SourceLocation SLE = SR.getEnd(); + auto SR = nice_source_range(DRE->getSourceRange(), Rewrite); + SourceLocation SL = SR.getBegin(); + SourceLocation SLE = SR.getEnd(); - QualType QT = DRE->getType(); + QualType QT = DRE->getType(); - const clang::Type* TP = QT.getTypePtr(); + const clang::Type* TP = QT.getTypePtr(); - ASTContext *const ASTC = MR.Context; - FullSourceLoc FSL = ASTC->getFullLoc(SL); + ASTContext *const ASTC = MR.Context; + FullSourceLoc FSL = ASTC->getFullLoc(SL); - SourceManager &SM = ASTC->getSourceManager(); + 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 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 (filtered_out_by_location(MR, SL)) { - return void(); - } + if (filtered_out_by_location(MR, SL)) { + return void(); + } - auto decl = DRE->getDecl(); - auto DD = dynamic_cast<const DeclaratorDecl*>(decl); + 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; - } + 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 = 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(); - 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; - } - } - } - } + if (!DD) { + return; + } else { + 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(); + 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_array_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, *var_decl); + } + int q = 3; + } else { + int q = 7; + } + } else { + int q = 7; + } + } + } + } private: - Rewriter &Rewrite; - CState1& m_state1; + Rewriter &Rewrite; + CState1& m_state1; }; /**********************************************************************************************************************/ -static std::string IPointerFromPointerDecl(const DeclaratorDecl* DD, Rewriter &Rewrite) { + +class CIndirectionState { +public: + CIndirectionState(std::string original, std::string current) + : m_original(original), m_current(current) {} + CIndirectionState(const CIndirectionState& src) = default; + std::string m_original; + std::string m_current; +}; + +std::vector<CIndirectionState>& populateTypeIndirectionStack(std::vector<CIndirectionState>& stack, const clang::Type& type, int depth = 0) { + auto TP = &type; + if (TP->isArrayType()) { + const clang::ArrayType* ATP = TP->getAsArrayTypeUnsafe(); + if (ATP) { + auto QT = ATP->getElementType(); + auto l_TP = QT.getTypePtr(); + auto type_str = clang::QualType::getAsString(QT.split()); + + stack.push_back(CIndirectionState("native array", "native array")); + + return populateTypeIndirectionStack(stack, *l_TP, depth+1); + } else { + assert(false); + } + } else if (TP->isPointerType()) { + auto PTP = static_cast<const clang::PointerType*>(TP); + if (PTP) { + auto QT = PTP->getPointeeType(); + auto l_TP = QT.getTypePtr(); + auto type_str = clang::QualType::getAsString(QT.split()); + + stack.push_back(CIndirectionState("native pointer", "native pointer")); + + return populateTypeIndirectionStack(stack, *l_TP, depth+1); + } else { + assert(false); + } + } + return stack; +} + +std::vector<std::string>& populateStmtIndirectionStack(std::vector<std::string>& stack, const clang::Stmt& stmt, int depth = 0) { + const clang::Stmt* ST = &stmt; + auto stmt_class = ST->getStmtClass(); + if (clang::Stmt::StmtClass::ArraySubscriptExprClass == stmt_class) { + auto ASE = static_cast<const clang::ArraySubscriptExpr*>(ST); + auto BE = ASE->getBase(); + stack.push_back("ArraySubscriptExpr"); + } else if (clang::Stmt::StmtClass::UnaryOperatorClass == stmt_class) { + auto UO = static_cast<const clang::UnaryOperator*>(ST); + if (UO) { + if (clang::UnaryOperatorKind::UO_Deref == UO->getOpcode()) { + stack.push_back("Deref"); + } + } else { + assert(false); + } + } else if(clang::Stmt::StmtClass::DeclRefExprClass == stmt_class) { + auto DRE = static_cast<const clang::DeclRefExpr*>(ST); + if (DRE) { + ; + } else { + assert(false); + } + } else if(clang::Stmt::StmtClass::MemberExprClass == stmt_class) { + auto ME = static_cast<const clang::MemberExpr*>(ST); + if (ME) { + ; + } else { + assert(false); + } + } + auto child_iter = ST->child_begin(); + if (child_iter != ST->child_end()) { + return populateStmtIndirectionStack(stack, *(*child_iter), depth+1); + } else { + return stack; + } +} + +static std::string IPointerFromPointerDecl(const DeclaratorDecl* DD, Rewriter &Rewrite, const std::string& notes_str = "") { std::string retval; + assert(DD); + auto DDSR = nice_source_range(DD->getSourceRange(), Rewrite); + std::string decl_source_text = Rewrite.getRewrittenText(DDSR); + QualType QT = DD->getType(); - const clang::Type* TP = QT.getTypePtr(); + 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; + auto type_str = clang::QualType::getAsString(QT.split()); + 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 = nice_source_range(pInitExpr->getSourceRange(), Rewrite); - 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 = nice_source_range(pInitExpr->getSourceRange(), Rewrite); - initialization_expr_str = Rewrite.getRewrittenText(init_expr_source_range); - } - } + 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 = nice_source_range(pInitExpr->getSourceRange(), Rewrite); + 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 = nice_source_range(pInitExpr->getSourceRange(), Rewrite); + 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(); + 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) && false) { - 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 ("array element" == notes_str) { + if (TP->isArrayType()) { + std::string array_size_str; + bool invalid_flag = false; + size_t array_size_str_start_index = decl_source_text.size(); + size_t array_size_str_end_index = 0; + for (size_t index1 = 0; index1 < decl_source_text.size(); index1 += 1) { + if ('[' == decl_source_text[index1]) { + array_size_str_start_index = index1 + 1; + break; + } + } + if (array_size_str_start_index >= decl_source_text.size()) { + invalid_flag = true; + } + for (size_t index1 = decl_source_text.size(); index1 > 1; index1 -= 1) { + if (']' == decl_source_text[index1 - 1]) { + array_size_str_end_index = index1 - 1; + break; + } + } + if (array_size_str_end_index == 0) { + invalid_flag = true; + } + if (invalid_flag || (array_size_str_start_index >= array_size_str_end_index)) { + invalid_flag = true; + } else { + array_size_str = decl_source_text.substr(array_size_str_start_index, array_size_str_end_index - array_size_str_start_index); + + const clang::ArrayType* ATP = TP->getAsArrayTypeUnsafe(); + if (ATP) { + QT = ATP->getElementType(); + TP = QT.getTypePtr(); + type_str = clang::QualType::getAsString(QT.split()); + } else { + assert(false); + } + + 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::mstd::array<mse::TIPointerWithBundledVector<"; + replacement_code += type_str; + replacement_code += ">, "; + replacement_code += array_size_str; + replacement_code += "> "; + replacement_code += variable_name; + + if (("" != initialization_expr_str) && false) { + replacement_code += " = "; + replacement_code += initialization_expr_str; + } + retval = replacement_code; + replacement_code_generated = true; + } + } + } + } else if (TP->isPointerType()) { + + auto PTP = static_cast<const clang::PointerType*>(TP); + if (PTP) { + QT = PTP->getPointeeType(); + TP = QT.getTypePtr(); + type_str = clang::QualType::getAsString(QT.split()); + } else { + assert(false); + } + + 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<mse::TIPointerWithBundledVector<"; + replacement_code += type_str; + replacement_code += "> "; + replacement_code += "> "; + replacement_code += variable_name; + + if (("" != initialization_expr_str) && false) { + replacement_code += " = "; + replacement_code += initialization_expr_str; + } + retval = replacement_code; + replacement_code_generated = true; + } + } + } else { + assert(false); + } + } else if ("dereference" == notes_str) { + if (TP->isPointerType()) { + auto PTP = static_cast<const clang::PointerType*>(TP); + if (PTP) { + QT = PTP->getPointeeType(); + TP = QT.getTypePtr(); + type_str = clang::QualType::getAsString(QT.split()); + } else { + assert(false); + } + + 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::TAnyPointer<mse::TIPointerWithBundledVector<"; + replacement_code += type_str; + replacement_code += "> "; + replacement_code += "> "; + replacement_code += variable_name; + + if (("" != initialization_expr_str) && false) { + replacement_code += " = "; + replacement_code += initialization_expr_str; + } + retval = replacement_code; + replacement_code_generated = true; + } + } + } else { + assert(false); + } + } else 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) && false) { + 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; + 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; + retval = decl_source_text; + replacement_code_generated = true; } return retval; } @@ -1198,744 +1519,789 @@ class MCSSSMalloc : public MatchFinder::MatchCallback { public: MCSSSMalloc (Rewriter &Rewrite, CState1& state1) - : Rewrite(Rewrite), m_state1(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)) - { - auto BOSR = nice_source_range(BO->getSourceRange(), Rewrite); - SourceLocation BOSL = BOSR.getBegin(); - SourceLocation BOSLE = BOSR.getEnd(); - - 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 (filtered_out_by_location(MR, BOSL)) { - return void(); - } - - auto function_decl = CE->getDirectCallee(); - auto num_args = CE->getNumArgs(); - if (function_decl && ((1 == num_args) || (2 == 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))); - bool still_potentially_valid1 = (ends_with_alloc && (1 == num_args)) || (ends_with_realloc && (2 == num_args)); - if (still_potentially_valid1) { - auto iter = CE->arg_begin(); - if (ends_with_realloc) { - iter++; - } - { - auto arg_source_range = nice_source_range((*iter)->getSourceRange(), Rewrite); - 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 = 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(); - 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 = nice_source_range(lhs->getSourceRange(), Rewrite); - 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; - } - } - - } - } - } + 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"); + const ArraySubscriptExpr* ASE = MR.Nodes.getNodeAs<clang::ArraySubscriptExpr>("mcsssmalloc5"); + const UnaryOperator* UO = MR.Nodes.getNodeAs<clang::UnaryOperator>("mcsssmalloc6"); + + if ((BO != nullptr) && (CE != nullptr) && (DRE != nullptr)) + { + auto BOSR = nice_source_range(BO->getSourceRange(), Rewrite); + SourceLocation BOSL = BOSR.getBegin(); + SourceLocation BOSLE = BOSR.getEnd(); + + 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 (std::string::npos != source_location_str.find("526")) { + int q = 5; + } + + if (filtered_out_by_location(MR, BOSL)) { + return void(); + } + + auto function_decl = CE->getDirectCallee(); + auto num_args = CE->getNumArgs(); + if (function_decl && ((1 == num_args) || (2 == 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))); + bool still_potentially_valid1 = (ends_with_alloc && (1 == num_args)) || (ends_with_realloc && (2 == num_args)); + if (still_potentially_valid1) { + auto iter = CE->arg_begin(); + if (ends_with_realloc) { + iter++; + } + bool argIsIntegerType = false; + if (*iter) { + argIsIntegerType = (*iter)->getType().split().asPair().first->isIntegerType(); + } + if (argIsIntegerType) { + auto arg_source_range = nice_source_range((*iter)->getSourceRange(), Rewrite); + 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); + + bool asterisk_found = false; + 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); + } + + 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 (true || 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 LHS = BO->getLHS(); + auto lhs_QT = LHS->getType(); + auto lhs_children = LHS->children(); + for (const auto& child : lhs_children) { + auto stmt_class = child->getStmtClass(); + clang::Stmt::StmtClass a; + } + + 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(); + const clang::Type* TP = QT.getTypePtr(); + 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; + } + + std::string notes_str; + if (ASE != nullptr) { + notes_str = "array element"; + if (TP->isArrayType()) { + const clang::ArrayType* ATP = TP->getAsArrayTypeUnsafe(); + if (ATP) { + QT = ATP->getElementType(); + TP = QT.getTypePtr(); + //type_str = clang::QualType::getAsString(QT.split()); + } else { + assert(false); + } + } else if (TP->isPointerType()) { + auto PTP = static_cast<const clang::PointerType*>(TP); + if (PTP) { + QT = PTP->getPointeeType(); + TP = QT.getTypePtr(); + //type_str = clang::QualType::getAsString(QT.split()); + } else { + assert(false); + } + } + } else if (UO != nullptr) { + notes_str = "dereference"; + if (TP->isPointerType()) { + auto PTP = static_cast<const clang::PointerType*>(TP); + if (PTP) { + QT = PTP->getPointeeType(); + TP = QT.getTypePtr(); + //type_str = clang::QualType::getAsString(QT.split()); + } else { + assert(false); + } + } + } + auto decls = IndividualDeclaratorDecls(DD, Rewrite); + if ((1 <= decls.size()) && (decls.back() == DD)) { + for (const auto& decl : decls) { + declaration_replacement_code += IPointerFromPointerDecl(decl, Rewrite, notes_str); + 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; + } + + 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) { + num_elements_text = "("; + num_elements_text += arg_source_text; + num_elements_text += ") / sizeof("; + num_elements_text += element_type_str; + num_elements_text += ")"; + + auto lhs = BO->getLHS(); + auto lhs_source_range = nice_source_range(lhs->getSourceRange(), Rewrite); + 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())) { + auto cr_shptr = std::make_shared<CMallocArrayReplacementAction>(Rewrite, MR, *DD, BO, bo_replacement_code, declaration_replacement_code); + + bool already_determined_to_be_an_array = false; + 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) { + if (("pointer to random access iterator" == (*iter).action_species()) + || ("pointer targeting heap allocated array to mse vector iterator" == (*iter).action_species())) { + already_determined_to_be_an_array = true; + } + } + } + if (already_determined_to_be_an_array) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array_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; + Rewriter &Rewrite; + CState1& m_state1; }; class MCSSSMallocInitializer : public MatchFinder::MatchCallback { public: MCSSSMallocInitializer (Rewriter &Rewrite, CState1& state1) - : Rewrite(Rewrite), m_state1(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)) - { - auto DSSR = nice_source_range(DS->getSourceRange(), Rewrite); - SourceLocation DSSL = DSSR.getBegin(); - SourceLocation DSSLE = DSSR.getEnd(); - - ASTContext *const ASTC = MR.Context; - FullSourceLoc FDSSL = ASTC->getFullLoc(DSSL); - - SourceManager &SM = ASTC->getSourceManager(); - - auto source_location_str = DSSL.printToString(*MR.SourceManager); - std::string source_text; - if (DSSL.isValid() && DSSLE.isValid()) { - source_text = Rewrite.getRewrittenText(SourceRange(DSSL, DSSLE)); - } else { - return; - } - - if (filtered_out_by_location(MR, DSSL)) { - return void(); - } - - auto function_decl = CE->getDirectCallee(); - auto num_args = CE->getNumArgs(); - if (function_decl && ((1 == num_args) || (2 == 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))); - bool still_potentially_valid1 = (ends_with_alloc && (1 == num_args)) || (ends_with_realloc && (2 == num_args)); - if (still_potentially_valid1) { - auto iter = CE->arg_begin(); - if (ends_with_realloc) { - iter++; - } - { - auto arg_source_range = nice_source_range((*iter)->getSourceRange(), Rewrite); - 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 = 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(); - 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 += "("; - 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; - } - } - - } - } - } + 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)) + { + auto DSSR = nice_source_range(DS->getSourceRange(), Rewrite); + SourceLocation DSSL = DSSR.getBegin(); + SourceLocation DSSLE = DSSR.getEnd(); + + ASTContext *const ASTC = MR.Context; + FullSourceLoc FDSSL = ASTC->getFullLoc(DSSL); + + SourceManager &SM = ASTC->getSourceManager(); + + auto source_location_str = DSSL.printToString(*MR.SourceManager); + std::string source_text; + if (DSSL.isValid() && DSSLE.isValid()) { + source_text = Rewrite.getRewrittenText(SourceRange(DSSL, DSSLE)); + } else { + return; + } + + if (filtered_out_by_location(MR, DSSL)) { + return void(); + } + + auto function_decl = CE->getDirectCallee(); + auto num_args = CE->getNumArgs(); + if (function_decl && ((1 == num_args) || (2 == 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))); + bool still_potentially_valid1 = (ends_with_alloc && (1 == num_args)) || (ends_with_realloc && (2 == num_args)); + if (still_potentially_valid1) { + auto iter = CE->arg_begin(); + if (ends_with_realloc) { + iter++; + } + { + auto arg_source_range = nice_source_range((*iter)->getSourceRange(), Rewrite); + 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 = 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(); + 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 += "("; + 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(m_state1, *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; + Rewriter &Rewrite; + CState1& m_state1; }; class MCSSSFree : public MatchFinder::MatchCallback { public: MCSSSFree (Rewriter &Rewrite, CState1& state1) - : Rewrite(Rewrite), m_state1(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)) - { - 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 && (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 = nice_source_range((*iter)->getSourceRange(), Rewrite); - 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 = 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(); - 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; - } - } - - } - } - } + 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)) + { + 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 && (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 = nice_source_range((*iter)->getSourceRange(), Rewrite); + 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 = 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(); + 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; + Rewriter &Rewrite; + CState1& m_state1; }; class MCSSSSetToNull : public MatchFinder::MatchCallback { public: MCSSSSetToNull (Rewriter &Rewrite, CState1& state1) - : Rewrite(Rewrite), m_state1(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(); + 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)) + { + auto BOSR = nice_source_range(BO->getSourceRange(), Rewrite); + SourceLocation BOSL = BOSR.getBegin(); + SourceLocation BOSLE = BOSR.getEnd(); + + 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 (filtered_out_by_location(MR, BOSL)) { + return void(); + } + + Expr::NullPointerConstantKind kind = RHS->isNullPointerConstant(*ASTC, Expr::NullPointerConstantValueDependence()); + if (clang::Expr::NPCK_NotNull != kind) { + auto lhs_source_range = nice_source_range(LHS->getSourceRange(), Rewrite); + 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 = 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(); + 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; + } + } } - 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)) - { - auto BOSR = nice_source_range(BO->getSourceRange(), Rewrite); - SourceLocation BOSL = BOSR.getBegin(); - SourceLocation BOSLE = BOSR.getEnd(); - - 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 (filtered_out_by_location(MR, BOSL)) { - return void(); - } - - Expr::NullPointerConstantKind kind = RHS->isNullPointerConstant(*ASTC, Expr::NullPointerConstantValueDependence()); - if (clang::Expr::NPCK_NotNull != kind) { - auto lhs_source_range = nice_source_range(LHS->getSourceRange(), Rewrite); - 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 = 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(); - 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; + Rewriter &Rewrite; + CState1& m_state1; }; @@ -1981,14 +2347,22 @@ public: hasRHS( anyOf( cStyleCastExpr(has(callExpr().bind("mcsssmalloc2"))), - 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") + unaryOperator(allOf(hasOperatorName("*"), hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc4")))).bind("mcsssmalloc6"), + unaryOperator(allOf(hasOperatorName("*"), hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc6"), + arraySubscriptExpr(expr(hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc4")))).bind("mcsssmalloc5"), + arraySubscriptExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc5"), + memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc4"), + declRefExpr().bind("mcsssmalloc3"), + hasDescendant(unaryOperator(allOf(hasOperatorName("*"), hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc4")))).bind("mcsssmalloc6")), + hasDescendant(unaryOperator(allOf(hasOperatorName("*"), hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc6")), + hasDescendant(arraySubscriptExpr(expr(hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc4")))).bind("mcsssmalloc5")), + hasDescendant(arraySubscriptExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc5")), + hasDescendant(memberExpr(expr(hasDescendant(declRefExpr().bind("mcsssmalloc3")))).bind("mcsssmalloc4")), + hasDescendant(declRefExpr().bind("mcsssmalloc3")) )), hasLHS(expr(hasType(pointerType()))) )).bind("mcsssmalloc1"), &HandlerForSSSMalloc); |