diff options
Diffstat (limited to '')
| -rw-r--r-- | safercpp/safercpp-arr.cpp | 413 |
1 files changed, 287 insertions, 126 deletions
diff --git a/safercpp/safercpp-arr.cpp b/safercpp/safercpp-arr.cpp index 7142e70..1ec010d 100644 --- a/safercpp/safercpp-arr.cpp +++ b/safercpp/safercpp-arr.cpp @@ -69,9 +69,15 @@ SourceRange nice_source_range(const SourceRange& sr, Rewriter &Rewrite) { if (SL.isMacroID() || SLE.isMacroID()) { int q = 5; } - SL = Devi::SourceLocationHasMacro(SL, Rewrite, "start"); - SLE = Devi::SourceLocationHasMacro(SLE, Rewrite, "end"); - return SourceRange(SL, SLE); + //SL = Devi::SourceLocationHasMacro(SL, Rewrite, "start"); + //SLE = Devi::SourceLocationHasMacro(SLE, Rewrite, "end"); + SL = Rewrite.getSourceMgr().getFileLoc(SL); + SLE = Rewrite.getSourceMgr().getFileLoc(SLE); + if ((SL == SLE) && (sr.getBegin() != sr.getEnd())) { + return sr; + } else { + return SourceRange(SL, SLE); + } } bool filtered_out_by_location(const ast_matchers::MatchFinder::MatchResult &MR, SourceLocation SL) { @@ -266,7 +272,7 @@ static std::vector<const DeclaratorDecl*> IndividualDeclaratorDecls(const Declar } if (0 == retval.size()) { //assert(false); - int q = 7; + retval.push_back(DD); } return retval; @@ -316,10 +322,18 @@ public: } return retval; } + void set_current(const std::string& new_current) { + m_current = new_current; + } + const std::string& current() const { + return m_current; + } +private: std::string m_original; std::string m_current; +public: std::string m_original_array_size_expr; bool m_current_is_function_type = false; @@ -700,6 +714,15 @@ void walkTheAST1(const clang::Stmt& stmt, int depth = 0) { class CDDeclConversionState { public: CDDeclConversionState(const clang::DeclaratorDecl& ddecl) : m_ddecl_cptr(&ddecl) { + if ((*this).m_ddecl_cptr) { + std::string variable_name = m_ddecl_cptr->getNameAsString(); + if ("buffer" == variable_name) { + std::string qtype_str = m_ddecl_cptr->getType().getAsString(); + if ("const unsigned char *" == qtype_str) { + int q = 5; + } + } + } QualType QT = ddecl.getType(); assert(ddecl.isFunctionOrFunctionTemplate() == QT->isFunctionType()); if (QT->isFunctionType()) { @@ -718,12 +741,27 @@ public: m_current_direct_qtype_is_current = false; m_current_direct_qtype_str = str; } + void set_indirection_current(size_t indirection_level, const std::string& new_current) { + if ((*this).m_ddecl_cptr) { + std::string variable_name = m_ddecl_cptr->getNameAsString(); + if ("buffer" == variable_name) { + std::string qtype_str = m_ddecl_cptr->getType().getAsString(); + if ("const unsigned char *" == qtype_str) { + int q = 5; + } + } + } + (*this).m_indirection_state_stack.at(indirection_level).set_current(new_current); + } + const std::string& indirection_current(size_t indirection_level) const { + return (*this).m_indirection_state_stack.at(indirection_level).current(); + } bool is_an_indirect_type(size_t indirection_level = 0) const { return (m_indirection_state_stack.size() > indirection_level); } bool has_been_determined_to_be_an_array(size_t indirection_level = 0) const { bool retval = false; assert((0 == indirection_level) || (m_indirection_state_stack.size() > indirection_level)); if (m_indirection_state_stack.size() > indirection_level) { - const auto& current_state = m_indirection_state_stack[indirection_level].m_current; + const auto& current_state = m_indirection_state_stack.at(indirection_level).current(); if (("inferred array" == current_state) || ("dynamic array" == current_state) || ("native array" == current_state)) { retval = true; } @@ -734,13 +772,14 @@ public: bool retval = false; assert((0 == indirection_level) || (m_indirection_state_stack.size() > indirection_level)); if (m_indirection_state_stack.size() > indirection_level) { - const auto& current_state = m_indirection_state_stack[indirection_level].m_current; + const auto& current_state = m_indirection_state_stack.at(indirection_level).current(); if ("dynamic array" == current_state) { retval = true; } } return retval; } + const DeclaratorDecl* m_ddecl_cptr = nullptr; CIndirectionStateStack m_indirection_state_stack; clang::QualType m_original_direct_qtype; @@ -1368,7 +1407,7 @@ static CTypeIndirectionPrefixAndSuffixItem generate_type_indirection_prefix_and_ //suffix_str = indirection_state_stack[i].current_params_string() + suffix_str; } - if ("inferred array" == indirection_state_stack[i].m_current) { + if ("inferred array" == indirection_state_stack[i].current()) { 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. */ @@ -1383,7 +1422,7 @@ static CTypeIndirectionPrefixAndSuffixItem generate_type_indirection_prefix_and_ suffix_str = "> " + suffix_str; retval.m_action_species = "native pointer to TNullableAnyRandomAccessIterator"; } - } else if ("dynamic array" == indirection_state_stack[i].m_current) { + } else if ("dynamic array" == indirection_state_stack[i].current()) { 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. */ @@ -1403,7 +1442,7 @@ static CTypeIndirectionPrefixAndSuffixItem generate_type_indirection_prefix_and_ retval.m_action_species = "native pointer to TIPointerWithBundledVector"; } } - } else if ("native array" == indirection_state_stack[i].m_current) { + } else if ("native array" == indirection_state_stack[i].current()) { std::string size_text = indirection_state_stack[i].m_original_array_size_expr; if (is_char_star) { @@ -1425,7 +1464,7 @@ static CTypeIndirectionPrefixAndSuffixItem generate_type_indirection_prefix_and_ retval.m_action_species = "native array to TNativeArrayReplacement"; } } - } else if ("native pointer" == indirection_state_stack[i].m_current) { + } else if ("native pointer" == indirection_state_stack[i].current()) { 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. */ @@ -1447,7 +1486,7 @@ static CTypeIndirectionPrefixAndSuffixItem generate_type_indirection_prefix_and_ retval.m_action_species = "native pointer"; } } - } else if ("malloc target" == indirection_state_stack[i].m_current) { + } else if ("malloc target" == indirection_state_stack[i].current()) { /* We'll just leaving it as a native pointer for now. Ultimately, this won't be the case. */ //prefix_str = prefix_str + ""; suffix_str = "* " + suffix_str; @@ -1932,31 +1971,31 @@ CArrayInferenceInfo infer_array_type_info_from_stmt_indirection_stack(CDDeclConv /* We're using the empty string as a generic state for the "terminal level of indirection" * when we don't want to bother specifying a specific state. */ retval.indirection_level = i; - } else if ("native pointer" == ddcs_ref.m_indirection_state_stack[i].m_current) { + } else if ("native pointer" == ddcs_ref.m_indirection_state_stack.at(i).current()) { if (("ArraySubscriptExpr" == stmt_indirection_stack[i]) || ("pointer arithmetic" == stmt_indirection_stack[i])) { - ddcs_ref.m_indirection_state_stack[i].m_current = "inferred array"; + ddcs_ref.set_indirection_current(i, "inferred array"); retval.update_declaration_flag = true; state1_ref.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1_ref, CDDeclIndirection(*DD, i)); } else if (("malloc target" == stmt_indirection_stack[i])) { - ddcs_ref.m_indirection_state_stack[i].m_current = "malloc target"; + ddcs_ref.set_indirection_current(i, "malloc target"); retval.indirection_level = i; } else if (("set to null" == stmt_indirection_stack[i]) || ("memset/cpy target" == stmt_indirection_stack[i])) { retval.indirection_level = i; } - } else if ("malloc target" == ddcs_ref.m_indirection_state_stack[i].m_current) { + } else if ("malloc target" == ddcs_ref.m_indirection_state_stack.at(i).current()) { if (("ArraySubscriptExpr" == stmt_indirection_stack[i]) || ("pointer arithmetic" == stmt_indirection_stack[i])) { - ddcs_ref.m_indirection_state_stack[i].m_current = "dynamic array"; + ddcs_ref.set_indirection_current(i, "dynamic array"); retval.update_declaration_flag = true; state1_ref.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1_ref, CDDeclIndirection(*DD, i)); state1_ref.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1_ref, CDDeclIndirection(*DD, i)); } - } else if ("inferred array" == ddcs_ref.m_indirection_state_stack[i].m_current) { + } else if ("inferred array" == ddcs_ref.m_indirection_state_stack.at(i).current()) { if (("malloc target" == stmt_indirection_stack[i]) || ("set to null" == stmt_indirection_stack[i])) { - ddcs_ref.m_indirection_state_stack[i].m_current = "dynamic array"; + ddcs_ref.set_indirection_current(i, "dynamic array"); retval.update_declaration_flag = true; retval.has_just_been_determined_to_be_an_array_flag = true; retval.indirection_level = i; @@ -1965,7 +2004,7 @@ CArrayInferenceInfo infer_array_type_info_from_stmt_indirection_stack(CDDeclConv retval.has_just_been_determined_to_be_an_array_flag = true; retval.indirection_level = i; } - } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_current) { + } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack.at(i).current()) { if (("malloc target" == stmt_indirection_stack[i]) || ("set to null" == stmt_indirection_stack[i])) { retval.has_just_been_determined_to_be_an_array_flag = true; @@ -2072,8 +2111,8 @@ void CMallocArray2ReplacementAction::do_replacement(CState1& state1) const { bool update_declaration_flag = res1.second; if (ddcs_ref.m_indirection_state_stack.size() >= ddecl_indirection_cref().m_indirection_level) { - if ("inferred array" == ddcs_ref.m_indirection_state_stack[ddecl_indirection_cref().m_indirection_level].m_current) { - ddcs_ref.m_indirection_state_stack[ddecl_indirection_cref().m_indirection_level].m_current = "dynamic array"; + if ("inferred array" == ddcs_ref.indirection_current(ddecl_indirection_cref().m_indirection_level)) { + ddcs_ref.set_indirection_current(ddecl_indirection_cref().m_indirection_level, "dynamic array"); update_declaration_flag |= true; state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, ddecl_indirection_cref()); } else { @@ -2193,7 +2232,7 @@ void CAssignmentTargetConstrainsSourceDynamicArray2ReplacementAction::do_replace if (ddcs_ref.m_indirection_state_stack.size() >= m_ddecl_indirection2.m_indirection_level) { if (true) { - ddcs_ref.m_indirection_state_stack[m_ddecl_indirection2.m_indirection_level].m_current = "dynamic array"; + ddcs_ref.set_indirection_current(m_ddecl_indirection2.m_indirection_level, "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); @@ -2280,12 +2319,12 @@ void CAssignmentTargetConstrainsSourceArray2ReplacementAction::do_replacement(CS 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"; + if ("native pointer" == ddcs_ref.m_indirection_state_stack.at(m_ddecl_indirection2.m_indirection_level).current()) { + ddcs_ref.set_indirection_current(m_ddecl_indirection2.m_indirection_level, "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"; + } else if ("malloc target" == ddcs_ref.m_indirection_state_stack.at(m_ddecl_indirection2.m_indirection_level).current()) { + ddcs_ref.set_indirection_current(m_ddecl_indirection2.m_indirection_level, "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); @@ -2305,18 +2344,28 @@ void CAssignmentSourceConstrainsTargetArray2ReplacementAction::do_replacement(CS Rewriter &Rewrite = m_Rewrite; const MatchFinder::MatchResult &MR = m_MR; + if (m_ddecl_indirection2.m_ddecl_cptr) { + std::string variable_name = (m_ddecl_indirection2.m_ddecl_cptr)->getNameAsString(); + if ("buffer" == variable_name) { + std::string qtype_str = (m_ddecl_indirection2.m_ddecl_cptr)->getType().getAsString(); + if ("const unsigned char *" == qtype_str) { + int q = 5; + } + } + } + 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"; + if ("native pointer" == ddcs_ref.m_indirection_state_stack.at(m_ddecl_indirection2.m_indirection_level).current()) { + ddcs_ref.set_indirection_current(m_ddecl_indirection2.m_indirection_level, "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"; + } else if ("malloc target" == ddcs_ref.m_indirection_state_stack.at(m_ddecl_indirection2.m_indirection_level).current()) { + ddcs_ref.set_indirection_current(m_ddecl_indirection2.m_indirection_level, "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); @@ -2348,109 +2397,111 @@ void CSameTypeArray2ReplacementAction::do_replacement(CState1& state1) const { if ((lhs_ddcs_ref.m_indirection_state_stack.size() >= m_ddecl_indirection2.m_indirection_level) && (rhs_ddcs_ref.m_indirection_state_stack.size() >= m_ddecl_indirection.m_indirection_level)){ - auto& lhs_current_ref = lhs_ddcs_ref.m_indirection_state_stack[m_ddecl_indirection2.m_indirection_level].m_current; - auto& rhs_current_ref = rhs_ddcs_ref.m_indirection_state_stack[m_ddecl_indirection.m_indirection_level].m_current; - - if ("native pointer" == lhs_current_ref) { - if ("native pointer" == rhs_current_ref) { - } else if ("malloc target" == rhs_current_ref) { - lhs_current_ref = rhs_current_ref; + auto lhs_indirection_level = m_ddecl_indirection2.m_indirection_level; + auto rhs_indirection_level = m_ddecl_indirection.m_indirection_level; + auto& lhs_current_cref = lhs_ddcs_ref.indirection_current(lhs_indirection_level); + auto& rhs_current_cref = rhs_ddcs_ref.indirection_current(rhs_indirection_level); + + if ("native pointer" == lhs_current_cref) { + if ("native pointer" == rhs_current_cref) { + } else if ("malloc target" == rhs_current_cref) { + lhs_ddcs_ref.set_indirection_current(lhs_indirection_level, rhs_current_cref); lhs_update_declaration_flag |= true; - } else if ("inferred array" == rhs_current_ref) { - lhs_current_ref = rhs_current_ref; + } else if ("inferred array" == rhs_current_cref) { + lhs_ddcs_ref.set_indirection_current(lhs_indirection_level, rhs_current_cref); lhs_update_declaration_flag |= true; state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection2); - } else if ("dynamic array" == rhs_current_ref) { - lhs_current_ref = rhs_current_ref; + } else if ("dynamic array" == rhs_current_cref) { + lhs_ddcs_ref.set_indirection_current(lhs_indirection_level, rhs_current_cref); lhs_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 if ("native array" == rhs_current_ref) { - lhs_current_ref = rhs_current_ref; + } else if ("native array" == rhs_current_cref) { + lhs_ddcs_ref.set_indirection_current(lhs_indirection_level, rhs_current_cref); lhs_update_declaration_flag |= true; state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection2); } - } else if ("malloc target" == lhs_current_ref) { - if ("native pointer" == rhs_current_ref) { - rhs_current_ref = lhs_current_ref; + } else if ("malloc target" == lhs_current_cref) { + if ("native pointer" == rhs_current_cref) { + rhs_ddcs_ref.set_indirection_current(rhs_indirection_level, lhs_current_cref); rhs_update_declaration_flag |= true; - } else if ("malloc target" == rhs_current_ref) { - } else if ("inferred array" == rhs_current_ref) { - lhs_current_ref = "dynamic array"; + } else if ("malloc target" == rhs_current_cref) { + } else if ("inferred array" == rhs_current_cref) { + lhs_ddcs_ref.set_indirection_current(lhs_indirection_level, "dynamic array"); lhs_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); - rhs_current_ref = "dynamic array"; + rhs_ddcs_ref.set_indirection_current(rhs_indirection_level, "dynamic array"); rhs_update_declaration_flag |= true; state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection); - } else if ("dynamic array" == rhs_current_ref) { - lhs_current_ref = rhs_current_ref; + } else if ("dynamic array" == rhs_current_cref) { + lhs_ddcs_ref.set_indirection_current(lhs_indirection_level, rhs_current_cref); lhs_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 if ("native array" == rhs_current_ref) { + } else if ("native array" == rhs_current_cref) { // could be a problem int q = 7; } - } else if ("inferred array" == lhs_current_ref) { - if ("native pointer" == rhs_current_ref) { - rhs_current_ref = lhs_current_ref; + } else if ("inferred array" == lhs_current_cref) { + if ("native pointer" == rhs_current_cref) { + rhs_ddcs_ref.set_indirection_current(rhs_indirection_level, lhs_current_cref); rhs_update_declaration_flag |= true; state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection); - } else if ("malloc target" == rhs_current_ref) { - lhs_current_ref = "dynamic array"; + } else if ("malloc target" == rhs_current_cref) { + lhs_ddcs_ref.set_indirection_current(lhs_indirection_level, "dynamic array"); lhs_update_declaration_flag |= true; state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection2); - rhs_current_ref = "dynamic array"; + rhs_ddcs_ref.set_indirection_current(rhs_indirection_level, "dynamic array"); rhs_update_declaration_flag |= true; state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection); state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection); - } else if ("inferred array" == rhs_current_ref) { - } else if ("dynamic array" == rhs_current_ref) { - lhs_current_ref = rhs_current_ref; + } else if ("inferred array" == rhs_current_cref) { + } else if ("dynamic array" == rhs_current_cref) { + lhs_ddcs_ref.set_indirection_current(lhs_indirection_level, rhs_current_cref); lhs_update_declaration_flag |= true; state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection2); - } else if ("native array" == rhs_current_ref) { - lhs_current_ref = rhs_current_ref; + } else if ("native array" == rhs_current_cref) { + lhs_ddcs_ref.set_indirection_current(lhs_indirection_level, rhs_current_cref); lhs_update_declaration_flag |= true; } - } else if ("dynamic array" == lhs_current_ref) { - if ("native pointer" == rhs_current_ref) { - rhs_current_ref = lhs_current_ref; + } else if ("dynamic array" == lhs_current_cref) { + if ("native pointer" == rhs_current_cref) { + rhs_ddcs_ref.set_indirection_current(rhs_indirection_level, lhs_current_cref); rhs_update_declaration_flag |= true; state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection); state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection); - } else if ("malloc target" == rhs_current_ref) { - rhs_current_ref = lhs_current_ref; + } else if ("malloc target" == rhs_current_cref) { + rhs_ddcs_ref.set_indirection_current(rhs_indirection_level, lhs_current_cref); rhs_update_declaration_flag |= true; state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection); state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection); - } else if ("inferred array" == rhs_current_ref) { - rhs_current_ref = lhs_current_ref; + } else if ("inferred array" == rhs_current_cref) { + rhs_ddcs_ref.set_indirection_current(rhs_indirection_level, lhs_current_cref); rhs_update_declaration_flag |= true; state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection); - } else if ("dynamic array" == rhs_current_ref) { - } else if ("native array" == rhs_current_ref) { + } else if ("dynamic array" == rhs_current_cref) { + } else if ("native array" == rhs_current_cref) { // could be a problem int q = 7; } - } else if ("native array" == lhs_current_ref) { - if ("native pointer" == rhs_current_ref) { - rhs_current_ref = lhs_current_ref; + } else if ("native array" == lhs_current_cref) { + if ("native pointer" == rhs_current_cref) { + rhs_ddcs_ref.set_indirection_current(rhs_indirection_level, lhs_current_cref); rhs_update_declaration_flag |= true; state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection); - } else if ("malloc target" == rhs_current_ref) { + } else if ("malloc target" == rhs_current_cref) { // could be a problem int q = 7; - } else if ("inferred array" == rhs_current_ref) { - rhs_current_ref = lhs_current_ref; + } else if ("inferred array" == rhs_current_cref) { + rhs_ddcs_ref.set_indirection_current(rhs_indirection_level, lhs_current_cref); rhs_update_declaration_flag |= true; - } else if ("dynamic array" == rhs_current_ref) { + } else if ("dynamic array" == rhs_current_cref) { // could be a problem int q = 7; - } else if ("native array" == rhs_current_ref) { + } else if ("native array" == rhs_current_cref) { } } } else { @@ -2511,20 +2562,27 @@ void CAssignmentTargetConstrainsAddressofArraySubscriptExprArray2ReplacementActi auto index_expr_cptr = ASE->getIdx(); auto array_expr_cptr = ASE->getBase(); if (index_expr_cptr && array_expr_cptr) { - auto index_expr_SR = nice_source_range(index_expr_cptr->getSourceRange(), (*this).m_Rewrite); - auto array_expr_SR = nice_source_range(array_expr_cptr->getSourceRange(), (*this).m_Rewrite); - if (index_expr_SR.isValid() && array_expr_SR.isValid()) { - std::string index_expr_text = (*this).m_Rewrite.getRewrittenText(index_expr_SR); - std::string array_expr_text = (*this).m_Rewrite.getRewrittenText(array_expr_SR); + auto index_cs_iter = state1.m_expr_conversion_state_map.find(index_expr_cptr); + if (state1.m_expr_conversion_state_map.end() == index_cs_iter) { + std::shared_ptr<CExprConversionState> shptr1 = make_expr_conversion_state_shared_ptr<CExprConversionState>(*index_expr_cptr, m_Rewrite); + index_cs_iter = state1.m_expr_conversion_state_map.insert(shptr1); + } + auto& index_cs_shptr_ref = (*index_cs_iter).second; - std::string UO_replacement_text = "((" + array_expr_text + ") + (" + index_expr_text + "))"; - if (ConvertToSCPP) { - std::shared_ptr<CExprTextModifier> shptr1 = std::make_shared<CStraightReplacementExprTextModifier>(UO_replacement_text); - (*uocs_shptr_ref).m_expr_text_modifier_stack.push_back(shptr1); - (*uocs_shptr_ref).update_current_text(); + auto array_cs_iter = state1.m_expr_conversion_state_map.find(array_expr_cptr); + if (state1.m_expr_conversion_state_map.end() == array_cs_iter) { + std::shared_ptr<CExprConversionState> shptr1 = make_expr_conversion_state_shared_ptr<CExprConversionState>(*array_expr_cptr, m_Rewrite); + array_cs_iter = state1.m_expr_conversion_state_map.insert(shptr1); + } + auto& array_cs_shptr_ref = (*array_cs_iter).second; - (*this).m_Rewrite.ReplaceText(UOSR, (*uocs_shptr_ref).m_current_text_str); - } + std::string UO_replacement_text = "((" + (*array_cs_shptr_ref).m_current_text_str + ") + (" + (*index_cs_shptr_ref).m_current_text_str + "))"; + if (ConvertToSCPP) { + std::shared_ptr<CExprTextModifier> shptr1 = std::make_shared<CStraightReplacementExprTextModifier>(UO_replacement_text); + (*uocs_shptr_ref).m_expr_text_modifier_stack.push_back(shptr1); + (*uocs_shptr_ref).update_current_text(); + + (*this).m_Rewrite.ReplaceText(UOSR, (*uocs_shptr_ref).m_current_text_str); } } @@ -2563,7 +2621,7 @@ void CUpdateIndirectFunctionTypeParamsArray2ReplacementAction::do_replacement(CS if (rhs_res2.ddecl_cptr && rhs_res2.ddecl_conversion_state_ptr) { CIndirectionStateStack indirection_state_stack; for (size_t i = rhs_res2.indirection_level; (*(rhs_res2.ddecl_conversion_state_ptr)).m_indirection_state_stack.size() > i; i += 1) { - indirection_state_stack.push_back((*(rhs_res2.ddecl_conversion_state_ptr)).m_indirection_state_stack[i]); + indirection_state_stack.push_back((*(rhs_res2.ddecl_conversion_state_ptr)).m_indirection_state_stack.at(i)); } auto rhs_direct_qtype = (*(rhs_res2.ddecl_conversion_state_ptr)).m_current_direct_qtype; @@ -2640,13 +2698,13 @@ void CConditionalOperatorReconciliation2ReplacementAction::do_replacement(CState /* 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) { + if ("dynamic array" == ddcs_ref.m_indirection_state_stack.at(0).current()) { lhs_is_dynamic_array = true; lhs_is_array = true; - } else if ("native array" == ddcs_ref.m_indirection_state_stack[0].m_current) { + } else if ("native array" == ddcs_ref.m_indirection_state_stack.at(0).current()) { lhs_is_native_array = true; lhs_is_array = true; - } else if ("inferred array" == ddcs_ref.m_indirection_state_stack[0].m_current) { + } else if ("inferred array" == ddcs_ref.m_indirection_state_stack.at(0).current()) { lhs_is_array = true; } } else { @@ -2662,13 +2720,13 @@ void CConditionalOperatorReconciliation2ReplacementAction::do_replacement(CState auto ddcs_map_iter = res1.first; auto& ddcs_ref = (*ddcs_map_iter).second; if (1 <= ddcs_ref.m_indirection_state_stack.size()) { - if ("dynamic array" == ddcs_ref.m_indirection_state_stack[0].m_current) { + if ("dynamic array" == ddcs_ref.m_indirection_state_stack.at(0).current()) { rhs_is_dynamic_array = true; rhs_is_array = true; - } else if ("native array" == ddcs_ref.m_indirection_state_stack[0].m_current) { + } else if ("native array" == ddcs_ref.m_indirection_state_stack.at(0).current()) { rhs_is_native_array = true; rhs_is_array = true; - } else if ("inferred array" == ddcs_ref.m_indirection_state_stack[0].m_current) { + } else if ("inferred array" == ddcs_ref.m_indirection_state_stack.at(0).current()) { rhs_is_array = true; } } else { @@ -2933,7 +2991,7 @@ public: //bool update_declaration_flag = res1.second; for (size_t i = 0; (i < ddcs_ref.m_indirection_state_stack.size()); i += 1) { - if ("native array" == ddcs_ref.m_indirection_state_stack[i].m_current) { + if ("native array" == ddcs_ref.m_indirection_state_stack.at(i).current()) { m_state1.m_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, i)); } } @@ -3448,17 +3506,17 @@ public: bool update_declaration_flag = res1.second; bool lhs_has_been_determined_to_be_an_array = false; - if ("native pointer" == ddcs_ref.m_indirection_state_stack[0].m_current) { - ddcs_ref.m_indirection_state_stack[0].m_current = "malloc target"; - } else if ("inferred array" == ddcs_ref.m_indirection_state_stack[0].m_current) { - ddcs_ref.m_indirection_state_stack[0].m_current = "dynamic array"; + if ("native pointer" == ddcs_ref.m_indirection_state_stack.at(0).current()) { + ddcs_ref.set_indirection_current(0, "malloc target"); + } else if ("inferred array" == ddcs_ref.m_indirection_state_stack.at(0).current()) { + ddcs_ref.set_indirection_current(0, "dynamic array"); lhs_has_been_determined_to_be_an_array = true; //update_declaration_flag = true; m_state1.m_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(m_state1, CDDeclIndirection(*DD, 0)); - } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[0].m_current) { + } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack.at(0).current()) { lhs_has_been_determined_to_be_an_array = true; } else { - assert("native array" != ddcs_ref.m_indirection_state_stack[0].m_current); + assert("native array" != ddcs_ref.m_indirection_state_stack.at(0).current()); } const clang::Type* TP = QT.getTypePtr(); @@ -4442,7 +4500,7 @@ public: auto ddcs_map_iter = res1.first; auto& ddcs_ref = (*ddcs_map_iter).second; if (1 <= ddcs_ref.m_indirection_state_stack.size()) { - var_current_state_str = ddcs_ref.m_indirection_state_stack[0].m_current; + var_current_state_str = ddcs_ref.m_indirection_state_stack.at(0).current(); } else { int q = 7; } @@ -4550,7 +4608,7 @@ public: auto ddcs_map_iter = res1.first; auto& ddcs_ref = (*ddcs_map_iter).second; if (1 <= ddcs_ref.m_indirection_state_stack.size()) { - lhs_current_state_str = ddcs_ref.m_indirection_state_stack[0].m_current; + lhs_current_state_str = ddcs_ref.m_indirection_state_stack.at(0).current(); } else { int q = 7; } @@ -4561,7 +4619,7 @@ public: auto ddcs_map_iter = res1.first; auto& ddcs_ref = (*ddcs_map_iter).second; if (1 <= ddcs_ref.m_indirection_state_stack.size()) { - rhs_current_state_str = ddcs_ref.m_indirection_state_stack[0].m_current; + rhs_current_state_str = ddcs_ref.m_indirection_state_stack.at(0).current(); } else { int q = 7; } @@ -4732,14 +4790,14 @@ public: } } - size_t lhs_indirection_level_adjustment = 0; + int lhs_indirection_level_adjustment = 0; auto rhs_res3 = leading_addressof_operator_info_from_stmt(*RHS); if (rhs_res3.without_leading_addressof_operator_expr_cptr) { assert(rhs_res3.leading_addressof_operator_detected && rhs_res3.addressof_unary_operator_cptr); RHS = rhs_res3.without_leading_addressof_operator_expr_cptr; rhs_res2 = infer_array_type_info_from_stmt(*RHS, "", (*this).m_state1); - lhs_indirection_level_adjustment = 1; + lhs_indirection_level_adjustment += 1; const clang::ArraySubscriptExpr* array_subscript_expr_cptr = nullptr; if (clang::Stmt::StmtClass::ArraySubscriptExprClass == (*(rhs_res3.without_leading_addressof_operator_expr_cptr)).getStmtClass()) { @@ -4865,23 +4923,33 @@ public: return void(); } - auto function_decls_range = function_decl1->redecls(); + if ("lodepng_crc32" == function_name) { + int q = 5; + } + + std::vector<const clang::ParmVarDecl*> param_decls_of_first_function_decl; + for (auto param_VD : function_decl1->parameters()) { + param_decls_of_first_function_decl.push_back(param_VD); + } + auto function_decls_range = function_decl1->redecls(); for (const auto& function_decl : function_decls_range) { + auto fdecl_source_range = nice_source_range(function_decl->getSourceRange(), Rewrite); + auto fdecl_source_location_str = fdecl_source_range.getBegin().printToString(*MR.SourceManager); + auto param_iter = function_decl->param_begin(); auto arg_iter = CE->arg_begin(); - for (; (arg_iter != CE->arg_end()) && (param_iter != function_decl->param_end()); - arg_iter++, param_iter++) { - assert((*arg_iter)->getType().getTypePtrOrNull()); - auto arg_source_range = nice_source_range((*arg_iter)->getSourceRange(), Rewrite); + for (size_t arg_index = 0; (CE->getNumArgs() > arg_index) && (function_decl->getNumParams() > arg_index); arg_index += 1) { + auto param_VD = function_decl->getParamDecl(arg_index); + auto arg_EX = CE->getArg(arg_index); + + assert(arg_EX->getType().getTypePtrOrNull()); + auto arg_source_range = nice_source_range(arg_EX->getSourceRange(), Rewrite); std::string arg_source_text; if (arg_source_range.isValid()) { arg_source_text = Rewrite.getRewrittenText(arg_source_range); } - auto param_VD = (*param_iter)->getDefinition(); - auto arg_EX = (*arg_iter); - if ((nullptr != param_VD) && (nullptr != arg_EX) && arg_source_range.isValid()) { bool lhs_is_an_indirect_type = is_an_indirect_type(param_VD->getType()); bool rhs_is_an_indirect_type = is_an_indirect_type(arg_EX->getType()); @@ -4990,13 +5058,13 @@ public: } } - size_t lhs_indirection_level_adjustment = 0; + int lhs_indirection_level_adjustment = 0; auto rhs_res3 = leading_addressof_operator_info_from_stmt(*arg_EX); if (rhs_res3.without_leading_addressof_operator_expr_cptr) { assert(rhs_res3.leading_addressof_operator_detected && rhs_res3.addressof_unary_operator_cptr); arg_EX = rhs_res3.without_leading_addressof_operator_expr_cptr; - lhs_indirection_level_adjustment = 1; + lhs_indirection_level_adjustment += 1; const clang::ArraySubscriptExpr* array_subscript_expr_cptr = nullptr; if (clang::Stmt::StmtClass::ArraySubscriptExprClass == (*(rhs_res3.without_leading_addressof_operator_expr_cptr)).getStmtClass()) { @@ -5025,7 +5093,8 @@ public: } if (ConvertToSCPP && (rhs_res2.ddecl_conversion_state_ptr) && lhs_is_an_indirect_type) { - int max_indirection_level1 = int((*(rhs_res2.ddecl_conversion_state_ptr)).m_indirection_state_stack.size()) - int(rhs_res2.indirection_level); + int max_indirection_level1 = int((*(rhs_res2.ddecl_conversion_state_ptr)).m_indirection_state_stack.size()) + - int(rhs_res2.indirection_level); int int_max_indirection_level = std::min(int(ddcs_ref.m_indirection_state_stack.size()) - int(lhs_indirection_level_adjustment), max_indirection_level1); size_t szt_max_indirection_level = 0; if (0 <= int_max_indirection_level) { @@ -5081,6 +5150,53 @@ public: } } } + + if (function_decl1 != function_decl) { + assert(arg_index < param_decls_of_first_function_decl.size()); + auto param_VD_of_first_function_decl = param_decls_of_first_function_decl.at(arg_index); + + auto res1_ffd = m_state1.m_ddecl_conversion_state_map.insert(*param_VD_of_first_function_decl); + auto ddcs_map_iter_ffd = res1_ffd.first; + auto& ddcs_ref_ffd = (*ddcs_map_iter_ffd).second; + + if (ddcs_ref.m_indirection_state_stack.size() != ddcs_ref_ffd.m_indirection_state_stack.size()) { + int q = 7; + } + for (size_t i = 0; (i < ddcs_ref.m_indirection_state_stack.size()) && (i < ddcs_ref_ffd.m_indirection_state_stack.size()); i += 1) { + { + /* Here we're establishing and "enforcing" the constraint that the current parameter must + * be of the same type as the corresponding parameter in the first declaration of this function. */ + std::shared_ptr<CArray2ReplacementAction> cr_shptr = std::make_shared<CSameTypeArray2ReplacementAction>(Rewrite, MR, + CDDeclIndirection(*param_VD, i), CDDeclIndirection(*param_VD_of_first_function_decl, i)); + + if (ddcs_ref.has_been_determined_to_be_an_array(i)) { + (*cr_shptr).do_replacement(m_state1); + if (!(ddcs_ref.has_been_determined_to_be_a_dynamic_array(i))) { + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + } + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + } + } + { + /* Here we're establishing the constraint in the opposite direction as well. */ + std::shared_ptr<CArray2ReplacementAction> cr_shptr = std::make_shared<CSameTypeArray2ReplacementAction>(Rewrite, MR, + CDDeclIndirection(*param_VD_of_first_function_decl, i), CDDeclIndirection(*param_VD, i)); + + if (ddcs_ref_ffd.has_been_determined_to_be_an_array(i)) { + (*cr_shptr).do_replacement(m_state1); + if (!(ddcs_ref_ffd.has_been_determined_to_be_a_dynamic_array(i))) { + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + } + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + } + } + } + } + } } else { int q = 5; @@ -5241,13 +5357,13 @@ public: } else { assert(false); } } - size_t lhs_indirection_level_adjustment = 0; + int lhs_indirection_level_adjustment = 0; auto rhs_res3 = leading_addressof_operator_info_from_stmt(*retval_EX); if (rhs_res3.without_leading_addressof_operator_expr_cptr) { assert(rhs_res3.leading_addressof_operator_detected && rhs_res3.addressof_unary_operator_cptr); retval_EX = rhs_res3.without_leading_addressof_operator_expr_cptr; - lhs_indirection_level_adjustment = 1; + lhs_indirection_level_adjustment += 1; } auto rhs_res2 = infer_array_type_info_from_stmt(*(retval_EX), "", (*this).m_state1); @@ -5287,7 +5403,8 @@ public: } if (ConvertToSCPP && (rhs_res2.ddecl_conversion_state_ptr) && lhs_is_an_indirect_type) { - int max_indirection_level1 = int((*(rhs_res2.ddecl_conversion_state_ptr)).m_indirection_state_stack.size()) - int(rhs_res2.indirection_level); + int max_indirection_level1 = int((*(rhs_res2.ddecl_conversion_state_ptr)).m_indirection_state_stack.size()) + - int(rhs_res2.indirection_level); int int_max_indirection_level = std::min(int(ddcs_ref.m_indirection_state_stack.size()) - int(lhs_indirection_level_adjustment), max_indirection_level1); size_t szt_max_indirection_level = 0; if (0 <= int_max_indirection_level) { @@ -5343,6 +5460,50 @@ public: } } } + + if (function_decl1 != function_decl) { + auto res1_ffd = m_state1.m_ddecl_conversion_state_map.insert(*function_decl1); + auto ddcs_map_iter_ffd = res1_ffd.first; + auto& ddcs_ref_ffd = (*ddcs_map_iter_ffd).second; + + if (ddcs_ref.m_indirection_state_stack.size() != ddcs_ref_ffd.m_indirection_state_stack.size()) { + int q = 7; + } + for (size_t i = 0; (i < ddcs_ref.m_indirection_state_stack.size()) && (i < ddcs_ref_ffd.m_indirection_state_stack.size()); i += 1) { + { + /* Here we're establishing and "enforcing" the constraint that the current parameter must + * be of the same type as the corresponding parameter in the first declaration of this function. */ + std::shared_ptr<CArray2ReplacementAction> cr_shptr = std::make_shared<CSameTypeArray2ReplacementAction>(Rewrite, MR, + CDDeclIndirection(*function_decl, i), CDDeclIndirection(*function_decl1, i)); + + if (ddcs_ref.has_been_determined_to_be_an_array(i)) { + (*cr_shptr).do_replacement(m_state1); + if (!(ddcs_ref.has_been_determined_to_be_a_dynamic_array(i))) { + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + } + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + } + } + { + /* Here we're establishing the constraint in the opposite direction as well. */ + std::shared_ptr<CArray2ReplacementAction> cr_shptr = std::make_shared<CSameTypeArray2ReplacementAction>(Rewrite, MR, + CDDeclIndirection(*function_decl1, i), CDDeclIndirection(*function_decl, i)); + + if (ddcs_ref_ffd.has_been_determined_to_be_an_array(i)) { + (*cr_shptr).do_replacement(m_state1); + if (!(ddcs_ref_ffd.has_been_determined_to_be_a_dynamic_array(i))) { + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + } + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + } + } + } + } + } } |