#include "matcher_parser.h"
#include "prefs_gtk.h"
+/*!
+ *\brief Keyword lookup element
+ */
struct _MatchParser {
- gint id;
- gchar *str;
+ gint id; /*!< keyword id */
+ gchar *str; /*!< keyword */
};
-
typedef struct _MatchParser MatchParser;
-static MatchParser matchparser_tab[] = {
+/*!
+ *\brief Table with strings and ids used by the lexer and
+ * the parser. New keywords can be added here.
+ */
+static const MatchParser matchparser_tab[] = {
/* msginfo flags */
{MATCHCRITERIA_ALL, "all"},
{MATCHCRITERIA_UNREAD, "unread"},
{MATCHACTION_EXECUTE, "execute"},
{MATCHACTION_COLOR, "color"},
{MATCHACTION_REDIRECT, "redirect"},
- {MATCHACTION_DELETE_ON_SERVER, "delete_on_server"}
+ {MATCHACTION_CHANGE_SCORE, "change_score"}
};
+/*!
+ *\brief Look up table with keywords defined in \sa matchparser_tab
+ */
static GHashTable *matchparser_hashtab;
-/* get_matchparser_tab_str() - used by filtering.c to translate
- * actions to debug strings */
-gchar *get_matchparser_tab_str(gint id)
+/*!
+ *\brief Translate keyword id to keyword string
+ *
+ *\param id Id of keyword
+ *
+ *\return const gchar * Keyword
+ */
+const gchar *get_matchparser_tab_str(gint id)
{
gint i;
return NULL;
}
+/*!
+ *\brief Create keyword lookup table
+ */
static void create_matchparser_hashtab(void)
{
int i;
for (i = 0; i < sizeof matchparser_tab / sizeof matchparser_tab[0]; i++)
g_hash_table_insert(matchparser_hashtab,
matchparser_tab[i].str,
- &matchparser_tab[i]);
+ (gpointer) &matchparser_tab[i]);
}
+/*!
+ *\brief Return a keyword id from a keyword string
+ *
+ *\param str Keyword string
+ *
+ *\return gint Keyword id
+ */
gint get_matchparser_tab_id(const gchar *str)
{
- gint i;
MatchParser *res;
if (NULL != (res = g_hash_table_lookup(matchparser_hashtab, str))) {
return -1;
}
-/* matcher_escape_str() - escapes a string returns newly allocated escaped string */
+/*!
+ *\brief Escape characters in a string by inserting '\' characters
+ *
+ *\param str String with characters to be escaped
+ *
+ *\return gchar * Newly allocated string with escaped characters
+ */
gchar *matcher_escape_str(const gchar *str)
{
register const gchar *walk;
return res;
}
-/* matcher_unescape_str() - assumes that unescaping frees up room
- * in the string, so it returns the unescaped string in the
- * source */
+/*!
+ *\brief Unescape string by replacing escaped char sequences
+ * (\b, \n, etc) by their actual char. Note that this
+ * function changes the contents of the buffer pointed
+ * to by \a str.
+ *
+ *\param str Buffer containing string that needs to be escaped.
+ * Note that this function changes the contents of the
+ * buffer
+ *
+ *\return gchar * Pointer to changed buffer
+ */
gchar *matcher_unescape_str(gchar *str)
{
gchar *tmp = alloca(strlen(str) + 1);
/* **************** data structure allocation **************** */
-/* matcherprop_new() - allocates a structure for one condition
+/*!
+ *\brief Allocate a structure for a filtering / scoring
+ * "condition" (a matcher structure)
+ *
+ *\param criteria Criteria ID (MATCHCRITERIA_XXXX)
+ *\param header Header string (if criteria is MATCHCRITERIA_HEADER)
+ *\param matchtype Type of action (MATCHTYPE_XXX)
+ *\param expr String value or expression to check
+ *\param value Integer value to check
+ *
+ *\return MatcherProp * Pointer to newly allocated structure
*/
-MatcherProp *matcherprop_new(gint criteria, gchar *header,
- gint matchtype, gchar *expr,
+MatcherProp *matcherprop_new(gint criteria, const gchar *header,
+ gint matchtype, const gchar *expr,
int value)
{
MatcherProp *prop;
return prop;
}
-/* matcherprop_free()
+/*!
+ *\brief Free a matcher structure
+ *
+ *\param prop Pointer to matcher structure allocated with
+ * #matcherprop_new
*/
void matcherprop_free(MatcherProp *prop)
{
g_free(prop);
}
-MatcherProp *matcherprop_copy(MatcherProp *src)
+/*!
+ *\brief Copy a matcher structure
+ *
+ *\param src Matcher structure to copy
+ *
+ *\return MatcherProp * Pointer to newly allocated matcher structure
+ */
+MatcherProp *matcherprop_copy(const MatcherProp *src)
{
MatcherProp *prop = g_new0(MatcherProp, 1);
/* ****************** wrapper for file reading ************** */
-MatcherProp *matcherprop_unquote_new(gint criteria, gchar *header,
- gint matchtype, gchar *expr,
+/*!
+ *\brief Allocate a matcher structure where all strings
+ * are unescaped ("unquoted")
+ *
+ *\param criteria One of the MATCHCRITERIA_XXX constants
+ *\param header A header string
+ *\param matchtype Type of matcher (MATCHTYPE_XXX)
+ *\param expr Matcher string expression
+ *\param value Matcher integer value
+ *
+ *\return MatcherProp * Pointer to newly allocated matcher
+ * structure
+ */
+MatcherProp *matcherprop_unquote_new(gint criteria, const gchar *header,
+ gint matchtype, const gchar *expr,
int value)
{
MatcherProp *prop;
prop = matcherprop_new(criteria, header, matchtype, expr, value);
- g_free(header);
- g_free(expr);
+ g_free((gpointer) header);
+ g_free((gpointer) expr);
return prop;
}
/* ************** match ******************************/
-
-/* matcherprop_string_match() - finds out if a string matches
- * with a criterium */
-static gboolean matcherprop_string_match(MatcherProp *prop, gchar *str)
+/*!
+ *\brief Find out if a string matches a condition
+ *
+ *\param prop Matcher structure
+ *\param str String to check
+ *
+ *\return gboolean TRUE if str matches the condition in the
+ * matcher structure
+ */
+static gboolean matcherprop_string_match(MatcherProp *prop, const gchar *str)
{
gchar *str1;
gchar *str2;
}
}
-gboolean matcherprop_match_execute(MatcherProp *prop, MsgInfo *info)
+/*!
+ *\brief Execute a command defined in the matcher structure
+ *
+ *\param prop Pointer to matcher structure
+ *\param info Pointer to message info structure
+ *
+ *\return gboolean TRUE if command was executed succesfully
+ */
+static gboolean matcherprop_match_execute(const MatcherProp *prop,
+ MsgInfo *info)
{
gchar *file;
gchar *cmd;
return (retval == 0);
}
-/* match a message and his headers, hlist can be NULL if you don't
- want to use headers */
-
-gboolean matcherprop_match(MatcherProp *prop, MsgInfo *info)
+/*!
+ *\brief Check if a message matches the condition in a matcher
+ * structure.
+ *
+ *\param prop Pointer to matcher structure
+ *\param info Pointer to message info
+ *
+ *\return gboolean TRUE if a match
+ */
+gboolean matcherprop_match(MatcherProp *prop,
+ MsgInfo *info)
{
time_t t;
/* ********************* MatcherList *************************** */
-
+/*!
+ *\brief Create a new list of matchers
+ *
+ *\param matchers List of matcher structures
+ *\param bool_and Operator
+ *
+ *\return MatcherList * New list
+ */
MatcherList *matcherlist_new(GSList *matchers, gboolean bool_and)
{
MatcherList *cond;
return cond;
}
+/*!
+ *\brief Frees a list of matchers
+ *
+ *\param cond List of matchers
+ */
void matcherlist_free(MatcherList *cond)
{
GSList *l;
g_free(cond);
}
-/*
- skip the headers
+/*!
+ *\brief Skip all headers in a message file
+ *
+ *\param fp Message file
*/
-
static void matcherlist_skip_headers(FILE *fp)
{
gchar buf[BUFFSIZE];
;
}
-/*
- matcherprop_match_one_header
- returns TRUE if buf matchs the MatchersProp criteria
+/*!
+ *\brief Check if a header matches a matcher condition
+ *
+ *\param matcher Matcher structure to check header for
+ *\param buf Header name
+ *
+ *\return boolean TRUE if matching header
*/
-
static gboolean matcherprop_match_one_header(MatcherProp *matcher,
gchar *buf)
{
return FALSE;
}
-/*
- matcherprop_criteria_header
- returns TRUE if the headers must be matched
+/*!
+ *\brief Check if the matcher structure wants headers to
+ * be matched
+ *
+ *\param matcher Matcher structure
+ *
+ *\return gboolean TRUE if the matcher structure describes
+ * a header match condition
*/
-
-static gboolean matcherprop_criteria_headers(MatcherProp *matcher)
+static gboolean matcherprop_criteria_headers(const MatcherProp *matcher)
{
switch (matcher->criteria) {
case MATCHCRITERIA_HEADER:
}
}
+/*!
+ *\brief Check if the matcher structure wants the message
+ * to be matched (just perform an action on any
+ * message)
+ *
+ *\param matcher Matcher structure
+ *
+ *\return gboolean TRUE if matcher condition should match
+ * a message
+ */
static gboolean matcherprop_criteria_message(MatcherProp *matcher)
{
switch (matcher->criteria) {
}
}
-/*
- matcherlist_match_one_header
- returns TRUE if match should stop
+/*!
+ *\brief Check if a list of conditions match a header
+ *
+ *\param matchers One set of conditions
+ *\param buf Name of header
+ *
+ *\return gboolean TRUE if matching should stop
*/
-
static gboolean matcherlist_match_one_header(MatcherList *matchers,
gchar *buf)
{
for (l = matchers->matchers ; l != NULL ; l = g_slist_next(l)) {
MatcherProp *matcher = (MatcherProp *) l->data;
-
+
+ /* see if a single condition matches */
if (matcherprop_criteria_headers(matcher) ||
matcherprop_criteria_message(matcher)) {
if (matcherprop_match_one_header(matcher, buf)) {
return FALSE;
}
-/*
- matcherlist_match_headers
- returns TRUE if one of the headers matchs the MatcherList criteria
+/*!
+ *\brief Check if a list of conditions matches one header in
+ * a message file.
+ *
+ *\param matchers List of conditions
+ *\param fp Message file
+ *
+ *\return gboolean TRUE if one of the headers is matched by
+ * the list of conditions.
*/
-
static gboolean matcherlist_match_headers(MatcherList *matchers, FILE *fp)
{
gchar buf[BUFFSIZE];
return FALSE;
}
-/*
- matcherprop_criteria_body
- returns TRUE if the body must be matched
+/*!
+ *\brief Check if a matcher wants to check the message body
+ *
+ *\param matcher Matcher structure
+ *
+ *\return gboolean TRUE if body must be matched.
*/
-
-static gboolean matcherprop_criteria_body(MatcherProp *matcher)
+static gboolean matcherprop_criteria_body(const MatcherProp *matcher)
{
switch (matcher->criteria) {
case MATCHCRITERIA_BODY_PART:
}
}
-/*
- matcherprop_match_line
- returns TRUE if the string matchs the MatcherProp criteria
+/*!
+ *\brief Check if a (line) string matches the criteria
+ * described by a matcher structure
+ *
+ *\param matcher Matcher structure
+ *\param line String
+ *
+ *\return gboolean TRUE if string matches criteria
*/
-
-static gboolean matcherprop_match_line(MatcherProp *matcher, gchar *line)
+static gboolean matcherprop_match_line(MatcherProp *matcher, const gchar *line)
{
switch (matcher->criteria) {
case MATCHCRITERIA_BODY_PART:
return FALSE;
}
-/*
- matcherlist_match_line
- returns TRUE if the string matchs the MatcherList criteria
+/*!
+ *\brief Check if a list of conditions matches a (line) string
+ *
+ *\param matchers List of matchers
+ *\param line String to match
+ *
+ *\return gboolean TRUE if string matches list of criteria
*/
-
-static gboolean matcherlist_match_line(MatcherList *matchers, gchar *line)
+static gboolean matcherlist_match_line(MatcherList *matchers, const gchar *line)
{
GSList *l;
return FALSE;
}
-/*
- matcherlist_match_body
- returns TRUE if one line of the body matchs the MatcherList criteria
+/*!
+ *\brief Check if a line in a message file's body matches
+ * the criteria
+ *
+ *\param matchers List of conditions
+ *\param fp Message file
+ *
+ *\return gboolean TRUE if succesful match
*/
-
static gboolean matcherlist_match_body(MatcherList *matchers, FILE *fp)
{
gchar buf[BUFFSIZE];
return FALSE;
}
+/*!
+ *\brief Check if a message file matches criteria
+ *
+ *\param matchers Criteria
+ *\param info Message info
+ *\param result Default result
+ *
+ *\return gboolean TRUE if matched
+ */
gboolean matcherlist_match_file(MatcherList *matchers, MsgInfo *info,
gboolean result)
{
return result;
}
-/* test a list of condition */
-
+/*!
+ *\brief Test list of conditions on a message.
+ *
+ *\param matchers List of conditions
+ *\param info Message info
+ *
+ *\return gboolean TRUE if matched
+ */
gboolean matcherlist_match(MatcherList *matchers, MsgInfo *info)
{
GSList *l;
return result;
}
-
+/*!
+ *\brief Convert a matcher structure to a string
+ *
+ *\param matcher Matcher structure
+ *
+ *\return gchar * Newly allocated string
+ */
gchar *matcherprop_to_string(MatcherProp *matcher)
{
gchar *matcher_str = NULL;
- gchar *criteria_str;
- gchar *matchtype_str;
+ const gchar *criteria_str;
+ const gchar *matchtype_str;
int i;
- char *expr;
- char *header;
+ gchar *expr;
criteria_str = NULL;
for (i = 0; i < (int) (sizeof(matchparser_tab) / sizeof(MatchParser)); i++) {
case MATCHCRITERIA_NOT_EXECUTE:
expr = matcher_escape_str(matcher->expr);
matcher_str = g_strdup_printf("%s \"%s\"", criteria_str, expr);
- g_free(expr);
+ g_free((gpointer) expr);
return matcher_str;
}
case MATCHTYPE_REGEXP:
case MATCHTYPE_REGEXPCASE:
expr = matcher_escape_str(matcher->expr);
- header = matcher_escape_str(matcher->header);
if (matcher->header)
matcher_str = g_strdup_printf
("%s \"%s\" %s \"%s\"",
matcher_str = g_strdup_printf
("%s %s \"%s\"", criteria_str,
matchtype_str, expr);
+ g_free((gpointer) expr);
break;
- g_free(header);
- g_free(expr);
}
return matcher_str;
}
-gchar *matcherlist_to_string(MatcherList *matchers)
+/*!
+ *\brief Convert a list of conditions to a string
+ *
+ *\param matchers List of conditions
+ *
+ *\return gchar * Newly allocated string
+ */
+gchar *matcherlist_to_string(const MatcherList *matchers)
{
gint count;
gchar **vstr;
#define STRLEN_ZERO(s) ((s) ? strlen(s) : 0)
#define STRLEN_DEFAULT(s,d) ((s) ? strlen(s) : STRLEN_ZERO(d))
/* matching_build_command() - preferably cmd should be unescaped */
-gchar *matching_build_command(gchar *cmd, MsgInfo *info)
+/*!
+ *\brief Build the command line to execute
+ *
+ *\param cmd String with command line specifiers
+ *\param info Message info to use for command
+ *
+ *\return gchar * Newly allocated string
+ *
+ *\warning The \a cmd string should have been unescaped using
+ * #matcher_unescape_str.
+ */
+gchar *matching_build_command(const gchar *cmd, MsgInfo *info)
{
- gchar *s = cmd;
+ const gchar *s = cmd;
gchar *filename = NULL;
gchar *processed_cmd;
gchar *p;
/* ************************************************************ */
+/*!
+ *\brief Write scoring list to file
+ *
+ *\param fp File
+ *\param prefs_scoring List of scoring conditions
+ */
static void prefs_scoring_write(FILE *fp, GSList *prefs_scoring)
{
GSList *cur;
}
}
-static void prefs_filtering_write(FILE *fp, GSList *prefs_scoring)
+/*!
+ *\brief Write filtering list to file
+ *
+ *\param fp File
+ *\param prefs_filtering List of filtering conditions
+ */
+static void prefs_filtering_write(FILE *fp, GSList *prefs_filtering)
{
GSList *cur;
- for (cur = prefs_scoring; cur != NULL; cur = cur->next) {
+ for (cur = prefs_filtering; cur != NULL; cur = cur->next) {
gchar *filtering_str;
FilteringProp *prop;
}
}
+/*!
+ *\brief Write matchers from a folder item
+ *
+ *\param node Node with folder info
+ *\param data File pointer
+ *
+ *\return gboolean FALSE
+ */
static gboolean prefs_matcher_write_func(GNode *node, gpointer data)
{
FolderItem *item;
return FALSE;
}
+/*!
+ *\brief Save matchers from folder items
+ *
+ *\param fp File
+ */
static void prefs_matcher_save(FILE *fp)
{
GList *cur;
prefs_matcher_write_func(NULL, fp);
}
-
+/*!
+ *\brief Write filtering / matcher configuration file
+ */
void prefs_matcher_write_config(void)
{
gchar *rcpath;
/* ******************************************************************* */
+/*!
+ *\brief Read matcher configuration
+ */
void prefs_matcher_read_config(void)
{
gchar *rcpath;
projects / claws.git / blobdiff