The exact listing depends on your configured Emacs, but Figure 23.2 is an example of what you can expect.

Figure 23.2
List of prefix keys.

There are several defined prefix keys that lead to further submaps, which is indicated by the wording Prefix command . From here you can query the defined keys in a particular keymap with the key sequence <PREFIX-KEY> followed by C-h. For example, to peek at what keys are defined in ctl-x-4-map, press C-x 4 C-h. The listing shows us several commands in that submap (see Figure 23.3).

Figure 23.3
Keybindings in ctl-x-4-map.

Prefix Argument

A prefix argument carries extra information to the command behind key sequence. It is an additional parameter that makes the command work differently than without a parameter. Take a closer look at key a, with C-h a:

(self-insert-command N)

This command can accept the additional argument N (count), so how do you send it? The keys C-u (universal-argument) and Esc followed by a numeric value have been assigned to be used for a prefix argument. The C-u can be distinguished from the Esc prefix key, but that depends on the command if it wants to do that. C-u can be taken as C-u (raw prefix argument '(4) in Lisp), but can also be interpreted to map to value 4 or a multiple of it. If you press C-u C-u, it can be counted as 4x4 = 16 (raw value would be '(16) in Lisp). The self-insert-command interprets C-u as 4, so if you press C-u a; you would get a repeated four times. Not very useful? Well, let's draw some straight lines. Try C-u C-u C-u = and you get 64 equal characters on the screen. You could have done that with the Esc prefix key too by pressing Esc followed by number keys 6 and 4 plus the equals sign (=). Want to delete all lines to the end of buffer? Use C-u C-u C-u C-u C-k, which sends 4x4x4x4 (256) kill-line commands.

It is also possible to pass negative prefix arguments to commands. The plain minus sign is sent with key sequence C-u - followed by <command>. That did not request four dashes, if you thought that it would draw a small separator on the screen. Emacs reserves the minus sign for the negative prefix, because that's the only way to pass signed values. If you want to pass numeric negative values, you can add a number: C-u - 2 would pass -2 to a <command>.

You can find a use for negative arguments, for example, when you adjust indentation. First, draw a region, then call C-u C-x Tab (indent-rigidly) to push selected lines four spaces forward. To unindent the text, first select a region or recall the previous region with C-x C-x (exchange-point-and-mark), then call C-u - 4 C-x Tab. This is same command except that you used -4 instead of the positive value 4.

Major Modes and Keymaps

As you learned earlier, the global-map rules everywhere and inside it there can be more keymaps and submap definitions. There are many modes in Emacs, such as text-mode, mail-mode, message-mode, c++-mode, sh-mode, dired-mode, tar-mode, that need special keybindings to serve the mode's needs. How does a mode take over a global-map that is always present? It defines its own keymap and overrides the global-map with it. The dired-mode can now take control of all your regular keys such as a, b, and c and make it easier to use the mode.

Only one major mode can be active at the time. C++ editing mode (c++-mode), for example, is one major mode that remaps your global-map keys with its own keymap. In C++ the key mappings are mostly designed to help you position your code, to indent braces { and }, or to indent your current line when you hit the Tab key.

Each major mode keymap is named by using the mode's name and adding a suffix -keymap to it. The major mode name is the command that turns on the major mode--for example, M-x text-mode, M-x c++-, and so on. The keymap for each mode is named respectively text-mode-map and c++-mode-map.

Major Mode Hook and Mode Keymaps

You can't use the major mode keymaps right away. The only keymaps that are immediately available in Emacs are those mentioned in the "Key Sequences and Keymaps" section earlier this hour, which were part of the global-map. Remember that global-map was always present and defined.

The major mode's keymap does not exist until the major mode has been loaded and it has defined and initialized the keymap. If you have vanilla Emacs and you try to access c++-mode-map, Emacs rings a bell and tells you that "Symbol's value as variable is void: c++-mode-map."

;; See if C-c C-c binding is defined in c++-mode-map 
(lookup-key c++-mode-map "\C-c\C-c")  ;; --> Signals error 

The right moment to access a mode's keymap is when the mode gets turned on. At that point, mode initializes itself and runs a MODE-hook for user customizations. C++ mode runs c++-mode-hook, text mode runs text-mode-hook, and so on. The following is a solution to handle mode's keybinding settings in separate functions:

(add-hook 'c++-mode-hook 'my-c++-mode-hook) 
 
(defun my-c++-mode-hook () 
   (define-key c++-mode-map [(f4)] 'c-indent-function)) 

This Lisp code says that call function my-c++-mode-hook is used when C++ mode is turned on, and key f4 defines the run command c-indent-function.

Minor Modes and Keymaps

There can be only one major mode active in a buffer, but it is possible to have any number of accompanying minor modes running parallel to major mode. For example, minor modes font-lock-mode and lazy-lock-mode can run at the same time as the major mode c++-mode. These two minor modes highlight your current program so that function names, language keywords, type definitions, and so on get a distinct coloring.

Minor modes can have keymaps that override the major mode's keymap. If you have modes (A-major) and minor modes X Y Z shown in the modeline, and if they all define key C-c C-c, the leftmost minor mode sweeps the board.

Minor Mode Hook and Mode Keymap

While all major modes have a MAJOR-hook, it is not always the case with minor modes. For example font-lock-mode is a minor mode and it runs font-lock-mode-hook. lazy-lock-mode is also a minor mode, but it does not have and thus doesn't run lazy-lock-mode-hook.

You have to examine each minor mode to see if it supports a MODE-hook, where you can add minor mode keybinding customizations or other minor mode setup code. Use C-h v <MODE-NAME + Tab> to find your information on variables defined by minor mode. If you can complete a variable name with the Tab key to end with -hook suffix, the mode (whether it's major or minor) does have its own hook.

Clearing Keybinding in Keymaps

To define and modify key settings in Emacs, you have to write some Lisp code. Suppose you want to disable an Emacs keybinding that you find disturbing. Do you find yourself mistakenly hitting C-z and iconifying Emacs accidentally from time to time? Me too, so here is the Lisp command that makes the C-z binding go away:

;; C-x runs Emacs command iconify-or-deiconify-frame 
 (define-key global-map [(control z)] nil) 

Creating Custom Keymaps in Global-Map

Let's return to that C-z binding. Suppose you still have the default binding which you can restore with the following:

(global-set-key [(control z)] 'iconify-or-deiconify-frame)

You can't assign C-z-derived keys, such as if you try to add these new bindings:

;;  Signals error: 
;;  "Key sequence control a uses invalid prefix characters" 
(global-set-key [(control z) (p)] 'print-buffer) 
(global-set-key [(control z) (P)] 'print-region) 

Why not? Because the C-z key has already been taken by iconify-or-deiconify-frame. To be able to press keys after C-z, the key must be made a prefix key first. You make one by clearing the key as you did earlier:

(define-key global-map [(control z)] nil)

Now C-z has no definition, so you can use it as a prefix key and bind more keys after it:

(global-set-key [(control z) (p)] 'print-buffer) 
(global-set-key [(control z) (P)] 'print-region) 

If you look at the listing C-z C-h, you see that Emacs has made a submap that is accessed via C-z (see Figure 23.4).

Figure 23.4
Output of C-z C-h.

Know Your Environment

Before you leap into defining custom keybindings, you have to find out what kind of key sequence Emacs thinks you pressed.

Running Emacs in an X Window system is different from running Emacs in console mode. The console mode can be started with the -nw (no window) command-line switch or you might be running it already inside a vt100 tty or equivalent terminal. Be prepared that console Emacs can't use the same bindings as the X Window version. Here is a comparison minitable for Ctrl-<key> combinations in both environments. Notice that this listing might be different in the terminal where you're running the Emacs:

Look closely at the last rows: In a nonwindowed environment the Shift and Ctrl modifiers are not recognized for these keys, whereas Ctrl-a and Shift-a are. In the nonwindowed Emacs, the cursor keys are recognized as a combination of separate characters. The cursor keys appear in this case under the Esc O prefix key.

Finding the Key Sequence Syntax

The most convenient way to find out the key sequence syntax is to press the keys and recall the input with command C-h l (view-lossage). Follow these steps:

1. Press the x key three times.

2. Press a key sequence, say Ctrl-Alt-a.

3. Press the x key three times.

4. Recall the view-lossage with C-h l.

x x x M-C-a x x x C-h l

(global-set-key [(meta control a)] 'beginning-of-defun) ;; Go to function

C-M-down-mouse-1 C-M-down-mouse-2

(global-set-key [(control meta mouse-1)] 'scroll-up)    ;; Like Page down key 
(global-set-key [(control meta mouse-2)] 'scroll-down)  ;; Like Page up key 

;;  C-h l reads:  C-f1, so here is the binding 
(global-set-key [(control f1)] 'shell) 

;; C-h l reads: M-C-d; which was useless down-list command 
(global-set-key [(meta control ?d)] 'diary) 

;; C-h l output reads: A-C-d 
(global-set-key [(alt control ?d)] 'diary) 

 ;; C-h l output reads: M-f12 
(global-set-key [(meta f12)] 'compile) 

;; C-h l output reads: escape down-mouse-1 mouse-1 
(global-set-key [(?\e mouse-1)] 'compile) 

            (global-set-key [(control ?\()] 'start-kbd-macro) 
            (global-set-key [(control ?\))] 'end-kbd-macro) 
            (global-set-key [(control ?\=)] [ja1]'call-last-kbd-macro) 

(comment-region BEG END &optional ARG) 
... 
With just C-u prefix arg, uncomment each line in region. 

(add-hook 'c++-mode-hook 'my-c++-mode-hook) 
 
(defun my-c++-mode-hook () 
 (define-key c++-mode-map [(f4)] 'c-indent-function) 
 (define-key c++-mode-map [(f5)] 'comment-region) 
 (define-key c++-mode-map [(f6)] (definteractive (comment-region '(4)))) 
 )