(pp-buffer): New fun created from the code in

[gnu-emacs] / lisp / emacs-lisp / lisp.el

diff --git a/lisp/emacs-lisp/lisp.el b/lisp/emacs-lisp/lisp.el
index a815eddfd78f0997754f7ed36fb393fa21fdeed6..53b9e7507ef174308a574444f79a79622b399c8b 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
 
 ;;; lisp.el --- Lisp editing commands for Emacs
 

-;; Copyright (C) 1985, 1986, 1994, 2000 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 86, 1994, 2000, 2004  Free Software Foundation, Inc.

 
 ;; Maintainer: FSF
 ;; Keywords: lisp, languages
 
 ;; Maintainer: FSF
 ;; Keywords: lisp, languages


@@ -157,8 +157,9 @@ normal recipe (see `beginning-of-defun').  Major modes can define this
 if defining `defun-prompt-regexp' is not sufficient to handle the mode's
 needs.
 
 if defining `defun-prompt-regexp' is not sufficient to handle the mode's
 needs.
 

-The function should go to the line on which the current defun starts,
-and return non-nil, or should return nil if it can't find the beginning.")
+The function (of no args) should go to the line on which the current
+defun starts, and return non-nil, or should return nil if it can't
+find the beginning.")

 
 (defun beginning-of-defun (&optional arg)
   "Move backward to the beginning of a defun.
 
 (defun beginning-of-defun (&optional arg)
   "Move backward to the beginning of a defun.


@@ -166,7 +167,7 @@ With ARG, do it that many times.  Negative arg -N
 means move forward to Nth following beginning of defun.
 Returns t unless search stops due to beginning or end of buffer.
 
 means move forward to Nth following beginning of defun.
 Returns t unless search stops due to beginning or end of buffer.
 

-Normally a defun starts when there is an char with open-parenthesis
+Normally a defun starts when there is a 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, and point ends up at the beginning of the line.
 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, and point ends up at the beginning of the line.


@@ -174,6 +175,8 @@ open-parenthesis, and point ends up at the beginning of the line.
 If variable `beginning-of-defun-function' is non-nil, its value
 is called as a function to find the defun's beginning."
   (interactive "p")
 If variable `beginning-of-defun-function' is non-nil, its value
 is called as a function to find the defun's beginning."
   (interactive "p")

+  (and (eq this-command 'beginning-of-defun)
+       (or (eq last-command 'beginning-of-defun) (push-mark)))

   (and (beginning-of-defun-raw arg)
        (progn (beginning-of-line) t)))
 
   (and (beginning-of-defun-raw arg)
        (progn (beginning-of-line) t)))
 


@@ -187,12 +190,17 @@ If variable `beginning-of-defun-function' is non-nil, its value
 is called as a function to find the defun's beginning."
   (interactive "p")
   (if beginning-of-defun-function
 is called as a function to find the defun's beginning."
   (interactive "p")
   (if beginning-of-defun-function

-      (funcall beginning-of-defun-function)
+      (if (> (setq arg (or arg 1)) 0)
+         (dotimes (i arg)
+           (funcall beginning-of-defun-function))
+       ;; Better not call end-of-defun-function directly, in case
+       ;; it's not defined.
+       (end-of-defun (- arg)))

     (and arg (< arg 0) (not (eobp)) (forward-char 1))
     (and (re-search-backward (if defun-prompt-regexp
                                 (concat (if open-paren-in-column-0-is-defun-start
                                             "^\\s(\\|" "")
     (and arg (< arg 0) (not (eobp)) (forward-char 1))
     (and (re-search-backward (if defun-prompt-regexp
                                 (concat (if open-paren-in-column-0-is-defun-start
                                             "^\\s(\\|" "")

-                                        "\\(" defun-prompt-regexp "\\)\\s(")
+                                        "\\(?:" defun-prompt-regexp "\\)\\s(")

                               "^\\s(")
                             nil 'move (or arg 1))
         (progn (goto-char (1- (match-end 0)))) t)))
                               "^\\s(")
                             nil 'move (or arg 1))
         (progn (goto-char (1- (match-end 0)))) t)))


@@ -217,12 +225,19 @@ matches the open-parenthesis that starts a defun; see function
 If variable `end-of-defun-function' is non-nil, its value
 is called as a function to find the defun's end."
   (interactive "p")
 If variable `end-of-defun-function' is non-nil, its value
 is called as a function to find the defun's end."
   (interactive "p")

+  (and (eq this-command 'end-of-defun)
+       (or (eq last-command 'end-of-defun) (push-mark)))
+  (if (or (null arg) (= arg 0)) (setq arg 1))

   (if end-of-defun-function
   (if end-of-defun-function

-      (funcall end-of-defun-function)
-    (if (or (null arg) (= arg 0)) (setq arg 1))
+      (if (> arg 0)
+         (dotimes (i arg)
+           (funcall end-of-defun-function))
+       ;; Better not call beginning-of-defun-function
+       ;; directly, in case it's not defined.
+       (beginning-of-defun (- arg)))

     (let ((first t))
       (while (and (> arg 0) (< (point) (point-max)))
     (let ((first t))
       (while (and (> arg 0) (< (point) (point-max)))

-       (let ((pos (point)) npos)
+       (let ((pos (point)))

          (while (progn
                   (if (and first
                            (progn
          (while (progn
                   (if (and first
                            (progn


@@ -259,17 +274,38 @@ The defun marked is the one that contains point or follows point.
 If this command is repeated, marks more defuns after the ones
 already marked."
   (interactive)
 If this command is repeated, marks more defuns after the ones
 already marked."
   (interactive)

-  (let (here)
-    (when (and (eq last-command this-command) (mark t))
-      (setq here (point))
-      (goto-char (mark)))
-    (push-mark (point))
-    (end-of-defun)
-    (push-mark (point) nil t)
-    (if here
-       (goto-char here)
-      (beginning-of-defun)
-      (re-search-backward "^\n" (- (point) 1) t))))
+  (cond ((and (eq last-command this-command) (mark t))
+        (set-mark
+         (save-excursion
+           (goto-char (mark))
+           (end-of-defun)
+           (point))))
+       (t
+        (let ((opoint (point))
+              beg end)
+          (push-mark opoint)
+          ;; Try first in this order for the sake of languages with nested
+          ;; functions where several can end at the same place as with
+          ;; the offside rule, e.g. Python.
+          (beginning-of-defun)
+          (setq beg (point))
+          (end-of-defun)
+          (setq end (point))
+          (while (looking-at "^\n")
+            (forward-line 1))
+          (if (> (point) opoint)
+              (progn
+                ;; We got the right defun.
+                (push-mark beg nil t)
+                (goto-char end)
+                (exchange-point-and-mark))
+            ;; beginning-of-defun moved back one defun
+            ;; so we got the wrong one.
+            (goto-char opoint)
+            (end-of-defun)
+            (push-mark (point) nil t)
+            (beginning-of-defun))
+          (re-search-backward "^\n" (- (point) 1) t)))))

 
 (defun narrow-to-defun (&optional arg)
   "Make text outside current defun invisible.
 
 (defun narrow-to-defun (&optional arg)
   "Make text outside current defun invisible.


@@ -278,34 +314,71 @@ Optional ARG is ignored."
   (interactive)
   (save-excursion
     (widen)
   (interactive)
   (save-excursion
     (widen)

-    (end-of-defun)
-    (let ((end (point)))
+    (let ((opoint (point))
+         beg end)
+      ;; Try first in this order for the sake of languages with nested
+      ;; functions where several can end at the same place as with
+      ;; the offside rule, e.g. Python.

       (beginning-of-defun)
       (beginning-of-defun)

-      (narrow-to-region (point) end))))
+      (setq beg (point))
+      (end-of-defun)
+      (setq end (point))
+      (while (looking-at "^\n")
+       (forward-line 1))
+      (unless (> (point) opoint)
+       ;; beginning-of-defun moved back one defun
+       ;; so we got the wrong one.
+       (goto-char opoint)
+       (end-of-defun)
+       (setq end (point))
+       (beginning-of-defun)
+       (setq beg (point)))
+      (goto-char end)
+      (re-search-backward "^\n" (- (point) 1) t)
+      (narrow-to-region beg end))))
+
+(defun insert-pair (arg &optional open close)
+  "Enclose following ARG sexps in a pair of OPEN and CLOSE characters.
+Leave point after the first character.
+A negative ARG encloses the preceding ARG sexps instead.
+No argument is equivalent to zero: just insert characters
+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.
+If region is active, insert enclosing characters at region boundaries."
+  (interactive "P")
+  (if arg (setq arg (prefix-numeric-value arg))
+    (setq arg 0))
+  (or open  (setq open  ?\())
+  (or close (setq close ?\)))
+  (if (and transient-mark-mode mark-active)
+      (progn
+        (save-excursion (goto-char (region-end))       (insert close))
+        (save-excursion (goto-char (region-beginning)) (insert open)))
+    (cond ((> arg 0) (skip-chars-forward " \t"))
+          ((< arg 0) (forward-sexp arg) (setq arg (- arg))))
+    (and parens-require-spaces
+         (not (bobp))
+         (memq (char-syntax (preceding-char)) (list ?w ?_ (char-syntax close)))
+         (insert " "))
+    (insert open)
+    (save-excursion
+      (or (eq arg 0) (forward-sexp arg))
+      (insert close)
+      (and parens-require-spaces
+           (not (eobp))
+           (memq (char-syntax (following-char)) (list ?w ?_ (char-syntax open)))
+           (insert " ")))))

 
 (defun insert-parentheses (arg)
   "Enclose following ARG sexps in parentheses.  Leave point after open-paren.
 A negative ARG encloses the preceding ARG sexps instead.
 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
 
 (defun insert-parentheses (arg)
   "Enclose following ARG sexps in parentheses.  Leave point after open-paren.
 A negative ARG encloses the preceding ARG sexps instead.
 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."
+before and after, depending on the surrounding characters.
+If region is active, insert enclosing characters at region boundaries."

   (interactive "P")
   (interactive "P")

-  (if arg (setq arg (prefix-numeric-value arg))
-    (setq arg 0))
-  (cond ((> arg 0) (skip-chars-forward " \t"))
-       ((< arg 0) (forward-sexp arg) (setq arg (- arg))))
-  (and parens-require-spaces
-       (not (bobp))
-       (memq (char-syntax (preceding-char)) '(?w ?_ ?\) ))
-       (insert " "))
-  (insert ?\()
-  (save-excursion
-    (or (eq arg 0) (forward-sexp arg))
-    (insert ?\))
-    (and parens-require-spaces
-        (not (eobp))
-        (memq (char-syntax (following-char)) '(?w ?_ ?\( ))
-        (insert " "))))
+  (insert-pair arg ?\( ?\)))

 
 (defun move-past-close-and-reindent ()
   "Move past next `)', delete indentation before it, then indent after it."
 
 (defun move-past-close-and-reindent ()
   "Move past next `)', delete indentation before it, then indent after it."


@@ -444,4 +517,5 @@ considered."
                   (display-completion-list list)))
               (message "Making completion list...%s" "done")))))))
 
                   (display-completion-list list)))
               (message "Making completion list...%s" "done")))))))
 

+;;; arch-tag: aa7fa8a4-2e6f-4e9b-9cd9-fef06340e67e

 ;;; lisp.el ends here
 ;;; lisp.el ends here