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 "functions.h"

Include dependency graph for history.c:

Go to the source code of this file.

Data Structures
struct	History
	Saved list of user-entered commands/searches. More...

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)
	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 HistoryArray *matches)
	Find matches in a history list.
void	mutt_hist_cleanup (void)
	Free all the history lists.
void	mutt_hist_init (void)
	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 -.

Variables
static struct History	Histories [HC_MAX]
	Command histories, one for each HistoryClass.
static int	OldSize = 0
	The previous number of history entries to save.

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()

static 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 111 of file history.c.

{
  const short c_history = cs_subset_number(NeoMutt->sub, "history");
  if ((hclass >= HC_MAX) || (c_history == 0))
    return NULL;
 
  struct History *hist = &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()

static void init_history ( struct History *  h )

static

Set up a new History ring buffer.

Parameters

h	History to populate

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

Definition at line 127 of file history.c.

{
  if (OldSize != 0)
  {
    if (h->hist)
    {
      for (int i = 0; i <= OldSize; 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()

static 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 157 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()

static 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 183 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()

static void shrink_histfile ( void  )

static

Read, de-dupe and write the history file.

Definition at line 204 of file history.c.

{
  FILE *fp_tmp = NULL;
  int n[HC_MAX] = { 0 };
  int line, hclass = 0, read = 0;
  char *linebuf = NULL, *p = NULL;
  size_t buflen;
  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;
 
  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);
  }
 
  line = 0;
  while ((linebuf = mutt_file_read_line(linebuf, &buflen, fp, &line, MUTT_RL_NO_FLAGS)))
  {
    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)
  {
    fp_tmp = mutt_file_mkstemp();
    if (!fp_tmp)
    {
      mutt_perror(_("Can't create temporary file"));
      goto cleanup;
    }
    rewind(fp);
    line = 0;
    while ((linebuf = mutt_file_read_line(linebuf, &buflen, fp, &line, MUTT_RL_NO_FLAGS)))
    {
      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)
      {
        rewind(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()

static 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 318 of file history.c.

{
  static int n = 0;
 
  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_NO_FLAGS);
 
  // 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);
 
  if (--n < 0)
  {
    const short c_save_history = cs_subset_number(NeoMutt->sub, "save_history");
    n = c_save_history;
    shrink_histfile();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

remove_history_dups()

static 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 363 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 HistoryArray *	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 413 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

(

void

)

Free all the history lists.

Definition at line 445 of file history.c.

{
  if (!NeoMutt)
    return;
 
  const short c_history = cs_subset_number(NeoMutt->sub, "history");
  for (enum HistoryClass hclass = HC_FIRST; hclass < HC_MAX; hclass++)
  {
    struct History *h = &Histories[hclass];
    if (!h->hist)
      continue;
 
    /* The array has (`$history`+1) elements */
    for (int i = 0; i <= c_history; i++)
    {
      FREE(&h->hist[i]);
    }
    FREE(&h->hist);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_hist_init()

void mutt_hist_init

(

void

)

Create a set of empty History ring buffers.

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

Definition at line 472 of file history.c.

{
  const short c_history = cs_subset_number(NeoMutt->sub, "history");
  if (c_history == OldSize)
    return;
 
  for (enum HistoryClass hclass = HC_FIRST; hclass < HC_MAX; hclass++)
    init_history(&Histories[hclass]);
 
  OldSize = 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 490 of file history.c.

{
  struct History *h = get_history(hclass);
  if (!h)
    return; /* disabled */
 
  if (*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 530 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 558 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 586 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 600 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, hclass = 0, read = 0;
  char *linebuf = NULL, *p = NULL;
  size_t buflen;
 
  const char *const c_charset = cc_charset();
  while ((linebuf = mutt_file_read_line(linebuf, &buflen, fp, &line, MUTT_RL_NO_FLAGS)))
  {
    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_NO_FLAGS);
      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 652 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 669 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 685 of file history.c.

{
  struct HistoryArray 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:

Variable Documentation

Histories

struct History Histories[HC_MAX]

static

Command histories, one for each HistoryClass.

Definition at line 101 of file history.c.

OldSize

int OldSize = 0

static

The previous number of history entries to save.

See also

$history

Definition at line 104 of file history.c.