(debug): Fix arg to backtrace-debug for debug-on-entry.

[bpt/emacs.git] / lisp / emacs-lisp / lisp.el

diff --git a/lisp/emacs-lisp/lisp.el b/lisp/emacs-lisp/lisp.el
index 3ffc6a0..fd9ae0c 100644 (file)
--- a/lisp/emacs-lisp/lisp.el
+++ b/lisp/emacs-lisp/lisp.el
@@ -1,6 +1,6 @@
 ;;; lisp.el --- Lisp editing commands for Emacs
 
-;; Copyright (C) 1985, 1986 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 1986, 1994 Free Software Foundation, Inc.
 
 ;; Maintainer: FSF
 ;; Keywords: lisp, languages
@@ -27,8 +27,12 @@
 
 ;;; 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.")
@@ -132,15 +136,23 @@ Returns t unless search stops due to beginning or end of buffer.
 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)))
@@ -159,11 +171,11 @@ the open-parenthesis that starts a defun; see `beginning-of-defun'."
        (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")
@@ -173,15 +185,15 @@ the open-parenthesis that starts a defun; see `beginning-of-defun'."
       (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)))))
@@ -206,6 +218,7 @@ before and after, depending on the surrounding characters."
     (setq arg 0))
   (or (eq arg 0) (skip-chars-forward " \t"))
   (and parens-require-spaces
+       (not (bobp))
        (memq (char-syntax (preceding-char)) '(?w ?_ ?\) ))
        (insert " "))
   (insert ?\()
@@ -213,6 +226,7 @@ before and after, depending on the surrounding characters."
     (or (eq arg 0) (forward-sexp arg))
     (insert ?\))
     (and parens-require-spaces
+        (not (eobp))
         (memq (char-syntax (following-char)) '(?w ?_ ?\( ))
         (insert " "))))
 
@@ -265,7 +279,12 @@ function definitions, values or properties are considered."
           (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
@@ -275,7 +294,7 @@ function definitions, values or properties are considered."
                                     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")))))