Add const modifier to range-based for loops

edding3000 · edding3000 · commit e9bf9ad0e2c4 · 2025-11-21T12:35:20.000+01:00
diff --git a/src/actions/block.cc b/src/actions/block.cc
@@ -32,7 +32,7 @@ namespace actions {
 bool Block::evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) {
     ms_dbg_a(transaction, 8, "Marking request as disruptive.");
 
-    for (auto &a : transaction->m_rules->m_defaultActions[rule->getPhase()]) {
+    for (const auto& a : transaction->m_rules->m_defaultActions[rule->getPhase()]) {
         if (a->isDisruptive() == false) {
             continue;
         }
diff --git a/src/collection/backend/in_memory-per_process.cc b/src/collection/backend/in_memory-per_process.cc
@@ -155,7 +155,7 @@ void InMemoryPerProcess::resolveMultiMatches(const std::string& var,
         const std::shared_lock lock(m_mutex); // read lock (shared access)
 
         if (keySize == 0) {
-            for (auto &i : m_map) {
+            for (const auto &i : m_map) {
                 if (ke.toOmit(i.first)) {
                     continue;
                 }
diff --git a/src/engine/lua.cc b/src/engine/lua.cc
@@ -297,7 +297,7 @@ int Lua::getvars(lua_State *L) {
     variables::Variable::stringMatchResolveMulti(t, varname, &l);
 
     lua_newtable(L);
-    for (auto* i : l) {
+    for (const auto *i : l) {
         lua_pushnumber(L, idx);
         lua_newtable(L);
 
diff --git a/src/rule_with_actions.cc b/src/rule_with_actions.cc
@@ -209,7 +209,7 @@ void RuleWithActions::executeActionsIndependentOfChainedRuleResult(Transaction *
         a->evaluate(this, trans);
     }
 
-    for (auto &b :
+    for (const auto& b :
         trans->m_rules->m_exceptions.m_action_pre_update_target_by_id) {
         if (m_ruleId != b.first) {
             continue;
@@ -262,7 +262,7 @@ void RuleWithActions::executeActionsAfterFullMatch(Transaction *trans,
         a->evaluate(this, trans, ruleMessage);
     }
 
-    for (auto &b :
+    for (const auto& b :
         trans->m_rules->m_exceptions.m_action_pos_update_target_by_id) {
         if (m_ruleId != b.first) {
             continue;
@@ -373,7 +373,7 @@ void RuleWithActions::executeTransformations(
     // Notice that first we make sure that won't be a t:none
     // on the target rule.
     if (none == 0) {
-        for (auto &a : trans->m_rules->m_defaultActions[getPhase()]) {
+        for (const auto& a : trans->m_rules->m_defaultActions[getPhase()]) {
             if (a->action_kind \
                 != actions::Action::Kind::RunTimeBeforeMatchAttemptKind) {
                 continue;
@@ -400,7 +400,7 @@ void RuleWithActions::executeTransformations(
 
     // FIXME: It can't be something different from transformation. Sort this
     //        on rules compile time.
-    for (auto &b :
+    for (const auto& b :
         trans->m_rules->m_exceptions.m_action_pre_update_target_by_id) {
         if (m_ruleId != b.first) {
             continue;
@@ -412,7 +412,7 @@ void RuleWithActions::executeTransformations(
         }
     }
 
-    for (auto &b :
+    for (const auto& b :
         trans->m_rules->m_exceptions.m_action_pre_update_target_by_id) {
         if (m_ruleId != b.first) {
             continue;
@@ -442,7 +442,7 @@ void RuleWithActions::executeTransformations(
 
 
 bool RuleWithActions::containsTag(const std::string& name, Transaction *t) {
-    for (auto &tag : m_actionsTag) {
+    for (const auto &tag : m_actionsTag) {
         if (tag != NULL && tag->getName(t) == name) {
             return true;
         }
@@ -459,17 +459,17 @@ bool RuleWithActions::containsMsg(const std::string& name, Transaction *t) {
 std::vector<actions::Action *> RuleWithActions::getActionsByName(const std::string& name,
     const Transaction *trans) {
     std::vector<actions::Action *> ret;
-    for (auto &z : m_actionsRuntimePos) {
+    for (const auto &z : m_actionsRuntimePos) {
         if (*z->m_name.get() == name) {
             ret.push_back(z);
         }
     }
-    for (auto &z : m_transformations) {
+    for (const auto& z : m_transformations) {
         if (*z->m_name.get() == name) {
             ret.push_back(z);
         }
     }
-    for (auto &b :
+    for (const auto& b :
         trans->m_rules->m_exceptions.m_action_pre_update_target_by_id) {
         if (m_ruleId != b.first) {
             continue;
@@ -479,7 +479,7 @@ std::vector<actions::Action *> RuleWithActions::getActionsByName(const std::stri
             ret.push_back(z);
         }
     }
-    for (auto &b :
+    for (const auto& b :
         trans->m_rules->m_exceptions.m_action_pos_update_target_by_id) {
         if (m_ruleId != b.first) {
             continue;
diff --git a/src/rule_with_operator.cc b/src/rule_with_operator.cc
@@ -252,7 +252,7 @@ bool RuleWithOperator::evaluate(Transaction *trans,
 
     getFinalVars(&vars, &exclusion, trans);
 
-    for (auto &var : vars) {
+    for (const auto &var : vars) {
         std::vector<const VariableValue *> e;
         if (!var) {
             continue;
diff --git a/src/rules_exceptions.cc b/src/rules_exceptions.cc
@@ -195,7 +195,7 @@ bool RulesExceptions::contains(int a) {
         }
     }
 
-    for (auto& z : m_ranges) {
+    for (const auto& z : m_ranges) {
         if (z.first <= a && z.second >= a) {
             return true;
         }
@@ -212,42 +212,42 @@ bool RulesExceptions::merge(RulesExceptions *from) {
             return ret;
         }
     }
-    for (auto& b : from->m_ranges) {
+    for (const auto& b : from->m_ranges) {
         bool ret = addRange(b.first, b.second);
         if (ret == false) {
             return ret;
         }
     }
 
-    for (auto &p : from->m_variable_update_target_by_tag) {
+    for (const auto &p : from->m_variable_update_target_by_tag) {
         m_variable_update_target_by_tag.emplace(
             std::pair<std::shared_ptr<std::string>,
             std::shared_ptr<variables::Variable>>(p.first,
                 p.second));
     }
 
-    for (auto &p : from->m_variable_update_target_by_msg) {
+    for (const auto &p : from->m_variable_update_target_by_msg) {
         m_variable_update_target_by_msg.emplace(
             std::pair<std::shared_ptr<std::string>,
             std::shared_ptr<variables::Variable>>(p.first,
                 p.second));
     }
 
-    for (auto &p : from->m_variable_update_target_by_id) {
+    for (const auto &p : from->m_variable_update_target_by_id) {
         m_variable_update_target_by_id.emplace(
             std::pair<double,
                 std::shared_ptr<variables::Variable>>(p.first,
                     p.second));
     }
 
-    for (auto &p : from->m_action_pos_update_target_by_id) {
+    for (const auto &p : from->m_action_pos_update_target_by_id) {
         m_action_pos_update_target_by_id.emplace(
             std::pair<double,
                 std::shared_ptr<actions::Action>>(p.first,
                     p.second));
     }
 
-    for (auto &p : from->m_action_pre_update_target_by_id) {
+    for (const auto &p : from->m_action_pre_update_target_by_id) {
         m_action_pre_update_target_by_id.emplace(
             std::pair<double,
                 std::shared_ptr<actions::Action>>(p.first,
diff --git a/src/run_time_string.cc b/src/run_time_string.cc
@@ -53,7 +53,7 @@ std::string RunTimeString::evaluate(Transaction *t) {
 
 std::string RunTimeString::evaluate(Transaction *t, Rule *r) {
     std::string s;
-    for (auto &z : m_elements) {
+    for (const auto& z : m_elements) {
         if (z->m_string.size() > 0) {
             s.append(z->m_string);
         } else if (z->m_var != NULL && t != NULL) {
diff --git a/src/transaction.cc b/src/transaction.cc
@@ -1700,7 +1700,7 @@ std::string Transaction::toJSON(int parts) {
             reinterpret_cast<const unsigned char*>("messages"),
             strlen("messages"));
         yajl_gen_array_open(g);
-        for (auto& a : m_rulesMessages) {
+        for (const auto& a : m_rulesMessages) {
             yajl_gen_map_open(g);
             LOGFY_ADD("message", a.m_message);
             yajl_gen_string(g,
@@ -1721,7 +1721,7 @@ std::string Transaction::toJSON(int parts) {
                 reinterpret_cast<const unsigned char*>("tags"),
                 strlen("tags"));
             yajl_gen_array_open(g);
-            for (auto& b : a.m_tags) {
+            for (const auto& b : a.m_tags) {
                 yajl_gen_string(g,
                     reinterpret_cast<const unsigned char*>(b.data()),
                     b.length());
diff --git a/src/variables/variable.h b/src/variables/variable.h
@@ -155,7 +155,7 @@ class KeyExclusions : public std::deque<std::unique_ptr<KeyExclusion>> {
     }
 
     bool toOmit(std::string a) {
-        for (auto &z : *this) {
+        for (const auto& z : *this) {
             if (z->match(a)) {
                 return true;
             }
diff --git a/test/regression/regression.cc b/test/regression/regression.cc
@@ -115,7 +115,7 @@ void perform_unit_test(const ModSecurityTest<RegressionTest> &test,
     const std::vector<std::unique_ptr<RegressionTest>> &tests,
     ModSecurityTestResults<RegressionTestResult> *res, int *count)
 {
-    for (auto &t : tests) {
+    for (const auto &t : tests) {
         ModSecurityTestResults<RegressionTest> r;
         RegressionTestResult *testRes = new RegressionTestResult();
 
diff --git a/test/unit/unit.cc b/test/unit/unit.cc
@@ -249,9 +249,9 @@ int main(int argc, char **argv) {
         test.load_tests("test-cases/secrules-language-tests/transformations");
     }
 
-    for (auto& [filename, tests] : test) {
+    for (const auto& [filename, tests] : test) {
         total += tests.size();
-        for (auto &t : tests) {
+        for (const auto &t : tests) {
             ModSecurityTestResults<UnitTest> r;
 
             if (!test.m_automake_output) {
@@ -286,7 +286,7 @@ int main(int argc, char **argv) {
     if (!test.m_automake_output) {
         std::cout << "Total >> "  << total << std::endl;
 
-        for (const auto t : results) {
+        for (const auto& t : results) {
             std::cout << t->print() << std::endl;
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ namespace actions {`
`32`	`32`	`bool Block::evaluate(RuleWithActions rule, Transaction transaction, RuleMessage &ruleMessage) {`
`33`	`33`	`ms_dbg_a(transaction, 8, "Marking request as disruptive.");`
`34`	`34`
`35`		`- for (auto &a : transaction->m_rules->m_defaultActions[rule->getPhase()]) {`
	`35`	`+ for (const auto& a : transaction->m_rules->m_defaultActions[rule->getPhase()]) {`
`36`	`36`	`if (a->isDisruptive() == false) {`
`37`	`37`	`continue;`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,7 @@ void InMemoryPerProcess::resolveMultiMatches(const std::string& var,`
`155`	`155`	`const std::shared_lock lock(m_mutex); // read lock (shared access)`
`156`	`156`
`157`	`157`	`if (keySize == 0) {`
`158`		`- for (auto &i : m_map) {`
	`158`	`+ for (const auto &i : m_map) {`
`159`	`159`	`if (ke.toOmit(i.first)) {`
`160`	`160`	`continue;`
`161`	`161`	`}`
Original file line number	Diff line number	Diff line change
`@@ -195,7 +195,7 @@ bool RulesExceptions::contains(int a) {`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`
`198`		`- for (auto& z : m_ranges) {`
	`198`	`+ for (const auto& z : m_ranges) {`
`199`	`199`	`if (z.first <= a && z.second >= a) {`
`200`	`200`	`return true;`
`201`	`201`	`}`
`@@ -212,42 +212,42 @@ bool RulesExceptions::merge(RulesExceptions *from) {`
`212`	`212`	`return ret;`
`213`	`213`	`}`
`214`	`214`	`}`
`215`		`- for (auto& b : from->m_ranges) {`
	`215`	`+ for (const auto& b : from->m_ranges) {`
`216`	`216`	`bool ret = addRange(b.first, b.second);`
`217`	`217`	`if (ret == false) {`
`218`	`218`	`return ret;`
`219`	`219`	`}`
`220`	`220`	`}`
`221`	`221`
`222`		`- for (auto &p : from->m_variable_update_target_by_tag) {`
	`222`	`+ for (const auto &p : from->m_variable_update_target_by_tag) {`
`223`	`223`	`m_variable_update_target_by_tag.emplace(`
`224`	`224`	`std::pair<std::shared_ptr<std::string>,`
`225`	`225`	`std::shared_ptr<variables::Variable>>(p.first,`
`226`	`226`	`p.second));`
`227`	`227`	`}`
`228`	`228`
`229`		`- for (auto &p : from->m_variable_update_target_by_msg) {`
	`229`	`+ for (const auto &p : from->m_variable_update_target_by_msg) {`
`230`	`230`	`m_variable_update_target_by_msg.emplace(`
`231`	`231`	`std::pair<std::shared_ptr<std::string>,`
`232`	`232`	`std::shared_ptr<variables::Variable>>(p.first,`
`233`	`233`	`p.second));`
`234`	`234`	`}`
`235`	`235`
`236`		`- for (auto &p : from->m_variable_update_target_by_id) {`
	`236`	`+ for (const auto &p : from->m_variable_update_target_by_id) {`
`237`	`237`	`m_variable_update_target_by_id.emplace(`
`238`	`238`	`std::pair<double,`
`239`	`239`	`std::shared_ptr<variables::Variable>>(p.first,`
`240`	`240`	`p.second));`
`241`	`241`	`}`
`242`	`242`
`243`		`- for (auto &p : from->m_action_pos_update_target_by_id) {`
	`243`	`+ for (const auto &p : from->m_action_pos_update_target_by_id) {`
`244`	`244`	`m_action_pos_update_target_by_id.emplace(`
`245`	`245`	`std::pair<double,`
`246`	`246`	`std::shared_ptr<actions::Action>>(p.first,`
`247`	`247`	`p.second));`
`248`	`248`	`}`
`249`	`249`
`250`		`- for (auto &p : from->m_action_pre_update_target_by_id) {`
	`250`	`+ for (const auto &p : from->m_action_pre_update_target_by_id) {`
`251`	`251`	`m_action_pre_update_target_by_id.emplace(`
`252`	`252`	`std::pair<double,`
`253`	`253`	`std::shared_ptr<actions::Action>>(p.first,`
Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,7 @@ class KeyExclusions : public std::deque<std::unique_ptr<KeyExclusion>> {`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`bool toOmit(std::string a) {`
`158`		`- for (auto &z : *this) {`
	`158`	`+ for (const auto& z : *this) {`
`159`	`159`	`if (z->match(a)) {`
`160`	`160`	`return true;`
`161`	`161`	`}`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ void perform_unit_test(const ModSecurityTest<RegressionTest> &test,`
`115`	`115`	`const std::vector<std::unique_ptr<RegressionTest>> &tests,`
`116`	`116`	`ModSecurityTestResults<RegressionTestResult> res, int count)`
`117`	`117`	`{`
`118`		`- for (auto &t : tests) {`
	`118`	`+ for (const auto &t : tests) {`
`119`	`119`	`ModSecurityTestResults<RegressionTest> r;`
`120`	`120`	`RegressionTestResult *testRes = new RegressionTestResult();`
`121`	`121`