GNUemacs: beyond the tutorial

Offer to save each buffer, then quit Emacs.

Scroll text of current window upward.

Scroll text of current window down.

Center point in window and redisplay frame.

Move point left N characters (right if N is negative).

Move point right N characters (left if N is negative).

Move point vertically up.

Move point vertically down.

Begin a numeric argument for the following command.

Move backward until encountering the beginning of a word.

Move point forward a word.

Move point to beginning of current line as displayed.

Move point to end of current line as displayed.

Move backward to start of sentence.

Move forward to next end of sentence.

Move point to the beginning of the buffer; leave mark at previous position.

Move point to the end of the buffer; leave mark at previous position.

Begin a numeric argument for the following command.

Signal a `quit' condition.

Make the selected window fill its frame.

Delete the previous character.

Delete the following characters.

Kill characters forward until encountering the end of a word.

Kill characters backward until encountering the beginning of a word.

Kill the rest of the current line; if no nonblanks there, kill thru newline.

Kill from point to end of sentence.

Set the mark where point is, or jump to the mark.

Kill ("cut") text between point and mark.

Reinsert ("paste") the last stretch of killed text.

Replace just-yanked stretch of killed text with a different stretch.

Undo some previous changes.

Edit a specified file.

Save current buffer in visited file if modified.

Save some modified file-visiting buffers. Asks user about each one, unless a prefix was given.

Pop up a buffer describing the set of Emacs buffers, and allow selection of them.

Switches to a specified buffer in the current window.

Iconify the selected frame, or deiconify if it's currently an icon.

Read function name, then read its arguments and call it.

Do incremental search forward.

Do incremental search backward.

Split current window into two windows, one above the other.

Scroll next window upward.

Select the next window on this frame.

Edit a specified file, in another window.

Print the name of the function a specified key invokes.

Display documentation of the function invoked by a specified key.

Show commands (interactively callable functions) that match a given regexp.

Enter Info, the documentation browser.

Print the name of the function a specified key invokes.

Display documentation of the function invoked by a specified key.

Show commands (interactively callable functions) that match a given regexp.

Display the full documentation of a specified function (a symbol).

Show commands (interactively callable functions) that match a given regexp.

Show symbols whose documentation contains matches for a given regexp.

Enter Info, the documentation browser.

Enter Info, the documentation browser, at the Emacs manual.

Display documentation of current major mode and minor modes.

Show a list of all defined keys, and their definitions.

Describe the syntax specifications in the syntax table of a specified buffer.

Get a Un*x manual page and put it in a buffer.

Kill ("cut") text between point and mark.

Save the region as if killed, but don't kill it.

Cause following command, if it kills, to append to previous kill.

Reinsert ("paste") the last stretch of killed text.

Replace just-yanked stretch of killed text with a different stretch.

Move forward over a balanced bracketed expression; a symbol also counts as an expression.

Move backward over a balanced bracketed expression.

Move forward and in one level of parentheses.

Move back and out one level of parentheses.

Set the region to the balanced bracketed expression starting at point.

Kill the balanced bracketed expression starting at point.

Re-indent the balanced bracketed expression starting at point.

Insert a pair of parentheses, leaving point between them. With a numeric prefix argument (which can be negative), surround that many expressions with the parentheses.

Replace the expression surrounding this one with this one.

Move to the start of the current statement.

Move to the end of the current statement.

Adjust the indentation of the current line.

Start a new line, at the appropriate indentation.

Start a comment, or move to an existing one, or adjust its position, or comment out a region.

Comment or uncomment each line in the region.

Uncomment each line in the region.

Move to the start of the current function.

Move to the start of the current function.

Set the region to the function definition around point.

In some programming languages, send the function definition around point to an attached session of the programming language system.

Move forward to end of paragraph.

Move backward to start of paragraph.

Set the region to the current paragraph.

Kill forward to end of paragraph.

Convert following word to upper case, moving over it.

Convert following word to lower case, moving over it.

Capitalize the following word, moving over it.

Convert the region to upper case.

Convert the region to lower case.

Convert the region to capitalized form.

Fill paragraph at or after point.

Fill paragraphs of uniform indentation within the region.

Set the column at which to word-wrap when filling text.

Use the text from the beginning of the line to point, as a margin to skip in each line when filling a paragraph.

Interchange characters around point, moving forward one character.

Interchange words around point, leaving point at end of them.

Exchange current line and previous line, leaving point after both.

Like M-t but applies to sexps.

Move to left margin.

Constrains movement up and down, to stay in the same column; with prefix, releases the constraint.

Leaves just one space at point.

Leaves no spaces at point.

Leaves one or none lines at point.

Delete the region-rectangle and save it as the last killed one.

Yank the last killed rectangle with upper left corner at point.

Blank out the region-rectangle, shifting text right.

Blank out the region-rectangle.

Replace rectangle contents with a specified string on each line.

Copy region into a register.

Insert contents of a register.

Copy rectangular region into register.

Insert contents of register a specified register. (a specified register is a character.)

Display a list of nonempty registers saying briefly what they contain.

Read function name, then read its arguments and call it.

Print message listing key sequences that invoke the given command.

Display documentation of the function invoked by the following keystrokes.

Print the name of the function invoked by the following keystrokes.

List the commands whose names match a given regexp.

Read an Emacs-Lisp expression in the minibuffer, and run it.

Bring up the most recent complex command, in the minibuffer.

Move to the previous history element.

Move to the next history element.

Run the currently selected recalled command.

Bring up the most recent complex command that matches a given regexp, in the minibuffer.

Bring up a browsable buffer containing recent commands.

Display a list of possible completions of the current minibuffer contents.

Complete the minibuffer contents as far as possible.

Complete the minibuffer contents at most a single word.

If the minibuffer contents is a valid completion then exit.

Expand previous word "dynamically". This searches back through the buffer for words that start the same way as the one you have started to type, and fills in the rest of the word.

Do incremental search forward.

Do incremental search backward.

Do incremental search forward for a specified regexp.

Do incremental search backward for a specied regexp.

At the start of a search, resume the previous search, going forwards; when already searching, search for the next occurence of the search string.

At the start of a search, resume the previous search, going backwards; when already searching, search for the previous occurence of the search string.

Include the rest of the current word, as part of the search string.

Include the rest of the current line, as part of the search string.

Add the top item from the kill-ring to the search string.

Move backwards and forwards through the history of search strings.

Switch to query-replace, with the current search string as the query string.

Toggle regexp searching.

Restrict editing in this buffer to the current region.

Make text outside current defun invisible.

Make text outside current page invisible.

Remove restrictions (narrowing) from current buffer.

Replace all occurrences of a given string, from point onwards, by a given replacement.

Query-replace all occurrences of a given string, from point onwards, by a given string.

Replace all occurrences of a given regexp, from point onwards, by a given replacement.

Query-replace all occurrences of a given regexp, from point onwards, by a given replacement.

Match any character.

Match any of characters a, b, or c.

Match any characters except a, b, or c.

Match a zero or more times, taking as many matches as possible.

Match a one or more times, taking as many matches as possible.

Match a zero or one times, taking as many matches as possible.

Match a zero or more times, taking as few matches as possible (that is, if a piece of text could match this or match the next thing in the regexp, it will be taken to match the next thing).

Match a one or more times, taking as few matches as possible.

Match a zero or one times, taking as few matches as possible.

Match the start of the line.

Match the end of the line.

Match either a or b. a and b extend as far as possible in the regexp (see \( .. \)).

A grouping construct, which limits the \| construct, can be used with *, +, ? etc, and which remembers the text matched in a numbered register.

Like \( .. \) but does not use up a numbered register.

Represents the piece of text matched by the nth \( .. \) construct. Mostly used in the replacement text, but may also be used in the search expression to indicate matching a copy of something that has already been matched.

Represents the entire matched text. Used only in the replacement text.

Matches the start of a word.

Matches the end of a word.

Matches any word-constituent character.

Matches any non-word-constituent character.

Matches any character of syntax class a. Common syntax classes are:

Which characters have which syntax class depends on the mode of the current buffer. Use C-h s to see the current syntax values.

Match any character not of syntax class a.

Match a between m and n times.

Match a, n times.

Insert the whole matched text

Insert the text matched by the nth \(...\) construct in the pattern

Insert the number of replacements done so far -- useful for numbering lists

Insert the result of evaluating lisp-expression; \1 etc are allowed, e.g. \,(capitalize \1)

Replace this occurrence, then move to the next one.

Skip to the next occurrence.

Exit query-replace

Replace this occurrence, then exit query-replace

Replace this occurrence, but don't move to the next one

Replace all remaining occurrences.

Enter a recursive edit

Delete this occurrence, then enter a recursive edit

Go back to the previous occurrence.

Redisplay the screen.

Edit the replacement string.

Display the options.

Record subsequent keyboard input, defining a keyboard macro.

Finish defining a keyboard macro.

Call last keyboard macro, ending it first if currently being defined.

Append to specified buffer the text of the region.

Insert contents of file a specified filename into buffer after point.

Write current region into specified file.

Write current buffer into specified file.

"Edit" directory a specified dirname--delete, rename, print, etc. some files in it.

In Dired, visit the file or directory named on this line.

In Dired, visit this file or directory in another window.

Mark the current (or next specified number) files.

Unmark the current (or next specified number) files.

In Dired, flag the current line's file for deletion.

Flag all backup files (names ending with `~') for deletion.

In Dired, delete the files flagged for deletion.

Rename current file or all marked (or next specified number) files.

Copy all marked (or next specified number) files, or copy the current file.

Replace current buffer text with the text of the visited file on disk.

Execute a command in inferior shell; display output, if any. With prefix argument, insert the command's output at point.

Execute a command in inferior shell with region as input; with prefix arg, replace the region with the command output.

Run an inferior shell, with I/O through a specified buffer (which defaults to `*shell*').

Send input to process.

Delete all output from interpreter since last input.

Display start of this batch of interpreter output at top of window.

Compile the program including the current buffer. Default: run `make'.

Move to next error message and corresponding source code.

Compare and merge two (or three) files interactively.

Do the next logical version control operation on the current file (check in, check out, etc).

Run a debugger on a given program. Supports similar features to graphical IDEs (windows displaying variables, etc).

Select which tags file to use. (Use the external command etags to create tags files.)

Find tag (in current tags table) whose name contains a specified tagname.

Continue last M-x tags-search or M-x tags-query-replace command.

Like query-replace but throughout all files mentioned in the current tags table

Jump to a place in the buffer chosen using a buffer menu or mouse menu.

Select and activate input method a specified input-METHOD for the current buffer.

Enable or disable multilingual text input method for the current buffer.

Follow this with a character sequence that, if overtyped, would like a bit like the character you want; for example, to get an a with an umlaut, type C-x 8 " a.

Exchange the mark and the point. Useful for checking whereqthe mark is, and other things.

Delete up to, and including, the next occurrence of a given character.

Describes the cursor position, and the character at that position.

Display the number of characters, words, and lines, in the region

Delete all lines starting after point containing a given regexp.

Delete all lines starting after point except those containing a given regexp.

Indent all lines starting in the region sideways by specified number columns.

Put point at beginning and mark at end of buffer.

Delete all the trailing whitespace across the current buffer.

Convert multiple spaces in region to tabs when possible.

Convert all tabs in region to multiple spaces, preserving columns.

Change whether this buffer is visiting its file read-only.

Use a larger default font in this buffer.

Use a smaller default font in this buffer.

Switch auto-fill-mode on or off.

Display a browsable calendar.

Show a browsable coloured diff between two buffers, allowing changes to be copied from one to the other.

Display the quarters of the moon for last month, this month, and next month.

Offer to save each buffer, then quit Emacs. You don't normally need to do this.