diff options
Diffstat (limited to 'safercpp/safercpp-arr.cpp')
| -rw-r--r-- | safercpp/safercpp-arr.cpp | 984 |
1 files changed, 646 insertions, 338 deletions
diff --git a/safercpp/safercpp-arr.cpp b/safercpp/safercpp-arr.cpp index 28419a1..750d393 100644 --- a/safercpp/safercpp-arr.cpp +++ b/safercpp/safercpp-arr.cpp @@ -214,14 +214,6 @@ static std::vector<std::string> f_declared_object_strings(const std::string& dec return retval; } -class CState1; - -class CReplacementAction { -public: - virtual ~CReplacementAction() {} - virtual void do_replacement(CState1& state1) const = 0; -}; - std::string tolowerstr(const std::string& a) { std::string retval; for (const auto& ch : a) { @@ -230,6 +222,10 @@ std::string tolowerstr(const std::string& a) { return retval; } +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) { @@ -295,197 +291,6 @@ public: size_t m_indirection_level = 0; }; -class CDDecl2ReplacementAction : public CReplacementAction { -public: - CDDecl2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, - const CDDeclIndirection& ddecl_indirection) : m_Rewrite(Rewrite), m_MR(MR), m_ddecl_indirection(ddecl_indirection) {} - virtual ~CDDecl2ReplacementAction() {} - - virtual void do_replacement(CState1& state1) const = 0; - virtual const clang::DeclaratorDecl* get_ddecl_cptr() const { return m_ddecl_indirection.m_ddecl_cptr; } - virtual const CDDeclIndirection& ddecl_indirection_cref() const { return m_ddecl_indirection; } - - clang::SourceRange source_range() { - clang::SourceRange retval = m_ddecl_indirection.m_ddecl_cptr->getSourceRange(); - return retval; - } - clang::SourceLocation start_location() { - clang::SourceLocation retval = source_range().getBegin(); - return retval; - } - std::string get_var_name() { - std::string retval = m_ddecl_indirection.m_ddecl_cptr->getNameAsString(); - return retval; - } - - Rewriter& m_Rewrite; - const MatchFinder::MatchResult m_MR; - CDDeclIndirection m_ddecl_indirection; -}; - -class CArray2ReplacementAction : public CDDecl2ReplacementAction { -public: - using CDDecl2ReplacementAction::CDDecl2ReplacementAction; - virtual ~CArray2ReplacementAction() {} -}; - -class CMemsetArray2ReplacementAction : public CArray2ReplacementAction { -public: - CMemsetArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, - const CallExpr* CE, const std::string& ce_replacement_code) : - CArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr), - m_ce_replacement_code(ce_replacement_code) {} - virtual ~CMemsetArray2ReplacementAction() {} - - virtual void do_replacement(CState1& state1) const; - - const CallExpr* m_CE = nullptr; - //const DeclRefExpr* m_DRE = nullptr; - //const MemberExpr* m_ME = nullptr; - const DeclaratorDecl* m_DD = nullptr; - std::string m_ce_replacement_code; -}; - -class CMemcpyArray2ReplacementAction : public CArray2ReplacementAction { -public: - CMemcpyArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, - const CallExpr* CE, const std::string& ce_replacement_code) : - CArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr), - m_ce_replacement_code(ce_replacement_code) {} - virtual ~CMemcpyArray2ReplacementAction() {} - - virtual void do_replacement(CState1& state1) const; - - const CallExpr* m_CE = nullptr; - //const DeclRefExpr* m_DRE = nullptr; - //const MemberExpr* m_ME = nullptr; - const DeclaratorDecl* m_DD = nullptr; - std::string m_ce_replacement_code; -}; - -class CAssignedFromArray2ReplacementAction : public CArray2ReplacementAction { -public: - CAssignedFromArray2ReplacementAction(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 void do_replacement(CState1& state1) const; - - const CDDeclIndirection m_ddecl_indirection2; -}; - -class CDDecl2ReplacementActionMap : public std::multimap<CDDeclIndirection, std::shared_ptr<CDDecl2ReplacementAction>> { -public: - typedef std::multimap<CDDeclIndirection, std::shared_ptr<CDDecl2ReplacementAction>> base_class; - iterator insert( const std::shared_ptr<CDDecl2ReplacementAction>& cr_shptr ) { - iterator retval(end()); - if (!cr_shptr) { assert(false); } else { - value_type val((*cr_shptr).ddecl_indirection_cref(), cr_shptr); - retval = base_class::insert(val); - } - return retval; - } - void do_and_dispose_matching_replacements(CState1& state1, const CDDeclIndirection& ddecl_indirection) { - /* The base class map may be modified during loop iterations. Maybe. */ - auto iter = base_class::find(ddecl_indirection); - while (base_class::end() != iter) { - (*((*iter).second)).do_replacement(state1); - base_class::erase(iter); - - iter = base_class::find(ddecl_indirection); - } - } -}; - -class CDynamicArray2ReplacementAction : public CArray2ReplacementAction { -public: - using CArray2ReplacementAction::CArray2ReplacementAction; - virtual ~CDynamicArray2ReplacementAction() {} -}; - -class CMallocArray2ReplacementAction : public CDynamicArray2ReplacementAction { -public: - CMallocArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, - const BinaryOperator* BO, const std::string& bo_replacement_code) : - CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_BO(BO), m_DD(ddecl_indirection.m_ddecl_cptr), - m_bo_replacement_code(bo_replacement_code) {} - virtual ~CMallocArray2ReplacementAction() {} - - 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; -}; - -class CMallocInitializerArray2ReplacementAction : public CDynamicArray2ReplacementAction { -public: - CMallocInitializerArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, - const DeclStmt* DS, const std::string& initializer_info_str) : - CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_DS(DS), m_DD(ddecl_indirection.m_ddecl_cptr), - m_initializer_info_str(initializer_info_str) {} - virtual ~CMallocInitializerArray2ReplacementAction() {} - - virtual void do_replacement(CState1& state1) const; - - const DeclStmt* m_DS = nullptr; - //const CallExpr* m_CE = nullptr; - const DeclaratorDecl* m_DD = nullptr; - std::string m_initializer_info_str; -}; - -class CFreeDynamicArray2ReplacementAction : public CDynamicArray2ReplacementAction { -public: - CFreeDynamicArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, - const CallExpr* CE, const std::string& ce_replacement_code) : - CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr), - m_ce_replacement_code(ce_replacement_code) {} - virtual ~CFreeDynamicArray2ReplacementAction() {} - - virtual void do_replacement(CState1& state1) const; - - const CallExpr* m_CE = nullptr; - //const DeclRefExpr* m_DRE = nullptr; - //const MemberExpr* m_ME = nullptr; - const DeclaratorDecl* m_DD = nullptr; - std::string m_ce_replacement_code; -}; - -class CSetArrayPointerToNull2ReplacementAction : public CDynamicArray2ReplacementAction { -public: - CSetArrayPointerToNull2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, - const BinaryOperator* BO, const std::string& bo_replacement_code) : - CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_BO(BO), m_DD(ddecl_indirection.m_ddecl_cptr), - m_bo_replacement_code(bo_replacement_code) {} - virtual ~CSetArrayPointerToNull2ReplacementAction() {} - - virtual void do_replacement(CState1& state1) const; - - const BinaryOperator* m_BO = nullptr; - //const DeclRefExpr* m_DRE = nullptr; - //const MemberExpr* m_ME = nullptr; - const DeclaratorDecl* m_DD = nullptr; - std::string m_bo_replacement_code; -}; - -class CDynamicArray2ReplacementActionMap : public CDDecl2ReplacementActionMap { -public: - iterator insert( const std::shared_ptr<CDynamicArray2ReplacementAction>& cr_shptr ) { - return CDDecl2ReplacementActionMap::insert(static_cast<std::shared_ptr<CDDecl2ReplacementAction> >(cr_shptr)); - } -}; - -class CArray2ReplacementActionMap : public CDDecl2ReplacementActionMap { -public: - iterator insert( const std::shared_ptr<CArray2ReplacementAction>& cr_shptr ) { - return CDDecl2ReplacementActionMap::insert(static_cast<std::shared_ptr<CDDecl2ReplacementAction> >(cr_shptr)); - } -}; - class CIndirectionState { public: CIndirectionState(std::string original, std::string current) @@ -740,6 +545,8 @@ public: std::string m_initializer_info_str; bool m_original_initialization_has_been_noted = false; std::string m_original_initialization_expr_str; + bool m_original_source_text_has_been_noted = false; + std::string m_original_source_text_str; }; class CDDeclConversionStateMap : public std::map<const clang::DeclaratorDecl*, CDDeclConversionState> { @@ -750,6 +557,223 @@ public: } }; + +class CState1; + +class CReplacementAction { +public: + virtual ~CReplacementAction() {} + virtual void do_replacement(CState1& state1) const = 0; +}; + +class CDDecl2ReplacementAction : public CReplacementAction { +public: + CDDecl2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, + const CDDeclIndirection& ddecl_indirection) : m_Rewrite(Rewrite), m_MR(MR), m_ddecl_indirection(ddecl_indirection) {} + virtual ~CDDecl2ReplacementAction() {} + + virtual void do_replacement(CState1& state1) const = 0; + virtual const clang::DeclaratorDecl* get_ddecl_cptr() const { return m_ddecl_indirection.m_ddecl_cptr; } + virtual const CDDeclIndirection& ddecl_indirection_cref() const { return m_ddecl_indirection; } + + clang::SourceRange source_range() { + clang::SourceRange retval = m_ddecl_indirection.m_ddecl_cptr->getSourceRange(); + return retval; + } + clang::SourceLocation start_location() { + clang::SourceLocation retval = source_range().getBegin(); + return retval; + } + std::string get_var_name() { + std::string retval = m_ddecl_indirection.m_ddecl_cptr->getNameAsString(); + return retval; + } + + Rewriter& m_Rewrite; + const MatchFinder::MatchResult m_MR; + CDDeclIndirection m_ddecl_indirection; +}; + +class CArray2ReplacementAction : public CDDecl2ReplacementAction { +public: + using CDDecl2ReplacementAction::CDDecl2ReplacementAction; + virtual ~CArray2ReplacementAction() {} +}; + +class CMemsetArray2ReplacementAction : public CArray2ReplacementAction { +public: + CMemsetArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, + const CallExpr* CE, const std::string& ce_replacement_code) : + CArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr), + m_ce_replacement_code(ce_replacement_code) {} + virtual ~CMemsetArray2ReplacementAction() {} + + virtual void do_replacement(CState1& state1) const; + + const CallExpr* m_CE = nullptr; + //const DeclRefExpr* m_DRE = nullptr; + //const MemberExpr* m_ME = nullptr; + const DeclaratorDecl* m_DD = nullptr; + std::string m_ce_replacement_code; +}; + +class CMemcpyArray2ReplacementAction : public CArray2ReplacementAction { +public: + CMemcpyArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, + const CallExpr* CE, const std::string& ce_replacement_code) : + CArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr), + m_ce_replacement_code(ce_replacement_code) {} + virtual ~CMemcpyArray2ReplacementAction() {} + + virtual void do_replacement(CState1& state1) const; + + const CallExpr* m_CE = nullptr; + //const DeclRefExpr* m_DRE = nullptr; + //const MemberExpr* m_ME = nullptr; + const DeclaratorDecl* m_DD = nullptr; + std::string m_ce_replacement_code; +}; + +class CAssignedFromArray2ReplacementAction : public CArray2ReplacementAction { +public: + CAssignedFromArray2ReplacementAction(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 void do_replacement(CState1& state1) const; + + const CDDeclIndirection m_ddecl_indirection2; +}; + +class CDDecl2ReplacementActionMap : public std::multimap<CDDeclIndirection, std::shared_ptr<CDDecl2ReplacementAction>> { +public: + typedef std::multimap<CDDeclIndirection, std::shared_ptr<CDDecl2ReplacementAction>> base_class; + iterator insert( const std::shared_ptr<CDDecl2ReplacementAction>& cr_shptr ) { + iterator retval(end()); + if (!cr_shptr) { assert(false); } else { + value_type val((*cr_shptr).ddecl_indirection_cref(), cr_shptr); + retval = base_class::insert(val); + } + return retval; + } + void do_and_dispose_matching_replacements(CState1& state1, const CDDeclIndirection& ddecl_indirection) { + /* The base class map may be modified during loop iterations. Maybe. */ + auto iter = base_class::find(ddecl_indirection); + while (base_class::end() != iter) { + (*((*iter).second)).do_replacement(state1); + base_class::erase(iter); + + iter = base_class::find(ddecl_indirection); + } + } +}; + +class CDynamicArray2ReplacementAction : public CArray2ReplacementAction { +public: + using CArray2ReplacementAction::CArray2ReplacementAction; + virtual ~CDynamicArray2ReplacementAction() {} +}; + +class CMallocArray2ReplacementAction : public CDynamicArray2ReplacementAction { +public: + CMallocArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, + const BinaryOperator* BO, const std::string& bo_replacement_code) : + CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_BO(BO), m_DD(ddecl_indirection.m_ddecl_cptr), + m_bo_replacement_code(bo_replacement_code) {} + virtual ~CMallocArray2ReplacementAction() {} + + 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; +}; + +class CMallocInitializerArray2ReplacementAction : public CDynamicArray2ReplacementAction { +public: + CMallocInitializerArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, + const DeclStmt* DS, const std::string& initializer_info_str) : + CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_DS(DS), m_DD(ddecl_indirection.m_ddecl_cptr), + m_initializer_info_str(initializer_info_str) {} + virtual ~CMallocInitializerArray2ReplacementAction() {} + + virtual void do_replacement(CState1& state1) const; + + const DeclStmt* m_DS = nullptr; + //const CallExpr* m_CE = nullptr; + const DeclaratorDecl* m_DD = nullptr; + std::string m_initializer_info_str; +}; + +class CFreeDynamicArray2ReplacementAction : public CDynamicArray2ReplacementAction { +public: + CFreeDynamicArray2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, + const CallExpr* CE, const std::string& ce_replacement_code) : + CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CE(CE), m_DD(ddecl_indirection.m_ddecl_cptr), + m_ce_replacement_code(ce_replacement_code) {} + virtual ~CFreeDynamicArray2ReplacementAction() {} + + virtual void do_replacement(CState1& state1) const; + + const CallExpr* m_CE = nullptr; + //const DeclRefExpr* m_DRE = nullptr; + //const MemberExpr* m_ME = nullptr; + const DeclaratorDecl* m_DD = nullptr; + std::string m_ce_replacement_code; +}; + +class CSetArrayPointerToNull2ReplacementAction : public CDynamicArray2ReplacementAction { +public: + CSetArrayPointerToNull2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, + const BinaryOperator* BO, const std::string& bo_replacement_code) : + CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_BO(BO), m_DD(ddecl_indirection.m_ddecl_cptr), + m_bo_replacement_code(bo_replacement_code) {} + virtual ~CSetArrayPointerToNull2ReplacementAction() {} + + virtual void do_replacement(CState1& state1) const; + + const BinaryOperator* m_BO = nullptr; + //const DeclRefExpr* m_DRE = nullptr; + //const MemberExpr* m_ME = nullptr; + const DeclaratorDecl* m_DD = nullptr; + std::string m_bo_replacement_code; +}; + +/* This class represents and "enforces" the constraint that the lhs and rhs + * values of a conditional operator must be the same type. */ +class CConditionalOperatorReconciliation2ReplacementAction : public CDynamicArray2ReplacementAction { +public: + CConditionalOperatorReconciliation2ReplacementAction(Rewriter &Rewrite, const MatchFinder::MatchResult &MR, const CDDeclIndirection& ddecl_indirection, + const clang::ConditionalOperator* CO, const DeclaratorDecl* lhs_DD, const DeclaratorDecl* rhs_DD, const DeclaratorDecl* var_DD = nullptr) : + CDynamicArray2ReplacementAction(Rewrite, MR, ddecl_indirection), m_CO(CO), m_lhs_DD(lhs_DD), m_rhs_DD(rhs_DD), m_var_DD(var_DD) {} + virtual ~CConditionalOperatorReconciliation2ReplacementAction() {} + + virtual void do_replacement(CState1& state1) const; + + const clang::ConditionalOperator* m_CO = nullptr; + const DeclaratorDecl* m_lhs_DD = nullptr; + const DeclaratorDecl* m_rhs_DD = nullptr; + const DeclaratorDecl* m_var_DD = nullptr; +}; + +class CDynamicArray2ReplacementActionMap : public CDDecl2ReplacementActionMap { +public: + iterator insert( const std::shared_ptr<CDynamicArray2ReplacementAction>& cr_shptr ) { + return CDDecl2ReplacementActionMap::insert(static_cast<std::shared_ptr<CDDecl2ReplacementAction> >(cr_shptr)); + } +}; + +class CArray2ReplacementActionMap : public CDDecl2ReplacementActionMap { +public: + iterator insert( const std::shared_ptr<CArray2ReplacementAction>& cr_shptr ) { + return CDDecl2ReplacementActionMap::insert(static_cast<std::shared_ptr<CDDecl2ReplacementAction> >(cr_shptr)); + } +}; + class CState1 { public: /* This container holds (potential) actions that are meant to be executed if/when @@ -773,6 +797,14 @@ public: static CDeclarationReplacementCodeItem generate_declaration_replacement_code(const DeclaratorDecl* DD, Rewriter &Rewrite, CDDeclConversionStateMap& ddecl_conversion_state_map, std::string options_str = "") { CDeclarationReplacementCodeItem retval; + if (!DD) { + return retval; + } + auto decl_source_range = nice_source_range(DD->getSourceRange(), Rewrite); + if (!(decl_source_range.isValid())) { + return retval; + } + auto res1 = ddecl_conversion_state_map.insert(*DD); auto ddcs_map_iter = res1.first; auto& ddcs_ref = (*ddcs_map_iter).second; @@ -786,6 +818,11 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con } else if ("const _Bool" == direct_qtype_str) { direct_qtype_str = "const bool"; } + auto direct_TP = ddcs_ref.m_direct_qtype.getTypePtr(); + if (!direct_TP) { + return retval; + } + bool direct_type_is_function_type = direct_TP->isFunctionType(); std::string variable_name = DD->getNameAsString(); std::string identifier_name_str; @@ -797,6 +834,13 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con int q = 7; } + if (!(ddcs_ref.m_original_source_text_has_been_noted)) { + ddcs_ref.m_original_source_text_str = Rewrite.getRewrittenText(decl_source_range); + ddcs_ref.m_original_source_text_has_been_noted = true; + } + + clang::StorageClass storage_class = clang::StorageClass::SC_None; + bool is_extern = false; clang::StorageDuration storage_duration = clang::StorageDuration::SD_Automatic; bool has_dynamic_storage_duration = false; bool is_a_temporary = false; @@ -805,14 +849,21 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con bool is_member = false; bool is_vardecl = false; std::string initialization_expr_str; + bool is_function = DD->isFunctionOrFunctionTemplate(); auto VD = dynamic_cast<const clang::VarDecl *>(DD); if (VD) { is_vardecl = true; + storage_class = VD->getStorageClass(); + is_extern = (clang::StorageClass::SC_Extern == storage_class); 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_static = (clang::StorageDuration::SD_Static == storage_duration); + is_static = (clang::StorageClass::SC_Static == storage_class); + if ((clang::StorageDuration::SD_Static == storage_duration) && (!is_static)) { + int q = 5; + } is_a_function_parameter = (VD->isLocalVarDeclOrParm() && (!VD->isLocalVarDecl())); if (ddcs_ref.m_original_initialization_has_been_noted) { @@ -880,142 +931,177 @@ static CDeclarationReplacementCodeItem generate_declaration_replacement_code(con } ddcs_ref.m_original_initialization_has_been_noted = true; + bool changed_from_original = false; std::string replacement_code; std::string prefix_str; std::string suffix_str; - for (size_t i = 0; i < ddcs_ref.m_indirection_state_stack.size(); i += 1) { - bool is_char_star = false; - bool is_last_indirection = (ddcs_ref.m_indirection_state_stack.size() == (i+1)); - if (is_last_indirection && (("char" == direct_qtype_str) || ("const char" == direct_qtype_str))) { - is_char_star = true; - } - if ("inferred array" == ddcs_ref.m_indirection_state_stack[i].m_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. */ - //prefix_str = prefix_str + ""; - suffix_str = "* " + suffix_str; - retval.m_action_species = "char*"; - } else { - prefix_str = prefix_str + "mse::TNullableAnyRandomAccessIterator<"; - suffix_str = "> " + suffix_str; - retval.m_action_species = "native pointer to TNullableAnyRandomAccessIterator"; - } - } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_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. */ - //prefix_str = prefix_str + ""; - suffix_str = "* " + suffix_str; - retval.m_action_species = "char*"; - } else { - prefix_str = prefix_str + "mse::TIPointerWithBundledVector<"; - if (is_a_function_parameter) { - suffix_str = "> " + suffix_str; - retval.m_action_species = "native pointer parameter to TIPointerWithBundledVector"; + if (true) { + for (size_t i = 0; i < ddcs_ref.m_indirection_state_stack.size(); i += 1) { + bool is_char_star = false; + bool is_function_pointer = false; + bool is_last_indirection = (ddcs_ref.m_indirection_state_stack.size() == (i+1)); + if (is_last_indirection && (("char" == direct_qtype_str) || ("const char" == direct_qtype_str))) { + is_char_star = true; + } else if (is_last_indirection && direct_type_is_function_type) { + is_function_pointer = true; + } + if ("inferred array" == ddcs_ref.m_indirection_state_stack[i].m_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. */ + //prefix_str = prefix_str + ""; + suffix_str = "* " + suffix_str; + retval.m_action_species = "char*"; } else { + prefix_str = prefix_str + "mse::TNullableAnyRandomAccessIterator<"; suffix_str = "> " + suffix_str; - retval.m_action_species = "native pointer to TIPointerWithBundledVector"; + retval.m_action_species = "native pointer to TNullableAnyRandomAccessIterator"; } - } - } else if ("native array" == ddcs_ref.m_indirection_state_stack[i].m_current) { - std::string size_text; - if (TP->isVariableArrayType()) { - auto VATP = llvm::cast<const clang::VariableArrayType>(TP); - if (!VATP) { - assert(false); + } else if ("dynamic array" == ddcs_ref.m_indirection_state_stack[i].m_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. */ + //prefix_str = prefix_str + ""; + suffix_str = "* " + suffix_str; + retval.m_action_species = "char*"; } else { - auto size_expr = VATP->getSizeExpr(); - auto SR = nice_source_range(size_expr->getSourceRange(), Rewrite); - size_text = Rewrite.getRewrittenText(SR); + prefix_str = prefix_str + "mse::TIPointerWithBundledVector<"; + if (is_a_function_parameter) { + suffix_str = "> " + suffix_str; + retval.m_action_species = "native pointer parameter to TIPointerWithBundledVector"; + } else { + suffix_str = "> " + suffix_str; + retval.m_action_species = "native pointer to TIPointerWithBundledVector"; + } } - } else if (TP->isConstantArrayType()) { - auto CATP = llvm::cast<const clang::ConstantArrayType>(TP); - if (!CATP) { - assert(false); - } else { - auto array_size = CATP->getSize(); - size_text = array_size.toString(10, false);/*check this*/ - - if (false) { - auto DDSR = nice_source_range(DD->getSourceRange(), Rewrite); - std::string array_size_expression_text; - std::string source_text; - if (DDSR.isValid()) { - source_text = Rewrite.getRewrittenText(DDSR); - - 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)); - int q = 3; + } else if ("native array" == ddcs_ref.m_indirection_state_stack[i].m_current) { + std::string size_text; + if (TP->isVariableArrayType()) { + auto VATP = llvm::cast<const clang::VariableArrayType>(TP); + if (!VATP) { + assert(false); + } else { + auto size_expr = VATP->getSizeExpr(); + auto SR = nice_source_range(size_expr->getSourceRange(), Rewrite); + size_text = Rewrite.getRewrittenText(SR); + } + } else if (TP->isConstantArrayType()) { + auto CATP = llvm::cast<const clang::ConstantArrayType>(TP); + if (!CATP) { + assert(false); + } else { + auto array_size = CATP->getSize(); + size_text = array_size.toString(10, false);/*check this*/ + + if (false) { + auto DDSR = nice_source_range(DD->getSourceRange(), Rewrite); + std::string array_size_expression_text; + std::string source_text; + if (DDSR.isValid()) { + source_text = Rewrite.getRewrittenText(DDSR); + + 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)); + int q = 3; + } else { + int q = 7; + } } else { - int q = 7; + int q = 5; } - } else { - int q = 5; } } } - } - 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. */ - //prefix_str = prefix_str + ""; - suffix_str = "[" + size_text + "]" + suffix_str; - } else { - if (is_a_function_parameter) { - prefix_str = prefix_str + "mse::TNullableAnyRandomAccessIterator<"; - suffix_str = ", " + size_text + "> " + suffix_str; - retval.m_action_species = "native array parameter to TNullableAnyRandomAccessIterator"; + 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. */ + //prefix_str = prefix_str + ""; + suffix_str = "[" + size_text + "]" + suffix_str; } else { - prefix_str = prefix_str + "mse::TIteratorWithBundledArray<"; - suffix_str = ", " + size_text + "> " + suffix_str; - retval.m_action_species = "native array to TIteratorWithBundledArray"; + if (is_a_function_parameter) { + prefix_str = prefix_str + "mse::TNullableAnyRandomAccessIterator<"; + suffix_str = ", " + size_text + "> " + suffix_str; + retval.m_action_species = "native array parameter to TNullableAnyRandomAccessIterator"; + } else { + prefix_str = prefix_str + "mse::TIteratorWithBundledArray<"; + suffix_str = ", " + size_text + "> " + suffix_str; + retval.m_action_species = "native array to TIteratorWithBundledArray"; + } } - } - } else if ("native pointer" == ddcs_ref.m_indirection_state_stack[i].m_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. */ - //prefix_str = prefix_str + ""; - suffix_str = "* " + suffix_str; - retval.m_action_species = "char*"; - } else { - if (false/*for now*/) { - prefix_str = prefix_str + "mse::TAnyPointer<"; - suffix_str = "> " + suffix_str; - retval.m_action_species = "native pointer to TAnyPointer"; - } else { + } else if ("native pointer" == ddcs_ref.m_indirection_state_stack[i].m_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. */ //prefix_str = prefix_str + ""; suffix_str = "* " + suffix_str; - retval.m_action_species = "native pointer"; + retval.m_action_species = "char*"; + } else if (is_function_pointer) { + prefix_str = prefix_str + "std::function<"; + suffix_str = "> " + suffix_str; + retval.m_action_species = "function pointer to std::function"; + } else { + if (false/*for now*/) { + prefix_str = prefix_str + "mse::TAnyPointer<"; + suffix_str = "> " + suffix_str; + retval.m_action_species = "native pointer to TAnyPointer"; + } else { + //prefix_str = prefix_str + ""; + suffix_str = "* " + suffix_str; + retval.m_action_species = "native pointer"; + } } + } else if ("malloc target" == ddcs_ref.m_indirection_state_stack[i].m_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; + retval.m_action_species = "malloc target"; } - } else if ("malloc target" == ddcs_ref.m_indirection_state_stack[i].m_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; - retval.m_action_species = "malloc target"; } } - if (is_static) { - replacement_code += "static "; - } - replacement_code += prefix_str + direct_qtype_str + suffix_str; - replacement_code += " "; - replacement_code += variable_name; - if (std::string::npos == options_str.find("[no-initializer]")) { - std::string initializer_append_str = ddcs_ref.m_initializer_info_str; + bool discard_initializer_option_flag = (std::string::npos != options_str.find("[discard-initializer]")); + std::string initializer_append_str; + if (!discard_initializer_option_flag) { + initializer_append_str = ddcs_ref.m_initializer_info_str; if (("" == initializer_append_str) && ("" != initialization_expr_str)) { initializer_append_str = " = " + initialization_expr_str; } + } + + if (("" != prefix_str) || ("" != suffix_str)) { + changed_from_original = true; + } else if (("" != ddcs_ref.m_initializer_info_str) || + (discard_initializer_option_flag)) { + changed_from_original = true; + } else if (2 <= IndividualDeclaratorDecls(DD, Rewrite).size()) { + /* There is more than one declaration in the declaration statement. We split + * them so that each has their own separate declaration statement. This counts + * as a change from the original source code. */ + changed_from_original = true; + } + + if (changed_from_original) { + if (is_extern) { + if ("" == ddcs_ref.m_original_initialization_expr_str) { + replacement_code += "extern "; + } + } else if (is_static) { + replacement_code += "static "; + } + replacement_code += prefix_str + direct_qtype_str + suffix_str; + replacement_code += " "; + replacement_code += variable_name; + replacement_code += initializer_append_str; + } else { + replacement_code = ddcs_ref.m_original_source_text_str; } + retval.m_replacement_code = replacement_code; return retval; } @@ -1294,16 +1380,21 @@ void CAssignedFromArray2ReplacementAction::do_replacement(CState1& state1) const auto& ddcs_ref = (*ddcs_map_iter).second; bool update_declaration_flag = res1.second; - 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_dynamic_array2_contingent_replacement_map.do_and_dispose_matching_replacements(state1, m_ddecl_indirection2); + 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 = 3; + int q = 7; } if (update_declaration_flag) { @@ -1311,6 +1402,136 @@ void CAssignedFromArray2ReplacementAction::do_replacement(CState1& state1) const } } +void CConditionalOperatorReconciliation2ReplacementAction::do_replacement(CState1& state1) const { + const clang::ConditionalOperator* CO = m_CO; + const Expr* COND = nullptr; + const Expr* LHS = nullptr; + const Expr* RHS = nullptr; + if (CO) { + COND = CO->getCond(); + LHS = CO->getLHS(); + RHS = CO->getRHS(); + } + const DeclaratorDecl* lhs_DD = m_lhs_DD; + const DeclaratorDecl* rhs_DD = m_rhs_DD; + if ((COND != nullptr) && (LHS != nullptr) && (RHS != nullptr) && (lhs_DD != nullptr) && (rhs_DD != nullptr)) { + bool lhs_is_array = false; + bool lhs_is_dynamic_array = false; + bool lhs_is_native_array = false; + + auto COSR = nice_source_range(CO->getSourceRange(), (*this).m_Rewrite); + auto cond_SR = nice_source_range(COND->getSourceRange(), (*this).m_Rewrite); + auto lhs_SR = nice_source_range(LHS->getSourceRange(), (*this).m_Rewrite); + auto rhs_SR = nice_source_range(RHS->getSourceRange(), (*this).m_Rewrite); + if ((COSR.isValid()) && (cond_SR.isValid()) && (lhs_SR.isValid()) && (rhs_SR.isValid())) { + auto res1 = state1.m_ddecl_conversion_state_map.insert(*lhs_DD); + 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) { + lhs_is_dynamic_array = true; + lhs_is_array = true; + } else if ("native array" == ddcs_ref.m_indirection_state_stack[0].m_current) { + lhs_is_native_array = true; + lhs_is_array = true; + } else if ("inferred array" == ddcs_ref.m_indirection_state_stack[0].m_current) { + lhs_is_array = true; + } + } else { + int q = 3; + } + } + + bool rhs_is_array = false; + bool rhs_is_dynamic_array = false; + bool rhs_is_native_array = false; + { + auto res1 = state1.m_ddecl_conversion_state_map.insert(*rhs_DD); + 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) { + rhs_is_dynamic_array = true; + rhs_is_array = true; + } else if ("native array" == ddcs_ref.m_indirection_state_stack[0].m_current) { + rhs_is_native_array = true; + rhs_is_array = true; + } else if ("inferred array" == ddcs_ref.m_indirection_state_stack[0].m_current) { + rhs_is_array = true; + } + } else { + int q = 3; + } + } + if (lhs_is_array && rhs_is_array) { + if (m_var_DD) { + update_declaration(*m_var_DD, (*this).m_Rewrite, state1); + } + + std::string CO_prior_text = (*this).m_Rewrite.getRewrittenText(COSR); + std::string CO_replacement_text; + + std::string cond_prior_text = (*this).m_Rewrite.getRewrittenText(cond_SR); + std::string cond_replacement_text = cond_prior_text; + + std::string lhs_prior_text = (*this).m_Rewrite.getRewrittenText(lhs_SR); + std::string lhs_replacement_text = lhs_prior_text; + + 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<"; + + 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; + + CO_replacement_text = possibly_truncated_CO_replacement_text; + int q = 3; + } + } + } + + if (m_var_DD && ("" != CO_replacement_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; + } + + } + } +} + + struct CArrayInferenceInfo { bool update_declaration_flag = false; bool has_been_determined_to_be_an_array = false; @@ -1326,7 +1547,11 @@ CArrayInferenceInfo infer_array_type_info_from_stmt_indirection_stack(CDDeclConv if (!DD) { assert(false); return retval; } for (size_t i = 0; ((i < ddcs_ref.m_indirection_state_stack.size()) && (i < stmt_indirection_stack.size())); i += 1) { - if ("native pointer" == ddcs_ref.m_indirection_state_stack[i].m_current) { + if (("" == stmt_indirection_stack[i])) { + /* 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) { if (("ArraySubscriptExpr" == stmt_indirection_stack[i]) || ("pointer arithmetic" == stmt_indirection_stack[i])) { ddcs_ref.m_indirection_state_stack[i].m_current = "inferred array"; @@ -2780,6 +3005,7 @@ private: CState1& m_state1; }; +/* This class addresses the initialized declarations in the form "type var = cond ? lhs : rhs;". */ class MCSSSConditionalInitializer : public MatchFinder::MatchCallback { public: @@ -2821,11 +3047,6 @@ public: return void(); } - if (std::string::npos != source_location_str.find("73")) { - walkTheAST1(*LHS); - int q = 5; - } - 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; @@ -2845,52 +3066,139 @@ public: return; } - auto res1 = (*this).m_state1.m_ddecl_conversion_state_map.insert(*DD); - auto ddcs_map_iter = res1.first; - auto& ddcs_ref = (*ddcs_map_iter).second; - bool update_declaration_flag = res1.second; + std::string var_current_state_str; + { + auto res1 = m_state1.m_ddecl_conversion_state_map.insert(*DD); + 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; + } else { + int q = 7; + } + } + bool var_has_been_determined_to_be_an_array = false; + if (("inferred array" == var_current_state_str) || + ("dynamic array" == var_current_state_str) || + ("native array" == var_current_state_str)) { + if ("native array" == var_current_state_str) { + assert(false); /* right? */ + } + var_has_been_determined_to_be_an_array = true; + } + + 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); + bool lhs_qualifies = false; + bool rhs_qualifies = false; { - auto res2 = infer_array_type_info_from_stmt(*LHS, "", (*this).m_state1); + auto& res2 = lhs_res2; if (res2.ddecl_cptr && res2.declaration_expr_cptr) { std::string variable_name = res2.ddecl_cptr->getNameAsString(); auto QT = res2.ddecl_cptr->getType(); auto LHS_QT = LHS->getType(); - if (QT == LHS_QT) { - - if (ConvertToSCPP && decl_source_range.isValid()) { + /* Currently we only support the case where the value expressions are direct + * references to declared variables. */ + 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)); - if (true || res2.has_been_determined_to_be_an_array) { + 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); } - } else { - int q = 7; } } } } { - auto res2 = infer_array_type_info_from_stmt(*RHS, "", (*this).m_state1); + auto& res2 = rhs_res2; if (res2.ddecl_cptr && res2.declaration_expr_cptr) { std::string variable_name = res2.ddecl_cptr->getNameAsString(); auto QT = res2.ddecl_cptr->getType(); auto RHS_QT = RHS->getType(); + /* Currently we only support the case where the value expressions are direct + * references to declared variables. */ if (QT == RHS_QT) { - - if (ConvertToSCPP && decl_source_range.isValid()) { + 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)); - if (true || res2.has_been_determined_to_be_an_array) { + 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 (lhs_qualifies && rhs_qualifies) { + std::string lhs_current_state_str; + { + auto res1 = m_state1.m_ddecl_conversion_state_map.insert(*(lhs_res2.ddecl_cptr)); + 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; + } else { + int q = 7; + } + } + std::string rhs_current_state_str; + { + auto res1 = m_state1.m_ddecl_conversion_state_map.insert(*(rhs_res2.ddecl_cptr)); + 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; + } else { + int q = 7; + } + } + + if (ConvertToSCPP) { + /* Here we're establishing and "enforcing" the constraint that the lhs and rhs + * values of the conditional operator must be the same type. */ + { + auto cr_shptr = std::make_shared<CConditionalOperatorReconciliation2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*lhs_res2.ddecl_cptr, 0), CO, lhs_res2.ddecl_cptr, rhs_res2.ddecl_cptr, DD); + + if ("dynamic array" == lhs_current_state_str) { + (*cr_shptr).do_replacement(m_state1); + } else if ("native array" == lhs_current_state_str) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + if ("inferred array" == lhs_current_state_str) { (*cr_shptr).do_replacement(m_state1); } else { m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); } + } + } + { + auto cr_shptr = std::make_shared<CConditionalOperatorReconciliation2ReplacementAction>(Rewrite, MR, CDDeclIndirection(*rhs_res2.ddecl_cptr, 0), CO, lhs_res2.ddecl_cptr, rhs_res2.ddecl_cptr, DD); + + if ("dynamic array" == rhs_current_state_str) { + (*cr_shptr).do_replacement(m_state1); + } else if ("native array" == rhs_current_state_str) { + (*cr_shptr).do_replacement(m_state1); } else { - int q = 7; + m_state1.m_dynamic_array2_contingent_replacement_map.insert(cr_shptr); + if ("inferred array" == rhs_current_state_str) { + (*cr_shptr).do_replacement(m_state1); + } else { + m_state1.m_array2_contingent_replacement_map.insert(cr_shptr); + } } } } |