![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lisp-mode.el CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / lisp|
Return to lisp-mode.el CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / lisp |
1.1 root 1: ;; Lisp mode, and its idiosyncratic commands.
2: ;; Copyright (C) 1985 Richard M. Stallman.
3:
4: ;; This file is part of GNU Emacs.
5:
6: ;; GNU Emacs is distributed in the hope that it will be useful,
7: ;; but WITHOUT ANY WARRANTY. No author or distributor
8: ;; accepts responsibility to anyone for the consequences of using it
9: ;; or for whether it serves any particular purpose or works at all,
10: ;; unless he says so in writing. Refer to the GNU Emacs General Public
11: ;; License for full details.
12:
13: ;; Everyone is granted permission to copy, modify and redistribute
14: ;; GNU Emacs, but only under the conditions described in the
15: ;; GNU Emacs General Public License. A copy of this license is
16: ;; supposed to have been given to you along with GNU Emacs so you
17: ;; can know your rights and responsibilities. It should be in a
18: ;; file named COPYING. Among other things, the copyright notice
19: ;; and this notice must be preserved on all copies.
20:
21:
22: (defvar lisp-mode-syntax-table nil "")
23: (defvar lisp-mode-abbrev-table nil "")
24:
25: (if (not lisp-mode-syntax-table)
26: (let ((i 0))
27: (setq lisp-mode-syntax-table (make-syntax-table))
28: (set-syntax-table lisp-mode-syntax-table)
29: (while (< i ?0)
30: (modify-syntax-entry i "_ ")
31: (setq i (1+ i)))
32: (setq i (1+ ?9))
33: (while (< i ?A)
34: (modify-syntax-entry i "_ ")
35: (setq i (1+ i)))
36: (setq i (1+ ?Z))
37: (while (< i ?a)
38: (modify-syntax-entry i "_ ")
39: (setq i (1+ i)))
40: (setq i (1+ ?z))
41: (while (< i 128)
42: (modify-syntax-entry i "_ ")
43: (setq i (1+ i)))
44: (modify-syntax-entry ? " ")
45: (modify-syntax-entry ?\t " ")
46: (modify-syntax-entry ?\n "> ")
47: (modify-syntax-entry ?\f "> ")
48: (modify-syntax-entry ?\; "< ")
49: (modify-syntax-entry ?` "' ")
50: (modify-syntax-entry ?' "' ")
51: (modify-syntax-entry ?, "' ")
52: (modify-syntax-entry ?. "' ")
53: (modify-syntax-entry ?# "' ")
54: (modify-syntax-entry ?\" "\" ")
55: (modify-syntax-entry ?\\ "\\ ")
56: (modify-syntax-entry ?\( "() ")
57: (modify-syntax-entry ?\) ")( ")))
58:
59: (define-abbrev-table 'lisp-mode-abbrev-table ())
60:
61: (defun lisp-mode-variables ()
62: (set-syntax-table lisp-mode-syntax-table)
63: (setq local-abbrev-table lisp-mode-abbrev-table)
64: (make-local-variable 'paragraph-start)
65: (setq paragraph-start (concat "^$\\|" page-delimiter))
66: (make-local-variable 'paragraph-separate)
67: (setq paragraph-separate paragraph-start)
68: (make-local-variable 'indent-line-function)
69: (setq indent-line-function 'lisp-indent-line)
70: (make-local-variable 'comment-start)
71: (setq comment-start ";")
72: (make-local-variable 'comment-start-skip)
73: (setq comment-start-skip ";+ *")
74: (make-local-variable 'comment-column)
75: (setq comment-column 40)
76: (make-local-variable 'comment-indent-hook)
77: (setq comment-indent-hook 'lisp-comment-indent))
78:
79: (defun lisp-mode-commands (map)
80: (define-key map "\e\C-q" 'indent-sexp)
81: (define-key map "\177" 'backward-delete-char-untabify)
82: (define-key map "\t" 'lisp-indent-line))
83:
84: (defvar emacs-lisp-mode-map (make-sparse-keymap) "")
85: (define-key emacs-lisp-mode-map "\e\C-x" 'eval-defun)
86: (lisp-mode-commands emacs-lisp-mode-map)
87:
88: (defun emacs-lisp-mode ()
89: "Major mode for editing Lisp code to run in Emacs.
90: Commands:
91: Delete converts tabs to spaces as it moves back.
92: Blank lines separate paragraphs. Semicolons start comments.
93: \\{emacs-lisp-mode-map}
94: Entry to this mode calls the value of emacs-lisp-mode-hook
95: if that value is non-nil."
96: (interactive)
97: (kill-all-local-variables)
98: (use-local-map emacs-lisp-mode-map)
99: (setq major-mode 'emacs-lisp-mode)
100: (setq mode-name "Emacs-Lisp")
101: (lisp-mode-variables)
102: (run-hooks 'emacs-lisp-mode-hook))
103:
104: (defvar lisp-mode-map (make-sparse-keymap))
105: (define-key lisp-mode-map "\e\C-x" 'lisp-send-defun)
106: (lisp-mode-commands lisp-mode-map)
107:
108: (defun lisp-mode ()
109: "Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
110: Commands:
111: Delete converts tabs to spaces as it moves back.
112: Blank lines separate paragraphs. Semicolons start comments.
113: \\{lisp-mode-map}
114: Entry to this mode calls the value of lisp-mode-hook
115: if that value is non-nil."
116: (interactive)
117: (kill-all-local-variables)
118: (use-local-map lisp-mode-map)
119: (setq major-mode 'lisp-mode)
120: (setq mode-name "Lisp")
121: (lisp-mode-variables)
122: (run-hooks 'lisp-mode-hook))
123:
124: ;; This will do unless shell.el is loaded.
125: (defun lisp-send-defun nil
126: "Send the current defun to the Lisp process made by M-x run-lisp."
127: (interactive)
128: (error "Process lisp does not exist"))
129:
130: (defvar lisp-interaction-mode-map (make-sparse-keymap))
131: (lisp-mode-commands lisp-interaction-mode-map)
132: (define-key lisp-interaction-mode-map "\e\C-x" 'eval-defun)
133: (define-key lisp-interaction-mode-map "\n" 'eval-print-last-sexp)
134:
135: (defun lisp-interaction-mode ()
136: "Major mode for typing and evaluating Lisp forms.
137: Like Lisp mode except that \\[eval-print-last-sexp] evals the Lisp expression
138: before point, and prints its value into the buffer, advancing point.
139:
140: Commands:
141: Delete converts tabs to spaces as it moves back.
142: Paragraphs are separated only by blank lines. Semicolons start comments.
143: \\{lisp-interaction-mode-map}
144: Entry to this mode calls the value of lisp-interaction-mode-hook
145: if that value is non-nil."
146: (interactive)
147: (kill-all-local-variables)
148: (use-local-map lisp-interaction-mode-map)
149: (setq major-mode 'lisp-interaction-mode)
150: (setq mode-name "Lisp Interaction")
151: (lisp-mode-variables)
152: (run-hooks 'lisp-interaction-mode-hook))
153:
154: (defun eval-print-last-sexp (arg)
155: "Evaluate sexp before point; print value into current buffer."
156: (interactive "P")
157: (eval-region
158: (let ((stab (syntax-table)))
159: (unwind-protect
160: (save-excursion
161: (set-syntax-table lisp-mode-syntax-table)
162: (forward-sexp -1)
163: (point))
164: (set-syntax-table stab)))
165: (point)
166: (current-buffer)))
167:
168: (defun eval-last-sexp (arg)
169: "Evaluate sexp before point; print value in minibuffer.
170: With argument, print output into current buffer."
171: (interactive "P")
172: (eval-region
173: (let ((stab (syntax-table)))
174: (unwind-protect
175: (save-excursion
176: (set-syntax-table lisp-mode-syntax-table)
177: (forward-sexp -1)
178: (point))
179: (set-syntax-table stab)))
180: (point)
181: (if arg (current-buffer) t)))
182:
183: (defun eval-defun (arg)
184: "Evaluate defun that point is in or before.
185: Print value in minibuffer.
186: With argument, insert value in current buffer after the defun."
187: (interactive "P")
188: (save-excursion
189: (end-of-defun)
190: (let ((end (point)))
191: (beginning-of-defun)
192: (eval-region (point) end
193: (if arg (current-buffer) t)))))
194:
195: (defun lisp-comment-indent ()
196: (if (looking-at ";;;")
197: (current-column)
198: (if (looking-at ";;")
199: (let ((tem (calculate-lisp-indent)))
200: (if (listp tem) (car tem) tem))
201: (skip-chars-backward " \t")
202: (max (if (bolp) 0 (1+ (current-column)))
203: comment-column))))
204:
205: (defconst lisp-indent-offset nil "")
206: (defconst lisp-indent-hook 'lisp-indent-hook "")
207:
208: (defun lisp-indent-line (&optional whole-exp)
209: "Indent current line as Lisp code.
210: With argument, indent any additional lines of the same expression
211: rigidly along with this one."
212: (interactive "P")
213: (let ((indent (calculate-lisp-indent)) shift-amt beg end
214: (pos (- (point-max) (point))))
215: (beginning-of-line)
216: (setq beg (point))
217: (skip-chars-forward " \t")
218: (if (looking-at "[ \t]*;;;")
219: ;; Don't alter indentation of a ;;; comment line.
220: nil
221: (if (listp indent) (setq indent (car indent)))
222: (setq shift-amt (- indent (current-column)))
223: (if (zerop shift-amt)
224: nil
225: (delete-region beg (point))
226: (indent-to indent))
227: ;; If initial point was within line's indentation,
228: ;; position after the indentation. Else stay at same point in text.
229: (if (> (- (point-max) pos) (point))
230: (goto-char (- (point-max) pos)))
231: ;; If desired, shift remaining lines of expression the same amount.
232: (and whole-exp (not (zerop shift-amt))
233: (save-excursion
234: (goto-char beg)
235: (forward-sexp 1)
236: (setq end (point))
237: (goto-char beg)
238: (forward-line 1)
239: (setq beg (point))
240: (> end beg))
241: (indent-code-rigidly beg end shift-amt)))))
242:
243: (defun calculate-lisp-indent (&optional parse-start)
244: "Return appropriate indentation for current line as Lisp code.
245: In usual case returns an integer: the column to indent to.
246: Can instead return a list, whose car is the column to indent to.
247: This means that following lines at the same level of indentation
248: should not necessarily be indented the same way.
249: The second element of the list is the buffer position
250: of the start of the containing expression."
251: (save-excursion
252: (beginning-of-line)
253: (let ((indent-point (point)) state paren-depth desired-indent (retry t)
254: last-sexp containing-sexp)
255: (if parse-start
256: (goto-char parse-start)
257: (beginning-of-defun))
258: ;; Find outermost containing sexp
259: (while (< (point) indent-point)
260: (setq state (parse-partial-sexp (point) indent-point 0)))
261: ;; Find innermost containing sexp
262: (while (and retry (setq paren-depth (car state)) (> paren-depth 0))
263: (setq retry nil)
264: (setq last-sexp (nth 2 state))
265: (setq containing-sexp (car (cdr state)))
266: ;; Position following last unclosed open.
267: (goto-char (1+ containing-sexp))
268: ;; Is there a complete sexp since then?
269: (if (and last-sexp (> last-sexp (point)))
270: ;; Yes, but is there a containing sexp after that?
271: (let ((peek (parse-partial-sexp last-sexp indent-point 0)))
272: (if (setq retry (car (cdr peek))) (setq state peek))))
273: (if (not retry)
274: ;; Innermost containing sexp found
275: (progn
276: (goto-char (1+ containing-sexp))
277: (if (not last-sexp)
278: ;; indent-point immediately follows open paren.
279: ;; Don't call hook.
280: (setq desired-indent (current-column))
281: ;; Move to first sexp after containing open paren
282: (parse-partial-sexp (point) last-sexp 0 t)
283: (cond
284: ((looking-at "\\s(")
285: ;; Looking at a list. Don't call hook.
286: (if (not (> (save-excursion (forward-line 1) (point))
287: last-sexp))
288: (progn (goto-char last-sexp)
289: (beginning-of-line)
290: (parse-partial-sexp (point) last-sexp 0 t)))
291: ;; Indent under the list or under the first sexp on the
292: ;; same line as last-sexp. Note that first thing on that
293: ;; line has to be complete sexp since we are inside the
294: ;; innermost containing sexp.
295: (backward-prefix-chars)
296: (setq desired-indent (current-column)))
297: ((> (save-excursion (forward-line 1) (point))
298: last-sexp)
299: ;; Last sexp is on same line as containing sexp.
300: ;; It's almost certainly a function call.
301: (parse-partial-sexp (point) last-sexp 0 t)
302: (if (/= (point) last-sexp)
303: ;; Indent beneath first argument or, if only one sexp
304: ;; on line, indent beneath that.
305: (progn (forward-sexp 1)
306: (parse-partial-sexp (point) last-sexp 0 t)))
307: (backward-prefix-chars))
308: (t
309: ;; Indent beneath first sexp on same line as last-sexp.
310: ;; Again, it's almost certainly a function call.
311: (goto-char last-sexp)
312: (beginning-of-line)
313: (parse-partial-sexp (point) last-sexp 0 t)
314: (backward-prefix-chars)))))))
315: ;; Point is at the point to indent under unless we are inside a string.
316: ;; Call indentation hook except when overriden by lisp-indent-offset
317: ;; or if the desired indentation has already been computed.
318: (cond ((car (nthcdr 3 state))
319: ;; Inside a string, don't change indentation.
320: (goto-char indent-point)
321: (skip-chars-forward " \t")
322: (setq desired-indent (current-column)))
323: ((and (integerp lisp-indent-offset) containing-sexp)
324: ;; Indent by constant offset
325: (goto-char containing-sexp)
326: (setq desired-indent (+ lisp-indent-offset (current-column))))
327: ((not (or desired-indent
328: (and (boundp 'lisp-indent-hook)
329: lisp-indent-hook
330: (not retry)
331: (setq desired-indent
332: (funcall lisp-indent-hook indent-point state)))))
333: ;; Use default indentation if not computed yet
334: (setq desired-indent (current-column))))
335: desired-indent)))
336:
337: (defun lisp-indent-hook (indent-point state)
338: (let ((normal-indent (current-column)))
339: (save-excursion
340: (goto-char (1+ (car (cdr state))))
341: (re-search-forward "\\sw\\|\\s_")
342: (if (/= (point) (car (cdr state)))
343: (let ((function (buffer-substring (progn (forward-char -1) (point))
344: (progn (forward-sexp 1) (point))))
345: method)
346: (setq method (get (intern-soft function) 'lisp-indent-hook))
347: (if (or (eq method 'defun)
348: (and (null method)
349: (> (length function) 3)
350: (string-equal (substring function 0 3) "def")))
351: (lisp-indent-defform state indent-point)
352: (if (integerp method)
353: (lisp-indent-specform method state indent-point)
354: (if method
355: (funcall method state indent-point)))))))))
356:
357: (defconst lisp-body-indent 2 "")
358:
359: (defun lisp-indent-specform (count state indent-point)
360: (let ((containing-form-start (car (cdr state))) (i count)
361: body-indent containing-form-column)
362: ;; Move to the start of containing form, calculate indentation
363: ;; to use for non-distinguished forms (> count), and move past the
364: ;; function symbol. lisp-indent-hook guarantees that there is at
365: ;; least one word or symbol character following open paren of containing
366: ;; form.
367: (goto-char containing-form-start)
368: (setq containing-form-column (current-column))
369: (setq body-indent (+ lisp-body-indent containing-form-column))
370: (forward-char 1)
371: (forward-sexp 1)
372: ;; Now find the start of the last form.
373: (parse-partial-sexp (point) indent-point 1 t)
374: (while (and (< (point) indent-point)
375: (condition-case nil
376: (progn
377: (setq count (1- count))
378: (forward-sexp 1)
379: (parse-partial-sexp (point) indent-point 1 t))
380: (error nil))))
381: ;; Point is sitting on first character of last (or count) sexp.
382: (if (> count 0)
383: ;; A distinguished form. If it is the first or second form use double
384: ;; lisp-body-indent, else normal indent. With lisp-body-indent bound
385: ;; to 2 (the default), this just happens to work the same with if as
386: ;; the older code, but it makes unwind-protect, condition-case,
387: ;; with-output-to-temp-buffer, et. al. much more tasteful. The older,
388: ;; less hacked, behavior can be obtained by replacing below with
389: ;; (list normal-indent containing-form-start).
390: (if (<= (- i count) 1)
391: (list (+ containing-form-column (* 2 lisp-body-indent))
392: containing-form-start)
393: (list normal-indent containing-form-start))
394: ;; A non-distinguished form. Use body-indent if there are no distinguished
395: ;; forms and this is the first undistinguished form, or if this is the
396: ;; first undistinguished form and the preceding distinguished form has
397: ;; indentation at least as great as body-indent.
398: (if (or (and (= i 0) (= count 0))
399: (and (= count 0) (<= body-indent normal-indent)))
400: body-indent
401: normal-indent))))
402:
403: (defun lisp-indent-defform (state indent-point)
404: (goto-char (car (cdr state)))
405: (forward-line 1)
406: (if (> (point) (car (cdr (cdr state))))
407: (progn
408: (goto-char (car (cdr state)))
409: (+ lisp-body-indent (current-column)))))
410:
411: ;; (put 'progn 'lisp-indent-hook 0), say, causes progn to be indented
412: ;; like defun if the first form is placed on the next line, otherwise
413: ;; it is indented like any other form (i.e. forms line up under first).
414:
415: (put 'lambda 'lisp-indent-hook 'defun)
416: (put 'progn 'lisp-indent-hook 0)
417: (put 'prog1 'lisp-indent-hook 1)
418: (put 'save-excursion 'lisp-indent-hook 0)
419: (put 'save-window-excursion 'lisp-indent-hook 0)
420: (put 'save-restriction 'lisp-indent-hook 0)
421: (put 'let 'lisp-indent-hook 1)
422: (put 'let* 'lisp-indent-hook 1)
423: (put 'while 'lisp-indent-hook 1)
424: (put 'if 'lisp-indent-hook 2)
425: (put 'catch 'lisp-indent-hook 1)
426: (put 'condition-case 'lisp-indent-hook 2)
427: (put 'unwind-protect 'lisp-indent-hook 1)
428: (put 'with-output-to-temp-buffer 'lisp-indent-hook 1)
429:
430: (defun indent-sexp ()
431: "Indent each line of the list starting just after point."
432: (interactive)
433: (let ((indent-stack (list nil)) (next-depth 0) bol
434: outer-loop-done inner-loop-done state this-indent)
435: (save-excursion (forward-sexp 1))
436: (save-excursion
437: (setq outer-loop-done nil)
438: (while (not outer-loop-done)
439: (setq last-depth next-depth
440: innerloop-done nil)
441: (while (and (not innerloop-done)
442: (not (setq outer-loop-done (eobp))))
443: (setq state (parse-partial-sexp (point) (progn (end-of-line) (point))
444: nil nil state))
445: (setq next-depth (car state))
446: (if (car (nthcdr 4 state))
447: (progn (indent-for-comment)
448: (end-of-line)
449: (setcar (nthcdr 4 state) nil)))
450: (if (car (nthcdr 3 state))
451: (progn
452: (forward-line 1)
453: (setcar (nthcdr 5 state) nil))
454: (setq innerloop-done t)))
455: (if (setq outer-loop-done (<= next-depth 0))
456: nil
457: (while (> last-depth next-depth)
458: (setq indent-stack (cdr indent-stack)
459: last-depth (1- last-depth)))
460: (while (< last-depth next-depth)
461: (setq indent-stack (cons nil indent-stack)
462: last-depth (1+ last-depth)))
463: (forward-line 1)
464: (setq bol (point))
465: (skip-chars-forward " \t")
466: (if (or (eobp) (looking-at "[;\n]"))
467: nil
468: (if (and (car indent-stack)
469: (>= (car indent-stack) 0))
470: (setq this-indent (car indent-stack))
471: (let ((val (calculate-lisp-indent
472: (if (car indent-stack) (- (car indent-stack))))))
473: (if (integerp val)
474: (setcar indent-stack
475: (setq this-indent val))
476: (setcar indent-stack (- (car (cdr val))))
477: (setq this-indent (car val)))))
478: (if (/= (current-column) this-indent)
479: (progn (delete-region bol (point))
480: (indent-to this-indent)))))))))
481:
482: (defun indent-code-rigidly (start end arg &optional nochange-regexp)
483: "Indent all lines of code, starting in the region, sideways by ARG columns.
484: Does not affect lines starting inside comments or strings,
485: assuming that the start of the region is not inside them.
486: Called from a program, takes args START, END, COLUMNS and NOCHANGE-REGEXP.
487: The last is a regexp which, if matched at the beginning of a line,
488: means don't indent that line."
489: (interactive "r\np")
490: (let (state)
491: (save-excursion
492: (goto-char end)
493: (setq end (point-marker))
494: (goto-char start)
495: (or (bolp)
496: (setq state (parse-partial-sexp (point)
497: (progn
498: (forward-line 1) (point))
499: nil nil state)))
500: (while (< (point) end)
501: (or (car (nthcdr 3 state))
502: (and nochange-regexp
503: (looking-at nochange-regexp))
504: ;; If line does not start in string, indent it
505: (let ((indent (current-indentation)))
506: (delete-region (point) (progn (skip-chars-forward " \t") (point)))
507: (or (eolp)
508: (indent-to (max 0 (+ indent arg)) 0))))
509: (setq state (parse-partial-sexp (point)
510: (progn
511: (forward-line 1) (point))
512: nil nil state))))))
513:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.