|
0
|
1 ;;; -*- Mode:Emacs-Lisp -*-
|
|
|
2 ;;; Copyright © 1992-1993 by Lucid, Inc. All Rights Reserved.
|
|
|
3
|
|
|
4 ;; Load this file and ^X-\ (back-slash) gets bound to a
|
|
|
5 ;; command that visit all the places where a language element is used.
|
|
|
6 ;; It can be started from the Le-Browser buffer of that language element
|
|
|
7 ;; or from a toplevel from defining the element.
|
|
|
8 ;;
|
|
|
9 ;; The visit happens as follows:
|
|
|
10 ;; - the 1st ^X-\ jumps to the beginning of the definition of the 1sr user.
|
|
|
11 ;; - then search-forward inside the first user for the name of the
|
|
|
12 ;; language element that was in the le-browser buffer.
|
|
|
13 ;; - the 2rd one searches again etc.. until no more match is found inside
|
|
|
14 ;; the body of the 1 user.
|
|
|
15 ;; - after the last match is seen the next user of the LE is visited
|
|
|
16 ;; the same way.
|
|
|
17 ;;
|
|
|
18 ;; If you want to start revisiting while a previous visit is not terminated do
|
|
|
19 ;; ^U-^X-\ in another (or the same) le-browser buffer.
|
|
|
20 ;;
|
|
|
21 ;; If you position the point on a User in the LE Browser buffer before doing
|
|
|
22 ;; ^X-\, that use will become the next one shown.
|
|
|
23 ;;
|
|
|
24 ;; energize-next-use-previous, ^U-1-^X-\, backs up one use
|
|
|
25 ;;
|
|
|
26 ;; It's quite crude and the UI could be improved in different ways.
|
|
|
27 ;; What about:
|
|
|
28 ;; - Allow for stacking of visits so that you can recursively
|
|
|
29 ;; visit another LE while one is being visited.
|
|
|
30 ;; - Highlight all the occurences of the LE-name inside the body of the user.
|
|
|
31 ;; - Deal with *alternatives*
|
|
|
32
|
|
|
33 (defvar energize-next-use-show-le-browser t
|
|
|
34 "*If t energize-next-use-command will show both the next use and the le-browser buffer")
|
|
|
35
|
|
|
36 (defvar energize-next-use-search-by-file nil ;; default is off cause on is slow
|
|
|
37 "*If t energize-next-use-command will show all uses in a file before going to
|
|
|
38 the next file")
|
|
|
39
|
|
|
40 (defvar energize-next-use-command-name ())
|
|
|
41 (defvar energize-next-use-label ())
|
|
|
42 (defvar energize-next-use-name ())
|
|
|
43 (defvar energize-next-use-from-mark ())
|
|
|
44 (defvar energize-next-use-source-start-mark ())
|
|
|
45 (defvar energize-next-use-source-end-mark ())
|
|
|
46 (defvar energize-next-use-source-current-mark ())
|
|
|
47 (defvar energize-next-use-current-file ())
|
|
|
48 (defvar energize-next-use-file-began-mark ())
|
|
|
49 (defvar energize-next-use-from-extent-cache ())
|
|
|
50 (defvar energize-next-use-history ())
|
|
|
51 (defvar energize-next-use-history-pointer ())
|
|
|
52 (defvar energize-next-use-marker-heap ())
|
|
|
53
|
|
|
54 ;; remember markers we allocate so we can clean them up
|
|
|
55 (defun energize-next-use-make-a-marker ()
|
|
|
56 (let ((m (make-marker)))
|
|
|
57 (setq energize-next-use-marker-heap
|
|
|
58 (cons m energize-next-use-marker-heap))
|
|
|
59 m))
|
|
|
60
|
|
|
61 (defun energize-next-use-copy-a-marker (mark)
|
|
|
62 (let ((m (copy-marker mark)))
|
|
|
63 (setq energize-next-use-marker-heap
|
|
|
64 (cons m energize-next-use-marker-heap))
|
|
|
65 m))
|
|
|
66
|
|
|
67 (defun energize-next-use-cleanup-markers ()
|
|
|
68 (while energize-next-use-marker-heap
|
|
|
69 (set-marker (car energize-next-use-marker-heap) nil)
|
|
|
70 (setq energize-next-use-marker-heap (cdr energize-next-use-marker-heap))))
|
|
|
71
|
|
|
72 (defun extent-after (pos)
|
|
|
73 (let ((extent (next-extent (current-buffer))))
|
|
|
74 (while (and extent (< (extent-start-position extent) pos))
|
|
|
75 (setq extent (next-extent extent)))
|
|
|
76 extent))
|
|
|
77
|
|
|
78 (defun energize-next-use-start-pos ()
|
|
|
79 (save-excursion
|
|
|
80 (goto-char (point-min))
|
|
|
81 (if (search-forward energize-next-use-label () t)
|
|
|
82 (point)
|
|
|
83 ())))
|
|
|
84
|
|
|
85 ;; see if we are in the LE Browser buffer of the object we are looking at
|
|
|
86 ;; uses of. If so, capture the position as a possible place to find the
|
|
|
87 ;; next user, rather than take the first or next in sequence.
|
|
|
88 (defun energize-next-use-start-pos-offset ()
|
|
|
89 ;; energize-next-use-from-mark is NULL iff this is called from
|
|
|
90 ;; energize-next-use-init - in that case assume that if we are in a LEB
|
|
|
91 ;; it is the one we will be using
|
|
|
92 (if (if (and energize-next-use-from-mark
|
|
|
93 (marker-buffer energize-next-use-from-mark))
|
|
|
94 (eq (current-buffer) (marker-buffer energize-next-use-from-mark))
|
|
|
95 (eq major-mode 'energize-browser-mode))
|
|
|
96 (save-excursion
|
|
|
97 (beginning-of-line)
|
|
|
98 (point))))
|
|
|
99
|
|
|
100 (defun energize-next-use-get-name (name)
|
|
|
101 (let ((colon (- (length name) 1)))
|
|
|
102 (while (and (> colon 0) (not (eq (aref name colon) ?:)))
|
|
|
103 (setq colon (- colon 1)))
|
|
|
104 (if (= (aref name colon) ?:)
|
|
|
105 (substring name (+ colon 1))
|
|
|
106 name)))
|
|
|
107
|
|
|
108 ;; cache the extents (and later the results of following them to the
|
|
|
109 ;; source buffer) to avoid calling the server too many times
|
|
|
110 ;; returns nil if the extent does not have a "source" menu option
|
|
|
111 ;; returns the cache entry otherwise
|
|
|
112 (defun energize-next-use-valid-from-extent-p (buff extent)
|
|
|
113 (let ((cache-entry (assoc extent energize-next-use-from-extent-cache)))
|
|
|
114 (if (not cache-entry)
|
|
|
115 (if (energize-list-menu buff extent ()
|
|
|
116 energize-next-use-command-name)
|
|
|
117 (setq energize-next-use-from-extent-cache
|
|
|
118 (cons (setq cache-entry (list extent))
|
|
|
119 energize-next-use-from-extent-cache))))
|
|
|
120 cache-entry))
|
|
|
121
|
|
|
122 ;; decide what use to look at next. current is nil if called from
|
|
|
123 ;; energize-next-use-next, else it is the presumed first extent for
|
|
|
124 ;; energize-next-use-from-mark passed from energize-next-use-init
|
|
|
125 ;; wanted-pos is the position of the cursor in the LE Browser of the
|
|
|
126 ;; object being looked for, or nil if the cursor is not in that buffer
|
|
|
127 ;; if wanted-pos is non-nil it means we will consider restarting the
|
|
|
128 ;; search at the user indicated by that position. Otherwise, we just
|
|
|
129 ;; return current. If this is nil too, it means just continue searching
|
|
|
130 ;; as before. If not, it means continue initializing as before.
|
|
|
131 ;;
|
|
|
132 ;; returns an extent to be used to set energize-next-use-from-mark or nil
|
|
|
133 (defun energize-next-use-adjust-for-start-offset (current wanted-pos)
|
|
|
134 ;; assumes we're in the LE browser buffer (we may not have been when
|
|
|
135 ;; the value of wanted-pos was determined)
|
|
|
136 (if wanted-pos
|
|
|
137 (let ((end-pos (energize-next-use-end-pos))
|
|
|
138 ;; ok will be set to the first extent found that is actually
|
|
|
139 ;; a user
|
|
|
140 (ok nil)
|
|
|
141 (try (or current (extent-after (energize-next-use-start-pos)))))
|
|
|
142 ;; loop will exit if an actual user extent is found that follows
|
|
|
143 ;; the wanted-pos - if we go out of bounds, try is set to nil
|
|
|
144 ;; else it is the desired extent on exit from the loop
|
|
|
145 (while (and try
|
|
|
146 (or (< (extent-start-position try) end-pos)
|
|
|
147 (setq try nil))
|
|
|
148 (not
|
|
|
149 (and
|
|
|
150 ;; try is a valid user extent if this menu exists
|
|
|
151 (energize-next-use-valid-from-extent-p
|
|
|
152 (current-buffer) try)
|
|
|
153 ;; but it might be before wanted-pos,
|
|
|
154 (or (> (extent-end-position try) wanted-pos)
|
|
|
155 ;; in which case remember it as ok unless
|
|
|
156 ;; ok was already set
|
|
|
157 (and (setq ok (or ok try)) nil)))))
|
|
|
158 (setq try (next-extent try)))
|
|
|
159 ;; return try or if we were called from init, return ok
|
|
|
160 ;; else return nil to mean continue searching in current sequence
|
|
|
161 (or try (and current ok)))
|
|
|
162 current))
|
|
|
163
|
|
|
164 (defun energize-next-use-set-marks (extent buffer)
|
|
|
165 (if (not energize-next-use-from-mark)
|
|
|
166 (setq energize-next-use-from-mark (make-marker)))
|
|
|
167 (set-marker energize-next-use-from-mark
|
|
|
168 (extent-start-position extent) buffer))
|
|
|
169
|
|
|
170 (defun energize-next-use-init (command label)
|
|
|
171 ;; start-offset is the position of point if it is in the LEB buffer
|
|
|
172 (let ((start-offset (energize-next-use-start-pos-offset)))
|
|
|
173 (if (not (eq major-mode 'energize-browser-mode))
|
|
|
174 (if (energize-list-menu (current-buffer)
|
|
|
175 (energize-extent-at (point)) ()
|
|
|
176 "browse_le")
|
|
|
177 (energize-execute-command "browse_le"
|
|
|
178 (energize-extent-at (point)) () t)
|
|
|
179 (error
|
|
|
180 "command undefined unless in a LE buffer or at a LE definition form")))
|
|
|
181 (setq energize-next-use-command-name command)
|
|
|
182 (setq energize-next-use-label label)
|
|
|
183 (setq energize-next-use-current-file nil)
|
|
|
184 (setq energize-next-use-from-extent-cache nil)
|
|
|
185 (setq energize-next-use-history nil)
|
|
|
186 (setq energize-next-use-history-pointer nil)
|
|
|
187 (let* ((pos (energize-next-use-start-pos))
|
|
|
188 (extent (and pos
|
|
|
189 ;; start at the beginning, unless start-pos says
|
|
|
190 ;; to start further along
|
|
|
191 (energize-next-use-adjust-for-start-offset
|
|
|
192 (extent-after pos) start-offset))))
|
|
|
193 (if (null extent)
|
|
|
194 (error "no uses")
|
|
|
195 (energize-next-use-set-marks extent (current-buffer))
|
|
|
196 (setq energize-next-use-name
|
|
|
197 (save-excursion
|
|
|
198 (let ((s (energize-next-use-get-name (buffer-name))))
|
|
|
199 (if (let ((l (length s)))
|
|
|
200 (while (not
|
|
|
201 (and (> l 0)
|
|
|
202 (progn
|
|
|
203 (beginning-of-buffer)
|
|
|
204 (search-forward
|
|
|
205 (substring s 0 l) nil t))))
|
|
|
206 (setq l (- l 1)))
|
|
|
207 (> l 0))
|
|
|
208 (let (pos)
|
|
|
209 (backward-sexp)
|
|
|
210 (setq pos (point))
|
|
|
211 (forward-sexp)
|
|
|
212 (buffer-substring pos (point)))
|
|
|
213 s))))))
|
|
|
214 (energize-next-use-show-both)))
|
|
|
215
|
|
|
216 (defun energize-next-use-end-pos ()
|
|
|
217 (save-excursion
|
|
|
218 (goto-char (point-min))
|
|
|
219 (search-forward energize-next-use-label)
|
|
|
220 (re-search-forward "^ *[A-Za-z ]*: " () 'end)
|
|
|
221 (point)))
|
|
|
222
|
|
|
223 ;; return the source-entry portion of the extent cache, looking it up
|
|
|
224 ;; if necessary by doing energize-execute-command "source" on the extent
|
|
|
225 ;; source-entry portion is list of
|
|
|
226 ;; a) point marker after executing the "source" command
|
|
|
227 ;; b) a flag saying we've actually visited this use, not just looked it up
|
|
|
228 ;; c) marker for the window-start after executing the "source" command
|
|
|
229 (defun energize-next-use-from-extent-source-info (from-extent-entry)
|
|
|
230 (let ((extent (car from-extent-entry))
|
|
|
231 (source-entry (cdr from-extent-entry)))
|
|
|
232 (if (not source-entry)
|
|
|
233 (save-window-excursion
|
|
|
234 (save-excursion
|
|
|
235 (let ((pre-display-buffer-function nil)) ;; hack for multi-frame
|
|
|
236 (energize-execute-command
|
|
|
237 energize-next-use-command-name extent () t))
|
|
|
238 (setcdr from-extent-entry
|
|
|
239 (setq source-entry
|
|
|
240 (list (energize-next-use-copy-a-marker
|
|
|
241 (point-marker))
|
|
|
242 nil
|
|
|
243 (set-marker
|
|
|
244 (energize-next-use-make-a-marker)
|
|
|
245 (window-start))))))))
|
|
|
246 source-entry))
|
|
|
247
|
|
|
248 (defun energize-next-use-from-extent-source-mark (source-entry)
|
|
|
249 (car source-entry))
|
|
|
250
|
|
|
251 (defun energize-next-use-from-extent-source-start-mark (source-entry)
|
|
|
252 (car (cdr (cdr source-entry))))
|
|
|
253
|
|
|
254 (defun energize-next-use-from-extent-source-seen-p (source-entry)
|
|
|
255 (car (cdr source-entry)))
|
|
|
256
|
|
|
257 (defun energize-next-use-from-extent-set-source-seen-p (source-entry)
|
|
|
258 (setcar (cdr source-entry) t))
|
|
|
259
|
|
|
260 ;; goto the next user - or if advance is nil try to re-establish the
|
|
|
261 ;; extent for the current one
|
|
|
262 (defun energize-next-use-next-to-extent (advance)
|
|
|
263 (let ((buff (marker-buffer energize-next-use-from-mark))
|
|
|
264 (from-pos (marker-position energize-next-use-from-mark)))
|
|
|
265 (and buff from-pos
|
|
|
266 (let ((result nil))
|
|
|
267 (set-buffer buff)
|
|
|
268 (let ((end-pos (energize-next-use-end-pos))
|
|
|
269 (extent (or (energize-extent-at from-pos)
|
|
|
270 (setq advance nil)
|
|
|
271 (extent-after from-pos))))
|
|
|
272 (if (and advance energize-next-use-search-by-file)
|
|
|
273 (if (not energize-next-use-current-file)
|
|
|
274 ;; if searching by file but dont have a current file,
|
|
|
275 ;; set current file to current source buffer
|
|
|
276 (if (setq energize-next-use-current-file
|
|
|
277 (and energize-next-use-source-start-mark
|
|
|
278 (marker-buffer
|
|
|
279 energize-next-use-source-start-mark)))
|
|
|
280 (progn
|
|
|
281 (if (not energize-next-use-file-began-mark)
|
|
|
282 (setq energize-next-use-file-began-mark
|
|
|
283 (make-marker)))
|
|
|
284 (set-marker energize-next-use-file-began-mark
|
|
|
285 from-pos buff))))
|
|
|
286 (setq energize-next-use-current-file nil))
|
|
|
287 (if advance
|
|
|
288 (setq extent (next-extent extent)))
|
|
|
289 (if energize-next-use-search-by-file
|
|
|
290 (message "Searching for next use in current file...")
|
|
|
291 (message "Searching for next use..."))
|
|
|
292 ;; validate the extent
|
|
|
293 (while extent
|
|
|
294 (while
|
|
|
295 (and
|
|
|
296 extent
|
|
|
297 ;; if extent is beyond the end of the "used by" zone
|
|
|
298 ;; set it to nil to terminate loop
|
|
|
299 (or (< (extent-start-position extent) end-pos)
|
|
|
300 (setq extent nil))
|
|
|
301 (not
|
|
|
302 (let ((from-extent-entry
|
|
|
303 (energize-next-use-valid-from-extent-p
|
|
|
304 buff extent)))
|
|
|
305 (and
|
|
|
306 ;; true if the extent has a "source" menu option
|
|
|
307 from-extent-entry
|
|
|
308 (or
|
|
|
309 (not energize-next-use-search-by-file)
|
|
|
310 ;; see if this is extent points to the current file
|
|
|
311 ;; or a file we haven't looked at yet, if not current
|
|
|
312 ;; file is set now
|
|
|
313 (let* ((source-entry
|
|
|
314 (energize-next-use-from-extent-source-info
|
|
|
315 from-extent-entry))
|
|
|
316 (source-marker
|
|
|
317 (energize-next-use-from-extent-source-mark
|
|
|
318 source-entry))
|
|
|
319 (buff (marker-buffer source-marker)))
|
|
|
320 (if energize-next-use-current-file
|
|
|
321 (eq buff energize-next-use-current-file)
|
|
|
322 (not
|
|
|
323 (energize-next-use-from-extent-source-seen-p
|
|
|
324 source-entry)))))))))
|
|
|
325 (setq extent (next-extent extent)))
|
|
|
326 (if extent
|
|
|
327 ;; we found one we can use - remember it but set extent
|
|
|
328 ;; to nil to terminate the loop
|
|
|
329 (progn
|
|
|
330 ;; convert the extent to a mark for future reference
|
|
|
331 (energize-next-use-set-marks extent buff)
|
|
|
332 ;; terminate the loop
|
|
|
333 (setq extent nil)
|
|
|
334 ;; saw we succeeded in finding something
|
|
|
335 (setq result t))
|
|
|
336 ;; we didn't find anything valid - if we were looking in
|
|
|
337 ;; the current file, restart the loop now looking for
|
|
|
338 ;; anything we haven't used yet, to make it the current file
|
|
|
339 ;; if we weren't looking in the current file then we really
|
|
|
340 ;; have failed to find anything left, so return nil
|
|
|
341 (if energize-next-use-current-file
|
|
|
342 (progn
|
|
|
343 (setq energize-next-use-current-file nil)
|
|
|
344 (setq extent
|
|
|
345 ;; restart loop from were we started looking at
|
|
|
346 ;; the current file
|
|
|
347 (let ((pos (marker-position
|
|
|
348 energize-next-use-file-began-mark)))
|
|
|
349 (and pos
|
|
|
350 (or (energize-extent-at pos)
|
|
|
351 (extent-after pos)))))))))
|
|
|
352 (if energize-next-use-search-by-file
|
|
|
353 (message "Searching for next use in current file...done")
|
|
|
354 (message "Searching for next use...done"))
|
|
|
355 result)))))
|
|
|
356
|
|
|
357 (defun energize-next-use-show-from (&optional mark)
|
|
|
358 (setq mark (or mark energize-next-use-from-mark))
|
|
|
359 (if energize-next-use-show-le-browser
|
|
|
360 ;; position the browser to the line of the current user
|
|
|
361 (let ((buff (marker-buffer mark))
|
|
|
362 (from-pos (marker-position mark)))
|
|
|
363 (and buff from-pos
|
|
|
364 (progn
|
|
|
365 ;; don't worry about pre-display-buffer-function here;
|
|
|
366 ;; we actually want a new frame to be created when
|
|
|
367 ;; displaying the Browser buffer.
|
|
|
368 (pop-to-buffer buff)
|
|
|
369 (goto-char from-pos)
|
|
|
370 (beginning-of-line)
|
|
|
371 (set-window-start (selected-window) (point)))))
|
|
|
372 (message "next use of %s" energize-next-use-name)))
|
|
|
373
|
|
|
374 (defun energize-next-use-show-to ()
|
|
|
375 (let* ((buff (marker-buffer energize-next-use-from-mark))
|
|
|
376 (from-pos (marker-position energize-next-use-from-mark))
|
|
|
377 (from-extent (and buff from-pos (energize-extent-at from-pos buff)))
|
|
|
378 (from-extent-entry
|
|
|
379 ;; get the cache entry for the current user extent in the browser
|
|
|
380 (energize-next-use-valid-from-extent-p buff from-extent))
|
|
|
381 (source-extent nil))
|
|
|
382 (and
|
|
|
383 from-extent-entry
|
|
|
384 (let* ((source-entry
|
|
|
385 (energize-next-use-from-extent-source-info
|
|
|
386 from-extent-entry))
|
|
|
387 (source-marker
|
|
|
388 (energize-next-use-from-extent-source-mark
|
|
|
389 source-entry))
|
|
|
390 (source-buffer (marker-buffer source-marker))
|
|
|
391 (source-pos (marker-position source-marker))
|
|
|
392 ;; if we're allowed to split frames, call pop-to-buffer
|
|
|
393 ;; with no pre-display-buffer-function, so that the current
|
|
|
394 ;; frame (the frame of the Browser buffer) is used. If
|
|
|
395 ;; we don't split frames, then use the p-d-b-f, so that a
|
|
|
396 ;; new frame can be created for this file.
|
|
|
397 (pre-display-buffer-function
|
|
|
398 (if energize-split-screens-p
|
|
|
399 nil
|
|
|
400 pre-display-buffer-function)))
|
|
|
401 (if source-pos
|
|
|
402 (progn
|
|
|
403 ;; position the source window as if we had just executed the
|
|
|
404 ;; command "source" on the from-extent in the browser
|
|
|
405 (pop-to-buffer source-buffer)
|
|
|
406 (set-window-start
|
|
|
407 (selected-window)
|
|
|
408 (marker-position
|
|
|
409 (energize-next-use-from-extent-source-start-mark source-entry))
|
|
|
410 t)
|
|
|
411 (goto-char source-marker)
|
|
|
412 ;; note that we have actually visited this use
|
|
|
413 (energize-next-use-from-extent-set-source-seen-p source-entry)
|
|
|
414 (setq source-extent (energize-extent-at (point))))))
|
|
|
415 (let ((start-pos (extent-start-position source-extent)))
|
|
|
416 ;; convert positions to markers
|
|
|
417 (if (not energize-next-use-source-start-mark)
|
|
|
418 (setq energize-next-use-source-start-mark (make-marker)))
|
|
|
419 (if (not energize-next-use-source-end-mark)
|
|
|
420 (setq energize-next-use-source-end-mark (make-marker)))
|
|
|
421 (if (not energize-next-use-source-current-mark)
|
|
|
422 (setq energize-next-use-source-current-mark (make-marker)))
|
|
|
423 (set-marker energize-next-use-source-start-mark start-pos)
|
|
|
424 (set-marker energize-next-use-source-current-mark start-pos)
|
|
|
425 (set-marker energize-next-use-source-end-mark
|
|
|
426 (extent-end-position source-extent))))))
|
|
|
427
|
|
|
428 (defun energize-next-use-search-for-name ()
|
|
|
429 (if (let ((case-fold-search nil)
|
|
|
430 (found nil)
|
|
|
431 (end-pos (marker-position energize-next-use-source-end-mark)))
|
|
|
432 (if end-pos
|
|
|
433 (progn
|
|
|
434 (buffer-syntactic-context-flush-cache)
|
|
|
435 ;; case sensitive exact search for token not in comment or string
|
|
|
436 (while
|
|
|
437 (and
|
|
|
438 (setq found
|
|
|
439 (re-search-forward
|
|
|
440 (concat "[^A-Za-z0-9_]"
|
|
|
441 (regexp-quote energize-next-use-name)
|
|
|
442 "[^A-Za-z0-9_]")
|
|
|
443 end-pos t))
|
|
|
444 (save-excursion (buffer-syntactic-context))))))
|
|
|
445 found)
|
|
|
446 (progn
|
|
|
447 ;; allow for the delimiter
|
|
|
448 (backward-char 1)
|
|
|
449 t)
|
|
|
450 nil))
|
|
|
451
|
|
|
452
|
|
|
453 ;; say this if search can't find the thing that is being used
|
|
|
454 (defun energize-next-use-not-lexically-apparent ()
|
|
|
455 (message "next use of %s is here, but not lexically apparent"
|
|
|
456 energize-next-use-name))
|
|
|
457
|
|
|
458 ;; called when visiting a new users, not a new use within that user
|
|
|
459 (defun energize-next-use-show-both ()
|
|
|
460 ;; reposition the browser to the line showing the user
|
|
|
461 (energize-next-use-show-from)
|
|
|
462 ;; position the source to the user definition form
|
|
|
463 (energize-next-use-show-to)
|
|
|
464 ;; instead of stopping at the beginning of the user form,
|
|
|
465 ;; go immediately to the first use found if it is lexically apparent
|
|
|
466 (if (and
|
|
|
467 energize-next-use-source-start-mark
|
|
|
468 (let ((buff (marker-buffer energize-next-use-source-start-mark))
|
|
|
469 (current-pos
|
|
|
470 (marker-position energize-next-use-source-current-mark))
|
|
|
471 (end-pos (marker-position energize-next-use-source-end-mark)))
|
|
|
472 (if (and buff current-pos end-pos)
|
|
|
473 (save-excursion
|
|
|
474 (set-buffer buff)
|
|
|
475 (and (< current-pos end-pos)
|
|
|
476 (progn
|
|
|
477 (goto-char current-pos)
|
|
|
478 (energize-next-use-search-for-name)))))))
|
|
|
479 ;; an apparent use is there, so proceed as if going to the next use
|
|
|
480 ;; within the user
|
|
|
481 (energize-next-use-next)
|
|
|
482 ;; no use is apparent, so print a message
|
|
|
483 (energize-next-use-not-lexically-apparent)
|
|
|
484 ;; record the history entry for a non-apparent use - it is distinguished
|
|
|
485 ;; by having no point position from which to make a region to highlight
|
|
|
486 (setq energize-next-use-history
|
|
|
487 (cons (list (energize-next-use-copy-a-marker
|
|
|
488 energize-next-use-from-mark)
|
|
|
489 (energize-next-use-copy-a-marker
|
|
|
490 energize-next-use-source-current-mark)
|
|
|
491 (set-marker (energize-next-use-make-a-marker)
|
|
|
492 (window-start)))
|
|
|
493 energize-next-use-history))
|
|
|
494 (setq energize-next-use-history-pointer
|
|
|
495 energize-next-use-history)))
|
|
|
496
|
|
|
497 ;; show the next use within the current user - if no more are found
|
|
|
498 ;; go to the next user
|
|
|
499 (defun energize-next-use-next ()
|
|
|
500 ;; new-start will get set to an extent for a user at which to
|
|
|
501 ;; reposition the visit, iff the cursor is in the LEB buffer
|
|
|
502 ;; of the usee at a valid position in the list of users.
|
|
|
503 (let ((new-start (energize-next-use-adjust-for-start-offset
|
|
|
504 nil (energize-next-use-start-pos-offset)))
|
|
|
505 (buff (marker-buffer energize-next-use-source-start-mark))
|
|
|
506 (current-pos (marker-position energize-next-use-source-current-mark))
|
|
|
507 (end-pos (marker-position energize-next-use-source-end-mark)))
|
|
|
508 (if (and buff (not (eq buff (current-buffer))))
|
|
|
509 (set-buffer buff))
|
|
|
510 ;; new-start means we are repositioning due to the point being in the
|
|
|
511 ;; user list in the browser. In this case we will act as if we are
|
|
|
512 ;; at the end of the old user
|
|
|
513 (if new-start
|
|
|
514 (energize-next-use-set-marks
|
|
|
515 new-start
|
|
|
516 (marker-buffer energize-next-use-from-mark)))
|
|
|
517 (cond ((and buff current-pos end-pos
|
|
|
518 (not new-start) ;; don't stay in current user if repositioning
|
|
|
519 (< current-pos end-pos)
|
|
|
520 (progn
|
|
|
521 (goto-char current-pos)
|
|
|
522 (energize-next-use-search-for-name)))
|
|
|
523 ;; the 'still in the same user' case
|
|
|
524 (set-marker energize-next-use-source-current-mark (point))
|
|
|
525 ;; redisplay the browser in case it got covered up
|
|
|
526 (energize-next-use-show-from)
|
|
|
527 ;; We know that we're not changing files, so there won't be any
|
|
|
528 ;; need to create a new frame; it would be nice if we reselected
|
|
|
529 ;; the appropriate frame instead of just using the current frame,
|
|
|
530 ;; but that's more work, and this will very rarely do the wrong
|
|
|
531 ;; thing.
|
|
|
532 (let ((pre-display-buffer-function
|
|
|
533 (if energize-split-screens-p
|
|
|
534 nil
|
|
|
535 pre-display-buffer-function)))
|
|
|
536 ;; display the source buffer
|
|
|
537 (pop-to-buffer buff)
|
|
|
538 ;; had to do this because window-start overrides point
|
|
|
539 ;; in terms of deciding what part of the window to show
|
|
|
540 ;; this seems like a possible bug
|
|
|
541 (set-window-buffer (selected-window) buff)
|
|
|
542 (push-mark (point) t)
|
|
|
543 (backward-char (length energize-next-use-name))
|
|
|
544 (if zmacs-regions
|
|
|
545 (zmacs-activate-region))
|
|
|
546 ;; record the visit in the history - this entry has a point
|
|
|
547 ;; marker, distinguishing it from a non-lexically apparent one
|
|
|
548 (setq energize-next-use-history
|
|
|
549 (cons (list
|
|
|
550 (energize-next-use-copy-a-marker
|
|
|
551 energize-next-use-from-mark)
|
|
|
552 (energize-next-use-copy-a-marker
|
|
|
553 energize-next-use-source-current-mark)
|
|
|
554 (set-marker (energize-next-use-make-a-marker)
|
|
|
555 (window-start))
|
|
|
556 (set-marker (energize-next-use-make-a-marker)
|
|
|
557 (point)))
|
|
|
558 energize-next-use-history))
|
|
|
559 (setq energize-next-use-history-pointer
|
|
|
560 energize-next-use-history)))
|
|
|
561 ((or new-start
|
|
|
562 (energize-next-use-next-to-extent
|
|
|
563 (and buff current-pos end-pos)))
|
|
|
564 ;; the 'moved to a new user or repositioned to one' case
|
|
|
565 (energize-next-use-show-both))
|
|
|
566 (t
|
|
|
567 ;; no more users
|
|
|
568 (energize-next-use-terminate)
|
|
|
569 (error "no more")))))
|
|
|
570
|
|
|
571
|
|
|
572 (defun energize-next-use-terminate ()
|
|
|
573 (setq energize-next-use-command-name ())
|
|
|
574 (setq energize-next-use-label ())
|
|
|
575 (setq energize-next-use-name ())
|
|
|
576 (if energize-next-use-from-mark
|
|
|
577 (set-marker energize-next-use-from-mark nil))
|
|
|
578 (if energize-next-use-source-start-mark
|
|
|
579 (set-marker energize-next-use-source-start-mark nil))
|
|
|
580 (if energize-next-use-source-current-mark
|
|
|
581 (set-marker energize-next-use-source-current-mark nil))
|
|
|
582 (if energize-next-use-source-end-mark
|
|
|
583 (set-marker energize-next-use-source-end-mark nil))
|
|
|
584 (if energize-next-use-file-began-mark
|
|
|
585 (set-marker energize-next-use-file-began-mark nil))
|
|
|
586 (energize-next-use-cleanup-markers))
|
|
|
587
|
|
|
588 ;; get next use from history list if we have regressed or are regressing
|
|
|
589 ;; if history-pointer == history then we are in the present
|
|
|
590 ;; to go back set history-pointer to cdr history-pointer
|
|
|
591 ;; to go forward set history-pointer to the last cell on history prior to
|
|
|
592 ;; the current value of history-pointer
|
|
|
593 ;; a history entry is just redisplay info for the browser and source buffers
|
|
|
594 (defun energize-next-use-from-history (backward)
|
|
|
595 (if backward
|
|
|
596 (setq energize-next-use-history-pointer
|
|
|
597 (cdr energize-next-use-history-pointer))
|
|
|
598 (let ((temp energize-next-use-history-pointer))
|
|
|
599 (setq energize-next-use-history-pointer
|
|
|
600 energize-next-use-history)
|
|
|
601 (while (not (eq (cdr energize-next-use-history-pointer) temp))
|
|
|
602 (setq energize-next-use-history-pointer
|
|
|
603 (cdr energize-next-use-history-pointer)))))
|
|
|
604 (let* ((history-entry (car energize-next-use-history-pointer))
|
|
|
605 (from-mark (car history-entry))
|
|
|
606 (source-mark (car (cdr history-entry)))
|
|
|
607 (source-start-mark (car (cdr (cdr history-entry))))
|
|
|
608 (source-point-mark (car (cdr (cdr (cdr history-entry))))))
|
|
|
609 (energize-next-use-show-from from-mark)
|
|
|
610 (if (and (marker-position source-mark)
|
|
|
611 (marker-position source-start-mark))
|
|
|
612 (progn
|
|
|
613 (pop-to-buffer (marker-buffer source-mark))
|
|
|
614 (set-window-start
|
|
|
615 (selected-window) (marker-position source-start-mark) t)
|
|
|
616 (goto-char source-mark)
|
|
|
617 (if (and source-point-mark (marker-position source-point-mark))
|
|
|
618 (progn
|
|
|
619 (push-mark (point) t)
|
|
|
620 (goto-char source-point-mark)
|
|
|
621 (if zmacs-regions
|
|
|
622 (zmacs-activate-region)))
|
|
|
623 (energize-next-use-not-lexically-apparent))))))
|
|
|
624
|
|
|
625 (defun energize-next-use-go (label command)
|
|
|
626 (if (and energize-next-use-from-mark
|
|
|
627 (marker-position energize-next-use-from-mark))
|
|
|
628 (if (eq energize-next-use-history-pointer
|
|
|
629 energize-next-use-history)
|
|
|
630 ;; normal case
|
|
|
631 (energize-next-use-next)
|
|
|
632 ;; in the depths of history but going forward
|
|
|
633 (energize-next-use-from-history nil))
|
|
|
634 ;; beginning of time
|
|
|
635 (energize-next-use-init label command)))
|
|
|
636
|
|
|
637 (defun energize-next-use-previous ()
|
|
|
638 (if (cdr energize-next-use-history-pointer)
|
|
|
639 ;; going back in time
|
|
|
640 (energize-next-use-from-history t)
|
|
|
641 ;; trying to go beyond the pale
|
|
|
642 (error "no prior use")))
|
|
|
643
|
|
|
644 (defun energize-next-use-command (arg)
|
|
|
645 "Show the next place where the current language element is used.
|
|
|
646 The current language element is the one that point is on for source buffers
|
|
|
647 or the element displayed in a language element browser buffer.
|
|
|
648 Repeated calls to this functions visit all the callers in sequence.
|
|
|
649
|
|
|
650 With prefix arg = 1, back up to the last use.
|
|
|
651
|
|
|
652 With prefix arg > 1, start a visit from scratch on the current language
|
|
|
653 element.
|
|
|
654
|
|
|
655 If the point is on a particular user in the language element browser, the
|
|
|
656 search will be (re)started in that user.
|
|
|
657
|
|
|
658 The variable energize-next-use-show-le-browser controls if this command should
|
|
|
659 display both the language element browser buffer and the next user or just the
|
|
|
660 next user of the current language element.
|
|
|
661
|
|
|
662 The variable energize-next-use-search-by-file controls whether all uses within
|
|
|
663 a given file should be shown in sequence. If the value is nil, the uses
|
|
|
664 are shown in the order in which they appear in the LE Browser. If the
|
|
|
665 value is non-nil, the all uses in a given file are shown before proceeding to
|
|
|
666 the next use in another file."
|
|
|
667 (interactive "P")
|
|
|
668 (if (eq arg 1)
|
|
|
669 (energize-next-use-previous)
|
|
|
670 (if arg
|
|
|
671 (energize-next-use-terminate))
|
|
|
672 (energize-next-use-go "source" "Used By:")))
|
|
|
673
|
|
|
674 (define-key global-map '[(control x) \\] 'energize-next-use-command)
|
|
|
675
|
|
|
676 (defun energize-next-use-start ()
|
|
|
677 "Start visiting the uses of a language element.
|
|
|
678 If executed in a LE Browser buffer visit the uses of the language element
|
|
|
679 in the buffer. In a source buffer visit the uses of the language element
|
|
|
680 at (point)"
|
|
|
681 (interactive)
|
|
|
682 (energize-next-use-command 4))
|
