filters.c

   1 /*
   2  * Copyright 2005 Timo Hirvonen
   3  */
   4
   5 #include "filters.h"
   6 #include "expr.h"
   7 #include "window.h"
   8 #include "search.h"
   9 #include "uchar.h"
  10 #include "lib.h"
  11 #include "misc.h"
  12 #include "file.h"
  13 #include "ui_curses.h"
  14 #include "xmalloc.h"
  15
  16 #include <ctype.h>
  17
  18 struct window *filters_win;
  19 struct searchable *filters_searchable;
  20 LIST_HEAD(filters_head);
  21
  22 static const char *recursive_filter;
  23
  24 static inline void filter_entry_to_iter(struct filter_entry *e, struct iter *iter)
  25 {
  26         iter->data0 = &filters_head;
  27         iter->data1 = e;
  28         iter->data2 = NULL;
  29 }
  30
  31 static GENERIC_ITER_PREV(filters_get_prev, struct filter_entry, node)
  32 static GENERIC_ITER_NEXT(filters_get_next, struct filter_entry, node)
  33
  34 static int filters_search_get_current(void *data, struct iter *iter)
  35 {
  36         return window_get_sel(filters_win, iter);
  37 }
  38
  39 static int filters_search_matches(void *data, struct iter *iter, const char *text)
  40 {
  41         char **words = get_words(text);
  42         int matched = 0;
  43
  44         if (words[0] != NULL) {
  45                 struct filter_entry *e;
  46                 int i;
  47
  48                 e = iter_to_filter_entry(iter);
  49                 for (i = 0; ; i++) {
  50                         if (words[i] == NULL) {
  51                                 window_set_sel(filters_win, iter);
  52                                 matched = 1;
  53                                 break;
  54                         }
  55                         if (u_strcasestr(e->name, words[i]) == NULL)
  56                                 break;
  57                 }
  58         }
  59         free_str_array(words);
  60         return matched;
  61 }
  62
  63 static const struct searchable_ops filters_search_ops = {
  64         .get_prev = filters_get_prev,
  65         .get_next = filters_get_next,
  66         .get_current = filters_search_get_current,
  67         .matches = filters_search_matches
  68 };
  69
  70 static void free_filter(struct filter_entry *e)
  71 {
  72         free(e->name);
  73         free(e->filter);
  74         free(e);
  75 }
  76
  77 static struct filter_entry *find_filter(const char *name)
  78 {
  79         struct filter_entry *e;
  80
  81         list_for_each_entry(e, &filters_head, node) {
  82                 if (strcmp(e->name, name) == 0)
  83                         return e;
  84         }
  85         return NULL;
  86 }
  87
  88 static const char *get_filter(const char *name)
  89 {
  90         struct filter_entry *e = find_filter(name);
  91
  92         if (e) {
  93                 if (e->visited) {
  94                         recursive_filter = e->name;
  95                         return NULL;
  96                 }
  97                 e->visited = 1;
  98                 return e->filter;
  99         }
 100         return NULL;
 101 }
 102
 103 void filters_activate(void)
 104 {
 105         struct filter_entry *f;
 106         struct expr *e, *expr = NULL;
 107
 108         /* mark visited and AND together all selected filters
 109          * mark any other filters unvisited */
 110         list_for_each_entry(f, &filters_head, node) {
 111                 f->visited = 0;
 112                 if (f->sel_stat == FS_IGNORE)
 113                         continue;
 114
 115                 f->visited = 1;
 116                 e = expr_parse(f->filter);
 117                 if (e == NULL) {
 118                         error_msg("error parsing filter %s: %s", f->name, expr_error());
 119                         if (expr)
 120                                 expr_free(expr);
 121                         return;
 122                 }
 123
 124                 if (f->sel_stat == FS_NO) {
 125                         /* add ! */
 126                         struct expr *not = xnew(struct expr, 1);
 127
 128                         not->type = EXPR_NOT;
 129                         not->key = NULL;
 130                         not->left = e;
 131                         not->right = NULL;
 132                         e = not;
 133                 }
 134                 if (expr == NULL) {
 135                         expr = e;
 136                 } else {
 137                         struct expr *and = xnew(struct expr, 1);
 138
 139                         and->type = EXPR_AND;
 140                         and->key = NULL;
 141                         and->left = expr;
 142                         and->right = e;
 143                         expr->parent = and;
 144                         e->parent = and;
 145                         expr = and;
 146                 }
 147         }
 148
 149         recursive_filter = NULL;
 150         if (expr && expr_check_leaves(&expr, get_filter)) {
 151                 if (recursive_filter) {
 152                         error_msg("recursion detected in filter %s", recursive_filter);
 153                 } else {
 154                         error_msg("error parsing filter: %s", expr_error());
 155                 }
 156                 expr_free(expr);
 157                 return;
 158         }
 159
 160         /* update active flag */
 161         list_for_each_entry(f, &filters_head, node) {
 162                 f->act_stat = f->sel_stat;
 163         }
 164         lib_set_filter(expr);
 165         filters_win->changed = 1;
 166 }
 167
 168 static int for_each_name(const char *str, int (*cb)(const char *name, int sel_stat))
 169 {
 170         char buf[64];
 171         int s, e, len;
 172
 173         e = 0;
 174         do {
 175                 int sel_stat = FS_YES;
 176
 177                 s = e;
 178                 while (str[s] == ' ')
 179                         s++;
 180                 if (str[s] == '!') {
 181                         sel_stat = FS_NO;
 182                         s++;
 183                 }
 184                 e = s;
 185                 while (str[e] && str[e] != ' ')
 186                         e++;
 187
 188                 len = e - s;
 189                 if (len == 0)
 190                         return 0;
 191                 if (len >= sizeof(buf)) {
 192                         error_msg("filter name too long");
 193                         return -1;
 194                 }
 195
 196                 memcpy(buf, str + s, len);
 197                 buf[len] = 0;
 198
 199                 if (cb(buf, sel_stat))
 200                         return -1;
 201         } while (1);
 202 }
 203
 204 static int ensure_filter_name(const char *name, int sel_stat)
 205 {
 206         if (find_filter(name) == NULL) {
 207                 error_msg("no such filter %s", name);
 208                 return -1;
 209         }
 210         return 0;
 211 }
 212
 213 static int select_filter(const char *name, int sel_stat)
 214 {
 215         struct filter_entry *e = find_filter(name);
 216
 217         e->sel_stat = sel_stat;
 218         return 0;
 219 }
 220
 221 void filters_activate_names(const char *str)
 222 {
 223         struct filter_entry *f;
 224
 225         /* first validate all filter names */
 226         if (str && for_each_name(str, ensure_filter_name))
 227                 return;
 228
 229         /* mark all filters unselected  */
 230         list_for_each_entry(f, &filters_head, node)
 231                 f->sel_stat = FS_IGNORE;
 232
 233         /* select the filters */
 234         if (str)
 235                 for_each_name(str, select_filter);
 236
 237         /* activate selected */
 238         filters_activate();
 239 }
 240
 241 void filters_toggle_filter(void)
 242 {
 243         struct iter iter;
 244
 245         if (window_get_sel(filters_win, &iter)) {
 246                 struct filter_entry *e;
 247
 248                 e = iter_to_filter_entry(&iter);
 249                 e->sel_stat = (e->sel_stat + 1) % 3;
 250                 filters_win->changed = 1;
 251         }
 252 }
 253
 254 void filters_delete_filter(void)
 255 {
 256         struct iter iter;
 257
 258         if (window_get_sel(filters_win, &iter)) {
 259                 struct filter_entry *e;
 260
 261                 e = iter_to_filter_entry(&iter);
 262                 if (yes_no_query("Delete filter '%s'? [y/N]", e->name)) {
 263                         window_row_vanishes(filters_win, &iter);
 264                         list_del(&e->node);
 265                         free_filter(e);
 266                 }
 267         }
 268 }
 269
 270 static int validate_filter_name(const char *name)
 271 {
 272         int i;
 273
 274         for (i = 0; name[i]; i++) {
 275                 if (isalnum(name[i]))
 276                         continue;
 277                 if (name[i] == '_' || name[i] == '-')
 278                         continue;
 279                 return 0;
 280         }
 281         return i != 0;
 282 }
 283
 284 static void do_filters_set_filter(const char *keyval)
 285 {
 286         const char *eq = strchr(keyval, '=');
 287         char *key, *val;
 288         struct expr *expr;
 289         struct filter_entry *new;
 290         struct list_head *item;
 291
 292         if (eq == NULL) {
 293                 if (ui_initialized)
 294                         error_msg("invalid argument ('key=value' expected)");
 295                 return;
 296         }
 297         key = xstrndup(keyval, eq - keyval);
 298         val = xstrdup(eq + 1);
 299         if (!validate_filter_name(key)) {
 300                 if (ui_initialized)
 301                         error_msg("invalid filter name (can only contain 'a-zA-Z0-9_-' characters)");
 302                 free(key);
 303                 free(val);
 304                 return;
 305         }
 306         expr = expr_parse(val);
 307         if (expr == NULL) {
 308                 if (ui_initialized)
 309                         error_msg("error parsing filter %s: %s", val, expr_error());
 310                 free(key);
 311                 free(val);
 312                 return;
 313         }
 314         expr_free(expr);
 315
 316         new = xnew(struct filter_entry, 1);
 317         new->name = key;
 318         new->filter = val;
 319         new->act_stat = FS_IGNORE;
 320         new->sel_stat = FS_IGNORE;
 321
 322         /* add or replace filter */
 323         list_for_each(item, &filters_head) {
 324                 struct filter_entry *e = container_of(item, struct filter_entry, node);
 325                 int res = strcmp(key, e->name);
 326
 327                 if (res < 0)
 328                         break;
 329                 if (res == 0) {
 330                         /* replace */
 331                         struct iter iter;
 332
 333                         if (ui_initialized) {
 334                                 filter_entry_to_iter(e, &iter);
 335                                 window_row_vanishes(filters_win, &iter);
 336                         }
 337                         item = item->next;
 338                         list_del(&e->node);
 339                         free_filter(e);
 340                         break;
 341                 }
 342         }
 343         /* add before item */
 344         list_add_tail(&new->node, item);
 345         if (ui_initialized)
 346                 window_changed(filters_win);
 347 }
 348
 349 void filters_init(void)
 350 {
 351         struct iter iter;
 352
 353         filters_win = window_new(filters_get_prev, filters_get_next);
 354         window_set_contents(filters_win, &filters_head);
 355         window_changed(filters_win);
 356
 357         iter.data0 = &filters_head;
 358         iter.data1 = NULL;
 359         iter.data2 = NULL;
 360         filters_searchable = searchable_new(NULL, &iter, &filters_search_ops);
 361 }
 362
 363 void filters_exit(void)
 364 {
 365         searchable_free(filters_searchable);
 366         window_free(filters_win);
 367 }
 368
 369 void filters_set_filter(const char *keyval)
 370 {
 371         do_filters_set_filter(keyval);
 372 }
 373
 374 struct expr *parse_filter(const char *val)
 375 {
 376         struct expr *e = NULL;
 377         struct filter_entry *f;
 378
 379         if (val) {
 380                 e = expr_parse(val);
 381                 if (e == NULL) {
 382                         error_msg("error parsing filter %s: %s", val, expr_error());
 383                         return NULL;
 384                 }
 385         }
 386
 387         /* mark all unvisited so that we can check recursion */
 388         list_for_each_entry(f, &filters_head, node)
 389                 f->visited = 0;
 390
 391         recursive_filter = NULL;
 392         if (e && expr_check_leaves(&e, get_filter)) {
 393                 if (recursive_filter) {
 394                         error_msg("recursion detected in filter %s", recursive_filter);
 395                 } else {
 396                         error_msg("error parsing filter: %s", expr_error());
 397                 }
 398                 expr_free(e);
 399                 return NULL;
 400         }
 401         return e;
 402 }
 403
 404 void filters_set_anonymous(const char *val)
 405 {
 406         struct filter_entry *f;
 407         struct expr *e = NULL;
 408
 409         if (val) {
 410                 e = parse_filter(val);
 411                 if (e == NULL)
 412                         return;
 413         }
 414
 415         /* deactive all filters */
 416         list_for_each_entry(f, &filters_head, node)
 417                 f->act_stat = FS_IGNORE;
 418
 419         lib_set_filter(e);
 420
 421         filters_win->changed = 1;
 422 }