The body of the progn expression

The body of the progn consists of two expressions. Spread out to delineate the different parts more clearly, and with comments added, the progn expression looks like this:

(progn 

  (goto-char                ; First expression in progn.
        (if (> arg 0)       ; If arg is positive,
            (1- (point))    ;   move back one character;
          (1+ (point))))    ;   else move forward one character.

  (point))                  ; Second expression in progn:
                            ;   return position of point.

The progn expression does this: when the search is forward (arg is positive), Emacs leaves point just after the searched-for character. By moving point back one position, the character is uncovered. In this case, the expression in the progn reads as follows: (goto-char (1- (point))). This moves point one character back. (The 1- function subtracts one from its argument, just as 1+ adds ones to its argument.) On the other hand, if the argument to zap-to-character is negative, the search will be backwards. The if detects this and the expression reads: (goto-char (1+ (point))). (The 1+ function adds one to its argument.)

The second and last argument to progn is the expression (point). This expression returns the value of the position to which point is moved by the first argument to progn. This value is then returned by the if expression of which it is a part and is passed to kill-region as kill-region's second argument.

In brief, the function works like this: the first argument to kill-region is the position of the cursor when the zap-to-char command is given--the value of point at that time. The search function then moves point if the search is successful. The progn expression moves point just enough so the zapped to character is not removed, and returns the value of point after all this is done. The kill-region function then removes the region.

Finally, the else-part of the if expression takes care of the situation in which the zapped-towards character is not found. If the argument to the zap-to-char function is positive (or if none is given) and the zapped-to character is not found, all the text is removed from the current position of point to the end of the accessible region of the buffer (the end of the buffer if there is no narrowing). If the arg is negative and the zapped-to character is not found, the operation goes to the beginning of the accessible region. The code for this is a simple if clause:

(if (> arg 0) (point-max) (point-min))

This says that if arg is a positive number, return the value of point-max, otherwise, return the value of point-min.

For review, here is the code involving kill-region, with comments:

(kill-region
 (point)                    ; beginning-of-region
 (if (search-forward
      (char-to-string char) ; target
      nil                   ; limit-of-search: none
      t                     ; Return nil if fail.
      arg)                  ; repeat-count.
     (progn                 ; then-part
       (goto-char     
        (if (> arg 0)
            (1- (point))
          (1+ (point))))
       (point))
   
   (if (> arg 0)            ; else-part
       (point-max)
     (point-min))))

As you can see, the version 19 implementation does slightly less than the version 18 implementation, but is much simpler.

Go to the first, previous, next, last section, table of contents.