Undoing the changes erroneously committed just before.
[emacs.git] / man / basic.texi
blobd92937ad1775946dca9971d8f41ab79260168818
1 @c This is part of the Emacs manual.
2 @c Copyright (C) 1985, 86, 87, 93, 94, 95, 97, 2000 Free Software Foundation, Inc.
3 @c See file emacs.texi for copying conditions.
4 @node Basic, Minibuffer, Exiting, Top
5 @chapter Basic Editing Commands
7 @kindex C-h t
8 @findex help-with-tutorial
9   We now give the basics of how to enter text, make corrections, and
10 save the text in a file.  If this material is new to you, you might
11 learn it more easily by running the Emacs learn-by-doing tutorial.  To
12 use the tutorial, run Emacs and type @kbd{Control-h t}
13 (@code{help-with-tutorial}).
15   To clear the screen and redisplay, type @kbd{C-l} (@code{recenter}).
17 @menu
19 * Inserting Text::      Inserting text by simply typing it.
20 * Moving Point::        How to move the cursor to the place where you want to
21                           change something.
22 * Erasing::             Deleting and killing text.
23 * Undo::                Undoing recent changes in the text.
24 * Files: Basic Files.   Visiting, creating, and saving files.
25 * Help: Basic Help.     Asking what a character does.
26 * Blank Lines::         Commands to make or delete blank lines.
27 * Continuation Lines::  Lines too wide for the screen.
28 * Position Info::       What page, line, row, or column is point on?
29 * Arguments::           Numeric arguments for repeating a command.
30 * Repeating::           A short-cut for repeating the previous command.
31 @end menu
33 @node Inserting Text
34 @section Inserting Text
36 @cindex insertion
37 @cindex graphic characters
38   To insert printing characters into the text you are editing, just type
39 them.  This inserts the characters you type into the buffer at the
40 cursor (that is, at @dfn{point}; @pxref{Point}).  The cursor moves
41 forward, and any text after the cursor moves forward too.  If the text
42 in the buffer is @samp{FOOBAR}, with the cursor before the @samp{B},
43 then if you type @kbd{XX}, you get @samp{FOOXXBAR}, with the cursor
44 still before the @samp{B}.
46    To @dfn{delete} text you have just inserted, use @key{DEL}.  @key{DEL}
47 deletes the character @emph{before} the cursor (not the one that the cursor
48 is on top of or under; that is the character @var{after} the cursor).  The
49 cursor and all characters after it move backwards.  Therefore, if you type
50 a printing character and then type @key{DEL}, they cancel out.
52 @kindex RET
53 @cindex newline
54    To end a line and start typing a new one, type @key{RET}.  This
55 inserts a newline character in the buffer.  If point is in the middle of
56 a line, @key{RET} splits the line.  Typing @key{DEL} when the cursor is
57 at the beginning of a line deletes the preceding newline, thus joining
58 the line with the preceding line.
60   Emacs can split lines automatically when they become too long, if you
61 turn on a special minor mode called @dfn{Auto Fill} mode.
62 @xref{Filling}, for how to use Auto Fill mode.
64   If you prefer to have text characters replace (overwrite) existing
65 text rather than shove it to the right, you can enable Overwrite mode,
66 a minor mode.  @xref{Minor Modes}.
68 @cindex quoting
69 @kindex C-q
70 @findex quoted-insert
71   Direct insertion works for printing characters and @key{SPC}, but other
72 characters act as editing commands and do not insert themselves.  If you
73 need to insert a control character or a character whose code is above 200
74 octal, you must @dfn{quote} it by typing the character @kbd{Control-q}
75 (@code{quoted-insert}) first.  (This character's name is normally written
76 @kbd{C-q} for short.)  There are two ways to use @kbd{C-q}:@refill
78 @itemize @bullet
79 @item
80 @kbd{C-q} followed by any non-graphic character (even @kbd{C-g})
81 inserts that character.
83 @item
84 @kbd{C-q} followed by a sequence of octal digits inserts the character
85 with the specified octal character code.  You can use any number of
86 octal digits; any non-digit terminates the sequence.  If the terminating
87 character is @key{RET}, it serves only to terminate the sequence; any
88 other non-digit is itself used as input after terminating the sequence.
89 (The use of octal sequences is disabled in ordinary non-binary Overwrite
90 mode, to give you a convenient way to insert a digit instead of
91 overwriting with it.)
92 @end itemize
94 @cindex 8-bit character codes
95 @noindent
96 When multibyte characters are enabled, if you specify a code in the
97 range 0200 through 0377 octal, @kbd{C-q} assumes that you intend to use
98 some ISO 8859-@var{n} character set, and converts the specified code to
99 the corresponding Emacs character code.  @xref{Enabling Multibyte}.  You
100 select to @emph{which} of the ISO 8859 character sets should Emacs
101 convert the 8-bit code through your choice of language environment
102 (@pxref{Language Environments}).
104 @vindex read-quoted-char-radix
105 To use decimal or hexadecimal instead of octal, set the variable
106 @code{read-quoted-char-radix} to 10 or 16.  If the radix is greater than
107 10, some letters starting with @kbd{a} serve as part of a character
108 code, just like digits.
110 A numeric argument to @kbd{C-q} specifies how many copies of the
111 quoted character should be inserted (@pxref{Arguments}).
113 @findex newline
114 @findex self-insert
115   Customization information: @key{DEL} in most modes runs the command
116 @code{delete-backward-char}; @key{RET} runs the command @code{newline}, and
117 self-inserting printing characters run the command @code{self-insert},
118 which inserts whatever character was typed to invoke it.  Some major modes
119 rebind @key{DEL} to other commands.
121 @node Moving Point
122 @section Changing the Location of Point
124 @cindex arrow keys
125 @kindex LEFT
126 @kindex RIGHT
127 @kindex UP
128 @kindex DOWN
129 @cindex moving point
130 @cindex movement
131 @cindex cursor motion
132 @cindex moving the cursor
133   To do more than insert characters, you have to know how to move point
134 (@pxref{Point}).  The simplest way to do this is with arrow keys, or by
135 clicking the left mouse button where you want to move to.
137   There are also control and meta characters for cursor motion.  Some
138 are equivalent to the arrow keys (these date back to the days before
139 terminals had arrow keys, and are usable on terminals which don't have
140 them).  Others do more sophisticated things.
142 @kindex C-a
143 @kindex C-e
144 @kindex C-f
145 @kindex C-b
146 @kindex C-n
147 @kindex C-p
148 @kindex M->
149 @kindex M-<
150 @kindex M-r
151 @findex beginning-of-line
152 @findex end-of-line
153 @findex forward-char
154 @findex backward-char
155 @findex next-line
156 @findex previous-line
157 @findex beginning-of-buffer
158 @findex end-of-buffer
159 @findex goto-char
160 @findex goto-line
161 @findex move-to-window-line
162 @table @kbd
163 @item C-a
164 Move to the beginning of the line (@code{beginning-of-line}).
165 @item C-e
166 Move to the end of the line (@code{end-of-line}).
167 @item C-f
168 Move forward one character (@code{forward-char}).
169 @item C-b
170 Move backward one character (@code{backward-char}).
171 @item M-f
172 Move forward one word (@code{forward-word}).
173 @item M-b
174 Move backward one word (@code{backward-word}).
175 @item C-n
176 Move down one line, vertically (@code{next-line}).  This command
177 attempts to keep the horizontal position unchanged, so if you start in
178 the middle of one line, you end in the middle of the next.  When on
179 the last line of text, @kbd{C-n} creates a new line and moves onto it.
180 @item C-p
181 Move up one line, vertically (@code{previous-line}).
182 @item M-r
183 Move point to left margin, vertically centered in the window
184 (@code{move-to-window-line}).  Text does not move on the screen.
186 A numeric argument says which screen line to place point on.  It counts
187 screen lines down from the top of the window (zero for the top line).  A
188 negative argument counts lines from the bottom (@minus{}1 for the bottom
189 line).
190 @item M-<
191 Move to the top of the buffer (@code{beginning-of-buffer}).  With
192 numeric argument @var{n}, move to @var{n}/10 of the way from the top.
193 @xref{Arguments}, for more information on numeric arguments.@refill
194 @item M->
195 Move to the end of the buffer (@code{end-of-buffer}).
196 @item M-x goto-char
197 Read a number @var{n} and move point to buffer position @var{n}.
198 Position 1 is the beginning of the buffer.
199 @item M-x goto-line
200 Read a number @var{n} and move point to line number @var{n}.  Line 1
201 is the beginning of the buffer.
202 @item C-x C-n
203 @findex set-goal-column
204 @kindex C-x C-n
205 Use the current column of point as the @dfn{semipermanent goal column} for
206 @kbd{C-n} and @kbd{C-p} (@code{set-goal-column}).  Henceforth, those
207 commands always move to this column in each line moved into, or as
208 close as possible given the contents of the line.  This goal column remains
209 in effect until canceled.
210 @item C-u C-x C-n
211 Cancel the goal column.  Henceforth, @kbd{C-n} and @kbd{C-p} once
212 again try to stick to a fixed horizontal position, as usual.
213 @end table
215 @vindex track-eol
216   If you set the variable @code{track-eol} to a non-@code{nil} value,
217 then @kbd{C-n} and @kbd{C-p} when at the end of the starting line move
218 to the end of another line.  Normally, @code{track-eol} is @code{nil}.
219 @xref{Variables}, for how to set variables such as @code{track-eol}.
221 @vindex next-line-add-newlines
222   Normally, @kbd{C-n} on the last line of a buffer appends a newline to
223 it.  If the variable @code{next-line-add-newlines} is @code{nil}, then
224 @kbd{C-n} gets an error instead (like @kbd{C-p} on the first line).
226 @node Erasing   
227 @section Erasing Text
229 @table @kbd
230 @item @key{DEL}
231 Delete the character before point (@code{delete-backward-char}).
232 @item C-d
233 Delete the character after point (@code{delete-char}).
234 @item C-k
235 Kill to the end of the line (@code{kill-line}).
236 @item M-d
237 Kill forward to the end of the next word (@code{kill-word}).
238 @item M-@key{DEL}
239 Kill back to the beginning of the previous word
240 (@code{backward-kill-word}).
241 @end table
243 @cindex killing characters and lines
244 @cindex deleting characters and lines
245 @cindex erasing characters and lines
246   You already know about the @key{DEL} key which deletes the character
247 before point (that is, before the cursor).  Another key, @kbd{Control-d}
248 (@kbd{C-d} for short), deletes the character after point (that is, the
249 character that the cursor is on).  This shifts the rest of the text on
250 the line to the left.  If you type @kbd{C-d} at the end of a line, it
251 joins together that line and the next line.
253   To erase a larger amount of text, use the @kbd{C-k} key, which kills a
254 line at a time.  If you type @kbd{C-k} at the beginning or middle of a
255 line, it kills all the text up to the end of the line.  If you type
256 @kbd{C-k} at the end of a line, it joins that line and the next line.
258   @xref{Killing}, for more flexible ways of killing text.
260 @node Undo
261 @section Undoing Changes
262 @cindex undo
263 @cindex changes, undoing
265   You can undo all the recent changes in the buffer text, up to a
266 certain point.  Each buffer records changes individually, and the undo
267 command always applies to the current buffer.  Usually each editing
268 command makes a separate entry in the undo records, but some commands
269 such as @code{query-replace} make many entries, and very simple commands
270 such as self-inserting characters are often grouped to make undoing less
271 tedious.
273 @table @kbd
274 @item C-x u
275 Undo one batch of changes---usually, one command worth (@code{undo}).
276 @item C-_
277 The same.
278 @item C-u C-x u
279 Undo one batch of changes in the region.
280 @end table
282 @kindex C-x u
283 @kindex C-_
284 @findex undo
285   The command @kbd{C-x u} or @kbd{C-_} is how you undo.  The first time
286 you give this command, it undoes the last change.  Point moves back to
287 where it was before the command that made the change.
289   Consecutive repetitions of @kbd{C-_} or @kbd{C-x u} undo earlier and
290 earlier changes, back to the limit of the undo information available.
291 If all recorded changes have already been undone, the undo command
292 prints an error message and does nothing.
294   Any command other than an undo command breaks the sequence of undo
295 commands.  Starting from that moment, the previous undo commands become
296 ordinary changes that you can undo.  Thus, to redo changes you have
297 undone, type @kbd{C-f} or any other command that will harmlessly break
298 the sequence of undoing, then type more undo commands.
300 @cindex selective undo
301 @kindex C-u C-x u
302   Ordinary undo applies to all changes made in the current buffer.  You
303 can also perform @dfn{selective undo}, limited to the current region.
304 To do this, specify the region you want, then run the @code{undo}
305 command with a prefix argument (the value does not matter): @kbd{C-u C-x
306 u} or @kbd{C-u C-_}.  This undoes the most recent change in the region.
307 To undo further changes in the same region, repeat the @code{undo}
308 command (no prefix argument is needed).  In Transient Mark mode, any use
309 of @code{undo} when there is an active region performs selective undo;
310 you do not need a prefix argument.
312   If you notice that a buffer has been modified accidentally, the
313 easiest way to recover is to type @kbd{C-_} repeatedly until the stars
314 disappear from the front of the mode line.  At this time, all the
315 modifications you made have been canceled.  Whenever an undo command
316 makes the stars disappear from the mode line, it means that the buffer
317 contents are the same as they were when the file was last read in or
318 saved.
320   If you do not remember whether you changed the buffer deliberately,
321 type @kbd{C-_} once.  When you see the last change you made undone, you
322 will see whether it was an intentional change.  If it was an accident,
323 leave it undone.  If it was deliberate, redo the change as described
324 above.
326   Not all buffers record undo information.  Buffers whose names start with
327 spaces don't; these buffers are used internally by Emacs and its extensions
328 to hold text that users don't normally look at or edit.
330   You cannot undo mere cursor motion; only changes in the buffer
331 contents save undo information.  However, some cursor motion commands
332 set the mark, so if you use these commands from time to time, you can
333 move back to the neighborhoods you have moved through by popping the
334 mark ring (@pxref{Mark Ring}).
336 @vindex undo-limit
337 @vindex undo-strong-limit
338 @cindex undo limit
339   When the undo information for a buffer becomes too large, Emacs
340 discards the oldest undo information from time to time (during garbage
341 collection).  You can specify how much undo information to keep by
342 setting two variables: @code{undo-limit} and @code{undo-strong-limit}.
343 Their values are expressed in units of bytes of space.
345   The variable @code{undo-limit} sets a soft limit: Emacs keeps undo
346 data for enough commands to reach this size, and perhaps exceed it, but
347 does not keep data for any earlier commands beyond that.  Its default
348 value is 20000.  The variable @code{undo-strong-limit} sets a stricter
349 limit: the command which pushes the size past this amount is itself
350 forgotten.  Its default value is 30000.
352   Regardless of the values of those variables, the most recent change is
353 never discarded, so there is no danger that garbage collection occurring
354 right after an unintentional large change might prevent you from undoing
357   The reason the @code{undo} command has two keys, @kbd{C-x u} and
358 @kbd{C-_}, set up to run it is that it is worthy of a single-character
359 key, but on some keyboards it is not obvious how to type @kbd{C-_}.
360 @kbd{C-x u} is an alternative you can type straightforwardly on any
361 terminal.
363 @node Basic Files
364 @section Files
366   The commands described above are sufficient for creating and altering
367 text in an Emacs buffer; the more advanced Emacs commands just make
368 things easier.  But to keep any text permanently you must put it in a
369 @dfn{file}.  Files are named units of text which are stored by the
370 operating system for you to retrieve later by name.  To look at or use
371 the contents of a file in any way, including editing the file with
372 Emacs, you must specify the file name.
374   Consider a file named @file{/usr/rms/foo.c}.  In Emacs, to begin editing
375 this file, type
377 @example
378 C-x C-f /usr/rms/foo.c @key{RET}
379 @end example
381 @noindent
382 Here the file name is given as an @dfn{argument} to the command @kbd{C-x
383 C-f} (@code{find-file}).  That command uses the @dfn{minibuffer} to
384 read the argument, and you type @key{RET} to terminate the argument
385 (@pxref{Minibuffer}).@refill
387   Emacs obeys the command by @dfn{visiting} the file: creating a buffer,
388 copying the contents of the file into the buffer, and then displaying
389 the buffer for you to edit.  If you alter the text, you can @dfn{save}
390 the new text in the file by typing @kbd{C-x C-s} (@code{save-buffer}).
391 This makes the changes permanent by copying the altered buffer contents
392 back into the file @file{/usr/rms/foo.c}.  Until you save, the changes
393 exist only inside Emacs, and the file @file{foo.c} is unaltered.
395   To create a file, just visit the file with @kbd{C-x C-f} as if it
396 already existed.  This creates an empty buffer in which you can insert
397 the text you want to put in the file.  The file is actually created when
398 you save this buffer with @kbd{C-x C-s}.
400   Of course, there is a lot more to learn about using files.  @xref{Files}.
402 @node Basic Help
403 @section Help
405 @cindex getting help with keys
406   If you forget what a key does, you can find out with the Help
407 character, which is @kbd{C-h} (or @key{F1}, which is an alias for
408 @kbd{C-h}).  Type @kbd{C-h k} followed by the key you want to know
409 about; for example, @kbd{C-h k C-n} tells you all about what @kbd{C-n}
410 does.  @kbd{C-h} is a prefix key; @kbd{C-h k} is just one of its
411 subcommands (the command @code{describe-key}).  The other subcommands of
412 @kbd{C-h} provide different kinds of help.  Type @kbd{C-h} twice to get
413 a description of all the help facilities.  @xref{Help}.@refill
415 @node Blank Lines
416 @section Blank Lines
418 @cindex inserting blank lines
419 @cindex deleting blank lines
420   Here are special commands and techniques for putting in and taking out
421 blank lines.
423 @c widecommands
424 @table @kbd
425 @item C-o
426 Insert one or more blank lines after the cursor (@code{open-line}).
427 @item C-x C-o
428 Delete all but one of many consecutive blank lines
429 (@code{delete-blank-lines}).
430 @end table
432 @kindex C-o
433 @kindex C-x C-o
434 @cindex blank lines
435 @findex open-line
436 @findex delete-blank-lines
437   When you want to insert a new line of text before an existing line, you
438 can do it by typing the new line of text, followed by @key{RET}.
439 However, it may be easier to see what you are doing if you first make a
440 blank line and then insert the desired text into it.  This is easy to do
441 using the key @kbd{C-o} (@code{open-line}), which inserts a newline
442 after point but leaves point in front of the newline.  After @kbd{C-o},
443 type the text for the new line.  @kbd{C-o F O O} has the same effect as
444 @w{@kbd{F O O @key{RET}}}, except for the final location of point.
446   You can make several blank lines by typing @kbd{C-o} several times, or
447 by giving it a numeric argument to tell it how many blank lines to make.
448 @xref{Arguments}, for how.  If you have a fill prefix, then @kbd{C-o}
449 command inserts the fill prefix on the new line, when you use it at the
450 beginning of a line.  @xref{Fill Prefix}.
452   The easy way to get rid of extra blank lines is with the command
453 @kbd{C-x C-o} (@code{delete-blank-lines}).  @kbd{C-x C-o} in a run of
454 several blank lines deletes all but one of them.  @kbd{C-x C-o} on a
455 solitary blank line deletes that blank line.  When point is on a
456 nonblank line, @kbd{C-x C-o} deletes any blank lines following that
457 nonblank line.
459 @node Continuation Lines
460 @section Continuation Lines
462 @cindex continuation line
463 @cindex wrapping
464 @cindex line wrapping
465   If you add too many characters to one line without breaking it with
466 @key{RET}, the line will grow to occupy two (or more) lines on the screen,
467 with a @samp{\} at the extreme right margin of all but the last of them.
468 The @samp{\} says that the following screen line is not really a distinct
469 line in the text, but just the @dfn{continuation} of a line too long to fit
470 the screen.  Continuation is also called @dfn{line wrapping}.
472   Sometimes it is nice to have Emacs insert newlines automatically when
473 a line gets too long.  Continuation on the screen does not do that.  Use
474 Auto Fill mode (@pxref{Filling}) if that's what you want.
476 @vindex truncate-lines
477 @findex toggle-truncate-lines
478 @cindex truncation
479   As an alternative to continuation, Emacs can display long lines by
480 @dfn{truncation}.  This means that all the characters that do not fit in
481 the width of the screen or window do not appear at all.  They remain in
482 the buffer, temporarily invisible.  @samp{$} is used in the last column
483 instead of @samp{\} to inform you that truncation is in effect.
485   Truncation instead of continuation happens whenever horizontal
486 scrolling is in use, and optionally in all side-by-side windows
487 (@pxref{Windows}).  You can enable truncation for a particular buffer by
488 setting the variable @code{truncate-lines} to non-@code{nil} in that
489 buffer.  (@xref{Variables}.)  Altering the value of
490 @code{truncate-lines} makes it local to the current buffer; until that
491 time, the default value is in effect.  The default is initially
492 @code{nil}.  @xref{Locals}.
494   The command @kbd{M-x toggle-truncate-lines} toggles the display
495 between continuation and truncation.
497   @xref{Display Vars}, for additional variables that affect how text is
498 displayed.
500 @node Position Info
501 @section Cursor Position Information
503   Here are commands to get information about the size and position of
504 parts of the buffer, and to count lines.
506 @table @kbd
507 @item M-x what-page
508 Print page number of point, and line number within page.
509 @item M-x what-line
510 Print line number of point in the buffer.
511 @item M-x line-number-mode
512 @itemx M-x column-number-mode
513 Toggle automatic display of current line number or column number.
514 @xref{Optional Mode Line}.
515 @item M-=
516 Print number of lines in the current region (@code{count-lines-region}).
517 @xref{Mark}, for information about the region.
518 @item C-x =
519 Print character code of character after point, character position of
520 point, and column of point (@code{what-cursor-position}).
521 @item M-x hl-line-mode
522 Highlighting the current line.
523 @end table
525 @findex what-page
526 @findex what-line
527 @cindex line number commands
528 @cindex location of point
529 @cindex cursor location
530 @cindex point location
531   There are two commands for working with line numbers.  @kbd{M-x
532 what-line} computes the current line number and displays it in the echo
533 area.  To go to a given line by number, use @kbd{M-x goto-line}; it
534 prompts you for the number.  These line numbers count from one at the
535 beginning of the buffer.
537   You can also see the current line number in the mode line; @xref{Mode
538 Line}.  If you narrow the buffer, then the line number in the mode line
539 is relative to the accessible portion (@pxref{Narrowing}).  By contrast,
540 @code{what-line} shows both the line number relative to the narrowed
541 region and the line number relative to the whole buffer.
543   By contrast, @kbd{M-x what-page} counts pages from the beginning of
544 the file, and counts lines within the page, printing both numbers.
545 @xref{Pages}.
547 @kindex M-=
548 @findex count-lines-region
549   While on this subject, we might as well mention @kbd{M-=} (@code{count-lines-region}),
550 which prints the number of lines in the region (@pxref{Mark}).
551 @xref{Pages}, for the command @kbd{C-x l} which counts the lines in the
552 current page.
554 @kindex C-x =
555 @findex what-cursor-position
556   The command @kbd{C-x =} (@code{what-cursor-position}) can be used to find out
557 the column that the cursor is in, and other miscellaneous information about
558 point.  It prints a line in the echo area that looks like this:
560 @smallexample
561 Char: c (0143, 99, 0x63)  point=21044 of 26883(78%)  column 53 
562 @end smallexample
564 @noindent
565 (In fact, this is the output produced when point is before the
566 @samp{column} in the example.)
568   The four values after @samp{Char:} describe the character that follows
569 point, first by showing it and then by giving its character code in
570 octal, decimal and hex.  For a non-ASCII multibyte character, these are
571 followed by @samp{ext} and the character's representation, in hex, in
572 the buffer's coding system, if that coding system encodes the character
573 safely and with a single byte (@pxref{Coding Systems}).  If the
574 character's encoding is longer than one byte, Emacs shows @samp{ext ...}.
576   @samp{point=} is followed by the position of point expressed as a character
577 count.  The front of the buffer counts as position 1, one character later
578 as 2, and so on.  The next, larger, number is the total number of characters
579 in the buffer.  Afterward in parentheses comes the position expressed as a
580 percentage of the total size.
582   @samp{column} is followed by the horizontal position of point, in
583 columns from the left edge of the window.
585   If the buffer has been narrowed, making some of the text at the
586 beginning and the end temporarily inaccessible, @kbd{C-x =} prints
587 additional text describing the currently accessible range.  For example, it
588 might display this:
590 @smallexample
591 Char: C (0103, 67, 0x43)  point=252 of 889(28%) <231 - 599>  column 0 
592 @end smallexample
594 @noindent
595 where the two extra numbers give the smallest and largest character
596 position that point is allowed to assume.  The characters between those
597 two positions are the accessible ones.  @xref{Narrowing}.
599   If point is at the end of the buffer (or the end of the accessible
600 part), the @w{@kbd{C-x =}} output does not describe a character after
601 point.  The output might look like this:
603 @smallexample
604 point=26957 of 26956(100%)  column 0 
605 @end smallexample
607   @w{@kbd{C-u C-x =}} displays additional information about a character,
608 in place of the buffer coordinates and column: the character set name
609 and the codes that identify the character within that character set;
610 ASCII characters are identified as belonging to the @code{ASCII}
611 character set.  In addition, the full character encoding, even if it
612 takes more than a single byte, is shown after @samp{ext}.  Here's an
613 example for a Latin-1 character A with a grave accent in a buffer whose
614 coding system is iso-2022-7bit@footnote{On terminals that support
615 Latin-1 characters, the character shown after @samp{Char:} is displayed
616 as the actual glyph of A with grave accent.}:
618 @example
619 Char: @`A (04300, 2240, 0x8c0, ext ESC , A @@) (latin-iso8859-1 64)
620 @end example
622 @findex hl-line-mode
623 @findex blink-cursor-mode
624 @cindex cursor, locating visually
625 @cindex cursor, blinking
626 @kbd{M-x hl-line-mode} turns on a global minor mode which highlights the
627 line about point in the selected window (on terminals which support
628 highlighting).  Some people find this convenient.  If you find the
629 cursor difficult to spot, you might try changing its color by
630 customizing the @code{cursor} face or rely on (the default)
631 @code{blink-cursor-mode}.  Cursor color and blinking can be conrolled
632 via the @code{cursor} Custom group.
634 @node Arguments
635 @section Numeric Arguments
636 @cindex numeric arguments
637 @cindex prefix arguments
638 @cindex arguments, numeric
639 @cindex arguments, prefix
641   In mathematics and computer usage, the word @dfn{argument} means
642 ``data provided to a function or operation.''  You can give any Emacs
643 command a @dfn{numeric argument} (also called a @dfn{prefix argument}).
644 Some commands interpret the argument as a repetition count.  For
645 example, @kbd{C-f} with an argument of ten moves forward ten characters
646 instead of one.  With these commands, no argument is equivalent to an
647 argument of one.  Negative arguments tell most such commands to move or
648 act in the opposite direction.
650 @kindex M-1
651 @kindex M-@t{-}
652 @findex digit-argument
653 @findex negative-argument
654   If your terminal keyboard has a @key{META} key, the easiest way to
655 specify a numeric argument is to type digits and/or a minus sign while
656 holding down the @key{META} key.  For example,
657 @example
658 M-5 C-n
659 @end example
660 @noindent
661 would move down five lines.  The characters @kbd{Meta-1}, @kbd{Meta-2},
662 and so on, as well as @kbd{Meta--}, do this because they are keys bound
663 to commands (@code{digit-argument} and @code{negative-argument}) that
664 are defined to contribute to an argument for the next command.  Digits
665 and @kbd{-} modified with Control, or Control and Meta, also specify
666 numeric arguments.
668 @kindex C-u
669 @findex universal-argument
670   Another way of specifying an argument is to use the @kbd{C-u}
671 (@code{universal-argument}) command followed by the digits of the
672 argument.  With @kbd{C-u}, you can type the argument digits without
673 holding down modifier keys; @kbd{C-u} works on all terminals.  To type a
674 negative argument, type a minus sign after @kbd{C-u}.  Just a minus sign
675 without digits normally means @minus{}1.
677   @kbd{C-u} followed by a character which is neither a digit nor a minus
678 sign has the special meaning of ``multiply by four.''  It multiplies the
679 argument for the next command by four.  @kbd{C-u} twice multiplies it by
680 sixteen.  Thus, @kbd{C-u C-u C-f} moves forward sixteen characters.  This
681 is a good way to move forward ``fast,'' since it moves about 1/5 of a line
682 in the usual size screen.  Other useful combinations are @kbd{C-u C-n},
683 @kbd{C-u C-u C-n} (move down a good fraction of a screen), @kbd{C-u C-u
684 C-o} (make ``a lot'' of blank lines), and @kbd{C-u C-k} (kill four
685 lines).@refill
687   Some commands care only about whether there is an argument, and not about
688 its value.  For example, the command @kbd{M-q} (@code{fill-paragraph}) with
689 no argument fills text; with an argument, it justifies the text as well.
690 (@xref{Filling}, for more information on @kbd{M-q}.)  Plain @kbd{C-u} is a
691 handy way of providing an argument for such commands.
693   Some commands use the value of the argument as a repeat count, but do
694 something peculiar when there is no argument.  For example, the command
695 @kbd{C-k} (@code{kill-line}) with argument @var{n} kills @var{n} lines,
696 including their terminating newlines.  But @kbd{C-k} with no argument is
697 special: it kills the text up to the next newline, or, if point is right at
698 the end of the line, it kills the newline itself.  Thus, two @kbd{C-k}
699 commands with no arguments can kill a nonblank line, just like @kbd{C-k}
700 with an argument of one.  (@xref{Killing}, for more information on
701 @kbd{C-k}.)@refill
703   A few commands treat a plain @kbd{C-u} differently from an ordinary
704 argument.  A few others may treat an argument of just a minus sign
705 differently from an argument of @minus{}1.  These unusual cases are
706 described when they come up; they are always for reasons of convenience
707 of use of the individual command.
709   You can use a numeric argument to insert multiple copies of a
710 character.  This is straightforward unless the character is a digit; for
711 example, @kbd{C-u 6 4 a} inserts 64 copies of the character @samp{a}.
712 But this does not work for inserting digits; @kbd{C-u 6 4 1} specifies
713 an argument of 641, rather than inserting anything.  To separate the
714 digit to insert from the argument, type another @kbd{C-u}; for example,
715 @kbd{C-u 6 4 C-u 1} does insert 64 copies of the character @samp{1}.
717   We use the term ``prefix argument'' as well as ``numeric argument'' to
718 emphasize that you type the argument before the command, and to
719 distinguish these arguments from minibuffer arguments that come after
720 the command.
722 @node Repeating
723 @section Repeating a Command
724 @cindex repeating a command
726 @kindex C-x z
727 @findex repeat
728   The command @kbd{C-x z} (@code{repeat}) provides another way to repeat
729 an Emacs command many times.  This command repeats the previous Emacs
730 command, whatever that was.  Repeating a command uses the same arguments
731 that were used before; it does not read new arguments each time.
733   To repeat the command more than once, type additional @kbd{z}'s: each
734 @kbd{z} repeats the command one more time.  Repetition ends when you
735 type a character other than @kbd{z}, or press a mouse button.
737   For example, suppose you type @kbd{C-u 2 0 C-d} to delete 20
738 characters.  You can repeat that command (including its argument) three
739 additional times, to delete a total of 80 characters, by typing @kbd{C-x
740 z z z}.  The first @kbd{C-x z} repeats the command once, and each
741 subsequent @kbd{z} repeats it once again.