alternates.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "alternates.h"
#include "parse/lib.h"
#include "commands.h"
#include "mview.h"
 
static struct RegexList Alternates = STAILQ_HEAD_INITIALIZER(Alternates); 
static struct RegexList UnAlternates = STAILQ_HEAD_INITIALIZER(UnAlternates); 
static struct Notify *AlternatesNotify = NULL; 

void alternates_cleanup(void)
{
  notify_free(&AlternatesNotify);
 
  mutt_regexlist_free(&Alternates);
  mutt_regexlist_free(&UnAlternates);
}

void alternates_init(void)
{
  if (AlternatesNotify)
    return;
 
  AlternatesNotify = notify_new();
  notify_set_parent(AlternatesNotify, NeoMutt->notify);
}

void mutt_alternates_reset(struct MailboxView *mv)
{
  if (!mv || !mv->mailbox)
    return;
 
  struct Mailbox *m = mv->mailbox;
 
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e = m->emails[i];
    if (!e)
      break;
    e->recip_valid = false;
  }
}

enum CommandResult parse_alternates(const struct Command *cmd,
                                    struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    if (parse_grouplist(&gl, token, line, err, NeoMutt->groups) == -1)
      goto done;
 
    mutt_regexlist_remove(&UnAlternates, buf_string(token));
 
    if (mutt_regexlist_add(&Alternates, buf_string(token), REG_ICASE, err) != 0)
      goto done;
 
    if (grouplist_add_regex(&gl, buf_string(token), REG_ICASE, err) != 0)
      goto done;
  } while (MoreArgs(line));
 
  mutt_debug(LL_NOTIFY, "NT_ALTERN_ADD: %s\n", buf_string(token));
  notify_send(AlternatesNotify, NT_ALTERN, NT_ALTERN_ADD, NULL);
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  grouplist_destroy(&gl);
  return rc;
}

enum CommandResult parse_unalternates(const struct Command *cmd,
                                      struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&Alternates, buf_string(token));
 
    if (!mutt_str_equal(buf_string(token), "*") &&
        (mutt_regexlist_add(&UnAlternates, buf_string(token), REG_ICASE, err) != 0))
    {
      goto done;
    }
 
  } while (MoreArgs(line));
 
  mutt_debug(LL_NOTIFY, "NT_ALTERN_DELETE: %s\n", buf_string(token));
  notify_send(AlternatesNotify, NT_ALTERN, NT_ALTERN_DELETE, NULL);
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

bool mutt_alternates_match(const char *addr)
{
  if (!addr)
    return false;
 
  if (mutt_regexlist_match(&Alternates, addr))
  {
    mutt_debug(LL_DEBUG5, "yes, %s matched by alternates\n", addr);
    if (mutt_regexlist_match(&UnAlternates, addr))
      mutt_debug(LL_DEBUG5, "but, %s matched by unalternates\n", addr);
    else
      return true;
  }
 
  return false;
}