libtecla/common/history.c

52  * History lines are split into sub-strings of GLH_SEG_SIZE
74  * History lines are recorded in a hash table, such that repeated
75  * lines are stored just once.
96                          /*  the time-ordered list of history lines. */
111  * All history lines which hash to a given bucket in the hash table, are
115   GlhHashNode *lines;  /* The list of history lines which fall in this bucket */
129  * GlhLineNode's are used to record history lines in time order.
148  * Encapsulate the time-ordered list of historical lines.
157  * The _glh_lookup_history() returns copies of history lines in a
168  * Encapsulate all of the resources needed to store historical input lines.
173                        /* into lists of sub-strings recording input lines. */
176   GlhLineList list;    /* A time ordered list of history lines */
180   GlhLineHash hash;    /* A hash-table of reference-counted history lines */
187                        /*  history lines */
190                        /*  currently being used to record sub-lines */
192                        /*  not currently being used to record sub-lines */
195   int nline;           /* The number of lines currently in the history list */
196   int max_lines;       /* Either -1 or a ceiling on the number of lines */
245  *                       most recent lines of user input that will fit.
277     glh->hash.bucket[i].lines = NULL;
390  * Append a new line to the history list, deleting old lines to make
396  *  force      int    Unless this flag is non-zero, empty lines aren't
409   GlhLineNode *lnode; /* A node in the time-ordered list of lines */
450  * Has an upper limit to the number of lines in the history list been
455  * If necessary, remove old lines until there is room to add one new
461  * We can't archive the line if the maximum number of lines allowed is
478  * Allocate a new node in the time-ordered list of lines.
903  * Query the id of a history line offset by a given number of lines from
926  * Search forward 'offset' lines to find the required line.
1002  *  max_lines        int    The maximum number of lines to save, or -1
1003  *                          to save all of the lines in the history
1020   GlhLineNode *head; /* The head of the list of lines to be saved */
1038  * If a ceiling on the number of lines to save was specified, count
1039  * that number of lines backwards, to find the first line to be saved.
1141  * Restore previous history lines from a given file.
1149  *  line            char *  A buffer into which lines can be read.
1379  *                          with subsequent history lines, and subsequent
1380  *                          history searches will only return lines with
1448  *  all_groups      int    If true, display history lines from all
1451  *  max_lines       int    If max_lines is < 0, all available lines
1453  *                         recent max_lines lines will be displayed.
1517  * If the number of lines in the buffer doesn't exceed the specified
1524  * List the history lines in increasing time order.
1528  * Only display lines from the current history group, unless
1692  * Starting from the oldest line in the buffer, discard lines until
1712 	for(hnode=b->lines; hnode; hnode=hnode->next) {
1747  * Set an upper limit to the number of lines that can be recorded in the
1752  *  max_lines    int    The maximum number of lines to allow, or -1 to
1753  *                      cancel a previous limit and allow as many lines
1765  * Count successively older lines until we reach the start of the
1766  * list, or until we have seen max_lines lines (at which point 'node'
1774  * Discard any lines that exceed the limit.
1800  *                      clear only the stored lines associated with the
1816  * Delete all history lines regardless of group?
1820  * Claer the time-ordered list of lines.
1830       glh->hash.bucket[i].lines = NULL;
1849  * Just delete lines of the current group?
1894  *                        input lines.
2070  *                           of history lines in the list, or -1 if
2087  * Get the range of lines in the history buffer.
2094  *                           to *oldest, unless there are no lines, in
2098  *                           to *newest, unless there are no lines, in
2100  *  nlines            int *  The number of lines currently in the history
2195  * Discard the oldest history lines in the buffer until at least
2233     hnode->next = bucket->lines;
2234     bucket->lines = hnode;
2276     if(bucket->lines == hnode) {
2277       bucket->lines = hnode->next;
2280       for(prev=bucket->lines; prev && prev->next != hnode; prev=prev->next)
2358   GlhHashNode *node;  /* A node in the list of lines in the bucket */
2360  * Compare each of the lines in the list of lines, against 'line'.
2362   for(node=bucket->lines; node; node=node->next) {
2380  *  return         int     0 - The lines differ.
2381  *                         1 - The lines are the same.
2388  * Do the two lines have the same length?
2423  * is to be matched, and this matches all lines.
2428  * Wrap the two history lines that are to be compared in iterator
2487  * history list while other lines in the history list are being
2522  * to be incremented for permanently entered lines, decrement it again.