Mercurial > emacs
diff man/basic.texi @ 25829:ac7e9e5e2ccb
#
author | Dave Love <fx@gnu.org> |
---|---|
date | Wed, 29 Sep 1999 15:17:24 +0000 |
parents | |
children | dddb1bca9704 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/man/basic.texi Wed Sep 29 15:17:24 1999 +0000 @@ -0,0 +1,721 @@ +@c This is part of the Emacs manual. +@c Copyright (C) 1985, 86, 87, 93, 94, 95, 1997 Free Software Foundation, Inc. +@c See file emacs.texi for copying conditions. +@node Basic, Minibuffer, Exiting, Top +@chapter Basic Editing Commands + +@kindex C-h t +@findex help-with-tutorial + We now give the basics of how to enter text, make corrections, and +save the text in a file. If this material is new to you, you might +learn it more easily by running the Emacs learn-by-doing tutorial. To +use the tutorial, run Emacs and type @kbd{Control-h t} +(@code{help-with-tutorial}). + + To clear the screen and redisplay, type @kbd{C-l} (@code{recenter}). + +@menu + +* Inserting Text:: Inserting text by simply typing it. +* Moving Point:: How to move the cursor to the place where you want to + change something. +* Erasing:: Deleting and killing text. +* Undo:: Undoing recent changes in the text. +* Files: Basic Files. Visiting, creating, and saving files. +* Help: Basic Help. Asking what a character does. +* Blank Lines:: Commands to make or delete blank lines. +* Continuation Lines:: Lines too wide for the screen. +* Position Info:: What page, line, row, or column is point on? +* Arguments:: Numeric arguments for repeating a command. +* Repeating:: A short-cut for repeating the previous command. +@end menu + +@node Inserting Text +@section Inserting Text + +@cindex insertion +@cindex graphic characters + To insert printing characters into the text you are editing, just type +them. This inserts the characters you type into the buffer at the +cursor (that is, at @dfn{point}; @pxref{Point}). The cursor moves +forward, and any text after the cursor moves forward too. If the text +in the buffer is @samp{FOOBAR}, with the cursor before the @samp{B}, +then if you type @kbd{XX}, you get @samp{FOOXXBAR}, with the cursor +still before the @samp{B}. + + To @dfn{delete} text you have just inserted, use @key{DEL}. @key{DEL} +deletes the character @emph{before} the cursor (not the one that the cursor +is on top of or under; that is the character @var{after} the cursor). The +cursor and all characters after it move backwards. Therefore, if you type +a printing character and then type @key{DEL}, they cancel out. + +@kindex RET +@cindex newline + To end a line and start typing a new one, type @key{RET}. This +inserts a newline character in the buffer. If point is in the middle of +a line, @key{RET} splits the line. Typing @key{DEL} when the cursor is +at the beginning of a line deletes the preceding newline, thus joining +the line with the preceding line. + + Emacs can split lines automatically when they become too long, if you +turn on a special minor mode called @dfn{Auto Fill} mode. +@xref{Filling}, for how to use Auto Fill mode. + + If you prefer to have text characters replace (overwrite) existing +text rather than shove it to the right, you can enable Overwrite mode, +a minor mode. @xref{Minor Modes}. + +@cindex quoting +@kindex C-q +@findex quoted-insert + Direct insertion works for printing characters and @key{SPC}, but other +characters act as editing commands and do not insert themselves. If you +need to insert a control character or a character whose code is above 200 +octal, you must @dfn{quote} it by typing the character @kbd{Control-q} +(@code{quoted-insert}) first. (This character's name is normally written +@kbd{C-q} for short.) There are two ways to use @kbd{C-q}:@refill + +@itemize @bullet +@item +@kbd{C-q} followed by any non-graphic character (even @kbd{C-g}) +inserts that character. + +@item +@kbd{C-q} followed by a sequence of octal digits inserts the character +with the specified octal character code. You can use any number of +octal digits; any non-digit terminates the sequence. If the terminating +character is @key{RET}, it serves only to terminate the sequence; any +other non-digit is itself used as input after terminating the sequence. +(The use of octal sequences is disabled in ordinary non-binary Overwrite +mode, to give you a convenient way to insert a digit instead of +overwriting with it.) +@end itemize + +@noindent +When multibyte characters are enabled, octal codes 0200 through 0377 are +not valid as characters; if you specify a code in this range, @kbd{C-q} +assumes that you intend to use some ISO Latin-@var{n} character set, and +converts the specified code to the corresponding Emacs character code. +@xref{Enabling Multibyte}. You select @emph{which} ISO Latin character +set though your choice of language environment (@pxref{Language +Environments}). + +@vindex read-quoted-char-radix +To use decimal or hexadecimal instead of octal, set the variable +@code{read-quoted-char-radix} to 10 or 16. If the radix is greater than +10, some letters starting with @kbd{a} serve as part of a character +code, just like digits. + +A numeric argument to @kbd{C-q} specifies how many copies of the +quoted character should be inserted (@pxref{Arguments}). + +@findex newline +@findex self-insert + Customization information: @key{DEL} in most modes runs the command +@code{delete-backward-char}; @key{RET} runs the command @code{newline}, and +self-inserting printing characters run the command @code{self-insert}, +which inserts whatever character was typed to invoke it. Some major modes +rebind @key{DEL} to other commands. + +@node Moving Point +@section Changing the Location of Point + +@cindex arrow keys +@kindex LEFT +@kindex RIGHT +@kindex UP +@kindex DOWN +@cindex moving point +@cindex movement +@cindex cursor motion +@cindex moving the cursor + To do more than insert characters, you have to know how to move point +(@pxref{Point}). The simplest way to do this is with arrow keys, or by +clicking the left mouse button where you want to move to. + + There are also control and meta characters for cursor motion. Some +are equivalent to the arrow keys (these date back to the days before +terminals had arrow keys, and are usable on terminals which don't have +them). Others do more sophisticated things. + +@kindex C-a +@kindex C-e +@kindex C-f +@kindex C-b +@kindex C-n +@kindex C-p +@kindex M-> +@kindex M-< +@kindex M-r +@findex beginning-of-line +@findex end-of-line +@findex forward-char +@findex backward-char +@findex next-line +@findex previous-line +@findex beginning-of-buffer +@findex end-of-buffer +@findex goto-char +@findex goto-line +@findex move-to-window-line +@table @kbd +@item C-a +Move to the beginning of the line (@code{beginning-of-line}). +@item C-e +Move to the end of the line (@code{end-of-line}). +@item C-f +Move forward one character (@code{forward-char}). +@item C-b +Move backward one character (@code{backward-char}). +@item M-f +Move forward one word (@code{forward-word}). +@item M-b +Move backward one word (@code{backward-word}). +@item C-n +Move down one line, vertically (@code{next-line}). This command +attempts to keep the horizontal position unchanged, so if you start in +the middle of one line, you end in the middle of the next. When on +the last line of text, @kbd{C-n} creates a new line and moves onto it. +@item C-p +Move up one line, vertically (@code{previous-line}). +@item M-r +Move point to left margin, vertically centered in the window +(@code{move-to-window-line}). Text does not move on the screen. + +A numeric argument says which screen line to place point on. It counts +screen lines down from the top of the window (zero for the top line). A +negative argument counts lines from the bottom (@minus{}1 for the bottom +line). +@item M-< +Move to the top of the buffer (@code{beginning-of-buffer}). With +numeric argument @var{n}, move to @var{n}/10 of the way from the top. +@xref{Arguments}, for more information on numeric arguments.@refill +@item M-> +Move to the end of the buffer (@code{end-of-buffer}). +@item M-x goto-char +Read a number @var{n} and move point to buffer position @var{n}. +Position 1 is the beginning of the buffer. +@item M-x goto-line +Read a number @var{n} and move point to line number @var{n}. Line 1 +is the beginning of the buffer. +@item C-x C-n +@findex set-goal-column +@kindex C-x C-n +Use the current column of point as the @dfn{semipermanent goal column} for +@kbd{C-n} and @kbd{C-p} (@code{set-goal-column}). Henceforth, those +commands always move to this column in each line moved into, or as +close as possible given the contents of the line. This goal column remains +in effect until canceled. +@item C-u C-x C-n +Cancel the goal column. Henceforth, @kbd{C-n} and @kbd{C-p} once +again try to stick to a fixed horizontal position, as usual. +@end table + +@vindex track-eol + If you set the variable @code{track-eol} to a non-@code{nil} value, +then @kbd{C-n} and @kbd{C-p} when at the end of the starting line move +to the end of another line. Normally, @code{track-eol} is @code{nil}. +@xref{Variables}, for how to set variables such as @code{track-eol}. + +@vindex next-line-add-newlines + Normally, @kbd{C-n} on the last line of a buffer appends a newline to +it. If the variable @code{next-line-add-newlines} is @code{nil}, then +@kbd{C-n} gets an error instead (like @kbd{C-p} on the first line). + +@node Erasing +@section Erasing Text + +@table @kbd +@item @key{DEL} +Delete the character before point (@code{delete-backward-char}). +@item C-d +Delete the character after point (@code{delete-char}). +@item C-k +Kill to the end of the line (@code{kill-line}). +@item M-d +Kill forward to the end of the next word (@code{kill-word}). +@item M-@key{DEL} +Kill back to the beginning of the previous word +(@code{backward-kill-word}). +@end table + +@cindex killing characters and lines +@cindex deleting characters and lines +@cindex erasing characters and lines + You already know about the @key{DEL} key which deletes the character +before point (that is, before the cursor). Another key, @kbd{Control-d} +(@kbd{C-d} for short), deletes the character after point (that is, the +character that the cursor is on). This shifts the rest of the text on +the line to the left. If you type @kbd{C-d} at the end of a line, it +joins together that line and the next line. + + To erase a larger amount of text, use the @kbd{C-k} key, which kills a +line at a time. If you type @kbd{C-k} at the beginning or middle of a +line, it kills all the text up to the end of the line. If you type +@kbd{C-k} at the end of a line, it joins that line and the next line. + + @xref{Killing}, for more flexible ways of killing text. + +@node Undo +@section Undoing Changes +@cindex undo +@cindex changes, undoing + + You can undo all the recent changes in the buffer text, up to a +certain point. Each buffer records changes individually, and the undo +command always applies to the current buffer. Usually each editing +command makes a separate entry in the undo records, but some commands +such as @code{query-replace} make many entries, and very simple commands +such as self-inserting characters are often grouped to make undoing less +tedious. + +@table @kbd +@item C-x u +Undo one batch of changes---usually, one command worth (@code{undo}). +@item C-_ +The same. +@item C-u C-x u +Undo one batch of changes in the region. +@end table + +@kindex C-x u +@kindex C-_ +@findex undo + The command @kbd{C-x u} or @kbd{C-_} is how you undo. The first time +you give this command, it undoes the last change. Point moves back to +where it was before the command that made the change. + + Consecutive repetitions of @kbd{C-_} or @kbd{C-x u} undo earlier and +earlier changes, back to the limit of the undo information available. +If all recorded changes have already been undone, the undo command +prints an error message and does nothing. + + Any command other than an undo command breaks the sequence of undo +commands. Starting from that moment, the previous undo commands become +ordinary changes that you can undo. Thus, to redo changes you have +undone, type @kbd{C-f} or any other command that will harmlessly break +the sequence of undoing, then type more undo commands. + +@cindex selective undo +@kindex C-u C-x u + Ordinary undo applies to all changes made in the current buffer. You +can also perform @dfn{selective undo}, limited to the current region. +To do this, specify the region you want, then run the @code{undo} +command with a prefix argument (the value does not matter): @kbd{C-u C-x +u} or @kbd{C-u C-_}. This undoes the most recent change in the region. +To undo further changes in the same region, repeat the @code{undo} +command (no prefix argument is needed). In Transient Mark mode, any use +of @code{undo} when there is an active region performs selective undo; +you do not need a prefix argument. + + If you notice that a buffer has been modified accidentally, the +easiest way to recover is to type @kbd{C-_} repeatedly until the stars +disappear from the front of the mode line. At this time, all the +modifications you made have been canceled. Whenever an undo command +makes the stars disappear from the mode line, it means that the buffer +contents are the same as they were when the file was last read in or +saved. + + If you do not remember whether you changed the buffer deliberately, +type @kbd{C-_} once. When you see the last change you made undone, you +will see whether it was an intentional change. If it was an accident, +leave it undone. If it was deliberate, redo the change as described +above. + + Not all buffers record undo information. Buffers whose names start with +spaces don't; these buffers are used internally by Emacs and its extensions +to hold text that users don't normally look at or edit. + + You cannot undo mere cursor motion; only changes in the buffer +contents save undo information. However, some cursor motion commands +set the mark, so if you use these commands from time to time, you can +move back to the neighborhoods you have moved through by popping the +mark ring (@pxref{Mark Ring}). + +@vindex undo-limit +@vindex undo-strong-limit +@cindex undo limit + When the undo information for a buffer becomes too large, Emacs +discards the oldest undo information from time to time (during garbage +collection). You can specify how much undo information to keep by +setting two variables: @code{undo-limit} and @code{undo-strong-limit}. +Their values are expressed in units of bytes of space. + + The variable @code{undo-limit} sets a soft limit: Emacs keeps undo +data for enough commands to reach this size, and perhaps exceed it, but +does not keep data for any earlier commands beyond that. Its default +value is 20000. The variable @code{undo-strong-limit} sets a stricter +limit: the command which pushes the size past this amount is itself +forgotten. Its default value is 30000. + + Regardless of the values of those variables, the most recent change is +never discarded, so there is no danger that garbage collection occurring +right after an unintentional large change might prevent you from undoing +it. + + The reason the @code{undo} command has two keys, @kbd{C-x u} and +@kbd{C-_}, set up to run it is that it is worthy of a single-character +key, but on some keyboards it is not obvious how to type @kbd{C-_}. +@kbd{C-x u} is an alternative you can type straightforwardly on any +terminal. + +@node Basic Files +@section Files + + The commands described above are sufficient for creating and altering +text in an Emacs buffer; the more advanced Emacs commands just make +things easier. But to keep any text permanently you must put it in a +@dfn{file}. Files are named units of text which are stored by the +operating system for you to retrieve later by name. To look at or use +the contents of a file in any way, including editing the file with +Emacs, you must specify the file name. + + Consider a file named @file{/usr/rms/foo.c}. In Emacs, to begin editing +this file, type + +@example +C-x C-f /usr/rms/foo.c @key{RET} +@end example + +@noindent +Here the file name is given as an @dfn{argument} to the command @kbd{C-x +C-f} (@code{find-file}). That command uses the @dfn{minibuffer} to +read the argument, and you type @key{RET} to terminate the argument +(@pxref{Minibuffer}).@refill + + Emacs obeys the command by @dfn{visiting} the file: creating a buffer, +copying the contents of the file into the buffer, and then displaying +the buffer for you to edit. If you alter the text, you can @dfn{save} +the new text in the file by typing @kbd{C-x C-s} (@code{save-buffer}). +This makes the changes permanent by copying the altered buffer contents +back into the file @file{/usr/rms/foo.c}. Until you save, the changes +exist only inside Emacs, and the file @file{foo.c} is unaltered. + + To create a file, just visit the file with @kbd{C-x C-f} as if it +already existed. This creates an empty buffer in which you can insert +the text you want to put in the file. The file is actually created when +you save this buffer with @kbd{C-x C-s}. + + Of course, there is a lot more to learn about using files. @xref{Files}. + +@node Basic Help +@section Help + +@cindex getting help with keys + If you forget what a key does, you can find out with the Help +character, which is @kbd{C-h} (or @key{F1}, which is an alias for +@kbd{C-h}). Type @kbd{C-h k} followed by the key you want to know +about; for example, @kbd{C-h k C-n} tells you all about what @kbd{C-n} +does. @kbd{C-h} is a prefix key; @kbd{C-h k} is just one of its +subcommands (the command @code{describe-key}). The other subcommands of +@kbd{C-h} provide different kinds of help. Type @kbd{C-h} twice to get +a description of all the help facilities. @xref{Help}.@refill + +@node Blank Lines +@section Blank Lines + +@cindex inserting blank lines +@cindex deleting blank lines + Here are special commands and techniques for putting in and taking out +blank lines. + +@c widecommands +@table @kbd +@item C-o +Insert one or more blank lines after the cursor (@code{open-line}). +@item C-x C-o +Delete all but one of many consecutive blank lines +(@code{delete-blank-lines}). +@end table + +@kindex C-o +@kindex C-x C-o +@cindex blank lines +@findex open-line +@findex delete-blank-lines + When you want to insert a new line of text before an existing line, you +can do it by typing the new line of text, followed by @key{RET}. +However, it may be easier to see what you are doing if you first make a +blank line and then insert the desired text into it. This is easy to do +using the key @kbd{C-o} (@code{open-line}), which inserts a newline +after point but leaves point in front of the newline. After @kbd{C-o}, +type the text for the new line. @kbd{C-o F O O} has the same effect as +@w{@kbd{F O O @key{RET}}}, except for the final location of point. + + You can make several blank lines by typing @kbd{C-o} several times, or +by giving it a numeric argument to tell it how many blank lines to make. +@xref{Arguments}, for how. If you have a fill prefix, then @kbd{C-o} +command inserts the fill prefix on the new line, when you use it at the +beginning of a line. @xref{Fill Prefix}. + + The easy way to get rid of extra blank lines is with the command +@kbd{C-x C-o} (@code{delete-blank-lines}). @kbd{C-x C-o} in a run of +several blank lines deletes all but one of them. @kbd{C-x C-o} on a +solitary blank line deletes that blank line. When point is on a +nonblank line, @kbd{C-x C-o} deletes any blank lines following that +nonblank line. + +@node Continuation Lines +@section Continuation Lines + +@cindex continuation line +@cindex wrapping +@cindex line wrapping + If you add too many characters to one line without breaking it with +@key{RET}, the line will grow to occupy two (or more) lines on the screen, +with a @samp{\} at the extreme right margin of all but the last of them. +The @samp{\} says that the following screen line is not really a distinct +line in the text, but just the @dfn{continuation} of a line too long to fit +the screen. Continuation is also called @dfn{line wrapping}. + + Sometimes it is nice to have Emacs insert newlines automatically when +a line gets too long. Continuation on the screen does not do that. Use +Auto Fill mode (@pxref{Filling}) if that's what you want. + +@vindex truncate-lines +@cindex truncation + As an alternative to continuation, Emacs can display long lines by +@dfn{truncation}. This means that all the characters that do not fit in +the width of the screen or window do not appear at all. They remain in +the buffer, temporarily invisible. @samp{$} is used in the last column +instead of @samp{\} to inform you that truncation is in effect. + + Truncation instead of continuation happens whenever horizontal +scrolling is in use, and optionally in all side-by-side windows +(@pxref{Windows}). You can enable truncation for a particular buffer by +setting the variable @code{truncate-lines} to non-@code{nil} in that +buffer. (@xref{Variables}.) Altering the value of +@code{truncate-lines} makes it local to the current buffer; until that +time, the default value is in effect. The default is initially +@code{nil}. @xref{Locals}. + + @xref{Display Vars}, for additional variables that affect how text is +displayed. + +@node Position Info +@section Cursor Position Information + + Here are commands to get information about the size and position of +parts of the buffer, and to count lines. + +@table @kbd +@item M-x what-page +Print page number of point, and line number within page. +@item M-x what-line +Print line number of point in the buffer. +@item M-x line-number-mode +Toggle automatic display of current line number. +@item M-= +Print number of lines in the current region (@code{count-lines-region}). +@xref{Mark}, for information about the region. +@item C-x = +Print character code of character after point, character position of +point, and column of point (@code{what-cursor-position}). +@end table + +@findex what-page +@findex what-line +@cindex line number commands +@cindex location of point +@cindex cursor location +@cindex point location + There are two commands for working with line numbers. @kbd{M-x +what-line} computes the current line number and displays it in the echo +area. To go to a given line by number, use @kbd{M-x goto-line}; it +prompts you for the number. These line numbers count from one at the +beginning of the buffer. + + You can also see the current line number in the mode line; @xref{Mode +Line}. If you narrow the buffer, then the line number in the mode line +is relative to the accessible portion (@pxref{Narrowing}). By contrast, +@code{what-line} shows both the line number relative to the narrowed +region and the line number relative to the whole buffer. + + By contrast, @kbd{M-x what-page} counts pages from the beginning of +the file, and counts lines within the page, printing both numbers. +@xref{Pages}. + +@kindex M-= +@findex count-lines-region + While on this subject, we might as well mention @kbd{M-=} (@code{count-lines-region}), +which prints the number of lines in the region (@pxref{Mark}). +@xref{Pages}, for the command @kbd{C-x l} which counts the lines in the +current page. + +@kindex C-x = +@findex what-cursor-position + The command @kbd{C-x =} (@code{what-cursor-position}) can be used to find out +the column that the cursor is in, and other miscellaneous information about +point. It prints a line in the echo area that looks like this: + +@smallexample +Char: c (0143, 99, 0x63) point=21044 of 26883(78%) column 53 +@end smallexample + +@noindent +(In fact, this is the output produced when point is before the +@samp{column} in the example.) + + The four values after @samp{Char:} describe the character that follows +point, first by showing it and then by giving its character code in +octal, decimal and hex. For a non-ASCII multibyte character, these are +followed by @samp{ext} and the character's representation, in hex, in +the buffer's coding system, if that coding system encodes the character +safely and with a single byte (@pxref{Coding Systems}). If the +character's encoding is longer than one byte, Emacs shows @samp{ext ...}. + + @samp{point=} is followed by the position of point expressed as a character +count. The front of the buffer counts as position 1, one character later +as 2, and so on. The next, larger, number is the total number of characters +in the buffer. Afterward in parentheses comes the position expressed as a +percentage of the total size. + + @samp{column} is followed by the horizontal position of point, in +columns from the left edge of the window. + + If the buffer has been narrowed, making some of the text at the +beginning and the end temporarily inaccessible, @kbd{C-x =} prints +additional text describing the currently accessible range. For example, it +might display this: + +@smallexample +Char: C (0103, 67, 0x43) point=252 of 889(28%) <231 - 599> column 0 +@end smallexample + +@noindent +where the two extra numbers give the smallest and largest character +position that point is allowed to assume. The characters between those +two positions are the accessible ones. @xref{Narrowing}. + + If point is at the end of the buffer (or the end of the accessible +part), the @w{@kbd{C-x =}} output does not describe a character after +point. The output might look like this: + +@smallexample +point=26957 of 26956(100%) column 0 +@end smallexample + + @w{@kbd{C-u C-x =}} displays additional information about a character, +in place of the buffer coordinates and column: the character set name +and the codes that identify the character within that character set; +ASCII characters are identified as belonging to the @code{ASCII} +character set. In addition, the full character encoding, even if it +takes more than a single byte, is shown after @samp{ext}. Here's an +example for a Latin-1 character A with a grave accent in a buffer whose +coding system is iso-2022-7bit@footnote{On terminals that support +Latin-1 characters, the character shown after @samp{Char:} is displayed +as the actual glyph of A with grave accent.}: + +@example +Char: @`A (04300, 2240, 0x8c0, ext ESC , A @@) (latin-iso8859-1 64) +@end example + +@node Arguments +@section Numeric Arguments +@cindex numeric arguments +@cindex prefix arguments +@cindex arguments, numeric +@cindex arguments, prefix + + In mathematics and computer usage, the word @dfn{argument} means +``data provided to a function or operation.'' You can give any Emacs +command a @dfn{numeric argument} (also called a @dfn{prefix argument}). +Some commands interpret the argument as a repetition count. For +example, @kbd{C-f} with an argument of ten moves forward ten characters +instead of one. With these commands, no argument is equivalent to an +argument of one. Negative arguments tell most such commands to move or +act in the opposite direction. + +@kindex M-1 +@kindex M-@t{-} +@findex digit-argument +@findex negative-argument + If your terminal keyboard has a @key{META} key, the easiest way to +specify a numeric argument is to type digits and/or a minus sign while +holding down the @key{META} key. For example, +@example +M-5 C-n +@end example +@noindent +would move down five lines. The characters @kbd{Meta-1}, @kbd{Meta-2}, +and so on, as well as @kbd{Meta--}, do this because they are keys bound +to commands (@code{digit-argument} and @code{negative-argument}) that +are defined to contribute to an argument for the next command. Digits +and @kbd{-} modified with Control, or Control and Meta, also specify +numeric arguments. + +@kindex C-u +@findex universal-argument + Another way of specifying an argument is to use the @kbd{C-u} +(@code{universal-argument}) command followed by the digits of the +argument. With @kbd{C-u}, you can type the argument digits without +holding down modifier keys; @kbd{C-u} works on all terminals. To type a +negative argument, type a minus sign after @kbd{C-u}. Just a minus sign +without digits normally means @minus{}1. + + @kbd{C-u} followed by a character which is neither a digit nor a minus +sign has the special meaning of ``multiply by four.'' It multiplies the +argument for the next command by four. @kbd{C-u} twice multiplies it by +sixteen. Thus, @kbd{C-u C-u C-f} moves forward sixteen characters. This +is a good way to move forward ``fast,'' since it moves about 1/5 of a line +in the usual size screen. Other useful combinations are @kbd{C-u C-n}, +@kbd{C-u C-u C-n} (move down a good fraction of a screen), @kbd{C-u C-u +C-o} (make ``a lot'' of blank lines), and @kbd{C-u C-k} (kill four +lines).@refill + + Some commands care only about whether there is an argument, and not about +its value. For example, the command @kbd{M-q} (@code{fill-paragraph}) with +no argument fills text; with an argument, it justifies the text as well. +(@xref{Filling}, for more information on @kbd{M-q}.) Plain @kbd{C-u} is a +handy way of providing an argument for such commands. + + Some commands use the value of the argument as a repeat count, but do +something peculiar when there is no argument. For example, the command +@kbd{C-k} (@code{kill-line}) with argument @var{n} kills @var{n} lines, +including their terminating newlines. But @kbd{C-k} with no argument is +special: it kills the text up to the next newline, or, if point is right at +the end of the line, it kills the newline itself. Thus, two @kbd{C-k} +commands with no arguments can kill a nonblank line, just like @kbd{C-k} +with an argument of one. (@xref{Killing}, for more information on +@kbd{C-k}.)@refill + + A few commands treat a plain @kbd{C-u} differently from an ordinary +argument. A few others may treat an argument of just a minus sign +differently from an argument of @minus{}1. These unusual cases are +described when they come up; they are always for reasons of convenience +of use of the individual command. + + You can use a numeric argument to insert multiple copies of a +character. This is straightforward unless the character is a digit; for +example, @kbd{C-u 6 4 a} inserts 64 copies of the character @samp{a}. +But this does not work for inserting digits; @kbd{C-u 6 4 1} specifies +an argument of 641, rather than inserting anything. To separate the +digit to insert from the argument, type another @kbd{C-u}; for example, +@kbd{C-u 6 4 C-u 1} does insert 64 copies of the character @samp{1}. + + We use the term ``prefix argument'' as well as ``numeric argument'' to +emphasize that you type the argument before the command, and to +distinguish these arguments from minibuffer arguments that come after +the command. + +@node Repeating +@section Repeating a Command +@cindex repeating a command + +@kindex C-x z +@findex repeat + The command @kbd{C-x z} (@code{repeat}) provides another way to repeat +an Emacs command many times. This command repeats the previous Emacs +command, whatever that was. Repeating a command uses the same arguments +that were used before; it does not read new arguments each time. + + To repeat the command more than once, type additional @kbd{z}'s: each +@kbd{z} repeats the command one more time. Repetition ends when you +type a character other than @kbd{z}, or press a mouse button. + + For example, suppose you type @kbd{C-u 2 0 C-d} to delete 20 +characters. You can repeat that command (including its argument) three +additional times, to delete a total of 80 characters, by typing @kbd{C-x +z z z}. The first @kbd{C-x z} repeats the command once, and each +subsequent @kbd{z} repeats it once again. +