Mercurial > emacs
annotate lisp/emacs-lisp/lisp.el @ 26940:f1998d661bc2
Remove conditional definition of eval-when-compile. Don't specify abs,
expt, gethash, hash-table-count, hash-table-p as side-effect-free here.
(cl-emacs-type): Don't declare.
(cl-compile-time-init): Remove Emacs 18 compiler patch.
(cl-parse-loop-clause): Remove compatibility code.
author | Dave Love <fx@gnu.org> |
---|---|
date | Sat, 18 Dec 1999 17:10:56 +0000 |
parents | 4b8c40cf1931 |
children | f132d890985a |
rev | line source |
---|---|
659
505130d1ddf8
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
215
diff
changeset
|
1 ;;; lisp.el --- Lisp editing commands for Emacs |
505130d1ddf8
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
215
diff
changeset
|
2 |
7300 | 3 ;; Copyright (C) 1985, 1986, 1994 Free Software Foundation, Inc. |
845 | 4 |
807
4f28bd14272c
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
659
diff
changeset
|
5 ;; Maintainer: FSF |
2247
2c7997f249eb
Add or correct keywords
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
845
diff
changeset
|
6 ;; Keywords: lisp, languages |
807
4f28bd14272c
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
659
diff
changeset
|
7 |
84 | 8 ;; This file is part of GNU Emacs. |
9 | |
10 ;; GNU Emacs is free software; you can redistribute it and/or modify | |
11 ;; it under the terms of the GNU General Public License as published by | |
807
4f28bd14272c
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
659
diff
changeset
|
12 ;; the Free Software Foundation; either version 2, or (at your option) |
84 | 13 ;; any later version. |
14 | |
15 ;; GNU Emacs is distributed in the hope that it will be useful, | |
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 ;; GNU General Public License for more details. | |
19 | |
20 ;; You should have received a copy of the GNU General Public License | |
14169 | 21 ;; along with GNU Emacs; see the file COPYING. If not, write to the |
22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
23 ;; Boston, MA 02111-1307, USA. | |
84 | 24 |
2307
10e417efb12a
Added or corrected Commentary sections
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
2247
diff
changeset
|
25 ;;; Commentary: |
10e417efb12a
Added or corrected Commentary sections
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
2247
diff
changeset
|
26 |
3591
507f64624555
Apply typo patches from Paul Eggert.
Jim Blandy <jimb@redhat.com>
parents:
2823
diff
changeset
|
27 ;; Lisp editing commands to go with Lisp major mode. |
2307
10e417efb12a
Added or corrected Commentary sections
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
2247
diff
changeset
|
28 |
807
4f28bd14272c
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
659
diff
changeset
|
29 ;;; Code: |
84 | 30 |
6369 | 31 ;; Note that this variable is used by non-lisp modes too. |
17665 | 32 (defcustom defun-prompt-regexp nil |
6369 | 33 "*Non-nil => regexp to ignore, before the character that starts a defun. |
34 This is only necessary if the opening paren or brace is not in column 0. | |
17665 | 35 See `beginning-of-defun'." |
19831
a517c846d04e
(defun-prompt-regexp): Fix customize type.
Richard M. Stallman <rms@gnu.org>
parents:
19781
diff
changeset
|
36 :type '(choice (const nil) |
a517c846d04e
(defun-prompt-regexp): Fix customize type.
Richard M. Stallman <rms@gnu.org>
parents:
19781
diff
changeset
|
37 regexp) |
17665 | 38 :group 'lisp) |
6973
7aa70fb3afa8
(defun-prompt-regexp): Make this variable buffer-local.
Karl Heuer <kwzh@gnu.org>
parents:
6420
diff
changeset
|
39 (make-variable-buffer-local 'defun-prompt-regexp) |
84 | 40 |
17665 | 41 (defcustom parens-require-spaces t |
42 "Non-nil => `insert-parentheses' should insert whitespace as needed." | |
43 :type 'boolean | |
44 :group 'lisp) | |
3733
c1c105ffdd0c
(parens-dont-require-spaces): New variable.
Richard M. Stallman <rms@gnu.org>
parents:
3591
diff
changeset
|
45 |
84 | 46 (defun forward-sexp (&optional arg) |
47 "Move forward across one balanced expression (sexp). | |
215 | 48 With argument, do it that many times. Negative arg -N means |
49 move backward across N balanced expressions." | |
84 | 50 (interactive "p") |
51 (or arg (setq arg 1)) | |
52 (goto-char (or (scan-sexps (point) arg) (buffer-end arg))) | |
53 (if (< arg 0) (backward-prefix-chars))) | |
54 | |
55 (defun backward-sexp (&optional arg) | |
56 "Move backward across one balanced expression (sexp). | |
215 | 57 With argument, do it that many times. Negative arg -N means |
58 move forward across N balanced expressions." | |
84 | 59 (interactive "p") |
60 (or arg (setq arg 1)) | |
61 (forward-sexp (- arg))) | |
62 | |
63 (defun mark-sexp (arg) | |
64 "Set mark ARG sexps from point. | |
215 | 65 The place mark goes is the same place \\[forward-sexp] would |
66 move to with the same argument." | |
84 | 67 (interactive "p") |
68 (push-mark | |
69 (save-excursion | |
70 (forward-sexp arg) | |
2823
8ab0e280fbf0
(mark-sexp, mark-defun): Activate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
2307
diff
changeset
|
71 (point)) |
8ab0e280fbf0
(mark-sexp, mark-defun): Activate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
2307
diff
changeset
|
72 nil t)) |
84 | 73 |
74 (defun forward-list (&optional arg) | |
75 "Move forward across one balanced group of parentheses. | |
76 With argument, do it that many times. | |
77 Negative arg -N means move backward across N groups of parentheses." | |
78 (interactive "p") | |
79 (or arg (setq arg 1)) | |
80 (goto-char (or (scan-lists (point) arg 0) (buffer-end arg)))) | |
81 | |
82 (defun backward-list (&optional arg) | |
83 "Move backward across one balanced group of parentheses. | |
84 With argument, do it that many times. | |
85 Negative arg -N means move forward across N groups of parentheses." | |
86 (interactive "p") | |
87 (or arg (setq arg 1)) | |
88 (forward-list (- arg))) | |
89 | |
90 (defun down-list (arg) | |
91 "Move forward down one level of parentheses. | |
92 With argument, do this that many times. | |
93 A negative argument means move backward but still go down a level. | |
94 In Lisp programs, an argument is required." | |
95 (interactive "p") | |
96 (let ((inc (if (> arg 0) 1 -1))) | |
97 (while (/= arg 0) | |
98 (goto-char (or (scan-lists (point) inc -1) (buffer-end arg))) | |
99 (setq arg (- arg inc))))) | |
100 | |
101 (defun backward-up-list (arg) | |
102 "Move backward out of one level of parentheses. | |
103 With argument, do this that many times. | |
104 A negative argument means move forward but still to a less deep spot. | |
105 In Lisp programs, an argument is required." | |
106 (interactive "p") | |
107 (up-list (- arg))) | |
108 | |
109 (defun up-list (arg) | |
110 "Move forward out of one level of parentheses. | |
111 With argument, do this that many times. | |
112 A negative argument means move backward but still to a less deep spot. | |
113 In Lisp programs, an argument is required." | |
114 (interactive "p") | |
115 (let ((inc (if (> arg 0) 1 -1))) | |
116 (while (/= arg 0) | |
117 (goto-char (or (scan-lists (point) inc 1) (buffer-end arg))) | |
118 (setq arg (- arg inc))))) | |
119 | |
120 (defun kill-sexp (arg) | |
121 "Kill the sexp (balanced expression) following the cursor. | |
122 With argument, kill that many sexps after the cursor. | |
123 Negative arg -N means kill N sexps before the cursor." | |
124 (interactive "p") | |
125 (let ((opoint (point))) | |
126 (forward-sexp arg) | |
127 (kill-region opoint (point)))) | |
128 | |
129 (defun backward-kill-sexp (arg) | |
130 "Kill the sexp (balanced expression) preceding the cursor. | |
131 With argument, kill that many sexps before the cursor. | |
132 Negative arg -N means kill N sexps after the cursor." | |
133 (interactive "p") | |
134 (kill-sexp (- arg))) | |
135 | |
136 (defun beginning-of-defun (&optional arg) | |
137 "Move backward to the beginning of a defun. | |
138 With argument, do it that many times. Negative arg -N | |
139 means move forward to Nth following beginning of defun. | |
140 Returns t unless search stops due to beginning or end of buffer. | |
141 | |
142 Normally a defun starts when there is an char with open-parenthesis | |
143 syntax at the beginning of a line. If `defun-prompt-regexp' is | |
144 non-nil, then a string which matches that regexp may precede the | |
6397
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
145 open-parenthesis, and point ends up at the beginning of the line." |
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
146 (interactive "p") |
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
147 (and (beginning-of-defun-raw arg) |
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
148 (progn (beginning-of-line) t))) |
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
149 |
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
150 (defun beginning-of-defun-raw (&optional arg) |
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
151 "Move point to the character that starts a defun. |
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
152 This is identical to beginning-of-defun, except that point does not move |
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
153 to the beginning of the line when `defun-prompt-regexp' is non-nil." |
84 | 154 (interactive "p") |
6420
09fadfc6384e
(beginning-of-defun-raw): Don't err when called at end of buffer.
Karl Heuer <kwzh@gnu.org>
parents:
6397
diff
changeset
|
155 (and arg (< arg 0) (not (eobp)) (forward-char 1)) |
84 | 156 (and (re-search-backward (if defun-prompt-regexp |
157 (concat "^\\s(\\|" | |
158 "\\(" defun-prompt-regexp "\\)\\s(") | |
159 "^\\s(") | |
160 nil 'move (or arg 1)) | |
6397
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
161 (progn (goto-char (1- (match-end 0)))) t)) |
84 | 162 |
163 (defun buffer-end (arg) | |
164 (if (> arg 0) (point-max) (point-min))) | |
165 | |
166 (defun end-of-defun (&optional arg) | |
167 "Move forward to next end of defun. With argument, do it that many times. | |
168 Negative argument -N means move back to Nth preceding end of defun. | |
169 | |
170 An end of a defun occurs right after the close-parenthesis that matches | |
171 the open-parenthesis that starts a defun; see `beginning-of-defun'." | |
172 (interactive "p") | |
173 (if (or (null arg) (= arg 0)) (setq arg 1)) | |
174 (let ((first t)) | |
175 (while (and (> arg 0) (< (point) (point-max))) | |
176 (let ((pos (point)) npos) | |
177 (while (progn | |
178 (if (and first | |
179 (progn | |
6397
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
180 (end-of-line 1) |
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
181 (beginning-of-defun-raw 1))) |
84 | 182 nil |
183 (or (bobp) (forward-char -1)) | |
6397
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
184 (beginning-of-defun-raw -1)) |
84 | 185 (setq first nil) |
186 (forward-list 1) | |
187 (skip-chars-forward " \t") | |
188 (if (looking-at "\\s<\\|\n") | |
189 (forward-line 1)) | |
190 (<= (point) pos)))) | |
191 (setq arg (1- arg))) | |
192 (while (< arg 0) | |
193 (let ((pos (point))) | |
6397
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
194 (beginning-of-defun-raw 1) |
84 | 195 (forward-sexp 1) |
196 (forward-line 1) | |
197 (if (>= (point) pos) | |
6397
70bf65b6aae9
(beginning-of-defun-raw): New function.
Karl Heuer <kwzh@gnu.org>
parents:
6396
diff
changeset
|
198 (if (beginning-of-defun-raw 2) |
84 | 199 (progn |
200 (forward-list 1) | |
201 (skip-chars-forward " \t") | |
6396
1740ec160ff8
(end-of-defun): Fix check for trailing comment.
Karl Heuer <kwzh@gnu.org>
parents:
6369
diff
changeset
|
202 (if (looking-at "\\s<\\|\n") |
84 | 203 (forward-line 1))) |
204 (goto-char (point-min))))) | |
205 (setq arg (1+ arg))))) | |
206 | |
207 (defun mark-defun () | |
208 "Put mark at end of this defun, point at beginning. | |
209 The defun marked is the one that contains point or follows point." | |
210 (interactive) | |
211 (push-mark (point)) | |
212 (end-of-defun) | |
2823
8ab0e280fbf0
(mark-sexp, mark-defun): Activate the mark.
Richard M. Stallman <rms@gnu.org>
parents:
2307
diff
changeset
|
213 (push-mark (point) nil t) |
84 | 214 (beginning-of-defun) |
215 (re-search-backward "^\n" (- (point) 1) t)) | |
216 | |
15971
9e9c14ecf6e1
(narrow-to-defun): New function.
Richard M. Stallman <rms@gnu.org>
parents:
14169
diff
changeset
|
217 (defun narrow-to-defun (&optional arg) |
9e9c14ecf6e1
(narrow-to-defun): New function.
Richard M. Stallman <rms@gnu.org>
parents:
14169
diff
changeset
|
218 "Make text outside current defun invisible. |
9e9c14ecf6e1
(narrow-to-defun): New function.
Richard M. Stallman <rms@gnu.org>
parents:
14169
diff
changeset
|
219 The defun visible is the one that contains point or follows point." |
9e9c14ecf6e1
(narrow-to-defun): New function.
Richard M. Stallman <rms@gnu.org>
parents:
14169
diff
changeset
|
220 (interactive) |
9e9c14ecf6e1
(narrow-to-defun): New function.
Richard M. Stallman <rms@gnu.org>
parents:
14169
diff
changeset
|
221 (save-excursion |
9e9c14ecf6e1
(narrow-to-defun): New function.
Richard M. Stallman <rms@gnu.org>
parents:
14169
diff
changeset
|
222 (widen) |
16410
454a13718b1f
(narrow-to-defun): Narrow to the same defun that `mark-defun' would make
Erik Naggum <erik@naggum.no>
parents:
15971
diff
changeset
|
223 (end-of-defun) |
454a13718b1f
(narrow-to-defun): Narrow to the same defun that `mark-defun' would make
Erik Naggum <erik@naggum.no>
parents:
15971
diff
changeset
|
224 (let ((end (point))) |
454a13718b1f
(narrow-to-defun): Narrow to the same defun that `mark-defun' would make
Erik Naggum <erik@naggum.no>
parents:
15971
diff
changeset
|
225 (beginning-of-defun) |
454a13718b1f
(narrow-to-defun): Narrow to the same defun that `mark-defun' would make
Erik Naggum <erik@naggum.no>
parents:
15971
diff
changeset
|
226 (narrow-to-region (point) end)))) |
15971
9e9c14ecf6e1
(narrow-to-defun): New function.
Richard M. Stallman <rms@gnu.org>
parents:
14169
diff
changeset
|
227 |
84 | 228 (defun insert-parentheses (arg) |
16410
454a13718b1f
(narrow-to-defun): Narrow to the same defun that `mark-defun' would make
Erik Naggum <erik@naggum.no>
parents:
15971
diff
changeset
|
229 "Enclose following ARG sexps in parentheses. Leave point after open-paren. |
454a13718b1f
(narrow-to-defun): Narrow to the same defun that `mark-defun' would make
Erik Naggum <erik@naggum.no>
parents:
15971
diff
changeset
|
230 A negative ARG encloses the preceding ARG sexps instead. |
3733
c1c105ffdd0c
(parens-dont-require-spaces): New variable.
Richard M. Stallman <rms@gnu.org>
parents:
3591
diff
changeset
|
231 No argument is equivalent to zero: just insert `()' and leave point between. |
5838 | 232 If `parens-require-spaces' is non-nil, this command also inserts a space |
233 before and after, depending on the surrounding characters." | |
84 | 234 (interactive "P") |
133
2f5b3f50773d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
119
diff
changeset
|
235 (if arg (setq arg (prefix-numeric-value arg)) |
2f5b3f50773d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
119
diff
changeset
|
236 (setq arg 0)) |
16410
454a13718b1f
(narrow-to-defun): Narrow to the same defun that `mark-defun' would make
Erik Naggum <erik@naggum.no>
parents:
15971
diff
changeset
|
237 (cond ((> arg 0) (skip-chars-forward " \t")) |
454a13718b1f
(narrow-to-defun): Narrow to the same defun that `mark-defun' would make
Erik Naggum <erik@naggum.no>
parents:
15971
diff
changeset
|
238 ((< arg 0) (forward-sexp arg) (setq arg (- arg)))) |
3758
e212a0863773
(parens-require-spaces): Var renamed and sense changed.
Richard M. Stallman <rms@gnu.org>
parents:
3733
diff
changeset
|
239 (and parens-require-spaces |
8996
06a5ceb0fb21
(insert-parentheses): Don't insert spaces at beginning and end of buffer.
Richard M. Stallman <rms@gnu.org>
parents:
8205
diff
changeset
|
240 (not (bobp)) |
3733
c1c105ffdd0c
(parens-dont-require-spaces): New variable.
Richard M. Stallman <rms@gnu.org>
parents:
3591
diff
changeset
|
241 (memq (char-syntax (preceding-char)) '(?w ?_ ?\) )) |
84 | 242 (insert " ")) |
243 (insert ?\() | |
244 (save-excursion | |
133
2f5b3f50773d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
119
diff
changeset
|
245 (or (eq arg 0) (forward-sexp arg)) |
84 | 246 (insert ?\)) |
3758
e212a0863773
(parens-require-spaces): Var renamed and sense changed.
Richard M. Stallman <rms@gnu.org>
parents:
3733
diff
changeset
|
247 (and parens-require-spaces |
8996
06a5ceb0fb21
(insert-parentheses): Don't insert spaces at beginning and end of buffer.
Richard M. Stallman <rms@gnu.org>
parents:
8205
diff
changeset
|
248 (not (eobp)) |
3733
c1c105ffdd0c
(parens-dont-require-spaces): New variable.
Richard M. Stallman <rms@gnu.org>
parents:
3591
diff
changeset
|
249 (memq (char-syntax (following-char)) '(?w ?_ ?\( )) |
133
2f5b3f50773d
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
119
diff
changeset
|
250 (insert " ")))) |
84 | 251 |
252 (defun move-past-close-and-reindent () | |
253 "Move past next `)', delete indentation before it, then indent after it." | |
254 (interactive) | |
255 (up-list 1) | |
256 (forward-char -1) | |
257 (while (save-excursion ; this is my contribution | |
258 (let ((before-paren (point))) | |
259 (back-to-indentation) | |
19781
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
260 (and (= (point) before-paren) |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
261 (progn |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
262 ;; Move to end of previous line. |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
263 (beginning-of-line) |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
264 (forward-char -1) |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
265 ;; Verify it doesn't end within a string or comment. |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
266 (let ((end (point)) |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
267 state) |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
268 (beginning-of-line) |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
269 ;; Get state at start of line. |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
270 (setq state (list 0 nil nil |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
271 (null (calculate-lisp-indent)) |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
272 nil nil nil nil |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
273 nil)) |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
274 ;; Parse state across the line to get state at end. |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
275 (setq state (parse-partial-sexp (point) end nil nil |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
276 state)) |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
277 ;; Check not in string or comment. |
03264c342376
(move-past-close-and-reindent):
Richard M. Stallman <rms@gnu.org>
parents:
17665
diff
changeset
|
278 (and (not (elt state 3)) (not (elt state 4)))))))) |
84 | 279 (delete-indentation)) |
280 (forward-char 1) | |
281 (newline-and-indent)) | |
282 | |
283 (defun lisp-complete-symbol () | |
6004
4fa3d631dae8
(lisp-complete-symbol): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
5981
diff
changeset
|
284 "Perform completion on Lisp symbol preceding point. |
4fa3d631dae8
(lisp-complete-symbol): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
5981
diff
changeset
|
285 Compare that symbol against the known Lisp symbols. |
4fa3d631dae8
(lisp-complete-symbol): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
5981
diff
changeset
|
286 |
4fa3d631dae8
(lisp-complete-symbol): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
5981
diff
changeset
|
287 The context determines which symbols are considered. |
4fa3d631dae8
(lisp-complete-symbol): Doc fix.
Richard M. Stallman <rms@gnu.org>
parents:
5981
diff
changeset
|
288 If the symbol starts just after an open-parenthesis, only symbols |
215 | 289 with function definitions are considered. Otherwise, all symbols with |
290 function definitions, values or properties are considered." | |
84 | 291 (interactive) |
292 (let* ((end (point)) | |
293 (buffer-syntax (syntax-table)) | |
119 | 294 (beg (unwind-protect |
295 (save-excursion | |
296 (set-syntax-table emacs-lisp-mode-syntax-table) | |
297 (backward-sexp 1) | |
298 (while (= (char-syntax (following-char)) ?\') | |
299 (forward-char 1)) | |
300 (point)) | |
84 | 301 (set-syntax-table buffer-syntax))) |
302 (pattern (buffer-substring beg end)) | |
303 (predicate | |
304 (if (eq (char-after (1- beg)) ?\() | |
305 'fboundp | |
306 (function (lambda (sym) | |
307 (or (boundp sym) (fboundp sym) | |
308 (symbol-plist sym)))))) | |
309 (completion (try-completion pattern obarray predicate))) | |
310 (cond ((eq completion t)) | |
311 ((null completion) | |
312 (message "Can't find completion for \"%s\"" pattern) | |
313 (ding)) | |
314 ((not (string= pattern completion)) | |
315 (delete-region beg end) | |
316 (insert completion)) | |
317 (t | |
318 (message "Making completion list...") | |
23451
4b8c40cf1931
(lisp-complete-symbol): Don't bind completion-fixup-function.
Richard M. Stallman <rms@gnu.org>
parents:
19831
diff
changeset
|
319 (let ((list (all-completions pattern obarray predicate))) |
16494
3f971c7163fb
(lisp-complete-symbol): Sort the list.
Richard M. Stallman <rms@gnu.org>
parents:
16410
diff
changeset
|
320 (setq list (sort list 'string<)) |
84 | 321 (or (eq predicate 'fboundp) |
322 (let (new) | |
323 (while list | |
324 (setq new (cons (if (fboundp (intern (car list))) | |
325 (list (car list) " <f>") | |
326 (car list)) | |
327 new)) | |
328 (setq list (cdr list))) | |
329 (setq list (nreverse new)))) | |
7845
6f6b61216b0b
(lisp-complete-symbol): Likewise.
Richard M. Stallman <rms@gnu.org>
parents:
7300
diff
changeset
|
330 (with-output-to-temp-buffer "*Completions*" |
84 | 331 (display-completion-list list))) |
332 (message "Making completion list...%s" "done"))))) | |
659
505130d1ddf8
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
215
diff
changeset
|
333 |
505130d1ddf8
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
215
diff
changeset
|
334 ;;; lisp.el ends here |