Merge pull request #399 from bshifter/filterx-regexp-search

Filterx regexp_search rework

Author: alltilla

lib/filterx/expr-regexp.c

@@ -41,7 +41,14 @@
   FILTERX_FUNC_REGEXP_SUBST_FLAG_NEWLINE_NAME"=(boolean)" \
   FILTERX_FUNC_REGEXP_SUBST_FLAG_GROUPS_NAME"=(boolean))" \
 
-#define FILTERX_FUNC_REGEXP_SEARCH_USAGE "Usage: regexp_search(string, pattern)"
+DEFINE_FUNC_FLAG_NAMES(FilterXRegexpSearchFlags,
+                       FILTERX_REGEXP_SEARCH_KEEP_GRP_ZERO_NAME,
+                       FILTERX_REGEXP_SEARCH_LIST_MODE_NAME
+                      );
+
+#define FILTERX_FUNC_REGEXP_SEARCH_USAGE "Usage: regexp_search(string, pattern, " \
+FILTERX_REGEXP_SEARCH_KEEP_GRP_ZERO_NAME"=(boolean), "\
+FILTERX_REGEXP_SEARCH_LIST_MODE_NAME"=(boolean))"
 
 typedef struct FilterXReMatchState_
 {
@@ -50,6 +57,7 @@ typedef struct FilterXReMatchState_
   const gchar *lhs_str;
   gsize lhs_str_len;
   gint rc;
+  FLAGSET flags;
 } FilterXReMatchState;
 
 static void
@@ -164,14 +172,6 @@ _match(FilterXExpr *lhs_expr, pcre2_code_8 *pattern, FilterXReMatchState *state)
   return FALSE;
 }
 
-static gboolean
-_has_named_capture_groups(pcre2_code_8 *pattern)
-{
-  guint32 namecount = 0;
-  pcre2_pattern_info(pattern, PCRE2_INFO_NAMECOUNT, &namecount);
-  return namecount > 0;
-}
-
 static gboolean
 _store_matches_to_list(pcre2_code_8 *pattern, const FilterXReMatchState *state, FilterXObject *fillable)
 {
@@ -180,6 +180,8 @@ _store_matches_to_list(pcre2_code_8 *pattern, const FilterXReMatchState *state,
 
   for (gint i = 0; i < num_matches; i++)
     {
+      if (num_matches > 1 && i==0 && !check_flag(state->flags, FILTERX_REGEXP_SEARCH_KEEP_GRP_ZERO))
+        continue;
       gint begin_index = matches[2 * i];
       gint end_index = matches[2 * i + 1];
       if (begin_index < 0 || end_index < 0)
@@ -209,6 +211,9 @@ _store_matches_to_dict(pcre2_code_8 *pattern, const FilterXReMatchState *state,
   /* First store all matches with string formatted indexes as keys. */
   for (guint32 i = 0; i < num_matches; i++)
     {
+      if (num_matches > 1 && i==0 && !check_flag(state->flags, FILTERX_REGEXP_SEARCH_KEEP_GRP_ZERO))
+        continue;
+
       PCRE2_SIZE begin_index = matches[2 * i];
       PCRE2_SIZE end_index = matches[2 * i + 1];
       if (begin_index < 0 || end_index < 0)
@@ -385,6 +390,7 @@ typedef struct FilterXExprRegexpSearchGenerator_
   FilterXGeneratorFunction super;
   FilterXExpr *lhs;
   pcre2_code_8 *pattern;
+  FLAGSET flags;
 } FilterXExprRegexpSearchGenerator;
 
 static gboolean
@@ -395,6 +401,7 @@ _regexp_search_generator_generate(FilterXExprGenerator *s, FilterXObject *fillab
   gboolean result;
   FilterXReMatchState state;
   _state_init(&state);
+  state.flags = self->flags;
 
   gboolean matched = _match(self->lhs, self->pattern, &state);
   if (!matched)
@@ -422,10 +429,10 @@ _regexp_search_generator_create_container(FilterXExprGenerator *s, FilterXExpr *
 {
   FilterXExprRegexpSearchGenerator *self = (FilterXExprRegexpSearchGenerator *) s;
 
-  if (_has_named_capture_groups(self->pattern))
-    return filterx_generator_create_dict_container(s, fillable_parent);
+  if (check_flag(self->flags, FILTERX_REGEXP_SEARCH_LIST_MODE))
+    return filterx_generator_create_list_container(s, fillable_parent);
 
-  return filterx_generator_create_list_container(s, fillable_parent);
+  return filterx_generator_create_dict_container(s, fillable_parent);
 }
 
 static gboolean
@@ -459,6 +466,29 @@ _regexp_search_generator_free(FilterXExpr *s)
   filterx_generator_function_free_method(&self->super);
 }
 
+static gboolean
+_extract_optional_arg_flag(FilterXExprRegexpSearchGenerator *self, FilterXRegexpSearchFlags flag,
+                           FilterXFunctionArgs *args, GError **error)
+{
+  gboolean exists, eval_error;
+  g_assert(flag < FilterXRegexpSearchFlags_MAX);
+  const gchar *arg_name = FilterXRegexpSearchFlags_NAMES[flag];
+  gboolean value = filterx_function_args_get_named_literal_boolean(args, arg_name, &exists, &eval_error);
+  if (!exists)
+    return TRUE;
+
+  if (eval_error)
+    {
+      g_set_error(error, FILTERX_FUNCTION_ERROR, FILTERX_FUNCTION_ERROR_CTOR_FAIL,
+                  "%s argument must be boolean literal. " FILTERX_FUNC_REGEXP_SEARCH_USAGE, arg_name);
+      return FALSE;
+    }
+
+  set_flag(&self->flags, flag, value);
+
+  return TRUE;
+}
+
 static gboolean
 _extract_search_args(FilterXExprRegexpSearchGenerator *self, FilterXFunctionArgs *args, GError **error)
 {
@@ -504,6 +534,12 @@ filterx_generator_function_regexp_search_new(FilterXFunctionArgs *args, GError *
   self->super.super.super.free_fn = _regexp_search_generator_free;
   self->super.super.create_container = _regexp_search_generator_create_container;
 
+  if (!_extract_optional_arg_flag(self, FILTERX_REGEXP_SEARCH_KEEP_GRP_ZERO, args, error))
+    goto error;
+
+  if (!_extract_optional_arg_flag(self, FILTERX_REGEXP_SEARCH_LIST_MODE, args, error))
+    goto error;
+
   if (!_extract_search_args(self, args, error) ||
       !filterx_function_args_check(args, error))
     goto error;

lib/filterx/expr-regexp.h

@@ -27,6 +27,7 @@
 #include "filterx/filterx-expr.h"
 #include "filterx/expr-generator.h"
 #include "filterx/expr-function.h"
+#include "filterx/func-flags.h"
 
 #define FILTERX_FUNC_REGEXP_SUBST_FLAG_JIT_NAME "jit"
 #define FILTERX_FUNC_REGEXP_SUBST_FLAG_GLOBAL_NAME "global"
@@ -35,6 +36,16 @@
 #define FILTERX_FUNC_REGEXP_SUBST_FLAG_NEWLINE_NAME "newline"
 #define FILTERX_FUNC_REGEXP_SUBST_FLAG_GROUPS_NAME "groups"
 
+DEFINE_FUNC_FLAGS(FilterXRegexpSearchFlags,
+                  FILTERX_REGEXP_SEARCH_KEEP_GRP_ZERO,
+                  FILTERX_REGEXP_SEARCH_LIST_MODE
+                 );
+
+#define FILTERX_REGEXP_SEARCH_KEEP_GRP_ZERO_NAME "keep_zero"
+#define FILTERX_REGEXP_SEARCH_LIST_MODE_NAME "list_mode"
+
+extern const char *FilterXRegexpSearchFlags_NAMES[];
+
 typedef struct FilterXFuncRegexpSubstOpts_
 {
   gboolean global;

lib/filterx/func-flags.h

@@ -27,6 +27,8 @@
 
 #include "syslog-ng.h"
 
+#define FLAGSET guint64
+
 #define MAX_ENUMS 64
 
 #define STATIC_ASSERT(COND) G_STATIC_ASSERT(COND)
@@ -35,14 +37,19 @@
     typedef enum { __VA_ARGS__, ENUM_NAME##_MAX} ENUM_NAME; \
     STATIC_ASSERT(ENUM_NAME##_MAX <= MAX_ENUMS) \
 
-#define FUNC_FLAGS_ITER(ENUM_NAME, CODE) for (guint64 enum_elt = 0; enum_elt < ENUM_NAME##_MAX; enum_elt++) { CODE; };
+#define DEFINE_FUNC_FLAG_NAMES(ENUM_NAME, ...)  \
+    const char *ENUM_NAME##_NAMES[] = {  \
+      __VA_ARGS__                               \
+    };
+
+#define FUNC_FLAGS_ITER(ENUM_NAME, CODE) for (FLAGSET enum_elt = 0; enum_elt < ENUM_NAME##_MAX; enum_elt++) { CODE; };
 
 #define FLAG_VAL(ID) (1 << ID)
 
 #define ALL_FLAG_SET(ENUM_NAME) (FLAG_VAL(ENUM_NAME##_MAX) - 1)
 
 static inline void
-set_flag(guint64 *flags, guint64 flag, gboolean val)
+set_flag(FLAGSET *flags, FLAGSET flag, gboolean val)
 {
   if (val)
     {
@@ -55,19 +62,19 @@ set_flag(guint64 *flags, guint64 flag, gboolean val)
 }
 
 static inline gboolean
-check_flag(guint64 flags, guint64 flag)
+check_flag(FLAGSET flags, FLAGSET flag)
 {
   return (flags & FLAG_VAL(flag)) != 0;
 }
 
 static inline void
-reset_flags(guint64 *flags, guint64 val)
+reset_flags(FLAGSET *flags, FLAGSET val)
 {
   *flags = val;
 }
 
 static inline gboolean
-toggle_flag(guint64 *flags, guint64 flag)
+toggle_flag(FLAGSET *flags, FLAGSET flag)
 {
   *flags ^= FLAG_VAL(flag);
   return (*flags & FLAG_VAL(flag)) != 0;