(make-variable-buffer-local 'next-error-function)
-(defsubst next-error-buffer-p (buffer
- &optional
- extra-test-inclusive
+(defsubst next-error-buffer-p (buffer
+ &optional
+ extra-test-inclusive
extra-test-exclusive)
"Test if BUFFER is a next-error capable buffer.
EXTRA-TEST-INCLUSIVE is called to allow extra buffers.
-EXTRA-TEST-INCLUSIVE is called to disallow buffers."
+EXTRA-TEST-EXCLUSIVE is called to disallow buffers."
(with-current-buffer buffer
(or (and extra-test-inclusive (funcall extra-test-inclusive))
(and (if extra-test-exclusive (funcall extra-test-exclusive) t)
next-error-function))))
-(defun next-error-find-buffer (&optional other-buffer
- extra-test-inclusive
+(defun next-error-find-buffer (&optional other-buffer
+ extra-test-inclusive
extra-test-exclusive)
"Return a next-error capable buffer.
OTHER-BUFFER will disallow the current buffer.
EXTRA-TEST-INCLUSIVE is called to allow extra buffers.
-EXTRA-TEST-INCLUSIVE is called to disallow buffers."
+EXTRA-TEST-EXCLUSIVE is called to disallow buffers."
(or
;; 1. If one window on the selected frame displays such buffer, return it.
(let ((window-buffers
(delete-dups
(delq nil (mapcar (lambda (w)
(if (next-error-buffer-p
- (window-buffer w)
- extra-test-inclusive extra-test-exclusive)
+ (window-buffer w)
+ extra-test-inclusive extra-test-exclusive)
(window-buffer w)))
(window-list))))))
(if other-buffer
;; 2. If next-error-last-buffer is set to a live buffer, use that.
(if (and next-error-last-buffer
(buffer-name next-error-last-buffer)
- (next-error-buffer-p next-error-last-buffer
- extra-test-inclusive extra-test-exclusive)
+ (next-error-buffer-p next-error-last-buffer
+ extra-test-inclusive extra-test-exclusive)
(or (not other-buffer)
(not (eq next-error-last-buffer (current-buffer)))))
next-error-last-buffer)
;; 3. If the current buffer is a next-error capable buffer, return it.
(if (and (not other-buffer)
- (next-error-buffer-p (current-buffer)
- extra-test-inclusive extra-test-exclusive))
+ (next-error-buffer-p (current-buffer)
+ extra-test-inclusive extra-test-exclusive))
(current-buffer))
;; 4. Look for a next-error capable buffer in a buffer list.
(let ((buffers (buffer-list)))
(while (and buffers
- (or (not (next-error-buffer-p
- (car buffers)
- extra-test-inclusive extra-test-exclusive))
+ (or (not (next-error-buffer-p
+ (car buffers)
+ extra-test-inclusive extra-test-exclusive))
(and other-buffer (eq (car buffers) (current-buffer)))))
(setq buffers (cdr buffers)))
(if buffers
(car buffers)
(or (and other-buffer
- (next-error-buffer-p (current-buffer)
- extra-test-inclusive extra-test-exclusive)
+ (next-error-buffer-p (current-buffer)
+ extra-test-inclusive extra-test-exclusive)
;; The current buffer is a next-error capable buffer.
(progn
(if other-buffer
(skip-chars-forward " \t")
(constrain-to-field nil orig-pos t)))))
\f
-(defvar inhibit-mark-movement nil
- "If non-nil, \\[beginning-of-buffer] and \\[end-of-buffer] does not set the mark.")
-
(defun beginning-of-buffer (&optional arg)
"Move point to the beginning of the buffer; leave mark at previous position.
With \\[universal-argument] prefix, do not set mark at previous position.
Don't use this command in Lisp programs!
\(goto-char (point-min)) is faster and avoids clobbering the mark."
(interactive "P")
- (unless (or inhibit-mark-movement (consp arg))
- (push-mark))
+ (or (consp arg)
+ (and transient-mark-mode mark-active)
+ (push-mark))
(let ((size (- (point-max) (point-min))))
(goto-char (if (and arg (not (consp arg)))
(+ (point-min)
Don't use this command in Lisp programs!
\(goto-char (point-max)) is faster and avoids clobbering the mark."
(interactive "P")
- (unless (or inhibit-mark-movement (consp arg))
- (push-mark))
+ (or (consp arg)
+ (and transient-mark-mode mark-active)
+ (push-mark))
(let ((size (- (point-max) (point-min))))
(goto-char (if (and arg (not (consp arg)))
(- (point-max)
(t
'(0 . 0)))
'(0 . 0)))
+
+;; When the first undo batch in an undo list is longer than undo-outer-limit,
+;; this function gets called to ask the user what to do.
+;; Garbage collection is inhibited around the call,
+;; so it had better not do a lot of consing.
+(setq undo-outer-limit-function 'undo-outer-limit-truncate)
+(defun undo-outer-limit-truncate (size)
+ (if (yes-or-no-p (format "Buffer %s undo info is %d bytes long; discard it? "
+ (buffer-name) size))
+ (progn (setq buffer-undo-list nil) t)
+ nil))
\f
(defvar shell-command-history nil
"History list for some commands that read shell commands.")
Many commands change their behavior when Transient Mark mode is in effect
and the mark is active, by acting on the region instead of their usual
default part of the buffer's text. Examples of such commands include
-\\[comment-dwim], \\[flush-lines], \\[ispell], \\[keep-lines],
-\\[query-replace], \\[query-replace-regexp], and \\[undo]. Invoke
-\\[apropos-documentation] and type \"transient\" or \"mark.*active\" at
-the prompt, to see the documentation of commands which are sensitive to
-the Transient Mark mode."
+\\[comment-dwim], \\[flush-lines], \\[keep-lines], \
+\\[query-replace], \\[query-replace-regexp], \\[ispell], and \\[undo].
+Invoke \\[apropos-documentation] and type \"transient\" or
+\"mark.*active\" at the prompt, to see the documentation of
+commands which are sensitive to the Transient Mark mode."
:global t :group 'editing-basics :require nil)
(defun pop-global-mark ()
(if (if forward
;; If going forward, don't accept the previous
;; allowable position if it is before the target line.
- (< line-beg (point))
+ (< line-beg (point))
;; If going backward, don't accept the previous
;; allowable position if it is still after the target line.
(<= (point) line-end))
(interactive "p")
(forward-word (- (or arg 1))))
-(defun mark-word (arg)
- "Set mark arg words away from point.
-If this command is repeated, it marks the next ARG words after the ones
-already marked."
- (interactive "p")
- (cond ((and (eq last-command this-command) (mark t))
+(defun mark-word (&optional arg)
+ "Set mark ARG words away from point.
+The place mark goes is the same place \\[forward-word] would
+move to with the same argument.
+If this command is repeated or mark is active in Transient Mark mode,
+it marks the next ARG words after the ones already marked."
+ (interactive "P")
+ (cond ((or (and (eq last-command this-command) (mark t))
+ (and transient-mark-mode mark-active))
+ (setq arg (if arg (prefix-numeric-value arg)
+ (if (< (mark) (point)) -1 1)))
(set-mark
(save-excursion
(goto-char (mark))
(t
(push-mark
(save-excursion
- (forward-word arg)
+ (forward-word (prefix-numeric-value arg))
(point))
nil t))))
(abort-recursive-edit))
(current-prefix-arg
nil)
- ((and transient-mark-mode
- mark-active)
+ ((and transient-mark-mode mark-active)
(deactivate-mark))
((> (recursion-depth) 0)
(exit-recursive-edit))