GNU Info

(emacs-lisp-intro.info)fwd-para while

---

Next: fwd-para between paragraphs Prev: fwd-para let Up: forward-paragraph

---

Enter node , (file) or (file)node

The forward motion `while' loop
-------------------------------

   The second part of the body of the `let*' deals with forward motion.
It is a `while' loop that repeats itself so long as the value of `arg'
is greater than zero.  In the most common use of the function, the
value of the argument is 1, so the body of the `while' loop is
evaluated exactly once, and the cursor moves forward one paragraph.

   This part handles three situations: when point is between paragraphs,
when point is within a paragraph and there is a fill prefix, and when
point is within a paragraph and there is no fill prefix.

   The `while' loop looks like this:

     (while (> arg 0)
       (beginning-of-line)
     
       ;; between paragraphs
       (while (prog1 (and (not (eobp))
                          (looking-at paragraph-separate))
                (forward-line 1)))
     
       ;; within paragraphs, with a fill prefix
       (if fill-prefix-regexp
           ;; There is a fill prefix; it overrides paragraph-start.
           (while (and (not (eobp))
                       (not (looking-at paragraph-separate))
                       (looking-at fill-prefix-regexp))
             (forward-line 1))
     
         ;; within paragraphs, no fill prefix
         (if (re-search-forward paragraph-start nil t)
             (goto-char (match-beginning 0))
           (goto-char (point-max))))
     
       (setq arg (1- arg)))

   We can see immediately that this is a decrementing counter `while'
loop, using the expression `(setq arg (1- arg))' as the decrementer.

   The body of the loop consists of three expressions:

     ;; between paragraphs
     (beginning-of-line)
     (while
         BODY-OF-WHILE)
     
     ;; within paragraphs, with fill prefix
     (if TRUE-OR-FALSE-TEST
         THEN-PART
     
     ;; within paragraphs, no fill prefix
       ELSE-PART

When the Emacs Lisp interpreter evaluates the body of the `while' loop,
the first thing it does is evaluate the `(beginning-of-line)'
expression and move point to the beginning of the line.  Then there is
an inner `while' loop.  This `while' loop is designed to move the
cursor out of the blank space between paragraphs, if it should happen
to be there.  Finally, there is an `if' expression that actually moves
point to the end of the paragraph.