lib.h File Reference

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

#include <stdbool.h>
#include <stdlib.h>

Include dependency graph for lib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum	HistoryClass {   HC_CMD , HC_ALIAS , HC_COMMAND , HC_FILE ,   HC_PATTERN , HC_OTHER , HC_MBOX , HC_MAX }
	Type to differentiate different histories. More...

Functions
void	mutt_hist_add (enum HistoryClass hclass, const char *str, bool save)
	Add a string to a history. More...
bool	mutt_hist_at_scratch (enum HistoryClass hclass)
	Is the current History position at the 'scratch' place? More...
void	mutt_hist_free (void)
	Free all the history lists. More...
void	mutt_hist_init (void)
	Create a set of empty History ring buffers. More...
char *	mutt_hist_next (enum HistoryClass hclass)
	Get the next string in a History. More...
char *	mutt_hist_prev (enum HistoryClass hclass)
	Get the previous string in a History. More...
void	mutt_hist_read_file (void)
	Read the History from a file. More...
void	mutt_hist_reset_state (enum HistoryClass hclass)
	Move the 'current' position to the end of the History. More...
void	mutt_hist_save_scratch (enum HistoryClass hclass, const char *str)
	Save a temporary string to the History. More...
int	mutt_hist_search (const char *search_buf, enum HistoryClass hclass, char **matches)
	Find matches in a history list. More...
void	dlg_select_history (char *buf, size_t buflen, char **matches, int match_count)
	Select an item from a history list. More...

Detailed Description

Read/write command history from/to a file.

Authors

• Michael R. Elkins

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 lib.h.

Enumeration Type Documentation

HistoryClass

enum HistoryClass

Type to differentiate different histories.

Saved lists of recently-used:

Enumerator
HC_CMD	External commands.
HC_ALIAS	Aliases.
HC_COMMAND	NeoMutt commands.
HC_FILE	Files.
HC_PATTERN	Patterns.
HC_OTHER	Miscellaneous strings.
HC_MBOX	Mailboxes.
HC_MAX

Definition at line 47 of file lib.h.

{
  HC_CMD,     
  HC_ALIAS,   
  HC_COMMAND, 
  HC_FILE,    
  HC_PATTERN, 
  HC_OTHER,   
  HC_MBOX,    
  HC_MAX,
};

Function Documentation

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 483 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_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 645 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_free()

void mutt_hist_free

(

void

)

Free all the history lists.

Definition at line 438 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 465 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_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 523 of file history.c.

{
  struct History *h = get_history(hclass);
  if (!h)
    return ""; /* disabled */
 
  int next = h->cur;
  do
  {
    next++;
    const short c_history = cs_subset_number(NeoMutt->sub, "history");
    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 551 of file history.c.

{
  struct History *h = get_history(hclass);
  if (!h)
    return ""; /* disabled */
 
  int prev = h->cur;
  do
  {
    prev--;
    const short c_history = cs_subset_number(NeoMutt->sub, "history");
    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_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 593 of file history.c.

{
  int line = 0, hclass, read;
  char *linebuf = NULL, *p = NULL;
  size_t buflen;
 
  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;
 
  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(_("Bad history file format (line %d)"), line);
      break;
    }
    /* silently ignore too high class (probably newer neomutt) */
    if (hclass >= HC_MAX)
      continue;
    *p = '\0';
    p = mutt_str_dup(linebuf + read);
    if (p)
    {
      const char *const c_charset = cs_subset_string(NeoMutt->sub, "charset");
      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_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 579 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_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 662 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_search()

int mutt_hist_search	(	const char *	search_buf,
		enum HistoryClass	hclass,
		char **	matches
	)

Find matches in a history list.

Parameters

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

Return values

num	Matches found

Definition at line 409 of file history.c.

{
  if (!search_buf || !matches)
    return 0;
 
  struct History *h = get_history(hclass);
  if (!h)
    return 0;
 
  int match_count = 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], search_buf))
      matches[match_count++] = h->hist[cur];
  } while (match_count < c_history);
 
  return match_count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dlg_select_history()

void dlg_select_history	(	char *	buf,
		size_t	buflen,
		char **	matches,
		int	match_count
	)

Select an item from a history list.

Parameters

[in]	buf	Buffer in which to save string
[in]	buflen	Buffer length
[out]	matches	Items to choose from
[in]	match_count	Number of items

Definition at line 129 of file dlg_history.c.

{
  struct MuttWindow *dlg = simple_dialog_new(MENU_GENERIC, WT_DLG_HISTORY, HistoryHelp);
 
  struct MuttWindow *sbar = window_find_child(dlg, WT_STATUS_BAR);
  char title[256] = { 0 };
  snprintf(title, sizeof(title), _("History '%s'"), buf);
  sbar_set_title(sbar, title);
 
  struct Menu *menu = dlg->wdata;
  menu->make_entry = history_make_entry;
  menu->max = match_count;
  menu->mdata = matches;
  menu->mdata_free = NULL; // Menu doesn't own the data
 
  struct HistoryData hd = { false, false,   buf,        buflen,
                            menu,  matches, match_count };
  dlg->wdata = &hd;
 
  // ---------------------------------------------------------------------------
  // Event Loop
  int op = OP_NULL;
  do
  {
    menu_tagging_dispatcher(menu->win, op);
    window_redraw(NULL);
 
    struct KeyEvent event = km_dokey_event(MENU_GENERIC);
    if (event.ch == 'q')
      op = OP_EXIT;
    else
      op = event.op;
 
    mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(op), op);
    if (op < 0)
      continue;
    if (op == OP_NULL)
    {
      km_error_key(MENU_GENERIC);
      continue;
    }
    mutt_clear_error();
 
    int rc = history_function_dispatcher(dlg, op);
 
    if (rc == FR_UNKNOWN)
      rc = menu_function_dispatcher(menu->win, op);
    if (rc == FR_UNKNOWN)
      rc = global_function_dispatcher(NULL, op);
  } while (!hd.done);
  // ---------------------------------------------------------------------------
 
  simple_dialog_free(&dlg);
}

Here is the call graph for this function:

Here is the caller graph for this function: