@c in the Texinfo version 4.6 of the 2003 Jun 13 distribution.
@tex
-\global\def\xrefprintnodename#1{\unskip, ``#1''}
+\if \xrefprintnodename
+ \global\def\xrefprintnodename#1{\unskip, ``#1''}
+ \else
+ \global\def\xrefprintnodename#1{ ``#1''}
+\fi
% \global\def\xrefprintnodename#1{, ``#1''}
@end tex
@dircategory Emacs
@direntry
* Emacs Lisp Intro: (eintr).
- A simple introduction to Emacs Lisp programming.
+ A simple introduction to Emacs Lisp programming.
@end direntry
@copying
(interactive
(list (read-buffer "Append to buffer: " (other-buffer
(current-buffer) t))
- (region-beginning) (region-end)))
+ (region-beginning) (region-end)))
@end group
@group
(let ((oldbuf (current-buffer)))
(save-excursion
(let* ((append-to (get-buffer-create buffer))
- (windows (get-buffer-window-list append-to t t))
- point)
- (set-buffer append-to)
- (setq point (point))
- (barf-if-buffer-read-only)
- (insert-buffer-substring oldbuf start end)
- (dolist (window windows)
- (when (= (window-point window) point)
- (set-window-point window (point))))))))
+ (windows (get-buffer-window-list append-to t t))
+ point)
+ (set-buffer append-to)
+ (setq point (point))
+ (barf-if-buffer-read-only)
+ (insert-buffer-substring oldbuf start end)
+ (dolist (window windows)
+ (when (= (window-point window) point)
+ (set-window-point window (point))))))))
@end group
@end smallexample
Function Interactive}.) The expression reads as follows:
@smallexample
+@group
(interactive
- (list (read-buffer
- "Append to buffer: "
- (other-buffer (current-buffer) t))
- (region-beginning)
- (region-end)))
+ (list (read-buffer
+ "Append to buffer: "
+ (other-buffer (current-buffer) t))
+ (region-beginning)
+ (region-end)))
+@end group
@end smallexample
@noindent
START and END specify the portion of the current buffer to be copied."
(interactive
(list (read-buffer "Append to buffer: " (other-buffer (current-buffer) t))
- (region-beginning) (region-end)))
+ (region-beginning) (region-end)))
(let ((oldbuf (current-buffer)))
(save-excursion
(let* ((append-to (get-buffer-create buffer))
- (windows (get-buffer-window-list append-to t t))
- point)
- (set-buffer append-to)
- (setq point (point))
- (barf-if-buffer-read-only)
- (insert-buffer-substring oldbuf start end)
- (dolist (window windows)
- (when (= (window-point window) point)
- (set-window-point window (point))))))))
+ (windows (get-buffer-window-list append-to t t))
+ point)
+ (set-buffer append-to)
+ (setq point (point))
+ (barf-if-buffer-read-only)
+ (insert-buffer-substring oldbuf start end)
+ (dolist (window windows)
+ (when (= (window-point window) point)
+ (set-window-point window (point))))))))
@end ignore
The body of the @code{append-to-buffer} function begins with @code{let}.
(let ((oldbuf (current-buffer)))
(save-excursion
(let* ((append-to (get-buffer-create buffer))
- (windows (get-buffer-window-list append-to t t))
- point)
- (set-buffer append-to)
- (setq point (point))
- (barf-if-buffer-read-only)
- (insert-buffer-substring oldbuf start end)
- (dolist (window windows)
- (when (= (window-point window) point)
- (set-window-point window (point))))))))
+ (windows (get-buffer-window-list append-to t t))
+ point)
+ (set-buffer append-to)
+ (setq point (point))
+ (barf-if-buffer-read-only)
+ (insert-buffer-substring oldbuf start end)
+ (dolist (window windows)
+ (when (= (window-point window) point)
+ (set-window-point window (point))))))))
@end ignore
The @code{append-to-buffer} function definition inserts text from the
Here is a discussion based on the original code. The code was
simplified in 2003 and is harder to understand.
-@xref{New insert-buffer, , New Body for @code{insert-buffer}}, to see
+(@xref{New insert-buffer, , New Body for @code{insert-buffer}}, to see
a discussion of the new body.)
In addition, this code illustrates the use of @code{interactive} with a
As previously described, when invoked without an argument,
@code{beginning-of-buffer} moves the cursor to the beginning of the
-buffer (in truth, the accessible portion of the buffer), leaving the
-mark at the previous position. However, when the command is invoked
-with a number between one and ten, the function considers that number
-to be a fraction of the length of the buffer, measured in tenths, and
-Emacs moves the cursor that fraction of the way from the beginning of
-the buffer. Thus, you can either call this function with the key
-command @kbd{M-<}, which will move the cursor to the beginning of the
-buffer, or with a key command such as @kbd{C-u 7 M-<} which will move
-the cursor to a point 70% of the way through the buffer. If a number
-bigger than ten is used for the argument, it moves to the end of the
-buffer.
+buffer (in truth, the beginning of the accessible portion of the
+buffer), leaving the mark at the previous position. However, when the
+command is invoked with a number between one and ten, the function
+considers that number to be a fraction of the length of the buffer,
+measured in tenths, and Emacs moves the cursor that fraction of the
+way from the beginning of the buffer. Thus, you can either call this
+function with the key command @kbd{M-<}, which will move the cursor to
+the beginning of the buffer, or with a key command such as @kbd{C-u 7
+M-<} which will move the cursor to a point 70% of the way through the
+buffer. If a number bigger than ten is used for the argument, it
+moves to the end of the buffer.
The @code{beginning-of-buffer} function can be called with or without an
argument. The use of the argument is optional.
@group
(if (> (buffer-size) 10000)
;; @r{Avoid overflow for large buffer sizes!}
- (* (prefix-numeric-value arg)
- (/ size 10))
+ (* (prefix-numeric-value arg)
+ (/ size 10))
(/
(+ 10
(*
@group
(let ((size (- (point-max) (point-min))))
(goto-char (if (and arg (not (consp arg)))
- (+ (point-min)
- (if (> size 10000)
- ;; Avoid overflow for large buffer sizes!
- (* (prefix-numeric-value arg)
- (/ size 10))
- (/ (+ 10 (* size (prefix-numeric-value arg))) 10)))
- (point-min))))
+ (+ (point-min)
+ (if (> size 10000)
+ ;; Avoid overflow for large buffer sizes!
+ (* (prefix-numeric-value arg)
+ (/ size 10))
+ (/ (+ 10 (* size (prefix-numeric-value arg))) 10)))
+ (point-min))))
(if arg (forward-line 1)))
@end group
@end smallexample
"Print the current buffer line number and narrowed line number of point."
(interactive)
(let ((start (point-min))
- (n (line-number-at-pos)))
+ (n (line-number-at-pos)))
(if (= start 1)
- (message "Line %d" n)
+ (message "Line %d" n)
(save-excursion
- (save-restriction
- (widen)
- (message "line %d (narrowed line %d)"
- (+ n (line-number-at-pos start) -1) n))))))
+ (save-restriction
+ (widen)
+ (message "line %d (narrowed line %d)"
+ (+ n (line-number-at-pos start) -1) n))))))
(defun line-number-at-pos (&optional pos)
"Return (narrowed) buffer line number at position POS.
(narrow-to-region start end)
(goto-char (point-min))
(if (eq selective-display t)
- (save-match-data
- (let ((done 0))
- (while (re-search-forward "[\n\C-m]" nil t 40)
- (setq done (+ 40 done)))
- (while (re-search-forward "[\n\C-m]" nil t 1)
- (setq done (+ 1 done)))
- (goto-char (point-max))
- (if (and (/= start end)
- (not (bolp)))
- (1+ done)
- done)))
- (- (buffer-size) (forward-line (buffer-size)))))))
+ (save-match-data
+ (let ((done 0))
+ (while (re-search-forward "[\n\C-m]" nil t 40)
+ (setq done (+ 40 done)))
+ (while (re-search-forward "[\n\C-m]" nil t 1)
+ (setq done (+ 1 done)))
+ (goto-char (point-max))
+ (if (and (/= start end)
+ (not (bolp)))
+ (1+ done)
+ done)))
+ (- (buffer-size) (forward-line (buffer-size)))))))
@end ignore
@node what-line, narrow Exercise, save-restriction, Narrowing & Widening
(narrow-to-region start end)
(goto-char (point-min))
(if (eq selective-display t)
- (save-match-data
- (let ((done 0))
- (while (re-search-forward "[\n\C-m]" nil t 40)
- (setq done (+ 40 done)))
- (while (re-search-forward "[\n\C-m]" nil t 1)
- (setq done (+ 1 done)))
- (goto-char (point-max))
- (if (and (/= start end)
- (not (bolp)))
- (1+ done)
- done)))
- (- (buffer-size) (forward-line (buffer-size)))))))
+ (save-match-data
+ (let ((done 0))
+ (while (re-search-forward "[\n\C-m]" nil t 40)
+ (setq done (+ 40 done)))
+ (while (re-search-forward "[\n\C-m]" nil t 1)
+ (setq done (+ 1 done)))
+ (goto-char (point-max))
+ (if (and (/= start end)
+ (not (bolp)))
+ (1+ done)
+ done)))
+ (- (buffer-size) (forward-line (buffer-size)))))))
@end ignore
@noindent
@code{filter-buffer-substring} @dots{}, yet other functions. Text
properties are a feature otherwise not discussed here. @xref{Text
Properties, , Text Properties, elisp, The GNU Emacs Lisp Reference
-Manual}.
+Manual}.)
Additionally, do you really need @code{goto-char} or @code{point-min}?
-Or can you write the function without them?)
+Or can you write the function without them?
@node car cdr & cons, Cutting & Storing Text, Narrowing & Widening, Top
@comment node-name, next, previous, up
@section @code{zap-to-char}
@findex zap-to-char
-The @code{zap-to-char} function changed a little between GNU Emacs
+The @code{zap-to-char} function changed little between GNU Emacs
version 19 and GNU Emacs version 22. However, @code{zap-to-char}
calls another function, @code{kill-region}, which enjoyed a major
rewrite.
@unnumberedsubsec The Complete @code{zap-to-char} Implementation
@end ifnottex
-The GNU Emacs version 19 and version 21 implementations of the
-@code{zap-to-char} function are nearly identical in form, and they
-work alike. The function removes the text in the region between the
-location of the cursor (i.e., of point) up to and including the next
-occurrence of a specified character. The text that @code{zap-to-char}
-removes is put in the kill ring; and it can be retrieved from the kill
-ring by typing @kbd{C-y} (@code{yank}). If the command is given an
-argument, it removes text through that number of occurrences. Thus,
-if the cursor were at the beginning of this sentence and the character
-were @samp{s}, @samp{Thus} would be removed. If the argument were
-two, @samp{Thus, if the curs} would be removed, up to and including
-the @samp{s} in @samp{cursor}.
+The @code{zap-to-char} function removes the text in the region between
+the location of the cursor (i.e., of point) up to and including the
+next occurrence of a specified character. The text that
+@code{zap-to-char} removes is put in the kill ring; and it can be
+retrieved from the kill ring by typing @kbd{C-y} (@code{yank}). If
+the command is given an argument, it removes text through that number
+of occurrences. Thus, if the cursor were at the beginning of this
+sentence and the character were @samp{s}, @samp{Thus} would be
+removed. If the argument were two, @samp{Thus, if the curs} would be
+removed, up to and including the @samp{s} in @samp{cursor}.
If the specified character is not found, @code{zap-to-char} will say
``Search failed'', tell you the character you typed, and not remove
(if (char-table-p translation-table-for-input)
(setq char (or (aref translation-table-for-input char) char)))
(kill-region (point) (progn
- (search-forward (char-to-string char) nil nil arg)
- (point))))
+ (search-forward (char-to-string char) nil nil arg)
+ (point))))
@end group
@end smallexample
+The documentation is thorough. You do need to know the jargon meaning
+of the word `kill'.
+
@node zap-to-char interactive, zap-to-char body, Complete zap-to-char, zap-to-char
@comment node-name, next, previous, up
@subsection The @code{interactive} Expression
message saying that the buffer is read-only. Also, the terminal may
beep or blink at you.
-Let us continue with the interactive specification.
-
@node zap-to-char body, search-forward, zap-to-char interactive, zap-to-char
@comment node-name, next, previous, up
@subsection The Body of @code{zap-to-char}
kills (that is, removes) the text in the region from the current
position of the cursor up to and including the specified character.
-The documentation is thorough. You do need to know the jargon meaning
-of the word `kill'.
-
The first part of the code looks like this:
@smallexample
(error "The mark is not set now, so there is no region"))
(condition-case nil
(let ((string (filter-buffer-substring beg end t)))
- (when string ;STRING is nil if BEG = END
- ;; Add that string to the kill ring, one way or another.
- (if (eq last-command 'kill-region)
- (kill-append string (< end beg) yank-handler)
- (kill-new string nil yank-handler)))
- (when (or string (eq last-command 'kill-region))
- (setq this-command 'kill-region))
- nil)
+ (when string ;STRING is nil if BEG = END
+ ;; Add that string to the kill ring, one way or another.
+ (if (eq last-command 'kill-region)
+ (kill-append string (< end beg) yank-handler)
+ (kill-new string nil yank-handler)))
+ (when (or string (eq last-command 'kill-region))
+ (setq this-command 'kill-region))
+ nil)
((buffer-read-only text-read-only)
;; The code above failed because the buffer, or some of the characters
;; in the region, are read-only.
(setq this-command 'kill-region)
;; This should barf, if appropriate, and give us the correct error.
(if kill-read-only-ok
- (progn (message "Read only text copied to kill ring") nil)
+ (progn (message "Read only text copied to kill ring") nil)
;; Signal an error if the buffer is read-only.
(barf-if-buffer-read-only)
;; If the buffer isn't read-only, the text is.
;; @bullet{} Since order matters, pass point first.
(interactive (list (point) (mark)))
;; @bullet{} And tell us if we cannot cut the text.
+ ;; `unless' is an `if' without a then-part.
(unless (and beg end)
(error "The mark is not set now, so there is no region"))
@end group
@end group
@group
(let ((string (filter-buffer-substring beg end t)))
- (when string ;STRING is nil if BEG = END
+ (when string ;STRING is nil if BEG = END
;; Add that string to the kill ring, one way or another.
(if (eq last-command 'kill-region)
@end group
;; `kill-new' functions how deal with properties
;; added to the text, such as `bold' or `italics'.
(kill-append string (< end beg) yank-handler)
- (kill-new string nil yank-handler)))
- (when (or string (eq last-command 'kill-region))
- (setq this-command 'kill-region))
- nil)
+ (kill-new string nil yank-handler)))
+ (when (or string (eq last-command 'kill-region))
+ (setq this-command 'kill-region))
+ nil)
@end group
@group
enables you to define new control constructs and other language
features. It tells the interpreter how to compute another Lisp
expression which will in turn compute the value. In this case, the
-`other expression' is an @code{if} expression. For more about Lisp
-macros, see @ref{Macros, , Macros, elisp, The GNU Emacs Lisp Reference
-Manual}. The C programming language also provides macros. These are
-different, but also useful.
+`other expression' is an @code{if} expression.
+
+The @code{kill-region} function definition also has an @code{unless}
+macro; it is the converse of @code{when}. The @code{unless} macro is
+an @code{if} without a then clause
+
+For more about Lisp macros, see @ref{Macros, , Macros, elisp, The GNU
+Emacs Lisp Reference Manual}. The C programming language also
+provides macros. These are different, but also useful.
@ignore
We will briefly look at C macros in
@end ignore
@need 1200
-If the string has content, then another conditional expression is
-executed. This is an @code{if} with both a then-part and an else-part.
+Regarding the @code{when} macro, in the @code{condition-case}
+expression, when the string has content, then another conditional
+expression is executed. This is an @code{if} with both a then-part
+and an else-part.
@smallexample
@group
function.
@need 1250
-The @code{if} expression reads as follows; it uses @code{eq}, which is
-a function we have not yet seen:
+The @code{if} expression reads as follows; it uses @code{eq}:
@smallexample
@group
@dots{} "
(let* ((cur (car kill-ring)))
(kill-new (if before-p (concat string cur) (concat cur string))
- (or (= (length cur) 0)
- (equal yank-handler (get-text-property 0 'yank-handler cur)))
- yank-handler)))
+ (or (= (length cur) 0)
+ (equal yank-handler
+ (get-text-property 0 'yank-handler cur)))
+ yank-handler)))
@end group
@end smallexample
@group
(if (> (length string) 0)
(if yank-handler
- (put-text-property 0 (length string)
- 'yank-handler yank-handler string))
+ (put-text-property 0 (length string)
+ 'yank-handler yank-handler string))
(if yank-handler
- (signal 'args-out-of-range
- (list string "yank-handler specified for empty string"))))
+ (signal 'args-out-of-range
+ (list string "yank-handler specified for empty string"))))
@end group
@group
(if (fboundp 'menu-bar-update-yank-menu)
(setcar kill-ring string)
(push string kill-ring)
(if (> (length kill-ring) kill-ring-max)
- (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))
+ (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))
@end group
@group
(setq kill-ring-yank-pointer kill-ring)
(funcall interprogram-cut-function string (not replace))))
@end ignore
-@noindent
(Notice that the function is not interactive.)
As usual, we can look at this function in parts.
@noindent
@need 1250
-@code{push} puts its first argument onto the second. It is the same
-as the older
+@code{push} puts its first argument onto the second. It is similar to
+the older
@smallexample
(setq kill-ring (cons string kill-ring))
@findex setcdr, @r{example}
Thus, if we had a four element list that was supposed to be three
elements long, we could set the @sc{cdr} of the next to last element
-to @code{nil}, and thereby shorten the list. (If you sent the last
+to @code{nil}, and thereby shorten the list. (If you set the last
element to some other value than @code{nil}, which you could do, then
you would not have shortened the list. @xref{setcdr, ,
@code{setcdr}}.)
Even though the @code{kill-ring-yank-pointer} is called a
@samp{pointer}, it is a variable just like the kill ring. However, the
name has been chosen to help humans understand how the variable is used.
-The variable is used in functions such as @code{yank} and
-@code{yank-pop} (@pxref{Yanking, , Yanking Text Back}).
@need 1200
Now, to return to an early expression in the body of the function:
bringing back text that has been cut out of the buffer---the yank
commands. However, before discussing the yank commands, it is better
to learn how lists are implemented in a computer. This will make
-clear such mysteries as the use of the term `pointer'.
+clear such mysteries as the use of the term `pointer'. But before
+that, we will digress into C.
@ignore
@c is this true in Emacs 22? Does not seems to be
If optional arg DO-NOT-MOVE is non-nil, then don't actually move the
yanking point; just return the Nth kill forward."
(let ((interprogram-paste (and (= n 0)
- interprogram-paste-function
- (funcall interprogram-paste-function))))
+ interprogram-paste-function
+ (funcall interprogram-paste-function))))
(if interprogram-paste
- (progn
- ;; Disable the interprogram cut function when we add the new
- ;; text to the kill ring, so Emacs doesn't try to own the
- ;; selection, with identical text.
- (let ((interprogram-cut-function nil))
- (kill-new interprogram-paste))
- interprogram-paste)
+ (progn
+ ;; Disable the interprogram cut function when we add the new
+ ;; text to the kill ring, so Emacs doesn't try to own the
+ ;; selection, with identical text.
+ (let ((interprogram-cut-function nil))
+ (kill-new interprogram-paste))
+ interprogram-paste)
(or kill-ring (error "Kill ring is empty"))
(let ((ARGth-kill-element
- (nthcdr (mod (- n (length kill-ring-yank-pointer))
- (length kill-ring))
- kill-ring)))
- (or do-not-move
- (setq kill-ring-yank-pointer ARGth-kill-element))
- (car ARGth-kill-element)))))
+ (nthcdr (mod (- n (length kill-ring-yank-pointer))
+ (length kill-ring))
+ kill-ring)))
+ (or do-not-move
+ (setq kill-ring-yank-pointer ARGth-kill-element))
+ (car ARGth-kill-element)))))
@end ignore
(sentence-end (sentence-end)))
(while (< arg 0)
(let ((pos (point))
- (par-beg (save-excursion (start-of-paragraph-text) (point))))
+ (par-beg (save-excursion (start-of-paragraph-text) (point))))
(if (and (re-search-backward sentence-end par-beg t)
- (or (< (match-end 0) pos)
- (re-search-backward sentence-end par-beg t)))
- (goto-char (match-end 0))
- (goto-char par-beg)))
+ (or (< (match-end 0) pos)
+ (re-search-backward sentence-end par-beg t)))
+ (goto-char (match-end 0))
+ (goto-char par-beg)))
(setq arg (1+ arg)))
@end group
@group
(while (> arg 0)
(let ((par-end (save-excursion (end-of-paragraph-text) (point))))
(if (re-search-forward sentence-end par-end t)
- (skip-chars-backward " \t\n")
- (goto-char par-end)))
+ (skip-chars-backward " \t\n")
+ (goto-char par-end)))
(setq arg (1- arg)))
(constrain-to-field nil opoint t)))
@end group
(let ((opoint (point)) (sentence-end (sentence-end)))
(while (< arg 0)
(let ((pos (point))
- (par-beg (save-excursion (start-of-paragraph-text) (point))))
+ (par-beg (save-excursion (start-of-paragraph-text) (point))))
@var{rest-of-body-of-while-loop-when-going-backwards}
(while (> arg 0)
(let ((par-end (save-excursion (end-of-paragraph-text) (point))))
(interactive "p")
(or arg (setq arg 1))
(let* ((opoint (point))
- (fill-prefix-regexp
- (and fill-prefix (not (equal fill-prefix ""))
- (not paragraph-ignore-fill-prefix)
- (regexp-quote fill-prefix)))
- ;; Remove ^ from paragraph-start and paragraph-sep if they are there.
- ;; These regexps shouldn't be anchored, because we look for them
- ;; starting at the left-margin. This allows paragraph commands to
- ;; work normally with indented text.
- ;; This hack will not find problem cases like "whatever\\|^something".
- (parstart (if (and (not (equal "" paragraph-start))
- (equal ?^ (aref paragraph-start 0)))
- (substring paragraph-start 1)
- paragraph-start))
- (parsep (if (and (not (equal "" paragraph-separate))
- (equal ?^ (aref paragraph-separate 0)))
- (substring paragraph-separate 1)
- paragraph-separate))
- (parsep
- (if fill-prefix-regexp
- (concat parsep "\\|"
- fill-prefix-regexp "[ \t]*$")
- parsep))
- ;; This is used for searching.
- (sp-parstart (concat "^[ \t]*\\(?:" parstart "\\|" parsep "\\)"))
- start found-start)
+ (fill-prefix-regexp
+ (and fill-prefix (not (equal fill-prefix ""))
+ (not paragraph-ignore-fill-prefix)
+ (regexp-quote fill-prefix)))
+ ;; Remove ^ from paragraph-start and paragraph-sep if they are there.
+ ;; These regexps shouldn't be anchored, because we look for them
+ ;; starting at the left-margin. This allows paragraph commands to
+ ;; work normally with indented text.
+ ;; This hack will not find problem cases like "whatever\\|^something".
+ (parstart (if (and (not (equal "" paragraph-start))
+ (equal ?^ (aref paragraph-start 0)))
+ (substring paragraph-start 1)
+ paragraph-start))
+ (parsep (if (and (not (equal "" paragraph-separate))
+ (equal ?^ (aref paragraph-separate 0)))
+ (substring paragraph-separate 1)
+ paragraph-separate))
+ (parsep
+ (if fill-prefix-regexp
+ (concat parsep "\\|"
+ fill-prefix-regexp "[ \t]*$")
+ parsep))
+ ;; This is used for searching.
+ (sp-parstart (concat "^[ \t]*\\(?:" parstart "\\|" parsep "\\)"))
+ start found-start)
(while (and (< arg 0) (not (bobp)))
(if (and (not (looking-at parsep))
- (re-search-backward "^\n" (max (1- (point)) (point-min)) t)
- (looking-at parsep))
- (setq arg (1+ arg))
- (setq start (point))
- ;; Move back over paragraph-separating lines.
- (forward-char -1) (beginning-of-line)
- (while (and (not (bobp))
- (progn (move-to-left-margin)
- (looking-at parsep)))
- (forward-line -1))
- (if (bobp)
- nil
- (setq arg (1+ arg))
- ;; Go to end of the previous (non-separating) line.
- (end-of-line)
- ;; Search back for line that starts or separates paragraphs.
- (if (if fill-prefix-regexp
- ;; There is a fill prefix; it overrides parstart.
- (let (multiple-lines)
- (while (and (progn (beginning-of-line) (not (bobp)))
- (progn (move-to-left-margin)
- (not (looking-at parsep)))
- (looking-at fill-prefix-regexp))
- (unless (= (point) start)
- (setq multiple-lines t))
- (forward-line -1))
- (move-to-left-margin)
- ;; This deleted code caused a long hanging-indent line
- ;; not to be filled together with the following lines.
- ;; ;; Don't move back over a line before the paragraph
- ;; ;; which doesn't start with fill-prefix
- ;; ;; unless that is the only line we've moved over.
- ;; (and (not (looking-at fill-prefix-regexp))
- ;; multiple-lines
- ;; (forward-line 1))
- (not (bobp)))
- (while (and (re-search-backward sp-parstart nil 1)
- (setq found-start t)
- ;; Found a candidate, but need to check if it is a
- ;; REAL parstart.
- (progn (setq start (point))
- (move-to-left-margin)
- (not (looking-at parsep)))
- (not (and (looking-at parstart)
- (or (not use-hard-newlines)
- (bobp)
- (get-text-property
- (1- start) 'hard)))))
- (setq found-start nil)
- (goto-char start))
- found-start)
- ;; Found one.
- (progn
- ;; Move forward over paragraph separators.
- ;; We know this cannot reach the place we started
- ;; because we know we moved back over a non-separator.
- (while (and (not (eobp))
- (progn (move-to-left-margin)
- (looking-at parsep)))
- (forward-line 1))
- ;; If line before paragraph is just margin, back up to there.
- (end-of-line 0)
- (if (> (current-column) (current-left-margin))
- (forward-char 1)
- (skip-chars-backward " \t")
- (if (not (bolp))
- (forward-line 1))))
- ;; No starter or separator line => use buffer beg.
- (goto-char (point-min))))))
+ (re-search-backward "^\n" (max (1- (point)) (point-min)) t)
+ (looking-at parsep))
+ (setq arg (1+ arg))
+ (setq start (point))
+ ;; Move back over paragraph-separating lines.
+ (forward-char -1) (beginning-of-line)
+ (while (and (not (bobp))
+ (progn (move-to-left-margin)
+ (looking-at parsep)))
+ (forward-line -1))
+ (if (bobp)
+ nil
+ (setq arg (1+ arg))
+ ;; Go to end of the previous (non-separating) line.
+ (end-of-line)
+ ;; Search back for line that starts or separates paragraphs.
+ (if (if fill-prefix-regexp
+ ;; There is a fill prefix; it overrides parstart.
+ (let (multiple-lines)
+ (while (and (progn (beginning-of-line) (not (bobp)))
+ (progn (move-to-left-margin)
+ (not (looking-at parsep)))
+ (looking-at fill-prefix-regexp))
+ (unless (= (point) start)
+ (setq multiple-lines t))
+ (forward-line -1))
+ (move-to-left-margin)
+ ;; This deleted code caused a long hanging-indent line
+ ;; not to be filled together with the following lines.
+ ;; ;; Don't move back over a line before the paragraph
+ ;; ;; which doesn't start with fill-prefix
+ ;; ;; unless that is the only line we've moved over.
+ ;; (and (not (looking-at fill-prefix-regexp))
+ ;; multiple-lines
+ ;; (forward-line 1))
+ (not (bobp)))
+ (while (and (re-search-backward sp-parstart nil 1)
+ (setq found-start t)
+ ;; Found a candidate, but need to check if it is a
+ ;; REAL parstart.
+ (progn (setq start (point))
+ (move-to-left-margin)
+ (not (looking-at parsep)))
+ (not (and (looking-at parstart)
+ (or (not use-hard-newlines)
+ (bobp)
+ (get-text-property
+ (1- start) 'hard)))))
+ (setq found-start nil)
+ (goto-char start))
+ found-start)
+ ;; Found one.
+ (progn
+ ;; Move forward over paragraph separators.
+ ;; We know this cannot reach the place we started
+ ;; because we know we moved back over a non-separator.
+ (while (and (not (eobp))
+ (progn (move-to-left-margin)
+ (looking-at parsep)))
+ (forward-line 1))
+ ;; If line before paragraph is just margin, back up to there.
+ (end-of-line 0)
+ (if (> (current-column) (current-left-margin))
+ (forward-char 1)
+ (skip-chars-backward " \t")
+ (if (not (bolp))
+ (forward-line 1))))
+ ;; No starter or separator line => use buffer beg.
+ (goto-char (point-min))))))
(while (and (> arg 0) (not (eobp)))
;; Move forward over separator lines...
(while (and (not (eobp))
- (progn (move-to-left-margin) (not (eobp)))
- (looking-at parsep))
- (forward-line 1))
+ (progn (move-to-left-margin) (not (eobp)))
+ (looking-at parsep))
+ (forward-line 1))
(unless (eobp) (setq arg (1- arg)))
;; ... and one more line.
(forward-line 1)
(if fill-prefix-regexp
- ;; There is a fill prefix; it overrides parstart.
- (while (and (not (eobp))
- (progn (move-to-left-margin) (not (eobp)))
- (not (looking-at parsep))
- (looking-at fill-prefix-regexp))
- (forward-line 1))
- (while (and (re-search-forward sp-parstart nil 1)
- (progn (setq start (match-beginning 0))
- (goto-char start)
- (not (eobp)))
- (progn (move-to-left-margin)
- (not (looking-at parsep)))
- (or (not (looking-at parstart))
- (and use-hard-newlines
- (not (get-text-property (1- start) 'hard)))))
- (forward-char 1))
- (if (< (point) (point-max))
- (goto-char start))))
+ ;; There is a fill prefix; it overrides parstart.
+ (while (and (not (eobp))
+ (progn (move-to-left-margin) (not (eobp)))
+ (not (looking-at parsep))
+ (looking-at fill-prefix-regexp))
+ (forward-line 1))
+ (while (and (re-search-forward sp-parstart nil 1)
+ (progn (setq start (match-beginning 0))
+ (goto-char start)
+ (not (eobp)))
+ (progn (move-to-left-margin)
+ (not (looking-at parsep)))
+ (or (not (looking-at parstart))
+ (and use-hard-newlines
+ (not (get-text-property (1- start) 'hard)))))
+ (forward-char 1))
+ (if (< (point) (point-max))
+ (goto-char start))))
(constrain-to-field nil opoint t)
;; Return the number of steps that could not be done.
arg))
(interactive (find-file-read-args "Find file: " nil))
(let ((value (find-file-noselect filename nil nil wildcards)))
(if (listp value)
- (mapcar 'switch-to-buffer (nreverse value))
+ (mapcar 'switch-to-buffer (nreverse value))
(switch-to-buffer value))))
@end ignore
This is an interface to the function `load'."
(interactive
(list (completing-read "Load library: "
- 'locate-file-completion
- (cons load-path (get-load-suffixes)))))
+ 'locate-file-completion
+ (cons load-path (get-load-suffixes)))))
(load library))
@end group
@end smallexample
If optional arg DO-NOT-MOVE is non-nil, then don't actually move the
yanking point; just return the Nth kill forward."
(let ((interprogram-paste (and (= n 0)
- interprogram-paste-function
- (funcall interprogram-paste-function))))
+ interprogram-paste-function
+ (funcall interprogram-paste-function))))
@end group
@group
(if interprogram-paste
- (progn
- ;; Disable the interprogram cut function when we add the new
- ;; text to the kill ring, so Emacs doesn't try to own the
- ;; selection, with identical text.
- (let ((interprogram-cut-function nil))
- (kill-new interprogram-paste))
- interprogram-paste)
+ (progn
+ ;; Disable the interprogram cut function when we add the new
+ ;; text to the kill ring, so Emacs doesn't try to own the
+ ;; selection, with identical text.
+ (let ((interprogram-cut-function nil))
+ (kill-new interprogram-paste))
+ interprogram-paste)
@end group
@group
(or kill-ring (error "Kill ring is empty"))
(let ((ARGth-kill-element
- (nthcdr (mod (- n (length kill-ring-yank-pointer))
- (length kill-ring))
- kill-ring)))
- (or do-not-move
- (setq kill-ring-yank-pointer ARGth-kill-element))
- (car ARGth-kill-element)))))
+ (nthcdr (mod (- n (length kill-ring-yank-pointer))
+ (length kill-ring))
+ kill-ring)))
+ (or do-not-move
+ (setq kill-ring-yank-pointer ARGth-kill-element))
+ (car ARGth-kill-element)))))
@end group
@end smallexample
@end group
@group
(insert-for-yank (current-kill (cond
- ((listp arg) 0)
- ((eq arg '-) -2)
- (t (1- arg)))))
+ ((listp arg) 0)
+ ((eq arg '-) -2)
+ (t (1- arg)))))
(if (consp arg)
;; This is like exchange-point-and-mark,
;; but doesn't activate the mark.
;; It is cleaner to avoid activation, even though the command
;; loop would deactivate the mark because we inserted text.
(goto-char (prog1 (mark t)
- (set-marker (mark-marker) (point) (current-buffer)))))
+ (set-marker (mark-marker) (point) (current-buffer)))))
@end group
@group
;; If we do get all the way thru, make this-command indicate that.
(setq this-command 'yank)
(unless arg (setq arg 1))
(let ((inhibit-read-only t)
- (before (< (point) (mark t))))
+ (before (< (point) (mark t))))
@end group
@group
(if before
- (funcall (or yank-undo-function 'delete-region) (point) (mark t))
+ (funcall (or yank-undo-function 'delete-region) (point) (mark t))
(funcall (or yank-undo-function 'delete-region) (mark t) (point)))
(setq yank-undo-function nil)
@end group
@end group
@group
(if before
- ;; This is like exchange-point-and-mark,
+ ;; This is like exchange-point-and-mark,
;; but doesn't activate the mark.
- ;; It is cleaner to avoid activation, even though the command
- ;; loop would deactivate the mark because we inserted text.
- (goto-char (prog1 (mark t)
- (set-marker (mark-marker)
+ ;; It is cleaner to avoid activation, even though the command
+ ;; loop would deactivate the mark because we inserted text.
+ (goto-char (prog1 (mark t)
+ (set-marker (mark-marker)
(point)
(current-buffer))))))
nil)
HCoop / bpt / emacs.git / blobdiff