| 1 | @c This is part of the Emacs manual. |
| 2 | @c Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000, 2001, |
| 3 | @c 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. |
| 4 | @c See file emacs.texi for copying conditions. |
| 5 | @node Basic, Minibuffer, Exiting, Top |
| 6 | @chapter Basic Editing Commands |
| 7 | |
| 8 | @kindex C-h t |
| 9 | @findex help-with-tutorial |
| 10 | Here we explain the basics of how to enter text, make corrections, |
| 11 | and save the text in a file. If this material is new to you, we |
| 12 | suggest you first run the Emacs learn-by-doing tutorial, by typing |
| 13 | @kbd{Control-h t} inside Emacs. (@code{help-with-tutorial}). |
| 14 | |
| 15 | @menu |
| 16 | |
| 17 | * Inserting Text:: Inserting text by simply typing it. |
| 18 | * Moving Point:: Moving the cursor to the place where you want to |
| 19 | change something. |
| 20 | * Erasing:: Deleting and killing text. |
| 21 | * Basic Undo:: Undoing recent changes in the text. |
| 22 | * Files: Basic Files. Visiting, creating, and saving files. |
| 23 | * Help: Basic Help. Asking what a character does. |
| 24 | * Blank Lines:: Making and deleting blank lines. |
| 25 | * Continuation Lines:: How Emacs displays lines too wide for the screen. |
| 26 | * Position Info:: What page, line, row, or column is point on? |
| 27 | * Arguments:: Numeric arguments for repeating a command N times. |
| 28 | * Repeating:: Repeating the previous command quickly. |
| 29 | @end menu |
| 30 | |
| 31 | @node Inserting Text |
| 32 | @section Inserting Text |
| 33 | |
| 34 | @cindex insertion |
| 35 | @cindex graphic characters |
| 36 | You can insert an ordinary @dfn{graphic character} (e.g., @samp{a}, |
| 37 | @samp{B}, @samp{3}, and @samp{=}) by typing the associated key. This |
| 38 | adds the character to the buffer at point. Insertion moves point |
| 39 | forward, so that point remains just after the inserted text. |
| 40 | @xref{Point}. |
| 41 | |
| 42 | @kindex RET |
| 43 | @cindex newline |
| 44 | To end a line and start a new one, type @key{RET}. This key may be |
| 45 | labeled @key{Return} or @key{Enter} on your keyboard, but we refer to |
| 46 | it as @key{RET} in this manual. Pressing it inserts a newline |
| 47 | character in the buffer. If point is at the end of the line, this |
| 48 | creates a new blank line after it; if point is in the middle of a |
| 49 | line, the line is split at that position. |
| 50 | |
| 51 | As we explain later in this manual, you can change the way Emacs |
| 52 | handles text insertion by turning on @dfn{minor modes}. For instance, |
| 53 | if you turn on a minor mode called @dfn{Auto Fill} mode, Emacs can |
| 54 | split lines automatically when they become too long (@pxref{Filling}). |
| 55 | If you turn on a minor mode called @dfn{Overwrite} mode, inserted |
| 56 | characters replace (overwrite) existing text, instead of shoving it to |
| 57 | the right. @xref{Minor Modes}. |
| 58 | |
| 59 | @cindex quoting |
| 60 | @kindex C-q |
| 61 | @findex quoted-insert |
| 62 | Only graphic characters can be inserted by typing the associated |
| 63 | key; other keys act as editing commands and do not insert themselves. |
| 64 | For instance, @kbd{DEL} runs the command @code{delete-backward-char} |
| 65 | by default (some modes bind it to a different command); it does not |
| 66 | insert a literal @samp{DEL} character (@acronym{ASCII} character code |
| 67 | 127). To insert a non-graphic character, first @dfn{quote} it by |
| 68 | typing @kbd{C-q} (@code{quoted-insert}). There are two ways to use |
| 69 | @kbd{C-q}: |
| 70 | |
| 71 | @itemize @bullet |
| 72 | @item |
| 73 | @kbd{C-q} followed by any non-graphic character (even @kbd{C-g}) |
| 74 | inserts that character. For instance, @kbd{C-q @key{DEL}} inserts a |
| 75 | literal @samp{DEL} character. |
| 76 | |
| 77 | @item |
| 78 | @kbd{C-q} followed by a sequence of octal digits inserts the character |
| 79 | with the specified octal character code. You can use any number of |
| 80 | octal digits; any non-digit terminates the sequence. If the |
| 81 | terminating character is @key{RET}, it serves only to terminate the |
| 82 | sequence. Any other non-digit terminates the sequence and then acts |
| 83 | as normal input---thus, @kbd{C-q 1 0 1 B} inserts @samp{AB}. |
| 84 | |
| 85 | The use of octal sequences is disabled in ordinary non-binary |
| 86 | Overwrite mode, to give you a convenient way to insert a digit instead |
| 87 | of overwriting with it. |
| 88 | @end itemize |
| 89 | |
| 90 | @cindex 8-bit character codes |
| 91 | @noindent |
| 92 | If you specify a code in the octal range 0200 through 0377, @kbd{C-q} |
| 93 | assumes that you intend to use some ISO 8859-@var{n} character set, |
| 94 | and converts the specified code to the corresponding Emacs character |
| 95 | code. Your choice of language environment determines which of the ISO |
| 96 | 8859 character sets to use (@pxref{Language Environments}). This |
| 97 | feature is disabled if multibyte characters are disabled |
| 98 | (@pxref{Enabling Multibyte}). |
| 99 | |
| 100 | @vindex read-quoted-char-radix |
| 101 | To use decimal or hexadecimal instead of octal, set the variable |
| 102 | @code{read-quoted-char-radix} to 10 or 16. If the radix is greater than |
| 103 | 10, some letters starting with @kbd{a} serve as part of a character |
| 104 | code, just like digits. |
| 105 | |
| 106 | A numeric argument tells @kbd{C-q} how many copies of the quoted |
| 107 | character to insert (@pxref{Arguments}). |
| 108 | |
| 109 | @findex newline |
| 110 | @findex self-insert |
| 111 | Customization information: @key{DEL} in most modes runs the command |
| 112 | @code{delete-backward-char}; @key{RET} runs the command |
| 113 | @code{newline}, and self-inserting printing characters run the command |
| 114 | @code{self-insert}, which inserts whatever character you typed. Some |
| 115 | major modes rebind @key{DEL} to other commands. |
| 116 | |
| 117 | @node Moving Point |
| 118 | @section Changing the Location of Point |
| 119 | |
| 120 | @cindex arrow keys |
| 121 | @cindex moving point |
| 122 | @cindex movement |
| 123 | @cindex cursor motion |
| 124 | @cindex moving the cursor |
| 125 | To do more than insert characters, you have to know how to move |
| 126 | point (@pxref{Point}). The keyboard commands @kbd{C-f}, @kbd{C-b}, |
| 127 | @kbd{C-n}, and @kbd{C-p} move point to the right, left, up and down |
| 128 | respectively. These are equivalent to the commands @kbd{@key{right}}, |
| 129 | @kbd{@key{left}}, @kbd{@key{down}}, and @kbd{@key{up}}, entered using |
| 130 | the @dfn{arrow keys} present on many keyboards. Many Emacs users find |
| 131 | that it is slower to use the arrow keys than the equivalent control |
| 132 | keys. You can also click the left mouse button to move point to the |
| 133 | position clicked. Emacs also provides a variety of additional |
| 134 | keyboard commands that move point in more sophisticated ways. |
| 135 | |
| 136 | @kindex C-a |
| 137 | @kindex C-e |
| 138 | @kindex C-f |
| 139 | @kindex C-b |
| 140 | @kindex C-n |
| 141 | @kindex C-p |
| 142 | @kindex M-> |
| 143 | @kindex M-< |
| 144 | @kindex M-r |
| 145 | @kindex LEFT |
| 146 | @kindex RIGHT |
| 147 | @kindex UP |
| 148 | @kindex DOWN |
| 149 | @findex move-beginning-of-line |
| 150 | @findex move-end-of-line |
| 151 | @findex forward-char |
| 152 | @findex backward-char |
| 153 | @findex next-line |
| 154 | @findex previous-line |
| 155 | @findex beginning-of-buffer |
| 156 | @findex end-of-buffer |
| 157 | @findex goto-char |
| 158 | @findex goto-line |
| 159 | @findex move-to-window-line |
| 160 | @table @kbd |
| 161 | @item C-a |
| 162 | @itemx @key{Home} |
| 163 | Move to the beginning of the line (@code{move-beginning-of-line}). |
| 164 | @item C-e |
| 165 | @itemx @key{End} |
| 166 | Move to the end of the line (@code{move-end-of-line}). |
| 167 | @item C-f |
| 168 | @itemx @key{right} |
| 169 | Move forward one character (@code{forward-char}). |
| 170 | @item C-b |
| 171 | @itemx @key{left} |
| 172 | Move backward one character (@code{backward-char}). |
| 173 | @item M-f |
| 174 | @itemx M-@key{right} |
| 175 | @itemx C-@key{right} |
| 176 | Move forward one word (@code{forward-word}). |
| 177 | @item M-b |
| 178 | @itemx M-@key{left} |
| 179 | @itemx C-@key{left} |
| 180 | Move backward one word (@code{backward-word}). |
| 181 | @item C-n |
| 182 | @itemx @key{down} |
| 183 | Move down one screen line (@code{next-line}). This command attempts |
| 184 | to keep the horizontal position unchanged, so if you start in the |
| 185 | middle of one line, you move to the middle of the next. |
| 186 | @item C-p |
| 187 | @itemx @key{up} |
| 188 | Move up one screen line (@code{previous-line}). This command |
| 189 | preserves position within the line, like @kbd{C-n}. |
| 190 | @item M-r |
| 191 | Move point to left margin, vertically centered in the window |
| 192 | (@code{move-to-window-line}). Text does not move on the screen. |
| 193 | A numeric argument says which screen line to place point on, counting |
| 194 | downward from the top of the window (zero means the top line). A |
| 195 | negative argument counts lines up from the bottom (@minus{}1 means the |
| 196 | bottom line). |
| 197 | @item M-< |
| 198 | Move to the top of the buffer (@code{beginning-of-buffer}). With |
| 199 | numeric argument @var{n}, move to @var{n}/10 of the way from the top. |
| 200 | @xref{Arguments}, for more information on numeric arguments.@refill |
| 201 | @item M-> |
| 202 | Move to the end of the buffer (@code{end-of-buffer}). |
| 203 | @item C-v |
| 204 | @itemx @key{PageDown} |
| 205 | @itemx @key{next} |
| 206 | Scroll the display one screen forward, and move point if necessary to |
| 207 | put it on the screen (@code{scroll-up}). If your keyboard has a |
| 208 | @key{PageDown} key (sometimes labelled @key{next}), it does the same |
| 209 | thing as as @key{C-v}. Scrolling commands are described further in |
| 210 | @ref{Scrolling}. |
| 211 | @item M-v |
| 212 | @itemx @key{PageUp} |
| 213 | @itemx @key{prior} |
| 214 | Scroll one screen backward, and move point if necessary to put it on |
| 215 | the screen (@code{scroll-down}). If your keyboard has a @key{PageUp} |
| 216 | key (sometimes labelled @key{prior}), it does the same thing as |
| 217 | @key{M-v}. |
| 218 | @item M-x goto-char |
| 219 | Read a number @var{n} and move point to buffer position @var{n}. |
| 220 | Position 1 is the beginning of the buffer. |
| 221 | @item M-g M-g |
| 222 | @itemx M-g g |
| 223 | Read a number @var{n} and move point to the beginning of line number |
| 224 | @var{n} (@code{goto-line}). Line 1 is the beginning of the buffer. If |
| 225 | point is on or just after a number in the buffer, that is the default |
| 226 | for @var{n}. Just type @key{RET} in the minibuffer to use it. You can |
| 227 | also specify @var{n} by giving @kbd{M-g M-g} a numeric prefix argument. |
| 228 | @xref{Select Buffer}, for the behavior of @kbd{M-g M-g} when you give it |
| 229 | a plain prefix argument. |
| 230 | @item C-x C-n |
| 231 | @findex set-goal-column |
| 232 | @kindex C-x C-n |
| 233 | Use the current column of point as the @dfn{semipermanent goal column} |
| 234 | for @kbd{C-n} and @kbd{C-p} (@code{set-goal-column}). When a |
| 235 | semipermanent goal column is in effect, those commands always try to |
| 236 | move to this column, or as close as possible to it, after moving |
| 237 | vertically. The goal column remains in effect until canceled. |
| 238 | @item C-u C-x C-n |
| 239 | Cancel the goal column. Henceforth, @kbd{C-n} and @kbd{C-p} try to |
| 240 | preserve the horizontal position, as usual. |
| 241 | @end table |
| 242 | |
| 243 | @vindex line-move-visual |
| 244 | When a line of text in the buffer is longer than the width of the |
| 245 | window, Emacs usually displays it on two or more @dfn{screen lines}. |
| 246 | For convenience, @kbd{C-n} and @kbd{C-p} move point by screen lines, |
| 247 | as do the equivalent keys @kbd{@key{down}} and @kbd{@key{up}}. You |
| 248 | can force these commands to move according to @dfn{logical lines} |
| 249 | (i.e., according to the text lines in the buffer) by setting the |
| 250 | variable @code{line-move-visual} to @code{nil}; if a logical line |
| 251 | occupies multiple screen lines, the cursor then skips over the |
| 252 | additional screen lines. Moving by logical lines was the default |
| 253 | behavior prior to Emacs 23.1. For details, see @ref{Continuation |
| 254 | Lines}. @xref{Variables}, for how to set variables such as |
| 255 | @code{line-move-visual}. |
| 256 | |
| 257 | Unlike @kbd{C-n} and @kbd{C-p}, most of the Emacs commands that work |
| 258 | on lines work on @emph{logical} lines. For instance, @kbd{C-a} |
| 259 | (@code{move-beginning-of-line}) and @kbd{C-e} |
| 260 | (@code{move-end-of-line}) respectively move to the beginning and end |
| 261 | of the logical line. Whenever we encounter commands that work on |
| 262 | screen lines, such as @kbd{C-n} and @kbd{C-p}, we will point these |
| 263 | out. |
| 264 | |
| 265 | @vindex track-eol |
| 266 | When @code{line-move-visual} is @code{nil}, you can also set the |
| 267 | variable @code{track-eol} to a non-@code{nil} value. Then @kbd{C-n} |
| 268 | and @kbd{C-p}, when starting at the end of the logical line, move to |
| 269 | the end of the next logical line. Normally, @code{track-eol} is |
| 270 | @code{nil}. |
| 271 | |
| 272 | @vindex next-line-add-newlines |
| 273 | @kbd{C-n} normally stops at the end of the buffer when you use it on |
| 274 | the last line of the buffer. However, if you set the variable |
| 275 | @code{next-line-add-newlines} to a non-@code{nil} value, @kbd{C-n} on |
| 276 | the last line of a buffer creates an additional line at the end and |
| 277 | moves down into it. |
| 278 | |
| 279 | @node Erasing |
| 280 | @section Erasing Text |
| 281 | |
| 282 | @table @kbd |
| 283 | @item @key{DEL} |
| 284 | @itemx @key{Backspace} |
| 285 | Delete the character before point (@code{delete-backward-char}). |
| 286 | @item C-d |
| 287 | @itemx @key{Delete} |
| 288 | Delete the character after point (@code{delete-char}). |
| 289 | @item C-k |
| 290 | Kill to the end of the line (@code{kill-line}). |
| 291 | @item M-d |
| 292 | Kill forward to the end of the next word (@code{kill-word}). |
| 293 | @item M-@key{DEL} |
| 294 | Kill back to the beginning of the previous word |
| 295 | (@code{backward-kill-word}). |
| 296 | @end table |
| 297 | |
| 298 | The key @kbd{@key{DEL}} (@code{delete-backward-char}) removes the |
| 299 | character before point, moving the cursor and all the characters after |
| 300 | it backwards. On most keyboards, @key{DEL} is labelled |
| 301 | @key{Backspace}, but we refer to it as @key{DEL} in this manual. Do |
| 302 | not confuse @key{DEL} with another key, labelled @key{Delete}, that |
| 303 | exists on many keyboards; we will discuss @key{Delete} momentarily. |
| 304 | |
| 305 | Typing @key{DEL} when the cursor is at the beginning of a line |
| 306 | deletes the preceding newline character, joining the line with the one |
| 307 | before it. |
| 308 | |
| 309 | On some text-only terminals, Emacs may not recognize the @key{DEL} |
| 310 | key properly. If @key{DEL} does not do the right thing (e.g., if it |
| 311 | deletes characters forwards), see @ref{DEL Does Not Delete}. |
| 312 | |
| 313 | @cindex killing characters and lines |
| 314 | @cindex deleting characters and lines |
| 315 | @cindex erasing characters and lines |
| 316 | The key @kbd{C-d} (@code{delete-char}) deletes the character after |
| 317 | point, i.e., the character under the cursor. This shifts the rest of |
| 318 | the text on the line to the left. If you type @kbd{C-d} at the end of |
| 319 | a line, it joins that line with the following line. This command is |
| 320 | also bound to the key labelled @key{Delete} on many keyboards. |
| 321 | |
| 322 | To erase a larger amount of text, use the @kbd{C-k} key, which |
| 323 | erases (kills) a line at a time. If you type @kbd{C-k} at the |
| 324 | beginning or middle of a line, it kills all the text up to the end of |
| 325 | the line. If you type @kbd{C-k} at the end of a line, it joins that |
| 326 | line with the following line. |
| 327 | |
| 328 | To learn more about killing text, see @ref{Killing}. |
| 329 | |
| 330 | @node Basic Undo |
| 331 | @section Undoing Changes |
| 332 | |
| 333 | @table @kbd |
| 334 | @item C-/ |
| 335 | Undo one entry of the undo records---usually, one command worth |
| 336 | (@code{undo}). |
| 337 | @itemx C-x u |
| 338 | @item C-_ |
| 339 | The same. |
| 340 | @end table |
| 341 | |
| 342 | Emacs records a list of changes made in the buffer text, so you can |
| 343 | undo recent changes. This is done using the @code{undo} command, |
| 344 | which is bound to @kbd{C-/} (as well as @kbd{C-x u} and @kbd{C-_}). |
| 345 | Normally, this command undoes the last change, moving point back to |
| 346 | where it was before the change. The undo command applies only to |
| 347 | changes in the buffer; you can't use it to undo cursor motion. |
| 348 | |
| 349 | Although each editing command usually makes a separate entry in the |
| 350 | undo records, very simple commands may be grouped together. |
| 351 | Sometimes, an entry may cover just part of a complex command. |
| 352 | |
| 353 | If you repeat @kbd{C-/} (or its aliases), each repetition undoes |
| 354 | another, earlier change, back to the limit of the undo information |
| 355 | available. If all recorded changes have already been undone, the undo |
| 356 | command displays an error message and does nothing. |
| 357 | |
| 358 | To learn more about the @code{undo} command, see @ref{Undo}. |
| 359 | |
| 360 | @node Basic Files |
| 361 | @section Files |
| 362 | |
| 363 | Text that you insert in an Emacs buffer lasts only as long as the |
| 364 | Emacs session. To keep any text permanently, you must put it in a |
| 365 | @dfn{file}. Files are named units of text which are stored by the |
| 366 | operating system for you to retrieve later by name. To use the |
| 367 | contents of a file in any way, including editing it with Emacs, you |
| 368 | must specify the file name. |
| 369 | |
| 370 | Suppose there is a file named @file{test.emacs} in your home |
| 371 | directory. To begin editing this file in Emacs, type |
| 372 | |
| 373 | @example |
| 374 | C-x C-f test.emacs @key{RET} |
| 375 | @end example |
| 376 | |
| 377 | @noindent |
| 378 | Here the file name is given as an @dfn{argument} to the command @kbd{C-x |
| 379 | C-f} (@code{find-file}). That command uses the @dfn{minibuffer} to |
| 380 | read the argument, and you type @key{RET} to terminate the argument |
| 381 | (@pxref{Minibuffer}). |
| 382 | |
| 383 | Emacs obeys this command by @dfn{visiting} the file: it creates a |
| 384 | buffer, copies the contents of the file into the buffer, and then |
| 385 | displays the buffer for editing. If you alter the text, you can |
| 386 | @dfn{save} the new text in the file by typing @kbd{C-x C-s} |
| 387 | (@code{save-buffer}). This copies the altered buffer contents back |
| 388 | into the file @file{test.emacs}, making them permanent. Until you |
| 389 | save, the changed text exists only inside Emacs, and the file |
| 390 | @file{test.emacs} is unaltered. |
| 391 | |
| 392 | To create a file, just visit it with @kbd{C-x C-f} as if it already |
| 393 | existed. This creates an empty buffer, in which you can insert the |
| 394 | text you want to put in the file. Emacs actually creates the file the |
| 395 | first time you save this buffer with @kbd{C-x C-s}. |
| 396 | |
| 397 | To learn more about using files in Emacs, see @ref{Files}. |
| 398 | |
| 399 | @node Basic Help |
| 400 | @section Help |
| 401 | |
| 402 | @cindex getting help with keys |
| 403 | If you forget what a key does, you can find out with the Help |
| 404 | character, which is @kbd{C-h} (or @key{F1}, which is an alias for |
| 405 | @kbd{C-h}). Type @kbd{C-h k}, followed by the key of interest; for |
| 406 | example, @kbd{C-h k C-n} tells you what @kbd{C-n} does. @kbd{C-h} is |
| 407 | a prefix key; @kbd{C-h k} is just one of its subcommands (the command |
| 408 | @code{describe-key}). The other subcommands of @kbd{C-h} provide |
| 409 | different kinds of help. Type @kbd{C-h} twice to get a description of |
| 410 | all the help facilities. @xref{Help}. |
| 411 | |
| 412 | @node Blank Lines |
| 413 | @section Blank Lines |
| 414 | |
| 415 | @cindex inserting blank lines |
| 416 | @cindex deleting blank lines |
| 417 | Here are special commands and techniques for inserting and deleting |
| 418 | blank lines. |
| 419 | |
| 420 | @table @kbd |
| 421 | @item C-o |
| 422 | Insert a blank line after the cursor (@code{open-line}). |
| 423 | @item C-x C-o |
| 424 | Delete all but one of many consecutive blank lines |
| 425 | (@code{delete-blank-lines}). |
| 426 | @end table |
| 427 | |
| 428 | @kindex C-o |
| 429 | @kindex C-x C-o |
| 430 | @cindex blank lines |
| 431 | @findex open-line |
| 432 | @findex delete-blank-lines |
| 433 | We have seen how @kbd{@key{RET}} (@code{newline}) starts a new line |
| 434 | of text. However, it may be easier to see what you are doing if you |
| 435 | first make a blank line and then insert the desired text into it. |
| 436 | This is easy to do using the key @kbd{C-o} (@code{open-line}), which |
| 437 | inserts a newline after point but leaves point in front of the |
| 438 | newline. After @kbd{C-o}, type the text for the new line. |
| 439 | |
| 440 | You can make several blank lines by typing @kbd{C-o} several times, or |
| 441 | by giving it a numeric argument specifying how many blank lines to make. |
| 442 | @xref{Arguments}, for how. If you have a fill prefix, the @kbd{C-o} |
| 443 | command inserts the fill prefix on the new line, if typed at the |
| 444 | beginning of a line. @xref{Fill Prefix}. |
| 445 | |
| 446 | The easy way to get rid of extra blank lines is with the command |
| 447 | @kbd{C-x C-o} (@code{delete-blank-lines}). If point lies within a run |
| 448 | of several blank lines, @kbd{C-x C-o} deletes all but one of them. If |
| 449 | point is on a single blank line, @kbd{C-x C-o} deletes it. If point |
| 450 | is on a nonblank line, @kbd{C-x C-o} deletes all following blank |
| 451 | lines, if any exists. |
| 452 | |
| 453 | @node Continuation Lines |
| 454 | @section Continuation Lines |
| 455 | |
| 456 | @cindex continuation line |
| 457 | @cindex wrapping |
| 458 | @cindex line wrapping |
| 459 | @cindex fringes, and continuation lines |
| 460 | Sometimes, a line of text in the buffer---a @dfn{logical line}---is |
| 461 | too long to fit in the window, and Emacs displays it as two or more |
| 462 | @dfn{screen lines}. This is called @dfn{line wrapping} or |
| 463 | @dfn{continuation}, and the long logical line is called a |
| 464 | @dfn{continued line}. On a graphical display, Emacs indicates line |
| 465 | wrapping with small bent arrows in the left and right window fringes. |
| 466 | On a text-only terminal, Emacs indicates line wrapping by displaying a |
| 467 | @samp{\} character at the right margin. |
| 468 | |
| 469 | Most commands that act on lines act on logical lines, not screen |
| 470 | lines. For instance, @kbd{C-k} kills a logical line. As described |
| 471 | earlier, @kbd{C-n} (@code{next-line}) and @kbd{C-p} |
| 472 | (@code{previous-line}) are special exceptions: they move point down |
| 473 | and up, respectively, by one screen line (@pxref{Moving Point}). |
| 474 | |
| 475 | @cindex truncation |
| 476 | @cindex line truncation, and fringes |
| 477 | Emacs can optionally @dfn{truncate} long logical lines instead of |
| 478 | continuing them. This means that every logical line occupies a single |
| 479 | screen line; if it is longer than the width of the window, the rest of |
| 480 | the line is not displayed. On a graphical display, a truncated line |
| 481 | is indicated by a small straight arrow in the right fringe; on a |
| 482 | text-only terminal, it is indicated by a @samp{$} character in the |
| 483 | right margin. @xref{Line Truncation}. |
| 484 | |
| 485 | By default, continued lines are wrapped at the right window edge. |
| 486 | Since the wrapping may occur in the middle of a word, continued lines |
| 487 | can be difficult to read. The usual solution is to break your lines |
| 488 | before they get too long, by inserting newlines. If you prefer, you |
| 489 | can make Emacs insert a newline automatically when a line gets too |
| 490 | long, by using Auto Fill mode. @xref{Filling}. |
| 491 | |
| 492 | @cindex word wrap |
| 493 | Sometimes, you may need to edit files containing many long logical |
| 494 | lines, and it may not be practical to break them all up by adding |
| 495 | newlines. In that case, you can use Visual Line mode, which enables |
| 496 | @dfn{word wrapping}: instead of wrapping long lines exactly at the |
| 497 | right window edge, Emacs wraps them at the word boundaries (i.e., |
| 498 | space or tab characters) nearest to the right window edge. Visual |
| 499 | Line mode also redefines editing commands such as @code{C-a}, |
| 500 | @code{C-n}, and @code{C-k} to operate on screen lines rather than |
| 501 | logical lines. @xref{Visual Line Mode}. |
| 502 | |
| 503 | @node Position Info |
| 504 | @section Cursor Position Information |
| 505 | |
| 506 | Here are commands to get information about the size and position of |
| 507 | parts of the buffer, and to count lines. |
| 508 | |
| 509 | @table @kbd |
| 510 | @item M-x what-page |
| 511 | Display the page number of point, and the line number within that page. |
| 512 | @item M-x what-line |
| 513 | Display the line number of point in the whole buffer. |
| 514 | @item M-x line-number-mode |
| 515 | @itemx M-x column-number-mode |
| 516 | Toggle automatic display of the current line number or column number. |
| 517 | @xref{Optional Mode Line}. |
| 518 | @item M-= |
| 519 | Display the number of lines in the current region (@code{count-lines-region}). |
| 520 | @xref{Mark}, for information about the region. |
| 521 | @item C-x = |
| 522 | Display the character code of character after point, character position of |
| 523 | point, and column of point (@code{what-cursor-position}). |
| 524 | @item M-x hl-line-mode |
| 525 | Enable or disable highlighting of the current line. @xref{Cursor |
| 526 | Display}. |
| 527 | @item M-x size-indication-mode |
| 528 | Toggle automatic display of the size of the buffer. |
| 529 | @xref{Optional Mode Line}. |
| 530 | @end table |
| 531 | |
| 532 | @findex what-page |
| 533 | @findex what-line |
| 534 | @cindex line number commands |
| 535 | @cindex location of point |
| 536 | @cindex cursor location |
| 537 | @cindex point location |
| 538 | @kbd{M-x what-line} displays the current line number in the echo |
| 539 | area. This command is usually redundant, because the current line |
| 540 | number is shown in the mode line (@pxref{Mode Line}). However, if you |
| 541 | narrow the buffer, the mode line shows the the line number relative to |
| 542 | the accessible portion (@pxref{Narrowing}). By contrast, |
| 543 | @code{what-line} displays both the line number relative to the |
| 544 | narrowed region and the line number relative to the whole buffer. |
| 545 | |
| 546 | @kbd{M-x what-page} counts pages from the beginning of the file, and |
| 547 | counts lines within the page, showing both numbers in the echo area. |
| 548 | @xref{Pages}. |
| 549 | |
| 550 | @kindex M-= |
| 551 | @findex count-lines-region |
| 552 | Use @kbd{M-=} (@code{count-lines-region}) to display the number of |
| 553 | lines in the region (@pxref{Mark}). @xref{Pages}, for the command |
| 554 | @kbd{C-x l} which counts the lines in the current page. |
| 555 | |
| 556 | @kindex C-x = |
| 557 | @findex what-cursor-position |
| 558 | The command @kbd{C-x =} (@code{what-cursor-position}) shows |
| 559 | information about the current cursor position and the buffer contents |
| 560 | at that position. It displays a line in the echo area that looks like |
| 561 | this: |
| 562 | |
| 563 | @smallexample |
| 564 | Char: c (99, #o143, #x63) point=28062 of 36168 (78%) column=53 |
| 565 | @end smallexample |
| 566 | |
| 567 | After @samp{Char:}, this shows the character in the buffer at point. |
| 568 | The text inside the parenthesis shows the corresponding decimal, octal |
| 569 | and hex character codes; for more information about how @kbd{C-x =} |
| 570 | displays character information, see @ref{International Chars}. After |
| 571 | @samp{point=} is the position of point as a character count (the first |
| 572 | character in the buffer is position 1, the second character is |
| 573 | position 2, and so on). The number after that is the total number of |
| 574 | characters in the buffer, and the number in parenthesis expresses the |
| 575 | position as a percentage of the total. After @samp{column=} is the |
| 576 | horizontal position of point, in columns counting from the left edge |
| 577 | of the window. |
| 578 | |
| 579 | If the buffer has been narrowed, making some of the text at the |
| 580 | beginning and the end temporarily inaccessible, @kbd{C-x =} displays |
| 581 | additional text describing the currently accessible range. For |
| 582 | example, it might display this: |
| 583 | |
| 584 | @smallexample |
| 585 | Char: C (67, #o103, #x43) point=252 of 889 (28%) <231-599> column=0 |
| 586 | @end smallexample |
| 587 | |
| 588 | @noindent |
| 589 | where the two extra numbers give the smallest and largest character |
| 590 | position that point is allowed to assume. The characters between |
| 591 | those two positions are the accessible ones. @xref{Narrowing}. |
| 592 | |
| 593 | @node Arguments |
| 594 | @section Numeric Arguments |
| 595 | @cindex numeric arguments |
| 596 | @cindex prefix arguments |
| 597 | @cindex arguments to commands |
| 598 | |
| 599 | In the terminology of mathematics and computing, @dfn{argument} |
| 600 | means ``data provided to a function or operation.'' You can give any |
| 601 | Emacs command a @dfn{numeric argument} (also called a @dfn{prefix |
| 602 | argument}). Some commands interpret the argument as a repetition |
| 603 | count. For example, giving @kbd{C-f} an argument of ten causes it to |
| 604 | move point forward by ten characters instead of one. With these |
| 605 | commands, no argument is equivalent to an argument of one, and |
| 606 | negative arguments cause them to move or act in the opposite |
| 607 | direction. |
| 608 | |
| 609 | @kindex M-1 |
| 610 | @kindex M-@t{-} |
| 611 | @findex digit-argument |
| 612 | @findex negative-argument |
| 613 | The easiest way to specify a numeric argument is to type a digit |
| 614 | and/or a minus sign while holding down the @key{META} key. For |
| 615 | example, |
| 616 | |
| 617 | @example |
| 618 | M-5 C-n |
| 619 | @end example |
| 620 | |
| 621 | @noindent |
| 622 | moves down five lines. The keys @kbd{M-1}, @kbd{M-2}, and so on, as |
| 623 | well as @kbd{M--}, are bound to commands (@code{digit-argument} and |
| 624 | @code{negative-argument}) that set up an argument for the next |
| 625 | command. @kbd{Meta--} without digits normally means @minus{}1. |
| 626 | |
| 627 | If you enter more than one digit, you need not hold down the |
| 628 | @key{META} key for the second and subsequent digits. Thus, to move |
| 629 | down fifty lines, type |
| 630 | |
| 631 | @example |
| 632 | M-5 0 C-n |
| 633 | @end example |
| 634 | |
| 635 | @noindent |
| 636 | Note that this @emph{does not} insert five copies of @samp{0} and move |
| 637 | down one line, as you might expect---the @samp{0} is treated as part |
| 638 | of the prefix argument. |
| 639 | |
| 640 | (What if you do want to insert five copies of @samp{0}? Type @kbd{M-5 |
| 641 | C-u 0}. Here, @kbd{C-u} ``terminates'' the prefix argument, so that |
| 642 | the next keystroke begins the command that you want to execute. Note |
| 643 | that this meaning of @kbd{C-u} applies only to this case. For the |
| 644 | usual role of @kbd{C-u}, see below.) |
| 645 | |
| 646 | @kindex C-u |
| 647 | @findex universal-argument |
| 648 | Instead of typing @kbd{M-1}, @kbd{M-2}, and so on, another way to |
| 649 | specify a numeric argument is to type @kbd{C-u} |
| 650 | (@code{universal-argument}) followed by some digits, or (for a |
| 651 | negative argument) a minus sign followed by digits. A minus sign |
| 652 | without digits normally means @minus{}1. |
| 653 | |
| 654 | @kbd{C-u} alone has the special meaning of ``four times'': it |
| 655 | multiplies the argument for the next command by four. @kbd{C-u C-u} |
| 656 | multiplies it by sixteen. Thus, @kbd{C-u C-u C-f} moves forward |
| 657 | sixteen characters. Other useful combinations are @kbd{C-u C-n}, |
| 658 | @kbd{C-u C-u C-n} (move down a good fraction of a screen), @kbd{C-u |
| 659 | C-u C-o} (make ``a lot'' of blank lines), and @kbd{C-u C-k} (kill four |
| 660 | lines). |
| 661 | |
| 662 | You can use a numeric argument before a self-inserting character to |
| 663 | insert multiple copies of it. This is straightforward when the |
| 664 | character is not a digit; for example, @kbd{C-u 6 4 a} inserts 64 |
| 665 | copies of the character @samp{a}. But this does not work for |
| 666 | inserting digits; @kbd{C-u 6 4 1} specifies an argument of 641. You |
| 667 | can separate the argument from the digit to insert with another |
| 668 | @kbd{C-u}; for example, @kbd{C-u 6 4 C-u 1} does insert 64 copies of |
| 669 | the character @samp{1}. |
| 670 | |
| 671 | Some commands care whether there is an argument, but ignore its |
| 672 | value. For example, the command @kbd{M-q} (@code{fill-paragraph}) |
| 673 | fills text; with an argument, it justifies the text as well. |
| 674 | (@xref{Filling}, for more information on @kbd{M-q}.) For these |
| 675 | commands, it is enough to the argument with a single @kbd{C-u}. |
| 676 | |
| 677 | Some commands use the value of the argument as a repeat count, but |
| 678 | do something special when there is no argument. For example, the |
| 679 | command @kbd{C-k} (@code{kill-line}) with argument @var{n} kills |
| 680 | @var{n} lines, including their terminating newlines. But @kbd{C-k} |
| 681 | with no argument is special: it kills the text up to the next newline, |
| 682 | or, if point is right at the end of the line, it kills the newline |
| 683 | itself. Thus, two @kbd{C-k} commands with no arguments can kill a |
| 684 | nonblank line, just like @kbd{C-k} with an argument of one. |
| 685 | (@xref{Killing}, for more information on @kbd{C-k}.) |
| 686 | |
| 687 | A few commands treat a plain @kbd{C-u} differently from an ordinary |
| 688 | argument. A few others may treat an argument of just a minus sign |
| 689 | differently from an argument of @minus{}1. These unusual cases are |
| 690 | described when they come up; they exist to make an individual command |
| 691 | more convenient, and they are documented in that command's |
| 692 | documentation string. |
| 693 | |
| 694 | We use the term ``prefix argument'' as well as ``numeric argument,'' |
| 695 | to emphasize that you type these argument before the command, and to |
| 696 | distinguish them from minibuffer arguments that come after the |
| 697 | command. |
| 698 | |
| 699 | @node Repeating |
| 700 | @section Repeating a Command |
| 701 | @cindex repeating a command |
| 702 | |
| 703 | Many simple commands, such as those invoked with a single key or |
| 704 | with @kbd{M-x @var{command-name} @key{RET}}, can be repeated by |
| 705 | invoking them with a numeric argument that serves as a repeat count |
| 706 | (@pxref{Arguments}). However, if the command you want to repeat |
| 707 | prompts for input, or uses a numeric argument in another way, that |
| 708 | method won't work. |
| 709 | |
| 710 | @kindex C-x z |
| 711 | @findex repeat |
| 712 | The command @kbd{C-x z} (@code{repeat}) provides another way to repeat |
| 713 | an Emacs command many times. This command repeats the previous Emacs |
| 714 | command, whatever that was. Repeating a command uses the same arguments |
| 715 | that were used before; it does not read new arguments each time. |
| 716 | |
| 717 | To repeat the command more than once, type additional @kbd{z}'s: each |
| 718 | @kbd{z} repeats the command one more time. Repetition ends when you |
| 719 | type a character other than @kbd{z}, or press a mouse button. |
| 720 | |
| 721 | For example, suppose you type @kbd{C-u 2 0 C-d} to delete 20 |
| 722 | characters. You can repeat that command (including its argument) three |
| 723 | additional times, to delete a total of 80 characters, by typing @kbd{C-x |
| 724 | z z z}. The first @kbd{C-x z} repeats the command once, and each |
| 725 | subsequent @kbd{z} repeats it once again. |
| 726 | |
| 727 | @ignore |
| 728 | arch-tag: cda8952a-c439-41c1-aecf-4bc0d6482956 |
| 729 | @end ignore |