Having a better organization for Variables::

headers/modsecurity/rule.h

@@ -34,6 +34,7 @@
 namespace modsecurity {
 namespace Variables {
 class Variable;
+class Variables;
 }
 namespace actions {
 class Action;
@@ -45,7 +46,7 @@ class Operator;
 class Rule {
  public:
     Rule(operators::Operator *_op,
-            std::vector<Variables::Variable *> *_variables,
+            Variables::Variables *_variables,
             std::vector<actions::Action *> *_actions,
             std::string fileName,
             int lineNumber);
@@ -110,7 +111,7 @@ class Rule {
     std::string m_rev;
     int64_t m_ruleId;
     bool m_secMarker;
-    std::vector<Variables::Variable *> *m_variables;
+    modsecurity::Variables::Variables *m_variables;
     std::string m_ver;
 
  private:

src/parser/seclang-parser.cc

@@ -2011,7 +2011,7 @@ namespace yy {
         for (auto &i : *yystack_[0].value.as< std::unique_ptr<std::vector<std::unique_ptr<actions::Action> > >  > ().get()) {
             a->push_back(i.release());
         }
-        std::vector<Variable *> *v = new std::vector<Variable *>();
+        Variables::Variables *v = new Variables::Variables();
         for (auto &i : *yystack_[2].value.as< std::unique_ptr<std::vector<std::unique_ptr<Variable> > >  > ().get()) {
             v->push_back(i.release());
         }
@@ -2035,7 +2035,7 @@ namespace yy {
   case 74:
 #line 1121 "seclang-parser.yy" // lalr1.cc:856
     {
-        std::vector<Variable *> *v = new std::vector<Variable *>();
+        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());
         }
@@ -2896,7 +2896,7 @@ namespace yy {
         while (!originalList->empty()) {
             std::unique_ptr<Variable> var = std::move(originalList->back());
             originalList->pop_back();
-            if (var->m_isExclusion) {
+            if (dynamic_cast<VariableModificatorExclusion*>(var.get())) {
                 exclusionVars->push_back(std::move(var));
             } else {
                 newList->push_back(std::move(var));

src/parser/seclang-parser.yy

@@ -1099,7 +1099,7 @@ expression:
         for (auto &i : *$4.get()) {
             a->push_back(i.release());
         }
-        std::vector<Variable *> *v = new std::vector<Variable *>();
+        Variables::Variables *v = new Variables::Variables();
         for (auto &i : *$2.get()) {
             v->push_back(i.release());
         }
@@ -1119,7 +1119,7 @@ expression:
       }
     | DIRECTIVE variables op
       {
-        std::vector<Variable *> *v = new std::vector<Variable *>();
+        Variables::Variables *v = new Variables::Variables();
         for (auto &i : *$2.get()) {
             v->push_back(i.release());
         }
@@ -1732,7 +1732,7 @@ variables:
         while (!originalList->empty()) {
             std::unique_ptr<Variable> var = std::move(originalList->back());
             originalList->pop_back();
-            if (var->m_isExclusion) {
+            if (dynamic_cast<VariableModificatorExclusion*>(var.get())) {
                 exclusionVars->push_back(std::move(var));
             } else {
                 newList->push_back(std::move(var));

src/rule.cc

@@ -70,7 +70,7 @@ Rule::Rule(std::string marker)
 
 
 Rule::Rule(Operator *_op,
-        std::vector<Variable *> *_variables,
+        Variables::Variables *_variables,
         std::vector<Action *> *actions,
         std::string fileName,
         int lineNumber)
@@ -425,7 +425,7 @@ std::vector<std::unique_ptr<VariableValue>> Rule::getFinalVars(
     std::list<std::string> exclusions_update_by_tag_remove;
     std::list<std::string> exclusions_update_by_msg_remove;
     std::list<std::string> exclusions_update_by_id_remove;
-    std::vector<Variables::Variable *> variables;
+    Variables::Variables variables;
     std::vector<std::unique_ptr<VariableValue>> finalVars;
 
     std::copy(m_variables->begin(), m_variables->end(),
@@ -436,7 +436,8 @@ std::vector<std::unique_ptr<VariableValue>> Rule::getFinalVars(
         if (containsTag(*a.first.get(), trans) == false) {
             continue;
         }
-        if (a.second->m_isExclusion) {
+        if (dynamic_cast<Variables::VariableModificatorExclusion*>(
+                a.second.get())) {
             std::vector<const VariableValue *> z;
             a.second->evaluate(trans, this, &z);
             for (auto &y : z) {
@@ -458,7 +459,8 @@ std::vector<std::unique_ptr<VariableValue>> Rule::getFinalVars(
         if (containsMsg(*a.first.get(), trans) == false) {
             continue;
         }
-        if (a.second->m_isExclusion) {
+        if (dynamic_cast<Variables::VariableModificatorExclusion*>(
+                a.second.get())) {
             std::vector<const VariableValue *> z;
             a.second->evaluate(trans, this, &z);
             for (auto &y : z) {
@@ -480,7 +482,8 @@ std::vector<std::unique_ptr<VariableValue>> Rule::getFinalVars(
         if (m_ruleId != a.first) {
             continue;
         }
-        if (a.second->m_isExclusion) {
+        if (dynamic_cast<Variables::VariableModificatorExclusion*>(
+                a.second.get())) {
             std::vector<const VariableValue *> z;
             a.second->evaluate(trans, this, &z);
             for (auto &y : z) {
@@ -712,7 +715,7 @@ void Rule::executeActionsAfterFullMatch(Transaction *trans,
 bool Rule::evaluate(Transaction *trans,
     std::shared_ptr<RuleMessage> ruleMessage) {
     bool globalRet = false;
-    std::vector<Variable *> *variables = this->m_variables;
+    Variables::Variables *variables = this->m_variables;
     bool recursiveGlobalRet;
     bool containsBlock = false;
     std::vector<std::unique_ptr<VariableValue>> finalVars;
@@ -764,14 +767,14 @@ bool Rule::evaluate(Transaction *trans,
         + "\" with param " \
         + eparam \
         + " against " \
-        + Variable::to_s(variables) + ".");
+        + variables + ".");
 #endif
     } else {
 #ifndef NO_LOGS
     trans->debug(4, "(Rule: " + std::to_string(m_ruleId) \
         + ") Executing operator \"" + this->m_op->m_op \
         + " against " \
-        + Variable::to_s(variables) + ".");
+        + variables + ".");
 #endif
     }
 

src/variables/args.h

@@ -29,51 +29,7 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class Args_DictElement : public Variable {
+DEFINE_VARIABLE_DICT(Args, ARGS, m_variableArgs)
- public:
-    explicit Args_DictElement(std::string dictElement)
-        : Variable("ARGS" + std::string(":") + std::string(dictElement)),
-        m_dictElement(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgs.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class Args_NoDictElement : public Variable {
- public:
-    Args_NoDictElement()
-        : Variable("ARGS") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgs.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class Args_DictElementRegexp : public Variable {
- public:
-    explicit Args_DictElementRegexp(std::string dictElement)
-        : Variable("ARGS:regex(" + dictElement + ")"),
-        m_r(dictElement) {
-    }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgs.resolveRegularExpression(&m_r, l,
-            m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/args_combined_size.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ArgsCombinedSize : public Variable {
- public:
-    ArgsCombinedSize()
-        : Variable("ARGS_COMBINED_SIZE") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(ArgsCombinedSize, ARGS_COMBINED_SIZE,
-        Rule *rule,
+    m_variableARGScombinedSize)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableARGScombinedSize.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/args_get.h

@@ -29,50 +29,8 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ArgsGet_DictElement : public Variable {
- public:
-    explicit ArgsGet_DictElement(std::string dictElement)
-        : Variable("ARGS_GET" + std::string(":") + std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(ArgsGet, ARGS_GET, m_variableArgsGet)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsGet.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class ArgsGet_NoDictElement : public Variable {
- public:
-    ArgsGet_NoDictElement()
-        : Variable("ARGS_GET") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsGet.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class ArgsGet_DictElementRegexp : public Variable {
- public:
-    explicit ArgsGet_DictElementRegexp(std::string dictElement)
-        : Variable("ARGS_GET:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsGet.resolveRegularExpression(&m_r, l,
-            m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/args_get_names.h

@@ -29,49 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ArgsGetNames_DictElement : public Variable {
- public:
-    explicit ArgsGetNames_DictElement(std::string dictElement)
-        : Variable("ARGS_GET_NAMES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(ArgsGetNames, ARGS_GET_NAMES, m_variableArgsGetNames)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsGetNames.resolve(m_dictElement, l);
-    }
 
-    std::string m_dictElement;
-};
-
-class ArgsGetNames_NoDictElement : public Variable {
- public:
-    ArgsGetNames_NoDictElement()
-        : Variable("ARGS_GET_NAMES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsGetNames.resolve(l, m_keyExclusion);
-    }
-};
-
-class ArgsGetNames_DictElementRegexp : public Variable {
- public:
-    explicit ArgsGetNames_DictElementRegexp(std::string dictElement)
-        : Variable("ARGS_GET_NAMES:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsGetNames.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/args_names.h

@@ -29,49 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ArgsNames_DictElement : public Variable {
- public:
-    explicit ArgsNames_DictElement(std::string dictElement)
-        : Variable("ARGS_NAMES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(ArgsNames, ARGS_NAMES, m_variableArgsNames)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsNames.resolve(m_dictElement, l);
-    }
 
-    std::string m_dictElement;
-};
-
-class ArgsNames_NoDictElement : public Variable {
- public:
-    ArgsNames_NoDictElement()
-        : Variable("ARGS_NAMES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsNames.resolve(l, m_keyExclusion);
-    }
-};
-
-class ArgsNames_DictElementRegexp : public Variable {
- public:
-    explicit ArgsNames_DictElementRegexp(std::string dictElement)
-        : Variable("ARGS_NAMES:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsNames.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/args_post.h

@@ -29,50 +29,8 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ArgsPost_DictElement : public Variable {
- public:
-    explicit ArgsPost_DictElement(std::string dictElement)
-        : Variable("ARGS_POST" + std::string(":") + std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(ArgsPost, ARGS_POST, m_variableArgsPost)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsPost.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class ArgsPost_NoDictElement : public Variable {
- public:
-    ArgsPost_NoDictElement()
-        : Variable("ARGS_POST") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsPost.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class ArgsPost_DictElementRegexp : public Variable {
- public:
-    explicit ArgsPost_DictElementRegexp(std::string dictElement)
-        : Variable("ARGS_POST:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsPost.resolveRegularExpression(&m_r, l,
-            m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/args_post_names.h

@@ -29,49 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ArgsPostNames_DictElement : public Variable {
- public:
-    explicit ArgsPostNames_DictElement(std::string dictElement)
-        : Variable("ARGS_POST_NAMES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(ArgsPostNames, ARGS_POST_NAMES, m_variableArgsPostNames)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsPostNames.resolve(m_dictElement, l);
-    }
 
-    std::string m_dictElement;
-};
-
-class ArgsPostNames_NoDictElement : public Variable {
- public:
-    ArgsPostNames_NoDictElement()
-        : Variable("ARGS_POST_NAMES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsPostNames.resolve(l, m_keyExclusion);
-    }
-};
-
-class ArgsPostNames_DictElementRegexp : public Variable {
- public:
-    explicit ArgsPostNames_DictElementRegexp(std::string dictElement)
-        : Variable("ARGS_POST_NAMES:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableArgsPostNames.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/auth_type.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class AuthType : public Variable {
- public:
-    AuthType()
-        : Variable("AUTH_TYPE") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(AuthType, AUTH_TYPE, m_variableAuthType)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableAuthType.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/files.h

@@ -29,51 +29,8 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class Files_DictElement : public Variable {
- public:
-    explicit Files_DictElement(std::string dictElement)
-        : Variable("FILES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(Files, FILES, m_variableFiles)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFiles.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class Files_NoDictElement : public Variable {
- public:
-    Files_NoDictElement()
-        : Variable("FILES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFiles.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class Files_DictElementRegexp : public Variable {
- public:
-    explicit Files_DictElementRegexp(std::string dictElement)
-        : Variable("FILES:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFiles.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/files_combined_size.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class FilesCombinedSize : public Variable {
- public:
-    FilesCombinedSize()
-        : Variable("FILES_COMBINED_SIZE") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(FilesCombinedSize, FILES_COMBINED_SIZE,
-        Rule *rule,
+    m_variableFilesCombinedSize)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableFilesCombinedSize.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/files_names.h

@@ -29,52 +29,8 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class FilesNames_DictElement : public Variable {
- public:
-    explicit FilesNames_DictElement(std::string dictElement)
-        : Variable("FILES_NAMES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(FilesNames, FILES_NAMES, m_variableFilesNames)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesNames.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class FilesNames_NoDictElement : public Variable {
- public:
-    FilesNames_NoDictElement()
-        : Variable("FILES_NAMES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesNames.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class FilesNames_DictElementRegexp : public Variable {
- public:
-    explicit FilesNames_DictElementRegexp(std::string dictElement)
-        : Variable("FILES_NAMES:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesNames.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/files_sizes.h

@@ -29,51 +29,8 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class FilesSizes_DictElement : public Variable {
- public:
-    explicit FilesSizes_DictElement(std::string dictElement)
-        : Variable("FILES_SIZES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(FilesSizes, FILES_SIZES, m_variableFilesSizes)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesSizes.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class FilesSizes_NoDictElement : public Variable {
- public:
-    FilesSizes_NoDictElement()
-        : Variable("FILES_SIZES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesSizes.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class FilesSizes_DictElementRegexp : public Variable {
- public:
-    explicit FilesSizes_DictElementRegexp(std::string dictElement)
-        : Variable("FILES_SIZES"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesSizes.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/files_tmp_content.h

@@ -29,51 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class FilesTmpContent_DictElement : public Variable {
- public:
-    explicit FilesTmpContent_DictElement(std::string dictElement)
-        : Variable("FILES_TMP_CONTENT" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(FilesTmpContent, FILES_TMP_CONTENT,
-        Rule *rule,
+    m_variableFilesTmpContent)
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesTmpContent.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class FilesTmpContent_NoDictElement : public Variable {
- public:
-    FilesTmpContent_NoDictElement()
-        : Variable("FILES_TMP_CONTENT") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesTmpContent.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class FilesTmpContent_DictElementRegexp : public Variable {
- public:
-    explicit FilesTmpContent_DictElementRegexp(std::string dictElement)
-        : Variable("FILES_TMP_CONTENT:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesTmpContent.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/files_tmp_names.h

@@ -28,51 +28,9 @@ namespace modsecurity {
 
 class Transaction;
 namespace Variables {
-class FilesTmpNames_DictElement : public Variable {
- public:
-    explicit FilesTmpNames_DictElement(std::string dictElement)
-        : Variable("FILES_TMPNAMES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesTmpNames.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
 
 
-class FilesTmpNames_NoDictElement : public Variable {
+DEFINE_VARIABLE_DICT(FilesTmpNames, FILES_TMPNAMES, m_variableFilesTmpNames)
- public:
-    FilesTmpNames_NoDictElement()
-        : Variable("FILES_TMPNAMES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesTmpNames.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class FilesTmpNames_DictElementRegexp : public Variable {
- public:
-    explicit FilesTmpNames_DictElementRegexp(std::string dictElement)
-        : Variable("FILES_TMPNAMES:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableFilesTmpNames.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/full_request.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class FullRequest : public Variable {
- public:
-    FullRequest()
-        : Variable("FULL_REQUEST") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(FullRequest, FULL_REQUEST, m_variableFullRequest)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableFullRequest.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/full_request_length.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class FullRequestLength : public Variable {
- public:
-    FullRequestLength()
-        : Variable("FULL_REQUEST_LENGTH") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(FullRequestLength, FULL_REQUEST_LENGTH,
-        Rule *rule,
+    m_variableFullRequestLength)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableFullRequestLength.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/geo.h

@@ -29,51 +29,8 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class Geo_DictElement : public Variable {
- public:
-    explicit Geo_DictElement(std::string dictElement)
-        : Variable("GEO" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(Geo, GEO, m_variableGeo)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableGeo.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class Geo_NoDictElement : public Variable {
- public:
-    Geo_NoDictElement()
-        : Variable("GEO") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableGeo.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class Geo_DictElementRegexp : public Variable {
- public:
-    explicit Geo_DictElementRegexp(std::string dictElement)
-        : Variable("GEO:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableGeo.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/global.h

@@ -65,11 +65,10 @@ class Global_NoDictElement : public Variable {
 };
 
 
-class Global_DictElementRegexp : public Variable {
+class Global_DictElementRegexp : public VariableRegex {
  public:
     explicit Global_DictElementRegexp(std::string dictElement)
-        : Variable("GLOBAL:regex(" + dictElement + ")"),
+        : VariableRegex("GLOBAL", dictElement),
-        m_r(dictElement),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *t,
@@ -81,7 +80,6 @@ class Global_DictElementRegexp : public Variable {
             t->m_rules->m_secWebAppId.m_value, l, m_keyExclusion);
     }
 
-    Utils::Regex m_r;
     std::string m_dictElement;
 };
 

src/variables/inbound_data_error.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class InboundDataError : public Variable {
- public:
-    InboundDataError()
-        : Variable("INBOUND_DATA_ERROR") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(InboundDataError, INBOUND_DATA_ERROR, m_variableInboundDataError)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableInboundDataError.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/ip.h

@@ -65,11 +65,10 @@ class Ip_NoDictElement : public Variable {
 };
 
 
-class Ip_DictElementRegexp : public Variable {
+class Ip_DictElementRegexp : public VariableRegex {
  public:
     explicit Ip_DictElementRegexp(std::string dictElement)
-        : Variable("IP:regex(" + dictElement + ")"),
+        : VariableRegex("IP", dictElement),
-        m_r(dictElement),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *t,
@@ -80,7 +79,6 @@ class Ip_DictElementRegexp : public Variable {
             t->m_rules->m_secWebAppId.m_value, l, m_keyExclusion);
     }
 
-    Utils::Regex m_r;
     std::string m_dictElement;
 };
 

src/variables/matched_var.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MatchedVar : public Variable {
- public:
-    MatchedVar()
-        : Variable("MATCHED_VAR") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MatchedVar, MATCHED_VAR, m_variableMatchedVar)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableMatchedVar.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/matched_var_name.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MatchedVarName : public Variable {
- public:
-    MatchedVarName()
-        : Variable("MATCHED_VAR_NAME") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MatchedVarName, MATCHED_VAR_NAME, m_variableMatchedVarName)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMatchedVarName.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/matched_vars.h

@@ -29,51 +29,8 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MatchedVars_DictElement : public Variable {
- public:
-    explicit MatchedVars_DictElement(std::string dictElement)
-        : Variable("MATCHED_VARS" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(MatchedVars, MATCHED_VARS, m_variableMatchedVars)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMatchedVars.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class MatchedVars_NoDictElement : public Variable {
- public:
-    MatchedVars_NoDictElement()
-        : Variable("MATCHED_VARS") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMatchedVars.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class MatchedVars_DictElementRegexp : public Variable {
- public:
-    explicit MatchedVars_DictElementRegexp(std::string dictElement)
-        : Variable("MATCHED_VARS:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMatchedVars.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/matched_vars_names.h

@@ -29,51 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MatchedVarsNames_DictElement : public Variable {
- public:
-    explicit MatchedVarsNames_DictElement(std::string dictElement)
-        : Variable("MATCHED_VARS_NAMES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(MatchedVarsNames, MATCHED_VARS_NAMES,
-        Rule *rule,
+   m_variableMatchedVarsNames)
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMatchedVarsNames.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class MatchedVarsNames_NoDictElement : public Variable {
- public:
-    MatchedVarsNames_NoDictElement()
-        : Variable("MATCHED_VARS_NAMES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMatchedVarsNames.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class MatchedVarsNames_DictElementRegexp : public Variable {
- public:
-    explicit MatchedVarsNames_DictElementRegexp(std::string dictElement)
-        : Variable("MATCHED_VARS_NAMES:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMatchedVarsNames.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-     Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/multipart_boundary_quoted.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartBoundaryQuoted : public Variable {
- public:
-    MultipartBoundaryQuoted()
-        : Variable("MULTIPART_BOUNDARY_QUOTED") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartBoundaryQuoted, MULTIPART_BOUNDARY_QUOTED,
-        Rule *rule,
+    m_variableMultipartBoundaryQuoted)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableMultipartBoundaryQuoted.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_boundary_whitespace.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartBoundaryWhiteSpace : public Variable {
- public:
-    MultipartBoundaryWhiteSpace()
-        : Variable("MULTIPART_BOUNDARY_WHITESPACE") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartBoundaryWhiteSpace, MULTIPART_BOUNDARY_WHITESPACE,
-        Rule *rule,
+    m_variableMultipartBoundaryWhiteSpace)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableMultipartBoundaryWhiteSpace.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_crlf_lf_lines.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartCrlfLFLines : public Variable {
- public:
-    MultipartCrlfLFLines()
-        : Variable("MULTIPART_CRLF_LF_LINES") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartCrlfLFLines, MULTIPART_CRLF_LF_LINES,
-        Rule *rule,
+    m_variableMultipartCrlfLFLines)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableMultipartCrlfLFLines.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_data_after.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartDateAfter : public Variable {
- public:
-    MultipartDateAfter()
-        : Variable("MULTIPART_DATA_AFTER") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartDateAfter, MULTIPART_DATA_AFTER,
-        Rule *rule,
+    m_variableMultipartDataAfter)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableMultipartDataAfter.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_data_before.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartDateBefore : public Variable {
- public:
-    MultipartDateBefore()
-        : Variable("MULTIPART_DATA_BEFORE") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartDateBefore, MULTIPART_DATA_BEFORE,
-        Rule *rule,
+    m_variableMultipartDataBefore)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableMultipartDataBefore.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_file_limit_exceeded.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartFileLimitExceeded : public Variable {
- public:
-    MultipartFileLimitExceeded()
-        : Variable("MULTIPART_FILE_LIMIT_EXCEEDED") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartFileLimitExceeded, MULTIPART_FILE_LIMIT_EXCEEDED,
-        Rule *rule,
+    m_variableMultipartFileLimitExceeded)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableMultipartFileLimitExceeded.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_file_name.h

@@ -29,51 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultiPartFileName_DictElement : public Variable {
- public:
-    explicit MultiPartFileName_DictElement(std::string dictElement)
-        : Variable("MULTIPART_FILENAME" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(MultiPartFileName, MULTIPART_FILENAME,
-        Rule *rule,
+    m_variableMultipartFileName)
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMultipartFileName.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class MultiPartFileName_NoDictElement : public Variable {
- public:
-    MultiPartFileName_NoDictElement()
-        : Variable("MULTIPART_FILENAME") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMultipartFileName.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class MultiPartFileName_DictElementRegexp : public Variable {
- public:
-    explicit MultiPartFileName_DictElementRegexp(std::string dictElement)
-        : Variable("MULTIPART_FILENAME:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMultipartFileName.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/multipart_header_folding.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartHeaderFolding : public Variable {
- public:
-    MultipartHeaderFolding()
-        : Variable("MULTIPART_HEADER_FOLDING") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartHeaderFolding, MULTIPART_HEADER_FOLDING,
-        Rule *rule,
+    m_variableMultipartHeaderFolding)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableMultipartHeaderFolding.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_invalid_header_folding.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartInvalidHeaderFolding : public Variable {
- public:
-    MultipartInvalidHeaderFolding()
-        : Variable("MULTIPART_INVALID_HEADER_FOLDING") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartInvalidHeaderFolding, MULTIPART_INVALID_HEADER_FOLDING, m_variableMultipartInvalidHeaderFolding)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableMultipartInvalidHeaderFolding.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_invalid_part.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartInvalidPart : public Variable {
- public:
-    MultipartInvalidPart()
-        : Variable("MULTIPART_INVALID_PART") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartInvalidPart, MULTIPART_INVALID_PART,
-        Rule *rule,
+    m_variableMultipartInvalidHeaderFolding)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableMultipartInvalidPart.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_invalid_quoting.h

@@ -29,16 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartInvalidQuoting : public Variable {
+
- public:
+DEFINE_VARIABLE(MultipartInvalidQuoting, MULTIPART_INVALID_QUOTING,
-    MultipartInvalidQuoting()
+    m_variableMultipartInvalidQuoting)
-        : Variable("MULTIPART_INVALID_QUOTING") { }
+
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableMultipartInvalidQuoting.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_lf_line.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartLFLine : public Variable {
- public:
-    MultipartLFLine()
-        : Variable("MULTIPART_LF_LINE") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartLFLine, MULTIPART_LF_LINE, m_variableMultipartLFLine)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableMultipartLFLine.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_missing_semicolon.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartMissingSemicolon : public Variable {
- public:
-    MultipartMissingSemicolon()
-        : Variable("MULTIPART_MISSING_SEMICOLON") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartMissingSemicolon, MULTIPART_MISSING_SEMICOLON,
-        Rule *rule,
+    m_variableMultipartMissingSemicolon)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableMultipartMissingSemicolon.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_name.h

@@ -29,51 +29,8 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultiPartName_DictElement : public Variable {
- public:
-    explicit MultiPartName_DictElement(std::string dictElement)
-        : Variable("MULTIPART_NAME" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(MultiPartName, MULTIPART_NAME, m_variableMultipartName)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMultipartName.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class MultiPartName_NoDictElement : public Variable {
- public:
-    MultiPartName_NoDictElement()
-        : Variable("MULTIPART_NAME") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMultipartName.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class MultiPartName_DictElementRegexp : public Variable {
- public:
-    explicit MultiPartName_DictElementRegexp(std::string dictElement)
-        : Variable("MULTIPART_NAME:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableMultipartName.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/multipart_strict_error.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartStrictError : public Variable {
- public:
-    MultipartStrictError()
-        : Variable("MULTIPART_STRICT_ERROR") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartStrictError, MULTIPART_STRICT_ERROR,
-        Rule *rule,
+    m_variableMultipartStrictError)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableMultipartStrictError.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/multipart_unmatched_boundary.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class MultipartUnmatchedBoundary : public Variable {
- public:
-    MultipartUnmatchedBoundary()
-        : Variable("MULTIPART_UNMATCHED_BOUNDARY") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(MultipartUnmatchedBoundary, MULTIPART_UNMATCHED_BOUNDARY,
-        Rule *rule,
+    m_variableMultipartUnmatchedBoundary)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableMultipartUnmatchedBoundary.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/outbound_data_error.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class OutboundDataError : public Variable {
- public:
-    OutboundDataError()
-        : Variable("OUTBOUND_DATA_ERROR") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(OutboundDataError, OUTBOUND_DATA_ERROR,
-        Rule *rule,
+    m_variableOutboundDataError)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableOutboundDataError.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/path_info.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class PathInfo : public Variable {
- public:
-    PathInfo()
-        : Variable("PATH_INFO") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(PathInfo, PATH_INFO, m_variablePathInfo)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variablePathInfo.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/query_string.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class QueryString : public Variable {
- public:
-    QueryString()
-        : Variable("QUERY_STRING") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(QueryString, QUERY_STRING, m_variableQueryString)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableQueryString.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/remote_addr.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RemoteAddr : public Variable {
- public:
-    RemoteAddr()
-        : Variable("REMOTE_ADDR") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(RemoteAddr, REMOTE_ADDR, m_variableRemoteAddr)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRemoteAddr.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/remote_host.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RemoteHost : public Variable {
- public:
-    RemoteHost()
-        : Variable("REMOTE_HOST") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(RemoteHost, REMOTE_HOST, m_variableRemoteHost)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRemoteHost.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/remote_port.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RemotePort : public Variable {
- public:
-    RemotePort()
-        : Variable("REMOTE_PORT") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(RemotePort, REMOTE_PORT, m_variableRemotePort)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRemotePort.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/reqbody_error.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ReqbodyError : public Variable {
- public:
-    ReqbodyError()
-        : Variable("REQBODY_ERROR") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(ReqbodyError, REQBODY_ERROR, m_variableReqbodyError)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableReqbodyError.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/reqbody_error_msg.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ReqbodyErrorMsg : public Variable {
+
- public:
+DEFINE_VARIABLE(ReqbodyErrorMsg, REQBODY_ERROR_MSG, m_variableReqbodyErrorMsg)
-    ReqbodyErrorMsg()
+
-        : Variable("REQBODY_ERROR_MSG") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableReqbodyErrorMsg.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/reqbody_processor.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ReqbodyProcessor : public Variable {
+
- public:
+DEFINE_VARIABLE(ReqbodyProcessor, REQBODY_PROCESSOR, m_variableReqbodyProcessor)
-    ReqbodyProcessor()
+
-        : Variable("REQBODY_PROCESSOR") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableReqbodyProcessor.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/reqbody_processor_error.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ReqbodyProcessorError : public Variable {
- public:
-    ReqbodyProcessorError()
-        : Variable("REQBODY_PROCESSOR_ERROR") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(ReqbodyProcessorError, REQBODY_PROCESSOR_ERROR,
-        Rule *rule,
+    m_variableReqbodyProcessorError)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableReqbodyProcessorError.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/reqbody_processor_error_msg.h

@@ -29,17 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ReqbodyProcessorErrorMsg : public Variable {
- public:
-    ReqbodyProcessorErrorMsg()
-        : Variable("PROCESSOR_ERROR_MSG") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(ReqbodyProcessorErrorMsg, PROCESSOR_ERROR_MSG,
-        Rule *rule,
+    m_variableReqbodyProcessorErrorMsg)
-        std::vector<const VariableValue *> *l) {
+
-        transaction->m_variableReqbodyProcessorErrorMsg.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/request_base_name.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestBasename : public Variable {
- public:
-    RequestBasename()
-        : Variable("REQUEST_BASENAME") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(RequestBasename, REQUEST_BASENAME, m_variableRequestBasename)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRequestBasename.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/request_body.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestBody : public Variable {
+
- public:
+DEFINE_VARIABLE(RequestBody, REQUEST_BODY, m_variableRequestBody)
-    RequestBody()
+
-        : Variable("REQUEST_BODY") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRequestBody.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/request_body_length.h

@@ -29,16 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestBodyLength : public Variable {
+
- public:
+DEFINE_VARIABLE(RequestBodyLength, REQUEST_BODY_LENGTH,
-    RequestBodyLength()
+    m_variableRequestBodyLength)
-        : Variable("REQUEST_BODY_LENGTH") { }
+
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRequestBodyLength.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/request_cookies.h

@@ -29,53 +29,8 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestCookies_DictElement : public Variable {
- public:
-    explicit RequestCookies_DictElement(std::string dictElement)
-        : Variable("REQUEST_COOKIES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(RequestCookies, REQUEST_COOKIES, m_variableRequestCookies)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestCookies.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class RequestCookies_NoDictElement : public Variable {
- public:
-    RequestCookies_NoDictElement()
-        : Variable("REQUEST_COOKIES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestCookies.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class RequestCookies_DictElementRegexp : public Variable {
- public:
-    explicit RequestCookies_DictElementRegexp(std::string dictElement)
-        : Variable("REQUEST_COOKIES:regex(" + dictElement + ")"),
-        m_r(dictElement) {
-            m_regex = dictElement;
-        }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestCookies.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/request_cookies_names.h

@@ -29,51 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestCookiesNames_DictElement : public Variable {
- public:
-    explicit RequestCookiesNames_DictElement(std::string dictElement)
-        : Variable("REQUEST_COOKIES_NAMES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(RequestCookiesNames, REQUEST_COOKIES_NAMES,
-        Rule *rule,
+    m_variableRequestCookiesNames)
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestCookiesNames.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class RequestCookiesNames_NoDictElement : public Variable {
- public:
-    RequestCookiesNames_NoDictElement()
-        : Variable("REQUEST_COOKIES_NAMES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestCookiesNames.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class RequestCookiesNames_DictElementRegexp : public Variable {
- public:
-    explicit RequestCookiesNames_DictElementRegexp(std::string dictElement)
-        : Variable("REQUEST_COOKIES_NAMES:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestCookiesNames.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/request_file_name.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestFilename : public Variable {
+
- public:
+DEFINE_VARIABLE(RequestFilename, REQUEST_FILENAME, m_variableRequestFilename)
-    RequestFilename()
+
-        : Variable("REQUEST_FILENAME") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRequestFilename.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/request_headers.h

@@ -29,51 +29,8 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestHeaders_DictElement : public Variable {
- public:
-    explicit RequestHeaders_DictElement(std::string dictElement)
-        : Variable("REQUEST_HEADERS" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(RequestHeaders, REQUEST_HEADERS, m_variableRequestHeaders)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestHeaders.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class RequestHeaders_NoDictElement : public Variable {
- public:
-    RequestHeaders_NoDictElement()
-        : Variable("REQUEST_HEADERS") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestHeaders.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class RequestHeaders_DictElementRegexp : public Variable {
- public:
-    explicit RequestHeaders_DictElementRegexp(std::string dictElement)
-        : Variable("REQUEST_HEADERS"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestHeaders.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/request_headers_names.h

@@ -29,49 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestHeadersNames_DictElement : public Variable {
- public:
-    explicit RequestHeadersNames_DictElement(std::string dictElement)
-        : Variable("REQUEST_HEADERS_NAMES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(RequestHeadersNames, REQUEST_HEADERS_NAMES,
-        Rule *rule,
+    m_variableRequestHeadersNames)
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestHeadersNames.resolve(m_dictElement, l);
-    }
 
-    std::string m_dictElement;
-};
-
-class RequestHeadersNames_NoDictElement : public Variable {
- public:
-    RequestHeadersNames_NoDictElement()
-        : Variable("REQUEST_HEADERS_NAMES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestHeadersNames.resolve(l, m_keyExclusion);
-    }
-};
-
-class RequestHeadersNames_DictElementRegexp : public Variable {
- public:
-    explicit RequestHeadersNames_DictElementRegexp(std::string dictElement)
-        : Variable("REQUEST_HEADERS_NAMES:regex(" + dictElement + ")"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRequestHeadersNames.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/request_line.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestLine : public Variable {
+
- public:
+DEFINE_VARIABLE(RequestLine, REQUEST_LINE, m_variableRequestLine)
-    RequestLine()
+
-        : Variable("REQUEST_LINE") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRequestLine.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/request_method.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestMethod : public Variable {
+
- public:
+DEFINE_VARIABLE(RequestMethod, REQUEST_METHOD, m_variableRequestMethod)
-    RequestMethod()
+
-        : Variable("REQUEST_METHOD") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRequestMethod.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/request_protocol.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestProtocol : public Variable {
+
- public:
+DEFINE_VARIABLE(RequestProtocol, REQUEST_PROTOCOL, m_variableRequestProtocol)
-    RequestProtocol()
+
-        : Variable("REQUEST_PROTOCOL") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRequestProtocol.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/request_uri.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestURI : public Variable {
+
- public:
+DEFINE_VARIABLE(RequestURI, REQUEST_URI, m_variableRequestURI)
-    RequestURI()
+
-        : Variable("REQUEST_URI") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRequestURI.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/request_uri_raw.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class RequestURIRaw : public Variable {
+
- public:
+DEFINE_VARIABLE(RequestURIRaw, REQUEST_URI_RAW, m_variableRequestURIRaw)
-    RequestURIRaw()
+
-        : Variable("REQUEST_URI_RAW") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableRequestURIRaw.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/resource.h

@@ -65,11 +65,10 @@ class Resource_NoDictElement : public Variable {
 };
 
 
-class Resource_DictElementRegexp : public Variable {
+class Resource_DictElementRegexp : public VariableRegex {
  public:
     explicit Resource_DictElementRegexp(std::string dictElement)
-        : Variable("RESOURCE:regex(" + dictElement + ")"),
+        : VariableRegex("RESOURCE:", dictElement),
-        m_r(dictElement),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *t,
@@ -80,7 +79,6 @@ class Resource_DictElementRegexp : public Variable {
             t->m_rules->m_secWebAppId.m_value, l, m_keyExclusion);
     }
 
-    Utils::Regex m_r;
     std::string m_dictElement;
 };
 

src/variables/response_body.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ResponseBody : public Variable {
+
- public:
+DEFINE_VARIABLE(ResponseBody, RESPONSE_BODY, m_variableResponseBody)
-    ResponseBody()
+
-        : Variable("RESPONSE_BODY") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableResponseBody.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/response_content_length.h

@@ -29,16 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ResponseContentLength : public Variable {
+
- public:
+DEFINE_VARIABLE(ResponseContentLength, RESPONSE_CONTENT_LENGTH,
-    ResponseContentLength()
+    m_variableResponseContentLength)
-        : Variable("RESPONSE_CONTENT_LENGTH") { }
+
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableResponseContentLength.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/response_content_type.h

@@ -29,16 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ResponseContentType : public Variable {
+
- public:
+DEFINE_VARIABLE(ResponseContentType, RESPONSE_CONTENT_TYPE,
-    ResponseContentType()
+    m_variableResponseContentType)
-        : Variable("RESPONSE_CONTENT_TYPE") { }
+
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableResponseContentType.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/response_headers.h

@@ -29,51 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ResponseHeaders_DictElement : public Variable {
- public:
-    explicit ResponseHeaders_DictElement(std::string dictElement)
-        : Variable("RESPONSE_HEADERS" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(ResponseHeaders, RESPONSE_HEADERS,
-        Rule *rule,
+    m_variableResponseHeaders)
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableResponseHeaders.resolve(m_dictElement, l);
-    }
-
-    std::string m_dictElement;
-};
-
-
-class ResponseHeaders_NoDictElement : public Variable {
- public:
-    ResponseHeaders_NoDictElement()
-        : Variable("RESPONSE_HEADERS") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableResponseHeaders.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class ResponseHeaders_DictElementRegexp : public Variable {
- public:
-    explicit ResponseHeaders_DictElementRegexp(std::string dictElement)
-        : Variable("RESPONSE_HEADERS"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableResponseHeaders.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 
 }  // namespace Variables

src/variables/response_headers_names.h

@@ -29,49 +29,10 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ResponseHeadersNames_DictElement : public Variable {
- public:
-    explicit ResponseHeadersNames_DictElement(std::string dictElement)
-        : Variable("RESPONSE_HEADERS_NAMES" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(ResponseHeadersNames, RESPONSE_HEADERS_NAMES,
-        Rule *rule,
+    m_variableResponseHeadersNames)
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableResponseHeadersNames.resolve(m_dictElement, l);
-    }
 
-    std::string m_dictElement;
-};
-
-class ResponseHeadersNames_NoDictElement : public Variable {
- public:
-    ResponseHeadersNames_NoDictElement()
-        : Variable("RESPONSE_HEADERS_NAMES") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableResponseHeadersNames.resolve(l, m_keyExclusion);
-    }
-};
-
-class ResponseHeadersNames_DictElementRegexp : public Variable {
- public:
-    explicit ResponseHeadersNames_DictElementRegexp(std::string dictElement)
-        : Variable("RESPONSE_HEADERS_NAMES"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableResponseHeadersNames.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/response_protocol.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ResponseProtocol : public Variable {
+
- public:
+DEFINE_VARIABLE(ResponseProtocol, RESPONSE_PROTOCOL, m_variableResponseProtocol)
-    ResponseProtocol()
+
-        : Variable("RESPONSE_PROTOCOL") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableResponseProtocol.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/response_status.h

@@ -29,16 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ResponseStatus : public Variable {
+
- public:
+DEFINE_VARIABLE(ResponseStatus, RESPONSE_STATUS, m_variableResponseStatus)
-    ResponseStatus()
+
-        : Variable("RESPONSE_STATUS") { }
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableResponseStatus.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/rule.h

@@ -27,51 +27,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class Rule_DictElement : public Variable {
- public:
-    explicit Rule_DictElement(std::string dictElement)
-        : Variable("RULE" + std::string(":") +
-            std::string(dictElement)),
-        m_dictElement(dictElement) { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE_DICT(Rule, RULE, m_variableRule)
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRule.resolve(m_dictElement, l);
-    }
 
-    std::string m_dictElement;
-};
-
-
-class Rule_NoDictElement : public Variable {
- public:
-    Rule_NoDictElement()
-        : Variable("RULE") { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRule.resolve(l, m_keyExclusion);
-    }
-};
-
-
-class Rule_DictElementRegexp : public Variable {
- public:
-    explicit Rule_DictElementRegexp(std::string dictElement)
-        : Variable("RULE"),
-        m_r(dictElement) { }
-
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) override {
-        transaction->m_variableRule.resolveRegularExpression(
-            &m_r, l, m_keyExclusion);
-    }
-
-    Utils::Regex m_r;
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/server_addr.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ServerAddr : public Variable {
- public:
-    ServerAddr()
-        : Variable("SERVER_ADDR") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(ServerAddr, SERVER_ADDR, m_variableServerAddr)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableServerAddr.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/server_name.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ServerName : public Variable {
- public:
-    ServerName()
-        : Variable("SERVER_NAME") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(ServerName, SERVER_NAME, m_variableServerName)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableServerName.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/server_port.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class ServerPort : public Variable {
- public:
-    ServerPort()
-        : Variable("SERVER_PORT") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(ServerPort, SERVER_PORT, m_variableServerPort)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableServerPort.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/session.h

@@ -65,11 +65,10 @@ class Session_NoDictElement : public Variable {
 };
 
 
-class Session_DictElementRegexp : public Variable {
+class Session_DictElementRegexp : public VariableRegex {
  public:
     explicit Session_DictElementRegexp(std::string dictElement)
-        : Variable("SESSION:regex(" + dictElement + ")"),
+        : VariableRegex("SESSION", dictElement),
-        m_r(dictElement),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *t,
@@ -80,7 +79,6 @@ class Session_DictElementRegexp : public Variable {
             t->m_rules->m_secWebAppId.m_value, l, m_keyExclusion);
     }
 
-    Utils::Regex m_r;
     std::string m_dictElement;
 };
 

src/variables/session_id.h

@@ -29,17 +29,8 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class SessionID : public Variable {
+DEFINE_VARIABLE(SessionID, SESSIONID, m_variableSessionID)
- public:
-    SessionID()
-        : Variable("SESSIONID") { }
 
-    void evaluate(Transaction *transaction,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableSessionID.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/status.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class Status : public Variable {
- public:
-    Status()
-        : Variable("STATUS") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(Status, STATUS, m_variableResponseStatus)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableResponseStatus.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/tx.h

@@ -63,11 +63,10 @@ class Tx_NoDictElement : public Variable {
 };
 
 
-class Tx_DictElementRegexp : public Variable {
+class Tx_DictElementRegexp : public VariableRegex {
  public:
     explicit Tx_DictElementRegexp(std::string dictElement)
-        : Variable("TX:regex(" + dictElement + ")"),
+        : VariableRegex("TX", dictElement),
-        m_r(dictElement),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *t,
@@ -77,7 +76,6 @@ class Tx_DictElementRegexp : public Variable {
             m_dictElement, l, m_keyExclusion);
     }
 
-    Utils::Regex m_r;
     std::string m_dictElement;
 };
 

src/variables/unique_id.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class UniqueID : public Variable {
- public:
-    UniqueID()
-        : Variable("UNIQUEID") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(UniqueID, UNIQUEID, m_variableUniqueID)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableUniqueID.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/url_encoded_error.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class UrlEncodedError : public Variable {
- public:
-    UrlEncodedError()
-        : Variable("URLENCODED_ERROR") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(UrlEncodedError, URLENCODED_ERROR, m_variableUrlEncodedError)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableUrlEncodedError.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/user.h

@@ -65,11 +65,10 @@ class User_NoDictElement : public Variable {
 };
 
 
-class User_DictElementRegexp : public Variable {
+class User_DictElementRegexp : public VariableRegex {
  public:
     explicit User_DictElementRegexp(std::string dictElement)
-        : Variable("USER:regex(" + dictElement + ")"),
+        : VariableRegex("USER", dictElement),
-        m_r(dictElement),
         m_dictElement(dictElement) { }
 
     void evaluate(Transaction *t,
@@ -80,7 +79,6 @@ class User_DictElementRegexp : public Variable {
             t->m_rules->m_secWebAppId.m_value, l, m_keyExclusion);
     }
 
-    Utils::Regex m_r;
     std::string m_dictElement;
 };
 

src/variables/user_id.h

@@ -29,17 +29,9 @@ namespace modsecurity {
 class Transaction;
 namespace Variables {
 
-class UserID : public Variable {
- public:
-    UserID()
-        : Variable("USERID") { }
 
-    void evaluate(Transaction *transaction,
+DEFINE_VARIABLE(UserID, USERID, m_variableUserID)
-        Rule *rule,
+
-        std::vector<const VariableValue *> *l) {
-        transaction->m_variableUserID.evaluate(l);
-    }
-};
 
 }  // namespace Variables
 }  // namespace modsecurity

src/variables/variable.cc

@@ -30,10 +30,7 @@ namespace Variables {
 
 Variable::Variable(std::string name)
     : m_name(name),
-    m_collectionName(""),
+    m_collectionName("") {
-    m_isExclusion(false),
-    m_isCount(false),
-    m_regex("") {
     size_t a = m_name.find(":");
     if (a == std::string::npos) {
         a = m_name.find(".");
@@ -51,36 +48,50 @@ Variable::Variable(std::string name)
 }
 
 
+Variable::Variable(Variable *var) :
+    m_name(var->m_name),
+    m_collectionName(var->m_collectionName),
+    m_fullName(var->m_fullName) { }
 
 
+void Variable::addsKeyExclusion(Variable *v) {
+    std::unique_ptr<KeyExclusion> r;
+    VariableModificatorExclusion *ve = \
+        dynamic_cast<VariableModificatorExclusion *>(v);
+    VariableRegex *vr;
 
-std::string Variable::to_s(
+    if (!ve) {
-    std::vector<Variable *> *variables) {
+        return;
-    std::string ret;
+    }
-    std::string except("");
+
-    for (int i = 0; i < variables->size() ; i++) {
+    vr = dynamic_cast<VariableRegex *>(ve->m_base.get());
-        VariableModificatorExclusion *e =
+
-            dynamic_cast<VariableModificatorExclusion *>(variables->at(i));
+    if (vr == NULL) {
-        if (e != NULL) {
+        r.reset(new KeyExclusionString(v->m_name));
-            if (except.empty()) {
-                except = except + *variables->at(i)->m_fullName.get();
     } else {
-                except = except + "|" + *variables->at(i)->m_fullName.get();
+        r.reset(new KeyExclusionRegex(vr->m_regex));
-            }
-            continue;
     }
 
-        if (i == 0) {
+    m_keyExclusion.push_back(std::move(r));
-            ret = ret + *variables->at(i)->m_fullName.get();
+}
+
+
+std::string operator+(std::string a, Variable *v) {
+    return *v->m_fullName.get();
+}
+
+
+std::string operator+(std::string a, Variables *v) {
+    std::string test;
+    for (auto &b : *v) {
+        if (test.empty()) {
+            test = std::string("") + b;
         } else {
-            ret = ret + "|" + *variables->at(i)->m_fullName.get();
+            test = test + "|" + b;
         }
     }
 
-    if (except.empty() == false) {
+    return a + test;
-        ret = ret + ", except for: " + except;
-    }
-    return ret;
 }
 
 

src/variables/variable.h

@@ -19,6 +19,7 @@
 #include <string>
 #include <utility>
 #include <vector>
+#include <deque>
 
 #include "modsecurity/transaction.h"
 #include "modsecurity/rule.h"
@@ -29,23 +30,96 @@
 #ifndef SRC_VARIABLES_VARIABLE_H_
 #define SRC_VARIABLES_VARIABLE_H_
 
+#define DEFINE_VARIABLE(n, N, e) \
+    VAR_DIRECT(n, N, e)
+
+#define DEFINE_VARIABLE_DICT(n, N, e) \
+    VAR_WITH_DICT_ELEMENT(n, N, e) \
+    \
+    VAR_WITHOUT_DICT_ELEMENT(n, N, e) \
+    \
+    VAR_WITH_REGEX(n, N, e) \
+
+
+
+#define VAR_WITH_REGEX(n, N, e) \
+class n ## _DictElementRegexp : public VariableRegex { \
+ public: \
+    explicit n ## _DictElementRegexp(std::string regex) \
+        : VariableRegex(#N, regex) { } \
+\
+    void evaluate(Transaction *transaction, \
+        Rule *rule, \
+        std::vector<const VariableValue *> *l) override { \
+        transaction-> e .resolveRegularExpression(&m_r, l, \
+            m_keyExclusion); \
+    } \
+};
+
+
+#define VAR_WITH_DICT_ELEMENT(n, N, e) \
+class n ## _DictElement : public VariableDictElement { \
+ public: \
+    explicit n ## _DictElement(std::string dictElement) \
+        : VariableDictElement(#N, dictElement) { } \
+\
+    void evaluate(Transaction *transaction, \
+        Rule *rule, \
+        std::vector<const VariableValue *> *l) override { \
+        transaction-> e .resolve(m_dictElement, l); \
+    } \
+};
+
+
+#define VAR_WITHOUT_DICT_ELEMENT(n, N, e) \
+class n ## _NoDictElement : public Variable { \
+ public: \
+    explicit n ## _NoDictElement() \
+        : Variable(#N) { } \
+\
+    void evaluate(Transaction *transaction, \
+        Rule *rule, \
+        std::vector<const VariableValue *> *l) override { \
+        transaction-> e .resolve(l, m_keyExclusion); \
+    } \
+};
+
+
+#define VAR_DIRECT(n, N, e) \
+class n : public Variable { \
+ public: \
+    n() \
+        : Variable(#N) { } \
+    \
+    void evaluate(Transaction *transaction, \
+        Rule *rule, \
+        std::vector<const VariableValue *> *l) override { \
+        transaction-> e .evaluate(l); \
+    } \
+};
+
+
 namespace modsecurity {
 
 class Transaction;
 namespace Variables {
 
-
 class KeyExclusion {
  public:
     virtual bool match(std::string &a) = 0;
+    virtual ~KeyExclusion() { }
 };
 
 
 // FIXME: use pre built regex.
 class KeyExclusionRegex : public KeyExclusion {
  public:
-    KeyExclusionRegex(std::string &re)
+    explicit KeyExclusionRegex(Utils::Regex re)
-        : m_re(re) { };
+        : m_re(re.pattern) { }
+    explicit KeyExclusionRegex(std::string re)
+        : m_re(re) { }
+
+    ~KeyExclusionRegex() override { }
 
     bool match(std::string &a) override {
         return m_re.searchAll(a).size() > 0;
@@ -58,12 +132,15 @@ class KeyExclusionRegex : public KeyExclusion {
 class KeyExclusionString : public KeyExclusion {
  public:
     KeyExclusionString(std::string &a)
-        : m_key(utils::string::toupper(a)) { };
+        : m_key(utils::string::toupper(a)) { }
+
+    ~KeyExclusionString() override { }
 
     bool match(std::string &a) override {
-    return a.size() == m_key.size() && std::equal(a.begin(), a.end(), m_key.begin(),
+        return a.size() == m_key.size() && std::equal(a.begin(), a.end(),
+            m_key.begin(),
             [](char aa, char bb) {
-            return (char) toupper(aa) == (char) bb;
+                return static_cast<char>(toupper(aa)) == static_cast<char>(bb);
             });
     }
 
@@ -84,17 +161,8 @@ class KeyExclusions : public std::deque<std::unique_ptr<KeyExclusion>> {
 };
 
 
-class Variable {
+class VariableMonkeyResolution {
  public:
-    explicit Variable(std::string _name);
-    virtual ~Variable() { }
-
-    virtual void evaluate(Transaction *t,
-        Rule *rule,
-        std::vector<const VariableValue *> *l) = 0;
-
-    static std::string to_s(std::vector<Variable *> *variables);
-
     static inline bool comp(const std::string &a, const std::string &b) {
         return a.size() == b.size()
              && std::equal(a.begin(), a.end(), b.begin(),
@@ -103,34 +171,6 @@ class Variable {
         });
     }
 
-
-    bool inline belongsToCollection(Variable *var) {
-        return m_collectionName.size() == var->m_collectionName.size()
-             && std::equal(m_collectionName.begin(), m_collectionName.end(), var->m_collectionName.begin(),
-            [](char aa, char bb) {
-            return toupper(aa) == bb;
-        });
-    }
-
-
-    void inline addsKeyExclusion(Variable *v) {
-        if (v->m_regex.empty()) {
-            std::unique_ptr<KeyExclusion> r(new KeyExclusionString(v->m_name));
-            m_keyExclusion.push_back(std::move(r));
-        } else {
-            std::unique_ptr<KeyExclusion> r(new KeyExclusionRegex(v->m_regex));
-            m_keyExclusion.push_back(std::move(r));
-        }
-    }
-
-
-    bool operator==(const Variable& b) {
-        return m_collectionName == b.m_collectionName &&
-            m_name == b.m_name &&
-            *m_fullName == *b.m_fullName;
-    }
-
-
     static void stringMatchResolveMulti(Transaction *t,
         const std::string &variable,
         std::vector<const VariableValue *> *l) {
@@ -498,44 +538,97 @@ class Variable {
         }
         return std::string(*vv.get());
     }
+};
+
+
+class Variable : public VariableMonkeyResolution {
+ public:
+    explicit Variable(std::string _name);
+    explicit Variable(Variable *_name);
+    virtual ~Variable() { }
+
+
+    virtual void evaluate(Transaction *t,
+        Rule *rule,
+        std::vector<const VariableValue *> *l) = 0;
+
+
+    bool inline belongsToCollection(Variable *var) {
+        return m_collectionName.size() == var->m_collectionName.size()
+             && std::equal(m_collectionName.begin(), m_collectionName.end(),
+                           var->m_collectionName.begin(),
+            [](char aa, char bb) {
+            return toupper(aa) == bb;
+        });
+    }
+
+
+    void addsKeyExclusion(Variable *v);
+
+
+    bool operator==(const Variable& b) {
+        return m_collectionName == b.m_collectionName &&
+            m_name == b.m_name &&
+            *m_fullName == *b.m_fullName;
+    }
+
+
+    std::string& operator+=(const char * p) {  return m_name; }
+
 
     std::string m_name;
     std::string m_collectionName;
     std::shared_ptr<std::string> m_fullName;
-    std::string m_regex;
-
     KeyExclusions m_keyExclusion;
+};
 
-    bool m_isExclusion;
+class VariableDictElement : public Variable {
-    bool m_isCount;
+ public:
+    VariableDictElement(std::string name, std::string dict_element)
+        :  m_dictElement(dict_element), Variable(name + ":" + dict_element) { }
+
+    std::string m_dictElement;
+};
+
+
+class VariableRegex : public Variable {
+ public:
+    VariableRegex(std::string name, std::string regex)
+        :  m_r(regex),
+        m_regex(regex),
+        Variable(name + ":" + "regex(" + regex + ")") { }
+
+    // FIXME: no need for that.
+    std::string m_regex;
+    Utils::Regex m_r;
+};
+
+class Variables : public std::vector<Variable *> {
+ public:
 };
 
 
 class VariableModificatorExclusion : public Variable {
  public:
     explicit VariableModificatorExclusion(std::unique_ptr<Variable> var)
-        : Variable(*var->m_fullName.get()),
+        : m_base(std::move(var)), Variable(var.get()) { }
-        m_var(std::move(var)) {
-            m_isExclusion = true;
-            m_regex = m_var->m_regex;
-        }
 
     void evaluate(Transaction *t,
         Rule *rule,
         std::vector<const VariableValue *> *l) {
-        m_var->evaluate(t, rule, l);
+        m_base->evaluate(t, rule, l);
     }
 
-    std::unique_ptr<Variable> m_var;
+    std::unique_ptr<Variable> m_base;
 };
 
 
 class VariableModificatorCount : public Variable {
  public:
     explicit VariableModificatorCount(std::unique_ptr<Variable> var)
-        : Variable(*var->m_fullName.get()),
+        : Variable(var.get()),
-        m_var(std::move(var)) {
+          m_base(nullptr) {
-            m_isCount = true;
+            m_base.reset(var.release());
         }
 
     void evaluate(Transaction *t,
@@ -545,7 +638,8 @@ class VariableModificatorCount : public Variable {
         VariableValue *val = NULL;
         int count = 0;
 
-        m_var->evaluate(t, rule, &reslIn);
+        m_base->evaluate(t, rule, &reslIn);
+
         for (const VariableValue *a : reslIn) {
             count++;
             delete a;
@@ -554,16 +648,21 @@ class VariableModificatorCount : public Variable {
         reslIn.clear();
 
         std::string *res = new std::string(std::to_string(count));
-        val = new VariableValue(m_var->m_fullName, res);
+        val = new VariableValue(m_fullName, res);
         delete res;
 
         l->push_back(val);
         return;
     }
 
-    std::unique_ptr<Variable> m_var;
+    std::unique_ptr<Variable> m_base;
 };
 
+
+std::string operator+(std::string a, modsecurity::Variables::Variable *v);
+std::string operator+(std::string a, modsecurity::Variables::Variables *v);
+
+
 }  // namespace Variables
 }  // namespace modsecurity
 

test/optimization/optimization.cc

@@ -94,7 +94,7 @@ int main(int argc, char **argv) {
                 key = op;
             }
             if (z->m_variables != NULL) {
-                std::string var = Variable::to_s(z->m_variables);
+                std::string var = std::string("") + z->m_variables;
                 if (variables.count(var) > 0) {
                     variables[var] = 1 + variables[var];
                 } else {
@@ -119,7 +119,7 @@ int main(int argc, char **argv) {
         for (auto &z : operators) {
             auto &s = z.second;
             std::cout << "   " << std::left << std::setw(20) << z.first;
-            std::cout << std::right << std::setw(4) << std::to_string(s);
+            std::cout << std::right << std::setw(4) << s;
             std::cout << std::endl;
         }
 
@@ -127,14 +127,14 @@ int main(int argc, char **argv) {
         for (auto &z : variables) {
             auto &s = z.second;
             std::cout << "   " << std::left << std::setw(20) << z.first;
-            std::cout << std::right << std::setw(4) << std::to_string(s);
+            std::cout << std::right << std::setw(4) << s;
             std::cout << std::endl;
         }
         std::cout << " Operators applied to variables" << std::endl;
         for (auto &z : op2var) {
             auto &s = z.second;
             std::cout << "   " << std::left << std::setw(40) << z.first;
-            std::cout << std::right << std::setw(4) << std::to_string(s);
+            std::cout << std::right << std::setw(4) << s;
             std::cout << std::endl;
         }