1 This is Info file ../../info/xemacs.info, produced by Makeinfo version
2 1.68 from the input file xemacs.texi.
4 INFO-DIR-SECTION XEmacs Editor
6 * XEmacs: (xemacs). XEmacs Editor.
9 This file documents the XEmacs editor.
11 Copyright (C) 1985, 1986, 1988 Richard M. Stallman. Copyright (C)
12 1991, 1992, 1993, 1994 Lucid, Inc. Copyright (C) 1993, 1994 Sun
13 Microsystems, Inc. Copyright (C) 1995 Amdahl Corporation.
15 Permission is granted to make and distribute verbatim copies of this
16 manual provided the copyright notice and this permission notice are
17 preserved on all copies.
19 Permission is granted to copy and distribute modified versions of
20 this manual under the conditions for verbatim copying, provided also
21 that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
22 General Public License" are included exactly as in the original, and
23 provided that the entire resulting derived work is distributed under the
24 terms of a permission notice identical to this one.
26 Permission is granted to copy and distribute translations of this
27 manual into another language, under the above conditions for modified
28 versions, except that the sections entitled "The GNU Manifesto",
29 "Distribution" and "GNU General Public License" may be included in a
30 translation approved by the author instead of in the original English.
33 File: xemacs.info, Node: Appending Kills, Next: Earlier Kills, Prev: Kill Ring, Up: Yanking
38 Normally, each kill command pushes a new block onto the kill ring.
39 However, two or more kill commands in a row combine their text into a
40 single entry, so that a single `C-y' yanks it all back. This means you
41 don't have to kill all the text you want to yank in one command; you
42 can kill line after line, or word after word, until you have killed what
43 you want, then get it all back at once using `C-y'. (Thus we join
44 television in leading people to kill thoughtlessly.)
46 Commands that kill forward from point add onto the end of the
47 previous killed text. Commands that kill backward from point add onto
48 the beginning. This way, any sequence of mixed forward and backward
49 kill commands puts all the killed text into one entry without
50 rearrangement. Numeric arguments do not break the sequence of
51 appending kills. For example, suppose the buffer contains:
55 and here is the third.
57 with point at the beginning of the second line. If you type `C-k C-u 2
58 M-<DEL> C-k', the first `C-k' kills the text `line of sample text',
59 `C-u 2 M-<DEL>' kills `the first' with the newline that followed it,
60 and the second `C-k' kills the newline after the second line. The
61 result is that the buffer contains `This is and here is the third.' and
62 a single kill entry contains `the first<RET>line of sample
63 text<RET>'--all the killed text, in its original order.
65 If a kill command is separated from the last kill command by other
66 commands (not just numeric arguments), it starts a new entry on the kill
67 ring. To force a kill command to append, first type the command `C-M-w'
68 (`append-next-kill'). `C-M-w' tells the following command, if it is a
69 kill command, to append the text it kills to the last killed text,
70 instead of starting a new entry. With `C-M-w', you can kill several
71 separated pieces of text and accumulate them to be yanked back in one
75 File: xemacs.info, Node: Earlier Kills, Prev: Appending Kills, Up: Yanking
80 To recover killed text that is no longer the most recent kill, you
81 need the `Meta-y' (`yank-pop') command. You can use `M-y' only after a
82 `C-y' or another `M-y'. It takes the text previously yanked and
83 replaces it with the text from an earlier kill. To recover the text of
84 the next-to-the-last kill, first use `C-y' to recover the last kill,
85 then `M-y' to replace it with the previous kill.
87 You can think in terms of a "last yank" pointer which points at an
88 item in the kill ring. Each time you kill, the "last yank" pointer
89 moves to the new item at the front of the ring. `C-y' yanks the item
90 which the "last yank" pointer points to. `M-y' moves the "last yank"
91 pointer to a different item, and the text in the buffer changes to
92 match. Enough `M-y' commands can move the pointer to any item in the
93 ring, so you can get any item into the buffer. Eventually the pointer
94 reaches the end of the ring; the next `M-y' moves it to the first item
97 Yanking moves the "last yank" pointer around the ring, but does not
98 change the order of the entries in the ring, which always runs from the
99 most recent kill at the front to the oldest one still remembered.
101 Use `M-y' with a numeric argument to advance the "last yank" pointer
102 by the specified number of items. A negative argument moves the
103 pointer toward the front of the ring; from the front of the ring, it
104 moves to the last entry and starts moving forward from there.
106 Once the text you are looking for is brought into the buffer, you can
107 stop doing `M-y' commands and the text will stay there. Since the text
108 is just a copy of the kill ring item, editing it in the buffer does not
109 change what's in the ring. As long you don't kill additional text, the
110 "last yank" pointer remains at the same place in the kill ring:
111 repeating `C-y' will yank another copy of the same old kill.
113 If you know how many `M-y' commands it would take to find the text
114 you want, you can yank that text in one step using `C-y' with a numeric
115 argument. `C-y' with an argument greater than one restores the text
116 the specified number of entries back in the kill ring. Thus, `C-u 2
117 C-y' gets the next to the last block of killed text. It is equivalent
118 to `C-y M-y'. `C-y' with a numeric argument starts counting from the
119 "last yank" pointer, and sets the "last yank" pointer to the entry that
122 The variable `kill-ring-max' controls the length of the kill ring;
123 no more than that many blocks of killed text are saved.
126 File: xemacs.info, Node: Using X Selections, Next: Accumulating Text, Prev: Yanking, Up: Top
131 In the X window system, mouse selections provide a simple mechanism
132 for text transfer between different applications. In a typical X
133 application, you can select text by pressing the left mouse button and
134 dragging the cursor over the text you want to copy. The text becomes
135 the primary X selection and is highlighted. The highlighted region is
136 also the Emacs selected region.
138 * Since the region is the primary X selection, you can go to a
139 different X application and click the middle mouse button: the
140 text that you selected in the previous application is pasted into
141 the current application.
143 * Since the region is the Emacs selected region, you can use all
144 region commands (`C-w, M-w' etc.) as well as the options of the
145 Edit menu to manipulate the selected text.
149 * X Clipboard Selection:: Pasting to the X clipboard.
150 * X Selection Commands:: Other operations on the selection.
151 * X Cut Buffers:: X cut buffers are available for compatibility.
152 * Active Regions:: Using zmacs-style highlighting of the
156 File: xemacs.info, Node: X Clipboard Selection, Next: X Selection Commands, Prev: Using X Selections, Up: Using X Selections
158 The Clipboard Selection
159 -----------------------
161 There are other kinds of X selections besides the Primary selection;
162 one common one is the Clipboard selection. Some applications prefer to
163 transfer data using this selection in preference to the Primary. One
164 can transfer text from the Primary selection to the Clipboard
165 selection with the Copy command under the Edit menu in the menubar.
167 Usually, the clipboard selection is not visible. However, if you
168 run the `xclipboard' application, the text most recently copied to the
169 clipboard (with the Copy command) is displayed in a window. Any time
170 new text is thus copied, the `xclipboard' application makes a copy of
171 it and displays it in its window. The value of the clipboard can
172 survive the lifetime of the running Emacs process. The `xclipboard'
173 man page provides more details.
175 Warning: If you use the `xclipboard' application, remember that it
176 maintains a list of all things that have been pasted to the clipboard
177 (that is, copied with the Copy command). If you don't manually delete
178 elements from this list by clicking on the Delete button in the
179 `xclipboard' window, the clipboard will eventually consume a lot of
182 In summary, some X applications (such as `xterm') allow one to paste
183 text in them from XEmacs in the following way:
185 * Drag out a region of text in Emacs with the left mouse button,
186 making that text be the Primary selection.
188 * Click the middle button in the other application, pasting the
191 With some other applications (notably, the OpenWindows and Motif
192 tools) you must use this method instead:
194 * Drag out a region of text in Emacs with the left mouse button,
195 making that text be the Primary selection.
197 * Copy the selected text to the Clipboard selection by selecting the
198 Copy menu item from the Edit menu, or by hitting the Copy key on
201 * Paste the text in the other application by selecting Paste from its
202 menu, or by hitting the Paste key on your keyboard.
205 File: xemacs.info, Node: X Selection Commands, Next: X Cut Buffers, Prev: X Clipboard Selection, Up: Using X Selections
207 Miscellaneous X Selection Commands
208 ----------------------------------
210 `M-x x-copy-primary-selection'
211 Copy the primary selection to both the kill ring and the Clipboard.
213 `M-x x-insert-selection'
214 Insert the current selection into the buffer at point.
216 `M-x x-delete-primary-selection'
217 Deletes the text in the primary selection without copying it to
218 the kill ring or the Clipboard.
220 `M-x x-kill-primary-selection'
221 Deletes the text in the primary selection and copies it to both
222 the kill ring and the Clipboard.
225 Kill the text between point and the mouse and copy it to the
226 clipboard and to the cut buffer.
228 `M-x x-own-secondary-selection'
229 Make a secondary X selection of the given argument.
231 `M-x x-own-selection'
232 Make a primary X selection of the given argument.
234 `M-x x-set-point-and-insert-selection'
235 Set point where clicked and insert the primary selection or the
239 File: xemacs.info, Node: X Cut Buffers, Next: Active Regions, Prev: X Selection Commands, Up: Using X Selections
244 X cut buffers are a different, older way of transferring text between
245 applications. XEmacs supports cut buffers for compatibility with older
246 programs, even though selections are now the preferred way of
249 X has a concept of applications "owning" selections. When you select
250 text by clicking and dragging inside an application, the application
251 tells the X server that it owns the selection. When another
252 application asks the X server for the value of the selection, the X
253 server requests the information from the owner. When you use
254 selections, the selection data is not actually transferred unless
255 someone wants it; the act of making a selection doesn't transfer data.
256 Cut buffers are different: when you "own" a cut buffer, the data is
257 actually transferred to the X server immediately, and survives the
258 lifetime of the application.
260 Any time a region of text becomes the primary selection in Emacs,
261 Emacs also copies that text to the cut buffer. This makes it possible
262 to copy text from an XEmacs buffer and paste it into an older,
263 non-selection-based application (such as Emacs 18).
265 Note: Older versions of Emacs could not access the X selections, only
269 File: xemacs.info, Node: Active Regions, Prev: X Cut Buffers, Up: Using X Selections
274 By default, both the text you select in an Emacs buffer using the
275 click-and-drag mechanism and text you select by setting point and the
276 mark is highlighted. You can use Emacs region commands as well as the
277 Cut and Copy commands on the highlighted region you selected with the
280 If you prefer, you can make a distinction between text selected with
281 the mouse and text selected with point and the mark by setting the
282 variable `zmacs-regions' to `nil'. In that case:
284 * The text selected with the mouse becomes both the X selection and
285 the Emacs selected region. You can use menu-bar commands as well
286 as Emacs region commands on it.
288 * The text selected with point and the mark is not highlighted. You
289 can only use Emacs region commands on it, not the menu-bar items.
291 Active regions originally come from Zmacs, the Lisp Machine editor.
292 The idea behind them is that commands can only operate on a region when
293 the region is in an "active" state. Put simply, you can only operate on
294 a region that is highlighted.
296 The variable `zmacs-regions' checks whether LISPM-style active
297 regions should be used. This means that commands that operate on the
298 region (the area between point and the mark) only work while the region
299 is in the active state, which is indicated by highlighting. Most
300 commands causes the region to not be in the active state; for example,
301 `C-w' only works immediately after activating the region.
304 * Commands that operate on the region only work if the region is
307 * Only a very small set of commands causes the region to become
308 active-- those commands whose semantics are to mark an area, such
311 * The region is deactivated after each command that is executed,
312 except that motion commands do not change whether the region is
315 `set-mark-command' (`C-SPC') pushes a mark and activates the region.
316 Moving the cursor with normal motion commands (`C-n', `C-p', etc.)
317 will cause the region between point and the recently-pushed mark to be
318 highlighted. It will remain highlighted until some non-motion command
321 `exchange-point-and-mark' (`C-x C-x') activates the region. So if
322 you mark a region and execute a command that operates on it, you can
323 reactivate the same region with `C-x C-x' (or perhaps `C-x C-x C-x
324 C-x') to operate on it again.
326 Generally, commands that push marks as a means of navigation, such as
327 `beginning-of-buffer' (`M-<') and `end-of-buffer' (`M->'), do not
328 activate the region. However, commands that push marks as a means of
329 marking an area of text, such as `mark-defun' (`M-C-h'), `mark-word'
330 (`M-@'), and `mark-whole-buffer' (`C-x h'), do activate the region.
332 When `zmacs-regions' is `t', there is no distinction between the
333 primary X selection and the active region selected by point and the
334 mark. To see this, set the mark (<C-SPC>) and move the cursor with any
335 cursor-motion command: the region between point and mark is
336 highlighted, and you can watch it grow and shrink as you move the
339 Any other commands besides cursor-motion commands (such as inserting
340 or deleting text) will cause the region to no longer be active; it will
341 no longer be highlighted, and will no longer be the primary selection.
342 Region can be explicitly deactivated with `C-g'.
344 Commands that require a region (such as `C-w') signal an error if
345 the region is not active. Certain commands cause the region to be in
346 its active state. The most common ones are `push-mark' (<C-SPC>) and
347 `exchange-point-and-mark' (`C-x C-x').
349 When `zmacs-regions' is `t', programs can be non-intrusive on the
350 state of the region by setting the variable `zmacs-region-stays' to a
351 non-`nil' value. If you are writing a new Emacs command that is
352 conceptually a "motion" command and should not interfere with the
353 current highlightedness of the region, then you may set this variable.
354 It is reset to `nil' after each user command is executed.
356 When `zmacs-regions' is `t', programs can make the region between
357 point and mark go into the active (highlighted) state by using the
358 function `zmacs-activate-region'. Only a small number of commands
361 When `zmacs-regions' is `t', programs can deactivate the region
362 between point and the mark by using `zmacs-deactivate-region'. Note:
363 you should not have to call this function; the command loop calls it
367 File: xemacs.info, Node: Accumulating Text, Next: Rectangles, Prev: Using X Selections, Up: Top
372 Usually you copy or move text by killing it and yanking it, but
373 there are other ways that are useful for copying one block of text in
374 many places, or for copying many scattered blocks of text into one
377 If you like, you can accumulate blocks of text from scattered
378 locations either into a buffer or into a file. The relevant commands
379 are described here. You can also use Emacs registers for storing and
380 accumulating text. *Note Registers::.
382 `M-x append-to-buffer'
383 Append region to contents of specified buffer (`append-to-buffer').
385 `M-x prepend-to-buffer'
386 Prepend region to contents of specified buffer.
389 Copy region into specified buffer, deleting that buffer's old
393 Insert contents of specified buffer into current buffer at point.
396 Append region to the end of the contents of specified file.
398 To accumulate text into a buffer, use the command `M-x
399 append-to-buffer', which inserts a copy of the region into the buffer
400 BUFFERNAME, at the location of point in that buffer. If there is no
401 buffer with the given name, one is created.
403 If you append text to a buffer that has been used for editing, the
404 copied text goes to the place where point is. Point in that buffer is
405 left at the end of the copied text, so successive uses of
406 `append-to-buffer' accumulate the text in the specified buffer in the
407 same order as they were copied. Strictly speaking, this command does
408 not always append to the text already in the buffer; but if this command
409 is the only command used to alter a buffer, it does always append to the
410 existing text because point is always at the end.
412 `M-x prepend-to-buffer' is similar to `append-to-buffer', but point
413 in the other buffer is left before the copied text, so successive
414 prependings add text in reverse order. `M-x copy-to-buffer' is
415 similar, except that any existing text in the other buffer is deleted,
416 so the buffer is left containing just the text newly copied into it.
418 You can retrieve the accumulated text from that buffer with `M-x
419 insert-buffer', which takes BUFFERNAME as an argument. It inserts a
420 copy of the text in buffer BUFFERNAME into the selected buffer. You
421 could alternatively select the other buffer for editing, perhaps moving
422 text from it by killing or with `append-to-buffer'. *Note Buffers::,
423 for background information on buffers.
425 Instead of accumulating text within Emacs in a buffer, you can append
426 text directly into a file with `M-x append-to-file', which takes
427 FILE-NAME as an argument. It adds the text of the region to the end of
428 the specified file. The file is changed immediately on disk. This
429 command is normally used with files that are not being visited in
430 Emacs. Using it on a file that Emacs is visiting can produce confusing
431 results, because the file's text inside Emacs does not change while the
435 File: xemacs.info, Node: Rectangles, Next: Registers, Prev: Accumulating Text, Up: Top
440 The rectangle commands affect rectangular areas of text: all
441 characters between a certain pair of columns, in a certain range of
442 lines. Commands are provided to kill rectangles, yank killed
443 rectangles, clear them out, or delete them. Rectangle commands are
444 useful with text in multicolumnar formats, like code with comments at
445 the right, or for changing text into or out of such formats.
447 To specify the rectangle a command should work on, put the mark at
448 one corner and point at the opposite corner. The specified rectangle is
449 called the "region-rectangle" because it is controlled about the same
450 way the region is controlled. Remember that a given combination of
451 point and mark values can be interpreted either as specifying a region
452 or as specifying a rectangle; it is up to the command that uses them to
453 choose the interpretation.
455 `M-x delete-rectangle'
456 Delete the text of the region-rectangle, moving any following text
457 on each line leftward to the left edge of the region-rectangle.
460 Similar, but also save the contents of the region-rectangle as the
461 "last killed rectangle".
464 Yank the last killed rectangle with its upper left corner at point.
467 Insert blank space to fill the space of the region-rectangle. The
468 previous contents of the region-rectangle are pushed rightward.
470 `M-x clear-rectangle'
471 Clear the region-rectangle by replacing its contents with spaces.
473 The rectangle operations fall into two classes: commands deleting and
474 moving rectangles, and commands for blank rectangles.
476 There are two ways to get rid of the text in a rectangle: you can
477 discard the text (delete it) or save it as the "last killed" rectangle.
478 The commands for these two ways are `M-x delete-rectangle' and `M-x
479 kill-rectangle'. In either case, the portion of each line that falls
480 inside the rectangle's boundaries is deleted, causing following text
481 (if any) on the line to move left.
483 Note that "killing" a rectangle is not killing in the usual sense;
484 the rectangle is not stored in the kill ring, but in a special place
485 that only records the most recently killed rectangle (that is, does not
486 append to a killed rectangle). Different yank commands have to be used
487 and only one rectangle is stored, because yanking a rectangle is quite
488 different from yanking linear text and yank-popping commands are
489 difficult to make sense of.
491 Inserting a rectangle is the opposite of deleting one. You specify
492 where to put the upper left corner by putting point there. The
493 rectangle's first line is inserted at point, the rectangle's second line
494 is inserted at a point one line vertically down, and so on. The number
495 of lines affected is determined by the height of the saved rectangle.
497 To insert the last killed rectangle, type `M-x yank-rectangle'.
498 This can be used to convert single-column lists into double-column
499 lists; kill the second half of the list as a rectangle and then yank it
500 beside the first line of the list.
502 There are two commands for working with blank rectangles: `M-x
503 clear-rectangle' erases existing text, and `M-x open-rectangle' inserts
504 a blank rectangle. Clearing a rectangle is equivalent to deleting it
505 and then inserting a blank rectangle of the same size.
507 Rectangles can also be copied into and out of registers. *Note
508 Rectangle Registers: RegRect.
511 File: xemacs.info, Node: Registers, Next: Display, Prev: Rectangles, Up: Top
516 Emacs "registers" are places in which you can save text or positions
517 for later use. Text saved in a register can be copied into the buffer
518 once or many times; a position saved in a register is used by moving
519 point to that position. Rectangles can also be copied into and out of
520 registers (*note Rectangles::.).
522 Each register has a name, which is a single character. A register
523 can store either a piece of text, a position, or a rectangle, but only
524 one thing at any given time. Whatever you store in a register remains
525 there until you store something else in that register.
529 * RegPos:: Saving positions in registers.
530 * RegText:: Saving text in registers.
531 * RegRect:: Saving rectangles in registers.
533 `M-x view-register <RET> R'
534 Display a description of what register R contains.
536 `M-x view-register' reads a register name as an argument and then
537 displays the contents of the specified register.
540 File: xemacs.info, Node: RegPos, Next: RegText, Prev: Registers, Up: Registers
542 Saving Positions in Registers
543 =============================
545 Saving a position records a spot in a buffer so you can move back
546 there later. Moving to a saved position re-selects the buffer and
547 moves point to the spot.
550 Save the location of point in register R (`point-to-register').
553 Jump to the location saved in register R (`register-to-point').
555 To save the current location of point in a register, choose a name R
556 and type `C-x r SPC R'. The register R retains the location thus saved
557 until you store something else in that register.
559 The command `C-x r j R' moves point to the location recorded in
560 register R. The register is not affected; it continues to record the
561 same location. You can jump to the same position using the same
562 register as often as you want.
565 File: xemacs.info, Node: RegText, Next: RegRect, Prev: RegPos, Up: Registers
567 Saving Text in Registers
568 ========================
570 When you want to insert a copy of the same piece of text many times,
571 it can be impractical to use the kill ring, since each subsequent kill
572 moves the piece of text further down on the ring. It becomes hard to
573 keep track of the argument needed to retrieve the same text with `C-y'.
574 An alternative is to store the text in a register with `C-x r s'
575 (`copy-to-register') and then retrieve it with `C-x r g'
579 Copy region into register R (`copy-to-register').
582 Insert text contents of register R (`insert-register').
584 `C-x r s R' stores a copy of the text of the region into the
585 register named R. Given a numeric argument, `C-x r s' deletes the text
586 from the buffer as well.
588 `C-x r g R' inserts the text from register R in the buffer. By
589 default it leaves point before the text and places the mark after it.
590 With a numeric argument, it puts point after the text and the mark
594 File: xemacs.info, Node: RegRect, Prev: RegText, Up: Registers
596 Saving Rectangles in Registers
597 ==============================
599 A register can contain a rectangle instead of lines of text. The
600 rectangle is represented as a list of strings. *Note Rectangles::, for
601 basic information on rectangles and how to specify rectangles in a
605 Copy the region-rectangle into register
606 R(`copy-rectangle-to-register'). With a numeric argument, delete
610 Insert the rectangle stored in register R (if it contains a
611 rectangle) (`insert-register').
613 The `C-x r g' command inserts linear text if the register contains
614 that, or inserts a rectangle if the register contains one.
617 File: xemacs.info, Node: Display, Next: Search, Prev: Registers, Up: Top
619 Controlling the Display
620 ***********************
622 Since only part of a large buffer fits in the window, XEmacs tries
623 to show the part that is likely to be interesting. The display control
624 commands allow you to specify which part of the text you want to see.
627 Clear frame and redisplay, scrolling the selected window to center
628 point vertically within it (`recenter').
633 Scroll forward (a windowful or a specified number of lines)
634 (`scroll-up'). On most X keyboards, you can get this
635 functionality using the key labelled `Page Down', which generates
636 either `next' or `pgdn'.
641 Scroll backward (`scroll-down'). On most X keyboards, you can get
642 this functionality using the key labelled `Page Up', which
643 generates either `prior' or `pgup'.
646 Scroll so point is on line ARG (`recenter').
651 Scroll text in current window to the left (`scroll-left').
656 Scroll to the right (`scroll-right').
659 Make deeply indented lines invisible (`set-selective-display').
663 * Scrolling:: Moving text up and down in a window.
664 * Horizontal Scrolling:: Moving text left and right in a window.
665 * Selective Display:: Hiding lines with lots of indentation.
666 * Display Vars:: Information on variables for customizing display.
669 File: xemacs.info, Node: Scrolling, Next: Horizontal Scrolling, Prev: Display, Up: Display
674 If a buffer contains text that is too large to fit entirely within
675 the window that is displaying the buffer, XEmacs shows a contiguous
676 section of the text. The section shown always contains point.
678 "Scrolling" means moving text up or down in the window so that
679 different parts of the text are visible. Scrolling forward means that
680 text moves up, and new text appears at the bottom. Scrolling backward
681 moves text down and new text appears at the top.
683 Scrolling happens automatically if you move point past the bottom or
684 top of the window. You can also explicitly request scrolling with the
685 commands in this section.
688 Clear frame and redisplay, scrolling the selected window to center
689 point vertically within it (`recenter').
694 Scroll forward (a windowful or a specified number of lines)
700 Scroll backward (`scroll-down').
703 Scroll so point is on line ARG (`recenter').
705 The most basic scrolling command is `C-l' (`recenter') with no
706 argument. It clears the entire frame and redisplays all windows. In
707 addition, it scrolls the selected window so that point is halfway down
708 from the top of the window.
710 The scrolling commands `C-v' and `M-v' let you move all the text in
711 the window up or down a few lines. `C-v' (`scroll-up') with an
712 argument shows you that many more lines at the bottom of the window,
713 moving the text and point up together as `C-l' might. `C-v' with a
714 negative argument shows you more lines at the top of the window.
715 `Meta-v' (`scroll-down') is like `C-v', but moves in the opposite
718 To read the buffer a windowful at a time, use `C-v' with no
719 argument. `C-v' takes the last two lines at the bottom of the window
720 and puts them at the top, followed by nearly a whole windowful of lines
721 not previously visible. Point moves to the new top of the window if it
722 was in the text scrolled off the top. `M-v' with no argument moves
723 backward with similar overlap. The number of lines of overlap across a
724 `C-v' or `M-v' is controlled by the variable
725 `next-screen-context-lines'; by default, it is two.
727 Another way to scroll is using `C-l' with a numeric argument. `C-l'
728 does not clear the frame when given an argument; it only scrolls the
729 selected window. With a positive argument N, `C-l' repositions text to
730 put point N lines down from the top. An argument of zero puts point on
731 the very top line. Point does not move with respect to the text;
732 rather, the text and point move rigidly on the frame. `C-l' with a
733 negative argument puts point that many lines from the bottom of the
734 window. For example, `C-u - 1 C-l' puts point on the bottom line, and
735 `C-u - 5 C-l' puts it five lines from the bottom. Just `C-u' as
736 argument, as in `C-u C-l', scrolls point to the center of the frame.
738 Scrolling happens automatically if point has moved out of the visible
739 portion of the text when it is time to display. Usually scrolling is
740 done to put point vertically centered within the window. However, if
741 the variable `scroll-step' has a non-zero value, an attempt is made to
742 scroll the buffer by that many lines; if that is enough to bring point
743 back into visibility, that is what happens.
745 Scrolling happens automatically if point has moved out of the visible
746 portion of the text when it is time to display. Usually scrolling is
747 done to put point vertically centered within the window. However, if
748 the variable `scroll-step' has a non-zero value, an attempt is made to
749 scroll the buffer by that many lines; if that is enough to bring point
750 back into visibility, that is what happens.
752 If you set `scroll-step' to a small value because you want to use
753 arrow keys to scroll the screen without recentering, the redisplay
754 preemption will likely make XEmacs keep recentering the screen when
755 scrolling fast, regardless of `scroll-step'. To prevent this, set
756 `scroll-conservatively' to a small value, which will have the result of
757 overriding the redisplay preemption.
760 File: xemacs.info, Node: Horizontal Scrolling, Prev: Scrolling, Up: Display
766 Scroll text in current window to the left (`scroll-left').
769 Scroll to the right (`scroll-right').
771 The text in a window can also be scrolled horizontally. This means
772 that each line of text is shifted sideways in the window, and one or
773 more characters at the beginning of each line are not displayed at all.
774 When a window has been scrolled horizontally in this way, text lines
775 are truncated rather than continued (*note Continuation Lines::.), with
776 a `$' appearing in the first column when there is text truncated to the
777 left, and in the last column when there is text truncated to the right.
779 The command `C-x <' (`scroll-left') scrolls the selected window to
780 the left by N columns with argument N. With no argument, it scrolls by
781 almost the full width of the window (two columns less, to be precise).
782 `C-x >' (`scroll-right') scrolls similarly to the right. The window
783 cannot be scrolled any farther to the right once it is displaying
784 normally (with each line starting at the window's left margin);
785 attempting to do so has no effect.
788 File: xemacs.info, Node: Selective Display, Next: Display Vars, Prev: Display, Up: Display
793 XEmacs can hide lines indented more than a certain number of columns
794 (you specify how many columns). This allows you to get an overview of
797 To hide lines, type `C-x $' (`set-selective-display') with a numeric
798 argument N. (*Note Arguments::, for information on giving the
799 argument.) Lines with at least N columns of indentation disappear from
800 the screen. The only indication of their presence are three dots
801 (`...'), which appear at the end of each visible line that is followed
802 by one or more invisible ones.
804 The invisible lines are still present in the buffer, and most editing
805 commands see them as usual, so it is very easy to put point in the
806 middle of invisible text. When this happens, the cursor appears at the
807 end of the previous line, after the three dots. If point is at the end
808 of the visible line, before the newline that ends it, the cursor
809 appears before the three dots.
811 The commands `C-n' and `C-p' move across the invisible lines as if
814 To make everything visible again, type `C-x $' with no argument.
817 File: xemacs.info, Node: Display Vars, Prev: Selective Display, Up: Display
819 Variables Controlling Display
820 =============================
822 This section contains information for customization only. Beginning
823 users should skip it.
825 When you reenter XEmacs after suspending, XEmacs normally clears the
826 screen and redraws the entire display. On some terminals with more than
827 one page of memory, it is possible to arrange the termcap entry so that
828 the `ti' and `te' strings (output to the terminal when XEmacs is
829 entered and exited, respectively) switch between pages of memory so as
830 to use one page for XEmacs and another page for other output. In that
831 case, you might want to set the variable `no-redraw-on-reenter' to
832 non-`nil' so that XEmacs will assume, when resumed, that the screen
833 page it is using still contains what XEmacs last wrote there.
835 The variable `echo-keystrokes' controls the echoing of
836 multi-character keys; its value is the number of seconds of pause
837 required to cause echoing to start, or zero, meaning don't echo at all.
840 If the variable `ctl-arrow' is `nil', control characters in the
841 buffer are displayed with octal escape sequences, all except newline and
842 tab. If its value is `t', then control characters will be printed with
843 an up-arrow, for example `^A'.
845 If its value is not `t' and not `nil', then characters whose code is
846 greater than 160 (that is, the space character (32) with its high bit
847 set) will be assumed to be printable, and will be displayed without
848 alteration. This is the default when running under X Windows, since
849 XEmacs assumes an ISO/8859-1 character set (also known as "Latin1").
850 The `ctl-arrow' variable may also be set to an integer, in which case
851 all characters whose codes are greater than or equal to that value will
852 be assumed to be printable.
854 Altering the value of `ctl-arrow' makes it local to the current
855 buffer; until that time, the default value is in effect. *Note
858 Normally, a tab character in the buffer is displayed as whitespace
859 which extends to the next display tab stop position, and display tab
860 stops come at intervals equal to eight spaces. The number of spaces
861 per tab is controlled by the variable `tab-width', which is made local
862 by changing it, just like `ctl-arrow'. Note that how the tab character
863 in the buffer is displayed has nothing to do with the definition of
866 If you set the variable `selective-display-ellipses' to `nil', the
867 three dots at the end of a line that precedes invisible lines do not
868 appear. There is no visible indication of the invisible lines. This
869 variable becomes local automatically when set.
872 File: xemacs.info, Node: Search, Next: Fixit, Prev: Display, Up: Top
874 Searching and Replacement
875 *************************
877 Like other editors, Emacs has commands for searching for occurrences
878 of a string. The principal search command is unusual in that it is
879 "incremental": it begins to search before you have finished typing the
880 search string. There are also non-incremental search commands more like
881 those of other editors.
883 Besides the usual `replace-string' command that finds all
884 occurrences of one string and replaces them with another, Emacs has a
885 fancy replacement command called `query-replace' which asks
886 interactively which occurrences to replace.
890 * Incremental Search:: Search happens as you type the string.
891 * Non-Incremental Search:: Specify entire string and then search.
892 * Word Search:: Search for sequence of words.
893 * Regexp Search:: Search for match for a regexp.
894 * Regexps:: Syntax of regular expressions.
895 * Search Case:: To ignore case while searching, or not.
896 * Replace:: Search, and replace some or all matches.
897 * Other Repeating Search:: Operating on all matches for some regexp.
900 File: xemacs.info, Node: Incremental Search, Next: Non-Incremental Search, Prev: Search, Up: Search
905 An incremental search begins searching as soon as you type the first
906 character of the search string. As you type in the search string, Emacs
907 shows you where the string (as you have typed it so far) is found.
908 When you have typed enough characters to identify the place you want,
909 you can stop. Depending on what you do next, you may or may not need to
910 terminate the search explicitly with a <RET>.
913 Incremental search forward (`isearch-forward').
916 Incremental search backward (`isearch-backward').
918 `C-s' starts an incremental search. `C-s' reads characters from the
919 keyboard and positions the cursor at the first occurrence of the
920 characters that you have typed. If you type `C-s' and then `F', the
921 cursor moves right after the first `F'. Type an `O', and see the
922 cursor move to after the first `FO'. After another `O', the cursor is
923 after the first `FOO' after the place where you started the search.
924 Meanwhile, the search string `FOO' has been echoed in the echo area.
926 The echo area display ends with three dots when actual searching is
927 going on. When search is waiting for more input, the three dots are
928 removed. (On slow terminals, the three dots are not displayed.)
930 If you make a mistake in typing the search string, you can erase
931 characters with <DEL>. Each <DEL> cancels the last character of the
932 search string. This does not happen until Emacs is ready to read
933 another input character; first it must either find, or fail to find,
934 the character you want to erase. If you do not want to wait for this
935 to happen, use `C-g' as described below.
937 When you are satisfied with the place you have reached, you can type
938 <RET> (or <C-m>), which stops searching, leaving the cursor where the
939 search brought it. Any command not specially meaningful in searches
940 also stops the search and is then executed. Thus, typing `C-a' exits
941 the search and then moves to the beginning of the line. <RET> is
942 necessary only if the next command you want to type is a printing
943 character, <DEL>, <ESC>, or another control character that is special
944 within searches (`C-q', `C-w', `C-r', `C-s', or `C-y').
946 Sometimes you search for `FOO' and find it, but were actually
947 looking for a different occurance of it. To move to the next occurrence
948 of the search string, type another `C-s'. Do this as often as
949 necessary. If you overshoot, you can cancel some `C-s' characters with
952 After you exit a search, you can search for the same string again by
953 typing just `C-s C-s': the first `C-s' is the key that invokes
954 incremental search, and the second `C-s' means "search again".
956 If the specified string is not found at all, the echo area displays
957 the text `Failing I-Search'. The cursor is after the place where Emacs
958 found as much of your string as it could. Thus, if you search for
959 `FOOT', and there is no `FOOT', the cursor may be after the `FOO' in
960 `FOOL'. At this point there are several things you can do. If you
961 mistyped the search string, correct it. If you like the place you have
962 found, you can type <RET> or some other Emacs command to "accept what
963 the search offered". Or you can type `C-g', which removes from the
964 search string the characters that could not be found (the `T' in
965 `FOOT'), leaving those that were found (the `FOO' in `FOOT'). A second
966 `C-g' at that point cancels the search entirely, returning point to
967 where it was when the search started.
969 If a search is failing and you ask to repeat it by typing another
970 `C-s', it starts again from the beginning of the buffer. Repeating a
971 failing backward search with `C-r' starts again from the end. This is
972 called "wrapping around". `Wrapped' appears in the search prompt once
975 The `C-g' "quit" character does special things during searches; just
976 what it does depends on the status of the search. If the search has
977 found what you specified and is waiting for input, `C-g' cancels the
978 entire search. The cursor moves back to where you started the search.
979 If `C-g' is typed when there are characters in the search string that
980 have not been found--because Emacs is still searching for them, or
981 because it has failed to find them--then the search string characters
982 which have not been found are discarded from the search string. The
983 search is now successful and waiting for more input, so a second `C-g'
984 cancels the entire search.
986 To search for a control character such as `C-s' or <DEL> or <ESC>,
987 you must quote it by typing `C-q' first. This function of `C-q' is
988 analogous to its meaning as an Emacs command: it causes the following
989 character to be treated the way a graphic character would normally be
990 treated in the same context.
992 To search backwards, you can use `C-r' instead of `C-s' to start the
993 search; `C-r' is the key that runs the command (`isearch-backward') to
994 search backward. You can also use `C-r' to change from searching
995 forward to searching backwards. Do this if a search fails because the
996 place you started was too far down in the file. Repeated `C-r' keeps
997 looking for more occurrences backwards. `C-s' starts going forward
998 again. You can cancel `C-r' in a search with <DEL>.
1000 The characters `C-y' and `C-w' can be used in incremental search to
1001 grab text from the buffer into the search string. This makes it
1002 convenient to search for another occurrence of text at point. `C-w'
1003 copies the word after point as part of the search string, advancing
1004 point over that word. Another `C-s' to repeat the search will then
1005 search for a string including that word. `C-y' is similar to `C-w' but
1006 copies the rest of the current line into the search string.
1008 The characters `M-p' and `M-n' can be used in an incremental search
1009 to recall things which you have searched for in the past. A list of
1010 the last 16 things you have searched for is retained, and `M-p' and
1011 `M-n' let you cycle through that ring.
1013 The character `M-<TAB>' does completion on the elements in the
1014 search history ring. For example, if you know that you have recently
1015 searched for the string `POTATOE', you could type `C-s P O M-<TAB>'.
1016 If you had searched for other strings beginning with `PO' then you
1017 would be shown a list of them, and would need to type more to select
1020 You can change any of the special characters in incremental search
1021 via the normal keybinding mechanism: simply add a binding to the
1022 `isearch-mode-map'. For example, to make the character `C-b' mean
1023 "search backwards" while in isearch-mode, do this:
1025 (define-key isearch-mode-map "\C-b" 'isearch-repeat-backward)
1027 These are the default bindings of isearch-mode:
1030 Delete a character from the incremental search string
1031 (`isearch-delete-char').
1034 Exit incremental search (`isearch-exit').
1037 Quote special characters for incremental search
1038 (`isearch-quote-char').
1041 Repeat incremental search forward (`isearch-repeat-forward').
1044 Repeat incremental search backward (`isearch-repeat-backward').
1047 Pull rest of line from buffer into search string
1048 (`isearch-yank-line').
1051 Pull next word from buffer into search string
1052 (`isearch-yank-word').
1055 Cancels input back to what has been found successfully, or aborts
1056 the isearch (`isearch-abort').
1059 Recall the previous element in the isearch history ring
1060 (`isearch-ring-retreat').
1063 Recall the next element in the isearch history ring
1064 (`isearch-ring-advance').
1067 Do completion on the elements in the isearch history ring
1068 (`isearch-complete').
1070 Any other character which is normally inserted into a buffer when
1071 typed is automatically added to the search string in isearch-mode.
1073 Slow Terminal Incremental Search
1074 --------------------------------
1076 Incremental search on a slow terminal uses a modified style of
1077 display that is designed to take less time. Instead of redisplaying
1078 the buffer at each place the search gets to, it creates a new
1079 single-line window and uses that to display the line the search has
1080 found. The single-line window appears as soon as point gets outside of
1081 the text that is already on the screen.
1083 When the search is terminated, the single-line window is removed.
1084 Only at this time the window in which the search was done is
1085 redisplayed to show its new value of point.
1087 The three dots at the end of the search string, normally used to
1088 indicate that searching is going on, are not displayed in slow style
1091 The slow terminal style of display is used when the terminal baud
1092 rate is less than or equal to the value of the variable
1093 `search-slow-speed', initially 1200.
1095 The number of lines to use in slow terminal search display is
1096 controlled by the variable `search-slow-window-lines'. Its normal
1100 File: xemacs.info, Node: Non-Incremental Search, Next: Word Search, Prev: Incremental Search, Up: Search
1102 Non-Incremental Search
1103 ======================
1105 Emacs also has conventional non-incremental search commands, which
1106 require you type the entire search string before searching begins.
1108 `C-s <RET> STRING <RET>'
1111 `C-r <RET> STRING <RET>'
1112 Search backward for STRING.
1114 To do a non-incremental search, first type `C-s <RET>' (or `C-s
1115 C-m'). This enters the minibuffer to read the search string.
1116 Terminate the string with <RET> to start the search. If the string is
1117 not found, the search command gets an error.
1119 By default, `C-s' invokes incremental search, but if you give it an
1120 empty argument, which would otherwise be useless, it invokes
1121 non-incremental search. Therefore, `C-s <RET>' invokes non-incremental
1122 search. `C-r <RET>' also works this way.
1124 Forward and backward non-incremental searches are implemented by the
1125 commands `search-forward' and `search-backward'. You can bind these
1126 commands to keys. The reason that incremental search is programmed to
1127 invoke them as well is that `C-s <RET>' is the traditional sequence of
1128 characters used in Emacs to invoke non-incremental search.
1130 Non-incremental searches performed using `C-s <RET>' do not call
1131 `search-forward' right away. They first check if the next character is
1132 `C-w', which requests a word search. *Note Word Search::.
1135 File: xemacs.info, Node: Word Search, Next: Regexp Search, Prev: Non-Incremental Search, Up: Search
1140 Word search looks for a sequence of words without regard to how the
1141 words are separated. More precisely, you type a string of many words,
1142 using single spaces to separate them, and the string is found even if
1143 there are multiple spaces, newlines or other punctuation between the
1146 Word search is useful in editing documents formatted by text
1147 formatters. If you edit while looking at the printed, formatted
1148 version, you can't tell where the line breaks are in the source file.
1149 Word search, allows you to search without having to know the line
1152 `C-s <RET> C-w WORDS <RET>'
1153 Search for WORDS, ignoring differences in punctuation.
1155 `C-r <RET> C-w WORDS <RET>'
1156 Search backward for WORDS, ignoring differences in punctuation.
1158 Word search is a special case of non-incremental search. It is
1159 invoked with `C-s <RET> C-w' followed by the search string, which must
1160 always be terminated with another <RET>. Being non-incremental, this
1161 search does not start until the argument is terminated. It works by
1162 constructing a regular expression and searching for that. *Note Regexp
1165 You can do a backward word search with `C-r <RET> C-w'.
1167 Forward and backward word searches are implemented by the commands
1168 `word-search-forward' and `word-search-backward'. You can bind these
1169 commands to keys. The reason that incremental search is programmed to
1170 invoke them as well is that `C-s <RET> C-w' is the traditional Emacs
1171 sequence of keys for word search.
projects / chise / xemacs-chise.git.1 / blob