Add new option weechat.look.highlight_regex and function string_has_highlight_regex in plugin API (task #10321)

src/CMakeLists.txt

@@ -62,6 +62,9 @@ CHECK_FUNCTION_EXISTS(strpbrk HAVE_STRPBRK)
 CHECK_FUNCTION_EXISTS(strrchr HAVE_STRRCHR)
 CHECK_FUNCTION_EXISTS(strstr HAVE_STRSTR)
 
+CHECK_INCLUDE_FILES("regex.h" HAVE_REGEX_H)
+CHECK_FUNCTION_EXISTS(regexec HAVE_REGEXEC)
+
 
 #needs to be splitted in subdirectories
 # FIXME: weechat_gui_common MUST be the first lib in the list

src/core/wee-config.c

@@ -35,6 +35,7 @@
 #include <time.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <regex.h>
 
 #include "weechat.h"
 #include "wee-config.h"
@@ -83,6 +84,7 @@ struct t_config_option *config_look_confirm_quit;
 struct t_config_option *config_look_day_change;
 struct t_config_option *config_look_day_change_time_format;
 struct t_config_option *config_look_highlight;
+struct t_config_option *config_look_highlight_regex;
 struct t_config_option *config_look_hline_char;
 struct t_config_option *config_look_hotlist_names_count;
 struct t_config_option *config_look_hotlist_names_length;
@@ -200,6 +202,7 @@ struct t_config_option *config_plugin_save_config_on_unload;
 
 struct t_hook *config_day_change_timer = NULL;
 int config_day_change_old_day = -1;
+regex_t *config_highlight_regex = NULL;
 
 
 /*
@@ -283,6 +286,41 @@ config_change_buffer_time_format (void *data, struct t_config_option *option)
         gui_window_ask_refresh (1);
 }
 
+/*
+ * config_change_highlight_regex: called when highlight_regex changes
+ */
+
+void
+config_change_highlight_regex (void *data, struct t_config_option *option)
+{
+    /* make C compiler happy */
+    (void) data;
+    (void) option;
+    
+    if (config_highlight_regex)
+    {
+        regfree (config_highlight_regex);
+        free (config_highlight_regex);
+        config_highlight_regex = NULL;
+    }
+    
+    if (CONFIG_STRING(config_look_highlight_regex)
+        && CONFIG_STRING(config_look_highlight_regex)[0])
+    {
+        config_highlight_regex = malloc (sizeof (*config_highlight_regex));
+        if (config_highlight_regex)
+        {
+            if (regcomp (config_highlight_regex,
+                         CONFIG_STRING(config_look_highlight_regex),
+                         REG_EXTENDED) != 0)
+            {
+                free (config_highlight_regex);
+                config_highlight_regex = NULL;
+            }
+        }
+    }
+}
+
 /*
  * config_change_hotlist: called when hotlist changes
  */
@@ -1334,6 +1372,14 @@ config_weechat_init_options ()
         N_("comma separated list of words to highlight (case insensitive "
            "comparison, words may begin or end with \"*\" for partial match)"),
         NULL, 0, 0, "", NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL);
+    config_look_highlight_regex = config_file_new_option (
+        weechat_config_file, ptr_section,
+        "highlight_regex", "string",
+        N_("regular expression used to check if a message has highlight or not, "
+           "at least one match in string must be surrounded by word chars "
+            "(alphanumeric, \"-\", \"_\" or \"|\"), regular expression is case "
+           "sensitive, example: \"FlashCode|flashy\""),
+        NULL, 0, 0, "", NULL, 0, NULL, NULL, &config_change_highlight_regex, NULL, NULL, NULL);
     config_look_hline_char = config_file_new_option (
         weechat_config_file, ptr_section,
         "hline_char", "string",
@@ -2196,6 +2242,7 @@ config_weechat_init ()
                                               0,
                                               &config_day_change_timer_cb,
                                               NULL);
+        config_change_highlight_regex (NULL, NULL);
     }
     
     return rc;

src/core/wee-config.h

@@ -21,10 +21,11 @@
 #ifndef __WEECHAT_CONFIG_H
 #define __WEECHAT_CONFIG_H 1
 
-struct t_gui_buffer;
-
+#include <regex.h>
 #include "wee-config-file.h"
 
+struct t_gui_buffer;
+
 #define WEECHAT_CONFIG_NAME "weechat"
 
 enum t_config_look_nicklist
@@ -112,6 +113,7 @@ extern struct t_config_option *config_look_color_real_white;
 extern struct t_config_option *config_look_day_change;
 extern struct t_config_option *config_look_day_change_time_format;
 extern struct t_config_option *config_look_highlight;
+extern struct t_config_option *config_look_highlight_regex;
 extern struct t_config_option *config_look_hline_char;
 extern struct t_config_option *config_look_hotlist_names_count;
 extern struct t_config_option *config_look_hotlist_names_length;
@@ -215,6 +217,8 @@ extern struct t_config_option *config_plugin_extension;
 extern struct t_config_option *config_plugin_path;
 extern struct t_config_option *config_plugin_save_config_on_unload;
 
+extern regex_t *config_highlight_regex;
+
 
 extern struct t_config_option *config_weechat_debug_get (const char *plugin_name);
 extern int config_weechat_debug_set (const char *plugin_name,

src/core/wee-string.c

@@ -31,6 +31,7 @@
 #include <string.h>
 #include <ctype.h>
 #include <wctype.h>
+#include <regex.h>
 
 #if defined(__OpenBSD__)
 #include <utf8/wchar.h>
@@ -708,6 +709,76 @@ string_has_highlight (const char *string, const char *highlight_words)
     return 0;
 }
 
+/*
+ * string_has_highlight_regex_compiled: return 1 if string contains a highlight
+ *                                      using a regular expression (any match
+ *                                      in string must be surrounded by word
+ *                                      chars)
+ */
+
+int
+string_has_highlight_regex_compiled (const char *string, regex_t *regex)
+{
+    int rc, startswith, endswith;
+    regmatch_t regex_match;
+    const char *match_pre;
+    
+    if (!string || !regex)
+        return 0;
+    
+    while (string && string[0])
+    {
+        rc = regexec (regex, string,  1, &regex_match, 0);
+        if ((rc != 0) || (regex_match.rm_so < 0) || (regex_match.rm_eo < 0))
+            break;
+        
+        startswith = (regex_match.rm_so == 0);
+        if (!startswith)
+        {
+            match_pre = utf8_prev_char (string, string + regex_match.rm_so);
+            startswith = !string_is_word_char (match_pre);
+        }
+        endswith = 0;
+        if (startswith)
+        {
+            endswith = ((regex_match.rm_eo == (int)strlen (string))
+                        || !string_is_word_char (string + regex_match.rm_eo));
+        }
+        if (startswith && endswith)
+            return 1;
+        
+        string += regex_match.rm_eo;
+    }
+    
+    /* no highlight found */
+    return 0;
+}
+
+/*
+ * string_has_highlight_regex: return 1 if string contains a highlight
+ *                             using a regular expression (any match in string
+ *                             must be surrounded by word chars)
+ */
+
+int
+string_has_highlight_regex (const char *string, const char *regex)
+{
+    regex_t reg;
+    int rc;
+    
+    if (!string || !regex)
+        return 0;
+    
+    if (regcomp (&reg, regex, REG_EXTENDED) != 0)
+        return 0;
+    
+    rc = string_has_highlight_regex_compiled (string, &reg);
+    
+    regfree (&reg);
+    
+    return rc;
+}
+
 /*
  * string_mask_to_regex: convert a mask (string with only "*" as wildcard) to a
  *                       regex, paying attention to special chars in a regex

src/core/wee-string.h

@@ -20,6 +20,8 @@
 #ifndef __WEECHAT_STRING_H
 #define __WEECHAT_STRING_H 1
 
+#include <regex.h>
+
 extern char *string_strndup (const char *string, int length);
 extern void string_tolower (char *string);
 extern void string_toupper (char *string);
@@ -42,6 +44,9 @@ extern char *string_strip (const char *string, int left, int right,
 extern char *string_convert_hex_chars (const char *string);
 extern int string_has_highlight (const char *string,
                                  const char *highlight_words);
+extern int string_has_highlight_regex_compiled (const char *string,
+                                                regex_t *regex);
+extern int string_has_highlight_regex (const char *string, const char *regex);
 extern char *string_mask_to_regex (const char *mask);
 extern char **string_split (const char *string, const char *separators,
                             int keep_eol, int num_items_max, int *num_items);

src/gui/gui-line.c

@@ -474,6 +474,12 @@ gui_line_has_highlight (struct t_gui_line *line)
             free (highlight_words);
     }
     
+    if (!rc && config_highlight_regex)
+    {
+        rc = string_has_highlight_regex_compiled (msg_no_color,
+                                                  config_highlight_regex);
+    }
+    
     free (msg_no_color);
     
     return rc;

src/plugins/irc/CMakeLists.txt

@@ -45,9 +45,6 @@ irc-server.c irc-server.h
 irc-upgrade.c irc-upgrade.h)
 SET_TARGET_PROPERTIES(irc PROPERTIES PREFIX "")
 
-CHECK_INCLUDE_FILES("regex.h" HAVE_REGEX_H)
-CHECK_FUNCTION_EXISTS(regexec HAVE_REGEXEC)
-
 SET (LINK_LIBS)
 
 IF(GNUTLS_FOUND)

src/plugins/plugin.c

@@ -465,6 +465,7 @@ plugin_load (const char *filename)
         new_plugin->string_remove_quotes = &string_remove_quotes;
         new_plugin->string_strip = &string_strip;
         new_plugin->string_has_highlight = &string_has_highlight;
+        new_plugin->string_has_highlight_regex = &string_has_highlight_regex;
         new_plugin->string_mask_to_regex = &string_mask_to_regex;
         new_plugin->string_split = &string_split;
         new_plugin->string_free_split = &string_free_split;

src/plugins/scripts/lua/weechat-lua-api.c

@@ -422,6 +422,45 @@ weechat_lua_api_string_has_highlight (lua_State *L)
     LUA_RETURN_INT(value);
 }
 
+/*
+ * weechat_lua_api_string_has_highlight_regex: return 1 if string contains a
+ *                                             highlight (using regular
+ *                                             expression)
+ *                                             return 0 if no highlight is
+ *                                             found in string
+ */
+
+static int
+weechat_lua_api_string_has_highlight_regex (lua_State *L)
+{
+    const char *string, *regex;
+    int n, value;
+    
+    /* make C compiler happy */
+    (void) L;
+    
+    if (!lua_current_script || !lua_current_script->name)
+    {
+        WEECHAT_SCRIPT_MSG_NOT_INIT(LUA_CURRENT_SCRIPT_NAME, "string_has_highlight_regex");
+        LUA_RETURN_INT(0);
+    }
+    
+    n = lua_gettop (lua_current_interpreter);
+    
+    if (n < 2)
+    {
+        WEECHAT_SCRIPT_MSG_WRONG_ARGS(LUA_CURRENT_SCRIPT_NAME, "string_has_highlight_regex");
+        LUA_RETURN_INT(0);
+    }
+    
+    string = lua_tostring (lua_current_interpreter, -2);
+    regex = lua_tostring (lua_current_interpreter, -1);
+    
+    value = weechat_string_has_highlight_regex (string, regex);
+    
+    LUA_RETURN_INT(value);
+}
+
 /*
  * weechat_lua_api_string_mask_to_regex: convert a mask (string with only
  *                                       "*" as wildcard) to a regex, paying
@@ -7562,6 +7601,7 @@ const struct luaL_reg weechat_lua_api_funcs[] = {
     { "ngettext", &weechat_lua_api_ngettext },
     { "string_match", &weechat_lua_api_string_match },
     { "string_has_highlight", &weechat_lua_api_string_has_highlight },
+    { "string_has_highlight_regex", &weechat_lua_api_string_has_highlight_regex },
     { "string_mask_to_regex", &weechat_lua_api_string_mask_to_regex },
     { "string_remove_color", &weechat_lua_api_string_remove_color },
     { "string_is_command_char", &weechat_lua_api_string_is_command_char },

src/plugins/scripts/perl/weechat-perl-api.c

@@ -387,6 +387,39 @@ XS (XS_weechat_api_string_has_highlight)
     PERL_RETURN_INT(value);
 }
 
+/*
+ * weechat::string_has_highlight_regex: return 1 if string contains a highlight
+ *                                      (using regular expression)
+ *                                      return 0 if no highlight is found in
+ *                                      string
+ */
+
+XS (XS_weechat_api_string_has_highlight_regex)
+{
+    int value;
+    dXSARGS;
+    
+    /* make C compiler happy */
+    (void) cv;
+    
+    if (!perl_current_script || !perl_current_script->name)
+    {
+        WEECHAT_SCRIPT_MSG_NOT_INIT(PERL_CURRENT_SCRIPT_NAME, "string_has_highlight_regex");
+        PERL_RETURN_INT(0);
+    }
+    
+    if (items < 2)
+    {
+        WEECHAT_SCRIPT_MSG_WRONG_ARGS(PERL_CURRENT_SCRIPT_NAME, "string_has_highlight_regex");
+        PERL_RETURN_INT(0);
+    }
+    
+    value = weechat_string_has_highlight_regex (SvPV (ST (0), PL_na), /* string */
+                                                SvPV (ST (1), PL_na)); /* regex */
+    
+    PERL_RETURN_INT(value);
+}
+
 /*
  * weechat::string_mask_to_regex: convert a mask (string with only "*" as
  *                                wildcard) to a regex, paying attention to
@@ -6509,6 +6542,7 @@ weechat_perl_api_init (pTHX)
     newXS ("weechat::ngettext", XS_weechat_api_ngettext, "weechat");
     newXS ("weechat::string_match", XS_weechat_api_string_match, "weechat");
     newXS ("weechat::string_has_highlight", XS_weechat_api_string_has_highlight, "weechat");
+    newXS ("weechat::string_has_highlight_regex", XS_weechat_api_string_has_highlight_regex, "weechat");
     newXS ("weechat::string_mask_to_regex", XS_weechat_api_string_mask_to_regex, "weechat");
     newXS ("weechat::string_remove_color", XS_weechat_api_string_remove_color, "weechat");
     newXS ("weechat::string_is_command_char", XS_weechat_api_string_is_command_char, "weechat");

src/plugins/scripts/python/weechat-python-api.c

@@ -395,6 +395,43 @@ weechat_python_api_string_has_highlight (PyObject *self, PyObject *args)
     PYTHON_RETURN_INT(value);
 }
 
+/*
+ * weechat_python_api_string_has_highlight_regex: return 1 if string contains a
+ *                                                highlight (using regular
+ *                                                expression)
+ *                                                return 0 if no highlight is
+ *                                                found in string
+ */
+
+static PyObject *
+weechat_python_api_string_has_highlight_regex (PyObject *self, PyObject *args)
+{
+    char *string, *regex;
+    int value;
+    
+    /* make C compiler happy */
+    (void) self;
+    
+    if (!python_current_script || !python_current_script->name)
+    {
+        WEECHAT_SCRIPT_MSG_NOT_INIT(PYTHON_CURRENT_SCRIPT_NAME, "string_has_highlight_regex");
+        PYTHON_RETURN_INT(0);
+    }
+    
+    string = NULL;
+    regex = NULL;
+    
+    if (!PyArg_ParseTuple (args, "ss", &string, &regex))
+    {
+        WEECHAT_SCRIPT_MSG_WRONG_ARGS(PYTHON_CURRENT_SCRIPT_NAME, "string_has_highlight_regex");
+        PYTHON_RETURN_INT(0);
+    }
+    
+    value = weechat_string_has_highlight_regex (string, regex);
+    
+    PYTHON_RETURN_INT(value);
+}
+
 /*
  * weechat_python_api_string_mask_to_regex: convert a mask (string with only
  *                                          "*" as wildcard) to a regex, paying
@@ -6838,6 +6875,7 @@ PyMethodDef weechat_python_funcs[] =
     { "ngettext", &weechat_python_api_ngettext, METH_VARARGS, "" },
     { "string_match", &weechat_python_api_string_match, METH_VARARGS, "" },
     { "string_has_highlight", &weechat_python_api_string_has_highlight, METH_VARARGS, "" },
+    { "string_has_highlight_regex", &weechat_python_api_string_has_highlight_regex, METH_VARARGS, "" },
     { "string_mask_to_regex", &weechat_python_api_string_mask_to_regex, METH_VARARGS, "" },
     { "string_remove_color", &weechat_python_api_string_remove_color, METH_VARARGS, "" },
     { "string_is_command_char", &weechat_python_api_string_is_command_char, METH_VARARGS, "" },

src/plugins/scripts/ruby/weechat-ruby-api.c

@@ -430,6 +430,47 @@ weechat_ruby_api_string_has_highlight (VALUE class, VALUE string,
     RUBY_RETURN_INT(value);
 }
 
+/*
+ * weechat_ruby_api_string_has_highlight_regex: return 1 if string contains a
+ *                                              highlight (using regular
+ *                                              expression)
+ *                                              return 0 if no highlight is
+ *                                              found in string
+ */
+
+static VALUE
+weechat_ruby_api_string_has_highlight_regex (VALUE class, VALUE string,
+                                             VALUE regex)
+{
+    char *c_string, *c_regex;
+    int value;
+    
+    /* make C compiler happy */
+    (void) class;
+    
+    if (!ruby_current_script || !ruby_current_script->name)
+    {
+        WEECHAT_SCRIPT_MSG_NOT_INIT(RUBY_CURRENT_SCRIPT_NAME, "string_has_highlight_regex");
+        RUBY_RETURN_INT(0);
+    }
+    
+    if (NIL_P (string) || NIL_P (regex))
+    {
+        WEECHAT_SCRIPT_MSG_WRONG_ARGS(RUBY_CURRENT_SCRIPT_NAME, "string_has_highlight_regex");
+        RUBY_RETURN_INT(0);
+    }
+    
+    Check_Type (string, T_STRING);
+    Check_Type (regex, T_STRING);
+    
+    c_string = StringValuePtr (string);
+    c_regex = StringValuePtr (regex);
+    
+    value = weechat_string_has_highlight_regex (c_string, c_regex);
+    
+    RUBY_RETURN_INT(value);
+}
+
 /*
  * weechat_ruby_api_string_mask_to_regex: convert a mask (string with only
  *                                        "*" as wildcard) to a regex, paying
@@ -7494,6 +7535,7 @@ weechat_ruby_api_init (VALUE ruby_mWeechat)
     rb_define_module_function (ruby_mWeechat, "ngettext", &weechat_ruby_api_ngettext, 3);
     rb_define_module_function (ruby_mWeechat, "string_match", &weechat_ruby_api_string_match, 3);
     rb_define_module_function (ruby_mWeechat, "string_has_highlight", &weechat_ruby_api_string_has_highlight, 2);
+    rb_define_module_function (ruby_mWeechat, "string_has_highlight_regex", &weechat_ruby_api_string_has_highlight_regex, 2);
     rb_define_module_function (ruby_mWeechat, "string_mask_to_regex", &weechat_ruby_api_string_mask_to_regex, 1);
     rb_define_module_function (ruby_mWeechat, "string_remove_color", &weechat_ruby_api_string_remove_color, 2);
     rb_define_module_function (ruby_mWeechat, "string_is_command_char", &weechat_ruby_api_string_is_command_char, 1);

src/plugins/scripts/tcl/weechat-tcl-api.c

@@ -530,6 +530,46 @@ weechat_tcl_api_string_has_highlight (ClientData clientData,
     TCL_RETURN_INT(result);
 }
 
+/*
+ * weechat_tcl_api_string_has_highlight_regex: return 1 if string contains a
+ *                                             highlight (using a regular
+ *                                             expression)
+ *                                             return 0 if no highlight is
+ *                                             found in string
+ */
+
+static int
+weechat_tcl_api_string_has_highlight_regex (ClientData clientData,
+                                            Tcl_Interp *interp,
+                                            int objc, Tcl_Obj *CONST objv[])
+{
+    Tcl_Obj* objp;
+    char *string, *regex;
+    int result, i;
+    
+    /* make C compiler happy */
+    (void) clientData;
+    
+    if (!tcl_current_script || !tcl_current_script->name)
+    {
+        WEECHAT_SCRIPT_MSG_NOT_INIT(TCL_CURRENT_SCRIPT_NAME, "string_has_highlight_regex");
+        TCL_RETURN_INT(0);
+    }
+    
+    if (objc < 3)
+    {
+        WEECHAT_SCRIPT_MSG_WRONG_ARGS(TCL_CURRENT_SCRIPT_NAME, "string_has_highlight_regex");
+        TCL_RETURN_INT(0);
+    }
+    
+    string = Tcl_GetStringFromObj (objv[1], &i);
+    regex = Tcl_GetStringFromObj (objv[2], &i);
+    
+    result = weechat_string_has_highlight_regex (string, regex);
+    
+    TCL_RETURN_INT(result);
+}
+
 /*
  * weechat_tcl_api_string_mask_to_regex: convert a mask (string with only
  *                                       "*" as wildcard) to a regex, paying
@@ -7343,6 +7383,8 @@ void weechat_tcl_api_init (Tcl_Interp *interp)
                           weechat_tcl_api_string_match, (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);
     Tcl_CreateObjCommand (interp, "weechat::string_has_highlight",
                           weechat_tcl_api_string_has_highlight, (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);
+    Tcl_CreateObjCommand (interp, "weechat::string_has_highlight_regex",
+                          weechat_tcl_api_string_has_highlight_regex, (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);
     Tcl_CreateObjCommand (interp, "weechat::string_mask_to_regex",
                           weechat_tcl_api_string_mask_to_regex, (ClientData)NULL, (Tcl_CmdDeleteProc*)NULL);
     Tcl_CreateObjCommand (interp, "weechat::string_remove_color",

src/plugins/weechat-plugin.h

@@ -45,7 +45,7 @@ struct timeval;
  */
 
 /* API version (used to check that plugin has same API and can be loaded) */
-#define WEECHAT_PLUGIN_API_VERSION "20101110-01"
+#define WEECHAT_PLUGIN_API_VERSION "20101125-01"
 
 /* macros for defining plugin infos */
 #define WEECHAT_PLUGIN_NAME(__name)                                     \
@@ -180,6 +180,7 @@ struct t_weechat_plugin
                            const char *chars);
     int (*string_has_highlight) (const char *string,
                                  const char *highlight_words);
+    int (*string_has_highlight_regex) (const char *string, const char *regex);
     char *(*string_mask_to_regex) (const char *mask);
     char **(*string_split) (const char *string, const char *separators,
                             int keep_eol, int num_items_max, int *num_items);
@@ -800,6 +801,8 @@ extern int weechat_plugin_end (struct t_weechat_plugin *plugin);
     weechat_plugin->string_strip(__string, __left, __right, __chars)
 #define weechat_string_has_highlight(__string, __highlight_words)       \
     weechat_plugin->string_has_highlight(__string, __highlight_words)
+#define weechat_string_has_highlight_regex(__string, __regex)           \
+    weechat_plugin->string_has_highlight_regex(__string, __regex)
 #define weechat_string_mask_to_regex(__mask)                            \
     weechat_plugin->string_mask_to_regex(__mask)
 #define weechat_string_split(__string, __separator, __eol, __max,       \