Commit | Line | Data |
---|---|---|
6594deb0 ER |
1 | ;;; lisp.el --- Lisp editing commands for Emacs |
2 | ||
8f1204db | 3 | ;; Copyright (C) 1985, 1986, 1994 Free Software Foundation, Inc. |
9750e079 | 4 | |
e5167999 | 5 | ;; Maintainer: FSF |
e9571d2a | 6 | ;; Keywords: lisp, languages |
e5167999 | 7 | |
b73b9811 | 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 | |
e5167999 | 12 | ;; the Free Software Foundation; either version 2, or (at your option) |
b73b9811 | 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 | |
b578f267 EN |
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. | |
b73b9811 | 24 | |
e41b2db1 ER |
25 | ;;; Commentary: |
26 | ||
eb8c3be9 | 27 | ;; Lisp editing commands to go with Lisp major mode. |
e41b2db1 | 28 | |
e5167999 | 29 | ;;; Code: |
b73b9811 | 30 | |
7fe78b07 | 31 | ;; Note that this variable is used by non-lisp modes too. |
b73b9811 | 32 | (defvar defun-prompt-regexp nil |
7fe78b07 KH |
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. | |
35 | See `beginning-of-defun'.") | |
24ff5498 | 36 | (make-variable-buffer-local 'defun-prompt-regexp) |
b73b9811 | 37 | |
78e367e9 RS |
38 | (defvar parens-require-spaces t |
39 | "Non-nil => `insert-parentheses' should insert whitespace as needed.") | |
44a53673 | 40 | |
b73b9811 | 41 | (defun forward-sexp (&optional arg) |
42 | "Move forward across one balanced expression (sexp). | |
e3f99b91 JB |
43 | With argument, do it that many times. Negative arg -N means |
44 | move backward across N balanced expressions." | |
b73b9811 | 45 | (interactive "p") |
46 | (or arg (setq arg 1)) | |
47 | (goto-char (or (scan-sexps (point) arg) (buffer-end arg))) | |
48 | (if (< arg 0) (backward-prefix-chars))) | |
49 | ||
50 | (defun backward-sexp (&optional arg) | |
51 | "Move backward across one balanced expression (sexp). | |
e3f99b91 JB |
52 | With argument, do it that many times. Negative arg -N means |
53 | move forward across N balanced expressions." | |
b73b9811 | 54 | (interactive "p") |
55 | (or arg (setq arg 1)) | |
56 | (forward-sexp (- arg))) | |
57 | ||
58 | (defun mark-sexp (arg) | |
59 | "Set mark ARG sexps from point. | |
e3f99b91 JB |
60 | The place mark goes is the same place \\[forward-sexp] would |
61 | move to with the same argument." | |
b73b9811 | 62 | (interactive "p") |
63 | (push-mark | |
64 | (save-excursion | |
65 | (forward-sexp arg) | |
0ba91115 RS |
66 | (point)) |
67 | nil t)) | |
b73b9811 | 68 | |
69 | (defun forward-list (&optional arg) | |
70 | "Move forward across one balanced group of parentheses. | |
71 | With argument, do it that many times. | |
72 | Negative arg -N means move backward across N groups of parentheses." | |
73 | (interactive "p") | |
74 | (or arg (setq arg 1)) | |
75 | (goto-char (or (scan-lists (point) arg 0) (buffer-end arg)))) | |
76 | ||
77 | (defun backward-list (&optional arg) | |
78 | "Move backward across one balanced group of parentheses. | |
79 | With argument, do it that many times. | |
80 | Negative arg -N means move forward across N groups of parentheses." | |
81 | (interactive "p") | |
82 | (or arg (setq arg 1)) | |
83 | (forward-list (- arg))) | |
84 | ||
85 | (defun down-list (arg) | |
86 | "Move forward down one level of parentheses. | |
87 | With argument, do this that many times. | |
88 | A negative argument means move backward but still go down a level. | |
89 | In Lisp programs, an argument is required." | |
90 | (interactive "p") | |
91 | (let ((inc (if (> arg 0) 1 -1))) | |
92 | (while (/= arg 0) | |
93 | (goto-char (or (scan-lists (point) inc -1) (buffer-end arg))) | |
94 | (setq arg (- arg inc))))) | |
95 | ||
96 | (defun backward-up-list (arg) | |
97 | "Move backward out of one level of parentheses. | |
98 | With argument, do this that many times. | |
99 | A negative argument means move forward but still to a less deep spot. | |
100 | In Lisp programs, an argument is required." | |
101 | (interactive "p") | |
102 | (up-list (- arg))) | |
103 | ||
104 | (defun up-list (arg) | |
105 | "Move forward out of one level of parentheses. | |
106 | With argument, do this that many times. | |
107 | A negative argument means move backward but still to a less deep spot. | |
108 | In Lisp programs, an argument is required." | |
109 | (interactive "p") | |
110 | (let ((inc (if (> arg 0) 1 -1))) | |
111 | (while (/= arg 0) | |
112 | (goto-char (or (scan-lists (point) inc 1) (buffer-end arg))) | |
113 | (setq arg (- arg inc))))) | |
114 | ||
115 | (defun kill-sexp (arg) | |
116 | "Kill the sexp (balanced expression) following the cursor. | |
117 | With argument, kill that many sexps after the cursor. | |
118 | Negative arg -N means kill N sexps before the cursor." | |
119 | (interactive "p") | |
120 | (let ((opoint (point))) | |
121 | (forward-sexp arg) | |
122 | (kill-region opoint (point)))) | |
123 | ||
124 | (defun backward-kill-sexp (arg) | |
125 | "Kill the sexp (balanced expression) preceding the cursor. | |
126 | With argument, kill that many sexps before the cursor. | |
127 | Negative arg -N means kill N sexps after the cursor." | |
128 | (interactive "p") | |
129 | (kill-sexp (- arg))) | |
130 | \f | |
131 | (defun beginning-of-defun (&optional arg) | |
132 | "Move backward to the beginning of a defun. | |
133 | With argument, do it that many times. Negative arg -N | |
134 | means move forward to Nth following beginning of defun. | |
135 | Returns t unless search stops due to beginning or end of buffer. | |
136 | ||
137 | Normally a defun starts when there is an char with open-parenthesis | |
138 | syntax at the beginning of a line. If `defun-prompt-regexp' is | |
139 | non-nil, then a string which matches that regexp may precede the | |
afa995e1 KH |
140 | open-parenthesis, and point ends up at the beginning of the line." |
141 | (interactive "p") | |
142 | (and (beginning-of-defun-raw arg) | |
143 | (progn (beginning-of-line) t))) | |
144 | ||
145 | (defun beginning-of-defun-raw (&optional arg) | |
146 | "Move point to the character that starts a defun. | |
147 | This is identical to beginning-of-defun, except that point does not move | |
148 | to the beginning of the line when `defun-prompt-regexp' is non-nil." | |
b73b9811 | 149 | (interactive "p") |
81ccc378 | 150 | (and arg (< arg 0) (not (eobp)) (forward-char 1)) |
b73b9811 | 151 | (and (re-search-backward (if defun-prompt-regexp |
152 | (concat "^\\s(\\|" | |
153 | "\\(" defun-prompt-regexp "\\)\\s(") | |
154 | "^\\s(") | |
155 | nil 'move (or arg 1)) | |
afa995e1 | 156 | (progn (goto-char (1- (match-end 0)))) t)) |
b73b9811 | 157 | |
158 | (defun buffer-end (arg) | |
159 | (if (> arg 0) (point-max) (point-min))) | |
160 | ||
161 | (defun end-of-defun (&optional arg) | |
162 | "Move forward to next end of defun. With argument, do it that many times. | |
163 | Negative argument -N means move back to Nth preceding end of defun. | |
164 | ||
165 | An end of a defun occurs right after the close-parenthesis that matches | |
166 | the open-parenthesis that starts a defun; see `beginning-of-defun'." | |
167 | (interactive "p") | |
168 | (if (or (null arg) (= arg 0)) (setq arg 1)) | |
169 | (let ((first t)) | |
170 | (while (and (> arg 0) (< (point) (point-max))) | |
171 | (let ((pos (point)) npos) | |
172 | (while (progn | |
173 | (if (and first | |
174 | (progn | |
afa995e1 KH |
175 | (end-of-line 1) |
176 | (beginning-of-defun-raw 1))) | |
b73b9811 | 177 | nil |
178 | (or (bobp) (forward-char -1)) | |
afa995e1 | 179 | (beginning-of-defun-raw -1)) |
b73b9811 | 180 | (setq first nil) |
181 | (forward-list 1) | |
182 | (skip-chars-forward " \t") | |
183 | (if (looking-at "\\s<\\|\n") | |
184 | (forward-line 1)) | |
185 | (<= (point) pos)))) | |
186 | (setq arg (1- arg))) | |
187 | (while (< arg 0) | |
188 | (let ((pos (point))) | |
afa995e1 | 189 | (beginning-of-defun-raw 1) |
b73b9811 | 190 | (forward-sexp 1) |
191 | (forward-line 1) | |
192 | (if (>= (point) pos) | |
afa995e1 | 193 | (if (beginning-of-defun-raw 2) |
b73b9811 | 194 | (progn |
195 | (forward-list 1) | |
196 | (skip-chars-forward " \t") | |
37f31acf | 197 | (if (looking-at "\\s<\\|\n") |
b73b9811 | 198 | (forward-line 1))) |
199 | (goto-char (point-min))))) | |
200 | (setq arg (1+ arg))))) | |
201 | ||
202 | (defun mark-defun () | |
203 | "Put mark at end of this defun, point at beginning. | |
204 | The defun marked is the one that contains point or follows point." | |
205 | (interactive) | |
206 | (push-mark (point)) | |
207 | (end-of-defun) | |
0ba91115 | 208 | (push-mark (point) nil t) |
b73b9811 | 209 | (beginning-of-defun) |
210 | (re-search-backward "^\n" (- (point) 1) t)) | |
211 | ||
212 | (defun insert-parentheses (arg) | |
213 | "Put parentheses around next ARG sexps. Leave point after open-paren. | |
44a53673 | 214 | No argument is equivalent to zero: just insert `()' and leave point between. |
d5bfe076 KH |
215 | If `parens-require-spaces' is non-nil, this command also inserts a space |
216 | before and after, depending on the surrounding characters." | |
b73b9811 | 217 | (interactive "P") |
a17f9e55 RS |
218 | (if arg (setq arg (prefix-numeric-value arg)) |
219 | (setq arg 0)) | |
220 | (or (eq arg 0) (skip-chars-forward " \t")) | |
78e367e9 | 221 | (and parens-require-spaces |
6696af65 | 222 | (not (bobp)) |
44a53673 | 223 | (memq (char-syntax (preceding-char)) '(?w ?_ ?\) )) |
b73b9811 | 224 | (insert " ")) |
b73b9811 | 225 | (insert ?\() |
226 | (save-excursion | |
a17f9e55 | 227 | (or (eq arg 0) (forward-sexp arg)) |
b73b9811 | 228 | (insert ?\)) |
78e367e9 | 229 | (and parens-require-spaces |
6696af65 | 230 | (not (eobp)) |
44a53673 | 231 | (memq (char-syntax (following-char)) '(?w ?_ ?\( )) |
a17f9e55 | 232 | (insert " ")))) |
b73b9811 | 233 | |
234 | (defun move-past-close-and-reindent () | |
235 | "Move past next `)', delete indentation before it, then indent after it." | |
236 | (interactive) | |
237 | (up-list 1) | |
238 | (forward-char -1) | |
239 | (while (save-excursion ; this is my contribution | |
240 | (let ((before-paren (point))) | |
241 | (back-to-indentation) | |
242 | (= (point) before-paren))) | |
243 | (delete-indentation)) | |
244 | (forward-char 1) | |
245 | (newline-and-indent)) | |
246 | \f | |
247 | (defun lisp-complete-symbol () | |
2eb9adab RS |
248 | "Perform completion on Lisp symbol preceding point. |
249 | Compare that symbol against the known Lisp symbols. | |
250 | ||
251 | The context determines which symbols are considered. | |
252 | If the symbol starts just after an open-parenthesis, only symbols | |
e3f99b91 JB |
253 | with function definitions are considered. Otherwise, all symbols with |
254 | function definitions, values or properties are considered." | |
b73b9811 | 255 | (interactive) |
256 | (let* ((end (point)) | |
257 | (buffer-syntax (syntax-table)) | |
ecb75942 RS |
258 | (beg (unwind-protect |
259 | (save-excursion | |
260 | (set-syntax-table emacs-lisp-mode-syntax-table) | |
261 | (backward-sexp 1) | |
262 | (while (= (char-syntax (following-char)) ?\') | |
263 | (forward-char 1)) | |
264 | (point)) | |
b73b9811 | 265 | (set-syntax-table buffer-syntax))) |
266 | (pattern (buffer-substring beg end)) | |
267 | (predicate | |
268 | (if (eq (char-after (1- beg)) ?\() | |
269 | 'fboundp | |
270 | (function (lambda (sym) | |
271 | (or (boundp sym) (fboundp sym) | |
272 | (symbol-plist sym)))))) | |
273 | (completion (try-completion pattern obarray predicate))) | |
274 | (cond ((eq completion t)) | |
275 | ((null completion) | |
276 | (message "Can't find completion for \"%s\"" pattern) | |
277 | (ding)) | |
278 | ((not (string= pattern completion)) | |
279 | (delete-region beg end) | |
280 | (insert completion)) | |
281 | (t | |
282 | (message "Making completion list...") | |
52ae2b42 RS |
283 | (let ((list (all-completions pattern obarray predicate)) |
284 | (completion-fixup-function | |
285 | (function (lambda () (if (save-excursion | |
286 | (goto-char (max (point-min) (- (point) 4))) | |
287 | (looking-at " <f>")) | |
288 | (forward-char -4)))))) | |
b73b9811 | 289 | (or (eq predicate 'fboundp) |
290 | (let (new) | |
291 | (while list | |
292 | (setq new (cons (if (fboundp (intern (car list))) | |
293 | (list (car list) " <f>") | |
294 | (car list)) | |
295 | new)) | |
296 | (setq list (cdr list))) | |
297 | (setq list (nreverse new)))) | |
1af808dc | 298 | (with-output-to-temp-buffer "*Completions*" |
b73b9811 | 299 | (display-completion-list list))) |
300 | (message "Making completion list...%s" "done"))))) | |
6594deb0 ER |
301 | |
302 | ;;; lisp.el ends here |