dump.c File Reference

Dump the Hooks to the Pager. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "mutt.h"
#include "commands/lib.h"
#include "expando/lib.h"
#include "pager/lib.h"
#include "parse/lib.h"
#include "hook.h"
#include "module_data.h"
#include "muttlib.h"

Include dependency graph for dump.c:

Go to the source code of this file.

Functions
static void	hooks_dump_one (struct Hook *hook, const struct Command *cmd, struct Buffer *buf)
	Dump a single hook to the buffer.
static void	hooks_dump_simple (struct Buffer *buf)
	Dump the simple Hooks.
static void	hooks_dump_index (struct Buffer *buf)
	Dump the Index Format Hooks.
static void	hooks_dump_charset (struct Buffer *buf)
	Dump the Charset Hooks.
enum CommandResult	parse_hooks (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'hooks' command - Implements Command::parse() -.

Detailed Description

Dump the Hooks to the Pager.

Authors

• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file dump.c.

Function Documentation

hooks_dump_one()

static void hooks_dump_one ( struct Hook * hook, const struct Command * cmd, struct Buffer * buf )

static

Dump a single hook to the buffer.

Parameters

hook	Hook to dump
cmd	Command defining the Hook
buf	Buffer for the results

Definition at line 50 of file dump.c.

{
  struct Buffer *pretty = buf_pool_get();
 
  buf_add_printf(buf, "%s ", cmd->name);
 
  if (hook->regex.pattern)
  {
    if (hook->regex.pat_not)
      buf_addch(pretty, '!');
 
    if ((hook->id == CMD_FOLDER_HOOK) || (hook->id == CMD_MBOX_HOOK))
    {
      buf_addstr(pretty, hook->regex.pattern);
      pretty_mailbox(pretty);
      buf_add_printf(buf, "\"%s\" ", buf_string(pretty));
    }
    else
    {
      buf_addstr(pretty, hook->regex.pattern);
      pretty_var(buf_string(pretty), buf);
      buf_addch(buf, ' ');
    }
  }
 
  if ((hook->id == CMD_FCC_HOOK) || (hook->id == CMD_MBOX_HOOK) || (hook->id == CMD_SAVE_HOOK))
  {
    buf_strcpy(pretty, hook->command);
    pretty_mailbox(pretty);
    buf_add_printf(buf, "\"%s\"\n", buf_string(pretty));
  }
  else
  {
    pretty_var(hook->command, buf);
    buf_addch(buf, '\n');
  }
 
  buf_pool_release(&pretty);
}

Here is the call graph for this function:

Here is the caller graph for this function:

hooks_dump_simple()

static void hooks_dump_simple ( struct Buffer * buf )

static

Dump the simple Hooks.

Parameters

buf	Buffer for the results

Definition at line 94 of file dump.c.

{
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  // Dump all the Hooks, except: CMD_CHARSET_HOOK, CMD_ICONV_HOOK, CMD_INDEX_FORMAT_HOOK
  static const enum CommandId hook_ids[] = {
    CMD_ACCOUNT_HOOK, CMD_APPEND_HOOK,   CMD_CLOSE_HOOK,   CMD_CRYPT_HOOK,
    CMD_FCC_HOOK,     CMD_FOLDER_HOOK,   CMD_MBOX_HOOK,    CMD_MESSAGE_HOOK,
    CMD_OPEN_HOOK,    CMD_REPLY_HOOK,    CMD_SAVE_HOOK,    CMD_SEND_HOOK,
    CMD_SEND2_HOOK,   CMD_SHUTDOWN_HOOK, CMD_STARTUP_HOOK, CMD_TIMEOUT_HOOK,
  };
 
  for (size_t i = 0; i < countof(hook_ids); i++)
  {
    const struct Command *hook_cmd = command_find_by_id(&NeoMutt->commands, hook_ids[i]);
    enum CommandId id = hook_ids[i];
    bool found_header = false;
    struct Hook *hook = NULL;
 
    TAILQ_FOREACH(hook, &mod_data->hooks, entries)
    {
      if (hook->id != id)
        continue;
 
      if (!found_header)
      {
        buf_add_printf(buf, "# %s\n", hook_cmd->help);
        found_header = true;
      }
 
      hooks_dump_one(hook, hook_cmd, buf);
    }
 
    if (found_header)
      buf_addstr(buf, "\n");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

hooks_dump_index()

static void hooks_dump_index ( struct Buffer * buf )

static

Dump the Index Format Hooks.

Parameters

buf	Buffer for the results

Definition at line 135 of file dump.c.

{
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  if (!mod_data->idx_fmt_hooks)
    return;
 
  struct HashWalkState hws = { 0 };
  struct HashElem *he = NULL;
  bool found_header = false;
 
  while ((he = mutt_hash_walk(mod_data->idx_fmt_hooks, &hws)))
  {
    const char *name = he->key.strkey;
    struct HookList *hl = he->data;
    struct Hook *hook = NULL;
 
    TAILQ_FOREACH(hook, hl, entries)
    {
      if (!found_header)
      {
        const struct Command *hook_cmd = command_find_by_id(&NeoMutt->commands,
                                                            CMD_INDEX_FORMAT_HOOK);
        buf_add_printf(buf, "# %s\n", hook_cmd->help);
        found_header = true;
      }
 
      const char *exp_str = hook->expando ? hook->expando->string : "";
      buf_add_printf(buf, "index-format-hook '%s' %s'%s' '%s'\n", name,
                     hook->regex.pat_not ? "! " : "",
                     NONULL(hook->regex.pattern), NONULL(exp_str));
    }
  }
 
  if (found_header)
    buf_addstr(buf, "\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

hooks_dump_charset()

static void hooks_dump_charset ( struct Buffer * buf )

static

Dump the Charset Hooks.

Parameters

buf	Buffer for the results

Definition at line 176 of file dump.c.

{
  struct Lookup *l = NULL;
  struct Buffer *charset = buf_pool_get();
  struct Buffer *iconv = buf_pool_get();
 
  TAILQ_FOREACH(l, &Lookups, entries)
  {
    if (l->type == MUTT_LOOKUP_CHARSET)
    {
      buf_addstr(charset, "charset-hook ");
      pretty_var(l->regex.pattern, charset);
      buf_addch(charset, ' ');
      pretty_var(l->replacement, charset);
      buf_addch(charset, '\n');
    }
    else if (l->type == MUTT_LOOKUP_ICONV)
    {
      buf_addstr(iconv, "iconv-hook ");
      pretty_var(l->regex.pattern, iconv);
      buf_addch(iconv, ' ');
      pretty_var(l->replacement, iconv);
      buf_addch(iconv, '\n');
    }
  }
 
  const struct Command *cmd = NULL;
  if (!buf_is_empty(charset))
  {
    cmd = command_find_by_name(&NeoMutt->commands, "charset-hook");
    buf_add_printf(buf, "# %s\n", cmd->help);
    buf_add_printf(buf, "%s\n", buf_string(charset));
  }
 
  if (!buf_is_empty(iconv))
  {
    cmd = command_find_by_name(&NeoMutt->commands, "iconv-hook");
    buf_add_printf(buf, "# %s\n", cmd->help);
    buf_add_printf(buf, "%s\n", buf_string(iconv));
  }
 
  buf_pool_release(&iconv);
  buf_pool_release(&charset);
}

Here is the call graph for this function:

Here is the caller graph for this function: