diff --git a/headers/modsecurity/rule.h b/headers/modsecurity/rule.h
index 78929be1..12d7ff79 100644
--- a/headers/modsecurity/rule.h
+++ b/headers/modsecurity/rule.h
@@ -100,20 +100,6 @@ class Rule {
     bool containsTag(const std::string& name, Transaction *t);
     bool containsMsg(const std::string& name, Transaction *t);
 
-    int refCountDecreaseAndCheck() {
-        m_referenceCount--;
-        if (m_referenceCount == 0) {
-            delete this;
-            return 1;
-        }
-        return 0;
-    }
-
-
-    void refCountIncrease() {
-        m_referenceCount++;
-    }
-
     void executeTransformations(
         actions::Action *a,
         std::shared_ptr<std::string> newValue,
@@ -140,7 +126,7 @@ class Rule {
     int m_phase;
     modsecurity::variables::Variables *m_variables;
     operators::Operator *m_op;
-    Rule *m_chainedRuleChild;
+    std::unique_ptr<Rule> m_chainedRuleChild;
     Rule *m_chainedRuleParent;
     std::string m_fileName;
     std::string m_marker;
@@ -150,9 +136,9 @@ class Rule {
     std::vector<actions::Action *> m_actionsRuntimePre;
     std::vector<actions::SetVar *> m_actionsSetVar;
     std::vector<actions::Tag *> m_actionsTag;
+
  private:
     bool m_unconditional;
-    int m_referenceCount;
 };
 
 
diff --git a/headers/modsecurity/rules.h b/headers/modsecurity/rules.h
index 36f481a7..9643f210 100644
--- a/headers/modsecurity/rules.h
+++ b/headers/modsecurity/rules.h
@@ -23,8 +23,10 @@
 #include <string>
 #include <vector>
 #include <list>
+#include <memory>
 #endif
 
+#include "modsecurity/rule.h"
 
 #ifndef HEADERS_MODSECURITY_RULES_H_
 #define HEADERS_MODSECURITY_RULES_H_
@@ -32,10 +34,55 @@
 
 #ifdef __cplusplus
 namespace modsecurity {
-class Rule;
 
-class Rules : public std::vector<Rule *> {
+
+class Rules {
  public:
+    void dump() const {
+        for (int j = 0; j < m_rules.size(); j++) {
+            std::cout << "    Rule ID: " << std::to_string(m_rules.at(j)->m_ruleId);
+            std::cout << "--" << m_rules.at(j) << std::endl;
+        }
+    }
+
+    int append(Rules *from, const std::vector<int64_t> &ids, std::ostringstream *err) {
+         size_t j = 0;
+         for (; j < from->size(); j++) {
+            Rule *rule = from->at(j).get();
+             if (std::binary_search(ids.begin(), ids.end(), rule->m_ruleId)) {
+                 if (err != NULL) {
+                     *err << "Rule id: " << std::to_string(rule->m_ruleId) \
+                        << " is duplicated" << std::endl;
+                 }
+                 return -1;
+             }
+         }
+         m_rules.insert(m_rules.end(), from->m_rules.begin(), from->m_rules.end());
+         return j;
+    }
+
+    bool insert(std::shared_ptr<Rule> rule) {
+        return insert(rule, nullptr, nullptr);
+    }
+
+    bool insert(std::shared_ptr<Rule> rule, const std::vector<int64_t> *ids, std::ostringstream *err) {
+        if (ids != nullptr && std::binary_search(ids->begin(), ids->end(), rule->m_ruleId)) {
+            if (err != nullptr) {
+                *err << "Rule id: " << std::to_string(rule->m_ruleId) \
+                    << " is duplicated" << std::endl;
+            }
+            return false;
+        }
+
+        m_rules.push_back(rule);
+        return true;
+    }
+
+    size_t size() const { return m_rules.size(); }
+    std::shared_ptr<Rule> operator[](int index) const { return m_rules[index]; }
+    std::shared_ptr<Rule> at(int index) const { return m_rules[index]; }
+
+    std::vector<std::shared_ptr<Rule> > m_rules;
 };
 
 
diff --git a/headers/modsecurity/rules_set_phases.h b/headers/modsecurity/rules_set_phases.h
index 35a77985..ea55f9e7 100644
--- a/headers/modsecurity/rules_set_phases.h
+++ b/headers/modsecurity/rules_set_phases.h
@@ -39,10 +39,9 @@ class Rule;
 /** @ingroup ModSecurity_CPP_API */
 class RulesSetPhases {
  public:
-
     ~RulesSetPhases();
 
-    bool insert(Rule *rule);
+    bool insert(std::shared_ptr<Rule> rule);
 
     int append(RulesSetPhases *from, std::ostringstream *err);
     void dump() const;
diff --git a/src/parser/driver.cc b/src/parser/driver.cc
index 3cfa100b..e82d4ec1 100644
--- a/src/parser/driver.cc
+++ b/src/parser/driver.cc
@@ -29,7 +29,7 @@ Driver::Driver()
   : RulesSetProperties(),
   trace_scanning(false),
   trace_parsing(false),
-  lastRule(NULL) { }
+  m_lastRule(nullptr) { }
 
 
 Driver::~Driver() {
@@ -43,15 +43,15 @@ Driver::~Driver() {
 
 int Driver::addSecMarker(std::string marker) {
     for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
-        Rule *rule = new Rule(marker);
+        std::unique_ptr<Rule> rule(new Rule(marker));
         rule->m_phase = i;
-        m_rulesSetPhases.insert(rule);
+        m_rulesSetPhases.insert(std::move(rule));
     }
     return 0;
 }
 
 
-int Driver::addSecAction(Rule *rule) {
+int Driver::addSecAction(std::unique_ptr<Rule> rule) {
     if (rule->m_phase >= modsecurity::Phases::NUMBER_OF_PHASES) {
         m_parserError << "Unknown phase: " << std::to_string(rule->m_phase);
         m_parserError << std::endl;
@@ -59,55 +59,40 @@ int Driver::addSecAction(Rule *rule) {
     }
 
 
-    m_rulesSetPhases.insert(rule);
+    m_rulesSetPhases.insert(std::move(rule));
 
     return true;
 }
 
 
-int Driver::addSecRuleScript(RuleScript *rule) {
-    m_rulesSetPhases.insert(rule);
+int Driver::addSecRuleScript(std::unique_ptr<RuleScript> rule) {
+    m_rulesSetPhases.insert(std::move(rule));
     return true;
 }
 
 
-int Driver::addSecRule(Rule *rule) {
-    if (rule->m_phase >= modsecurity::Phases::NUMBER_OF_PHASES) {
-        m_parserError << "Unknown phase: " << std::to_string(rule->m_phase);
+int Driver::addSecRule(std::unique_ptr<Rule> r) {
+    if (r->m_phase >= modsecurity::Phases::NUMBER_OF_PHASES) {
+        m_parserError << "Unknown phase: " << std::to_string(r->m_phase);
         m_parserError << std::endl;
         return false;
     }
 
-    if (lastRule && lastRule->m_chained) {
-        if (lastRule->m_chainedRuleChild == NULL) {
-            rule->m_phase = lastRule->m_phase;
-            if (rule->m_theDisruptiveAction) {
-                m_parserError << "Disruptive actions can only be specified by";
-                m_parserError << " chain starter rules.";
-                return false;
-            }
-            lastRule->m_chainedRuleChild = rule;
-            rule->m_chainedRuleParent = lastRule;
-            return true;
-        } else {
-            Rule *a = lastRule->m_chainedRuleChild;
-            while (a->m_chained && a->m_chainedRuleChild != NULL) {
-                a = a->m_chainedRuleChild;
-            }
-            if (a->m_chained && a->m_chainedRuleChild == NULL) {
-                a->m_chainedRuleChild = rule;
-                rule->m_chainedRuleParent = a;
-                if (a->m_theDisruptiveAction) {
-                    m_parserError << "Disruptive actions can only be ";
-                    m_parserError << "specified by chain starter rules.";
-                    return false;
-                }
-                return true;
-            }
+    /* is it a chained rule? */
+    if (m_lastRule != nullptr && m_lastRule->m_chained) {
+        r->m_phase = m_lastRule->m_phase;
+        if (r->m_theDisruptiveAction) {
+            m_parserError << "Disruptive actions can only be specified by";
+            m_parserError << " chain starter rules.";
+            return false;
         }
+        m_lastRule->m_chainedRuleChild = std::move(r);
+        m_lastRule->m_chainedRuleChild->m_chainedRuleParent = m_lastRule;
+        m_lastRule = m_lastRule->m_chainedRuleChild.get();
+        return true;
     }
 
-
+    std::shared_ptr<Rule> rule(std::move(r));
     /*
      * Checking if the rule has an ID and also checking if this ID is not used
      * by other rule
@@ -118,6 +103,7 @@ int Driver::addSecRule(Rule *rule) {
         m_parserError << std::to_string(rule->m_lineNumber) << std::endl;
         return false;
     }
+
     for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
         Rules *rules = m_rulesSetPhases[i];
         for (int j = 0; j < rules->size(); j++) {
@@ -129,14 +115,15 @@ int Driver::addSecRule(Rule *rule) {
         }
     }
 
-    lastRule = rule;
+    m_lastRule = rule.get();
     m_rulesSetPhases.insert(rule);
+
     return true;
 }
 
 
 int Driver::parse(const std::string &f, const std::string &ref) {
-    lastRule = NULL;
+    m_lastRule = nullptr;
     loc.push_back(new yy::location());
     if (ref.empty()) {
         loc.back()->begin.filename = loc.back()->end.filename = new std::string("<<reference missing or not informed>>");
@@ -155,6 +142,19 @@ int Driver::parse(const std::string &f, const std::string &ref) {
     int res = parser.parse();
     scan_end();
 
+    /*
+     * need to check for rules marked as chained but without
+     * a chained rule.
+     *
+     */
+    /*
+    if (m_lastRule != nullptr && m_lastRule->m_chained) {
+        m_parserError << "Last rule is marked as chained but there " \
+            "isn't a subsequent rule." << std::endl;
+        return false;
+    }
+    */
+
     /*
     if (m_auditLog->init(&error) == false) {
         m_parserError << "Problems while initializing the audit logs: " \
diff --git a/src/parser/driver.h b/src/parser/driver.h
index 72091f0a..b9abc3de 100644
--- a/src/parser/driver.h
+++ b/src/parser/driver.h
@@ -66,10 +66,10 @@ class Driver : public RulesSetProperties {
     Driver();
     virtual ~Driver();
 
-    int addSecRule(Rule *rule);
-    int addSecAction(Rule *rule);
+    int addSecRule(std::unique_ptr<Rule> rule);
+    int addSecAction(std::unique_ptr<Rule> rule);
     int addSecMarker(std::string marker);
-    int addSecRuleScript(RuleScript *rule);
+    int addSecRuleScript(std::unique_ptr<RuleScript> rule);
 
     bool scan_begin();
     void scan_end();
@@ -89,7 +89,7 @@ class Driver : public RulesSetProperties {
     std::list<yy::location *> loc;
 
     std::string buffer;
-    Rule *lastRule;
+    Rule *m_lastRule;
 
     RulesSetPhases m_rulesSetPhases;
 };
diff --git a/src/parser/location.hh b/src/parser/location.hh
index db226899..eafd7be7 100644
--- a/src/parser/location.hh
+++ b/src/parser/location.hh
@@ -1,4 +1,4 @@
-// A Bison parser, made by GNU Bison 3.5.2.
+// A Bison parser, made by GNU Bison 3.5.3.
 
 // Locations for Bison parsers in C++
 
diff --git a/src/parser/position.hh b/src/parser/position.hh
index c7c76bc7..faf89527 100644
--- a/src/parser/position.hh
+++ b/src/parser/position.hh
@@ -1,4 +1,4 @@
-// A Bison parser, made by GNU Bison 3.5.2.
+// A Bison parser, made by GNU Bison 3.5.3.
 
 // Starting with Bison 3.2, this file is useless: the structure it
 // used to define is now defined in "location.hh".
diff --git a/src/parser/seclang-parser.cc b/src/parser/seclang-parser.cc
index 2d46f55b..e608d13d 100644
--- a/src/parser/seclang-parser.cc
+++ b/src/parser/seclang-parser.cc
@@ -1,4 +1,4 @@
-// A Bison parser, made by GNU Bison 3.5.2.
+// A Bison parser, made by GNU Bison 3.5.3.
 
 // Skeleton implementation for Bison LALR(1) parsers in C++
 
@@ -2314,94 +2314,90 @@ namespace yy {
         }
 
         Operator *op = yystack_[1].value.as < std::unique_ptr<Operator> > ().release();
-        Rule *rule = new Rule(
+        std::unique_ptr<Rule> rule(new Rule(
             /* op */ op,
             /* variables */ v,
             /* actions */ a,
             /* file name */ *yystack_[3].location.end.filename,
             /* line number */ yystack_[3].location.end.line
-            );
+            ));
 
-        if (driver.addSecRule(rule) == false) {
-            delete rule;
+        if (driver.addSecRule(std::move(rule)) == false) {
             YYERROR;
         }
       }
-#line 2331 "seclang-parser.cc"
+#line 2330 "seclang-parser.cc"
     break;
 
   case 75:
-#line 1093 "seclang-parser.yy"
+#line 1092 "seclang-parser.yy"
       {
         variables::Variables *v = new variables::Variables();
         for (auto &i : *yystack_[1].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ().get()) {
             v->push_back(i.release());
         }
 
-        Rule *rule = new Rule(
+        std::unique_ptr<Rule> rule(new Rule(
             /* op */ yystack_[0].value.as < std::unique_ptr<Operator> > ().release(),
             /* variables */ v,
             /* actions */ NULL,
             /* file name */ *yystack_[2].location.end.filename,
             /* line number */ yystack_[2].location.end.line
-            );
-        if (driver.addSecRule(rule) == false) {
-            delete rule;
+            ));
+        if (driver.addSecRule(std::move(rule)) == false) {
             YYERROR;
         }
       }
-#line 2354 "seclang-parser.cc"
+#line 2352 "seclang-parser.cc"
     break;
 
   case 76:
-#line 1112 "seclang-parser.yy"
+#line 1110 "seclang-parser.yy"
       {
         std::vector<actions::Action *> *a = new std::vector<actions::Action *>();
         for (auto &i : *yystack_[0].value.as < std::unique_ptr<std::vector<std::unique_ptr<actions::Action> > >  > ().get()) {
             a->push_back(i.release());
         }
-        Rule *rule = new Rule(
+        std::unique_ptr<Rule> rule(new Rule(
             /* op */ NULL,
             /* variables */ NULL,
             /* actions */ a,
             /* file name */ *yystack_[1].location.end.filename,
             /* line number */ yystack_[1].location.end.line
-            );
-        driver.addSecAction(rule);
+            ));
+        driver.addSecAction(std::move(rule));
       }
-#line 2373 "seclang-parser.cc"
+#line 2371 "seclang-parser.cc"
     break;
 
   case 77:
-#line 1127 "seclang-parser.yy"
+#line 1125 "seclang-parser.yy"
       {
         std::string err;
         std::vector<actions::Action *> *a = new std::vector<actions::Action *>();
         for (auto &i : *yystack_[0].value.as < std::unique_ptr<std::vector<std::unique_ptr<actions::Action> > >  > ().get()) {
             a->push_back(i.release());
         }
-        RuleScript *r = new RuleScript(
+        std::unique_ptr<RuleScript> r(new RuleScript(
             /* path to script */ yystack_[1].value.as < std::string > (),
             /* actions */ a,
             /* file name */ *yystack_[1].location.end.filename,
             /* line number */ yystack_[1].location.end.line
-            );
+            ));
 
         if (r->init(&err) == false) {
             driver.error(yystack_[2].location, "Failed to load script: " + err);
-            delete r;
             YYERROR;
         }
-        if (driver.addSecRuleScript(r) == false) {
-            delete r;
+        if (driver.addSecRuleScript(std::move(r)) == false) {
             YYERROR;
         }
       }
-#line 2401 "seclang-parser.cc"
+#line 2397 "seclang-parser.cc"
     break;
 
   case 78:
-#line 1151 "seclang-parser.yy"
+#line 1147 "seclang-parser.yy"
       {
         bool hasDisruptive = false;
         std::vector<actions::Action *> *actions = new std::vector<actions::Action *>();
@@ -2457,75 +2453,75 @@ namespace yy {
 
         delete actions;
       }
-#line 2461 "seclang-parser.cc"
+#line 2457 "seclang-parser.cc"
     break;
 
   case 79:
-#line 1207 "seclang-parser.yy"
+#line 1203 "seclang-parser.yy"
       {
         driver.addSecMarker(modsecurity::utils::string::removeBracketsIfNeeded(yystack_[0].value.as < std::string > ()));
       }
-#line 2469 "seclang-parser.cc"
+#line 2465 "seclang-parser.cc"
     break;
 
   case 80:
-#line 1211 "seclang-parser.yy"
+#line 1207 "seclang-parser.yy"
       {
         driver.m_secRuleEngine = modsecurity::RulesSet::DisabledRuleEngine;
       }
-#line 2477 "seclang-parser.cc"
+#line 2473 "seclang-parser.cc"
     break;
 
   case 81:
-#line 1215 "seclang-parser.yy"
+#line 1211 "seclang-parser.yy"
       {
         driver.m_secRuleEngine = modsecurity::RulesSet::EnabledRuleEngine;
       }
-#line 2485 "seclang-parser.cc"
+#line 2481 "seclang-parser.cc"
     break;
 
   case 82:
-#line 1219 "seclang-parser.yy"
+#line 1215 "seclang-parser.yy"
       {
         driver.m_secRuleEngine = modsecurity::RulesSet::DetectionOnlyRuleEngine;
       }
-#line 2493 "seclang-parser.cc"
+#line 2489 "seclang-parser.cc"
     break;
 
   case 83:
-#line 1223 "seclang-parser.yy"
+#line 1219 "seclang-parser.yy"
       {
         driver.m_secRequestBodyAccess = modsecurity::RulesSetProperties::TrueConfigBoolean;
       }
-#line 2501 "seclang-parser.cc"
+#line 2497 "seclang-parser.cc"
     break;
 
   case 84:
-#line 1227 "seclang-parser.yy"
+#line 1223 "seclang-parser.yy"
       {
         driver.m_secRequestBodyAccess = modsecurity::RulesSetProperties::FalseConfigBoolean;
       }
-#line 2509 "seclang-parser.cc"
+#line 2505 "seclang-parser.cc"
     break;
 
   case 85:
-#line 1231 "seclang-parser.yy"
+#line 1227 "seclang-parser.yy"
       {
         driver.m_secResponseBodyAccess = modsecurity::RulesSetProperties::TrueConfigBoolean;
       }
-#line 2517 "seclang-parser.cc"
+#line 2513 "seclang-parser.cc"
     break;
 
   case 86:
-#line 1235 "seclang-parser.yy"
+#line 1231 "seclang-parser.yy"
       {
         driver.m_secResponseBodyAccess = modsecurity::RulesSetProperties::FalseConfigBoolean;
       }
-#line 2525 "seclang-parser.cc"
+#line 2521 "seclang-parser.cc"
     break;
 
   case 87:
-#line 1239 "seclang-parser.yy"
+#line 1235 "seclang-parser.yy"
       {
         if (yystack_[0].value.as < std::string > ().length() != 1) {
           driver.error(yystack_[1].location, "Argument separator should be set to a single character.");
@@ -2534,259 +2530,259 @@ namespace yy {
         driver.m_secArgumentSeparator.m_value = yystack_[0].value.as < std::string > ();
         driver.m_secArgumentSeparator.m_set = true;
       }
-#line 2538 "seclang-parser.cc"
+#line 2534 "seclang-parser.cc"
     break;
 
   case 88:
-#line 1248 "seclang-parser.yy"
+#line 1244 "seclang-parser.yy"
       {
         driver.m_components.push_back(yystack_[0].value.as < std::string > ());
       }
-#line 2546 "seclang-parser.cc"
+#line 2542 "seclang-parser.cc"
     break;
 
   case 89:
-#line 1252 "seclang-parser.yy"
+#line 1248 "seclang-parser.yy"
       {
         driver.error(yystack_[2].location, "SecConnEngine is not yet supported.");
         YYERROR;
       }
-#line 2555 "seclang-parser.cc"
+#line 2551 "seclang-parser.cc"
     break;
 
   case 90:
-#line 1257 "seclang-parser.yy"
+#line 1253 "seclang-parser.yy"
       {
       }
-#line 2562 "seclang-parser.cc"
+#line 2558 "seclang-parser.cc"
     break;
 
   case 91:
-#line 1260 "seclang-parser.yy"
+#line 1256 "seclang-parser.yy"
       {
         driver.m_secWebAppId.m_value = yystack_[0].value.as < std::string > ();
         driver.m_secWebAppId.m_set = true;
       }
-#line 2571 "seclang-parser.cc"
+#line 2567 "seclang-parser.cc"
     break;
 
   case 92:
-#line 1265 "seclang-parser.yy"
+#line 1261 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecServerSignature is not supported.");
         YYERROR;
       }
-#line 2580 "seclang-parser.cc"
+#line 2576 "seclang-parser.cc"
     break;
 
   case 93:
-#line 1270 "seclang-parser.yy"
+#line 1266 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecCacheTransformations is not supported.");
         YYERROR;
       }
-#line 2589 "seclang-parser.cc"
+#line 2585 "seclang-parser.cc"
     break;
 
   case 94:
-#line 1275 "seclang-parser.yy"
+#line 1271 "seclang-parser.yy"
       {
         driver.error(yystack_[2].location, "SecDisableBackendCompression is not supported.");
         YYERROR;
       }
-#line 2598 "seclang-parser.cc"
+#line 2594 "seclang-parser.cc"
     break;
 
   case 95:
-#line 1280 "seclang-parser.yy"
+#line 1276 "seclang-parser.yy"
       {
       }
-#line 2605 "seclang-parser.cc"
+#line 2601 "seclang-parser.cc"
     break;
 
   case 96:
-#line 1283 "seclang-parser.yy"
+#line 1279 "seclang-parser.yy"
       {
         driver.error(yystack_[2].location, "SecContentInjection is not yet supported.");
         YYERROR;
       }
-#line 2614 "seclang-parser.cc"
+#line 2610 "seclang-parser.cc"
     break;
 
   case 97:
-#line 1288 "seclang-parser.yy"
+#line 1284 "seclang-parser.yy"
       {
       }
-#line 2621 "seclang-parser.cc"
+#line 2617 "seclang-parser.cc"
     break;
 
   case 98:
-#line 1291 "seclang-parser.yy"
+#line 1287 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecChrootDir is not supported.");
         YYERROR;
       }
-#line 2630 "seclang-parser.cc"
+#line 2626 "seclang-parser.cc"
     break;
 
   case 99:
-#line 1296 "seclang-parser.yy"
+#line 1292 "seclang-parser.yy"
       {
         driver.error(yystack_[2].location, "SecHashEngine is not yet supported.");
         YYERROR;
       }
-#line 2639 "seclang-parser.cc"
+#line 2635 "seclang-parser.cc"
     break;
 
   case 100:
-#line 1301 "seclang-parser.yy"
+#line 1297 "seclang-parser.yy"
       {
       }
-#line 2646 "seclang-parser.cc"
+#line 2642 "seclang-parser.cc"
     break;
 
   case 101:
-#line 1304 "seclang-parser.yy"
+#line 1300 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecHashKey is not yet supported.");
         YYERROR;
       }
-#line 2655 "seclang-parser.cc"
+#line 2651 "seclang-parser.cc"
     break;
 
   case 102:
-#line 1309 "seclang-parser.yy"
+#line 1305 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecHashParam is not yet supported.");
         YYERROR;
       }
-#line 2664 "seclang-parser.cc"
+#line 2660 "seclang-parser.cc"
     break;
 
   case 103:
-#line 1314 "seclang-parser.yy"
+#line 1310 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecHashMethodRx is not yet supported.");
         YYERROR;
       }
-#line 2673 "seclang-parser.cc"
+#line 2669 "seclang-parser.cc"
     break;
 
   case 104:
-#line 1319 "seclang-parser.yy"
+#line 1315 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecHashMethodPm is not yet supported.");
         YYERROR;
       }
-#line 2682 "seclang-parser.cc"
+#line 2678 "seclang-parser.cc"
     break;
 
   case 105:
-#line 1324 "seclang-parser.yy"
+#line 1320 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecGsbLookupDb is not supported.");
         YYERROR;
       }
-#line 2691 "seclang-parser.cc"
+#line 2687 "seclang-parser.cc"
     break;
 
   case 106:
-#line 1329 "seclang-parser.yy"
+#line 1325 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecGuardianLog is not supported.");
         YYERROR;
       }
-#line 2700 "seclang-parser.cc"
+#line 2696 "seclang-parser.cc"
     break;
 
   case 107:
-#line 1334 "seclang-parser.yy"
+#line 1330 "seclang-parser.yy"
       {
         driver.error(yystack_[2].location, "SecInterceptOnError is not yet supported.");
         YYERROR;
       }
-#line 2709 "seclang-parser.cc"
+#line 2705 "seclang-parser.cc"
     break;
 
   case 108:
-#line 1339 "seclang-parser.yy"
+#line 1335 "seclang-parser.yy"
       {
       }
-#line 2716 "seclang-parser.cc"
+#line 2712 "seclang-parser.cc"
     break;
 
   case 109:
-#line 1342 "seclang-parser.yy"
+#line 1338 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecConnReadStateLimit is not yet supported.");
         YYERROR;
       }
-#line 2725 "seclang-parser.cc"
+#line 2721 "seclang-parser.cc"
     break;
 
   case 110:
-#line 1347 "seclang-parser.yy"
+#line 1343 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecConnWriteStateLimit is not yet supported.");
         YYERROR;
       }
-#line 2734 "seclang-parser.cc"
+#line 2730 "seclang-parser.cc"
     break;
 
   case 111:
-#line 1352 "seclang-parser.yy"
+#line 1348 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecSensorId is not yet supported.");
         YYERROR;
       }
-#line 2743 "seclang-parser.cc"
+#line 2739 "seclang-parser.cc"
     break;
 
   case 112:
-#line 1357 "seclang-parser.yy"
+#line 1353 "seclang-parser.yy"
       {
         driver.error(yystack_[2].location, "SecRuleInheritance is not yet supported.");
         YYERROR;
       }
-#line 2752 "seclang-parser.cc"
+#line 2748 "seclang-parser.cc"
     break;
 
   case 113:
-#line 1362 "seclang-parser.yy"
+#line 1358 "seclang-parser.yy"
       {
       }
-#line 2759 "seclang-parser.cc"
+#line 2755 "seclang-parser.cc"
     break;
 
   case 114:
-#line 1365 "seclang-parser.yy"
+#line 1361 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecRulePerfTime is not yet supported.");
         YYERROR;
       }
-#line 2768 "seclang-parser.cc"
+#line 2764 "seclang-parser.cc"
     break;
 
   case 115:
-#line 1370 "seclang-parser.yy"
+#line 1366 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecStreamInBodyInspection is not supported.");
         YYERROR;
       }
-#line 2777 "seclang-parser.cc"
+#line 2773 "seclang-parser.cc"
     break;
 
   case 116:
-#line 1375 "seclang-parser.yy"
+#line 1371 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecStreamOutBodyInspection is not supported.");
         YYERROR;
       }
-#line 2786 "seclang-parser.cc"
+#line 2782 "seclang-parser.cc"
     break;
 
   case 117:
-#line 1380 "seclang-parser.yy"
+#line 1376 "seclang-parser.yy"
       {
         std::string error;
         if (driver.m_exceptions.load(yystack_[0].value.as < std::string > (), &error) == false) {
@@ -2799,11 +2795,11 @@ namespace yy {
             YYERROR;
         }
       }
-#line 2803 "seclang-parser.cc"
+#line 2799 "seclang-parser.cc"
     break;
 
   case 118:
-#line 1393 "seclang-parser.yy"
+#line 1389 "seclang-parser.yy"
       {
         std::string error;
         if (driver.m_exceptions.loadRemoveRuleByTag(yystack_[0].value.as < std::string > (), &error) == false) {
@@ -2816,11 +2812,11 @@ namespace yy {
             YYERROR;
         }
       }
-#line 2820 "seclang-parser.cc"
+#line 2816 "seclang-parser.cc"
     break;
 
   case 119:
-#line 1406 "seclang-parser.yy"
+#line 1402 "seclang-parser.yy"
       {
         std::string error;
         if (driver.m_exceptions.loadRemoveRuleByMsg(yystack_[0].value.as < std::string > (), &error) == false) {
@@ -2833,11 +2829,11 @@ namespace yy {
             YYERROR;
         }
       }
-#line 2837 "seclang-parser.cc"
+#line 2833 "seclang-parser.cc"
     break;
 
   case 120:
-#line 1419 "seclang-parser.yy"
+#line 1415 "seclang-parser.yy"
       {
         std::string error;
         if (driver.m_exceptions.loadUpdateTargetByTag(yystack_[1].value.as < std::string > (), std::move(yystack_[0].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ()), &error) == false) {
@@ -2850,11 +2846,11 @@ namespace yy {
             YYERROR;
         }
       }
-#line 2854 "seclang-parser.cc"
+#line 2850 "seclang-parser.cc"
     break;
 
   case 121:
-#line 1432 "seclang-parser.yy"
+#line 1428 "seclang-parser.yy"
       {
         std::string error;
         if (driver.m_exceptions.loadUpdateTargetByMsg(yystack_[1].value.as < std::string > (), std::move(yystack_[0].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ()), &error) == false) {
@@ -2867,11 +2863,11 @@ namespace yy {
             YYERROR;
         }
       }
-#line 2871 "seclang-parser.cc"
+#line 2867 "seclang-parser.cc"
     break;
 
   case 122:
-#line 1445 "seclang-parser.yy"
+#line 1441 "seclang-parser.yy"
       {
         std::string error;
         double ruleId;
@@ -2897,11 +2893,11 @@ namespace yy {
             YYERROR;
         }
       }
-#line 2901 "seclang-parser.cc"
+#line 2897 "seclang-parser.cc"
     break;
 
   case 123:
-#line 1471 "seclang-parser.yy"
+#line 1467 "seclang-parser.yy"
       {
         std::string error;
         double ruleId;
@@ -2928,11 +2924,11 @@ namespace yy {
             YYERROR;
         }
       }
-#line 2932 "seclang-parser.cc"
+#line 2928 "seclang-parser.cc"
     break;
 
   case 124:
-#line 1499 "seclang-parser.yy"
+#line 1495 "seclang-parser.yy"
       {
         if (driver.m_debugLog != NULL) {
           driver.m_debugLog->setDebugLogLevel(atoi(yystack_[0].value.as < std::string > ().c_str()));
@@ -2944,11 +2940,11 @@ namespace yy {
             YYERROR;
         }
       }
-#line 2948 "seclang-parser.cc"
+#line 2944 "seclang-parser.cc"
     break;
 
   case 125:
-#line 1511 "seclang-parser.yy"
+#line 1507 "seclang-parser.yy"
       {
         if (driver.m_debugLog != NULL) {
             std::string error;
@@ -2967,11 +2963,11 @@ namespace yy {
             YYERROR;
         }
       }
-#line 2971 "seclang-parser.cc"
+#line 2967 "seclang-parser.cc"
     break;
 
   case 126:
-#line 1531 "seclang-parser.yy"
+#line 1527 "seclang-parser.yy"
       {
 #if defined(WITH_GEOIP) or defined(WITH_MAXMIND)
         std::string err;
@@ -2998,38 +2994,38 @@ namespace yy {
         YYERROR;
 #endif  // WITH_GEOIP
       }
-#line 3002 "seclang-parser.cc"
+#line 2998 "seclang-parser.cc"
     break;
 
   case 127:
-#line 1558 "seclang-parser.yy"
+#line 1554 "seclang-parser.yy"
       {
         driver.m_argumentsLimit.m_set = true;
         driver.m_argumentsLimit.m_value = atoi(yystack_[0].value.as < std::string > ().c_str());
       }
-#line 3011 "seclang-parser.cc"
+#line 3007 "seclang-parser.cc"
     break;
 
   case 128:
-#line 1564 "seclang-parser.yy"
+#line 1560 "seclang-parser.yy"
       {
         driver.m_requestBodyLimit.m_set = true;
         driver.m_requestBodyLimit.m_value = atoi(yystack_[0].value.as < std::string > ().c_str());
       }
-#line 3020 "seclang-parser.cc"
+#line 3016 "seclang-parser.cc"
     break;
 
   case 129:
-#line 1569 "seclang-parser.yy"
+#line 1565 "seclang-parser.yy"
       {
         driver.m_requestBodyNoFilesLimit.m_set = true;
         driver.m_requestBodyNoFilesLimit.m_value = atoi(yystack_[0].value.as < std::string > ().c_str());
       }
-#line 3029 "seclang-parser.cc"
+#line 3025 "seclang-parser.cc"
     break;
 
   case 130:
-#line 1574 "seclang-parser.yy"
+#line 1570 "seclang-parser.yy"
       {
         std::stringstream ss;
         ss << "As of ModSecurity version 3.0, SecRequestBodyInMemoryLimit is no longer ";
@@ -3038,68 +3034,68 @@ namespace yy {
         driver.error(yystack_[1].location, ss.str());
         YYERROR;
       }
-#line 3042 "seclang-parser.cc"
+#line 3038 "seclang-parser.cc"
     break;
 
   case 131:
-#line 1583 "seclang-parser.yy"
+#line 1579 "seclang-parser.yy"
       {
         driver.m_responseBodyLimit.m_set = true;
         driver.m_responseBodyLimit.m_value = atoi(yystack_[0].value.as < std::string > ().c_str());
       }
-#line 3051 "seclang-parser.cc"
+#line 3047 "seclang-parser.cc"
     break;
 
   case 132:
-#line 1588 "seclang-parser.yy"
+#line 1584 "seclang-parser.yy"
       {
         driver.m_requestBodyLimitAction = modsecurity::RulesSet::BodyLimitAction::ProcessPartialBodyLimitAction;
       }
-#line 3059 "seclang-parser.cc"
+#line 3055 "seclang-parser.cc"
     break;
 
   case 133:
-#line 1592 "seclang-parser.yy"
+#line 1588 "seclang-parser.yy"
       {
         driver.m_requestBodyLimitAction = modsecurity::RulesSet::BodyLimitAction::RejectBodyLimitAction;
       }
-#line 3067 "seclang-parser.cc"
+#line 3063 "seclang-parser.cc"
     break;
 
   case 134:
-#line 1596 "seclang-parser.yy"
+#line 1592 "seclang-parser.yy"
       {
         driver.m_responseBodyLimitAction = modsecurity::RulesSet::BodyLimitAction::ProcessPartialBodyLimitAction;
       }
-#line 3075 "seclang-parser.cc"
+#line 3071 "seclang-parser.cc"
     break;
 
   case 135:
-#line 1600 "seclang-parser.yy"
+#line 1596 "seclang-parser.yy"
       {
         driver.m_responseBodyLimitAction = modsecurity::RulesSet::BodyLimitAction::RejectBodyLimitAction;
       }
-#line 3083 "seclang-parser.cc"
+#line 3079 "seclang-parser.cc"
     break;
 
   case 136:
-#line 1604 "seclang-parser.yy"
+#line 1600 "seclang-parser.yy"
       {
         driver.m_remoteRulesActionOnFailed = RulesSet::OnFailedRemoteRulesAction::AbortOnFailedRemoteRulesAction;
       }
-#line 3091 "seclang-parser.cc"
+#line 3087 "seclang-parser.cc"
     break;
 
   case 137:
-#line 1608 "seclang-parser.yy"
+#line 1604 "seclang-parser.yy"
       {
         driver.m_remoteRulesActionOnFailed = RulesSet::OnFailedRemoteRulesAction::WarnOnFailedRemoteRulesAction;
       }
-#line 3099 "seclang-parser.cc"
+#line 3095 "seclang-parser.cc"
     break;
 
   case 140:
-#line 1622 "seclang-parser.yy"
+#line 1618 "seclang-parser.yy"
       {
         std::istringstream buf(yystack_[0].value.as < std::string > ());
         std::istream_iterator<std::string> beg(buf), end;
@@ -3111,37 +3107,37 @@ namespace yy {
             driver.m_responseBodyTypeToBeInspected.m_value.insert(*it);
         }
       }
-#line 3115 "seclang-parser.cc"
+#line 3111 "seclang-parser.cc"
     break;
 
   case 141:
-#line 1634 "seclang-parser.yy"
+#line 1630 "seclang-parser.yy"
       {
         driver.m_responseBodyTypeToBeInspected.m_set = true;
         driver.m_responseBodyTypeToBeInspected.m_clear = true;
         driver.m_responseBodyTypeToBeInspected.m_value.clear();
       }
-#line 3125 "seclang-parser.cc"
+#line 3121 "seclang-parser.cc"
     break;
 
   case 142:
-#line 1640 "seclang-parser.yy"
+#line 1636 "seclang-parser.yy"
       {
         driver.m_secXMLExternalEntity = modsecurity::RulesSetProperties::FalseConfigBoolean;
       }
-#line 3133 "seclang-parser.cc"
+#line 3129 "seclang-parser.cc"
     break;
 
   case 143:
-#line 1644 "seclang-parser.yy"
+#line 1640 "seclang-parser.yy"
       {
         driver.m_secXMLExternalEntity = modsecurity::RulesSetProperties::TrueConfigBoolean;
       }
-#line 3141 "seclang-parser.cc"
+#line 3137 "seclang-parser.cc"
     break;
 
   case 144:
-#line 1648 "seclang-parser.yy"
+#line 1644 "seclang-parser.yy"
       {
 /* Parser error disabled to avoid breaking default installations with modsecurity.conf-recommended
         std::stringstream ss;
@@ -3152,31 +3148,31 @@ namespace yy {
         YYERROR;
 */
       }
-#line 3156 "seclang-parser.cc"
+#line 3152 "seclang-parser.cc"
     break;
 
   case 147:
-#line 1669 "seclang-parser.yy"
+#line 1665 "seclang-parser.yy"
       {
         if (atoi(yystack_[0].value.as < std::string > ().c_str()) == 1) {
           driver.error(yystack_[1].location, "SecCookieFormat 1 is not yet supported.");
           YYERROR;
         }
       }
-#line 3167 "seclang-parser.cc"
+#line 3163 "seclang-parser.cc"
     break;
 
   case 148:
-#line 1676 "seclang-parser.yy"
+#line 1672 "seclang-parser.yy"
       {
         driver.error(yystack_[1].location, "SecCookieV0Separator is not yet supported.");
         YYERROR;
       }
-#line 3176 "seclang-parser.cc"
+#line 3172 "seclang-parser.cc"
     break;
 
   case 150:
-#line 1686 "seclang-parser.yy"
+#line 1682 "seclang-parser.yy"
       {
         std::string error;
         std::vector<std::string> param;
@@ -3230,31 +3226,31 @@ namespace yy {
         }
 
       }
-#line 3234 "seclang-parser.cc"
+#line 3230 "seclang-parser.cc"
     break;
 
   case 151:
-#line 1740 "seclang-parser.yy"
+#line 1736 "seclang-parser.yy"
       {
 /* Parser error disabled to avoid breaking default CRS installations with crs-setup.conf-recommended
         driver.error(@0, "SecCollectionTimeout is not yet supported.");
         YYERROR;
 */
       }
-#line 3245 "seclang-parser.cc"
+#line 3241 "seclang-parser.cc"
     break;
 
   case 152:
-#line 1747 "seclang-parser.yy"
+#line 1743 "seclang-parser.yy"
       {
         driver.m_httpblKey.m_set = true;
         driver.m_httpblKey.m_value = yystack_[0].value.as < std::string > ();
       }
-#line 3254 "seclang-parser.cc"
+#line 3250 "seclang-parser.cc"
     break;
 
   case 153:
-#line 1755 "seclang-parser.yy"
+#line 1751 "seclang-parser.yy"
       {
         std::unique_ptr<std::vector<std::unique_ptr<Variable> > > originalList = std::move(yystack_[0].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ());
         std::unique_ptr<std::vector<std::unique_ptr<Variable>>> newList(new std::vector<std::unique_ptr<Variable>>());
@@ -3288,2363 +3284,2363 @@ namespace yy {
         }
         yylhs.value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > () = std::move(newNewList);
       }
-#line 3292 "seclang-parser.cc"
+#line 3288 "seclang-parser.cc"
     break;
 
   case 154:
-#line 1792 "seclang-parser.yy"
+#line 1788 "seclang-parser.yy"
       {
         yylhs.value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > () = std::move(yystack_[0].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ());
       }
-#line 3300 "seclang-parser.cc"
+#line 3296 "seclang-parser.cc"
     break;
 
   case 155:
-#line 1796 "seclang-parser.yy"
+#line 1792 "seclang-parser.yy"
       {
         yylhs.value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > () = std::move(yystack_[1].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ());
       }
-#line 3308 "seclang-parser.cc"
+#line 3304 "seclang-parser.cc"
     break;
 
   case 156:
-#line 1803 "seclang-parser.yy"
+#line 1799 "seclang-parser.yy"
       {
         yystack_[2].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ()->push_back(std::move(yystack_[0].value.as < std::unique_ptr<Variable> > ()));
         yylhs.value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > () = std::move(yystack_[2].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ());
       }
-#line 3317 "seclang-parser.cc"
+#line 3313 "seclang-parser.cc"
     break;
 
   case 157:
-#line 1808 "seclang-parser.yy"
+#line 1804 "seclang-parser.yy"
       {
         std::unique_ptr<Variable> c(new VariableModificatorExclusion(std::move(yystack_[0].value.as < std::unique_ptr<Variable> > ())));
         yystack_[3].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ()->push_back(std::move(c));
         yylhs.value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > () = std::move(yystack_[3].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ());
       }
-#line 3327 "seclang-parser.cc"
+#line 3323 "seclang-parser.cc"
     break;
 
   case 158:
-#line 1814 "seclang-parser.yy"
+#line 1810 "seclang-parser.yy"
       {
         std::unique_ptr<Variable> c(new VariableModificatorCount(std::move(yystack_[0].value.as < std::unique_ptr<Variable> > ())));
         yystack_[3].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ()->push_back(std::move(c));
         yylhs.value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > () = std::move(yystack_[3].value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ());
       }
-#line 3337 "seclang-parser.cc"
+#line 3333 "seclang-parser.cc"
     break;
 
   case 159:
-#line 1820 "seclang-parser.yy"
+#line 1816 "seclang-parser.yy"
       {
         std::unique_ptr<std::vector<std::unique_ptr<Variable>>> b(new std::vector<std::unique_ptr<Variable>>());
         b->push_back(std::move(yystack_[0].value.as < std::unique_ptr<Variable> > ()));
         yylhs.value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > () = std::move(b);
       }
-#line 3347 "seclang-parser.cc"
+#line 3343 "seclang-parser.cc"
     break;
 
   case 160:
-#line 1826 "seclang-parser.yy"
+#line 1822 "seclang-parser.yy"
       {
         std::unique_ptr<std::vector<std::unique_ptr<Variable>>> b(new std::vector<std::unique_ptr<Variable>>());
         std::unique_ptr<Variable> c(new VariableModificatorExclusion(std::move(yystack_[0].value.as < std::unique_ptr<Variable> > ())));
         b->push_back(std::move(c));
         yylhs.value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > () = std::move(b);
       }
-#line 3358 "seclang-parser.cc"
+#line 3354 "seclang-parser.cc"
     break;
 
   case 161:
-#line 1833 "seclang-parser.yy"
+#line 1829 "seclang-parser.yy"
       {
         std::unique_ptr<std::vector<std::unique_ptr<Variable>>> b(new std::vector<std::unique_ptr<Variable>>());
         std::unique_ptr<Variable> c(new VariableModificatorCount(std::move(yystack_[0].value.as < std::unique_ptr<Variable> > ())));
         b->push_back(std::move(c));
         yylhs.value.as < std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > () = std::move(b);
       }
-#line 3369 "seclang-parser.cc"
+#line 3365 "seclang-parser.cc"
     break;
 
   case 162:
-#line 1843 "seclang-parser.yy"
+#line 1839 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Args_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3377 "seclang-parser.cc"
+#line 3373 "seclang-parser.cc"
     break;
 
   case 163:
-#line 1847 "seclang-parser.yy"
+#line 1843 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Args_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3385 "seclang-parser.cc"
+#line 3381 "seclang-parser.cc"
     break;
 
   case 164:
-#line 1851 "seclang-parser.yy"
+#line 1847 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Args_NoDictElement());
       }
-#line 3393 "seclang-parser.cc"
+#line 3389 "seclang-parser.cc"
     break;
 
   case 165:
-#line 1855 "seclang-parser.yy"
+#line 1851 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsPost_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3401 "seclang-parser.cc"
+#line 3397 "seclang-parser.cc"
     break;
 
   case 166:
-#line 1859 "seclang-parser.yy"
+#line 1855 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsPost_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3409 "seclang-parser.cc"
+#line 3405 "seclang-parser.cc"
     break;
 
   case 167:
-#line 1863 "seclang-parser.yy"
+#line 1859 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsPost_NoDictElement());
       }
-#line 3417 "seclang-parser.cc"
+#line 3413 "seclang-parser.cc"
     break;
 
   case 168:
-#line 1867 "seclang-parser.yy"
+#line 1863 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsGet_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3425 "seclang-parser.cc"
+#line 3421 "seclang-parser.cc"
     break;
 
   case 169:
-#line 1871 "seclang-parser.yy"
+#line 1867 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsGet_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3433 "seclang-parser.cc"
+#line 3429 "seclang-parser.cc"
     break;
 
   case 170:
-#line 1875 "seclang-parser.yy"
+#line 1871 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsGet_NoDictElement());
       }
-#line 3441 "seclang-parser.cc"
+#line 3437 "seclang-parser.cc"
     break;
 
   case 171:
-#line 1879 "seclang-parser.yy"
+#line 1875 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesSizes_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3449 "seclang-parser.cc"
+#line 3445 "seclang-parser.cc"
     break;
 
   case 172:
-#line 1883 "seclang-parser.yy"
+#line 1879 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesSizes_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3457 "seclang-parser.cc"
+#line 3453 "seclang-parser.cc"
     break;
 
   case 173:
-#line 1887 "seclang-parser.yy"
+#line 1883 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesSizes_NoDictElement());
       }
-#line 3465 "seclang-parser.cc"
+#line 3461 "seclang-parser.cc"
     break;
 
   case 174:
-#line 1891 "seclang-parser.yy"
+#line 1887 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesNames_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3473 "seclang-parser.cc"
+#line 3469 "seclang-parser.cc"
     break;
 
   case 175:
-#line 1895 "seclang-parser.yy"
+#line 1891 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesNames_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3481 "seclang-parser.cc"
+#line 3477 "seclang-parser.cc"
     break;
 
   case 176:
-#line 1899 "seclang-parser.yy"
+#line 1895 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesNames_NoDictElement());
       }
-#line 3489 "seclang-parser.cc"
+#line 3485 "seclang-parser.cc"
     break;
 
   case 177:
-#line 1903 "seclang-parser.yy"
+#line 1899 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesTmpContent_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3497 "seclang-parser.cc"
+#line 3493 "seclang-parser.cc"
     break;
 
   case 178:
-#line 1907 "seclang-parser.yy"
+#line 1903 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesTmpContent_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3505 "seclang-parser.cc"
+#line 3501 "seclang-parser.cc"
     break;
 
   case 179:
-#line 1911 "seclang-parser.yy"
+#line 1907 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesTmpContent_NoDictElement());
       }
-#line 3513 "seclang-parser.cc"
+#line 3509 "seclang-parser.cc"
     break;
 
   case 180:
-#line 1915 "seclang-parser.yy"
+#line 1911 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultiPartFileName_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3521 "seclang-parser.cc"
+#line 3517 "seclang-parser.cc"
     break;
 
   case 181:
-#line 1919 "seclang-parser.yy"
+#line 1915 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultiPartFileName_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3529 "seclang-parser.cc"
+#line 3525 "seclang-parser.cc"
     break;
 
   case 182:
-#line 1923 "seclang-parser.yy"
+#line 1919 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultiPartFileName_NoDictElement());
       }
-#line 3537 "seclang-parser.cc"
+#line 3533 "seclang-parser.cc"
     break;
 
   case 183:
-#line 1927 "seclang-parser.yy"
+#line 1923 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultiPartName_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3545 "seclang-parser.cc"
+#line 3541 "seclang-parser.cc"
     break;
 
   case 184:
-#line 1931 "seclang-parser.yy"
+#line 1927 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultiPartName_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3553 "seclang-parser.cc"
+#line 3549 "seclang-parser.cc"
     break;
 
   case 185:
-#line 1935 "seclang-parser.yy"
+#line 1931 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultiPartName_NoDictElement());
       }
-#line 3561 "seclang-parser.cc"
+#line 3557 "seclang-parser.cc"
     break;
 
   case 186:
-#line 1939 "seclang-parser.yy"
+#line 1935 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MatchedVarsNames_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3569 "seclang-parser.cc"
+#line 3565 "seclang-parser.cc"
     break;
 
   case 187:
-#line 1943 "seclang-parser.yy"
+#line 1939 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MatchedVarsNames_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3577 "seclang-parser.cc"
+#line 3573 "seclang-parser.cc"
     break;
 
   case 188:
-#line 1947 "seclang-parser.yy"
+#line 1943 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MatchedVarsNames_NoDictElement());
       }
-#line 3585 "seclang-parser.cc"
+#line 3581 "seclang-parser.cc"
     break;
 
   case 189:
-#line 1951 "seclang-parser.yy"
+#line 1947 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MatchedVars_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3593 "seclang-parser.cc"
+#line 3589 "seclang-parser.cc"
     break;
 
   case 190:
-#line 1955 "seclang-parser.yy"
+#line 1951 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MatchedVars_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3601 "seclang-parser.cc"
+#line 3597 "seclang-parser.cc"
     break;
 
   case 191:
-#line 1959 "seclang-parser.yy"
+#line 1955 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MatchedVars_NoDictElement());
       }
-#line 3609 "seclang-parser.cc"
+#line 3605 "seclang-parser.cc"
     break;
 
   case 192:
-#line 1963 "seclang-parser.yy"
+#line 1959 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Files_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3617 "seclang-parser.cc"
+#line 3613 "seclang-parser.cc"
     break;
 
   case 193:
-#line 1967 "seclang-parser.yy"
+#line 1963 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Files_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3625 "seclang-parser.cc"
+#line 3621 "seclang-parser.cc"
     break;
 
   case 194:
-#line 1971 "seclang-parser.yy"
+#line 1967 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Files_NoDictElement());
       }
-#line 3633 "seclang-parser.cc"
+#line 3629 "seclang-parser.cc"
     break;
 
   case 195:
-#line 1975 "seclang-parser.yy"
+#line 1971 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestCookies_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3641 "seclang-parser.cc"
+#line 3637 "seclang-parser.cc"
     break;
 
   case 196:
-#line 1979 "seclang-parser.yy"
+#line 1975 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestCookies_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3649 "seclang-parser.cc"
+#line 3645 "seclang-parser.cc"
     break;
 
   case 197:
-#line 1983 "seclang-parser.yy"
+#line 1979 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestCookies_NoDictElement());
       }
-#line 3657 "seclang-parser.cc"
+#line 3653 "seclang-parser.cc"
     break;
 
   case 198:
-#line 1987 "seclang-parser.yy"
+#line 1983 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestHeaders_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3665 "seclang-parser.cc"
+#line 3661 "seclang-parser.cc"
     break;
 
   case 199:
-#line 1991 "seclang-parser.yy"
+#line 1987 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestHeaders_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3673 "seclang-parser.cc"
+#line 3669 "seclang-parser.cc"
     break;
 
   case 200:
-#line 1995 "seclang-parser.yy"
+#line 1991 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestHeaders_NoDictElement());
       }
-#line 3681 "seclang-parser.cc"
+#line 3677 "seclang-parser.cc"
     break;
 
   case 201:
-#line 1999 "seclang-parser.yy"
+#line 1995 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ResponseHeaders_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3689 "seclang-parser.cc"
+#line 3685 "seclang-parser.cc"
     break;
 
   case 202:
-#line 2003 "seclang-parser.yy"
+#line 1999 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ResponseHeaders_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3697 "seclang-parser.cc"
+#line 3693 "seclang-parser.cc"
     break;
 
   case 203:
-#line 2007 "seclang-parser.yy"
+#line 2003 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ResponseHeaders_NoDictElement());
       }
-#line 3705 "seclang-parser.cc"
+#line 3701 "seclang-parser.cc"
     break;
 
   case 204:
-#line 2011 "seclang-parser.yy"
+#line 2007 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Geo_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3713 "seclang-parser.cc"
+#line 3709 "seclang-parser.cc"
     break;
 
   case 205:
-#line 2015 "seclang-parser.yy"
+#line 2011 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Geo_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3721 "seclang-parser.cc"
+#line 3717 "seclang-parser.cc"
     break;
 
   case 206:
-#line 2019 "seclang-parser.yy"
+#line 2015 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Geo_NoDictElement());
       }
-#line 3729 "seclang-parser.cc"
+#line 3725 "seclang-parser.cc"
     break;
 
   case 207:
-#line 2023 "seclang-parser.yy"
+#line 2019 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestCookiesNames_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3737 "seclang-parser.cc"
+#line 3733 "seclang-parser.cc"
     break;
 
   case 208:
-#line 2027 "seclang-parser.yy"
+#line 2023 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestCookiesNames_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3745 "seclang-parser.cc"
+#line 3741 "seclang-parser.cc"
     break;
 
   case 209:
-#line 2031 "seclang-parser.yy"
+#line 2027 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestCookiesNames_NoDictElement());
       }
-#line 3753 "seclang-parser.cc"
+#line 3749 "seclang-parser.cc"
     break;
 
   case 210:
-#line 2035 "seclang-parser.yy"
+#line 2031 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Rule_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3761 "seclang-parser.cc"
+#line 3757 "seclang-parser.cc"
     break;
 
   case 211:
-#line 2039 "seclang-parser.yy"
+#line 2035 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Rule_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3769 "seclang-parser.cc"
+#line 3765 "seclang-parser.cc"
     break;
 
   case 212:
-#line 2043 "seclang-parser.yy"
+#line 2039 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Rule_NoDictElement());
       }
-#line 3777 "seclang-parser.cc"
+#line 3773 "seclang-parser.cc"
     break;
 
   case 213:
+#line 2043 "seclang-parser.yy"
+      {
+        VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Env("ENV:" + yystack_[0].value.as < std::string > ()));
+      }
+#line 3781 "seclang-parser.cc"
+    break;
+
+  case 214:
 #line 2047 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Env("ENV:" + yystack_[0].value.as < std::string > ()));
       }
-#line 3785 "seclang-parser.cc"
-    break;
-
-  case 214:
-#line 2051 "seclang-parser.yy"
-      {
-        VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Env("ENV:" + yystack_[0].value.as < std::string > ()));
-      }
-#line 3793 "seclang-parser.cc"
+#line 3789 "seclang-parser.cc"
     break;
 
   case 215:
-#line 2055 "seclang-parser.yy"
+#line 2051 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Env("ENV"));
       }
-#line 3801 "seclang-parser.cc"
+#line 3797 "seclang-parser.cc"
     break;
 
   case 216:
+#line 2055 "seclang-parser.yy"
+      {
+        VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::XML("XML:" + yystack_[0].value.as < std::string > ()));
+      }
+#line 3805 "seclang-parser.cc"
+    break;
+
+  case 217:
 #line 2059 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::XML("XML:" + yystack_[0].value.as < std::string > ()));
       }
-#line 3809 "seclang-parser.cc"
-    break;
-
-  case 217:
-#line 2063 "seclang-parser.yy"
-      {
-        VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::XML("XML:" + yystack_[0].value.as < std::string > ()));
-      }
-#line 3817 "seclang-parser.cc"
+#line 3813 "seclang-parser.cc"
     break;
 
   case 218:
-#line 2067 "seclang-parser.yy"
+#line 2063 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::XML_NoDictElement());
       }
-#line 3825 "seclang-parser.cc"
+#line 3821 "seclang-parser.cc"
     break;
 
   case 219:
-#line 2071 "seclang-parser.yy"
+#line 2067 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesTmpNames_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3833 "seclang-parser.cc"
+#line 3829 "seclang-parser.cc"
     break;
 
   case 220:
-#line 2075 "seclang-parser.yy"
+#line 2071 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesTmpNames_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3841 "seclang-parser.cc"
+#line 3837 "seclang-parser.cc"
     break;
 
   case 221:
-#line 2079 "seclang-parser.yy"
+#line 2075 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesTmpNames_NoDictElement());
       }
-#line 3849 "seclang-parser.cc"
+#line 3845 "seclang-parser.cc"
     break;
 
   case 222:
-#line 2083 "seclang-parser.yy"
+#line 2079 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Resource_DynamicElement(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 3857 "seclang-parser.cc"
+#line 3853 "seclang-parser.cc"
     break;
 
   case 223:
-#line 2087 "seclang-parser.yy"
+#line 2083 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Resource_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3865 "seclang-parser.cc"
+#line 3861 "seclang-parser.cc"
     break;
 
   case 224:
-#line 2091 "seclang-parser.yy"
+#line 2087 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Resource_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3873 "seclang-parser.cc"
+#line 3869 "seclang-parser.cc"
     break;
 
   case 225:
-#line 2095 "seclang-parser.yy"
+#line 2091 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Resource_NoDictElement());
       }
-#line 3881 "seclang-parser.cc"
+#line 3877 "seclang-parser.cc"
     break;
 
   case 226:
-#line 2099 "seclang-parser.yy"
+#line 2095 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Ip_DynamicElement(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 3889 "seclang-parser.cc"
+#line 3885 "seclang-parser.cc"
     break;
 
   case 227:
-#line 2103 "seclang-parser.yy"
+#line 2099 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Ip_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3897 "seclang-parser.cc"
+#line 3893 "seclang-parser.cc"
     break;
 
   case 228:
-#line 2107 "seclang-parser.yy"
+#line 2103 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Ip_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3905 "seclang-parser.cc"
+#line 3901 "seclang-parser.cc"
     break;
 
   case 229:
-#line 2111 "seclang-parser.yy"
+#line 2107 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Ip_NoDictElement());
       }
-#line 3913 "seclang-parser.cc"
+#line 3909 "seclang-parser.cc"
     break;
 
   case 230:
-#line 2115 "seclang-parser.yy"
+#line 2111 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Global_DynamicElement(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 3921 "seclang-parser.cc"
+#line 3917 "seclang-parser.cc"
     break;
 
   case 231:
-#line 2119 "seclang-parser.yy"
+#line 2115 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Global_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3929 "seclang-parser.cc"
+#line 3925 "seclang-parser.cc"
     break;
 
   case 232:
-#line 2123 "seclang-parser.yy"
+#line 2119 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Global_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3937 "seclang-parser.cc"
+#line 3933 "seclang-parser.cc"
     break;
 
   case 233:
-#line 2127 "seclang-parser.yy"
+#line 2123 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Global_NoDictElement());
       }
-#line 3945 "seclang-parser.cc"
+#line 3941 "seclang-parser.cc"
     break;
 
   case 234:
-#line 2131 "seclang-parser.yy"
+#line 2127 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::User_DynamicElement(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 3953 "seclang-parser.cc"
+#line 3949 "seclang-parser.cc"
     break;
 
   case 235:
-#line 2135 "seclang-parser.yy"
+#line 2131 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::User_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3961 "seclang-parser.cc"
+#line 3957 "seclang-parser.cc"
     break;
 
   case 236:
-#line 2139 "seclang-parser.yy"
+#line 2135 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::User_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 3969 "seclang-parser.cc"
+#line 3965 "seclang-parser.cc"
     break;
 
   case 237:
-#line 2143 "seclang-parser.yy"
+#line 2139 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::User_NoDictElement());
       }
-#line 3977 "seclang-parser.cc"
+#line 3973 "seclang-parser.cc"
     break;
 
   case 238:
-#line 2147 "seclang-parser.yy"
+#line 2143 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Tx_DynamicElement(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 3985 "seclang-parser.cc"
+#line 3981 "seclang-parser.cc"
     break;
 
   case 239:
-#line 2151 "seclang-parser.yy"
+#line 2147 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Tx_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 3993 "seclang-parser.cc"
+#line 3989 "seclang-parser.cc"
     break;
 
   case 240:
-#line 2155 "seclang-parser.yy"
+#line 2151 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Tx_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 4001 "seclang-parser.cc"
+#line 3997 "seclang-parser.cc"
     break;
 
   case 241:
-#line 2159 "seclang-parser.yy"
+#line 2155 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Tx_NoDictElement());
       }
-#line 4009 "seclang-parser.cc"
+#line 4005 "seclang-parser.cc"
     break;
 
   case 242:
-#line 2163 "seclang-parser.yy"
+#line 2159 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Session_DynamicElement(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 4017 "seclang-parser.cc"
+#line 4013 "seclang-parser.cc"
     break;
 
   case 243:
-#line 2167 "seclang-parser.yy"
+#line 2163 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Session_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 4025 "seclang-parser.cc"
+#line 4021 "seclang-parser.cc"
     break;
 
   case 244:
-#line 2171 "seclang-parser.yy"
+#line 2167 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Session_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 4033 "seclang-parser.cc"
+#line 4029 "seclang-parser.cc"
     break;
 
   case 245:
-#line 2175 "seclang-parser.yy"
+#line 2171 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Session_NoDictElement());
       }
-#line 4041 "seclang-parser.cc"
+#line 4037 "seclang-parser.cc"
     break;
 
   case 246:
-#line 2179 "seclang-parser.yy"
+#line 2175 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsNames_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 4049 "seclang-parser.cc"
+#line 4045 "seclang-parser.cc"
     break;
 
   case 247:
-#line 2183 "seclang-parser.yy"
+#line 2179 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsNames_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 4057 "seclang-parser.cc"
+#line 4053 "seclang-parser.cc"
     break;
 
   case 248:
-#line 2187 "seclang-parser.yy"
+#line 2183 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsNames_NoDictElement());
       }
-#line 4065 "seclang-parser.cc"
+#line 4061 "seclang-parser.cc"
     break;
 
   case 249:
-#line 2191 "seclang-parser.yy"
+#line 2187 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsGetNames_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 4073 "seclang-parser.cc"
+#line 4069 "seclang-parser.cc"
     break;
 
   case 250:
-#line 2195 "seclang-parser.yy"
+#line 2191 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsGetNames_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 4081 "seclang-parser.cc"
+#line 4077 "seclang-parser.cc"
     break;
 
   case 251:
-#line 2199 "seclang-parser.yy"
+#line 2195 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsGetNames_NoDictElement());
       }
-#line 4089 "seclang-parser.cc"
+#line 4085 "seclang-parser.cc"
     break;
 
   case 252:
-#line 2204 "seclang-parser.yy"
+#line 2200 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsPostNames_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 4097 "seclang-parser.cc"
+#line 4093 "seclang-parser.cc"
     break;
 
   case 253:
-#line 2208 "seclang-parser.yy"
+#line 2204 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsPostNames_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 4105 "seclang-parser.cc"
+#line 4101 "seclang-parser.cc"
     break;
 
   case 254:
-#line 2212 "seclang-parser.yy"
+#line 2208 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsPostNames_NoDictElement());
       }
-#line 4113 "seclang-parser.cc"
+#line 4109 "seclang-parser.cc"
     break;
 
   case 255:
-#line 2217 "seclang-parser.yy"
+#line 2213 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestHeadersNames_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 4121 "seclang-parser.cc"
+#line 4117 "seclang-parser.cc"
     break;
 
   case 256:
-#line 2221 "seclang-parser.yy"
+#line 2217 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestHeadersNames_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 4129 "seclang-parser.cc"
+#line 4125 "seclang-parser.cc"
     break;
 
   case 257:
-#line 2225 "seclang-parser.yy"
+#line 2221 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestHeadersNames_NoDictElement());
       }
-#line 4137 "seclang-parser.cc"
+#line 4133 "seclang-parser.cc"
     break;
 
   case 258:
-#line 2230 "seclang-parser.yy"
+#line 2226 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ResponseContentType());
       }
-#line 4145 "seclang-parser.cc"
+#line 4141 "seclang-parser.cc"
     break;
 
   case 259:
-#line 2235 "seclang-parser.yy"
+#line 2231 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ResponseHeadersNames_DictElement(yystack_[0].value.as < std::string > ()));
       }
-#line 4153 "seclang-parser.cc"
+#line 4149 "seclang-parser.cc"
     break;
 
   case 260:
-#line 2239 "seclang-parser.yy"
+#line 2235 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ResponseHeadersNames_DictElementRegexp(yystack_[0].value.as < std::string > ()));
       }
-#line 4161 "seclang-parser.cc"
+#line 4157 "seclang-parser.cc"
     break;
 
   case 261:
-#line 2243 "seclang-parser.yy"
+#line 2239 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ResponseHeadersNames_NoDictElement());
       }
-#line 4169 "seclang-parser.cc"
+#line 4165 "seclang-parser.cc"
     break;
 
   case 262:
-#line 2247 "seclang-parser.yy"
+#line 2243 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ArgsCombinedSize());
       }
-#line 4177 "seclang-parser.cc"
+#line 4173 "seclang-parser.cc"
     break;
 
   case 263:
-#line 2251 "seclang-parser.yy"
+#line 2247 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::AuthType());
       }
-#line 4185 "seclang-parser.cc"
+#line 4181 "seclang-parser.cc"
     break;
 
   case 264:
-#line 2255 "seclang-parser.yy"
+#line 2251 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FilesCombinedSize());
       }
-#line 4193 "seclang-parser.cc"
+#line 4189 "seclang-parser.cc"
     break;
 
   case 265:
-#line 2259 "seclang-parser.yy"
+#line 2255 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FullRequest());
       }
-#line 4201 "seclang-parser.cc"
+#line 4197 "seclang-parser.cc"
     break;
 
   case 266:
-#line 2263 "seclang-parser.yy"
+#line 2259 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::FullRequestLength());
       }
-#line 4209 "seclang-parser.cc"
+#line 4205 "seclang-parser.cc"
     break;
 
   case 267:
-#line 2267 "seclang-parser.yy"
+#line 2263 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::InboundDataError());
       }
-#line 4217 "seclang-parser.cc"
+#line 4213 "seclang-parser.cc"
     break;
 
   case 268:
-#line 2271 "seclang-parser.yy"
+#line 2267 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MatchedVar());
       }
-#line 4225 "seclang-parser.cc"
+#line 4221 "seclang-parser.cc"
     break;
 
   case 269:
-#line 2275 "seclang-parser.yy"
+#line 2271 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MatchedVarName());
       }
-#line 4233 "seclang-parser.cc"
+#line 4229 "seclang-parser.cc"
     break;
 
   case 270:
-#line 2279 "seclang-parser.yy"
+#line 2275 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartBoundaryQuoted());
       }
-#line 4241 "seclang-parser.cc"
+#line 4237 "seclang-parser.cc"
     break;
 
   case 271:
-#line 2283 "seclang-parser.yy"
+#line 2279 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartBoundaryWhiteSpace());
       }
-#line 4249 "seclang-parser.cc"
+#line 4245 "seclang-parser.cc"
     break;
 
   case 272:
-#line 2287 "seclang-parser.yy"
+#line 2283 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartCrlfLFLines());
       }
-#line 4257 "seclang-parser.cc"
+#line 4253 "seclang-parser.cc"
     break;
 
   case 273:
-#line 2291 "seclang-parser.yy"
+#line 2287 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartDateAfter());
       }
-#line 4265 "seclang-parser.cc"
+#line 4261 "seclang-parser.cc"
     break;
 
   case 274:
-#line 2295 "seclang-parser.yy"
+#line 2291 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartDateBefore());
       }
-#line 4273 "seclang-parser.cc"
+#line 4269 "seclang-parser.cc"
     break;
 
   case 275:
-#line 2299 "seclang-parser.yy"
+#line 2295 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartFileLimitExceeded());
       }
-#line 4281 "seclang-parser.cc"
+#line 4277 "seclang-parser.cc"
     break;
 
   case 276:
-#line 2303 "seclang-parser.yy"
+#line 2299 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartHeaderFolding());
       }
-#line 4289 "seclang-parser.cc"
+#line 4285 "seclang-parser.cc"
     break;
 
   case 277:
-#line 2307 "seclang-parser.yy"
+#line 2303 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartInvalidHeaderFolding());
       }
-#line 4297 "seclang-parser.cc"
+#line 4293 "seclang-parser.cc"
     break;
 
   case 278:
-#line 2311 "seclang-parser.yy"
+#line 2307 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartInvalidPart());
       }
-#line 4305 "seclang-parser.cc"
+#line 4301 "seclang-parser.cc"
     break;
 
   case 279:
-#line 2315 "seclang-parser.yy"
+#line 2311 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartInvalidQuoting());
       }
-#line 4313 "seclang-parser.cc"
+#line 4309 "seclang-parser.cc"
     break;
 
   case 280:
-#line 2319 "seclang-parser.yy"
+#line 2315 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartLFLine());
       }
-#line 4321 "seclang-parser.cc"
+#line 4317 "seclang-parser.cc"
     break;
 
   case 281:
+#line 2319 "seclang-parser.yy"
+      {
+        VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartMissingSemicolon());
+      }
+#line 4325 "seclang-parser.cc"
+    break;
+
+  case 282:
 #line 2323 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartMissingSemicolon());
       }
-#line 4329 "seclang-parser.cc"
-    break;
-
-  case 282:
-#line 2327 "seclang-parser.yy"
-      {
-        VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartMissingSemicolon());
-      }
-#line 4337 "seclang-parser.cc"
+#line 4333 "seclang-parser.cc"
     break;
 
   case 283:
-#line 2331 "seclang-parser.yy"
+#line 2327 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartStrictError());
       }
-#line 4345 "seclang-parser.cc"
+#line 4341 "seclang-parser.cc"
     break;
 
   case 284:
-#line 2335 "seclang-parser.yy"
+#line 2331 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::MultipartUnmatchedBoundary());
       }
-#line 4353 "seclang-parser.cc"
+#line 4349 "seclang-parser.cc"
     break;
 
   case 285:
-#line 2339 "seclang-parser.yy"
+#line 2335 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::OutboundDataError());
       }
-#line 4361 "seclang-parser.cc"
+#line 4357 "seclang-parser.cc"
     break;
 
   case 286:
-#line 2343 "seclang-parser.yy"
+#line 2339 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::PathInfo());
       }
-#line 4369 "seclang-parser.cc"
+#line 4365 "seclang-parser.cc"
     break;
 
   case 287:
-#line 2347 "seclang-parser.yy"
+#line 2343 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::QueryString());
       }
-#line 4377 "seclang-parser.cc"
+#line 4373 "seclang-parser.cc"
     break;
 
   case 288:
-#line 2351 "seclang-parser.yy"
+#line 2347 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RemoteAddr());
       }
-#line 4385 "seclang-parser.cc"
+#line 4381 "seclang-parser.cc"
     break;
 
   case 289:
-#line 2355 "seclang-parser.yy"
+#line 2351 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RemoteHost());
       }
-#line 4393 "seclang-parser.cc"
+#line 4389 "seclang-parser.cc"
     break;
 
   case 290:
-#line 2359 "seclang-parser.yy"
+#line 2355 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RemotePort());
       }
-#line 4401 "seclang-parser.cc"
+#line 4397 "seclang-parser.cc"
     break;
 
   case 291:
-#line 2363 "seclang-parser.yy"
+#line 2359 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ReqbodyError());
       }
-#line 4409 "seclang-parser.cc"
+#line 4405 "seclang-parser.cc"
     break;
 
   case 292:
-#line 2367 "seclang-parser.yy"
+#line 2363 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ReqbodyErrorMsg());
       }
-#line 4417 "seclang-parser.cc"
+#line 4413 "seclang-parser.cc"
     break;
 
   case 293:
-#line 2371 "seclang-parser.yy"
+#line 2367 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ReqbodyProcessor());
       }
-#line 4425 "seclang-parser.cc"
+#line 4421 "seclang-parser.cc"
     break;
 
   case 294:
-#line 2375 "seclang-parser.yy"
+#line 2371 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ReqbodyProcessorError());
       }
-#line 4433 "seclang-parser.cc"
+#line 4429 "seclang-parser.cc"
     break;
 
   case 295:
-#line 2379 "seclang-parser.yy"
+#line 2375 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ReqbodyProcessorErrorMsg());
       }
-#line 4441 "seclang-parser.cc"
+#line 4437 "seclang-parser.cc"
     break;
 
   case 296:
-#line 2383 "seclang-parser.yy"
+#line 2379 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestBasename());
       }
-#line 4449 "seclang-parser.cc"
+#line 4445 "seclang-parser.cc"
     break;
 
   case 297:
-#line 2387 "seclang-parser.yy"
+#line 2383 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestBody());
       }
-#line 4457 "seclang-parser.cc"
+#line 4453 "seclang-parser.cc"
     break;
 
   case 298:
-#line 2391 "seclang-parser.yy"
+#line 2387 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestBodyLength());
       }
-#line 4465 "seclang-parser.cc"
+#line 4461 "seclang-parser.cc"
     break;
 
   case 299:
-#line 2395 "seclang-parser.yy"
+#line 2391 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestFilename());
       }
-#line 4473 "seclang-parser.cc"
+#line 4469 "seclang-parser.cc"
     break;
 
   case 300:
-#line 2399 "seclang-parser.yy"
+#line 2395 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestLine());
       }
-#line 4481 "seclang-parser.cc"
+#line 4477 "seclang-parser.cc"
     break;
 
   case 301:
-#line 2403 "seclang-parser.yy"
+#line 2399 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestMethod());
       }
-#line 4489 "seclang-parser.cc"
+#line 4485 "seclang-parser.cc"
     break;
 
   case 302:
-#line 2407 "seclang-parser.yy"
+#line 2403 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestProtocol());
       }
-#line 4497 "seclang-parser.cc"
+#line 4493 "seclang-parser.cc"
     break;
 
   case 303:
-#line 2411 "seclang-parser.yy"
+#line 2407 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestURI());
       }
-#line 4505 "seclang-parser.cc"
+#line 4501 "seclang-parser.cc"
     break;
 
   case 304:
-#line 2415 "seclang-parser.yy"
+#line 2411 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::RequestURIRaw());
       }
-#line 4513 "seclang-parser.cc"
+#line 4509 "seclang-parser.cc"
     break;
 
   case 305:
-#line 2419 "seclang-parser.yy"
+#line 2415 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ResponseBody());
       }
-#line 4521 "seclang-parser.cc"
+#line 4517 "seclang-parser.cc"
     break;
 
   case 306:
-#line 2423 "seclang-parser.yy"
+#line 2419 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ResponseContentLength());
       }
-#line 4529 "seclang-parser.cc"
+#line 4525 "seclang-parser.cc"
     break;
 
   case 307:
-#line 2427 "seclang-parser.yy"
+#line 2423 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ResponseProtocol());
       }
-#line 4537 "seclang-parser.cc"
+#line 4533 "seclang-parser.cc"
     break;
 
   case 308:
-#line 2431 "seclang-parser.yy"
+#line 2427 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ResponseStatus());
       }
-#line 4545 "seclang-parser.cc"
+#line 4541 "seclang-parser.cc"
     break;
 
   case 309:
-#line 2435 "seclang-parser.yy"
+#line 2431 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ServerAddr());
       }
-#line 4553 "seclang-parser.cc"
+#line 4549 "seclang-parser.cc"
     break;
 
   case 310:
-#line 2439 "seclang-parser.yy"
+#line 2435 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ServerName());
       }
-#line 4561 "seclang-parser.cc"
+#line 4557 "seclang-parser.cc"
     break;
 
   case 311:
-#line 2443 "seclang-parser.yy"
+#line 2439 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::ServerPort());
       }
-#line 4569 "seclang-parser.cc"
+#line 4565 "seclang-parser.cc"
     break;
 
   case 312:
-#line 2447 "seclang-parser.yy"
+#line 2443 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::SessionID());
       }
-#line 4577 "seclang-parser.cc"
+#line 4573 "seclang-parser.cc"
     break;
 
   case 313:
-#line 2451 "seclang-parser.yy"
+#line 2447 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::UniqueID());
       }
-#line 4585 "seclang-parser.cc"
+#line 4581 "seclang-parser.cc"
     break;
 
   case 314:
-#line 2455 "seclang-parser.yy"
+#line 2451 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::UrlEncodedError());
       }
-#line 4593 "seclang-parser.cc"
+#line 4589 "seclang-parser.cc"
     break;
 
   case 315:
-#line 2459 "seclang-parser.yy"
+#line 2455 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::UserID());
       }
-#line 4601 "seclang-parser.cc"
+#line 4597 "seclang-parser.cc"
     break;
 
   case 316:
+#line 2459 "seclang-parser.yy"
+      {
+        VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Status());
+      }
+#line 4605 "seclang-parser.cc"
+    break;
+
+  case 317:
 #line 2463 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Status());
       }
-#line 4609 "seclang-parser.cc"
-    break;
-
-  case 317:
-#line 2467 "seclang-parser.yy"
-      {
-        VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::Status());
-      }
-#line 4617 "seclang-parser.cc"
+#line 4613 "seclang-parser.cc"
     break;
 
   case 318:
-#line 2471 "seclang-parser.yy"
+#line 2467 "seclang-parser.yy"
       {
         VARIABLE_CONTAINER(yylhs.value.as < std::unique_ptr<Variable> > (), new variables::WebAppId());
       }
-#line 4625 "seclang-parser.cc"
+#line 4621 "seclang-parser.cc"
     break;
 
   case 319:
-#line 2475 "seclang-parser.yy"
+#line 2471 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new Duration(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4636 "seclang-parser.cc"
+#line 4632 "seclang-parser.cc"
     break;
 
   case 320:
-#line 2483 "seclang-parser.yy"
+#line 2479 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new ModsecBuild(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4647 "seclang-parser.cc"
+#line 4643 "seclang-parser.cc"
     break;
 
   case 321:
-#line 2490 "seclang-parser.yy"
+#line 2486 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new HighestSeverity(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4658 "seclang-parser.cc"
+#line 4654 "seclang-parser.cc"
     break;
 
   case 322:
-#line 2497 "seclang-parser.yy"
+#line 2493 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new RemoteUser(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4669 "seclang-parser.cc"
+#line 4665 "seclang-parser.cc"
     break;
 
   case 323:
-#line 2504 "seclang-parser.yy"
+#line 2500 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new Time(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4680 "seclang-parser.cc"
+#line 4676 "seclang-parser.cc"
     break;
 
   case 324:
-#line 2511 "seclang-parser.yy"
+#line 2507 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new TimeDay(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4691 "seclang-parser.cc"
+#line 4687 "seclang-parser.cc"
     break;
 
   case 325:
-#line 2518 "seclang-parser.yy"
+#line 2514 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new TimeEpoch(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4702 "seclang-parser.cc"
+#line 4698 "seclang-parser.cc"
     break;
 
   case 326:
-#line 2525 "seclang-parser.yy"
+#line 2521 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new TimeHour(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4713 "seclang-parser.cc"
+#line 4709 "seclang-parser.cc"
     break;
 
   case 327:
-#line 2532 "seclang-parser.yy"
+#line 2528 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new TimeMin(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4724 "seclang-parser.cc"
+#line 4720 "seclang-parser.cc"
     break;
 
   case 328:
-#line 2539 "seclang-parser.yy"
+#line 2535 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new TimeMon(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4735 "seclang-parser.cc"
+#line 4731 "seclang-parser.cc"
     break;
 
   case 329:
-#line 2546 "seclang-parser.yy"
+#line 2542 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
             std::unique_ptr<Variable> c(new TimeSec(name));
             yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4746 "seclang-parser.cc"
+#line 4742 "seclang-parser.cc"
     break;
 
   case 330:
-#line 2553 "seclang-parser.yy"
+#line 2549 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new TimeWDay(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4757 "seclang-parser.cc"
+#line 4753 "seclang-parser.cc"
     break;
 
   case 331:
-#line 2560 "seclang-parser.yy"
+#line 2556 "seclang-parser.yy"
       {
         std::string name(yystack_[0].value.as < std::string > ());
         char z = name.at(0);
         std::unique_ptr<Variable> c(new TimeYear(name));
         yylhs.value.as < std::unique_ptr<Variable> > () = std::move(c);
       }
-#line 4768 "seclang-parser.cc"
+#line 4764 "seclang-parser.cc"
     break;
 
   case 332:
-#line 2570 "seclang-parser.yy"
+#line 2566 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Accuracy(yystack_[0].value.as < std::string > ()));
       }
-#line 4776 "seclang-parser.cc"
+#line 4772 "seclang-parser.cc"
     break;
 
   case 333:
-#line 2574 "seclang-parser.yy"
+#line 2570 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::disruptive::Allow(yystack_[0].value.as < std::string > ()));
       }
-#line 4784 "seclang-parser.cc"
+#line 4780 "seclang-parser.cc"
     break;
 
   case 334:
-#line 2578 "seclang-parser.yy"
+#line 2574 "seclang-parser.yy"
       {
         ACTION_NOT_SUPPORTED("Append", yystack_[1].location);
       }
-#line 4792 "seclang-parser.cc"
+#line 4788 "seclang-parser.cc"
     break;
 
   case 335:
-#line 2582 "seclang-parser.yy"
+#line 2578 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::AuditLog(yystack_[0].value.as < std::string > ()));
       }
-#line 4800 "seclang-parser.cc"
+#line 4796 "seclang-parser.cc"
     break;
 
   case 336:
-#line 2586 "seclang-parser.yy"
+#line 2582 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Block(yystack_[0].value.as < std::string > ()));
       }
-#line 4808 "seclang-parser.cc"
+#line 4804 "seclang-parser.cc"
     break;
 
   case 337:
-#line 2590 "seclang-parser.yy"
+#line 2586 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Capture(yystack_[0].value.as < std::string > ()));
       }
-#line 4816 "seclang-parser.cc"
+#line 4812 "seclang-parser.cc"
     break;
 
   case 338:
-#line 2594 "seclang-parser.yy"
+#line 2590 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Chain(yystack_[0].value.as < std::string > ()));
       }
-#line 4824 "seclang-parser.cc"
+#line 4820 "seclang-parser.cc"
     break;
 
   case 339:
-#line 2598 "seclang-parser.yy"
+#line 2594 "seclang-parser.yy"
       {
         //ACTION_NOT_SUPPORTED("CtlAuditEngine", @0);
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Action(yystack_[1].value.as < std::string > ()));
       }
-#line 4833 "seclang-parser.cc"
+#line 4829 "seclang-parser.cc"
     break;
 
   case 340:
-#line 2603 "seclang-parser.yy"
+#line 2599 "seclang-parser.yy"
       {
         //ACTION_NOT_SUPPORTED("CtlAuditEngine", @0);
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Action(yystack_[1].value.as < std::string > ()));
       }
-#line 4842 "seclang-parser.cc"
+#line 4838 "seclang-parser.cc"
     break;
 
   case 341:
-#line 2608 "seclang-parser.yy"
+#line 2604 "seclang-parser.yy"
       {
         //ACTION_NOT_SUPPORTED("CtlAuditEngine", @0);
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Action(yystack_[1].value.as < std::string > ()));
       }
-#line 4851 "seclang-parser.cc"
+#line 4847 "seclang-parser.cc"
     break;
 
   case 342:
-#line 2613 "seclang-parser.yy"
+#line 2609 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::AuditLogParts(yystack_[0].value.as < std::string > ()));
       }
-#line 4859 "seclang-parser.cc"
+#line 4855 "seclang-parser.cc"
     break;
 
   case 343:
-#line 2617 "seclang-parser.yy"
+#line 2613 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RequestBodyProcessorJSON(yystack_[0].value.as < std::string > ()));
       }
-#line 4867 "seclang-parser.cc"
+#line 4863 "seclang-parser.cc"
     break;
 
   case 344:
-#line 2621 "seclang-parser.yy"
+#line 2617 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RequestBodyProcessorXML(yystack_[0].value.as < std::string > ()));
       }
-#line 4875 "seclang-parser.cc"
+#line 4871 "seclang-parser.cc"
     break;
 
   case 345:
-#line 2625 "seclang-parser.yy"
+#line 2621 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RequestBodyProcessorURLENCODED(yystack_[0].value.as < std::string > ()));
       }
-#line 4883 "seclang-parser.cc"
+#line 4879 "seclang-parser.cc"
     break;
 
   case 346:
-#line 2629 "seclang-parser.yy"
+#line 2625 "seclang-parser.yy"
       {
         //ACTION_NOT_SUPPORTED("CtlForceReequestBody", @0);
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Action(yystack_[1].value.as < std::string > ()));
       }
-#line 4892 "seclang-parser.cc"
+#line 4888 "seclang-parser.cc"
     break;
 
   case 347:
-#line 2634 "seclang-parser.yy"
+#line 2630 "seclang-parser.yy"
       {
         //ACTION_NOT_SUPPORTED("CtlForceReequestBody", @0);
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Action(yystack_[1].value.as < std::string > ()));
       }
-#line 4901 "seclang-parser.cc"
+#line 4897 "seclang-parser.cc"
     break;
 
   case 348:
-#line 2639 "seclang-parser.yy"
+#line 2635 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RequestBodyAccess(yystack_[1].value.as < std::string > () + "true"));
       }
-#line 4909 "seclang-parser.cc"
+#line 4905 "seclang-parser.cc"
     break;
 
   case 349:
-#line 2643 "seclang-parser.yy"
+#line 2639 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RequestBodyAccess(yystack_[1].value.as < std::string > () + "false"));
       }
-#line 4917 "seclang-parser.cc"
+#line 4913 "seclang-parser.cc"
     break;
 
   case 350:
-#line 2647 "seclang-parser.yy"
+#line 2643 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RuleEngine("ctl:RuleEngine=on"));
       }
-#line 4925 "seclang-parser.cc"
+#line 4921 "seclang-parser.cc"
     break;
 
   case 351:
-#line 2651 "seclang-parser.yy"
+#line 2647 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RuleEngine("ctl:RuleEngine=off"));
       }
-#line 4933 "seclang-parser.cc"
+#line 4929 "seclang-parser.cc"
     break;
 
   case 352:
-#line 2655 "seclang-parser.yy"
+#line 2651 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RuleEngine("ctl:RuleEngine=detectiononly"));
       }
-#line 4941 "seclang-parser.cc"
+#line 4937 "seclang-parser.cc"
     break;
 
   case 353:
-#line 2659 "seclang-parser.yy"
+#line 2655 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RuleRemoveById(yystack_[0].value.as < std::string > ()));
       }
-#line 4949 "seclang-parser.cc"
+#line 4945 "seclang-parser.cc"
     break;
 
   case 354:
-#line 2663 "seclang-parser.yy"
+#line 2659 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RuleRemoveByTag(yystack_[0].value.as < std::string > ()));
       }
-#line 4957 "seclang-parser.cc"
+#line 4953 "seclang-parser.cc"
     break;
 
   case 355:
-#line 2667 "seclang-parser.yy"
+#line 2663 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RuleRemoveTargetById(yystack_[0].value.as < std::string > ()));
       }
-#line 4965 "seclang-parser.cc"
+#line 4961 "seclang-parser.cc"
     break;
 
   case 356:
-#line 2671 "seclang-parser.yy"
+#line 2667 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::ctl::RuleRemoveTargetByTag(yystack_[0].value.as < std::string > ()));
       }
-#line 4973 "seclang-parser.cc"
+#line 4969 "seclang-parser.cc"
     break;
 
   case 357:
-#line 2675 "seclang-parser.yy"
+#line 2671 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::disruptive::Deny(yystack_[0].value.as < std::string > ()));
       }
-#line 4981 "seclang-parser.cc"
+#line 4977 "seclang-parser.cc"
     break;
 
   case 358:
-#line 2679 "seclang-parser.yy"
+#line 2675 "seclang-parser.yy"
       {
         ACTION_NOT_SUPPORTED("DeprecateVar", yystack_[1].location);
       }
-#line 4989 "seclang-parser.cc"
+#line 4985 "seclang-parser.cc"
     break;
 
   case 359:
-#line 2683 "seclang-parser.yy"
+#line 2679 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::disruptive::Drop(yystack_[0].value.as < std::string > ()));
       }
-#line 4997 "seclang-parser.cc"
+#line 4993 "seclang-parser.cc"
     break;
 
   case 360:
-#line 2687 "seclang-parser.yy"
+#line 2683 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Exec(yystack_[0].value.as < std::string > ()));
       }
-#line 5005 "seclang-parser.cc"
+#line 5001 "seclang-parser.cc"
     break;
 
   case 361:
-#line 2691 "seclang-parser.yy"
+#line 2687 "seclang-parser.yy"
       {
         //ACTION_NOT_SUPPORTED("ExpireVar", @0);
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Action(yystack_[0].value.as < std::string > ()));
       }
-#line 5014 "seclang-parser.cc"
+#line 5010 "seclang-parser.cc"
     break;
 
   case 362:
-#line 2696 "seclang-parser.yy"
+#line 2692 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::RuleId(yystack_[0].value.as < std::string > ()));
       }
-#line 5022 "seclang-parser.cc"
+#line 5018 "seclang-parser.cc"
     break;
 
   case 363:
-#line 2700 "seclang-parser.yy"
+#line 2696 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::InitCol(yystack_[1].value.as < std::string > (), std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5030 "seclang-parser.cc"
+#line 5026 "seclang-parser.cc"
     break;
 
   case 364:
-#line 2704 "seclang-parser.yy"
+#line 2700 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::LogData(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5038 "seclang-parser.cc"
+#line 5034 "seclang-parser.cc"
     break;
 
   case 365:
-#line 2708 "seclang-parser.yy"
+#line 2704 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Log(yystack_[0].value.as < std::string > ()));
       }
-#line 5046 "seclang-parser.cc"
+#line 5042 "seclang-parser.cc"
     break;
 
   case 366:
-#line 2712 "seclang-parser.yy"
+#line 2708 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Maturity(yystack_[0].value.as < std::string > ()));
       }
-#line 5054 "seclang-parser.cc"
+#line 5050 "seclang-parser.cc"
     break;
 
   case 367:
-#line 2716 "seclang-parser.yy"
+#line 2712 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Msg(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5062 "seclang-parser.cc"
+#line 5058 "seclang-parser.cc"
     break;
 
   case 368:
-#line 2720 "seclang-parser.yy"
+#line 2716 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::MultiMatch(yystack_[0].value.as < std::string > ()));
       }
-#line 5070 "seclang-parser.cc"
+#line 5066 "seclang-parser.cc"
     break;
 
   case 369:
-#line 2724 "seclang-parser.yy"
+#line 2720 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::NoAuditLog(yystack_[0].value.as < std::string > ()));
       }
-#line 5078 "seclang-parser.cc"
+#line 5074 "seclang-parser.cc"
     break;
 
   case 370:
-#line 2728 "seclang-parser.yy"
+#line 2724 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::NoLog(yystack_[0].value.as < std::string > ()));
       }
-#line 5086 "seclang-parser.cc"
+#line 5082 "seclang-parser.cc"
     break;
 
   case 371:
-#line 2732 "seclang-parser.yy"
+#line 2728 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::disruptive::Pass(yystack_[0].value.as < std::string > ()));
       }
-#line 5094 "seclang-parser.cc"
+#line 5090 "seclang-parser.cc"
     break;
 
   case 372:
-#line 2736 "seclang-parser.yy"
+#line 2732 "seclang-parser.yy"
       {
         ACTION_NOT_SUPPORTED("Pause", yystack_[1].location);
       }
-#line 5102 "seclang-parser.cc"
+#line 5098 "seclang-parser.cc"
     break;
 
   case 373:
-#line 2740 "seclang-parser.yy"
+#line 2736 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Phase(yystack_[0].value.as < std::string > ()));
       }
-#line 5110 "seclang-parser.cc"
+#line 5106 "seclang-parser.cc"
     break;
 
   case 374:
-#line 2744 "seclang-parser.yy"
+#line 2740 "seclang-parser.yy"
       {
         ACTION_NOT_SUPPORTED("Prepend", yystack_[1].location);
       }
-#line 5118 "seclang-parser.cc"
+#line 5114 "seclang-parser.cc"
     break;
 
   case 375:
-#line 2748 "seclang-parser.yy"
+#line 2744 "seclang-parser.yy"
       {
         ACTION_NOT_SUPPORTED("Proxy", yystack_[1].location);
       }
-#line 5126 "seclang-parser.cc"
+#line 5122 "seclang-parser.cc"
     break;
 
   case 376:
-#line 2752 "seclang-parser.yy"
+#line 2748 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::disruptive::Redirect(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5134 "seclang-parser.cc"
+#line 5130 "seclang-parser.cc"
     break;
 
   case 377:
-#line 2756 "seclang-parser.yy"
+#line 2752 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Rev(yystack_[0].value.as < std::string > ()));
       }
-#line 5142 "seclang-parser.cc"
+#line 5138 "seclang-parser.cc"
     break;
 
   case 378:
-#line 2760 "seclang-parser.yy"
+#line 2756 "seclang-parser.yy"
       {
         ACTION_NOT_SUPPORTED("SanitiseArg", yystack_[1].location);
       }
-#line 5150 "seclang-parser.cc"
+#line 5146 "seclang-parser.cc"
     break;
 
   case 379:
-#line 2764 "seclang-parser.yy"
+#line 2760 "seclang-parser.yy"
       {
         ACTION_NOT_SUPPORTED("SanitiseMatched", yystack_[1].location);
       }
-#line 5158 "seclang-parser.cc"
+#line 5154 "seclang-parser.cc"
     break;
 
   case 380:
-#line 2768 "seclang-parser.yy"
+#line 2764 "seclang-parser.yy"
       {
         ACTION_NOT_SUPPORTED("SanitiseMatchedBytes", yystack_[1].location);
       }
-#line 5166 "seclang-parser.cc"
+#line 5162 "seclang-parser.cc"
     break;
 
   case 381:
-#line 2772 "seclang-parser.yy"
+#line 2768 "seclang-parser.yy"
       {
         ACTION_NOT_SUPPORTED("SanitiseRequestHeader", yystack_[1].location);
       }
-#line 5174 "seclang-parser.cc"
+#line 5170 "seclang-parser.cc"
     break;
 
   case 382:
-#line 2776 "seclang-parser.yy"
+#line 2772 "seclang-parser.yy"
       {
         ACTION_NOT_SUPPORTED("SanitiseResponseHeader", yystack_[1].location);
       }
-#line 5182 "seclang-parser.cc"
+#line 5178 "seclang-parser.cc"
     break;
 
   case 383:
-#line 2780 "seclang-parser.yy"
+#line 2776 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::SetENV(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5190 "seclang-parser.cc"
+#line 5186 "seclang-parser.cc"
     break;
 
   case 384:
-#line 2784 "seclang-parser.yy"
+#line 2780 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::SetRSC(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5198 "seclang-parser.cc"
+#line 5194 "seclang-parser.cc"
     break;
 
   case 385:
-#line 2788 "seclang-parser.yy"
+#line 2784 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::SetSID(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5206 "seclang-parser.cc"
+#line 5202 "seclang-parser.cc"
     break;
 
   case 386:
-#line 2792 "seclang-parser.yy"
+#line 2788 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::SetUID(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5214 "seclang-parser.cc"
+#line 5210 "seclang-parser.cc"
     break;
 
   case 387:
-#line 2796 "seclang-parser.yy"
+#line 2792 "seclang-parser.yy"
       {
         yylhs.value.as < std::unique_ptr<actions::Action> > () = std::move(yystack_[0].value.as < std::unique_ptr<actions::Action> > ());
       }
-#line 5222 "seclang-parser.cc"
+#line 5218 "seclang-parser.cc"
     break;
 
   case 388:
-#line 2800 "seclang-parser.yy"
+#line 2796 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Severity(yystack_[0].value.as < std::string > ()));
       }
-#line 5230 "seclang-parser.cc"
+#line 5226 "seclang-parser.cc"
     break;
 
   case 389:
-#line 2804 "seclang-parser.yy"
+#line 2800 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Skip(yystack_[0].value.as < std::string > ()));
       }
-#line 5238 "seclang-parser.cc"
+#line 5234 "seclang-parser.cc"
     break;
 
   case 390:
-#line 2808 "seclang-parser.yy"
+#line 2804 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::SkipAfter(yystack_[0].value.as < std::string > ()));
       }
-#line 5246 "seclang-parser.cc"
+#line 5242 "seclang-parser.cc"
     break;
 
   case 391:
-#line 2812 "seclang-parser.yy"
+#line 2808 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::data::Status(yystack_[0].value.as < std::string > ()));
       }
-#line 5254 "seclang-parser.cc"
+#line 5250 "seclang-parser.cc"
     break;
 
   case 392:
-#line 2816 "seclang-parser.yy"
+#line 2812 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Tag(std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5262 "seclang-parser.cc"
+#line 5258 "seclang-parser.cc"
     break;
 
   case 393:
-#line 2820 "seclang-parser.yy"
+#line 2816 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::Ver(yystack_[0].value.as < std::string > ()));
       }
-#line 5270 "seclang-parser.cc"
+#line 5266 "seclang-parser.cc"
     break;
 
   case 394:
-#line 2824 "seclang-parser.yy"
+#line 2820 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::XmlNS(yystack_[0].value.as < std::string > ()));
       }
-#line 5278 "seclang-parser.cc"
+#line 5274 "seclang-parser.cc"
     break;
 
   case 395:
-#line 2828 "seclang-parser.yy"
+#line 2824 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::ParityZero7bit(yystack_[0].value.as < std::string > ()));
       }
-#line 5286 "seclang-parser.cc"
+#line 5282 "seclang-parser.cc"
     break;
 
   case 396:
-#line 2832 "seclang-parser.yy"
+#line 2828 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::ParityOdd7bit(yystack_[0].value.as < std::string > ()));
       }
-#line 5294 "seclang-parser.cc"
+#line 5290 "seclang-parser.cc"
     break;
 
   case 397:
-#line 2836 "seclang-parser.yy"
+#line 2832 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::ParityEven7bit(yystack_[0].value.as < std::string > ()));
       }
-#line 5302 "seclang-parser.cc"
+#line 5298 "seclang-parser.cc"
     break;
 
   case 398:
-#line 2840 "seclang-parser.yy"
+#line 2836 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::SqlHexDecode(yystack_[0].value.as < std::string > ()));
       }
-#line 5310 "seclang-parser.cc"
+#line 5306 "seclang-parser.cc"
     break;
 
   case 399:
-#line 2844 "seclang-parser.yy"
+#line 2840 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::Base64Encode(yystack_[0].value.as < std::string > ()));
       }
-#line 5318 "seclang-parser.cc"
+#line 5314 "seclang-parser.cc"
     break;
 
   case 400:
-#line 2848 "seclang-parser.yy"
+#line 2844 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::Base64Decode(yystack_[0].value.as < std::string > ()));
       }
-#line 5326 "seclang-parser.cc"
+#line 5322 "seclang-parser.cc"
     break;
 
   case 401:
-#line 2852 "seclang-parser.yy"
+#line 2848 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::Base64DecodeExt(yystack_[0].value.as < std::string > ()));
       }
-#line 5334 "seclang-parser.cc"
+#line 5330 "seclang-parser.cc"
     break;
 
   case 402:
-#line 2856 "seclang-parser.yy"
+#line 2852 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::CmdLine(yystack_[0].value.as < std::string > ()));
       }
-#line 5342 "seclang-parser.cc"
+#line 5338 "seclang-parser.cc"
     break;
 
   case 403:
-#line 2860 "seclang-parser.yy"
+#line 2856 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::Sha1(yystack_[0].value.as < std::string > ()));
       }
-#line 5350 "seclang-parser.cc"
+#line 5346 "seclang-parser.cc"
     break;
 
   case 404:
-#line 2864 "seclang-parser.yy"
+#line 2860 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::Md5(yystack_[0].value.as < std::string > ()));
       }
-#line 5358 "seclang-parser.cc"
+#line 5354 "seclang-parser.cc"
     break;
 
   case 405:
-#line 2868 "seclang-parser.yy"
+#line 2864 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::EscapeSeqDecode(yystack_[0].value.as < std::string > ()));
       }
-#line 5366 "seclang-parser.cc"
+#line 5362 "seclang-parser.cc"
     break;
 
   case 406:
-#line 2872 "seclang-parser.yy"
+#line 2868 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::HexEncode(yystack_[0].value.as < std::string > ()));
       }
-#line 5374 "seclang-parser.cc"
+#line 5370 "seclang-parser.cc"
     break;
 
   case 407:
-#line 2876 "seclang-parser.yy"
+#line 2872 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::HexDecode(yystack_[0].value.as < std::string > ()));
       }
-#line 5382 "seclang-parser.cc"
+#line 5378 "seclang-parser.cc"
     break;
 
   case 408:
-#line 2880 "seclang-parser.yy"
+#line 2876 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::LowerCase(yystack_[0].value.as < std::string > ()));
       }
-#line 5390 "seclang-parser.cc"
+#line 5386 "seclang-parser.cc"
     break;
 
   case 409:
-#line 2884 "seclang-parser.yy"
+#line 2880 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::UpperCase(yystack_[0].value.as < std::string > ()));
       }
-#line 5398 "seclang-parser.cc"
+#line 5394 "seclang-parser.cc"
     break;
 
   case 410:
-#line 2888 "seclang-parser.yy"
+#line 2884 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::UrlDecodeUni(yystack_[0].value.as < std::string > ()));
       }
-#line 5406 "seclang-parser.cc"
+#line 5402 "seclang-parser.cc"
     break;
 
   case 411:
-#line 2892 "seclang-parser.yy"
+#line 2888 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::UrlDecode(yystack_[0].value.as < std::string > ()));
       }
-#line 5414 "seclang-parser.cc"
+#line 5410 "seclang-parser.cc"
     break;
 
   case 412:
-#line 2896 "seclang-parser.yy"
+#line 2892 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::UrlEncode(yystack_[0].value.as < std::string > ()));
       }
-#line 5422 "seclang-parser.cc"
+#line 5418 "seclang-parser.cc"
     break;
 
   case 413:
-#line 2900 "seclang-parser.yy"
+#line 2896 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::None(yystack_[0].value.as < std::string > ()));
       }
-#line 5430 "seclang-parser.cc"
+#line 5426 "seclang-parser.cc"
     break;
 
   case 414:
-#line 2904 "seclang-parser.yy"
+#line 2900 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::CompressWhitespace(yystack_[0].value.as < std::string > ()));
       }
-#line 5438 "seclang-parser.cc"
+#line 5434 "seclang-parser.cc"
     break;
 
   case 415:
-#line 2908 "seclang-parser.yy"
+#line 2904 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::RemoveWhitespace(yystack_[0].value.as < std::string > ()));
       }
-#line 5446 "seclang-parser.cc"
+#line 5442 "seclang-parser.cc"
     break;
 
   case 416:
-#line 2912 "seclang-parser.yy"
+#line 2908 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::ReplaceNulls(yystack_[0].value.as < std::string > ()));
       }
-#line 5454 "seclang-parser.cc"
+#line 5450 "seclang-parser.cc"
     break;
 
   case 417:
-#line 2916 "seclang-parser.yy"
+#line 2912 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::RemoveNulls(yystack_[0].value.as < std::string > ()));
       }
-#line 5462 "seclang-parser.cc"
+#line 5458 "seclang-parser.cc"
     break;
 
   case 418:
-#line 2920 "seclang-parser.yy"
+#line 2916 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::HtmlEntityDecode(yystack_[0].value.as < std::string > ()));
       }
-#line 5470 "seclang-parser.cc"
+#line 5466 "seclang-parser.cc"
     break;
 
   case 419:
-#line 2924 "seclang-parser.yy"
+#line 2920 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::JsDecode(yystack_[0].value.as < std::string > ()));
       }
-#line 5478 "seclang-parser.cc"
+#line 5474 "seclang-parser.cc"
     break;
 
   case 420:
-#line 2928 "seclang-parser.yy"
+#line 2924 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::CssDecode(yystack_[0].value.as < std::string > ()));
       }
-#line 5486 "seclang-parser.cc"
+#line 5482 "seclang-parser.cc"
     break;
 
   case 421:
-#line 2932 "seclang-parser.yy"
+#line 2928 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::Trim(yystack_[0].value.as < std::string > ()));
       }
-#line 5494 "seclang-parser.cc"
+#line 5490 "seclang-parser.cc"
     break;
 
   case 422:
-#line 2936 "seclang-parser.yy"
+#line 2932 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::TrimLeft(yystack_[0].value.as < std::string > ()));
       }
-#line 5502 "seclang-parser.cc"
+#line 5498 "seclang-parser.cc"
     break;
 
   case 423:
-#line 2940 "seclang-parser.yy"
+#line 2936 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::TrimRight(yystack_[0].value.as < std::string > ()));
       }
-#line 5510 "seclang-parser.cc"
+#line 5506 "seclang-parser.cc"
     break;
 
   case 424:
-#line 2944 "seclang-parser.yy"
+#line 2940 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::NormalisePathWin(yystack_[0].value.as < std::string > ()));
       }
-#line 5518 "seclang-parser.cc"
+#line 5514 "seclang-parser.cc"
     break;
 
   case 425:
-#line 2948 "seclang-parser.yy"
+#line 2944 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::NormalisePath(yystack_[0].value.as < std::string > ()));
       }
-#line 5526 "seclang-parser.cc"
+#line 5522 "seclang-parser.cc"
     break;
 
   case 426:
-#line 2952 "seclang-parser.yy"
+#line 2948 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::Length(yystack_[0].value.as < std::string > ()));
       }
-#line 5534 "seclang-parser.cc"
+#line 5530 "seclang-parser.cc"
     break;
 
   case 427:
-#line 2956 "seclang-parser.yy"
+#line 2952 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::Utf8ToUnicode(yystack_[0].value.as < std::string > ()));
       }
-#line 5542 "seclang-parser.cc"
+#line 5538 "seclang-parser.cc"
     break;
 
   case 428:
-#line 2960 "seclang-parser.yy"
+#line 2956 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::RemoveCommentsChar(yystack_[0].value.as < std::string > ()));
       }
-#line 5550 "seclang-parser.cc"
+#line 5546 "seclang-parser.cc"
     break;
 
   case 429:
-#line 2964 "seclang-parser.yy"
+#line 2960 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::RemoveComments(yystack_[0].value.as < std::string > ()));
       }
-#line 5558 "seclang-parser.cc"
+#line 5554 "seclang-parser.cc"
     break;
 
   case 430:
-#line 2968 "seclang-parser.yy"
+#line 2964 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::transformations::ReplaceComments(yystack_[0].value.as < std::string > ()));
       }
-#line 5566 "seclang-parser.cc"
+#line 5562 "seclang-parser.cc"
     break;
 
   case 431:
-#line 2975 "seclang-parser.yy"
+#line 2971 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::SetVar(actions::SetVarOperation::unsetOperation, std::move(yystack_[0].value.as < std::unique_ptr<Variable> > ())));
       }
-#line 5574 "seclang-parser.cc"
+#line 5570 "seclang-parser.cc"
     break;
 
   case 432:
-#line 2979 "seclang-parser.yy"
+#line 2975 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::SetVar(actions::SetVarOperation::setToOneOperation, std::move(yystack_[0].value.as < std::unique_ptr<Variable> > ())));
       }
-#line 5582 "seclang-parser.cc"
+#line 5578 "seclang-parser.cc"
     break;
 
   case 433:
-#line 2983 "seclang-parser.yy"
+#line 2979 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::SetVar(actions::SetVarOperation::setOperation, std::move(yystack_[2].value.as < std::unique_ptr<Variable> > ()), std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5590 "seclang-parser.cc"
+#line 5586 "seclang-parser.cc"
     break;
 
   case 434:
-#line 2987 "seclang-parser.yy"
+#line 2983 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::SetVar(actions::SetVarOperation::sumAndSetOperation, std::move(yystack_[2].value.as < std::unique_ptr<Variable> > ()), std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5598 "seclang-parser.cc"
+#line 5594 "seclang-parser.cc"
     break;
 
   case 435:
-#line 2991 "seclang-parser.yy"
+#line 2987 "seclang-parser.yy"
       {
         ACTION_CONTAINER(yylhs.value.as < std::unique_ptr<actions::Action> > (), new actions::SetVar(actions::SetVarOperation::substractAndSetOperation, std::move(yystack_[2].value.as < std::unique_ptr<Variable> > ()), std::move(yystack_[0].value.as < std::unique_ptr<RunTimeString> > ())));
       }
-#line 5606 "seclang-parser.cc"
+#line 5602 "seclang-parser.cc"
     break;
 
   case 436:
-#line 2998 "seclang-parser.yy"
+#line 2994 "seclang-parser.yy"
       {
         yystack_[1].value.as < std::unique_ptr<RunTimeString> > ()->appendText(yystack_[0].value.as < std::string > ());
         yylhs.value.as < std::unique_ptr<RunTimeString> > () = std::move(yystack_[1].value.as < std::unique_ptr<RunTimeString> > ());
       }
-#line 5615 "seclang-parser.cc"
+#line 5611 "seclang-parser.cc"
     break;
 
   case 437:
-#line 3003 "seclang-parser.yy"
+#line 2999 "seclang-parser.yy"
       {
         yystack_[1].value.as < std::unique_ptr<RunTimeString> > ()->appendVar(std::move(yystack_[0].value.as < std::unique_ptr<Variable> > ()));
         yylhs.value.as < std::unique_ptr<RunTimeString> > () = std::move(yystack_[1].value.as < std::unique_ptr<RunTimeString> > ());
       }
-#line 5624 "seclang-parser.cc"
+#line 5620 "seclang-parser.cc"
     break;
 
   case 438:
-#line 3008 "seclang-parser.yy"
+#line 3004 "seclang-parser.yy"
       {
         std::unique_ptr<RunTimeString> r(new RunTimeString());
         r->appendText(yystack_[0].value.as < std::string > ());
         yylhs.value.as < std::unique_ptr<RunTimeString> > () = std::move(r);
       }
-#line 5634 "seclang-parser.cc"
+#line 5630 "seclang-parser.cc"
     break;
 
   case 439:
-#line 3014 "seclang-parser.yy"
+#line 3010 "seclang-parser.yy"
       {
         std::unique_ptr<RunTimeString> r(new RunTimeString());
         r->appendVar(std::move(yystack_[0].value.as < std::unique_ptr<Variable> > ()));
         yylhs.value.as < std::unique_ptr<RunTimeString> > () = std::move(r);
       }
-#line 5644 "seclang-parser.cc"
+#line 5640 "seclang-parser.cc"
     break;
 
 
-#line 5648 "seclang-parser.cc"
+#line 5644 "seclang-parser.cc"
 
             default:
               break;
@@ -7061,43 +7057,43 @@ namespace yy {
      921,   925,   929,   933,   937,   941,   945,   950,   954,   958,
      962,   966,   970,   975,   980,   984,   988,   992,   996,  1000,
     1004,  1008,  1012,  1016,  1020,  1024,  1028,  1032,  1036,  1040,
-    1044,  1048,  1052,  1066,  1067,  1092,  1111,  1126,  1150,  1206,
-    1210,  1214,  1218,  1222,  1226,  1230,  1234,  1238,  1247,  1251,
-    1256,  1259,  1264,  1269,  1274,  1279,  1282,  1287,  1290,  1295,
-    1300,  1303,  1308,  1313,  1318,  1323,  1328,  1333,  1338,  1341,
-    1346,  1351,  1356,  1361,  1364,  1369,  1374,  1379,  1392,  1405,
-    1418,  1431,  1444,  1470,  1498,  1510,  1530,  1557,  1563,  1568,
-    1573,  1582,  1587,  1591,  1595,  1599,  1603,  1607,  1611,  1616,
-    1621,  1633,  1639,  1643,  1647,  1658,  1667,  1668,  1675,  1680,
-    1685,  1739,  1746,  1754,  1791,  1795,  1802,  1807,  1813,  1819,
-    1825,  1832,  1842,  1846,  1850,  1854,  1858,  1862,  1866,  1870,
-    1874,  1878,  1882,  1886,  1890,  1894,  1898,  1902,  1906,  1910,
-    1914,  1918,  1922,  1926,  1930,  1934,  1938,  1942,  1946,  1950,
-    1954,  1958,  1962,  1966,  1970,  1974,  1978,  1982,  1986,  1990,
-    1994,  1998,  2002,  2006,  2010,  2014,  2018,  2022,  2026,  2030,
-    2034,  2038,  2042,  2046,  2050,  2054,  2058,  2062,  2066,  2070,
-    2074,  2078,  2082,  2086,  2090,  2094,  2098,  2102,  2106,  2110,
-    2114,  2118,  2122,  2126,  2130,  2134,  2138,  2142,  2146,  2150,
-    2154,  2158,  2162,  2166,  2170,  2174,  2178,  2182,  2186,  2190,
-    2194,  2198,  2203,  2207,  2211,  2216,  2220,  2224,  2229,  2234,
-    2238,  2242,  2246,  2250,  2254,  2258,  2262,  2266,  2270,  2274,
-    2278,  2282,  2286,  2290,  2294,  2298,  2302,  2306,  2310,  2314,
-    2318,  2322,  2326,  2330,  2334,  2338,  2342,  2346,  2350,  2354,
-    2358,  2362,  2366,  2370,  2374,  2378,  2382,  2386,  2390,  2394,
-    2398,  2402,  2406,  2410,  2414,  2418,  2422,  2426,  2430,  2434,
-    2438,  2442,  2446,  2450,  2454,  2458,  2462,  2466,  2470,  2474,
-    2482,  2489,  2496,  2503,  2510,  2517,  2524,  2531,  2538,  2545,
-    2552,  2559,  2569,  2573,  2577,  2581,  2585,  2589,  2593,  2597,
-    2602,  2607,  2612,  2616,  2620,  2624,  2628,  2633,  2638,  2642,
-    2646,  2650,  2654,  2658,  2662,  2666,  2670,  2674,  2678,  2682,
-    2686,  2690,  2695,  2699,  2703,  2707,  2711,  2715,  2719,  2723,
-    2727,  2731,  2735,  2739,  2743,  2747,  2751,  2755,  2759,  2763,
-    2767,  2771,  2775,  2779,  2783,  2787,  2791,  2795,  2799,  2803,
-    2807,  2811,  2815,  2819,  2823,  2827,  2831,  2835,  2839,  2843,
-    2847,  2851,  2855,  2859,  2863,  2867,  2871,  2875,  2879,  2883,
-    2887,  2891,  2895,  2899,  2903,  2907,  2911,  2915,  2919,  2923,
-    2927,  2931,  2935,  2939,  2943,  2947,  2951,  2955,  2959,  2963,
-    2967,  2974,  2978,  2982,  2986,  2990,  2997,  3002,  3007,  3013
+    1044,  1048,  1052,  1066,  1067,  1091,  1109,  1124,  1146,  1202,
+    1206,  1210,  1214,  1218,  1222,  1226,  1230,  1234,  1243,  1247,
+    1252,  1255,  1260,  1265,  1270,  1275,  1278,  1283,  1286,  1291,
+    1296,  1299,  1304,  1309,  1314,  1319,  1324,  1329,  1334,  1337,
+    1342,  1347,  1352,  1357,  1360,  1365,  1370,  1375,  1388,  1401,
+    1414,  1427,  1440,  1466,  1494,  1506,  1526,  1553,  1559,  1564,
+    1569,  1578,  1583,  1587,  1591,  1595,  1599,  1603,  1607,  1612,
+    1617,  1629,  1635,  1639,  1643,  1654,  1663,  1664,  1671,  1676,
+    1681,  1735,  1742,  1750,  1787,  1791,  1798,  1803,  1809,  1815,
+    1821,  1828,  1838,  1842,  1846,  1850,  1854,  1858,  1862,  1866,
+    1870,  1874,  1878,  1882,  1886,  1890,  1894,  1898,  1902,  1906,
+    1910,  1914,  1918,  1922,  1926,  1930,  1934,  1938,  1942,  1946,
+    1950,  1954,  1958,  1962,  1966,  1970,  1974,  1978,  1982,  1986,
+    1990,  1994,  1998,  2002,  2006,  2010,  2014,  2018,  2022,  2026,
+    2030,  2034,  2038,  2042,  2046,  2050,  2054,  2058,  2062,  2066,
+    2070,  2074,  2078,  2082,  2086,  2090,  2094,  2098,  2102,  2106,
+    2110,  2114,  2118,  2122,  2126,  2130,  2134,  2138,  2142,  2146,
+    2150,  2154,  2158,  2162,  2166,  2170,  2174,  2178,  2182,  2186,
+    2190,  2194,  2199,  2203,  2207,  2212,  2216,  2220,  2225,  2230,
+    2234,  2238,  2242,  2246,  2250,  2254,  2258,  2262,  2266,  2270,
+    2274,  2278,  2282,  2286,  2290,  2294,  2298,  2302,  2306,  2310,
+    2314,  2318,  2322,  2326,  2330,  2334,  2338,  2342,  2346,  2350,
+    2354,  2358,  2362,  2366,  2370,  2374,  2378,  2382,  2386,  2390,
+    2394,  2398,  2402,  2406,  2410,  2414,  2418,  2422,  2426,  2430,
+    2434,  2438,  2442,  2446,  2450,  2454,  2458,  2462,  2466,  2470,
+    2478,  2485,  2492,  2499,  2506,  2513,  2520,  2527,  2534,  2541,
+    2548,  2555,  2565,  2569,  2573,  2577,  2581,  2585,  2589,  2593,
+    2598,  2603,  2608,  2612,  2616,  2620,  2624,  2629,  2634,  2638,
+    2642,  2646,  2650,  2654,  2658,  2662,  2666,  2670,  2674,  2678,
+    2682,  2686,  2691,  2695,  2699,  2703,  2707,  2711,  2715,  2719,
+    2723,  2727,  2731,  2735,  2739,  2743,  2747,  2751,  2755,  2759,
+    2763,  2767,  2771,  2775,  2779,  2783,  2787,  2791,  2795,  2799,
+    2803,  2807,  2811,  2815,  2819,  2823,  2827,  2831,  2835,  2839,
+    2843,  2847,  2851,  2855,  2859,  2863,  2867,  2871,  2875,  2879,
+    2883,  2887,  2891,  2895,  2899,  2903,  2907,  2911,  2915,  2919,
+    2923,  2927,  2931,  2935,  2939,  2943,  2947,  2951,  2955,  2959,
+    2963,  2970,  2974,  2978,  2982,  2986,  2993,  2998,  3003,  3009
   };
 
   // Print the state stack on the debug stream.
@@ -7131,9 +7127,9 @@ namespace yy {
 
 
 } // yy
-#line 7135 "seclang-parser.cc"
+#line 7131 "seclang-parser.cc"
 
-#line 3020 "seclang-parser.yy"
+#line 3016 "seclang-parser.yy"
 
 
 void yy::seclang_parser::error (const location_type& l, const std::string& m) {
diff --git a/src/parser/seclang-parser.hh b/src/parser/seclang-parser.hh
index bf260cd8..a23ee224 100644
--- a/src/parser/seclang-parser.hh
+++ b/src/parser/seclang-parser.hh
@@ -1,4 +1,4 @@
-// A Bison parser, made by GNU Bison 3.5.2.
+// A Bison parser, made by GNU Bison 3.5.3.
 
 // Skeleton interface for Bison LALR(1) parsers in C++
 
diff --git a/src/parser/seclang-parser.yy b/src/parser/seclang-parser.yy
index 02d4db25..aa29a430 100644
--- a/src/parser/seclang-parser.yy
+++ b/src/parser/seclang-parser.yy
@@ -1076,16 +1076,15 @@ expression:
         }
 
         Operator *op = $3.release();
-        Rule *rule = new Rule(
+        std::unique_ptr<Rule> rule(new Rule(
             /* op */ op,
             /* variables */ v,
             /* actions */ a,
             /* file name */ *@1.end.filename,
             /* line number */ @1.end.line
-            );
+            ));
 
-        if (driver.addSecRule(rule) == false) {
-            delete rule;
+        if (driver.addSecRule(std::move(rule)) == false) {
             YYERROR;
         }
       }
@@ -1096,15 +1095,14 @@ expression:
             v->push_back(i.release());
         }
 
-        Rule *rule = new Rule(
+        std::unique_ptr<Rule> rule(new Rule(
             /* op */ $3.release(),
             /* variables */ v,
             /* actions */ NULL,
             /* file name */ *@1.end.filename,
             /* line number */ @1.end.line
-            );
-        if (driver.addSecRule(rule) == false) {
-            delete rule;
+            ));
+        if (driver.addSecRule(std::move(rule)) == false) {
             YYERROR;
         }
       }
@@ -1114,14 +1112,14 @@ expression:
         for (auto &i : *$2.get()) {
             a->push_back(i.release());
         }
-        Rule *rule = new Rule(
+        std::unique_ptr<Rule> rule(new Rule(
             /* op */ NULL,
             /* variables */ NULL,
             /* actions */ a,
             /* file name */ *@1.end.filename,
             /* line number */ @1.end.line
-            );
-        driver.addSecAction(rule);
+            ));
+        driver.addSecAction(std::move(rule));
       }
     | DIRECTIVE_SECRULESCRIPT actions
       {
@@ -1130,20 +1128,18 @@ expression:
         for (auto &i : *$2.get()) {
             a->push_back(i.release());
         }
-        RuleScript *r = new RuleScript(
+        std::unique_ptr<RuleScript> r(new RuleScript(
             /* path to script */ $1,
             /* actions */ a,
             /* file name */ *@1.end.filename,
             /* line number */ @1.end.line
-            );
+            ));
 
         if (r->init(&err) == false) {
             driver.error(@0, "Failed to load script: " + err);
-            delete r;
             YYERROR;
         }
-        if (driver.addSecRuleScript(r) == false) {
-            delete r;
+        if (driver.addSecRuleScript(std::move(r)) == false) {
             YYERROR;
         }
       }
diff --git a/src/parser/stack.hh b/src/parser/stack.hh
index 517e1494..e83ba35f 100644
--- a/src/parser/stack.hh
+++ b/src/parser/stack.hh
@@ -1,4 +1,4 @@
-// A Bison parser, made by GNU Bison 3.5.2.
+// A Bison parser, made by GNU Bison 3.5.3.
 
 // Starting with Bison 3.2, this file is useless: the structure it
 // used to define is now defined with the parser itself.
diff --git a/src/rule.cc b/src/rule.cc
index 19e67884..57a44c97 100644
--- a/src/rule.cc
+++ b/src/rule.cc
@@ -68,7 +68,7 @@ Rule::Rule(const std::string &marker)
     m_phase(-1),
     m_variables(NULL),
     m_op(NULL),
-    m_chainedRuleChild(NULL),
+    m_chainedRuleChild(nullptr),
     m_chainedRuleParent(NULL),
     m_fileName(""),
     m_marker(marker),
@@ -78,9 +78,7 @@ Rule::Rule(const std::string &marker)
     m_actionsRuntimePre(),
     m_actionsSetVar(),
     m_actionsTag(),
-    m_unconditional(false),
-    m_referenceCount(1) { }
-
+    m_unconditional(false) { }
 
 Rule::Rule(Operator *_op,
     variables::Variables *_variables,
@@ -103,7 +101,7 @@ Rule::Rule(Operator *_op,
     m_phase(-1),
     m_variables(_variables),
     m_op(_op),
-    m_chainedRuleChild(NULL),
+    m_chainedRuleChild(nullptr),
     m_chainedRuleParent(NULL),
     m_fileName(fileName),
     m_marker(""),
@@ -113,9 +111,7 @@ Rule::Rule(Operator *_op,
     m_actionsRuntimePre(),
     m_actionsSetVar(),
     m_actionsTag(),
-    m_unconditional(false),
-    m_referenceCount(1)
-    {
+    m_unconditional(false) {
     /* */
     organizeActions(actions);
 
@@ -149,10 +145,6 @@ Rule::~Rule() {
     if (m_variables != NULL) {
         delete m_variables;
     }
-
-    if (m_chainedRuleChild != NULL) {
-        delete m_chainedRuleChild;
-    }
 }
 
 
@@ -779,14 +771,15 @@ bool Rule::evaluate(Transaction *trans,
         goto end_exec;
     }
 
-    if (this->m_chainedRuleChild == NULL) {
+    /* FIXME: this check should happens on the parser. */
+    if (this->m_chainedRuleChild == nullptr) {
         ms_dbg_a(trans, 4, "Rule is marked as chained but there " \
             "isn't a subsequent rule.");
         goto end_clean;
     }
 
     ms_dbg_a(trans, 4, "Executing chained rule.");
-    recursiveGlobalRet = this->m_chainedRuleChild->evaluate(trans, ruleMessage);
+    recursiveGlobalRet = m_chainedRuleChild->evaluate(trans, ruleMessage);
 
     if (recursiveGlobalRet == true) {
         goto end_exec;
diff --git a/src/rules_set.cc b/src/rules_set.cc
index e03d478f..91383d3f 100644
--- a/src/rules_set.cc
+++ b/src/rules_set.cc
@@ -111,7 +111,7 @@ int RulesSet::evaluate(int phase, Transaction *t) {
        return 0;
     }
 
-    std::vector<Rule *> *rules = m_rulesSetPhases[phase];
+    Rules *rules = m_rulesSetPhases[phase];
 
     ms_dbg_a(t, 9, "This phase consists of " \
         + std::to_string(rules->size()) + " rule(s).");
@@ -133,7 +133,7 @@ int RulesSet::evaluate(int phase, Transaction *t) {
     //}
 
     for (int i = 0; i < rules->size(); i++) {
-        Rule *rule = rules->at(i);
+        Rule *rule = rules->at(i).get();
         if (t->m_marker.empty() == false) {
             ms_dbg_a(t, 9, "Skipped rule id '" + std::to_string(rule->m_ruleId) \
                 + "' due to a SecMarker: " + t->m_marker);
diff --git a/src/rules_set_phases.cc b/src/rules_set_phases.cc
index efc07505..470dce53 100644
--- a/src/rules_set_phases.cc
+++ b/src/rules_set_phases.cc
@@ -29,24 +29,13 @@
 namespace modsecurity {
 
 RulesSetPhases::~RulesSetPhases() {
-    /** Cleanup the rules */
-    for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
-        Rules *rules = &m_rules[i];
-        while (rules->empty() == false) {
-            Rule *rule = rules->back();
-            rules->pop_back();
-            if (rule->refCountDecreaseAndCheck()) {
-                rule = NULL;
-            }
-        }
-    }
 }
 
-bool RulesSetPhases::insert(Rule *rule) {
+bool RulesSetPhases::insert(std::shared_ptr<Rule> rule) {
     if (rule->m_phase >= modsecurity::Phases::NUMBER_OF_PHASES) {
         return false;
     }
-    m_rules[rule->m_phase].push_back(rule);
+    m_rules[rule->m_phase].insert(rule);
     return true;
 }
 
@@ -58,7 +47,7 @@ int RulesSetPhases::append(RulesSetPhases *from, std::ostringstream *err) {
     for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
         v.reserve(m_rules[i].size());
         for (size_t z = 0; z < m_rules[i].size(); z++) {
-            Rule *rule_ckc = m_rules[i].at(z);
+            Rule *rule_ckc = m_rules[i].at(z).get();
             if (rule_ckc->m_secMarker == true) {
                 continue;
             }
@@ -67,19 +56,9 @@ int RulesSetPhases::append(RulesSetPhases *from, std::ostringstream *err) {
     }
     std::sort (v.begin(), v.end());
 
-    for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
-        for (size_t j = 0; j < from->at(i)->size(); j++) {
-            Rule *rule = from->at(i)->at(j);
-            if (std::binary_search(v.begin(), v.end(), rule->m_ruleId)) {
-                if (err != NULL) {
-                    *err << "Rule id: " << std::to_string(rule->m_ruleId) \
-                        << " is duplicated" << std::endl;
-                }
-                return -1;
-            }
-            amount_of_rules++;
-            rule->refCountIncrease();
-            m_rules[i].push_back(rule);
+    for (int phase = 0; phase < modsecurity::Phases::NUMBER_OF_PHASES; phase++) {
+        if (m_rules[phase].append(from->at(phase), v, err) < 0) {
+            return -1;
         }
     }
 
@@ -91,10 +70,7 @@ void RulesSetPhases::dump() const {
         std::cout << "Phase: " << std::to_string(i);
         std::cout << " (" << std::to_string(m_rules[i].size());
         std::cout << " rules)" << std::endl;
-        for (int j = 0; j < m_rules[i].size(); j++) {
-            std::cout << "    Rule ID: " << std::to_string(m_rules[i][j]->m_ruleId);
-            std::cout << "--" << m_rules[i][j] << std::endl;
-        }
+        m_rules[i].dump();
     }
 }
 
diff --git a/test/optimization/optimization.cc b/test/optimization/optimization.cc
index e10365ed..ff3daef1 100644
--- a/test/optimization/optimization.cc
+++ b/test/optimization/optimization.cc
@@ -40,14 +40,14 @@ int main(int argc, char **argv) {
     std::list<std::string> files;
     int total = 0;
 
-    int i = 1;
-    while (i < argc) {
+    int p = 1;
+    while (p < argc) {
         std::list<std::string> tfiles = modsecurity::utils::expandEnv(
-            argv[i], 0);
+            argv[p], 0);
         for (const auto &file : tfiles) {
             files.insert(files.begin(), file);
         }
-        i++;
+        p++;
     }
 
 
@@ -68,7 +68,7 @@ int main(int argc, char **argv) {
 
     int nphases = modsecurity::Phases::NUMBER_OF_PHASES;
     for (int j = 0; j < nphases; j++) {
-        std::vector<Rule *> *rules = modsecRules->m_rulesSetPhases[j];
+        Rules *rules = modsecRules->m_rulesSetPhases[j];
         if (rules->size() == 0) {
             continue;
         }
@@ -79,7 +79,9 @@ int main(int argc, char **argv) {
         std::unordered_map<std::string, int> operators;
         std::unordered_map<std::string, int> variables;
         std::unordered_map<std::string, int> op2var;
-        for (auto &z : *rules) {
+
+        for (int i = 0; i < rules->size(); i++) {
+            std::shared_ptr<Rule> z = rules->at(i);
             std::string key;
             if (z == NULL) {
                 continue;
diff --git a/test/test-cases/regression/issue-1831.json b/test/test-cases/regression/issue-1831.json
index 6ebd495c..773a0eec 100644
--- a/test/test-cases/regression/issue-1831.json
+++ b/test/test-cases/regression/issue-1831.json
@@ -191,7 +191,7 @@
     "rules": [
       "SecRuleEngine On",
       "SecRule ARGS \"@rx .\" \"id:954100,phase:1,block,capture,t:none,t:lowercase,msg:'Disclosure of IIS install location',logdata:'Matched Data',tag:'application-multi',tag:'language-multi',tag:'platform-iis',tag:'platform-windows',tag:'attack-disclosure',ctl:auditLogParts=+E,rev:3,ver:'OWASP_CRS/3.0.0',severity:'ERROR',chain\"",
-      "SecRule &GLOBAL:alerted_970018_iisDefLoc \"@eq 0\" \"setvar:'global.alerted_970018_iisDefLoc',setvar:'tx.msg=%{rule.msg}',setvar:'tx.outbound_anomaly_score=+%{tx.error_anomaly_score}',setvar:'tx.anomaly_score=+%{tx.error_anomaly_score}'\""
+      "SecRule ARGS \"@eq 0\" \"setvar:'global.alerted_970018_iisDefLoc',setvar:'tx.msg=%{rule.msg}',setvar:'tx.outbound_anomaly_score=+%{tx.error_anomaly_score}',setvar:'tx.anomaly_score=+%{tx.error_anomaly_score}'\""
     ]
   }
 ]