Go to the previous, next section.

A Simplified  beginning-of-buffer Definition

The  beginning-of-buffer command is a good function to start with since you are likely to be familiar with it and it is easy to understand. Used as an interactive command,  beginning-of-buffer moves the cursor to the beginning of the buffer, leaving the mark at the previous position. It is generally bound to M-<.

In this section, we will discuss a shortened version of the function that shows how it is most frequently used. This shortened function works as written, but it does not contain the code for a complex option. In another section, we will describe the entire function. (See section Complete Definition of  beginning-of-buffer }.)

Before looking at the code, let's consider what the function definition has to contain: it must include an expression that makes the function interactive so it can be called by typing M-x beginning-of-buffer or by typing a keychord such as C-<; it must include code to leave a mark at the original position in the buffer; and it must include code to move the cursor to the beginning of the buffer.

Here is the complete text of the shortened version of the function:

(defun simplified-beginning-of-buffer ()
  "Move point to the beginning of the buffer; 
leave mark at previous position."
  (interactive)
  (push-mark)
  (goto-char (point-min)))

Like all function definitions, this definition has five parts following the special form  defun :

  1. The name: in this case,  simplified-beginning-of-buffer .

  2. A list of the arguments: in this case, an empty list,  () ,

  3. The documentation string.

  4. The interactive expression.

  5. The body.

In this function definition, the argument list is empty; this means that this function does not require any arguments. (When we look at the definition for the complete function, we will see that it may be passed an optional argument.)

The interactive expression tells Emacs that the function is intended to be used interactively. In this case,  interactive does not have an argument because  simplified-beginning-of-buffer does not require one.

The body of the function consists of the two lines:

(push-mark)
(goto-char (point-min))

The first of these lines is the expression,  (push-mark) . When this expression is evaluated by the Lisp interpreter, it sets a mark at the current position of the cursor, wherever that may be. The position of this mark is saved in the mark ring.

The next line is  (goto-char (point-min)) . This expression jumps the cursor to the minimum point in the buffer, that is, to the beginning of the buffer (or to the beginning of the accessible portion of the buffer if it is narrowed. See section Narrowing and Widening.)

The  push-mark command sets a mark at the place where the cursor was located before it was moved to the beginning of the buffer by the  (goto-char (point-min)) expression. Consequently, you can, if you wish, go back to where you were originally by typing C-x C-x.

That is all there is to the function definition!

When you are reading code such as this and come upon an unfamiliar function, such as  goto-char , you can find out what it does by using the  describe-function command. To use this command, type C-h f and then type in the name of the function and press RET. The  describe-function command will print the function's documentation string in a `*Help*' window. For example, the documentation for  goto-char is:

One arg, a number.  Set point to that number.
Beginning of buffer is position (point-min),
end is (point-max).

(The prompt for  describe-function will offer you the symbol preceding the cursor, so you can save typing by positioning the cursor right after the function and then typing C-h f RET.)

The  end-of-buffer function definition is written in the same way as the  beginning-of-buffer definition except that the body of the function contains the expression  (goto-char (point-max)) in place of  (goto-char (point-min)) .

Go to the previous, next section.