-;; Lisp editing commands for Emacs
-;; Copyright (C) 1985, 1986 Free Software Foundation, Inc.
+;;; lisp.el --- Lisp editing commands for Emacs
+
+;; Copyright (C) 1985, 1986, 1994 Free Software Foundation, Inc.
+
+;; Maintainer: FSF
+;; Keywords: lisp, languages
;; This file is part of GNU Emacs.
;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 1, or (at your option)
+;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; along with GNU Emacs; see the file COPYING. If not, write to
;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+;;; Commentary:
+
+;; Lisp editing commands to go with Lisp major mode.
+
+;;; Code:
+;; Note that this variable is used by non-lisp modes too.
(defvar defun-prompt-regexp nil
- "Non-nil => regexp to ignore, before the `(' that starts a defun.")
+ "*Non-nil => regexp to ignore, before the character that starts a defun.
+This is only necessary if the opening paren or brace is not in column 0.
+See `beginning-of-defun'.")
+(make-variable-buffer-local 'defun-prompt-regexp)
+
+(defvar parens-require-spaces t
+ "Non-nil => `insert-parentheses' should insert whitespace as needed.")
(defun forward-sexp (&optional arg)
"Move forward across one balanced expression (sexp).
-With argument, do it that many times.
-Negative arg -N means move backward across N balanced expressions."
+With argument, do it that many times. Negative arg -N means
+move backward across N balanced expressions."
(interactive "p")
(or arg (setq arg 1))
(goto-char (or (scan-sexps (point) arg) (buffer-end arg)))
(defun backward-sexp (&optional arg)
"Move backward across one balanced expression (sexp).
-With argument, do it that many times.
-Negative arg -N means move forward across N balanced expressions."
+With argument, do it that many times. Negative arg -N means
+move forward across N balanced expressions."
(interactive "p")
(or arg (setq arg 1))
(forward-sexp (- arg)))
(defun mark-sexp (arg)
"Set mark ARG sexps from point.
-The place mark goes is the same place \\[forward-sexp] would move to
-with the same argument."
+The place mark goes is the same place \\[forward-sexp] would
+move to with the same argument."
(interactive "p")
(push-mark
(save-excursion
(forward-sexp arg)
- (point))))
+ (point))
+ nil t))
(defun forward-list (&optional arg)
"Move forward across one balanced group of parentheses.
Normally a defun starts when there is an char with open-parenthesis
syntax at the beginning of a line. If `defun-prompt-regexp' is
non-nil, then a string which matches that regexp may precede the
-open-parenthesis."
+open-parenthesis, and point ends up at the beginning of the line."
(interactive "p")
- (and arg (< arg 0) (forward-char 1))
+ (and (beginning-of-defun-raw arg)
+ (progn (beginning-of-line) t)))
+
+(defun beginning-of-defun-raw (&optional arg)
+ "Move point to the character that starts a defun.
+This is identical to beginning-of-defun, except that point does not move
+to the beginning of the line when `defun-prompt-regexp' is non-nil."
+ (interactive "p")
+ (and arg (< arg 0) (not (eobp)) (forward-char 1))
(and (re-search-backward (if defun-prompt-regexp
(concat "^\\s(\\|"
"\\(" defun-prompt-regexp "\\)\\s(")
"^\\s(")
nil 'move (or arg 1))
- (progn (beginning-of-line) t)))
+ (progn (goto-char (1- (match-end 0)))) t))
(defun buffer-end (arg)
(if (> arg 0) (point-max) (point-min)))
(while (progn
(if (and first
(progn
- (forward-char 1)
- (beginning-of-defun 1)))
+ (end-of-line 1)
+ (beginning-of-defun-raw 1)))
nil
(or (bobp) (forward-char -1))
- (beginning-of-defun -1))
+ (beginning-of-defun-raw -1))
(setq first nil)
(forward-list 1)
(skip-chars-forward " \t")
(setq arg (1- arg)))
(while (< arg 0)
(let ((pos (point)))
- (beginning-of-defun 1)
+ (beginning-of-defun-raw 1)
(forward-sexp 1)
(forward-line 1)
(if (>= (point) pos)
- (if (beginning-of-defun 2)
+ (if (beginning-of-defun-raw 2)
(progn
(forward-list 1)
(skip-chars-forward " \t")
- (if (looking-at "[;\n]")
+ (if (looking-at "\\s<\\|\n")
(forward-line 1)))
(goto-char (point-min)))))
(setq arg (1+ arg)))))
(interactive)
(push-mark (point))
(end-of-defun)
- (push-mark (point))
+ (push-mark (point) nil t)
(beginning-of-defun)
(re-search-backward "^\n" (- (point) 1) t))
(defun insert-parentheses (arg)
"Put parentheses around next ARG sexps. Leave point after open-paren.
-No argument is equivalent to zero: just insert () and leave point between."
+No argument is equivalent to zero: just insert `()' and leave point between.
+If `parens-require-spaces' is non-nil, this command also inserts a space
+before and after, depending on the surrounding characters."
(interactive "P")
- (if arg (skip-chars-forward " \t"))
- (and (memq (char-syntax (preceding-char)) '(?w ?_ ?\) ))
+ (if arg (setq arg (prefix-numeric-value arg))
+ (setq arg 0))
+ (or (eq arg 0) (skip-chars-forward " \t"))
+ (and parens-require-spaces
+ (not (bobp))
+ (memq (char-syntax (preceding-char)) '(?w ?_ ?\) ))
(insert " "))
-; (or (memq (char-syntax (preceding-char)) '(?\ ?> ?\( ))
-; (insert " ")))
(insert ?\()
(save-excursion
- (if arg
- (forward-sexp (prefix-numeric-value arg)))
+ (or (eq arg 0) (forward-sexp arg))
(insert ?\))
-; (or (memq (char-syntax (following-char)) '(?\ ?> ?\( ))
-; (insert " "))
- (and (memq (char-syntax (following-char)) '(?w ?_ ?\( ))
- (insert " "))
- ))
+ (and parens-require-spaces
+ (not (eobp))
+ (memq (char-syntax (following-char)) '(?w ?_ ?\( ))
+ (insert " "))))
(defun move-past-close-and-reindent ()
"Move past next `)', delete indentation before it, then indent after it."
\f
(defun lisp-complete-symbol ()
"Perform completion on Lisp symbol preceding point.
-That symbol is compared against the symbols that exist
-and any additional characters determined by what is there
-are inserted.
-If the symbol starts just after an open-parenthesis,
-only symbols with function definitions are considered.
-Otherwise, all symbols with function definitions, values
-or properties are considered."
+Compare that symbol against the known Lisp symbols.
+
+The context determines which symbols are considered.
+If the symbol starts just after an open-parenthesis, only symbols
+with function definitions are considered. Otherwise, all symbols with
+function definitions, values or properties are considered."
(interactive)
(let* ((end (point))
(buffer-syntax (syntax-table))
- (beg (save-excursion
- (set-syntax-table lisp-mode-syntax-table)
- (backward-sexp 1)
- (while (= (char-syntax (following-char)) ?\')
- (forward-char 1))
- (point)
+ (beg (unwind-protect
+ (save-excursion
+ (set-syntax-table emacs-lisp-mode-syntax-table)
+ (backward-sexp 1)
+ (while (= (char-syntax (following-char)) ?\')
+ (forward-char 1))
+ (point))
(set-syntax-table buffer-syntax)))
(pattern (buffer-substring beg end))
(predicate
(insert completion))
(t
(message "Making completion list...")
- (let ((list (all-completions pattern obarray predicate)))
+ (let ((list (all-completions pattern obarray predicate))
+ (completion-fixup-function
+ (function (lambda () (if (save-excursion
+ (goto-char (max (point-min) (- (point) 4)))
+ (looking-at " <f>"))
+ (forward-char -4))))))
(or (eq predicate 'fboundp)
(let (new)
(while list
new))
(setq list (cdr list)))
(setq list (nreverse new))))
- (with-output-to-temp-buffer " *Completions*"
+ (with-output-to-temp-buffer "*Completions*"
(display-completion-list list)))
(message "Making completion list...%s" "done")))))
+
+;;; lisp.el ends here
HCoop / bpt / emacs.git / blobdiff