Lines Matching defs:lines
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.