NeoMutt  2024-11-14-138-ge5ca67
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
lib.h File Reference

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

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

Data Structures

struct  HistoryEntry
 A line in the History menu. More...
 

Enumerations

enum  HistoryClass {
  HC_EXT_COMMAND , HC_ALIAS , HC_NEO_COMMAND , HC_FILE ,
  HC_PATTERN , HC_OTHER , HC_MAILBOX , HC_MAX
}
 Type to differentiate different histories. More...
 
enum  ExpandoDataHistory { ED_HIS_MATCH = 1 , ED_HIS_NUMBER }
 Expando UIDs for History. More...
 

Functions

void mutt_hist_add (enum HistoryClass hclass, const char *str, bool save)
 Add a string to a history.
 
bool mutt_hist_at_scratch (enum HistoryClass hclass)
 Is the current History position at the 'scratch' place?
 
void mutt_hist_cleanup (void)
 Free all the history lists.
 
void mutt_hist_init (void)
 Create a set of empty History ring buffers.
 
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_read_file (void)
 Read the History from a file.
 
void mutt_hist_reset_state (enum HistoryClass hclass)
 Move the 'current' position to the end of the History.
 
void mutt_hist_save_scratch (enum HistoryClass hclass, const char *str)
 Save a temporary string to the History.
 
int mutt_hist_search (const char *find, enum HistoryClass hclass, struct HistoryArray *matches)
 Find matches in a history list.
 
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 -.
 
void dlg_history (struct Buffer *buf, struct HistoryArray *matches)
 Select an item from a history list -.
 

Detailed Description

Read/write command history from/to a file.

Authors
  • Richard Russon

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

Type to differentiate different histories.

Saved lists of recently-used:

Enumerator
HC_EXT_COMMAND 

External commands.

HC_ALIAS 

Aliases.

HC_NEO_COMMAND 

NeoMutt commands.

HC_FILE 

Files.

HC_PATTERN 

Patterns.

HC_OTHER 

Miscellaneous strings.

HC_MAILBOX 

Mailboxes.

HC_MAX 

Definition at line 51 of file lib.h.

52{
54 HC_ALIAS,
56 HC_FILE,
58 HC_OTHER,
60 HC_MAX,
61};
@ HC_FILE
Files.
Definition: lib.h:56
@ HC_EXT_COMMAND
External commands.
Definition: lib.h:53
@ HC_MAILBOX
Mailboxes.
Definition: lib.h:59
@ HC_ALIAS
Aliases.
Definition: lib.h:54
@ HC_NEO_COMMAND
NeoMutt commands.
Definition: lib.h:55
@ HC_MAX
Definition: lib.h:60
@ HC_PATTERN
Patterns.
Definition: lib.h:57
@ HC_OTHER
Miscellaneous strings.
Definition: lib.h:58

◆ ExpandoDataHistory

Expando UIDs for History.

See also
ED_HISTORY, ExpandoDomain
Enumerator
ED_HIS_MATCH 

HistoryEntry.history.

ED_HIS_NUMBER 

HistoryEntry.num.

Definition at line 77 of file lib.h.

78{
79 ED_HIS_MATCH = 1,
81};
@ ED_HIS_MATCH
HistoryEntry.history.
Definition: lib.h:79
@ ED_HIS_NUMBER
HistoryEntry.num.
Definition: lib.h:80

Function Documentation

◆ mutt_hist_add()

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

Add a string to a history.

Parameters
hclassHistory to add to
strString to add
saveShould the changes be saved to file immediately?

Definition at line 494 of file history.c.

495{
496 struct History *h = get_history(hclass);
497 if (!h)
498 return; /* disabled */
499
500 if (*str)
501 {
502 int prev = h->last - 1;
503 const short c_history = cs_subset_number(NeoMutt->sub, "history");
504 if (prev < 0)
505 prev = c_history;
506
507 /* don't add to prompt history:
508 * - lines beginning by a space
509 * - repeated lines */
510 if ((*str != ' ') && (!h->hist[prev] || !mutt_str_equal(h->hist[prev], str)))
511 {
512 const bool c_history_remove_dups = cs_subset_bool(NeoMutt->sub, "history_remove_dups");
513 if (c_history_remove_dups)
514 remove_history_dups(hclass, str);
515 const short c_save_history = cs_subset_number(NeoMutt->sub, "save_history");
516 const char *const c_history_file = cs_subset_path(NeoMutt->sub, "history_file");
517 if (save && (c_save_history != 0) && c_history_file)
518 save_history(hclass, str);
519 mutt_str_replace(&h->hist[h->last++], str);
520 if (h->last > c_history)
521 h->last = 0;
522 }
523 }
524 h->cur = h->last; /* reset to the last entry */
525}
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:143
const char * cs_subset_path(const struct ConfigSubset *sub, const char *name)
Get a path config item by name.
Definition: helpers.c:168
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
static void remove_history_dups(enum HistoryClass hclass, const char *str)
De-dupe the history.
Definition: history.c:367
static struct History * get_history(enum HistoryClass hclass)
Get a particular history.
Definition: history.c:113
static void save_history(enum HistoryClass hclass, const char *str)
Save one history string to a file.
Definition: history.c:322
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:280
Saved list of user-entered commands/searches.
Definition: history.c:94
short cur
Current history item.
Definition: history.c:96
short last
Last history item.
Definition: history.c:97
char ** hist
Array of history items.
Definition: history.c:95
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ 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
hclassHistory to use
Return values
trueHistory 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 656 of file history.c.

657{
658 struct History *h = get_history(hclass);
659 if (!h)
660 return false; /* disabled */
661
662 return h->cur == h->last;
663}
+ 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 449 of file history.c.

450{
451 if (!NeoMutt)
452 return;
453
454 const short c_history = cs_subset_number(NeoMutt->sub, "history");
455 for (enum HistoryClass hclass = HC_FIRST; hclass < HC_MAX; hclass++)
456 {
457 struct History *h = &Histories[hclass];
458 if (!h->hist)
459 continue;
460
461 /* The array has (`$history`+1) elements */
462 for (int i = 0; i <= c_history; i++)
463 {
464 FREE(&h->hist[i]);
465 }
466 FREE(&h->hist);
467 }
468}
HistoryClass
Type to differentiate different histories.
Definition: lib.h:52
static struct History Histories[HC_MAX]
Command histories, one for each HistoryClass.
Definition: history.c:103
#define HC_FIRST
Definition: history.c:86
#define FREE(x)
Definition: memory.h:55
+ 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 476 of file history.c.

477{
478 const short c_history = cs_subset_number(NeoMutt->sub, "history");
479 if (c_history == OldSize)
480 return;
481
482 for (enum HistoryClass hclass = HC_FIRST; hclass < HC_MAX; hclass++)
483 init_history(&Histories[hclass]);
484
485 OldSize = c_history;
486}
static int OldSize
The previous number of history entries to save.
Definition: history.c:106
static void init_history(struct History *h)
Set up a new History ring buffer.
Definition: history.c:129
+ 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
hclassHistory to choose
Return values
ptrNext string

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

Definition at line 534 of file history.c.

535{
536 struct History *h = get_history(hclass);
537 if (!h)
538 return ""; /* disabled */
539
540 int next = h->cur;
541 const short c_history = cs_subset_number(NeoMutt->sub, "history");
542 do
543 {
544 next++;
545 if (next > c_history)
546 next = 0;
547 if (next == h->last)
548 break;
549 } while (!h->hist[next]);
550
551 h->cur = next;
552 return NONULL(h->hist[h->cur]);
553}
#define NONULL(x)
Definition: string2.h:37
+ 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
hclassHistory to choose
Return values
ptrPrevious string

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

Definition at line 562 of file history.c.

563{
564 struct History *h = get_history(hclass);
565 if (!h)
566 return ""; /* disabled */
567
568 int prev = h->cur;
569 const short c_history = cs_subset_number(NeoMutt->sub, "history");
570 do
571 {
572 prev--;
573 if (prev < 0)
574 prev = c_history;
575 if (prev == h->last)
576 break;
577 } while (!h->hist[prev]);
578
579 h->cur = prev;
580 return NONULL(h->hist[h->cur]);
581}
+ 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 604 of file history.c.

605{
606 const char *const c_history_file = cs_subset_path(NeoMutt->sub, "history_file");
607 if (!c_history_file)
608 return;
609
610 FILE *fp = mutt_file_fopen(c_history_file, "r");
611 if (!fp)
612 return;
613
614 int line = 0, hclass = 0, read = 0;
615 char *linebuf = NULL, *p = NULL;
616 size_t buflen;
617
618 const char *const c_charset = cc_charset();
619 while ((linebuf = mutt_file_read_line(linebuf, &buflen, fp, &line, MUTT_RL_NO_FLAGS)))
620 {
621 read = 0;
622 if ((sscanf(linebuf, "%d:%n", &hclass, &read) < 1) || (read == 0) ||
623 (*(p = linebuf + strlen(linebuf) - 1) != '|') || (hclass < 0))
624 {
625 mutt_error(_("%s:%d: Bad history file format"), c_history_file, line);
626 continue;
627 }
628 /* silently ignore too high class (probably newer neomutt) */
629 if (hclass >= HC_MAX)
630 continue;
631 *p = '\0';
632 p = mutt_str_dup(linebuf + read);
633 if (p)
634 {
635 mutt_ch_convert_string(&p, "utf-8", c_charset, MUTT_ICONV_NO_FLAGS);
636 mutt_hist_add(hclass, p, false);
637 FREE(&p);
638 }
639 }
640
641 mutt_file_fclose(&fp);
642 FREE(&linebuf);
643}
const char * cc_charset(void)
Get the cached value of $charset.
Definition: config_cache.c:116
char * mutt_file_read_line(char *line, size_t *size, FILE *fp, int *line_num, ReadLineFlags flags)
Read a line from a file.
Definition: file.c:808
#define mutt_file_fclose(FP)
Definition: file.h:138
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:137
#define MUTT_RL_NO_FLAGS
No flags are set.
Definition: file.h:40
#define mutt_error(...)
Definition: logging2.h:92
void mutt_hist_add(enum HistoryClass hclass, const char *str, bool save)
Add a string to a history.
Definition: history.c:494
int mutt_ch_convert_string(char **ps, const char *from, const char *to, uint8_t flags)
Convert a string between encodings.
Definition: charset.c:831
#define MUTT_ICONV_NO_FLAGS
No flags are set.
Definition: charset.h:64
#define _(a)
Definition: message.h:28
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
+ 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
hclassHistory to reset

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

Definition at line 590 of file history.c.

591{
592 struct History *h = get_history(hclass);
593 if (!h)
594 return; /* disabled */
595
596 h->cur = h->last;
597}
+ 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
hclassHistory to alter
strString to set

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

Definition at line 673 of file history.c.

674{
675 struct History *h = get_history(hclass);
676 if (!h)
677 return; /* disabled */
678
679 /* Don't check if str has a value because the scratch buffer may contain
680 * an old garbage value that should be overwritten */
681 mutt_str_replace(&h->hist[h->last], str);
682}
+ 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]findString to find
[in]hclassHistory list
[out]matchesAll the matching lines
Return values
numMatches found

Definition at line 417 of file history.c.

418{
419 if (!find || !matches)
420 return 0;
421
422 struct History *h = get_history(hclass);
423 if (!h)
424 return 0;
425
426 int cur = h->last;
427 const short c_history = cs_subset_number(NeoMutt->sub, "history");
428
429 do
430 {
431 cur--;
432 if (cur < 0)
433 cur = c_history;
434
435 if (cur == h->last)
436 break;
437
438 if (mutt_istr_find(h->hist[cur], find))
439 ARRAY_ADD(matches, h->hist[cur]);
440
441 } while (ARRAY_SIZE(matches) < c_history);
442
443 return ARRAY_SIZE(matches);
444}
#define ARRAY_ADD(head, elem)
Add an element at the end of the array.
Definition: array.h:156
#define ARRAY_SIZE(head)
The number of elements stored.
Definition: array.h:87
const char * mutt_istr_find(const char *haystack, const char *needle)
Find first occurrence of string (ignoring case)
Definition: string.c:521
+ 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
bufBuffer in which to save string
hclassHistory list to use

Definition at line 689 of file history.c.

690{
691 struct HistoryArray matches = ARRAY_HEAD_INITIALIZER;
692
693 int match_count = mutt_hist_search(buf_string(buf), hclass, &matches);
694 if (match_count != 0)
695 {
696 if (match_count == 1)
697 {
698 const char **pstr = ARRAY_GET(&matches, 0);
699 buf_strcpy(buf, *pstr);
700 }
701 else
702 {
703 dlg_history(buf, &matches);
704 }
705 }
706
707 ARRAY_FREE(&matches);
708}
#define ARRAY_FREE(head)
Release all memory.
Definition: array.h:204
#define ARRAY_GET(head, idx)
Return the element at index.
Definition: array.h:109
#define ARRAY_HEAD_INITIALIZER
Static initializer for arrays.
Definition: array.h:58
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
void dlg_history(struct Buffer *buf, struct HistoryArray *matches)
Select an item from a history list -.
Definition: dlg_history.c:119
int mutt_hist_search(const char *find, enum HistoryClass hclass, struct HistoryArray *matches)
Find matches in a history list.
Definition: history.c:417
+ Here is the call graph for this function:
+ Here is the caller graph for this function: