basic.texi 34.9 KB
Newer Older
Dave Love's avatar
#  
Dave Love committed
1
@c This is part of the Emacs manual.
Eli Zaretskii's avatar
Eli Zaretskii committed
2
@c Copyright (C) 1985,86,87,93,94,95,97,2000,2001 Free Software Foundation, Inc.
Dave Love's avatar
#  
Dave Love committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
@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}.

46 47 48
   To @dfn{delete} text you have just inserted, use the large key
labeled @key{DEL}, @key{BACKSPACE} or @key{DELETE} which is a short
distance above the @key{RET} or @key{ENTER} key.  This is the key you
49
normally use, outside Emacs, for erasing the last character that you
Richard M. Stallman's avatar
Richard M. Stallman committed
50 51
typed.  Regardless of the label on that key, Emacs thinks of it as
@key{DEL}, and that's what we call it in this manual.
Dave Love's avatar
#  
Dave Love committed
52

53 54 55 56 57
  The @key{DEL} key deletes the character @emph{before} the cursor.
As a consequence, the cursor and all the characters after it move
backwards.  If you type a printing character and then type @key{DEL},
they cancel out.

58 59 60 61 62
  On most computers, Emacs recognizes automatically which key ought to
be @key{DEL}, and sets it up that way.  But in some cases, especially
with text-only terminals, you will need to tell Emacs which key to use
for that purpose.  If the large key not far above the @key{RET} or
@key{ENTER} key doesn't delete backwards, you need to do this.
63
@xref{DEL Does Not Delete}, for an explanation of how.
64

65 66 67 68 69 70
  Most PC keyboards have both a @key{BACKSPACE} key a short ways above
@key{RET} or @key{ENTER}, and a @key{DELETE} key elsewhere.  On these
keyboards, Emacs supports when possible the usual convention that the
@key{BACKSPACE} key deletes backwards (it is @key{DEL}), while the
@key{DELETE} key deletes ``forwards,'' deleting the character after
point, the one underneath the cursor, like @kbd{C-d} (see below).
71

Dave Love's avatar
#  
Dave Love committed
72 73 74 75
@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
76
a line, the effect is to split the line.  Typing @key{DEL} when the cursor is
Dave Love's avatar
#  
Dave Love committed
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
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
Richard M. Stallman's avatar
Richard M. Stallman committed
106 107 108 109 110 111 112 113
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 terminates the sequence and then acts
as normal input---thus, @kbd{C-q 1 0 1 B} inserts @samp{AB}.

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.
Dave Love's avatar
#  
Dave Love committed
114 115
@end itemize

116
@cindex 8-bit character codes
Dave Love's avatar
#  
Dave Love committed
117
@noindent
Dave Love's avatar
Dave Love committed
118
When multibyte characters are enabled, if you specify a code in the
119 120 121 122 123 124
range 0200 through 0377 octal, @kbd{C-q} assumes that you intend to
use some ISO 8859-@var{n} character set, and converts the specified
code to the corresponding Emacs character code.  @xref{Enabling
Multibyte}.  You select @emph{which} of the ISO 8859 character sets to
use through your choice of language environment (@pxref{Language
Environments}).
Dave Love's avatar
#  
Dave Love committed
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168

@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
@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
169 170 171 172
@kindex LEFT
@kindex RIGHT
@kindex UP
@kindex DOWN
173
@findex move-beginning-of-line
174
@findex move-end-of-line
Dave Love's avatar
#  
Dave Love committed
175 176 177 178 179 180 181 182 183 184 185
@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
186
Move to the beginning of the line (@code{move-beginning-of-line}).
Dave Love's avatar
#  
Dave Love committed
187
@item C-e
188
Move to the end of the line (@code{move-end-of-line}).
Dave Love's avatar
#  
Dave Love committed
189
@item C-f
190 191
Move forward one character (@code{forward-char}).  The right-arrow key
does the same thing.
Dave Love's avatar
#  
Dave Love committed
192
@item C-b
193 194
Move backward one character (@code{backward-char}).  The left-arrow
key has the same effect.
Dave Love's avatar
#  
Dave Love committed
195 196 197 198 199 200 201
@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
202 203
the middle of one line, you end in the middle of the next.  The
down-arrow key does the same thing.
Dave Love's avatar
#  
Dave Love committed
204
@item C-p
205
Move up one line, vertically (@code{previous-line}).  The up-arrow key
206
has the same effect.
Dave Love's avatar
#  
Dave Love committed
207 208 209 210 211 212 213 214 215 216 217 218 219 220
@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}).
221
@item C-v
222 223 224 225 226 227
@itemx @key{PAGEDOWN}
@itemx @key{PRIOR}
Scroll the display one screen forward, and move point if necessary to
put it on the screen (@code{scroll-up}).  This doesn't always move
point, but it is commonly used to do so.  If your keyboard has a
@key{PAGEDOWN} or @key{PRIOR} key, it does the same thing.
228 229 230

Scrolling commands are further described in @ref{Scrolling}.
@item M-v
231 232
@itemx @key{PAGEUP}
@itemx @key{NEXT}
233 234
Scroll one screen backward, and move point if necessary to put it on
the screen (@code{scroll-down}).  This doesn't always move point, but
235 236
it is commonly used to do so.  If your keyboard has a @key{PAGEUP} or
@key{NEXT} key, it does the same thing.
Dave Love's avatar
#  
Dave Love committed
237 238 239
@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.
240
@item M-g M-g
241
@itemx M-g g
242
@itemx M-x goto-line
243 244 245 246
Read a number @var{n} and move point to the beginning of line number
@var{n}.  Line 1 is the beginning of the buffer.  If point is on or
just after a number, then that is the default for @var{n}, if you just
press @key{RET} with an empty minibuffer.
Dave Love's avatar
#  
Dave Love committed
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
@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,
Richard M. Stallman's avatar
Richard M. Stallman committed
262
then @kbd{C-n} and @kbd{C-p}, when starting at the end of the line, move
Dave Love's avatar
#  
Dave Love committed
263 264 265 266
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
267
  @kbd{C-n} normally stops at the end of the buffer when you use it on
268 269 270 271
the last line of the buffer.  But if you set the variable
@code{next-line-add-newlines} to a non-@code{nil} value, @kbd{C-n} on
the last line of a buffer creates an additional line at the end and
moves down onto it.
Dave Love's avatar
#  
Dave Love committed
272

273
@node Erasing
Dave Love's avatar
#  
Dave Love committed
274 275 276 277 278 279 280
@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}).
281 282 283 284 285 286
@item @key{DELETE}
@itemx @key{BACKSPACE}
One of these keys, whichever is the large key above the @key{RET} or
@key{ENTER} key, deletes the character before point, like @key{DEL}.
If that is @key{BACKSPACE}, and your keyboard also has @key{DELETE},
then @key{DELETE} deletes forwards, like @kbd{C-d}.
Dave Love's avatar
#  
Dave Love committed
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
@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-_
330
@itemx C-/
Dave Love's avatar
#  
Dave Love committed
331 332 333 334 335 336 337
The same.
@item C-u C-x u
Undo one batch of changes in the region.
@end table

@kindex C-x u
@kindex C-_
338
@kindex C-/
Dave Love's avatar
#  
Dave Love committed
339
@findex undo
340 341 342 343
  The command @kbd{C-x u} (or @kbd{C-_} 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.
Dave Love's avatar
#  
Dave Love committed
344 345 346 347

  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
348
displays an error message and does nothing.
Dave Love's avatar
#  
Dave Love committed
349

350
@findex undo-only
Dave Love's avatar
#  
Dave Love committed
351 352 353 354
  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
355 356 357 358
the sequence of undoing, then type more undo commands.  On the other
hand, if you want to ignore previous undo commands, use @kbd{M-x
undo-only}.  This is like @code{undo}, but will not redo changes
you have just undone.
Dave Love's avatar
#  
Dave Love committed
359 360 361 362

@cindex selective undo
@kindex C-u C-x u
  Ordinary undo applies to all changes made in the current buffer.  You
363
can also perform @dfn{selective undo}, limited to the current region
Lute Kamstra's avatar
Lute Kamstra committed
364
(@pxref{Mark}).
Dave Love's avatar
#  
Dave Love committed
365 366 367 368
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}
369 370 371 372
command (no prefix argument is needed).  In Transient Mark mode
(@pxref{Transient Mark}), any use of @code{undo} when there is an
active region performs selective undo; you do not need a prefix
argument.
Dave Love's avatar
#  
Dave Love committed
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399

  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
400
@vindex undo-outer-limit
Dave Love's avatar
#  
Dave Love committed
401 402 403 404
@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
405 406 407
setting three variables: @code{undo-limit}, @code{undo-strong-limit},
and @code{undo-outer-limit}.  Their values are expressed in units of
bytes of space.
Dave Love's avatar
#  
Dave Love committed
408 409

  The variable @code{undo-limit} sets a soft limit: Emacs keeps undo
410 411 412 413 414 415 416 417 418
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: a previous command (not the most recent one) which
pushes the size past this amount is itself forgotten.  The default
value of @code{undo-strong-limit} is 30000.

  Regardless of the values of those variables, the most recent change
is never discarded unless it gets bigger than @code{undo-outer-limit}
419
(normally 3,000,000).  At that point, Emacs discards the undo data and
420
warns you about it.  This is the only situation in which you cannot
421 422 423 424 425
undo the last command.  If this happens, you can increase the value of
@code{undo-outer-limit} to make it even less likely to happen in the
future.  But if you didn't expect the command to create such large
undo data, then it is probably a bug and you should report it.
@xref{Bugs,, Reporting Bugs}.
Dave Love's avatar
#  
Dave Love committed
426

427 428 429 430
  The reason the @code{undo} command has three key bindings, @kbd{C-x
u}, @kbd{C-_} and @kbd{C-/}, is that it is worthy of a
single-character key, but @kbd{C-x u} is more straightforward for
beginners to type.
Dave Love's avatar
#  
Dave Love committed
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515

@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.

@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.
516
@xref{Arguments}, for how.  If you have a fill prefix, the @kbd{C-o}
Dave Love's avatar
#  
Dave Love committed
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
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
533
@cindex fringes, and continuation lines
Dave Love's avatar
#  
Dave Love committed
534
  If you add too many characters to one line without breaking it with
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
@key{RET}, the line grows to occupy two (or more) lines on the screen.
On graphical displays, Emacs indicates line wrapping with small bent
arrows in the fringes to the left and right of the window.  On
text-only terminals, Emacs displays a @samp{\} character at the right
margin of a screen line if it is not the last in its text line.  This
@samp{\} character says that the following screen line is not really a
distinct line in the text, just a @dfn{continuation} of a line too
long to fit the screen.  Continuation is also called @dfn{line
wrapping}.

  When line wrapping occurs before a character that is wider than one
column, some columns at the end of the previous screen line may be
``empty.''  In this case, Emacs displays additional @samp{\}
characters in the ``empty'' columns, just before the @samp{\}
character that indicates continuation.
Dave Love's avatar
#  
Dave Love committed
550 551 552 553 554 555

  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.

@cindex truncation
556
@cindex line truncation, and fringes
Dave Love's avatar
#  
Dave Love committed
557
  As an alternative to continuation, Emacs can display long lines by
Gerd Moellmann's avatar
Gerd Moellmann committed
558
@dfn{truncation}.  This means that all the characters that do not fit
559 560 561 562 563 564
in the width of the screen or window do not appear at all.  @samp{$}
in the last column or a small straight arrow in the fringe to the
right of the window indicates a truncated line.

  @xref{Display Custom}, for more information about line truncation,
and other variables that affect how text is displayed.
Dave Love's avatar
#  
Dave Love committed
565 566 567 568 569 570 571 572 573

@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
574
Display the page number of point, and the line number within the page.
Dave Love's avatar
#  
Dave Love committed
575
@item M-x what-line
576
Display the line number of point in the buffer.
Dave Love's avatar
#  
Dave Love committed
577
@item M-x line-number-mode
578 579 580
@itemx M-x column-number-mode
Toggle automatic display of current line number or column number.
@xref{Optional Mode Line}.
Dave Love's avatar
#  
Dave Love committed
581
@item M-=
582
Display the number of lines in the current region (@code{count-lines-region}).
Dave Love's avatar
#  
Dave Love committed
583 584
@xref{Mark}, for information about the region.
@item C-x =
585
Display the character code of character after point, character position of
Dave Love's avatar
#  
Dave Love committed
586
point, and column of point (@code{what-cursor-position}).
587
@item M-x hl-line-mode
588 589
Enable or disable highlighting of the current line.  @xref{Cursor
Display}.
590 591 592
@item M-x size-indication-mode
Toggle automatic display of the size of the buffer.
@xref{Optional Mode Line}.
Dave Love's avatar
#  
Dave Love committed
593 594 595 596 597 598 599 600
@end table

@findex what-page
@findex what-line
@cindex line number commands
@cindex location of point
@cindex cursor location
@cindex point location
601 602 603 604 605 606 607
  @kbd{M-x what-line} computes the current line number and displays it
in the echo area.  You can also see the current line number in the
mode line; see @ref{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.
Dave Love's avatar
#  
Dave Love committed
608

Richard M. Stallman's avatar
Richard M. Stallman committed
609
  @kbd{M-x what-page} counts pages from the beginning of the file, and
610 611
counts lines within the page, showing both numbers in the echo area.
@xref{Pages}.
Dave Love's avatar
#  
Dave Love committed
612 613 614 615

@kindex M-=
@findex count-lines-region
  While on this subject, we might as well mention @kbd{M-=} (@code{count-lines-region}),
616
which displays the number of lines in the region (@pxref{Mark}).
Dave Love's avatar
#  
Dave Love committed
617 618 619 620 621
@xref{Pages}, for the command @kbd{C-x l} which counts the lines in the
current page.

@kindex C-x =
@findex what-cursor-position
622 623 624 625
  The command @kbd{C-x =} (@code{what-cursor-position}) shows what
column the cursor is in, and other miscellaneous information about
point and the character after it.  It displays a line in the echo area
that looks like this:
Dave Love's avatar
#  
Dave Love committed
626 627

@smallexample
628
Char: c (0143, 99, 0x63)  point=21044 of 26883(78%)  column 53
Dave Love's avatar
#  
Dave Love committed
629 630 631 632 633 634 635 636
@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
637
octal, decimal and hex.  For a non-@acronym{ASCII} multibyte character, these are
Dave Love's avatar
#  
Dave Love committed
638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
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
653
beginning and the end temporarily inaccessible, @kbd{C-x =} displays
Dave Love's avatar
#  
Dave Love committed
654 655 656 657
additional text describing the currently accessible range.  For example, it
might display this:

@smallexample
658
Char: C (0103, 67, 0x43)  point=252 of 889(28%) <231 - 599>  column 0
Dave Love's avatar
#  
Dave Love committed
659 660 661 662 663 664 665 666 667 668 669 670
@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
671
point=26957 of 26956(100%)  column 0
Dave Love's avatar
#  
Dave Love committed
672 673
@end smallexample

674
@cindex character set of character at point
675
@cindex font of character at point
676
@cindex text properties at point
677
  @w{@kbd{C-u C-x =}} displays the following additional information about a
678 679 680 681
character.

@itemize @bullet
@item
682
The character set name, and the codes that identify the character
683 684 685 686 687 688 689
within that character set; @acronym{ASCII} characters are identified
as belonging to the @code{ascii} character set.

@item
The character's syntax and categories.

@item
690 691
The character's encodings, both internally in the buffer, and externally
if you were to save the file.
692 693

@item
694 695
What to type to input the character in the current input method
(if it supports the character).
696 697 698 699 700 701 702 703

@item
If you are running Emacs on a window system, the font name and glyph
code for the character.  If you are running Emacs on a terminal, the
code(s) sent to the terminal.

@item
The character's text properties (@pxref{Text Properties,,,
704 705
elisp, the Emacs Lisp Reference Manual}), and any overlays containing it
(@pxref{Overlays,,, elisp, the same manual}).
706 707
@end itemize

708
  Here's an example showing the Latin-1 character A with grave accent,
709
in a buffer whose coding system is @code{iso-latin-1}, whose
710
terminal coding system is @code{iso-latin-1} (so the terminal actually
711 712
displays the character as @samp{@`A}), and which has font-lock-mode
(@pxref{Font Lock}) enabled:
Dave Love's avatar
#  
Dave Love committed
713

Richard M. Stallman's avatar
Richard M. Stallman committed
714
@smallexample
715 716 717 718 719 720 721 722 723 724 725 726 727
  character: @`A (04300, 2240, 0x8c0, U+00C0)
    charset: latin-iso8859-1
             (Right-Hand Part of Latin Alphabet 1@dots{}
 code point: 64
     syntax: w 	which means: word
   category: l:Latin
   to input: type "`A"
buffer code: 0x81 0xC0
  file code: ESC 2C 41 40 (encoded by coding system iso-2022-7bit)
    display: terminal code 0xC0

There are text properties here:
  fontified            t
Richard M. Stallman's avatar
Richard M. Stallman committed
728
@end smallexample
Dave Love's avatar
#  
Dave Love committed
729 730 731 732 733

@node Arguments
@section Numeric Arguments
@cindex numeric arguments
@cindex prefix arguments
734
@cindex arguments to commands
Dave Love's avatar
#  
Dave Love committed
735 736 737 738 739 740 741 742 743 744 745 746 747 748

  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
749 750 751 752
  If your terminal keyboard has a @key{META} key (labeled @key{ALT} on
PC keyboards), 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,
753

Dave Love's avatar
#  
Dave Love committed
754 755 756
@example
M-5 C-n
@end example
757

Dave Love's avatar
#  
Dave Love committed
758 759 760 761
@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
762 763 764 765
are defined to contribute to an argument for the next command.
@kbd{Meta--} without digits normally means @minus{}1.  Digits and
@kbd{-} modified with Control, or Control and Meta, also specify numeric
arguments.
Dave Love's avatar
#  
Dave Love committed
766 767 768 769 770 771 772 773 774 775 776 777 778 779

@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
780
is a good way to move forward ``fast,'' since it moves about 1/5 of a line
Dave Love's avatar
#  
Dave Love committed
781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804
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
805 806 807
described when they come up; they are always for reasons of
convenience of use of the individual command, and they are documented
in the command's documentation string.
Dave Love's avatar
#  
Dave Love committed
808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825

  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

Richard M. Stallman's avatar
Richard M. Stallman committed
826 827 828 829 830 831
  Many simple commands, such as those invoked with a single key or
with @kbd{M-x @var{command-name} @key{RET}}, can be repeated by
invoking them with a numeric argument that serves as a repeat count
(@pxref{Arguments}).  However, if the command you want to repeat
prompts for some input, or uses a numeric argument in another way,
repetition using a numeric argument might be problematical.
832

Dave Love's avatar
#  
Dave Love committed
833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
@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.

Miles Bader's avatar
Miles Bader committed
850 851 852
@ignore
   arch-tag: cda8952a-c439-41c1-aecf-4bc0d6482956
@end ignore