diff options
Diffstat (limited to 'safercpp')
| -rw-r--r-- | safercpp/safercpp-arr.cpp | 467 |
1 files changed, 419 insertions, 48 deletions
diff --git a/safercpp/safercpp-arr.cpp b/safercpp/safercpp-arr.cpp index 750d393..05f6f27 100644 --- a/safercpp/safercpp-arr.cpp +++ b/safercpp/safercpp-arr.cpp @@ -226,6 +226,7 @@ bool string_begins_with(const std::string& s1, const std::string& prefix) { return (0 == s1.compare(0, prefix.length(), prefix)); } + /* This function returns a list of individual declarations contained in the same declaration statement * as the given declaration. (eg.: "int a, b = 3, *c;" ) */ static std::vector<const DeclaratorDecl*> IndividualDeclaratorDecls(const DeclaratorDecl* DD, Rewriter &Rewrite) { @@ -539,6 +540,7 @@ public: m_direct_qtype = populateQTypeIndirectionStack(m_indirection_state_stack, QT); //std::reverse(m_indirection_state_stack.begin(), m_indirection_state_stack.end()); } + bool is_an_indirect_type(size_t indirection_level = 0) const { return (indirection_level < m_indirection_state_stack.size()); } const DeclaratorDecl* m_ddecl_cptr = nullptr; CIndirectionStateStack m_indirection_state_stack; clang::QualType m_direct_qtype; @@ -557,6 +559,173 @@ public: } }; +bool is_an_indirect_type(const CDDeclIndirection& ddecl_indirection) { + return CDDeclConversionState(*(ddecl_indirection.m_ddecl_cptr)).is_an_indirect_type(ddecl_indirection.m_indirection_level); +} +bool is_an_indirect_type(const clang::DeclaratorDecl& ddecl) { + return CDDeclConversionState(ddecl).is_an_indirect_type(); +} + +bool is_an_indirect_type(const QualType& QT, size_t indirection_level = 0) { + CIndirectionStateStack m_indirection_state_stack; + auto m_direct_qtype = populateQTypeIndirectionStack(m_indirection_state_stack, QT); + return (indirection_level < m_indirection_state_stack.size()); +} + +class CExprTextModifier { +public: + virtual ~CExprTextModifier() {} + virtual std::string modified_copy(const std::string& input_text, const clang::Expr* expr_ptr = nullptr) const { + return input_text; + } + virtual std::string species_str() const { + return "no op"; + } +}; + +class CWrapExprTextModifier : public CExprTextModifier { +public: + CWrapExprTextModifier(const std::string& prefix, const std::string& suffix) : + m_prefix(prefix), m_suffix(suffix) {} + virtual ~CWrapExprTextModifier() {} + virtual std::string modified_copy(const std::string& input_text, const clang::Expr* expr_ptr = nullptr) const { + return m_prefix + input_text + m_suffix; + } + virtual std::string species_str() const { + return "wrap"; + } + std::string m_prefix; + std::string m_suffix; +}; + +class CNullableAnyRandomAccessIterCastExprTextModifier : public CWrapExprTextModifier { +public: + CNullableAnyRandomAccessIterCastExprTextModifier(const clang::QualType& qtype) : + CWrapExprTextModifier("mse::TNullableAnyRandomAccessIterator<" + qtype.getAsString() + " >(", ")"), + m_qtype(qtype) {} + virtual ~CNullableAnyRandomAccessIterCastExprTextModifier() {} + virtual std::string species_str() const { + return "nullable any random access iter cast"; + } + clang::QualType m_qtype; +}; + +class CExprTextModifierStack : public std::vector<std::shared_ptr<CExprTextModifier>> { +public: +}; + +class CExprConversionState { +public: + CExprConversionState(const clang::Expr& expr, Rewriter &Rewrite) : m_expr_cptr(&expr), Rewrite(Rewrite) { + m_original_source_text_str = Rewrite.getRewrittenText(nice_source_range()); + m_current_text_str = m_original_source_text_str; + } + virtual ~CExprConversionState() {} + virtual void update_current_text() { + m_current_text_str = modified_copy(m_original_source_text_str); + } + + clang::SourceRange source_range() const { + clang::SourceRange retval; + return m_expr_cptr->getSourceRange(); + } + clang::SourceRange nice_source_range() const { + return ::nice_source_range(source_range(), Rewrite); + } + void set_parent_shptr(const std::shared_ptr<CExprConversionState>& parent_shptr) { + m_parent_shptr = parent_shptr; + } + void set_childrens_parent_shptr(const std::shared_ptr<CExprConversionState>& parent_shptr) { + for (auto& child_shptr : m_children_shptrs) { + child_shptr->set_parent_shptr(parent_shptr); + } + } + + std::string modified_copy(const std::string& input_text) const { + std::string retval = input_text; + for (const auto& modifier_shptr_cref : m_expr_text_modifier_stack) { + retval = (*modifier_shptr_cref).modified_copy(retval, m_expr_cptr); + } + return retval; + } + + CExprTextModifierStack m_expr_text_modifier_stack; + + std::shared_ptr<CExprConversionState> m_parent_shptr; + std::vector<std::shared_ptr<CExprConversionState>> m_children_shptrs; + + const Expr* m_expr_cptr = nullptr; + std::string m_original_source_text_str; + std::string m_current_text_str; + Rewriter &Rewrite; +}; + +class CConditionalOperatorExprConversionState : public CExprConversionState { +public: + CConditionalOperatorExprConversionState(const clang::ConditionalOperator& co_cref, Rewriter &Rewrite) : CExprConversionState(co_cref, Rewrite) { + auto cond_ptr = co_cref.getCond(); + auto lhs_ptr = co_cref.getLHS(); + auto rhs_ptr = co_cref.getRHS(); + if (cond_ptr && lhs_ptr && rhs_ptr) { + m_cond_shptr = std::make_shared<CExprConversionState>(*cond_ptr, Rewrite); + m_children_shptrs.push_back(m_cond_shptr); + + m_lhs_shptr = std::make_shared<CExprConversionState>(*lhs_ptr, Rewrite); + m_children_shptrs.push_back(m_lhs_shptr); + + m_rhs_shptr = std::make_shared<CExprConversionState>(*rhs_ptr, Rewrite); + m_children_shptrs.push_back(m_rhs_shptr); + } else { + assert(false); + throw(""); + } + } + const clang::ConditionalOperator& co_cref() const { + return (*(static_cast<const clang::ConditionalOperator *>(m_expr_cptr))); + } + virtual void update_current_text() { + if (false) { + /* Do we need to update the kids first? */ + m_cond_shptr->update_current_text(); + m_lhs_shptr->update_current_text(); + m_rhs_shptr->update_current_text(); + } + std::string updated_text = m_cond_shptr->m_current_text_str + " ? " + + m_lhs_shptr->m_current_text_str + " : " + m_rhs_shptr->m_current_text_str; + updated_text = modified_copy(updated_text); + m_current_text_str = updated_text; + } + + std::shared_ptr<CExprConversionState> m_cond_shptr; + std::shared_ptr<CExprConversionState> m_lhs_shptr; + std::shared_ptr<CExprConversionState> m_rhs_shptr; +}; + +template<class X, class... Args> +std::shared_ptr<X> make_expr_conversion_state_shared_ptr(Args&&... args) { + std::shared_ptr<X> retval = std::make_shared<X>(std::forward<Args>(args)...); + retval->set_childrens_parent_shptr(retval); + return retval; +} + +class CExprConversionStateMap : public std::map<const clang::Expr*, std::shared_ptr<CExprConversionState>> { +public: + typedef std::map<const clang::Expr*, std::shared_ptr<CExprConversionState>> base_class; + iterator insert( const std::shared_ptr<CExprConversionState>& cr_shptr ) { + iterator retval(end()); + if (!cr_shptr) { assert(false); } else { + value_type val((*cr_shptr).m_expr_cptr, cr_shptr); + auto res1 = base_class::insert(val); + retval = res1.first; + for (auto& child_shptr_ref : (*cr_shptr).m_children_shptrs) { + value_type val((*child_shptr_ref).m_expr_cptr, child_shptr_ref); + auto res1 = base_class::insert(val); + } + } + return retval; + } +}; + class CState1; @@ -634,12 +803,24 @@ public: std::string m_ce_replacement_code; }; -class CAssignedFromArray2ReplacementAction : public CArray2ReplacementAction { +class CAssignmentTargetConstrainsSourceArray2ReplacementAction : public CArray2ReplacementAction { public: - CAssignedFromArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, + CAssignmentTargetConstrainsSourceArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, const CDDeclIndirection& ddecl_indirection2) : CArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_ddecl_indirection2(ddecl_indirection2) {} - virtual ~CAssignedFromArray2ReplacementAction() {} + virtual ~CAssignmentTargetConstrainsSourceArray2ReplacementAction() {} + + virtual void do_replacement(CState1& state1) const; + + const CDDeclIndirection m_ddecl_indirection2; +}; + +class CAssignmentSourceConstrainsTargetArray2ReplacementAction : public CArray2ReplacementAction { +public: + CAssignmentSourceConstrainsTargetArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, + const CDDeclIndirection& ddecl_indirection2) : + CArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_ddecl_indirection2(ddecl_indirection2) {} + virtual ~CAssignmentSourceConstrainsTargetArray2ReplacementAction() {} virtual void do_replacement(CState1& state1) const; @@ -787,6 +968,10 @@ public: /* This container holds information about each item's original type and which * type it might be converted to. */ CDDeclConversionStateMap m_ddecl_conversion_state_map; + + /* This container holds information about selected expressions' original text and + * any modifications we might have made. */ + CExprConversionStateMap m_expr_conversion_state_map; }; class CDeclarationReplacementCodeItem { @@ -812,12 +997,21 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con QualType QT = DD->getType(); const clang::Type* TP = QT.getTypePtr(); auto qtype_str = QT.getAsString(); - auto direct_qtype_str = clang::QualType::getAsString(ddcs_ref.m_direct_qtype.split()); + auto direct_qtype_str = ddcs_ref.m_direct_qtype.getAsString(); if ("_Bool" == direct_qtype_str) { direct_qtype_str = "bool"; } else if ("const _Bool" == direct_qtype_str) { direct_qtype_str = "const bool"; } + QT.isConstQualified(); + + auto non_const_direct_qtype = ddcs_ref.m_direct_qtype; + non_const_direct_qtype.removeLocalConst(); + auto non_const_direct_qtype_str = non_const_direct_qtype.getAsString(); + if ("_Bool" == non_const_direct_qtype_str) { + non_const_direct_qtype_str = "bool"; + } + auto direct_TP = ddcs_ref.m_direct_qtype.getTypePtr(); if (!direct_TP) { return retval; @@ -947,6 +1141,7 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con is_function_pointer = true; } if ("inferred array" == ddcs_ref.m_indirection_state_stack[i].m_current) { + direct_qtype_str = non_const_direct_qtype_str; if (is_char_star) { /* We're assuming this is a null terminated string. We'll just leave it as a * char* for now. At some point we'll replace it with an mse::string or whatever. */ @@ -959,6 +1154,7 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con retval.m_action_species = "native pointer to TNullableAnyRandomAccessIterator"; } } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_current) { + direct_qtype_str = non_const_direct_qtype_str; if (is_char_star) { /* We're assuming this is a null terminated string. We'll just leave it as a * char* for now. At some point we'll replace it with an mse::string or whatever. */ @@ -976,6 +1172,7 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con } } } else if ("native array" == ddcs_ref.m_indirection_state_stack[i].m_current) { + direct_qtype_str = non_const_direct_qtype_str; std::string size_text; if (TP->isVariableArrayType()) { auto VATP = llvm::cast<const clang::VariableArrayType>(TP); @@ -1371,7 +1568,38 @@ void CMemcpyArray2ReplacementAction::do_replacement(CState1& state1) const { } } -void CAssignedFromArray2ReplacementAction::do_replacement(CState1& state1) const { +void CAssignmentTargetConstrainsSourceArray2ReplacementAction::do_replacement(CState1& state1) const { + Rewriter &Rewrite = m_Rewrite; + const MatchFinder::MatchResult &MR = m_MR; + + auto res1 = state1.m_ddecl_conversion_state_map.insert(*(m_ddecl_indirection2.m_ddecl_cptr)); + auto ddcs_map_iter = res1.first; + auto& ddcs_ref = (*ddcs_map_iter).second; + bool update_declaration_flag = res1.second; + + if (ddcs_ref.m_indirection_state_stack.size() >= m_ddecl_indirection2.m_indirection_level) { + if ("native pointer" == ddcs_ref.m_indirection_state_stack[m_ddecl_indirection2.m_indirection_level].m_current) { + ddcs_ref.m_indirection_state_stack[m_ddecl_indirection2.m_indirection_level].m_current = "inferred array"; + update_declaration_flag = true; + state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection2); + } else if ("malloc target" == ddcs_ref.m_indirection_state_stack[m_ddecl_indirection2.m_indirection_level].m_current) { + ddcs_ref.m_indirection_state_stack[m_ddecl_indirection2.m_indirection_level].m_current = "dynamic array"; + update_declaration_flag = true; + state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection2); + state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection2); + } else { + int q = 3; + } + } else { + int q = 7; + } + + if (update_declaration_flag) { + update_declaration(*(m_ddecl_indirection2.m_ddecl_cptr), Rewrite, state1); + } +} + +void CAssignmentSourceConstrainsTargetArray2ReplacementAction::do_replacement(CState1& state1) const { Rewriter &Rewrite = m_Rewrite; const MatchFinder::MatchResult &MR = m_MR; @@ -1427,6 +1655,8 @@ void CConditionalOperatorReconciliation2ReplacementAction::do_replacement(CState auto res1 = state1.m_ddecl_conversion_state_map.insert(*lhs_DD); auto ddcs_map_iter = res1.first; auto& ddcs_ref = (*ddcs_map_iter).second; + /* At the moment we only support the case where the value option expressions are + * just declared variables. */ if (1 <= ddcs_ref.m_indirection_state_stack.size()) { if ("dynamic array" == ddcs_ref.m_indirection_state_stack[0].m_current) { lhs_is_dynamic_array = true; @@ -1479,52 +1709,74 @@ void CConditionalOperatorReconciliation2ReplacementAction::do_replacement(CState std::string rhs_prior_text = (*this).m_Rewrite.getRewrittenText(rhs_SR); std::string rhs_replacement_text = rhs_prior_text; - static const std::string ara_iter_prefix = "mse::TAnyRandomAccessIterator<"; + static const std::string ara_iter_prefix = "mse::TNullableAnyRandomAccessIterator<"; bool lhs_needs_to_be_wrapped = false; if ((lhs_is_dynamic_array && (!rhs_is_dynamic_array)) || (lhs_is_native_array && (!rhs_is_native_array))) { lhs_needs_to_be_wrapped = true; } - if (lhs_needs_to_be_wrapped) { - if (!string_begins_with(lhs_prior_text, ara_iter_prefix)) { - std::string lhs_base_type_str = lhs_DD->getType().getAsString(); - std::string lhs_replacement_text = ara_iter_prefix + lhs_base_type_str + " >(" + lhs_prior_text + ")"; - if (ConvertToSCPP) { - auto res2 = (*this).m_Rewrite.ReplaceText(lhs_SR, lhs_replacement_text); - - CO_replacement_text = (*this).m_Rewrite.getRewrittenText(COSR); - int q = 3; - } - } - } - bool rhs_needs_to_be_wrapped = false; if ((rhs_is_dynamic_array && (!lhs_is_dynamic_array)) || (rhs_is_native_array && (!lhs_is_native_array))) { rhs_needs_to_be_wrapped = true; } - if (rhs_needs_to_be_wrapped) { - if (!string_begins_with(rhs_prior_text, ara_iter_prefix)) { - std::string rhs_base_type_str = rhs_DD->getType().getAsString(); - std::string rhs_replacement_text = ara_iter_prefix + rhs_base_type_str + " >(" + rhs_prior_text + ")"; - if (ConvertToSCPP) { - auto res2 = (*this).m_Rewrite.ReplaceText(rhs_SR, rhs_replacement_text); - - auto possibly_truncated_CO_replacement_text = (*this).m_Rewrite.getRewrittenText(COSR); - std::string cond_text = (*this).m_Rewrite.getRewrittenText(cond_SR); - std::string CO_replacement_text2 = cond_text + " ? " + lhs_replacement_text + " : " + rhs_replacement_text; + auto cocs_iter = state1.m_expr_conversion_state_map.end(); + if (lhs_needs_to_be_wrapped || rhs_needs_to_be_wrapped) { + cocs_iter = state1.m_expr_conversion_state_map.find(CO); + if (state1.m_expr_conversion_state_map.end() == cocs_iter) { + auto shptr1 = make_expr_conversion_state_shared_ptr<CConditionalOperatorExprConversionState>(*CO, m_Rewrite); + cocs_iter = state1.m_expr_conversion_state_map.insert(shptr1); + } + } - CO_replacement_text = possibly_truncated_CO_replacement_text; - int q = 3; + if (lhs_needs_to_be_wrapped) { + assert(state1.m_expr_conversion_state_map.end() != cocs_iter); + auto lhscs_iter = state1.m_expr_conversion_state_map.find(LHS); + if (state1.m_expr_conversion_state_map.end() != lhscs_iter) { + auto& lhscs_shptr_ref = (*lhscs_iter).second; + bool already_wrapped_flag = false; + if (1 <= (*lhscs_shptr_ref).m_expr_text_modifier_stack.size()) { + auto& last_modifier_ref = (*(*lhscs_shptr_ref).m_expr_text_modifier_stack.back()); + if ("nullable any random access iter cast" == last_modifier_ref.species_str()) { + already_wrapped_flag = true; + } + } + if (ConvertToSCPP && (!already_wrapped_flag)) { + auto shptr1 = std::make_shared<CNullableAnyRandomAccessIterCastExprTextModifier>(LHS->getType()->getPointeeType()); + (*lhscs_shptr_ref).m_expr_text_modifier_stack.push_back(shptr1); + (*lhscs_shptr_ref).update_current_text(); + } + } + } + if (rhs_needs_to_be_wrapped) { + assert(state1.m_expr_conversion_state_map.end() != cocs_iter); + auto rhscs_iter = state1.m_expr_conversion_state_map.find(RHS); + if (state1.m_expr_conversion_state_map.end() != rhscs_iter) { + auto& rhscs_shptr_ref = (*rhscs_iter).second; + bool already_wrapped_flag = false; + if (1 <= (*rhscs_shptr_ref).m_expr_text_modifier_stack.size()) { + auto& last_modifier_ref = (*(*rhscs_shptr_ref).m_expr_text_modifier_stack.back()); + if ("nullable any random access iter cast" == last_modifier_ref.species_str()) { + already_wrapped_flag = true; + } + } + if (ConvertToSCPP && (!already_wrapped_flag)) { + auto shptr1 = std::make_shared<CNullableAnyRandomAccessIterCastExprTextModifier>(RHS->getType()->getPointeeType()); + (*rhscs_shptr_ref).m_expr_text_modifier_stack.push_back(shptr1); + (*rhscs_shptr_ref).update_current_text(); } } } - if (m_var_DD && ("" != CO_replacement_text)) { + if (m_var_DD && (true)) { + assert(state1.m_expr_conversion_state_map.end() != cocs_iter); + auto& cocs_shptr_ref = (*(*cocs_iter).second); + cocs_shptr_ref.update_current_text(); + auto res1 = state1.m_ddecl_conversion_state_map.insert(*m_var_DD); auto ddcs_map_iter = res1.first; auto& ddcs_ref = (*ddcs_map_iter).second; - ddcs_ref.m_initializer_info_str = " = " + CO_replacement_text; + ddcs_ref.m_initializer_info_str = " = " + cocs_shptr_ref.m_current_text_str; } } @@ -1533,10 +1785,19 @@ void CConditionalOperatorReconciliation2ReplacementAction::do_replacement(CState struct CArrayInferenceInfo { + bool is_an_indirect_type() const { + if (nullptr != ddecl_conversion_state_ptr) { + return (1 <= ddecl_conversion_state_ptr->m_indirection_state_stack.size()); + } else { + return false; + } + } bool update_declaration_flag = false; bool has_been_determined_to_be_an_array = false; size_t indirection_level = 0; const DeclaratorDecl* ddecl_cptr = nullptr; + CDDeclConversionState* ddecl_conversion_state_ptr = nullptr; + bool ddecl_needs_update_flag = false; const clang::Expr* declaration_expr_cptr = nullptr; }; @@ -1649,6 +1910,9 @@ CArrayInferenceInfo infer_array_type_info_from_stmt(const clang::Stmt& stmt_cref if ((expr2_QT == QT) && (expr2_variable_name == variable_name)) { retval = infer_array_type_info_from_stmt_indirection_stack(ddcs_ref, stmt_indirection_stack, state1_ref); } + + retval.ddecl_conversion_state_ptr = &ddcs_ref; + retval.ddecl_needs_update_flag = update_declaration_flag; } retval.ddecl_cptr = expr2_DD; } @@ -3103,14 +3367,26 @@ public: if ((QT == LHS_QT)/* && (1 == res2.indirection_level)*/) { lhs_qualifies = true; if (ConvertToSCPP) { - /* Here we're establishing and "enforcing" the constraint that the lhs value must - * be of an (array) type that can be assigned to the target variable. */ - auto cr_shptr = std::make_shared<CAssignedFromArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, 0), CDDeclIndirection(*(res2.ddecl_cptr) , res2.indirection_level)); + { + /* Here we're establishing and "enforcing" the constraint that the lhs value must + * be of an (array) type that can be assigned to the target variable. */ + auto cr_shptr = std::make_shared<CAssignmentTargetConstrainsSourceArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, 0), CDDeclIndirection(*(res2.ddecl_cptr) , res2.indirection_level)); - if (var_has_been_determined_to_be_an_array) { - (*cr_shptr).do_replacement(m_state1); - } else { - m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + if (var_has_been_determined_to_be_an_array) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + } + } + { + /* Here we're establishing the constraint in the opposite direction as well. */ + auto cr_shptr = std::make_shared<CAssignmentSourceConstrainsTargetArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*(res2.ddecl_cptr) , res2.indirection_level), CDDeclIndirection(*DD, 0)); + + if (res2.has_been_determined_to_be_an_array) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + } } } } @@ -3128,14 +3404,26 @@ public: if (QT == RHS_QT) { rhs_qualifies = true; if (ConvertToSCPP) { - /* Here we're establishing and "enforcing" the constraint that the rhs value must - * be of an (array) type that can be assigned to the target variable. */ - auto cr_shptr = std::make_shared<CAssignedFromArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, 0), CDDeclIndirection(*(res2.ddecl_cptr) , res2.indirection_level)); + { + /* Here we're establishing and "enforcing" the constraint that the rhs value must + * be of an (array) type that can be assigned to the target variable. */ + auto cr_shptr = std::make_shared<CAssignmentTargetConstrainsSourceArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*DD, 0), CDDeclIndirection(*(res2.ddecl_cptr) , res2.indirection_level)); - if (var_has_been_determined_to_be_an_array) { - (*cr_shptr).do_replacement(m_state1); - } else { - m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + if (var_has_been_determined_to_be_an_array) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + } + } + { + /* Here we're establishing the constraint in the opposite direction as well. */ + auto cr_shptr = std::make_shared<CAssignmentSourceConstrainsTargetArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*(res2.ddecl_cptr) , res2.indirection_level), CDDeclIndirection(*DD, 0)); + + if (res2.has_been_determined_to_be_an_array) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + } } } } @@ -3211,6 +3499,81 @@ private: CState1& m_state1; }; +class MCSSSAssignment : public MatchFinder::MatchCallback +{ +public: + MCSSSAssignment (Rewriter &Rewrite, CState1& state1) : + Rewrite(Rewrite), m_state1(state1) {} + + virtual void run(const MatchFinder::MatchResult &MR) + { + const clang::BinaryOperator* BO = MR.Nodes.getNodeAs<clang::BinaryOperator>("mcsssassignment1"); + const Expr* LHS = nullptr; + const Expr* RHS = nullptr; + if (BO) { + LHS = BO->getLHS(); + RHS = BO->getRHS(); + } + const DeclRefExpr* DRE = MR.Nodes.getNodeAs<clang::DeclRefExpr>("mcsssassignment2"); + + if ((BO != nullptr) && (LHS != nullptr) && (RHS != 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 lhs_res2 = infer_array_type_info_from_stmt(*LHS, "", (*this).m_state1); + auto rhs_res2 = infer_array_type_info_from_stmt(*RHS, "", (*this).m_state1); + if (ConvertToSCPP && (lhs_res2.ddecl_cptr) && (rhs_res2.ddecl_cptr) + && (is_an_indirect_type(LHS->getType()))) { + { + /* Here we're establishing and "enforcing" the constraint that the rhs value must + * be of an (array) type that can be assigned to the lhs. */ + auto cr_shptr = std::make_shared<CAssignmentTargetConstrainsSourceArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*(lhs_res2.ddecl_cptr), lhs_res2.indirection_level), CDDeclIndirection(*(rhs_res2.ddecl_cptr), rhs_res2.indirection_level)); + + if (lhs_res2.has_been_determined_to_be_an_array) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + } + } + { + /* Here we're establishing the constraint in the opposite direction as well. */ + auto cr_shptr = std::make_shared<CAssignmentSourceConstrainsTargetArray2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*(rhs_res2.ddecl_cptr), rhs_res2.indirection_level), CDDeclIndirection(*(lhs_res2.ddecl_cptr), lhs_res2.indirection_level)); + + if (rhs_res2.has_been_determined_to_be_an_array) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + } + } + } + + } + } + +private: + Rewriter &Rewrite; + CState1& m_state1; +}; + /**********************************************************************************************************************/ class MyASTConsumer : public ASTConsumer { @@ -3218,7 +3581,8 @@ public: MyASTConsumer(Rewriter &R) : HandlerForSSSNativePointer(R), HandlerForSSSArrayToPointerDecay(R, m_state1), HandlerForSSSVarDecl2(R, m_state1), HandlerForSSSPointerArithmetic2(R, m_state1), HandlerForSSSMalloc2(R, m_state1), HandlerForSSSMallocInitializer2(R, m_state1), HandlerForSSSFree2(R, m_state1), HandlerForSSSSetToNull2(R, m_state1), - HandlerForSSSMemset(R, m_state1), HandlerForSSSMemcpy(R, m_state1), HandlerForSSSConditionalInitializer(R, m_state1) + HandlerForSSSMemset(R, m_state1), HandlerForSSSMemcpy(R, m_state1), HandlerForSSSConditionalInitializer(R, m_state1), + HandlerForSSSAssignment(R, m_state1) { Matcher.addMatcher(varDecl(hasType(pointerType())).bind("mcsssnativepointer"), &HandlerForSSSNativePointer); @@ -3329,6 +3693,12 @@ public: ))).bind("mcsssconditionalinitializer3") )).bind("mcsssconditionalinitializer1"), &HandlerForSSSConditionalInitializer); + Matcher.addMatcher(binaryOperator(allOf( + hasOperatorName("="), + hasLHS(hasDescendant(declRefExpr().bind("mcsssassignment2"))), + hasRHS(hasDescendant(declRefExpr().bind("mcsssassignment3"))) + )).bind("mcsssassignment1"), &HandlerForSSSAssignment); + } void HandleTranslationUnit(ASTContext &Context) override @@ -3351,6 +3721,7 @@ private: MCSSSMemset HandlerForSSSMemset; MCSSSMemcpy HandlerForSSSMemcpy; MCSSSConditionalInitializer HandlerForSSSConditionalInitializer; + MCSSSAssignment HandlerForSSSAssignment; MatchFinder Matcher; }; |