history.c File Reference

Read/write command history from/to a file. More...

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "lib.h"
#include "module_data.h"

Include dependency graph for history.c:

Go to the source code of this file.

Macros
#define	HC_FIRST   HC_EXT_COMMAND

Functions
static struct History *	get_history (enum HistoryClass hclass)
	Get a particular history.
static void	init_history (struct History *h, int old_size)
	Set up a new History ring buffer.
static int	dup_hash_dec (struct HashTable *dup_hash, char *str)
	Decrease the refcount of a history string.
static int	dup_hash_inc (struct HashTable *dup_hash, char *str)
	Increase the refcount of a history string.
static void	shrink_histfile (void)
	Read, de-dupe and write the history file.
static void	save_history (enum HistoryClass hclass, const char *str)
	Save one history string to a file.
static void	remove_history_dups (enum HistoryClass hclass, const char *str)
	De-dupe the history.
int	mutt_hist_search (const char *find, enum HistoryClass hclass, struct StringArray *matches)
	Find matches in a history list.
void	mutt_hist_cleanup (struct HistoryModuleData *mod_data)
	Free all the history lists.
void	mutt_hist_init (struct HistoryModuleData *mod_data)
	Create a set of empty History ring buffers.
void	mutt_hist_add (enum HistoryClass hclass, const char *str, bool save)
	Add a string to a history.
char *	mutt_hist_next (enum HistoryClass hclass)
	Get the next string in a History.
char *	mutt_hist_prev (enum HistoryClass hclass)
	Get the previous string in a History.
void	mutt_hist_reset_state (enum HistoryClass hclass)
	Move the 'current' position to the end of the History.
void	mutt_hist_read_file (void)
	Read the History from a file.
bool	mutt_hist_at_scratch (enum HistoryClass hclass)
	Is the current History position at the 'scratch' place?
void	mutt_hist_save_scratch (enum HistoryClass hclass, const char *str)
	Save a temporary string to the History.
void	mutt_hist_complete (struct Buffer *buf, enum HistoryClass hclass)
	Complete a string from a history list.
int	main_hist_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has change - Implements observer_t -.

Detailed Description

Read/write command history from/to a file.

Authors

• Richard Russon
• Pietro Cerutti
• Dennis Schön

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 history.c.

Macro Definition Documentation

HC_FIRST

#define HC_FIRST   HC_EXT_COMMAND

Definition at line 84 of file history.c.

Function Documentation

get_history()

struct History * get_history ( enum HistoryClass hclass )

static

Get a particular history.

Parameters

hclass

Type of history to find

Return values

ptr	History ring buffer

Definition at line 91 of file history.c.

{
  struct HistoryModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HISTORY);
  const short c_history = cs_subset_number(NeoMutt->sub, "history");
  if ((hclass >= HC_MAX) || (c_history == 0))
    return NULL;
 
  struct History *hist = &mod_data->histories[hclass];
  return hist->hist ? hist : NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_history()

void init_history ( struct History * h, int old_size )

static

Set up a new History ring buffer.

Parameters

h	History to populate
old_size	Previous number of history entries to save

If the History already has entries, they will be freed.

Definition at line 109 of file history.c.

{
  if (old_size != 0)
  {
    if (h->hist)
    {
      for (int i = 0; i <= old_size; i++)
        FREE(&h->hist[i]);
      FREE(&h->hist);
    }
  }
 
  const short c_history = cs_subset_number(NeoMutt->sub, "history");
  if (c_history != 0)
    h->hist = MUTT_MEM_CALLOC(c_history + 1, char *);
 
  h->cur = 0;
  h->last = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dup_hash_dec()

int dup_hash_dec ( struct HashTable * dup_hash, char * str )

static

Decrease the refcount of a history string.

Parameters

dup_hash	Hash Table containing unique history strings
str	String to find

Return values

0	String was deleted from the Hash Table
>0	Refcount of string
-1	Error, string not found

If the string's refcount is 1, then the string will be deleted.

Definition at line 139 of file history.c.

{
  struct HashElem *he = mutt_hash_find_elem(dup_hash, str);
  if (!he)
    return -1;
 
  uintptr_t count = (uintptr_t) he->data;
  if (count <= 1)
  {
    mutt_hash_delete(dup_hash, str, NULL);
    return 0;
  }
 
  count--;
  he->data = (void *) count;
  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dup_hash_inc()

int dup_hash_inc ( struct HashTable * dup_hash, char * str )

static

Increase the refcount of a history string.

Parameters

dup_hash	Hash Table containing unique history strings
str	String to find

Return values

num	Refcount of string

If the string isn't found it will be added to the Hash Table.

Definition at line 165 of file history.c.

{
  uintptr_t count;
 
  struct HashElem *he = mutt_hash_find_elem(dup_hash, str);
  if (!he)
  {
    count = 1;
    mutt_hash_insert(dup_hash, str, (void *) count);
    return count;
  }
 
  count = (uintptr_t) he->data;
  count++;
  he->data = (void *) count;
  return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

shrink_histfile()

void shrink_histfile ( void )

static

Read, de-dupe and write the history file.

Definition at line 186 of file history.c.

{
  FILE *fp_tmp = NULL;
  int n[HC_MAX] = { 0 };
  int line = 0;
  int hclass = 0;
  int read = 0;
  char *linebuf = NULL;
  char *p = NULL;
  size_t buflen = 0;
  bool regen_file = false;
  struct HashTable *dup_hashes[HC_MAX] = { 0 };
 
  const char *const c_history_file = cs_subset_path(NeoMutt->sub, "history_file");
  FILE *fp = mutt_file_fopen(c_history_file, "r");
  if (!fp)
    return;
 
  /* If duplicate removal is enabled, build per-class hash tables to track
   * how many times each history entry appears in the file */
  const bool c_history_remove_dups = cs_subset_bool(NeoMutt->sub, "history_remove_dups");
  const short c_save_history = cs_subset_number(NeoMutt->sub, "save_history");
  if (c_history_remove_dups)
  {
    for (hclass = 0; hclass < HC_MAX; hclass++)
      dup_hashes[hclass] = mutt_hash_new(MAX(10, c_save_history * 2), MUTT_HASH_STRDUP_KEYS);
  }
 
  /* First pass: count entries per class, detect duplicates, and validate
   * the file format (each line is "class:entry|") */
  while ((linebuf = mutt_file_read_line(linebuf, &buflen, fp, &line, MUTT_RL_NONE)))
  {
    if ((sscanf(linebuf, "%d:%n", &hclass, &read) < 1) || (read == 0) ||
        (*(p = linebuf + strlen(linebuf) - 1) != '|') || (hclass < 0))
    {
      mutt_error(_("%s:%d: Bad history file format"), c_history_file, line);
      regen_file = true;
      continue;
    }
    /* silently ignore too high class (probably newer neomutt) */
    if (hclass >= HC_MAX)
      continue;
    *p = '\0';
    if (c_history_remove_dups && (dup_hash_inc(dup_hashes[hclass], linebuf + read) > 1))
    {
      regen_file = true;
      continue;
    }
    n[hclass]++;
  }
 
  if (!regen_file)
  {
    for (hclass = HC_FIRST; hclass < HC_MAX; hclass++)
    {
      if (n[hclass] > c_save_history)
      {
        regen_file = true;
        break;
      }
    }
  }
 
  if (regen_file)
  {
    /* Second pass: rewrite the file keeping only the most recent
     * c_save_history entries per class, omitting duplicates */
    fp_tmp = mutt_file_mkstemp();
    if (!fp_tmp)
    {
      mutt_perror(_("Can't create temporary file"));
      goto cleanup;
    }
    fseek(fp, 0, SEEK_SET);
    clearerr(fp);
    line = 0;
    while ((linebuf = mutt_file_read_line(linebuf, &buflen, fp, &line, MUTT_RL_NONE)))
    {
      if ((sscanf(linebuf, "%d:%n", &hclass, &read) < 1) || (read == 0) ||
          (*(p = linebuf + strlen(linebuf) - 1) != '|') || (hclass < 0))
      {
        continue;
      }
      if (hclass >= HC_MAX)
        continue;
      *p = '\0';
      if (c_history_remove_dups && (dup_hash_dec(dup_hashes[hclass], linebuf + read) > 0))
      {
        continue;
      }
      *p = '|';
      if (n[hclass]-- <= c_save_history)
        fprintf(fp_tmp, "%s\n", linebuf);
    }
  }
 
cleanup:
  mutt_file_fclose(&fp);
  FREE(&linebuf);
  if (fp_tmp)
  {
    if (fflush(fp_tmp) == 0)
    {
      fp = mutt_file_fopen(c_history_file, "w");
      if (fp)
      {
        fseek(fp_tmp, 0, SEEK_SET);
        clearerr(fp_tmp);
        mutt_file_copy_stream(fp_tmp, fp);
        mutt_file_fclose(&fp);
      }
    }
    mutt_file_fclose(&fp_tmp);
  }
  if (c_history_remove_dups)
    for (hclass = 0; hclass < HC_MAX; hclass++)
      mutt_hash_free(&dup_hashes[hclass]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

save_history()

void save_history ( enum HistoryClass hclass, const char * str )

static

Save one history string to a file.

Parameters

hclass	History type
str	String to save

Definition at line 310 of file history.c.

{
  if (!str || (*str == '\0')) // This shouldn't happen, but it's safer
    return;
 
  const char *const c_history_file = cs_subset_path(NeoMutt->sub, "history_file");
  FILE *fp = mutt_file_fopen(c_history_file, "a");
  if (!fp)
    return;
 
  char *tmp = mutt_str_dup(str);
  mutt_ch_convert_string(&tmp, cc_charset(), "utf-8", MUTT_ICONV_NONE);
 
  // If tmp contains '\n' terminate it there.
  char *nl = strchr(tmp, '\n');
  if (nl)
    *nl = '\0';
 
  /* Format of a history item (1 line): "<histclass>:<string>|".
   * We add a '|' in order to avoid lines ending with '\'. */
  fprintf(fp, "%d:%s|\n", (int) hclass, tmp);
 
  mutt_file_fclose(&fp);
  FREE(&tmp);
 
  shrink_histfile();
}

Here is the call graph for this function:

Here is the caller graph for this function:

remove_history_dups()

void remove_history_dups ( enum HistoryClass hclass, const char * str )

static

De-dupe the history.

Parameters

hclass	History to de-dupe
str	String to find

If the string is found, it is removed from the history.

When removing dups, we want the created "blanks" to be right below the resulting h->last position. See the comment section above 'struct History'.

Definition at line 348 of file history.c.

{
  struct History *h = get_history(hclass);
  if (!h)
    return; /* disabled */
 
  /* Remove dups from 0..last-1 compacting up. */
  int source = 0;
  int dest = 0;
  while (source < h->last)
  {
    if (mutt_str_equal(h->hist[source], str))
      FREE(&h->hist[source++]);
    else
      h->hist[dest++] = h->hist[source++];
  }
 
  /* Move 'last' entry up. */
  h->hist[dest] = h->hist[source];
  int old_last = h->last;
  h->last = dest;
 
  /* Fill in moved entries with NULL */
  while (source > h->last)
    h->hist[source--] = NULL;
 
  /* Remove dups from last+1 .. `$history` compacting down. */
  const short c_history = cs_subset_number(NeoMutt->sub, "history");
  source = c_history;
  dest = c_history;
  while (source > old_last)
  {
    if (mutt_str_equal(h->hist[source], str))
      FREE(&h->hist[source--]);
    else
      h->hist[dest--] = h->hist[source--];
  }
 
  /* Fill in moved entries with NULL */
  while (dest > old_last)
    h->hist[dest--] = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hist_search()

int mutt_hist_search	(	const char *	find,
		enum HistoryClass	hclass,
		struct StringArray *	matches )

Find matches in a history list.

Parameters

[in]	find	String to find
[in]	hclass	History list
[out]	matches	All the matching lines

Return values

num	Matches found

Definition at line 398 of file history.c.

{
  if (!find || !matches)
    return 0;
 
  struct History *h = get_history(hclass);
  if (!h)
    return 0;
 
  int cur = h->last;
  const short c_history = cs_subset_number(NeoMutt->sub, "history");
 
  do
  {
    cur--;
    if (cur < 0)
      cur = c_history;
 
    if (cur == h->last)
      break;
 
    if (mutt_istr_find(h->hist[cur], find))
      ARRAY_ADD(matches, h->hist[cur]);
 
  } while (ARRAY_SIZE(matches) < c_history);
 
  return ARRAY_SIZE(matches);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hist_cleanup()

void mutt_hist_cleanup

(

struct HistoryModuleData *

mod_data

)

Free all the history lists.

Parameters

mod_data

History module data

Definition at line 431 of file history.c.

{
  for (enum HistoryClass hclass = HC_FIRST; hclass < HC_MAX; hclass++)
  {
    struct History *h = &mod_data->histories[hclass];
    if (!h->hist)
      continue;
 
    /* The array has (mod_data->old_size+1) elements */
    for (int i = 0; i <= mod_data->old_size; i++)
    {
      FREE(&h->hist[i]);
    }
    FREE(&h->hist);
  }
}

Here is the caller graph for this function:

mutt_hist_init()

void mutt_hist_init

(

struct HistoryModuleData *

mod_data

)

Create a set of empty History ring buffers.

Parameters

mod_data

History module data

This just creates empty histories. To fill them, call mutt_hist_read_file().

Definition at line 455 of file history.c.

{
  const short c_history = cs_subset_number(NeoMutt->sub, "history");
  if (c_history == mod_data->old_size)
    return;
 
  for (enum HistoryClass hclass = HC_FIRST; hclass < HC_MAX; hclass++)
    init_history(&mod_data->histories[hclass], mod_data->old_size);
 
  mod_data->old_size = c_history;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hist_add()

void mutt_hist_add	(	enum HistoryClass	hclass,
		const char *	str,
		bool	save )

Add a string to a history.

Parameters

hclass	History to add to
str	String to add
save	Should the changes be saved to file immediately?

Definition at line 473 of file history.c.

{
  struct History *h = get_history(hclass);
  if (!h)
    return; /* disabled */
 
  if (str && *str)
  {
    int prev = h->last - 1;
    const short c_history = cs_subset_number(NeoMutt->sub, "history");
    if (prev < 0)
      prev = c_history;
 
    /* don't add to prompt history:
     *  - lines beginning by a space
     *  - repeated lines */
    if ((*str != ' ') && (!h->hist[prev] || !mutt_str_equal(h->hist[prev], str)))
    {
      const bool c_history_remove_dups = cs_subset_bool(NeoMutt->sub, "history_remove_dups");
      if (c_history_remove_dups)
        remove_history_dups(hclass, str);
      const short c_save_history = cs_subset_number(NeoMutt->sub, "save_history");
      const char *const c_history_file = cs_subset_path(NeoMutt->sub, "history_file");
      if (save && (c_save_history != 0) && c_history_file)
        save_history(hclass, str);
      mutt_str_replace(&h->hist[h->last++], str);
      if (h->last > c_history)
        h->last = 0;
    }
  }
  h->cur = h->last; /* reset to the last entry */
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hist_next()

char * mutt_hist_next

(

enum HistoryClass

hclass

)

Get the next string in a History.

Parameters

hclass

History to choose

Return values

ptr	Next string

If there is no next string, and empty string will be returned.

Definition at line 513 of file history.c.

{
  struct History *h = get_history(hclass);
  if (!h)
    return ""; /* disabled */
 
  int next = h->cur;
  const short c_history = cs_subset_number(NeoMutt->sub, "history");
  do
  {
    next++;
    if (next > c_history)
      next = 0;
    if (next == h->last)
      break;
  } while (!h->hist[next]);
 
  h->cur = next;
  return NONULL(h->hist[h->cur]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hist_prev()

char * mutt_hist_prev

(

enum HistoryClass

hclass

)

Get the previous string in a History.

Parameters

hclass

History to choose

Return values

ptr	Previous string

If there is no previous string, and empty string will be returned.

Definition at line 541 of file history.c.

{
  struct History *h = get_history(hclass);
  if (!h)
    return ""; /* disabled */
 
  int prev = h->cur;
  const short c_history = cs_subset_number(NeoMutt->sub, "history");
  do
  {
    prev--;
    if (prev < 0)
      prev = c_history;
    if (prev == h->last)
      break;
  } while (!h->hist[prev]);
 
  h->cur = prev;
  return NONULL(h->hist[h->cur]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hist_reset_state()

void mutt_hist_reset_state

(

enum HistoryClass

hclass

)

Move the 'current' position to the end of the History.

Parameters

hclass

History to reset

After calling mutt_hist_next() and mutt_hist_prev(), this function resets the current position ('cur' pointer).

Definition at line 569 of file history.c.

{
  struct History *h = get_history(hclass);
  if (!h)
    return; /* disabled */
 
  h->cur = h->last;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hist_read_file()

void mutt_hist_read_file

(

void

)

Read the History from a file.

The file $history_file is read and parsed into separate History ring buffers.

Definition at line 583 of file history.c.

{
  const char *const c_history_file = cs_subset_path(NeoMutt->sub, "history_file");
  if (!c_history_file)
    return;
 
  FILE *fp = mutt_file_fopen(c_history_file, "r");
  if (!fp)
    return;
 
  int line = 0;
  int hclass = 0;
  int read = 0;
  char *linebuf = NULL;
  char *p = NULL;
  size_t buflen = 0;
 
  const char *const c_charset = cc_charset();
  while ((linebuf = mutt_file_read_line(linebuf, &buflen, fp, &line, MUTT_RL_NONE)))
  {
    read = 0;
    if ((sscanf(linebuf, "%d:%n", &hclass, &read) < 1) || (read == 0) ||
        (*(p = linebuf + strlen(linebuf) - 1) != '|') || (hclass < 0))
    {
      mutt_error(_("%s:%d: Bad history file format"), c_history_file, line);
      continue;
    }
    /* silently ignore too high class (probably newer neomutt) */
    if (hclass >= HC_MAX)
      continue;
    *p = '\0';
    p = mutt_str_dup(linebuf + read);
    if (p)
    {
      mutt_ch_convert_string(&p, "utf-8", c_charset, MUTT_ICONV_NONE);
      mutt_hist_add(hclass, p, false);
      FREE(&p);
    }
  }
 
  mutt_file_fclose(&fp);
  FREE(&linebuf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hist_at_scratch()

bool mutt_hist_at_scratch

(

enum HistoryClass

hclass

)

Is the current History position at the 'scratch' place?

Parameters

hclass

History to use

Return values

true	History is at 'scratch' place

The last entry in the history is used as a 'scratch' area. It can be overwritten as the user types and edits.

To get (back) to the scratch area, call mutt_hist_next(), mutt_hist_prev() or mutt_hist_reset_state().

Definition at line 638 of file history.c.

{
  struct History *h = get_history(hclass);
  if (!h)
    return false; /* disabled */
 
  return h->cur == h->last;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hist_save_scratch()

void mutt_hist_save_scratch	(	enum HistoryClass	hclass,
		const char *	str )

Save a temporary string to the History.

Parameters

hclass	History to alter
str	String to set

Write a 'scratch' string into the History's current position. This is useful to preserver a user's edits.

Definition at line 655 of file history.c.

{
  struct History *h = get_history(hclass);
  if (!h)
    return; /* disabled */
 
  /* Don't check if str has a value because the scratch buffer may contain
   * an old garbage value that should be overwritten */
  mutt_str_replace(&h->hist[h->last], str);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hist_complete()

void mutt_hist_complete	(	struct Buffer *	buf,
		enum HistoryClass	hclass )

Complete a string from a history list.

Parameters

buf	Buffer in which to save string
hclass	History list to use

Definition at line 671 of file history.c.

{
  struct StringArray matches = ARRAY_HEAD_INITIALIZER;
 
  int match_count = mutt_hist_search(buf_string(buf), hclass, &matches);
  if (match_count != 0)
  {
    if (match_count == 1)
    {
      const char **pstr = ARRAY_GET(&matches, 0);
      buf_strcpy(buf, *pstr);
    }
    else
    {
      dlg_history(buf, &matches);
    }
  }
 
  ARRAY_FREE(&matches);
}

Here is the call graph for this function:

Here is the caller graph for this function: