659
|
1 ;;; lisp.el --- Lisp editing commands for Emacs
|
|
2
|
74466
|
3 ;; Copyright (C) 1985, 1986, 1994, 2000, 2001, 2002, 2003, 2004,
|
75346
|
4 ;; 2005, 2006, 2007 Free Software Foundation, Inc.
|
845
|
5
|
807
|
6 ;; Maintainer: FSF
|
2247
|
7 ;; Keywords: lisp, languages
|
807
|
8
|
84
|
9 ;; This file is part of GNU Emacs.
|
|
10
|
|
11 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
12 ;; it under the terms of the GNU General Public License as published by
|
78217
|
13 ;; the Free Software Foundation; either version 3, or (at your option)
|
84
|
14 ;; any later version.
|
|
15
|
|
16 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
19 ;; GNU General Public License for more details.
|
|
20
|
|
21 ;; You should have received a copy of the GNU General Public License
|
14169
|
22 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
64085
|
23 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
24 ;; Boston, MA 02110-1301, USA.
|
84
|
25
|
2307
|
26 ;;; Commentary:
|
|
27
|
30979
|
28 ;; Lisp editing commands to go with Lisp major mode. More-or-less
|
|
29 ;; applicable in other modes too.
|
2307
|
30
|
807
|
31 ;;; Code:
|
84
|
32
|
6369
|
33 ;; Note that this variable is used by non-lisp modes too.
|
17665
|
34 (defcustom defun-prompt-regexp nil
|
61401
99b039f2f040
(defun-prompt-regexp, parens-require-spaces, buffer-end, end-of-defun)
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
35 "*If non-nil, a regexp to ignore before a defun.
|
6369
|
36 This is only necessary if the opening paren or brace is not in column 0.
|
61401
99b039f2f040
(defun-prompt-regexp, parens-require-spaces, buffer-end, end-of-defun)
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
37 See function `beginning-of-defun'."
|
19831
|
38 :type '(choice (const nil)
|
|
39 regexp)
|
17665
|
40 :group 'lisp)
|
6973
|
41 (make-variable-buffer-local 'defun-prompt-regexp)
|
84
|
42
|
17665
|
43 (defcustom parens-require-spaces t
|
61401
99b039f2f040
(defun-prompt-regexp, parens-require-spaces, buffer-end, end-of-defun)
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
44 "If non-nil, `insert-parentheses' inserts whitespace as needed."
|
17665
|
45 :type 'boolean
|
|
46 :group 'lisp)
|
3733
|
47
|
31982
|
48 (defvar forward-sexp-function nil
|
|
49 "If non-nil, `forward-sexp' delegates to this function.
|
|
50 Should take the same arguments and behave similarly to `forward-sexp'.")
|
|
51
|
84
|
52 (defun forward-sexp (&optional arg)
|
|
53 "Move forward across one balanced expression (sexp).
|
27190
|
54 With ARG, do it that many times. Negative arg -N means
|
215
|
55 move backward across N balanced expressions."
|
84
|
56 (interactive "p")
|
|
57 (or arg (setq arg 1))
|
31982
|
58 (if forward-sexp-function
|
|
59 (funcall forward-sexp-function arg)
|
|
60 (goto-char (or (scan-sexps (point) arg) (buffer-end arg)))
|
|
61 (if (< arg 0) (backward-prefix-chars))))
|
84
|
62
|
|
63 (defun backward-sexp (&optional arg)
|
|
64 "Move backward across one balanced expression (sexp).
|
27190
|
65 With ARG, do it that many times. Negative arg -N means
|
215
|
66 move forward across N balanced expressions."
|
84
|
67 (interactive "p")
|
|
68 (or arg (setq arg 1))
|
|
69 (forward-sexp (- arg)))
|
|
70
|
59177
|
71 (defun mark-sexp (&optional arg allow-extend)
|
84
|
72 "Set mark ARG sexps from point.
|
215
|
73 The place mark goes is the same place \\[forward-sexp] would
|
41291
|
74 move to with the same argument.
|
59177
|
75 Interactively, if this command is repeated
|
61401
99b039f2f040
(defun-prompt-regexp, parens-require-spaces, buffer-end, end-of-defun)
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
76 or (in Transient Mark mode) if the mark is active,
|
58918
|
77 it marks the next ARG sexps after the ones already marked."
|
59177
|
78 (interactive "P\np")
|
|
79 (cond ((and allow-extend
|
|
80 (or (and (eq last-command this-command) (mark t))
|
|
81 (and transient-mark-mode mark-active)))
|
57457
|
82 (setq arg (if arg (prefix-numeric-value arg)
|
58918
|
83 (if (< (mark) (point)) -1 1)))
|
43301
|
84 (set-mark
|
|
85 (save-excursion
|
58918
|
86 (goto-char (mark))
|
|
87 (forward-sexp arg)
|
|
88 (point))))
|
43301
|
89 (t
|
|
90 (push-mark
|
|
91 (save-excursion
|
57457
|
92 (forward-sexp (prefix-numeric-value arg))
|
43301
|
93 (point))
|
|
94 nil t))))
|
84
|
95
|
|
96 (defun forward-list (&optional arg)
|
|
97 "Move forward across one balanced group of parentheses.
|
27190
|
98 With ARG, do it that many times.
|
84
|
99 Negative arg -N means move backward across N groups of parentheses."
|
|
100 (interactive "p")
|
|
101 (or arg (setq arg 1))
|
|
102 (goto-char (or (scan-lists (point) arg 0) (buffer-end arg))))
|
|
103
|
|
104 (defun backward-list (&optional arg)
|
|
105 "Move backward across one balanced group of parentheses.
|
27190
|
106 With ARG, do it that many times.
|
84
|
107 Negative arg -N means move forward across N groups of parentheses."
|
|
108 (interactive "p")
|
|
109 (or arg (setq arg 1))
|
|
110 (forward-list (- arg)))
|
|
111
|
30979
|
112 (defun down-list (&optional arg)
|
84
|
113 "Move forward down one level of parentheses.
|
27190
|
114 With ARG, do this that many times.
|
32456
|
115 A negative argument means move backward but still go down a level."
|
84
|
116 (interactive "p")
|
30979
|
117 (or arg (setq arg 1))
|
84
|
118 (let ((inc (if (> arg 0) 1 -1)))
|
|
119 (while (/= arg 0)
|
|
120 (goto-char (or (scan-lists (point) inc -1) (buffer-end arg)))
|
|
121 (setq arg (- arg inc)))))
|
|
122
|
30979
|
123 (defun backward-up-list (&optional arg)
|
84
|
124 "Move backward out of one level of parentheses.
|
27190
|
125 With ARG, do this that many times.
|
32456
|
126 A negative argument means move forward but still to a less deep spot."
|
84
|
127 (interactive "p")
|
30979
|
128 (up-list (- (or arg 1))))
|
84
|
129
|
30979
|
130 (defun up-list (&optional arg)
|
84
|
131 "Move forward out of one level of parentheses.
|
27190
|
132 With ARG, do this that many times.
|
32456
|
133 A negative argument means move backward but still to a less deep spot."
|
84
|
134 (interactive "p")
|
30979
|
135 (or arg (setq arg 1))
|
84
|
136 (let ((inc (if (> arg 0) 1 -1)))
|
|
137 (while (/= arg 0)
|
|
138 (goto-char (or (scan-lists (point) inc 1) (buffer-end arg)))
|
|
139 (setq arg (- arg inc)))))
|
|
140
|
30979
|
141 (defun kill-sexp (&optional arg)
|
59602
|
142 "Kill the sexp (balanced expression) following point.
|
|
143 With ARG, kill that many sexps after point.
|
|
144 Negative arg -N means kill N sexps before point."
|
84
|
145 (interactive "p")
|
|
146 (let ((opoint (point)))
|
30979
|
147 (forward-sexp (or arg 1))
|
84
|
148 (kill-region opoint (point))))
|
|
149
|
30979
|
150 (defun backward-kill-sexp (&optional arg)
|
59602
|
151 "Kill the sexp (balanced expression) preceding point.
|
|
152 With ARG, kill that many sexps before point.
|
|
153 Negative arg -N means kill N sexps after point."
|
84
|
154 (interactive "p")
|
30979
|
155 (kill-sexp (- (or arg 1))))
|
56924
|
156
|
|
157 ;; After Zmacs:
|
|
158 (defun kill-backward-up-list (&optional arg)
|
|
159 "Kill the form containing the current sexp, leaving the sexp itself.
|
|
160 A prefix argument ARG causes the relevant number of surrounding
|
|
161 forms to be removed."
|
|
162 (interactive "*p")
|
|
163 (let ((current-sexp (thing-at-point 'sexp)))
|
|
164 (if current-sexp
|
|
165 (save-excursion
|
|
166 (backward-up-list arg)
|
|
167 (kill-sexp)
|
|
168 (insert current-sexp))
|
|
169 (error "Not at a sexp"))))
|
84
|
170
|
27380
59243c413664
(beginning-of-defun-function): Variable renamed from beginning-of-defun.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
171 (defvar beginning-of-defun-function nil
|
27190
|
172 "If non-nil, function for `beginning-of-defun-raw' to call.
|
|
173 This is used to find the beginning of the defun instead of using the
|
27380
59243c413664
(beginning-of-defun-function): Variable renamed from beginning-of-defun.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
174 normal recipe (see `beginning-of-defun'). Major modes can define this
|
59243c413664
(beginning-of-defun-function): Variable renamed from beginning-of-defun.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
175 if defining `defun-prompt-regexp' is not sufficient to handle the mode's
|
59243c413664
(beginning-of-defun-function): Variable renamed from beginning-of-defun.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
176 needs.
|
27190
|
177
|
86353
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
178 The function takes the same argument as `beginning-of-defun' and should
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
179 behave similarly, returning non-nil if it found the beginning of a defun.
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
180 Ideally it should move to a point right before an open-paren which encloses
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
181 the body of the defun.")
|
27190
|
182
|
84
|
183 (defun beginning-of-defun (&optional arg)
|
|
184 "Move backward to the beginning of a defun.
|
27190
|
185 With ARG, do it that many times. Negative arg -N
|
84
|
186 means move forward to Nth following beginning of defun.
|
|
187 Returns t unless search stops due to beginning or end of buffer.
|
|
188
|
74708
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
189 If variable `beginning-of-defun-function' is non-nil, its value
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
190 is called as a function to find the defun's beginning.
|
27190
|
191
|
74708
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
192 Normally a defun is assumed to start where there is a char with
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
193 open-parenthesis syntax at the beginning of a line. If
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
194 `defun-prompt-regexp' is non-nil, then a string which matches
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
195 that regexp may precede the open-parenthesis, and point ends up
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
196 at the beginning of the line.
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
197
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
198 If `defun-prompt-regexp' and `open-paren-in-column-0-is-defun-start'
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
199 are both nil, the function instead finds an open-paren at the
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
200 outermost level."
|
6397
|
201 (interactive "p")
|
58962
|
202 (or (not (eq this-command 'beginning-of-defun))
|
58918
|
203 (eq last-command 'beginning-of-defun)
|
|
204 (and transient-mark-mode mark-active)
|
|
205 (push-mark))
|
6397
|
206 (and (beginning-of-defun-raw arg)
|
|
207 (progn (beginning-of-line) t)))
|
|
208
|
|
209 (defun beginning-of-defun-raw (&optional arg)
|
|
210 "Move point to the character that starts a defun.
|
27190
|
211 This is identical to function `beginning-of-defun', except that point
|
|
212 does not move to the beginning of the line when `defun-prompt-regexp'
|
|
213 is non-nil.
|
|
214
|
27380
59243c413664
(beginning-of-defun-function): Variable renamed from beginning-of-defun.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
215 If variable `beginning-of-defun-function' is non-nil, its value
|
59243c413664
(beginning-of-defun-function): Variable renamed from beginning-of-defun.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
216 is called as a function to find the defun's beginning."
|
74708
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
217 (interactive "p") ; change this to "P", maybe, if we ever come to pass ARG
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
218 ; to beginning-of-defun-function.
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
219 (unless arg (setq arg 1))
|
73832
|
220 (cond
|
|
221 (beginning-of-defun-function
|
86353
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
222 (condition-case nil
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
223 (funcall beginning-of-defun-function arg)
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
224 ;; We used to define beginning-of-defun-function as taking no argument
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
225 ;; but that makes it impossible to implement correct forward motion:
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
226 ;; we used to use end-of-defun for that, but it's not supposed to do
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
227 ;; the same thing (it moves to the end of a defun not to the beginning
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
228 ;; of the next).
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
229 ;; In case the beginning-of-defun-function uses the old calling
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
230 ;; convention, fallback on the old implementation.
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
231 (wrong-number-of-arguments
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
232 (if (> arg 0)
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
233 (dotimes (i arg)
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
234 (funcall beginning-of-defun-function))
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
235 ;; Better not call end-of-defun-function directly, in case
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
236 ;; it's not defined.
|
480a058ecb2f
(beginning-of-defun-raw): Pass `arg' down to beginning-of-defun-function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
237 (end-of-defun (- arg))))))
|
73832
|
238
|
|
239 ((or defun-prompt-regexp open-paren-in-column-0-is-defun-start)
|
|
240 (and (< arg 0) (not (eobp)) (forward-char 1))
|
27190
|
241 (and (re-search-backward (if defun-prompt-regexp
|
28299
|
242 (concat (if open-paren-in-column-0-is-defun-start
|
|
243 "^\\s(\\|" "")
|
51084
|
244 "\\(?:" defun-prompt-regexp "\\)\\s(")
|
27190
|
245 "^\\s(")
|
73832
|
246 nil 'move arg)
|
|
247 (progn (goto-char (1- (match-end 0)))) t))
|
|
248
|
74708
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
249 ;; If open-paren-in-column-0-is-defun-start and defun-prompt-regexp
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
250 ;; are both nil, column 0 has no significance - so scan forward
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
251 ;; from BOB to see how nested point is, then carry on from there.
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
252 ;;
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
253 ;; It is generally not a good idea to land up here, because the
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
254 ;; call to scan-lists below can be extremely slow. This is because
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
255 ;; back_comment in syntax.c may have to scan from bob to find the
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
256 ;; beginning of each comment. Fixing this is not trivial -- cyd.
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
257
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
258 ((eq arg 0))
|
73832
|
259 (t
|
74708
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
260 (let ((floor (point-min))
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
261 (ceiling (point-max))
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
262 (arg-+ve (> arg 0)))
|
73832
|
263 (save-restriction
|
|
264 (widen)
|
74708
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
265 (let ((ppss (let (syntax-begin-function
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
266 font-lock-beginning-of-syntax-function)
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
267 (syntax-ppss)))
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
268 ;; position of least enclosing paren, or nil.
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
269 encl-pos)
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
270 ;; Back out of any comment/string, so that encl-pos will always
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
271 ;; become nil if we're at top-level.
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
272 (when (nth 8 ppss)
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
273 (goto-char (nth 8 ppss))
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
274 (setq ppss (syntax-ppss))) ; should be fast, due to cache.
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
275 (setq encl-pos (syntax-ppss-toplevel-pos ppss))
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
276 (if encl-pos (goto-char encl-pos))
|
73832
|
277
|
74708
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
278 (and encl-pos arg-+ve (setq arg (1- arg)))
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
279 (and (not encl-pos) (not arg-+ve) (not (looking-at "\\s("))
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
280 (setq arg (1+ arg)))
|
73832
|
281
|
74708
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
282 (condition-case nil ; to catch crazy parens.
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
283 (progn
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
284 (goto-char (scan-lists (point) (- arg) 0))
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
285 (if arg-+ve
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
286 (if (>= (point) floor)
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
287 t
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
288 (goto-char floor)
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
289 nil)
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
290 ;; forward to next (, or trigger the c-c
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
291 (goto-char (1- (scan-lists (point) 1 -1)))
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
292 (if (<= (point) ceiling)
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
293 t
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
294 (goto-char ceiling)
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
295 nil)))
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
296 (error
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
297 (goto-char (if arg-+ve floor ceiling))
|
ba0b39efd315
(beginning-of-defun-raw): Optimise (for speed) the case when
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
298 nil))))))))
|
27190
|
299
|
86454
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
300 (defvar end-of-defun-function #'forward-sexp
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
301 "Function for `end-of-defun' to call.
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
302 This is used to find the end of the defun.
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
303 It is called with no argument, right after calling `beginning-of-defun-raw'.
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
304 So the function can assume that point is at the beginning of the defun body.")
|
84
|
305
|
|
306 (defun buffer-end (arg)
|
61401
99b039f2f040
(defun-prompt-regexp, parens-require-spaces, buffer-end, end-of-defun)
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
307 "Return the \"far end\" position of the buffer, in direction ARG.
|
59940
|
308 If ARG is positive, that's the end of the buffer.
|
|
309 Otherwise, that's the beginning of the buffer."
|
84
|
310 (if (> arg 0) (point-max) (point-min)))
|
|
311
|
|
312 (defun end-of-defun (&optional arg)
|
61401
99b039f2f040
(defun-prompt-regexp, parens-require-spaces, buffer-end, end-of-defun)
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
313 "Move forward to next end of defun.
|
99b039f2f040
(defun-prompt-regexp, parens-require-spaces, buffer-end, end-of-defun)
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
314 With argument, do it that many times.
|
84
|
315 Negative argument -N means move back to Nth preceding end of defun.
|
|
316
|
27190
|
317 An end of a defun occurs right after the close-parenthesis that
|
|
318 matches the open-parenthesis that starts a defun; see function
|
27380
59243c413664
(beginning-of-defun-function): Variable renamed from beginning-of-defun.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
319 `beginning-of-defun'.
|
59243c413664
(beginning-of-defun-function): Variable renamed from beginning-of-defun.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
320
|
59243c413664
(beginning-of-defun-function): Variable renamed from beginning-of-defun.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
321 If variable `end-of-defun-function' is non-nil, its value
|
59243c413664
(beginning-of-defun-function): Variable renamed from beginning-of-defun.
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
322 is called as a function to find the defun's end."
|
84
|
323 (interactive "p")
|
58962
|
324 (or (not (eq this-command 'end-of-defun))
|
58918
|
325 (eq last-command 'end-of-defun)
|
|
326 (and transient-mark-mode mark-active)
|
|
327 (push-mark))
|
54876
|
328 (if (or (null arg) (= arg 0)) (setq arg 1))
|
86454
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
329 (while (> arg 0)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
330 (let ((pos (point)))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
331 (end-of-line 1)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
332 (beginning-of-defun-raw 1)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
333 (while (unless (eobp)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
334 (funcall end-of-defun-function)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
335 (skip-chars-forward " \t")
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
336 (if (looking-at "\\s<\\|\n")
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
337 (forward-line 1))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
338 ;; If we started after the end of the previous function, then
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
339 ;; try again with the next one.
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
340 (when (<= (point) pos)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
341 (or (bobp) (forward-char -1))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
342 (beginning-of-defun-raw -1)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
343 'try-again))))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
344 (setq arg (1- arg)))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
345 (while (< arg 0)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
346 (let ((pos (point)))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
347 (while (unless (bobp)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
348 (beginning-of-line 1)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
349 (beginning-of-defun-raw 1)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
350 (let ((beg (point)))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
351 (funcall end-of-defun-function)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
352 (skip-chars-forward " \t")
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
353 (if (looking-at "\\s<\\|\n")
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
354 (forward-line 1))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
355 ;; If we started from within the function just found, then
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
356 ;; try again with the previous one.
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
357 (when (>= (point) pos)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
358 (goto-char beg)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
359 'try-again)))))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
360 (setq arg (1+ arg))))
|
84
|
361
|
59177
|
362 (defun mark-defun (&optional allow-extend)
|
84
|
363 "Put mark at end of this defun, point at beginning.
|
43301
|
364 The defun marked is the one that contains point or follows point.
|
59177
|
365
|
|
366 Interactively, if this command is repeated
|
61401
99b039f2f040
(defun-prompt-regexp, parens-require-spaces, buffer-end, end-of-defun)
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
367 or (in Transient Mark mode) if the mark is active,
|
59177
|
368 it marks the next defun after the ones already marked."
|
|
369 (interactive "p")
|
|
370 (cond ((and allow-extend
|
|
371 (or (and (eq last-command this-command) (mark t))
|
|
372 (and transient-mark-mode mark-active)))
|
43384
cc3ba2d0d471
* emacs-lisp/lisp.el (mark-defun): Don't leave multiple marks
Kai Großjohann <kgrossjo@eu.uu.net>
diff
changeset
|
373 (set-mark
|
cc3ba2d0d471
* emacs-lisp/lisp.el (mark-defun): Don't leave multiple marks
Kai Großjohann <kgrossjo@eu.uu.net>
diff
changeset
|
374 (save-excursion
|
cc3ba2d0d471
* emacs-lisp/lisp.el (mark-defun): Don't leave multiple marks
Kai Großjohann <kgrossjo@eu.uu.net>
diff
changeset
|
375 (goto-char (mark))
|
cc3ba2d0d471
* emacs-lisp/lisp.el (mark-defun): Don't leave multiple marks
Kai Großjohann <kgrossjo@eu.uu.net>
diff
changeset
|
376 (end-of-defun)
|
cc3ba2d0d471
* emacs-lisp/lisp.el (mark-defun): Don't leave multiple marks
Kai Großjohann <kgrossjo@eu.uu.net>
diff
changeset
|
377 (point))))
|
cc3ba2d0d471
* emacs-lisp/lisp.el (mark-defun): Don't leave multiple marks
Kai Großjohann <kgrossjo@eu.uu.net>
diff
changeset
|
378 (t
|
55727
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
379 (let ((opoint (point))
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
380 beg end)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
381 (push-mark opoint)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
382 ;; Try first in this order for the sake of languages with nested
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
383 ;; functions where several can end at the same place as with
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
384 ;; the offside rule, e.g. Python.
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
385 (beginning-of-defun)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
386 (setq beg (point))
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
387 (end-of-defun)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
388 (setq end (point))
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
389 (while (looking-at "^\n")
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
390 (forward-line 1))
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
391 (if (> (point) opoint)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
392 (progn
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
393 ;; We got the right defun.
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
394 (push-mark beg nil t)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
395 (goto-char end)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
396 (exchange-point-and-mark))
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
397 ;; beginning-of-defun moved back one defun
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
398 ;; so we got the wrong one.
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
399 (goto-char opoint)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
400 (end-of-defun)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
401 (push-mark (point) nil t)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
402 (beginning-of-defun))
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
403 (re-search-backward "^\n" (- (point) 1) t)))))
|
84
|
404
|
15971
|
405 (defun narrow-to-defun (&optional arg)
|
|
406 "Make text outside current defun invisible.
|
27190
|
407 The defun visible is the one that contains point or follows point.
|
|
408 Optional ARG is ignored."
|
15971
|
409 (interactive)
|
|
410 (save-excursion
|
|
411 (widen)
|
55727
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
412 (let ((opoint (point))
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
413 beg end)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
414 ;; Try first in this order for the sake of languages with nested
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
415 ;; functions where several can end at the same place as with
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
416 ;; the offside rule, e.g. Python.
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
417 (beginning-of-defun)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
418 (setq beg (point))
|
53752
|
419 (end-of-defun)
|
55727
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
420 (setq end (point))
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
421 (while (looking-at "^\n")
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
422 (forward-line 1))
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
423 (unless (> (point) opoint)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
424 ;; beginning-of-defun moved back one defun
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
425 ;; so we got the wrong one.
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
426 (goto-char opoint)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
427 (end-of-defun)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
428 (setq end (point))
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
429 (beginning-of-defun)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
430 (setq beg (point)))
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
431 (goto-char end)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
432 (re-search-backward "^\n" (- (point) 1) t)
|
babf5161afd4
(mark-defun, narrow-to-defun): If moving back then fwd gets a defun
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
433 (narrow-to-region beg end))))
|
15971
|
434
|
55807
|
435 (defvar insert-pair-alist
|
|
436 '((?\( ?\)) (?\[ ?\]) (?\{ ?\}) (?\< ?\>) (?\" ?\") (?\' ?\') (?\` ?\'))
|
|
437 "Alist of paired characters inserted by `insert-pair'.
|
|
438 Each element looks like (OPEN-CHAR CLOSE-CHAR) or (COMMAND-CHAR
|
|
439 OPEN-CHAR CLOSE-CHAR). The characters OPEN-CHAR and CLOSE-CHAR
|
|
440 of the pair whose key is equal to the last input character with
|
|
441 or without modifiers, are inserted by `insert-pair'.")
|
|
442
|
|
443 (defun insert-pair (&optional arg open close)
|
55277
|
444 "Enclose following ARG sexps in a pair of OPEN and CLOSE characters.
|
|
445 Leave point after the first character.
|
|
446 A negative ARG encloses the preceding ARG sexps instead.
|
|
447 No argument is equivalent to zero: just insert characters
|
|
448 and leave point between.
|
|
449 If `parens-require-spaces' is non-nil, this command also inserts a space
|
|
450 before and after, depending on the surrounding characters.
|
55807
|
451 If region is active, insert enclosing characters at region boundaries.
|
|
452
|
|
453 If arguments OPEN and CLOSE are nil, the character pair is found
|
|
454 from the variable `insert-pair-alist' according to the last input
|
|
455 character with or without modifiers. If no character pair is
|
|
456 found in the variable `insert-pair-alist', then the last input
|
|
457 character is inserted ARG times."
|
55277
|
458 (interactive "P")
|
55807
|
459 (if (not (and open close))
|
|
460 (let ((pair (or (assq last-command-char insert-pair-alist)
|
|
461 (assq (event-basic-type last-command-event)
|
|
462 insert-pair-alist))))
|
|
463 (if pair
|
|
464 (if (nth 2 pair)
|
|
465 (setq open (nth 1 pair) close (nth 2 pair))
|
|
466 (setq open (nth 0 pair) close (nth 1 pair))))))
|
|
467 (if (and open close)
|
|
468 (if (and transient-mark-mode mark-active)
|
|
469 (progn
|
|
470 (save-excursion (goto-char (region-end)) (insert close))
|
|
471 (save-excursion (goto-char (region-beginning)) (insert open)))
|
|
472 (if arg (setq arg (prefix-numeric-value arg))
|
|
473 (setq arg 0))
|
|
474 (cond ((> arg 0) (skip-chars-forward " \t"))
|
|
475 ((< arg 0) (forward-sexp arg) (setq arg (- arg))))
|
|
476 (and parens-require-spaces
|
|
477 (not (bobp))
|
|
478 (memq (char-syntax (preceding-char)) (list ?w ?_ (char-syntax close)))
|
|
479 (insert " "))
|
|
480 (insert open)
|
|
481 (save-excursion
|
|
482 (or (eq arg 0) (forward-sexp arg))
|
|
483 (insert close)
|
|
484 (and parens-require-spaces
|
|
485 (not (eobp))
|
|
486 (memq (char-syntax (following-char)) (list ?w ?_ (char-syntax open)))
|
|
487 (insert " "))))
|
|
488 (insert-char (event-basic-type last-command-event)
|
|
489 (prefix-numeric-value arg))))
|
55277
|
490
|
55807
|
491 (defun insert-parentheses (&optional arg)
|
61401
99b039f2f040
(defun-prompt-regexp, parens-require-spaces, buffer-end, end-of-defun)
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
492 "Enclose following ARG sexps in parentheses.
|
99b039f2f040
(defun-prompt-regexp, parens-require-spaces, buffer-end, end-of-defun)
Luc Teirlinck <teirllm@auburn.edu>
diff
changeset
|
493 Leave point after open-paren.
|
16410
454a13718b1f
(narrow-to-defun): Narrow to the same defun that `mark-defun' would make
Erik Naggum <erik@naggum.no>
diff
changeset
|
494 A negative ARG encloses the preceding ARG sexps instead.
|
3733
|
495 No argument is equivalent to zero: just insert `()' and leave point between.
|
5838
|
496 If `parens-require-spaces' is non-nil, this command also inserts a space
|
55277
|
497 before and after, depending on the surrounding characters.
|
|
498 If region is active, insert enclosing characters at region boundaries."
|
84
|
499 (interactive "P")
|
55277
|
500 (insert-pair arg ?\( ?\)))
|
84
|
501
|
55807
|
502 (defun delete-pair ()
|
|
503 "Delete a pair of characters enclosing the sexp that follows point."
|
|
504 (interactive)
|
|
505 (save-excursion (forward-sexp 1) (delete-char -1))
|
|
506 (delete-char 1))
|
|
507
|
|
508 (defun raise-sexp (&optional arg)
|
|
509 "Raise ARG sexps higher up the tree."
|
|
510 (interactive "p")
|
|
511 (let ((s (if (and transient-mark-mode mark-active)
|
|
512 (buffer-substring (region-beginning) (region-end))
|
|
513 (buffer-substring
|
|
514 (point)
|
|
515 (save-excursion (forward-sexp arg) (point))))))
|
|
516 (backward-up-list 1)
|
|
517 (delete-region (point) (save-excursion (forward-sexp 1) (point)))
|
|
518 (save-excursion (insert s))))
|
|
519
|
84
|
520 (defun move-past-close-and-reindent ()
|
|
521 "Move past next `)', delete indentation before it, then indent after it."
|
|
522 (interactive)
|
|
523 (up-list 1)
|
|
524 (forward-char -1)
|
|
525 (while (save-excursion ; this is my contribution
|
|
526 (let ((before-paren (point)))
|
|
527 (back-to-indentation)
|
19781
|
528 (and (= (point) before-paren)
|
|
529 (progn
|
|
530 ;; Move to end of previous line.
|
|
531 (beginning-of-line)
|
|
532 (forward-char -1)
|
|
533 ;; Verify it doesn't end within a string or comment.
|
|
534 (let ((end (point))
|
|
535 state)
|
|
536 (beginning-of-line)
|
|
537 ;; Get state at start of line.
|
27190
|
538 (setq state (list 0 nil nil
|
19781
|
539 (null (calculate-lisp-indent))
|
|
540 nil nil nil nil
|
|
541 nil))
|
|
542 ;; Parse state across the line to get state at end.
|
|
543 (setq state (parse-partial-sexp (point) end nil nil
|
|
544 state))
|
|
545 ;; Check not in string or comment.
|
|
546 (and (not (elt state 3)) (not (elt state 4))))))))
|
84
|
547 (delete-indentation))
|
|
548 (forward-char 1)
|
|
549 (newline-and-indent))
|
27190
|
550
|
|
551 (defun check-parens () ; lame name?
|
|
552 "Check for unbalanced parentheses in the current buffer.
|
|
553 More accurately, check the narrowed part of the buffer for unbalanced
|
|
554 expressions (\"sexps\") in general. This is done according to the
|
|
555 current syntax table and will find unbalanced brackets or quotes as
|
62455
|
556 appropriate. (See Info node `(emacs)Parentheses'.) If imbalance is
|
63624
|
557 found, an error is signaled and point is left at the first unbalanced
|
62455
|
558 character."
|
27190
|
559 (interactive)
|
|
560 (condition-case data
|
|
561 ;; Buffer can't have more than (point-max) sexps.
|
|
562 (scan-sexps (point-min) (point-max))
|
|
563 (scan-error (goto-char (nth 2 data))
|
|
564 ;; Could print (nth 1 data), which is either
|
|
565 ;; "Containing expression ends prematurely" or
|
|
566 ;; "Unbalanced parentheses", but those may not be so
|
|
567 ;; accurate/helpful, e.g. quotes may actually be
|
|
568 ;; mismatched.
|
86454
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
569 (error "Unmatched bracket or quote"))))
|
84
|
570
|
86454
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
571 (defun field-complete (table &optional predicate)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
572 (let* ((pattern (field-string-no-properties))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
573 (completion (try-completion pattern table predicate)))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
574 (cond ((eq completion t))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
575 ((null completion)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
576 (message "Can't find completion for \"%s\"" pattern)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
577 (ding))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
578 ((not (string= pattern completion))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
579 (delete-region (field-beginning) (field-end))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
580 (insert completion)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
581 ;; Don't leave around a completions buffer that's out of date.
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
582 (let ((win (get-buffer-window "*Completions*" 0)))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
583 (if win (with-selected-window win (bury-buffer)))))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
584 (t
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
585 (let ((minibuf-is-in-use
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
586 (eq (minibuffer-window) (selected-window))))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
587 (unless minibuf-is-in-use
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
588 (message "Making completion list..."))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
589 (let ((list (all-completions pattern table predicate)))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
590 (setq list (sort list 'string<))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
591 (or (eq predicate 'fboundp)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
592 (let (new)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
593 (while list
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
594 (setq new (cons (if (fboundp (intern (car list)))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
595 (list (car list) " <f>")
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
596 (car list))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
597 new))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
598 (setq list (cdr list)))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
599 (setq list (nreverse new))))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
600 (if (> (length list) 1)
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
601 (with-output-to-temp-buffer "*Completions*"
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
602 (display-completion-list list pattern))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
603 ;; Don't leave around a completions buffer that's
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
604 ;; out of date.
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
605 (let ((win (get-buffer-window "*Completions*" 0)))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
606 (if win (with-selected-window win (bury-buffer))))))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
607 (unless minibuf-is-in-use
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
608 (message "Making completion list...%s" "done")))))))
|
ebd4b500132c
(end-of-defun): Restructure so that end-of-defun-function is called
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
609
|
30979
|
610 (defun lisp-complete-symbol (&optional predicate)
|
6004
|
611 "Perform completion on Lisp symbol preceding point.
|
|
612 Compare that symbol against the known Lisp symbols.
|
42658
|
613 If no characters can be completed, display a list of possible completions.
|
|
614 Repeating the command at that point scrolls the list.
|
6004
|
615
|
30979
|
616 When called from a program, optional arg PREDICATE is a predicate
|
|
617 determining which symbols are considered, e.g. `commandp'.
|
|
618 If PREDICATE is nil, the context determines which symbols are
|
|
619 considered. If the symbol starts just after an open-parenthesis, only
|
|
620 symbols with function definitions are considered. Otherwise, all
|
|
621 symbols with function definitions, values or properties are
|
|
622 considered."
|
84
|
623 (interactive)
|
76768
36178b78d004
(lisp-complete-symbol): Make get-buffer-window find windows in other frames.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
624 (let ((window (get-buffer-window "*Completions*" 0)))
|
42658
|
625 (if (and (eq last-command this-command)
|
|
626 window (window-live-p window) (window-buffer window)
|
|
627 (buffer-name (window-buffer window)))
|
|
628 ;; If this command was repeated, and
|
|
629 ;; there's a fresh completion window with a live buffer,
|
|
630 ;; and this command is repeated, scroll that window.
|
|
631 (with-current-buffer (window-buffer window)
|
|
632 (if (pos-visible-in-window-p (point-max) window)
|
|
633 (set-window-start window (point-min))
|
|
634 (save-selected-window
|
|
635 (select-window window)
|
|
636 (scroll-up))))
|
|
637
|
|
638 ;; Do completion.
|
|
639 (let* ((end (point))
|
|
640 (beg (with-syntax-table emacs-lisp-mode-syntax-table
|
|
641 (save-excursion
|
|
642 (backward-sexp 1)
|
|
643 (while (= (char-syntax (following-char)) ?\')
|
|
644 (forward-char 1))
|
|
645 (point))))
|
|
646 (pattern (buffer-substring-no-properties beg end))
|
|
647 (predicate
|
|
648 (or predicate
|
|
649 (save-excursion
|
|
650 (goto-char beg)
|
|
651 (if (not (eq (char-before) ?\())
|
|
652 (lambda (sym) ;why not just nil ? -sm
|
|
653 (or (boundp sym) (fboundp sym)
|
|
654 (symbol-plist sym)))
|
|
655 ;; Looks like a funcall position. Let's double check.
|
|
656 (if (condition-case nil
|
|
657 (progn (up-list -2) (forward-char 1)
|
|
658 (eq (char-after) ?\())
|
|
659 (error nil))
|
|
660 ;; If the first element of the parent list is an open
|
|
661 ;; parenthesis we are probably not in a funcall position.
|
|
662 ;; Maybe a `let' varlist or something.
|
|
663 nil
|
|
664 ;; Else, we assume that a function name is expected.
|
|
665 'fboundp)))))
|
|
666 (completion (try-completion pattern obarray predicate)))
|
|
667 (cond ((eq completion t))
|
|
668 ((null completion)
|
|
669 (message "Can't find completion for \"%s\"" pattern)
|
|
670 (ding))
|
67728
bffc4c57eda9
(lisp-complete-symbol): Mostly undo the change by Kevin Rodgers.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
671 ((not (string= pattern completion))
|
bffc4c57eda9
(lisp-complete-symbol): Mostly undo the change by Kevin Rodgers.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
672 (delete-region beg end)
|
bffc4c57eda9
(lisp-complete-symbol): Mostly undo the change by Kevin Rodgers.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
673 (insert completion)
|
67730
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
674 ;; Don't leave around a completions buffer that's out of date.
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
675 (let ((win (get-buffer-window "*Completions*" 0)))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
676 (if win (with-selected-window win (bury-buffer)))))
|
42658
|
677 (t
|
67730
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
678 (let ((minibuf-is-in-use
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
679 (eq (minibuffer-window) (selected-window))))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
680 (unless minibuf-is-in-use
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
681 (message "Making completion list..."))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
682 (let ((list (all-completions pattern obarray predicate)))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
683 (setq list (sort list 'string<))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
684 (or (eq predicate 'fboundp)
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
685 (let (new)
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
686 (while list
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
687 (setq new (cons (if (fboundp (intern (car list)))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
688 (list (car list) " <f>")
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
689 (car list))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
690 new))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
691 (setq list (cdr list)))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
692 (setq list (nreverse new))))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
693 (if (> (length list) 1)
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
694 (with-output-to-temp-buffer "*Completions*"
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
695 (display-completion-list list pattern))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
696 ;; Don't leave around a completions buffer that's
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
697 ;; out of date.
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
698 (let ((win (get-buffer-window "*Completions*" 0)))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
699 (if win (with-selected-window win (bury-buffer))))))
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
700 (unless minibuf-is-in-use
|
1ee1a77d8b03
(lisp-complete-symbol): Don't print progress messages if in the
Romain Francoise <romain@orebokech.com>
diff
changeset
|
701 (message "Making completion list...%s" "done")))))))))
|
659
|
702
|
67721
d372bc6eff1d
(lisp-complete-symbol): Don't call delete-windows-on with an inexistent buffer.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
703 ;; arch-tag: aa7fa8a4-2e6f-4e9b-9cd9-fef06340e67e
|
659
|
704 ;;; lisp.el ends here
|