|
72
|
1 ;;; history.el --- Generic history stuff
|
|
|
2
|
|
0
|
3 ;; Copyright (C) 1989 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 ;; This file is part of XEmacs.
|
|
|
6
|
|
|
7 ;; XEmacs is free software; you can redistribute it and/or modify it
|
|
|
8 ;; under the terms of the GNU General Public License as published by
|
|
|
9 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
10 ;; any later version.
|
|
|
11
|
|
|
12 ;; XEmacs is distributed in the hope that it will be useful, but
|
|
|
13 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
15 ;; General Public License for more details.
|
|
|
16
|
|
|
17 ;; You should have received a copy of the GNU General Public License
|
|
72
|
18 ;; along with XEmacs; see the file COPYING. If not, write to the Free
|
|
|
19 ;; Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
20
|
|
|
21 ;;; Synched up with: Not in FSF
|
|
|
22
|
|
|
23 ;;; Commentary:
|
|
0
|
24
|
|
|
25 ;; suggested generic history stuff -- tale
|
|
|
26
|
|
|
27 ;; This is intended to provided easy access to a list of elements
|
|
|
28 ;; being kept as a history ring.
|
|
|
29
|
|
|
30 ;; To use, variables for a list and the index to it need to be kept, and
|
|
|
31 ;; a limit to how large the list can grow. Short wrappers can than be provided
|
|
|
32 ;; to interact with these functions.
|
|
|
33
|
|
|
34 ;; For example, a typical application of this is in interactive processes,
|
|
|
35 ;; like shell or gdb. A history can be kept of commands that are sent
|
|
|
36 ;; to the process so that they are easily retrieved for re-inspection or
|
|
|
37 ;; re-use. Using process "foo" to illustrate:
|
|
|
38
|
|
|
39 ;; Variable foo-history will be the list. foo-history-index would be the
|
|
|
40 ;; pointer to the current item within the list; it is based with 0 being
|
|
|
41 ;; the most recent element added to the list. foo-history-size can be a
|
|
|
42 ;; user-variable which controls how many items are allowed to exist.
|
|
|
43
|
|
|
44 ;; The following functions could interactive with the list; foo-mark
|
|
|
45 ;; in these examples trackes the end of output from foo-process.
|
|
|
46
|
|
|
47 ;; (defun foo-history-previous (arg) ;; Suggested binding: C-c C-p
|
|
|
48 ;; "Retrieve the previous command sent to the foo process.
|
|
|
49 ;; ARG means to select that message out of the list (0 is the first)."
|
|
|
50 ;; (interactive "P")
|
|
|
51 ;; (history-fetch 'foo-history 'foo-history-index (or arg 'previous)
|
|
|
52 ;; foo-mark (point-max)))
|
|
|
53
|
|
|
54 ;; foo-history-next would look practically the same, but substituting "next"
|
|
|
55 ;; for "previous". Suggested binding: C-c C-n
|
|
|
56
|
|
|
57 ;; (defun foo-history-clear () ;; Suggested binding: C-c C-u
|
|
|
58 ;; "Clear the input region for the foo-process and reset history location."
|
|
|
59 ;; (interactive)
|
|
|
60 ;; (delete-region foo-mark (goto-char (point-max))))
|
|
|
61
|
|
|
62 ;; To get the history on the stack, an extremely minimal function would look
|
|
|
63 ;; something like this, probably bound to RET:
|
|
|
64
|
|
|
65 ;; (defun foo-send ()
|
|
|
66 ;; "Send a command to foo-process."
|
|
|
67 ;; (interactive)
|
|
|
68 ;; (let ((str (buffer-substring foo-mark (goto-char (point-max)))))
|
|
|
69 ;; (insert ?\C-j)
|
|
|
70 ;; (setq foo-history-index -1) ; reset the index
|
|
|
71 ;; (set-marker foo-mark (point))
|
|
|
72 ;; (send-string foo-process str)
|
|
|
73 ;; (history-add 'foo-history str foo-history-size)))
|
|
|
74
|
|
|
75 ;; ToDo: history-isearch
|
|
|
76
|
|
72
|
77 ;;; Code:
|
|
|
78
|
|
0
|
79 (provide 'history)
|
|
|
80
|
|
|
81 (defvar history-last-search ""
|
|
|
82 "The last regexp used by history-search which resulted in a match.")
|
|
|
83
|
|
|
84 (defun history-add (list item size)
|
|
|
85 "At the head of LIST append ITEM. Limit the length of LIST to SIZE elements.
|
|
|
86 LIST should be the name of the list."
|
|
|
87 (set list (append (list item) (eval list)))
|
|
|
88 (let ((elist (eval list)))
|
|
|
89 (if (> (length elist) size)
|
|
|
90 (setcdr (nthcdr (1- size) elist) nil))))
|
|
|
91
|
|
|
92 (defun history-fetch (list index dir &optional beg end)
|
|
|
93 "Retrieve an entry from LIST, working from INDEX in direction DIR.
|
|
|
94 LIST should be the name of the list, for message purposes. INDEX should be
|
|
|
95 the name of the variable used to index the list, so it can be maintained.
|
|
|
96 DIR non-nil means to use previous entry, unless it is the symbol ``next''
|
|
|
97 to get the next entry or a number to get an absolute reference. DIR
|
|
|
98 nil is equivalent to ``next''.
|
|
|
99
|
|
|
100 If optional numeric argument BEG is preset, it is taken as the point to insert
|
|
|
101 the entry in the current buffer, leaving point at the start of the entry.
|
|
|
102 If followed by a numeric END, the region between BEG and END will be deleted
|
|
|
103 before the entry is inserted."
|
|
|
104 (let (str (eind (eval index)) (elist (eval list)))
|
|
|
105 (cond
|
|
|
106 ((numberp dir)
|
|
|
107 (setq str (nth dir elist))
|
|
|
108 (if str (set index dir) (message "No entry %d in %s." dir list)))
|
|
|
109 ((or (not dir) (eq dir 'next))
|
|
|
110 (if (= eind -1)
|
|
|
111 (message "No next entry in %s." list)
|
|
|
112 (set index (1- eind))
|
|
|
113 (setq str (if (zerop eind) "" (nth (1- eind) elist)))))
|
|
|
114 (t
|
|
|
115 (if (>= (1+ eind) (length elist))
|
|
|
116 (message "No previous entry in %s." list)
|
|
|
117 (set index (1+ eind))
|
|
|
118 (setq str (nth (1+ eind) elist)))))
|
|
|
119 (if (not (and (integer-or-marker-p beg) str)) ()
|
|
|
120 (if (integer-or-marker-p end) (delete-region beg end))
|
|
|
121 (insert str)
|
|
|
122 (goto-char beg))
|
|
|
123 str))
|
|
|
124
|
|
|
125 (defun history-search (list index dir regexp &optional beg end)
|
|
|
126 "In history LIST, starting at INDEX and working in direction DIR, find REGEXP.
|
|
|
127 LIST and INDEX should be their respective symbol names. DIR nil or 'forward
|
|
|
128 means to search from the current index toward the most recent history entry.
|
|
|
129 DIR non-nil means to search toward the oldest entry. The current entry is
|
|
|
130 not checked in either case.
|
|
|
131
|
|
|
132 If an entry is found and optional numeric argument BEG exists then the entry
|
|
|
133 will be inserted there and point left at BEG. If numeric END also exists
|
|
|
134 then the region will be deleted between BEG and END."
|
|
|
135 (let* ((forw (or (not dir) (eq dir 'forward))) str found
|
|
|
136 (eind (eval index))
|
|
|
137 (elist (eval list))
|
|
|
138 (slist (if forw
|
|
|
139 (nthcdr (- (length elist) eind) (reverse elist))
|
|
|
140 (nthcdr (1+ eind) elist))))
|
|
|
141 (while (and (not found) slist)
|
|
|
142 (if (string-match regexp (car slist))
|
|
|
143 (setq found (car slist)
|
|
|
144 history-last-search regexp))
|
|
|
145 (setq eind (+ (if forw -1 1) eind)
|
|
|
146 slist (cdr slist)))
|
|
|
147 (if (not found)
|
|
|
148 (error "\"%s\" not found %s in %s"
|
|
|
149 regexp (if forw "forward" "backward") list)
|
|
|
150 (set index eind)
|
|
|
151 (if (not (integer-or-marker-p beg)) ()
|
|
|
152 (if (integer-or-marker-p end) (delete-region beg end))
|
|
|
153 (insert found)
|
|
|
154 (goto-char beg)))
|
|
|
155 found))
|
|
|
156
|
|
|
157 (defun history-menu (list buffer &optional notemp)
|
|
|
158 "Show the history kept by LIST in BUFFER.
|
|
|
159 This function will use ``with-output-to-temp-buffer'' unless optional third
|
|
|
160 argument NOTEMP is non-nil."
|
|
|
161 (let ((pop-up-windows t) (line 0)
|
|
|
162 (menu
|
|
|
163 (mapconcat (function (lambda (item)
|
|
|
164 (setq line (1+ line))
|
|
|
165 (format (format "%%%dd: %%s"
|
|
|
166 (int-to-string (length list)))
|
|
|
167 line item)))
|
|
|
168 list "\n")))
|
|
|
169 (if notemp
|
|
|
170 (save-excursion
|
|
|
171 (insert menu)
|
|
|
172 (display-buffer buffer))
|
|
|
173 (with-output-to-temp-buffer buffer (princ menu)))))
|
|
72
|
174
|
|
|
175 ;;; history.el ends here
|
