|
442
|
1 @c This is part of the XEmacs manual.
|
|
|
2 @c Copyright (C) 1985, 86, 87, 93, 94, 95, 1997 Free Software Foundation, Inc.
|
|
|
3 @c See file xemacs.texi for copying conditions.
|
|
444
|
4 @node Basic, Undo, Packages, Top
|
|
428
|
5 @chapter Basic Editing Commands
|
|
|
6
|
|
|
7 @kindex C-h t
|
|
|
8 @findex help-with-tutorial
|
|
|
9 We now give the basics of how to enter text, make corrections, and
|
|
|
10 save the text in a file. If this material is new to you, you might
|
|
|
11 learn it more easily by running the Emacs learn-by-doing tutorial. To
|
|
442
|
12 use the tutorial, run Emacs and type @kbd{Control-h t}
|
|
|
13 (@code{help-with-tutorial}). You can also use @b{Tutorials} item from
|
|
|
14 the @b{Help} menu.
|
|
|
15
|
|
|
16 XEmacs comes with many translations of tutorial. If your XEmacs is with
|
|
|
17 MULE and you set up language environment correctly, XEmacs chooses right
|
|
|
18 tutorial when available (@pxref{Language Environments}). If you want
|
|
|
19 specific translation, give @kbd{C-h t} a prefix argument, like @kbd{C-u
|
|
|
20 C-h t}.
|
|
|
21
|
|
|
22 To clear the screen and redisplay, type @kbd{C-l} (@code{recenter}).
|
|
|
23
|
|
|
24 @menu
|
|
428
|
25
|
|
442
|
26 * Inserting Text:: Inserting text by simply typing it.
|
|
|
27 * Moving Point:: How to move the cursor to the place where you want to
|
|
|
28 change something.
|
|
|
29 * Erasing:: Deleting and killing text.
|
|
|
30 * Files: Basic Files. Visiting, creating, and saving files.
|
|
|
31 * Help: Basic Help. Asking what a character does.
|
|
|
32 * Blank Lines:: Commands to make or delete blank lines.
|
|
|
33 * Continuation Lines:: Lines too wide for the screen.
|
|
|
34 * Position Info:: What page, line, row, or column is point on?
|
|
|
35 * Arguments:: Numeric arguments for repeating a command.
|
|
|
36 @c * Repeating:: A short-cut for repeating the previous command.
|
|
|
37 @end menu
|
|
|
38
|
|
|
39 @node Inserting Text, Moving Point, , Basic
|
|
428
|
40 @section Inserting Text
|
|
|
41
|
|
|
42 @cindex insertion
|
|
|
43 @cindex point
|
|
|
44 @cindex cursor
|
|
|
45 @cindex graphic characters
|
|
|
46 To insert printing characters into the text you are editing, just type
|
|
442
|
47 them. This inserts the characters you type into the buffer at the
|
|
|
48 cursor (that is, at @dfn{point}; @pxref{Point}). The cursor moves
|
|
|
49 forward, and any text after the cursor moves forward too. If the text
|
|
|
50 in the buffer is @samp{FOOBAR}, with the cursor before the @samp{B},
|
|
|
51 then if you type @kbd{XX}, you get @samp{FOOXXBAR}, with the cursor
|
|
|
52 still before the @samp{B}.
|
|
428
|
53
|
|
442
|
54 @kindex BS
|
|
428
|
55 @cindex deletion
|
|
442
|
56 To @dfn{delete} text you have just inserted, use @key{BS}. @key{BS}
|
|
|
57 deletes the character @emph{before} the cursor (not the one that the
|
|
|
58 cursor is on top of or under; that is the character @var{after} the
|
|
|
59 cursor). The cursor and all characters after it move backwards.
|
|
|
60 Therefore, if you type a printing character and then type @key{BS}, they
|
|
|
61 cancel out.
|
|
428
|
62
|
|
|
63 @kindex RET
|
|
|
64 @cindex newline
|
|
|
65 To end a line and start typing a new one, type @key{RET}. This
|
|
|
66 inserts a newline character in the buffer. If point is in the middle of
|
|
|
67 a line, @key{RET} splits the line. Typing @key{DEL} when the cursor is
|
|
442
|
68 at the beginning of a line deletes the preceding newline, thus joining
|
|
|
69 the line with the preceding line.
|
|
428
|
70
|
|
442
|
71 Emacs can split lines automatically when they become too long, if you
|
|
|
72 turn on a special minor mode called @dfn{Auto Fill} mode.
|
|
|
73 @xref{Filling}, for how to use Auto Fill mode.
|
|
|
74
|
|
|
75 If you prefer to have text characters replace (overwrite) existing
|
|
|
76 text rather than shove it to the right, you can enable Overwrite mode,
|
|
|
77 a minor mode. @xref{Minor Modes}.
|
|
428
|
78
|
|
|
79 @cindex quoting
|
|
|
80 @kindex C-q
|
|
|
81 @findex quoted-insert
|
|
442
|
82 Direct insertion works for printing characters and @key{SPC}, but other
|
|
|
83 characters act as editing commands and do not insert themselves. If you
|
|
|
84 need to insert a control character or a character whose code is above 200
|
|
|
85 octal, you must @dfn{quote} it by typing the character @kbd{Control-q}
|
|
|
86 (@code{quoted-insert}) first. (This character's name is normally written
|
|
|
87 @kbd{C-q} for short.) There are two ways to use @kbd{C-q}:
|
|
428
|
88
|
|
|
89 @itemize @bullet
|
|
|
90 @item
|
|
442
|
91 @kbd{C-q} followed by any non-graphic character (even @kbd{C-g})
|
|
428
|
92 inserts that character.
|
|
442
|
93
|
|
428
|
94 @item
|
|
442
|
95 @kbd{C-q} followed by a sequence of octal digits inserts the character
|
|
|
96 with the specified octal character code. You can use any number of
|
|
|
97 octal digits; any non-digit terminates the sequence. If the terminating
|
|
|
98 character is @key{RET}, it serves only to terminate the sequence; any
|
|
|
99 other non-digit is itself used as input after terminating the sequence.
|
|
|
100 (The use of octal sequences is disabled in ordinary non-binary Overwrite
|
|
|
101 mode, to give you a convenient way to insert a digit instead of
|
|
|
102 overwriting with it.)
|
|
428
|
103 @end itemize
|
|
|
104
|
|
|
105 @noindent
|
|
|
106 A numeric argument to @kbd{C-q} specifies how many copies of the quoted
|
|
|
107 character should be inserted (@pxref{Arguments}).
|
|
|
108
|
|
442
|
109 @findex backward-or-forward-delete-char
|
|
|
110 @findex newline
|
|
|
111 @findex self-insert
|
|
|
112 Customization information: @key{DEL}, in most modes, runs the command
|
|
|
113 @code{backward-or-forward-delete-char}; @key{RET} runs the command
|
|
|
114 @code{newline}, and self-inserting printing characters run the command
|
|
|
115 @code{self-insert}, which inserts whatever character was typed to invoke
|
|
|
116 it. Some major modes rebind @key{DEL} to other commands.
|
|
428
|
117
|
|
442
|
118 @node Moving Point, Erasing, Inserting Text, Basic
|
|
428
|
119 @section Changing the Location of Point
|
|
|
120
|
|
442
|
121 @cindex arrow keys
|
|
|
122 @kindex LEFT
|
|
|
123 @kindex RIGHT
|
|
|
124 @kindex UP
|
|
|
125 @kindex DOWN
|
|
|
126 @cindex moving point
|
|
|
127 @cindex movement
|
|
|
128 @cindex cursor motion
|
|
|
129 @cindex moving the cursor
|
|
428
|
130 To do more than insert characters, you have to know how to move point
|
|
442
|
131 (@pxref{Point}). The simplest way to do this is with arrow keys, or by
|
|
|
132 clicking the left mouse button where you want to move to.
|
|
428
|
133
|
|
|
134 NOTE: Many of the following commands have two versions, one that uses
|
|
|
135 the function keys (e.g. @key{LEFT} or @key{END}) and one that doesn't.
|
|
|
136 The former versions may only be available on X terminals (i.e. not on
|
|
|
137 TTY's), but the latter are available on all terminals.
|
|
|
138
|
|
|
139 @kindex C-a
|
|
|
140 @kindex C-e
|
|
|
141 @kindex C-f
|
|
|
142 @kindex C-b
|
|
|
143 @kindex C-n
|
|
|
144 @kindex C-p
|
|
|
145 @kindex C-l
|
|
|
146 @kindex C-t
|
|
|
147 @kindex C-v
|
|
|
148 @kindex M-v
|
|
|
149 @kindex M->
|
|
|
150 @kindex M-<
|
|
|
151 @kindex M-r
|
|
|
152 @kindex LEFT
|
|
|
153 @kindex RIGHT
|
|
|
154 @kindex UP
|
|
|
155 @kindex DOWN
|
|
|
156 @kindex HOME
|
|
|
157 @kindex END
|
|
|
158 @kindex PGUP
|
|
|
159 @kindex PGDN
|
|
|
160 @kindex C-LEFT
|
|
|
161 @kindex C-RIGHT
|
|
|
162 @kindex C-HOME
|
|
|
163 @kindex C-END
|
|
|
164 @findex beginning-of-line
|
|
|
165 @findex end-of-line
|
|
|
166 @findex forward-char
|
|
|
167 @findex backward-char
|
|
|
168 @findex next-line
|
|
|
169 @findex previous-line
|
|
|
170 @findex recenter
|
|
|
171 @findex transpose-chars
|
|
|
172 @findex beginning-of-buffer
|
|
|
173 @findex end-of-buffer
|
|
|
174 @findex goto-char
|
|
|
175 @findex goto-line
|
|
|
176 @findex move-to-window-line
|
|
|
177 @table @kbd
|
|
|
178 @item C-a
|
|
|
179 @itemx HOME
|
|
|
180 Move to the beginning of the line (@code{beginning-of-line}).
|
|
|
181 @item C-e
|
|
|
182 @itemx END
|
|
|
183 Move to the end of the line (@code{end-of-line}).
|
|
|
184 @item C-f
|
|
|
185 @itemx RIGHT
|
|
|
186 Move forward one character (@code{forward-char}).
|
|
|
187 @item C-b
|
|
|
188 @itemx LEFT
|
|
|
189 Move backward one character (@code{backward-char}).
|
|
|
190 @item M-f
|
|
|
191 @itemx C-RIGHT
|
|
|
192 Move forward one word (@code{forward-word}).
|
|
|
193 @item M-b
|
|
|
194 @itemx C-LEFT
|
|
|
195 Move backward one word (@code{backward-word}).
|
|
|
196 @item C-n
|
|
|
197 @itemx DOWN
|
|
442
|
198 Move down one line, vertically (@code{next-line}). This command
|
|
|
199 attempts to keep the horizontal position unchanged, so if you start in
|
|
|
200 the middle of one line, you end in the middle of the next. When on the
|
|
|
201 last line of text, @kbd{C-n} creates a new line and moves onto it.
|
|
428
|
202 @item C-p
|
|
|
203 @itemx UP
|
|
|
204 Move up one line, vertically (@code{previous-line}).
|
|
|
205 @item C-v
|
|
|
206 @itemx PGDN
|
|
|
207 Move down one page, vertically (@code{scroll-up}).
|
|
|
208 @item M-v
|
|
|
209 @itemx PGUP
|
|
|
210 Move up one page, vertically (@code{scroll-down}).
|
|
|
211 @item C-l
|
|
|
212 Clear the frame and reprint everything (@code{recenter}). Text moves
|
|
|
213 on the frame to bring point to the center of the window.
|
|
|
214 @item M-r
|
|
442
|
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
|
|
|
218 A numeric argument says which screen line to place point on. It counts
|
|
|
219 screen lines down from the top of the window (zero for the top line). A
|
|
|
220 negative argument counts lines from the bottom (@minus{}1 for the bottom
|
|
|
221 line).
|
|
428
|
222 @item C-t
|
|
|
223 Transpose two characters, the ones before and after the cursor
|
|
442
|
224 (@code{transpose-chars}).
|
|
428
|
225 @item M-<
|
|
|
226 @itemx C-HOME
|
|
|
227 Move to the top of the buffer (@code{beginning-of-buffer}). With
|
|
|
228 numeric argument @var{n}, move to @var{n}/10 of the way from the top.
|
|
|
229 @xref{Arguments}, for more information on numeric arguments.@refill
|
|
|
230 @item M->
|
|
|
231 @itemx C-END
|
|
|
232 Move to the end of the buffer (@code{end-of-buffer}).
|
|
|
233 @item M-x goto-char
|
|
442
|
234 Read a number @var{n} and move point to buffer position @var{n}.
|
|
428
|
235 Position 1 is the beginning of the buffer.
|
|
|
236 @item M-g
|
|
442
|
237 Read a number @var{n} and move point to line number @var{n}
|
|
428
|
238 (@code{goto-line}). Line 1 is the beginning of the buffer.
|
|
442
|
239 @c @item C-x C-n
|
|
|
240 @item M-x set-goal-column
|
|
428
|
241 @findex set-goal-column
|
|
|
242 Use the current column of point as the @dfn{semi-permanent goal column} for
|
|
|
243 @kbd{C-n} and @kbd{C-p} (@code{set-goal-column}). Henceforth, those
|
|
|
244 commands always move to this column in each line moved into, or as
|
|
|
245 close as possible given the contents of the line. This goal column remains
|
|
|
246 in effect until canceled.
|
|
442
|
247 @c @item C-u C-x C-n
|
|
|
248 @item C-u M-x set-goal-column
|
|
428
|
249 Cancel the goal column. Henceforth, @kbd{C-n} and @kbd{C-p} once
|
|
|
250 again try to avoid changing the horizontal position, as usual.
|
|
|
251 @end table
|
|
|
252
|
|
|
253 @vindex track-eol
|
|
|
254 If you set the variable @code{track-eol} to a non-@code{nil} value,
|
|
442
|
255 then @kbd{C-n} and @kbd{C-p} when at the end of the starting line move
|
|
|
256 to the end of another line. Normally, @code{track-eol} is @code{nil}.
|
|
|
257 @xref{Variables}, for how to set variables such as @code{track-eol}.
|
|
428
|
258
|
|
442
|
259 @vindex next-line-add-newlines
|
|
|
260 Normally, @kbd{C-n} on the last line of a buffer appends a newline to
|
|
|
261 it. If the variable @code{next-line-add-newlines} is @code{nil}, then
|
|
|
262 @kbd{C-n} gets an error instead (like @kbd{C-p} on the first line).
|
|
|
263
|
|
|
264 @node Erasing, Basic Files, Moving Point, Basic
|
|
428
|
265 @section Erasing Text
|
|
|
266
|
|
|
267 @table @kbd
|
|
|
268 @item @key{DEL}
|
|
442
|
269 Delete the character before or after point
|
|
|
270 (@code{backward-or-forward-delete-char}). You can customize
|
|
|
271 this behavior by setting the variable @code{delete-key-deletes-forward}.
|
|
428
|
272 @item C-d
|
|
442
|
273 Delete the character after point (@code{delete-char}).
|
|
428
|
274 @item C-k
|
|
|
275 Kill to the end of the line (@code{kill-line}).
|
|
|
276 @item M-d
|
|
|
277 Kill forward to the end of the next word (@code{kill-word}).
|
|
|
278 @item M-@key{DEL}
|
|
|
279 Kill back to the beginning of the previous word
|
|
|
280 (@code{backward-kill-word}).
|
|
|
281 @end table
|
|
|
282
|
|
442
|
283 @cindex killing characters and lines
|
|
|
284 @cindex deleting characters and lines
|
|
|
285 @cindex erasing characters and lines
|
|
|
286 You already know about the @key{DEL} key which deletes the character
|
|
|
287 before point (that is, before the cursor). Another key, @kbd{Control-d}
|
|
|
288 (@kbd{C-d} for short), deletes the character after point (that is, the
|
|
|
289 character that the cursor is on). This shifts the rest of the text on
|
|
|
290 the line to the left. If you type @kbd{C-d} at the end of a line, it
|
|
|
291 joins together that line and the next line.
|
|
428
|
292
|
|
442
|
293 To erase a larger amount of text, use the @kbd{C-k} key, which kills a
|
|
|
294 line at a time. If you type @kbd{C-k} at the beginning or middle of a
|
|
|
295 line, it kills all the text up to the end of the line. If you type
|
|
|
296 @kbd{C-k} at the end of a line, it joins that line and the next line.
|
|
428
|
297
|
|
|
298 @xref{Killing}, for more flexible ways of killing text.
|
|
|
299
|
|
442
|
300 @node Basic Files, Basic Help, Erasing, Basic
|
|
428
|
301 @section Files
|
|
|
302
|
|
|
303 @cindex files
|
|
442
|
304 The commands described above are sufficient for creating and altering
|
|
|
305 text in an Emacs buffer; the more advanced Emacs commands just make
|
|
|
306 things easier. But to keep any text permanently you must put it in a
|
|
|
307 @dfn{file}. Files are named units of text which are stored by the
|
|
|
308 operating system for you to retrieve later by name. To look at or use
|
|
|
309 the contents of a file in any way, including editing the file with
|
|
|
310 Emacs, you must specify the file name.
|
|
428
|
311
|
|
|
312 Consider a file named @file{/usr/rms/foo.c}. To begin editing
|
|
|
313 this file from Emacs, type:
|
|
|
314
|
|
|
315 @example
|
|
|
316 C-x C-f /usr/rms/foo.c @key{RET}
|
|
|
317 @end example
|
|
|
318
|
|
|
319 @noindent
|
|
442
|
320 Here the file name is given as an @dfn{argument} to the command @kbd{C-x
|
|
|
321 C-f} (@code{find-file}). That command uses the @dfn{minibuffer} to
|
|
|
322 read the argument, and you type @key{RET} to terminate the argument
|
|
|
323 (@pxref{Minibuffer}).
|
|
428
|
324
|
|
|
325 You can also use the @b{Open...} menu item from the @b{File} menu, then
|
|
|
326 type the name of the file to the prompt.
|
|
|
327
|
|
442
|
328 Emacs obeys the command by @dfn{visiting} the file: creating a buffer,
|
|
|
329 copying the contents of the file into the buffer, and then displaying
|
|
|
330 the buffer for you to edit. If you alter the text, you can @dfn{save}
|
|
|
331 the new text in the file by typing @kbd{C-x C-s} (@code{save-buffer}) or
|
|
|
332 choosing @b{Save Buffer} from the @b{File} menu. This makes the changes
|
|
|
333 permanent by copying the altered buffer contents back into the file
|
|
|
334 @file{/usr/rms/foo.c}. Until you save, the changes exist only inside
|
|
|
335 Emacs, and the file @file{foo.c} is unaltered.
|
|
428
|
336
|
|
|
337 To create a file, visit the file with @kbd{C-x C-f} as if it already
|
|
|
338 existed or choose @b{Open...} from the @b{File} menu and provide the
|
|
442
|
339 name for the new file. Emacs will create an empty buffer in which you
|
|
|
340 can insert the text you want to put in the file. When you save the
|
|
|
341 buffer with @kbd{C-x C-s}, or by choosing @b{Save Buffer} from the
|
|
|
342 @b{File} menu, the file is created.
|
|
428
|
343
|
|
442
|
344 To learn more about using files, @xref{Files}.
|
|
428
|
345
|
|
442
|
346 @node Basic Help, Blank Lines, Basic Files, Basic
|
|
428
|
347 @section Help
|
|
|
348
|
|
442
|
349 @cindex getting help with keys
|
|
|
350 If you forget what a key does, you can find out with the Help
|
|
|
351 character, which is @kbd{C-h} (or @key{F1}, which is an alias for
|
|
|
352 @kbd{C-h}). Type @kbd{C-h k} followed by the key you want to know
|
|
|
353 about; for example, @kbd{C-h k C-n} tells you all about what @kbd{C-n}
|
|
428
|
354 does. @kbd{C-h} is a prefix key; @kbd{C-h k} is just one of its
|
|
|
355 subcommands (the command @code{describe-key}). The other subcommands of
|
|
442
|
356 @kbd{C-h} provide different kinds of help. Type @kbd{C-h} twice to get
|
|
|
357 a description of all the help facilities. @xref{Help}.
|
|
428
|
358
|
|
442
|
359 @node Blank Lines, Continuation Lines, Basic Help, Basic
|
|
428
|
360 @section Blank Lines
|
|
|
361
|
|
442
|
362 @cindex inserting blank lines
|
|
|
363 @cindex deleting blank lines
|
|
|
364 Here are special commands and techniques for putting in and taking out
|
|
428
|
365 blank lines.
|
|
|
366
|
|
|
367 @c widecommands
|
|
|
368 @table @kbd
|
|
|
369 @item C-o
|
|
|
370 Insert one or more blank lines after the cursor (@code{open-line}).
|
|
|
371 @item C-x C-o
|
|
|
372 Delete all but one of many consecutive blank lines
|
|
|
373 (@code{delete-blank-lines}).
|
|
|
374 @end table
|
|
|
375
|
|
|
376 @kindex C-o
|
|
|
377 @kindex C-x C-o
|
|
|
378 @cindex blank lines
|
|
|
379 @findex open-line
|
|
|
380 @findex delete-blank-lines
|
|
442
|
381 When you want to insert a new line of text before an existing line, you
|
|
|
382 can do it by typing the new line of text, followed by @key{RET}.
|
|
|
383 However, it may be easier to see what you are doing if you first make a
|
|
|
384 blank line and then insert the desired text into it. This is easy to do
|
|
|
385 using the key @kbd{C-o} (@code{open-line}), which inserts a newline
|
|
|
386 after point but leaves point in front of the newline. After @kbd{C-o},
|
|
|
387 type the text for the new line. @kbd{C-o F O O} has the same effect as
|
|
|
388 @w{@kbd{F O O @key{RET}}}, except for the final location of point.
|
|
428
|
389
|
|
442
|
390 You can make several blank lines by typing @kbd{C-o} several times, or
|
|
|
391 by giving it a numeric argument to tell it how many blank lines to make.
|
|
|
392 @xref{Arguments}, for how. If you have a fill prefix, then @kbd{C-o}
|
|
|
393 command inserts the fill prefix on the new line, when you use it at the
|
|
|
394 beginning of a line. @xref{Fill Prefix}.
|
|
428
|
395
|
|
442
|
396 The easy way to get rid of extra blank lines is with the command
|
|
|
397 @kbd{C-x C-o} (@code{delete-blank-lines}). @kbd{C-x C-o} in a run of
|
|
|
398 several blank lines deletes all but one of them. @kbd{C-x C-o} on a
|
|
|
399 solitary blank line deletes that blank line. When point is on a
|
|
|
400 nonblank line, @kbd{C-x C-o} deletes any blank lines following that
|
|
|
401 nonblank line.
|
|
428
|
402
|
|
|
403 @node Continuation Lines, Position Info, Blank Lines, Basic
|
|
|
404 @section Continuation Lines
|
|
|
405
|
|
|
406 @cindex continuation line
|
|
442
|
407 @cindex wrapping
|
|
|
408 @cindex line wrapping
|
|
|
409 If you add too many characters to one line without breaking it with
|
|
|
410 @key{RET}, the line will grow to occupy two (or more) lines on the
|
|
|
411 screen, with a curved arrow at the extreme right margin of all but the
|
|
|
412 last of them. The curved arrow says that the following screen line is
|
|
|
413 not really a distinct line in the text, but just the @dfn{continuation}
|
|
|
414 of a line too long to fit the screen. Continuation is also called
|
|
|
415 @dfn{line wrapping}.
|
|
428
|
416
|
|
442
|
417 Sometimes it is nice to have Emacs insert newlines automatically when
|
|
|
418 a line gets too long. Continuation on the screen does not do that. Use
|
|
|
419 Auto Fill mode (@pxref{Filling}) if that's what you want.
|
|
428
|
420
|
|
|
421 @vindex truncate-lines
|
|
|
422 @cindex truncation
|
|
|
423 Instead of continuation, long lines can be displayed by @dfn{truncation}.
|
|
|
424 This means that all the characters that do not fit in the width of the
|
|
|
425 frame or window do not appear at all. They remain in the buffer,
|
|
442
|
426 temporarily invisible. Right arrow in the last column (instead of the
|
|
|
427 curved arrow) inform you that truncation is in effect.
|
|
428
|
428
|
|
442
|
429 Truncation instead of continuation happens whenever horizontal
|
|
|
430 scrolling is in use, and optionally in all side-by-side windows
|
|
|
431 (@pxref{Windows}). You can enable truncation for a particular buffer by
|
|
|
432 setting the variable @code{truncate-lines} to non-@code{nil} in that
|
|
|
433 buffer. (@xref{Variables}.) Altering the value of
|
|
|
434 @code{truncate-lines} makes it local to the current buffer; until that
|
|
|
435 time, the default value is in effect. The default is initially
|
|
|
436 @code{nil}. @xref{Locals}.
|
|
|
437
|
|
|
438 @xref{Display Vars}, for additional variables that affect how text is
|
|
|
439 displayed.
|
|
428
|
440
|
|
|
441 @node Position Info, Arguments, Continuation Lines, Basic
|
|
|
442 @section Cursor Position Information
|
|
|
443
|
|
|
444 If you are accustomed to other display editors, you may be surprised
|
|
|
445 that Emacs does not always display the page number or line number of
|
|
|
446 point in the mode line. In Emacs, this information is only rarely
|
|
|
447 needed, and a number of commands are available to compute and print it.
|
|
|
448 Since text is stored in a way that makes it difficult to compute the
|
|
|
449 information, it is not displayed all the time.
|
|
|
450
|
|
|
451 @table @kbd
|
|
|
452 @item M-x what-page
|
|
|
453 Print page number of point, and line number within page.
|
|
|
454 @item M-x what-line
|
|
|
455 Print line number of point in the buffer.
|
|
442
|
456 @item M-x line-number-mode
|
|
|
457 Toggle automatic display of current line number.
|
|
428
|
458 @item M-=
|
|
442
|
459 Print number of lines and characters in the current region
|
|
|
460 (@code{count-lines-region}). @xref{Mark}, for information about the
|
|
|
461 region.
|
|
428
|
462 @item C-x =
|
|
|
463 Print character code of character after point, character position of
|
|
|
464 point, and column of point (@code{what-cursor-position}).
|
|
|
465 @end table
|
|
|
466
|
|
|
467 @findex what-page
|
|
|
468 @findex what-line
|
|
|
469 @cindex line number
|
|
|
470 @cindex page number
|
|
|
471 @kindex M-=
|
|
|
472 @findex count-lines-region
|
|
|
473
|
|
|
474 There are several commands for printing line numbers:
|
|
442
|
475
|
|
428
|
476 @itemize @bullet
|
|
|
477 @item
|
|
|
478 @kbd{M-x what-line} counts lines from the beginning of the file and
|
|
|
479 prints the line number point is on. The first line of the file is line
|
|
|
480 number 1. You can use these numbers as arguments to @kbd{M-x
|
|
|
481 goto-line}.
|
|
|
482 @item
|
|
|
483 @kbd{M-x what-page} counts pages from the beginning of the file, and
|
|
|
484 counts lines within the page, printing both of them. @xref{Pages}, for
|
|
|
485 the command @kbd{C-x l}, which counts the lines in the current page.
|
|
|
486 @item
|
|
442
|
487 @kbd{M-=} (@code{count-lines-region}) prints the number of lines in the
|
|
|
488 region (@pxref{Mark}). @xref{Pages}, for the command @kbd{C-x l} which
|
|
|
489 counts the lines in the
|
|
428
|
490 @end itemize
|
|
|
491
|
|
|
492 @kindex C-x =
|
|
|
493 @findex what-cursor-position
|
|
442
|
494 The command @kbd{C-x =} (@code{what-cursor-position}) can be used to find out
|
|
|
495 the column that the cursor is in, and other miscellaneous information about
|
|
|
496 point. It prints a line in the echo area that looks like this:
|
|
428
|
497
|
|
|
498 @example
|
|
442
|
499 Char: c (0143, 99, 0x63) point=18862 of 24800(76%) column 53
|
|
428
|
500 @end example
|
|
|
501
|
|
|
502 @noindent
|
|
442
|
503 (In fact, this is the output produced when point is before @samp{column
|
|
|
504 53} in the example.)
|
|
428
|
505
|
|
442
|
506 The four values after @samp{Char:} describe the character that follows
|
|
|
507 point, first by showing it and then by giving its character code in
|
|
|
508 octal, decimal and hex.
|
|
428
|
509
|
|
|
510 @samp{point=} is followed by the position of point expressed as a character
|
|
|
511 count. The front of the buffer counts as position 1, one character later
|
|
|
512 as 2, and so on. The next, larger number is the total number of characters
|
|
|
513 in the buffer. Afterward in parentheses comes the position expressed as a
|
|
|
514 percentage of the total size.
|
|
|
515
|
|
442
|
516 @samp{column} is followed by the horizontal position of point, in
|
|
|
517 columns from the left edge of the window.
|
|
428
|
518
|
|
|
519 If the buffer has been narrowed, making some of the text at the
|
|
|
520 beginning and the end temporarily invisible, @kbd{C-x =} prints
|
|
|
521 additional text describing the current visible range. For example, it
|
|
|
522 might say:
|
|
|
523
|
|
|
524 @smallexample
|
|
442
|
525 Char: c (0143, 99, 0x63) point=19674 of 24575(80%) <19591 - 19703> column 69
|
|
428
|
526 @end smallexample
|
|
|
527
|
|
|
528 @noindent
|
|
|
529 where the two extra numbers give the smallest and largest character position
|
|
|
530 that point is allowed to assume. The characters between those two positions
|
|
|
531 are the visible ones. @xref{Narrowing}.
|
|
|
532
|
|
|
533 If point is at the end of the buffer (or the end of the visible part),
|
|
|
534 @kbd{C-x =} omits any description of the character after point.
|
|
|
535 The output looks like
|
|
|
536
|
|
|
537 @smallexample
|
|
|
538 point=563026 of 563025(100%) column 0
|
|
|
539 @end smallexample
|
|
|
540
|
|
|
541 @node Arguments,, Position Info, Basic
|
|
|
542 @section Numeric Arguments
|
|
|
543 @cindex numeric arguments
|
|
|
544
|
|
442
|
545 In mathematics and computer usage, the word @dfn{argument} means
|
|
|
546 ``data provided to a function or operation.'' Any Emacs command can be
|
|
|
547 given a @dfn{numeric argument} (also called a @dfn{prefix argument}).
|
|
|
548 Some commands interpret the argument as a repetition count. For
|
|
|
549 example, giving an argument of ten to the key @kbd{C-f} (the command
|
|
|
550 @code{forward-char}, move forward one character) moves forward ten
|
|
|
551 characters. With these commands, no argument is equivalent to an
|
|
|
552 argument of one. Negative arguments are allowed. Often they tell a
|
|
|
553 command to move or act in the opposite direction.
|
|
428
|
554
|
|
|
555 @kindex M-1
|
|
|
556 @kindex M-@t{-}
|
|
|
557 @findex digit-argument
|
|
|
558 @findex negative-argument
|
|
|
559 If your keyboard has a @key{META} key (labelled with a diamond on
|
|
|
560 Sun-type keyboards and labelled @samp{Alt} on some other keyboards), the
|
|
|
561 easiest way to specify a numeric argument is to type digits and/or a
|
|
|
562 minus sign while holding down the @key{META} key. For example,
|
|
|
563 @example
|
|
|
564 M-5 C-n
|
|
|
565 @end example
|
|
|
566 @noindent
|
|
442
|
567 would move down five lines. The characters @kbd{Meta-1}, @kbd{Meta-2},
|
|
|
568 and so on, as well as @kbd{Meta--}, do this because they are keys bound
|
|
|
569 to commands (@code{digit-argument} and @code{negative-argument}) that
|
|
|
570 are defined to contribute to an argument for the next command. Digits
|
|
|
571 and @kbd{-} modified with Control, or Control and Meta, also specify
|
|
|
572 numeric arguments.
|
|
428
|
573
|
|
|
574 @kindex C-u
|
|
|
575 @findex universal-argument
|
|
|
576 Another way of specifying an argument is to use the @kbd{C-u}
|
|
442
|
577 (@code{universal-argument}) command followed by the digits of the
|
|
|
578 argument. With @kbd{C-u}, you can type the argument digits without
|
|
|
579 holding down modifier keys; @kbd{C-u} works on all terminals. To type a
|
|
|
580 negative argument, type a minus sign after @kbd{C-u}. Just a minus sign
|
|
|
581 without digits normally means @minus{}1.
|
|
428
|
582
|
|
|
583 @kbd{C-u} followed by a character which is neither a digit nor a minus
|
|
|
584 sign has the special meaning of ``multiply by four''. It multiplies the
|
|
|
585 argument for the next command by four. @kbd{C-u} twice multiplies it by
|
|
|
586 sixteen. Thus, @kbd{C-u C-u C-f} moves forward sixteen characters. This
|
|
|
587 is a good way to move forward ``fast'', since it moves about 1/5 of a line
|
|
|
588 in the usual size frame. Other useful combinations are @kbd{C-u C-n},
|
|
|
589 @kbd{C-u C-u C-n} (move down a good fraction of a frame), @kbd{C-u C-u
|
|
|
590 C-o} (make ``a lot'' of blank lines), and @kbd{C-u C-k} (kill four
|
|
442
|
591 lines).
|
|
428
|
592
|
|
|
593 Some commands care only about whether there is an argument and not about
|
|
|
594 its value. For example, the command @kbd{M-q} (@code{fill-paragraph}) with
|
|
|
595 no argument fills text; with an argument, it justifies the text as well.
|
|
|
596 (@xref{Filling}, for more information on @kbd{M-q}.) Just @kbd{C-u} is a
|
|
|
597 handy way of providing an argument for such commands.
|
|
|
598
|
|
|
599 Some commands use the value of the argument as a repeat count, but do
|
|
|
600 something peculiar when there is no argument. For example, the command
|
|
|
601 @kbd{C-k} (@code{kill-line}) with argument @var{n} kills @var{n} lines,
|
|
|
602 including their terminating newlines. But @kbd{C-k} with no argument is
|
|
|
603 special: it kills the text up to the next newline, or, if point is right at
|
|
|
604 the end of the line, it kills the newline itself. Thus, two @kbd{C-k}
|
|
|
605 commands with no arguments can kill a non-blank line, just like @kbd{C-k}
|
|
|
606 with an argument of one. (@xref{Killing}, for more information on
|
|
442
|
607 @kbd{C-k}.)
|
|
428
|
608
|
|
|
609 A few commands treat a plain @kbd{C-u} differently from an ordinary
|
|
|
610 argument. A few others may treat an argument of just a minus sign
|
|
442
|
611 differently from an argument of @minus{}1. These unusual cases are
|
|
|
612 described when they come up; they are always for reasons of convenience
|
|
|
613 of use of the individual command.
|
|
428
|
614
|
|
442
|
615 You can use a numeric argument to insert multiple copies of a
|
|
|
616 character. This is straightforward unless the character is a digit; for
|
|
|
617 example, @kbd{C-u 6 4 a} inserts 64 copies of the character @samp{a}.
|
|
|
618 But this does not work for inserting digits; @kbd{C-u 6 4 1} specifies
|
|
|
619 an argument of 641, rather than inserting anything. To separate the
|
|
|
620 digit to insert from the argument, type another @kbd{C-u}; for example,
|
|
|
621 @kbd{C-u 6 4 C-u 1} does insert 64 copies of the character @samp{1}.
|
|
|
622
|
|
|
623 We use the term ``prefix argument'' as well as ``numeric argument'' to
|
|
|
624 emphasize that you type the argument before the command, and to
|
|
|
625 distinguish these arguments from minibuffer arguments that come after
|
|
|
626 the command.
|
|
|
627
|
|
428
|
628 @ignore
|
|
442
|
629 @node Repeating
|
|
|
630 @section Repeating a Command
|
|
|
631 @cindex repeating a command
|
|
|
632
|
|
|
633 @kindex C-x z
|
|
|
634 @findex repeat
|
|
|
635 The command @kbd{C-x z} (@code{repeat}) provides another way to repeat
|
|
|
636 an Emacs command many times. This command repeats the previous Emacs
|
|
|
637 command, whatever that was. Repeating a command uses the same arguments
|
|
|
638 that were used before; it does not read new arguments each time.
|
|
428
|
639
|
|
442
|
640 To repeat the command more than once, type additional @kbd{z}'s: each
|
|
|
641 @kbd{z} repeats the command one more time. Repetition ends when you
|
|
|
642 type a character other than @kbd{z}, or press a mouse button.
|
|
428
|
643
|
|
442
|
644 For example, suppose you type @kbd{C-u 2 0 C-d} to delete 20
|
|
|
645 characters. You can repeat that command (including its argument) three
|
|
|
646 additional times, to delete a total of 80 characters, by typing @kbd{C-x
|
|
|
647 z z z}. The first @kbd{C-x z} repeats the command once, and each
|
|
|
648 subsequent @kbd{z} repeats it once again.
|
|
|
649
|
|
428
|
650 @end ignore
|
