diff man/basic.texi @ 25829:ac7e9e5e2ccb

#

--- /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.
+