Commit | Line | Data |
---|---|---|
8cf51b2c GM |
1 | @c This is part of the Emacs manual. |
2 | @c Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000, 2001, | |
3f548a7c | 3 | @c 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. |
8cf51b2c GM |
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 | To clear and redisplay the screen, type @kbd{C-l} (@code{recenter}). | |
16 | ||
17 | @menu | |
18 | ||
19 | * Inserting Text:: Inserting text by simply typing it. | |
20 | * Moving Point:: Moving the cursor to the place where you want to | |
21 | change something. | |
22 | * Erasing:: Deleting and killing text. | |
23 | * Basic 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:: Making and deleting blank lines. | |
27 | * Continuation Lines:: How Emacs displays 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 N times. | |
30 | * Repeating:: Repeating the previous command quickly. | |
31 | @end menu | |
32 | ||
33 | @node Inserting Text | |
34 | @section Inserting Text | |
35 | ||
36 | @cindex insertion | |
37 | @cindex graphic characters | |
38 | Typing printing characters inserts them into the text you are | |
39 | editing. It inserts them into the buffer at the cursor; more | |
40 | precisely, it inserts them at @dfn{point}, but the cursor normally | |
41 | shows where point is. @xref{Point}. | |
42 | ||
43 | Insertion moves the cursor forward, and the following text moves | |
44 | forward with the cursor. If the text in the buffer is @samp{FOOBAR}, | |
45 | with the cursor before the @samp{B}, and you type @kbd{XX}, you get | |
46 | @samp{FOOXXBAR}, with the cursor still before the @samp{B}. | |
47 | ||
48 | To @dfn{delete} text you have just inserted, use the large key | |
49 | labeled @key{DEL}, @key{BACKSPACE} or @key{DELETE} which is a short | |
50 | distance above the @key{RET} or @key{ENTER} key. Regardless of the | |
51 | label on that key, Emacs thinks of it as @key{DEL}, and that's what we | |
52 | call it in this manual. @key{DEL} is the key you normally use outside | |
53 | Emacs to erase the last character that you typed. | |
54 | ||
55 | The @key{DEL} key deletes the character @emph{before} the cursor. | |
56 | As a consequence, the cursor and all the characters after it move | |
57 | backwards. If you type a printing character and then type @key{DEL}, | |
58 | they cancel out. | |
59 | ||
60 | On most computers, Emacs sets up @key{DEL} automatically. In some | |
61 | cases, especially with text-only terminals, Emacs may guess wrong. If | |
62 | the key that ought to erase the last character doesn't do it in Emacs, | |
63 | see @ref{DEL Does Not Delete}. | |
64 | ||
65 | Most PC keyboards have both a @key{BACKSPACE} key a little ways | |
66 | above @key{RET} or @key{ENTER}, and a @key{DELETE} key elsewhere. On | |
67 | these keyboards, Emacs tries to set up @key{BACKSPACE} as @key{DEL}. | |
68 | The @key{DELETE} key deletes ``forwards'' like @kbd{C-d} (see below), | |
69 | which means it deletes the character underneath the cursor (after | |
70 | point). | |
71 | ||
72 | @kindex RET | |
73 | @cindex newline | |
74 | To end a line and start typing a new one, type @key{RET}. (This | |
75 | key may be labeled @key{RETURN} or @key{ENTER}, but in Emacs we call | |
76 | it @key{RET}.) This inserts a newline character in the buffer. If | |
77 | point is at the end of the line, this creates a new blank line after | |
78 | it. If point is in the middle of a line, the effect is to split that | |
79 | line. Typing @key{DEL} when the cursor is at the beginning of a line | |
80 | deletes the preceding newline character, thus joining the line with | |
81 | the one before it. | |
82 | ||
83 | Emacs can split lines automatically when they become too long, if | |
84 | you turn on a special minor mode called @dfn{Auto Fill} mode. | |
85 | @xref{Filling}, for Auto Fill mode and other methods of @dfn{filling} | |
86 | text. | |
87 | ||
88 | If you prefer printing characters to replace (overwrite) existing | |
89 | text, rather than shove it to the right, you should enable Overwrite | |
90 | mode, a minor mode. @xref{Minor Modes}. | |
91 | ||
92 | @cindex quoting | |
93 | @kindex C-q | |
94 | @findex quoted-insert | |
95 | Only printing characters and @key{SPC} insert themselves in Emacs. | |
96 | Other characters act as editing commands and do not insert themselves. | |
97 | These include control characters, and characters with codes above 200 | |
98 | octal. If you need to insert one of these characters in the buffer, | |
99 | you must @dfn{quote} it by typing the character @kbd{Control-q} | |
100 | (@code{quoted-insert}) first. (This character's name is normally | |
101 | written @kbd{C-q} for short.) There are two ways to use | |
102 | @kbd{C-q}: | |
103 | ||
104 | @itemize @bullet | |
105 | @item | |
106 | @kbd{C-q} followed by any non-graphic character (even @kbd{C-g}) | |
107 | inserts that character. | |
108 | ||
109 | @item | |
110 | @kbd{C-q} followed by a sequence of octal digits inserts the character | |
111 | with the specified octal character code. You can use any number of | |
112 | octal digits; any non-digit terminates the sequence. If the | |
113 | terminating character is @key{RET}, it serves only to terminate the | |
114 | sequence. Any other non-digit terminates the sequence and then acts | |
115 | as normal input---thus, @kbd{C-q 1 0 1 B} inserts @samp{AB}. | |
116 | ||
117 | The use of octal sequences is disabled in ordinary non-binary | |
118 | Overwrite mode, to give you a convenient way to insert a digit instead | |
119 | of overwriting with it. | |
120 | @end itemize | |
121 | ||
122 | @cindex 8-bit character codes | |
123 | @noindent | |
124 | When multibyte characters are enabled, if you specify a code in the | |
125 | range 0200 through 0377 octal, @kbd{C-q} assumes that you intend to | |
126 | use some ISO 8859-@var{n} character set, and converts the specified | |
127 | code to the corresponding Emacs character code. @xref{Enabling | |
128 | Multibyte}. You select @emph{which} of the ISO 8859 character sets to | |
129 | use through your choice of language environment (@pxref{Language | |
130 | Environments}). | |
131 | ||
132 | @vindex read-quoted-char-radix | |
133 | To use decimal or hexadecimal instead of octal, set the variable | |
134 | @code{read-quoted-char-radix} to 10 or 16. If the radix is greater than | |
135 | 10, some letters starting with @kbd{a} serve as part of a character | |
136 | code, just like digits. | |
137 | ||
138 | A numeric argument tells @kbd{C-q} how many copies of the quoted | |
139 | character to insert (@pxref{Arguments}). | |
140 | ||
141 | @findex newline | |
142 | @findex self-insert | |
143 | Customization information: @key{DEL} in most modes runs the command | |
144 | @code{delete-backward-char}; @key{RET} runs the command | |
145 | @code{newline}, and self-inserting printing characters run the command | |
146 | @code{self-insert}, which inserts whatever character you typed. Some | |
147 | major modes rebind @key{DEL} to other commands. | |
148 | ||
149 | @node Moving Point | |
150 | @section Changing the Location of Point | |
151 | ||
152 | @cindex arrow keys | |
153 | @cindex moving point | |
154 | @cindex movement | |
155 | @cindex cursor motion | |
156 | @cindex moving the cursor | |
157 | To do more than insert characters, you have to know how to move point | |
158 | (@pxref{Point}). The simplest way to do this is with arrow keys, or by | |
159 | clicking the left mouse button where you want to move to. | |
160 | ||
161 | There are also control and meta characters for cursor motion. Some | |
162 | are equivalent to the arrow keys (it is faster to use these control | |
163 | keys than move your hand over to the arrow keys). Others do more | |
164 | sophisticated things. | |
165 | ||
166 | @kindex C-a | |
167 | @kindex C-e | |
168 | @kindex C-f | |
169 | @kindex C-b | |
170 | @kindex C-n | |
171 | @kindex C-p | |
172 | @kindex M-> | |
173 | @kindex M-< | |
174 | @kindex M-r | |
175 | @kindex LEFT | |
176 | @kindex RIGHT | |
177 | @kindex UP | |
178 | @kindex DOWN | |
179 | @findex move-beginning-of-line | |
180 | @findex move-end-of-line | |
181 | @findex forward-char | |
182 | @findex backward-char | |
183 | @findex next-line | |
184 | @findex previous-line | |
185 | @findex beginning-of-buffer | |
186 | @findex end-of-buffer | |
187 | @findex goto-char | |
188 | @findex goto-line | |
189 | @findex move-to-window-line | |
190 | @table @kbd | |
191 | @item C-a | |
192 | Move to the beginning of the line (@code{move-beginning-of-line}). | |
193 | @item C-e | |
194 | Move to the end of the line (@code{move-end-of-line}). | |
195 | @item C-f | |
196 | Move forward one character (@code{forward-char}). The right-arrow key | |
197 | does the same thing. | |
198 | @item C-b | |
199 | Move backward one character (@code{backward-char}). The left-arrow | |
200 | key has the same effect. | |
201 | @item M-f | |
202 | Move forward one word (@code{forward-word}). | |
203 | @item M-b | |
204 | Move backward one word (@code{backward-word}). | |
205 | @item C-n | |
206 | Move down one line vertically (@code{next-line}). This command | |
207 | attempts to keep the horizontal position unchanged, so if you start in | |
208 | the middle of one line, you move to the middle of the next. The | |
209 | down-arrow key does the same thing. | |
210 | @item C-p | |
211 | Move up one line, vertically (@code{previous-line}). The up-arrow key | |
212 | has the same effect. This command preserves position within the line, | |
213 | like @kbd{C-n}. | |
214 | @item M-r | |
215 | Move point to left margin, vertically centered in the window | |
216 | (@code{move-to-window-line}). Text does not move on the screen. | |
217 | A numeric argument says which screen line to place point on, counting | |
218 | downward from the top of the window (zero means the top line). A | |
219 | negative argument counts lines up from the bottom (@minus{}1 means the | |
220 | bottom line). | |
221 | @item M-< | |
222 | Move to the top of the buffer (@code{beginning-of-buffer}). With | |
223 | numeric argument @var{n}, move to @var{n}/10 of the way from the top. | |
224 | @xref{Arguments}, for more information on numeric arguments.@refill | |
225 | @item M-> | |
226 | Move to the end of the buffer (@code{end-of-buffer}). | |
227 | @item C-v | |
228 | @itemx @key{PAGEDOWN} | |
229 | @itemx @key{PRIOR} | |
230 | Scroll the display one screen forward, and move point if necessary to | |
231 | put it on the screen (@code{scroll-up}). This doesn't always move | |
232 | point, but it is commonly used to do so. If your keyboard has a | |
233 | @key{PAGEDOWN} or @key{PRIOR} key, it does the same thing. | |
234 | ||
235 | Scrolling commands are described further in @ref{Scrolling}. | |
236 | @item M-v | |
237 | @itemx @key{PAGEUP} | |
238 | @itemx @key{NEXT} | |
239 | Scroll one screen backward, and move point if necessary to put it on | |
240 | the screen (@code{scroll-down}). This doesn't always move point, but | |
241 | it is commonly used to do so. If your keyboard has a @key{PAGEUP} or | |
242 | @key{NEXT} key, it does the same thing. | |
243 | @item M-x goto-char | |
244 | Read a number @var{n} and move point to buffer position @var{n}. | |
245 | Position 1 is the beginning of the buffer. | |
246 | @item M-g M-g | |
247 | @itemx M-g g | |
248 | @itemx M-x goto-line | |
249 | Read a number @var{n} and move point to the beginning of line number | |
250 | @var{n}. Line 1 is the beginning of the buffer. If point is on or | |
251 | just after a number in the buffer, and you type @key{RET} with the | |
252 | minibuffer empty, that number is used for @var{n}. | |
253 | @item C-x C-n | |
254 | @findex set-goal-column | |
255 | @kindex C-x C-n | |
256 | Use the current column of point as the @dfn{semipermanent goal column} | |
257 | for @kbd{C-n} and @kbd{C-p} (@code{set-goal-column}). When a | |
258 | semipermanent goal column is in effect, those commands always try to | |
259 | move to this column, or as close as possible to it, after moving | |
260 | vertically. The goal column remains in effect until canceled. | |
261 | @item C-u C-x C-n | |
262 | Cancel the goal column. Henceforth, @kbd{C-n} and @kbd{C-p} try to | |
263 | preserve the horizontal position, as usual. | |
264 | @end table | |
265 | ||
266 | @vindex track-eol | |
267 | If you set the variable @code{track-eol} to a non-@code{nil} value, | |
268 | then @kbd{C-n} and @kbd{C-p}, when starting at the end of the line, move | |
269 | to the end of another line. Normally, @code{track-eol} is @code{nil}. | |
270 | @xref{Variables}, for how to set variables such as @code{track-eol}. | |
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 | Delete the character before point (@code{delete-backward-char}). | |
285 | @item C-d | |
286 | Delete the character after point (@code{delete-char}). | |
287 | @item @key{DELETE} | |
288 | @itemx @key{BACKSPACE} | |
289 | One of these keys, whichever is the large key above the @key{RET} or | |
290 | @key{ENTER} key, deletes the character before point---it is @key{DEL}. | |
291 | If @key{BACKSPACE} is @key{DEL}, and your keyboard also has @key{DELETE}, | |
292 | then @key{DELETE} deletes forwards, like @kbd{C-d}. | |
293 | @item C-k | |
294 | Kill to the end of the line (@code{kill-line}). | |
295 | @item M-d | |
296 | Kill forward to the end of the next word (@code{kill-word}). | |
297 | @item M-@key{DEL} | |
298 | Kill back to the beginning of the previous word | |
299 | (@code{backward-kill-word}). | |
300 | @end table | |
301 | ||
302 | @cindex killing characters and lines | |
303 | @cindex deleting characters and lines | |
304 | @cindex erasing characters and lines | |
305 | You already know about the @key{DEL} key which deletes the character | |
306 | before point (that is, before the cursor). Another key, @kbd{Control-d} | |
307 | (@kbd{C-d} for short), deletes the character after point (that is, the | |
308 | character that the cursor is on). This shifts the rest of the text on | |
309 | the line to the left. If you type @kbd{C-d} at the end of a line, it | |
310 | joins that line with the following line. | |
311 | ||
312 | To erase a larger amount of text, use the @kbd{C-k} key, which | |
313 | erases (kills) a line at a time. If you type @kbd{C-k} at the | |
314 | beginning or middle of a line, it kills all the text up to the end of | |
315 | the line. If you type @kbd{C-k} at the end of a line, it joins that | |
316 | line with the following line. | |
317 | ||
318 | @xref{Killing}, for more flexible ways of killing text. | |
319 | ||
320 | @node Basic Undo | |
321 | @section Undoing Changes | |
322 | ||
323 | Emacs records a list of changes made in the buffer text, so you can | |
72463824 GM |
324 | undo recent changes, as far as the records go. Usually each editing |
325 | command makes a separate entry in the undo records, but sometimes an | |
326 | entry covers just part of a command, and very simple commands may be | |
327 | grouped. | |
8cf51b2c GM |
328 | |
329 | @table @kbd | |
330 | @item C-x u | |
331 | Undo one entry of the undo records---usually, one command worth | |
332 | (@code{undo}). | |
333 | @item C-_ | |
334 | @itemx C-/ | |
335 | The same. | |
336 | @end table | |
337 | ||
338 | The command @kbd{C-x u} (or @kbd{C-_} or @kbd{C-/}) is how you undo. | |
339 | Normally this command undoes the last change, and moves point back to | |
340 | where it was before the change. | |
341 | ||
342 | If you repeat @kbd{C-x u} (or its aliases), each repetition undoes | |
343 | another, earlier change, back to the limit of the undo information | |
344 | available. If all recorded changes have already been undone, the undo | |
345 | command displays an error message and does nothing. | |
346 | ||
347 | The undo command applies only to changes in the buffer; you can't | |
be6c3e88 | 348 | use it to undo mere cursor motion. |
8cf51b2c GM |
349 | |
350 | @node Basic Files | |
351 | @section Files | |
352 | ||
353 | Text that you insert in an Emacs buffer lasts only as long as the | |
354 | Emacs session. To keep any text permanently you must put it in a | |
355 | @dfn{file}. Files are named units of text which are stored by the | |
356 | operating system for you to retrieve later by name. To use the | |
357 | contents of a file in any way, you must specify the file name. That | |
358 | includes editing the file with Emacs. | |
359 | ||
360 | Suppose there is a file named @file{test.emacs} in your home | |
361 | directory. To begin editing this file in Emacs, type | |
362 | ||
363 | @example | |
364 | C-x C-f test.emacs @key{RET} | |
365 | @end example | |
366 | ||
367 | @noindent | |
368 | Here the file name is given as an @dfn{argument} to the command @kbd{C-x | |
369 | C-f} (@code{find-file}). That command uses the @dfn{minibuffer} to | |
370 | read the argument, and you type @key{RET} to terminate the argument | |
371 | (@pxref{Minibuffer}). | |
372 | ||
373 | Emacs obeys this command by @dfn{visiting} the file: it creates a | |
374 | buffer, it copies the contents of the file into the buffer, and then | |
375 | displays the buffer for editing. If you alter the text, you can | |
376 | @dfn{save} the new text in the file by typing @kbd{C-x C-s} | |
377 | (@code{save-buffer}). This copies the altered buffer contents back | |
378 | into the file @file{test.emacs}, making them permanent. Until you | |
379 | save, the changed text exists only inside Emacs, and the file | |
380 | @file{test.emacs} is unaltered. | |
381 | ||
382 | To create a file, just visit it with @kbd{C-x C-f} as if it already | |
383 | existed. This creates an empty buffer, in which you can insert the | |
384 | text you want to put in the file. Emacs actually creates the file the | |
385 | first time you save this buffer with @kbd{C-x C-s}. | |
386 | ||
387 | To learn more about using files in Emacs, see @ref{Files}. | |
388 | ||
389 | @node Basic Help | |
390 | @section Help | |
391 | ||
392 | @cindex getting help with keys | |
393 | If you forget what a key does, you can find out with the Help | |
394 | character, which is @kbd{C-h} (or @key{F1}, which is an alias for | |
395 | @kbd{C-h}). Type @kbd{C-h k} followed by the key of interest; for | |
396 | example, @kbd{C-h k C-n} tells you what @kbd{C-n} does. @kbd{C-h} is | |
397 | a prefix key; @kbd{C-h k} is just one of its subcommands (the command | |
398 | @code{describe-key}). The other subcommands of @kbd{C-h} provide | |
399 | different kinds of help. Type @kbd{C-h} twice to get a description of | |
400 | all the help facilities. @xref{Help}. | |
401 | ||
402 | @node Blank Lines | |
403 | @section Blank Lines | |
404 | ||
405 | @cindex inserting blank lines | |
406 | @cindex deleting blank lines | |
407 | Here are special commands and techniques for inserting and deleting | |
408 | blank lines. | |
409 | ||
410 | @table @kbd | |
411 | @item C-o | |
412 | Insert one or more blank lines after the cursor (@code{open-line}). | |
413 | @item C-x C-o | |
414 | Delete all but one of many consecutive blank lines | |
415 | (@code{delete-blank-lines}). | |
416 | @end table | |
417 | ||
418 | @kindex C-o | |
419 | @kindex C-x C-o | |
420 | @cindex blank lines | |
421 | @findex open-line | |
422 | @findex delete-blank-lines | |
423 | To insert a new line of text before an existing line, | |
424 | type the new line of text, followed by @key{RET}. | |
425 | However, it may be easier to see what you are doing if you first make a | |
426 | blank line and then insert the desired text into it. This is easy to do | |
427 | using the key @kbd{C-o} (@code{open-line}), which inserts a newline | |
428 | after point but leaves point in front of the newline. After @kbd{C-o}, | |
429 | type the text for the new line. @kbd{C-o F O O} has the same effect as | |
430 | @w{@kbd{F O O @key{RET}}}, except for the final location of point. | |
431 | ||
432 | You can make several blank lines by typing @kbd{C-o} several times, or | |
433 | by giving it a numeric argument specifying how many blank lines to make. | |
434 | @xref{Arguments}, for how. If you have a fill prefix, the @kbd{C-o} | |
435 | command inserts the fill prefix on the new line, if typed at the | |
436 | beginning of a line. @xref{Fill Prefix}. | |
437 | ||
438 | The easy way to get rid of extra blank lines is with the command | |
439 | @kbd{C-x C-o} (@code{delete-blank-lines}). @kbd{C-x C-o} in a run of | |
440 | several blank lines deletes all but one of them. @kbd{C-x C-o} on a | |
441 | lone blank line deletes that one. When point is on a nonblank line, | |
442 | @kbd{C-x C-o} deletes all following blank lines (if any). | |
443 | ||
444 | @node Continuation Lines | |
445 | @section Continuation Lines | |
446 | ||
447 | @cindex continuation line | |
448 | @cindex wrapping | |
449 | @cindex line wrapping | |
450 | @cindex fringes, and continuation lines | |
451 | When a text line is too long to fit in one screen line, Emacs | |
452 | displays it on two or more screen lines. This is called | |
453 | @dfn{continuation} or @dfn{line wrapping}. On graphical displays, | |
454 | Emacs indicates line wrapping with small bent arrows in the left and | |
455 | right window fringes. On text-only terminals, Emacs displays a | |
456 | @samp{\} character at the right margin of a screen line if it is not | |
457 | the last in its text line. This @samp{\} character says that the | |
458 | following screen line is not really a new text line. | |
459 | ||
460 | When line wrapping occurs just before a character that is wider than one | |
461 | column, some columns at the end of the previous screen line may be | |
462 | ``empty.'' In this case, Emacs displays additional @samp{\} | |
463 | characters in the ``empty'' columns before the @samp{\} | |
464 | character that indicates continuation. | |
465 | ||
466 | Continued lines can be difficult to read, since lines can break in | |
467 | the middle of a word. If you prefer, you can make Emacs insert a | |
468 | newline automatically when a line gets too long, by using Auto Fill | |
469 | mode. Or enable Long Lines mode, which ensures that wrapping only | |
470 | occurs between words. @xref{Filling}. | |
471 | ||
472 | @cindex truncation | |
473 | @cindex line truncation, and fringes | |
474 | Emacs can optionally @dfn{truncate} long lines---this means | |
475 | displaying just one screen line worth, and the rest of the long line | |
476 | does not appear at all. @samp{$} in the last column or a small | |
477 | straight arrow in the window's right fringe indicates a truncated | |
478 | line. | |
479 | ||
480 | @xref{Line Truncation}, for more about line truncation, | |
481 | and other variables that control how text is displayed. | |
482 | ||
483 | @node Position Info | |
484 | @section Cursor Position Information | |
485 | ||
486 | Here are commands to get information about the size and position of | |
487 | parts of the buffer, and to count lines. | |
488 | ||
489 | @table @kbd | |
490 | @item M-x what-page | |
491 | Display the page number of point, and the line number within that page. | |
492 | @item M-x what-line | |
493 | Display the line number of point in the whole buffer. | |
494 | @item M-x line-number-mode | |
495 | @itemx M-x column-number-mode | |
496 | Toggle automatic display of the current line number or column number. | |
497 | @xref{Optional Mode Line}. | |
498 | @item M-= | |
499 | Display the number of lines in the current region (@code{count-lines-region}). | |
500 | @xref{Mark}, for information about the region. | |
501 | @item C-x = | |
502 | Display the character code of character after point, character position of | |
503 | point, and column of point (@code{what-cursor-position}). | |
504 | @item M-x hl-line-mode | |
505 | Enable or disable highlighting of the current line. @xref{Cursor | |
506 | Display}. | |
507 | @item M-x size-indication-mode | |
508 | Toggle automatic display of the size of the buffer. | |
509 | @xref{Optional Mode Line}. | |
510 | @end table | |
511 | ||
512 | @findex what-page | |
513 | @findex what-line | |
514 | @cindex line number commands | |
515 | @cindex location of point | |
516 | @cindex cursor location | |
517 | @cindex point location | |
518 | @kbd{M-x what-line} displays the current line number | |
519 | in the echo area. You can also see the current line number in the | |
520 | mode line; see @ref{Mode Line}; but if you narrow the buffer, the | |
521 | line number in the mode line is relative to the accessible portion | |
522 | (@pxref{Narrowing}). By contrast, @code{what-line} shows both the | |
523 | line number relative to the narrowed region and the line number | |
524 | relative to the whole buffer. | |
525 | ||
526 | @kbd{M-x what-page} counts pages from the beginning of the file, and | |
527 | counts lines within the page, showing both numbers in the echo area. | |
528 | @xref{Pages}. | |
529 | ||
530 | @kindex M-= | |
531 | @findex count-lines-region | |
be6c3e88 | 532 | Use @kbd{M-=} (@code{count-lines-region}) to display the number of |
8cf51b2c GM |
533 | lines in the region (@pxref{Mark}). @xref{Pages}, for the command |
534 | @kbd{C-x l} which counts the lines in the current page. | |
535 | ||
536 | @kindex C-x = | |
537 | @findex what-cursor-position | |
538 | The command @kbd{C-x =} (@code{what-cursor-position}) shows what | |
539 | cursor's column position, and other information about point and the | |
540 | character after it. It displays a line in the echo area that looks | |
541 | like this: | |
542 | ||
543 | @smallexample | |
544 | Char: c (99, #o143, #x63) point=28062 of 36168 (78%) column=53 | |
545 | @end smallexample | |
546 | ||
547 | The four values after @samp{Char:} describe the character that follows | |
548 | point, first by showing it and then by giving its character code in | |
549 | decimal, octal and hex. For a non-@acronym{ASCII} multibyte character, these are | |
550 | followed by @samp{file} and the character's representation, in hex, in | |
551 | the buffer's coding system, if that coding system encodes the character | |
552 | safely and with a single byte (@pxref{Coding Systems}). If the | |
553 | character's encoding is longer than one byte, Emacs shows @samp{file ...}. | |
554 | ||
555 | However, if the character displayed is in the range 0200 through | |
556 | 0377 octal, it may actually stand for an invalid UTF-8 byte read from | |
557 | a file. In Emacs, that byte is represented as a sequence of 8-bit | |
558 | characters, but all of them together display as the original invalid | |
559 | byte, in octal code. In this case, @kbd{C-x =} shows @samp{part of | |
560 | display ...} instead of @samp{file}. | |
561 | ||
562 | @samp{point=} is followed by the position of point expressed as a | |
563 | character count. The start of the buffer is position 1, one character | |
564 | later is position 2, and so on. The next, larger, number is the total | |
565 | number of characters in the buffer. Afterward in parentheses comes | |
566 | the position expressed as a percentage of the total size. | |
567 | ||
568 | @samp{column=} is followed by the horizontal position of point, in | |
569 | columns from the left edge of the window. | |
570 | ||
571 | If the buffer has been narrowed, making some of the text at the | |
572 | beginning and the end temporarily inaccessible, @kbd{C-x =} displays | |
573 | additional text describing the currently accessible range. For example, it | |
574 | might display this: | |
575 | ||
576 | @smallexample | |
577 | Char: C (67, #o103, #x43) point=252 of 889 (28%) <231-599> column=0 | |
578 | @end smallexample | |
579 | ||
580 | @noindent | |
581 | where the two extra numbers give the smallest and largest character | |
582 | position that point is allowed to assume. The characters between those | |
583 | two positions are the accessible ones. @xref{Narrowing}. | |
584 | ||
585 | If point is at the end of the buffer (or the end of the accessible | |
586 | part), the @w{@kbd{C-x =}} output does not describe a character after | |
587 | point. The output might look like this: | |
588 | ||
589 | @smallexample | |
590 | point=36169 of 36168 (EOB) column=0 | |
591 | @end smallexample | |
592 | ||
593 | @cindex character set of character at point | |
594 | @cindex font of character at point | |
595 | @cindex text properties at point | |
596 | @cindex face at point | |
597 | @w{@kbd{C-u C-x =}} displays the following additional information about a | |
598 | character. | |
599 | ||
600 | @itemize @bullet | |
601 | @item | |
602 | The character set name, and the codes that identify the character | |
603 | within that character set; @acronym{ASCII} characters are identified | |
604 | as belonging to the @code{ascii} character set. | |
605 | ||
606 | @item | |
607 | The character's syntax and categories. | |
608 | ||
609 | @item | |
610 | The character's encodings, both internally in the buffer, and externally | |
611 | if you were to save the file. | |
612 | ||
613 | @item | |
614 | What keys to type to input the character in the current input method | |
615 | (if it supports the character). | |
616 | ||
617 | @item | |
618 | If you are running Emacs on a graphical display, the font name and | |
619 | glyph code for the character. If you are running Emacs on a text-only | |
620 | terminal, the code(s) sent to the terminal. | |
621 | ||
622 | @item | |
623 | The character's text properties (@pxref{Text Properties,,, | |
624 | elisp, the Emacs Lisp Reference Manual}), including any non-default | |
625 | faces used to display the character, and any overlays containing it | |
626 | (@pxref{Overlays,,, elisp, the same manual}). | |
627 | @end itemize | |
628 | ||
629 | Here's an example showing the Latin-1 character A with grave accent, | |
630 | in a buffer whose coding system is @code{iso-latin-1}, whose | |
631 | terminal coding system is @code{iso-latin-1} (so the terminal actually | |
632 | displays the character as @samp{@`A}), and which has font-lock-mode | |
633 | (@pxref{Font Lock}) enabled: | |
634 | ||
635 | @smallexample | |
636 | character: @`A (2240, #o4300, #x8c0, U+00C0) | |
637 | charset: latin-iso8859-1 | |
638 | (Right-Hand Part of Latin Alphabet 1@dots{} | |
639 | code point: #x40 | |
640 | syntax: w which means: word | |
641 | category: l:Latin | |
642 | to input: type "`A" with latin-1-prefix | |
643 | buffer code: #x81 #xC0 | |
644 | file code: #xC0 (encoded by coding system iso-latin-1) | |
645 | display: terminal code #xC0 | |
646 | ||
647 | There are text properties here: | |
648 | fontified t | |
649 | @end smallexample | |
650 | ||
651 | @node Arguments | |
652 | @section Numeric Arguments | |
653 | @cindex numeric arguments | |
654 | @cindex prefix arguments | |
655 | @cindex arguments to commands | |
656 | ||
657 | In mathematics and computer usage, @dfn{argument} means | |
658 | ``data provided to a function or operation.'' You can give any Emacs | |
659 | command a @dfn{numeric argument} (also called a @dfn{prefix argument}). | |
660 | Some commands interpret the argument as a repetition count. For | |
661 | example, @kbd{C-f} with an argument of ten moves forward ten characters | |
662 | instead of one. With these commands, no argument is equivalent to an | |
663 | argument of one. Negative arguments tell most such commands to move or | |
664 | act in the opposite direction. | |
665 | ||
666 | @kindex M-1 | |
667 | @kindex M-@t{-} | |
668 | @findex digit-argument | |
669 | @findex negative-argument | |
670 | If your terminal keyboard has a @key{META} key (labeled @key{ALT} on | |
671 | PC keyboards), the easiest way to specify a numeric argument is to | |
672 | type digits and/or a minus sign while holding down the @key{META} key. | |
673 | For example, | |
674 | ||
675 | @example | |
676 | M-5 C-n | |
677 | @end example | |
678 | ||
679 | @noindent | |
680 | moves down five lines. The characters @kbd{Meta-1}, @kbd{Meta-2}, | |
681 | and so on, as well as @kbd{Meta--}, do this because they are keys bound | |
682 | to commands (@code{digit-argument} and @code{negative-argument}) that | |
683 | are defined to set up an argument for the next command. | |
684 | @kbd{Meta--} without digits normally means @minus{}1. Digits and | |
685 | @kbd{-} modified with Control, or Control and Meta, also specify numeric | |
686 | arguments. | |
687 | ||
688 | @kindex C-u | |
689 | @findex universal-argument | |
690 | You can also specify a numeric argument by typing @kbd{C-u} | |
691 | (@code{universal-argument}) followed by the digits. The advantage of | |
692 | @kbd{C-u} is that you can type the digits without modifier keys; thus, | |
693 | @kbd{C-u} works on all terminals. For a negative argument, type a | |
694 | minus sign after @kbd{C-u}. A minus sign without digits normally | |
695 | means @minus{}1. | |
696 | ||
697 | @kbd{C-u} alone has the special meaning of | |
698 | ``four times'': it multiplies the argument for the next command by | |
699 | four. @kbd{C-u C-u} multiplies it by sixteen. Thus, @kbd{C-u C-u | |
700 | C-f} moves forward sixteen characters. This is a good way to move | |
701 | forward ``fast,'' since it moves about 1/5 of a line in the usual size | |
702 | screen. Other useful combinations are @kbd{C-u C-n}, @kbd{C-u C-u | |
703 | C-n} (move down a good fraction of a screen), @kbd{C-u C-u C-o} (make | |
704 | ``a lot'' of blank lines), and @kbd{C-u C-k} (kill four lines). | |
705 | ||
706 | Some commands care whether there is an argument, but ignore its | |
f0a35bd4 | 707 | value. For example, the command @kbd{M-q} (@code{fill-paragraph}) |
8cf51b2c GM |
708 | fills text; with an argument, it justifies the text as well. |
709 | (@xref{Filling}, for more information on @kbd{M-q}.) Plain @kbd{C-u} | |
710 | is a handy way of providing an argument for such commands. | |
711 | ||
712 | Some commands use the value of the argument as a repeat count, but do | |
713 | something peculiar when there is no argument. For example, the command | |
714 | @kbd{C-k} (@code{kill-line}) with argument @var{n} kills @var{n} lines, | |
715 | including their terminating newlines. But @kbd{C-k} with no argument is | |
716 | special: it kills the text up to the next newline, or, if point is right at | |
717 | the end of the line, it kills the newline itself. Thus, two @kbd{C-k} | |
718 | commands with no arguments can kill a nonblank line, just like @kbd{C-k} | |
719 | with an argument of one. (@xref{Killing}, for more information on | |
720 | @kbd{C-k}.) | |
721 | ||
722 | A few commands treat a plain @kbd{C-u} differently from an ordinary | |
723 | argument. A few others may treat an argument of just a minus sign | |
724 | differently from an argument of @minus{}1. These unusual cases are | |
725 | described when they come up; they exist to make an individual command | |
726 | more convenient, and they are documented in that command's | |
727 | documentation string. | |
728 | ||
729 | You can use a numeric argument before a self-inserting character to | |
730 | insert multiple copies of it. This is straightforward when the | |
731 | character is not a digit; for example, @kbd{C-u 6 4 a} inserts 64 | |
732 | copies of the character @samp{a}. But this does not work for | |
733 | inserting digits; @kbd{C-u 6 4 1} specifies an argument of 641. You | |
734 | can separate the argument from the digit to insert with another | |
735 | @kbd{C-u}; for example, @kbd{C-u 6 4 C-u 1} does insert 64 copies of | |
736 | the character @samp{1}. | |
737 | ||
738 | We use the term ``prefix argument'' as well as ``numeric argument,'' | |
739 | to emphasize that you type these argument before the command, and to | |
740 | distinguish them from minibuffer arguments that come after the | |
741 | command. | |
742 | ||
743 | @node Repeating | |
744 | @section Repeating a Command | |
745 | @cindex repeating a command | |
746 | ||
747 | Many simple commands, such as those invoked with a single key or | |
748 | with @kbd{M-x @var{command-name} @key{RET}}, can be repeated by | |
749 | invoking them with a numeric argument that serves as a repeat count | |
750 | (@pxref{Arguments}). However, if the command you want to repeat | |
751 | prompts for input, or uses a numeric argument in another way, that | |
752 | method won't work. | |
753 | ||
754 | @kindex C-x z | |
755 | @findex repeat | |
756 | The command @kbd{C-x z} (@code{repeat}) provides another way to repeat | |
757 | an Emacs command many times. This command repeats the previous Emacs | |
758 | command, whatever that was. Repeating a command uses the same arguments | |
759 | that were used before; it does not read new arguments each time. | |
760 | ||
761 | To repeat the command more than once, type additional @kbd{z}'s: each | |
762 | @kbd{z} repeats the command one more time. Repetition ends when you | |
763 | type a character other than @kbd{z}, or press a mouse button. | |
764 | ||
765 | For example, suppose you type @kbd{C-u 2 0 C-d} to delete 20 | |
766 | characters. You can repeat that command (including its argument) three | |
767 | additional times, to delete a total of 80 characters, by typing @kbd{C-x | |
768 | z z z}. The first @kbd{C-x z} repeats the command once, and each | |
769 | subsequent @kbd{z} repeats it once again. | |
770 | ||
771 | @ignore | |
772 | arch-tag: cda8952a-c439-41c1-aecf-4bc0d6482956 | |
773 | @end ignore |