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: Completion, Next: Repetition, Prev: Minibuffer Edit, Up: Minibuffer
38 When appropriate, the minibuffer provides a "completion" facility.
39 You type the beginning of an argument and one of the completion keys,
40 and Emacs visibly fills in the rest, depending on what you have already
43 When completion is available, certain keys--<TAB>, <RET>, and
44 <SPC>--are redefined to complete an abbreviation present in the
45 minibuffer into a longer string that it stands for, by matching it
46 against a set of "completion alternatives" provided by the command
47 reading the argument. `?' is defined to display a list of possible
48 completions of what you have inserted.
50 For example, when the minibuffer is being used by `Meta-x' to read
51 the name of a command, it is given a list of all available Emacs command
52 names to complete against. The completion keys match the text in the
53 minibuffer against all the command names, find any additional
54 characters of the name that are implied by the ones already present in
55 the minibuffer, and add those characters to the ones you have given.
57 Case is normally significant in completion because it is significant
58 in most of the names that you can complete (buffer names, file names,
59 and command names). Thus, `fo' will not complete to `Foo'. When you
60 are completing a name in which case does not matter, case may be ignored
61 for completion's sake if specified by program.
63 When a completion list is displayed, the completions will highlight
64 as you move the mouse over them. Clicking the middle mouse button on
65 any highlighted completion will "select" it just as if you had typed it
71 Consider the following example. If you type `Meta-x au <TAB>',
72 <TAB> looks for alternatives (in this case, command names) that start
73 with `au'. There are only two commands: `auto-fill-mode' and
74 `auto-save-mode'. They are the same as far as `auto-', so the `au' in
75 the minibuffer changes to `auto-'.
77 If you type <TAB> again immediately, there are multiple possibilities
78 for the very next character--it could be `s' or `f'--so no more
79 characters are added; but a list of all possible completions is
80 displayed in another window.
82 If you go on to type `f <TAB>', this <TAB> sees `auto-f'. The only
83 command name starting this way is `auto-fill-mode', so completion
84 inserts the rest of that command. You now have `auto-fill-mode' in the
85 minibuffer after typing just `au <TAB> f <TAB>'. Note that <TAB> has
86 this effect because in the minibuffer it is bound to the function
87 `minibuffer-complete' when completion is supposed to be done.
92 Here is a list of all the completion commands defined in the
93 minibuffer when completion is available.
96 Complete the text in the minibuffer as much as possible
97 (`minibuffer-complete').
100 Complete the text in the minibuffer but don't add or fill out more
101 than one word (`minibuffer-complete-word').
104 Submit the text in the minibuffer as the argument, possibly
105 completing first as described below
106 (`minibuffer-complete-and-exit').
109 Print a list of all possible completions of the text in the
110 minibuffer (`minibuffer-list-completions').
113 Select the highlighted text under the mouse as a minibuffer
114 response. When the minibuffer is being used to prompt the user
115 for a completion, any valid completions which are visible on the
116 screen will be highlighted when the mouse moves over them.
117 Clicking <button2> will select the highlighted completion and exit
118 the minibuffer. (`minibuf-select-highlighted-completion').
120 <SPC> completes in a way that is similar to <TAB>, but it never goes
121 beyond the next hyphen or space. If you have `auto-f' in the
122 minibuffer and type <SPC>, it finds that the completion is
123 `auto-fill-mode', but it stops completing after `fill-'. The result is
124 `auto-fill-'. Another <SPC> at this point completes all the way to
125 `auto-fill-mode'. <SPC> in the minibuffer runs the function
126 `minibuffer-complete-word' when completion is available.
128 There are three different ways that <RET> can work in completing
129 minibuffers, depending on how the argument will be used.
131 * "Strict" completion is used when it is meaningless to give any
132 argument except one of the known alternatives. For example, when
133 `C-x k' reads the name of a buffer to kill, it is meaningless to
134 give anything but the name of an existing buffer. In strict
135 completion, <RET> refuses to exit if the text in the minibuffer
136 does not complete to an exact match.
138 * "Cautious" completion is similar to strict completion, except that
139 <RET> exits only if the text was an exact match already, not
140 needing completion. If the text is not an exact match, <RET> does
141 not exit, but it does complete the text. If it completes to an
142 exact match, a second <RET> will exit.
144 Cautious completion is used for reading file names for files that
147 * "Permissive" completion is used when any string is meaningful, and
148 the list of completion alternatives is just a guide. For example,
149 when `C-x C-f' reads the name of a file to visit, any file name is
150 allowed, in case you want to create a file. In permissive
151 completion, <RET> takes the text in the minibuffer exactly as
152 given, without completing it.
154 The completion commands display a list of all possible completions
155 in a window whenever there is more than one possibility for the very
156 next character. Typing `?' explicitly requests such a list. The list
157 of completions counts as help text, so `C-M-v' typed in the minibuffer
160 When completion is done on file names, certain file names are usually
161 ignored. The variable `completion-ignored-extensions' contains a list
162 of strings; a file whose name ends in any of those strings is ignored
163 as a possible completion. The standard value of this variable has
164 several elements including `".o"', `".elc"', `".dvi"' and `"~"'. The
165 effect is that, for example, `foo' completes to `foo.c' even though
166 `foo.o' exists as well. If the only possible completions are files
167 that end in "ignored" strings, they are not ignored.
169 If a completion command finds the next character is undetermined, it
170 automatically displays a list of all possible completions. If the
171 variable `completion-auto-help' is set to `nil', this does not happen,
172 and you must type `?' to display the possible completions.
174 If the variable `minibuffer-confirm-incomplete' is set to `t', then
175 in contexts where `completing-read' allows answers that are not valid
176 completions, an extra <RET> must be typed to confirm the response.
177 This is helpful for catching typos.
180 File: xemacs.info, Node: Repetition, Prev: Completion, Up: Minibuffer
182 Repeating Minibuffer Commands
183 =============================
185 Every command that uses the minibuffer at least once is recorded on a
186 special history list, together with the values of the minibuffer
187 arguments, so that you can repeat the command easily. In particular,
188 every use of `Meta-x' is recorded, since `M-x' uses the minibuffer to
189 read the command name.
192 Re-execute a recent minibuffer command
193 (`repeat-complex-command').
196 Within `C-x <ESC>', move to previous recorded command
197 (`previous-history-element').
200 Within `C-x <ESC>', move to the next (more recent) recorded
201 command (`next-history-element').
203 `M-x list-command-history'
204 Display the entire command history, showing all the commands `C-x
205 <ESC>' can repeat, most recent first.
207 `C-x <ESC>' is used to re-execute a recent command that used the
208 minibuffer. With no argument, it repeats the last command. A numeric
209 argument specifies which command to repeat; 1 means the last one, and
210 larger numbers specify earlier commands.
212 `C-x <ESC>' works by turning the previous command into a Lisp
213 expression and then entering a minibuffer initialized with the text for
214 that expression. If you type just <RET>, the command is repeated as
215 before. You can also change the command by editing the Lisp expression.
216 The expression you finally submit will be executed. The repeated
217 command is added to the front of the command history unless it is
218 identical to the most recently executed command already there.
220 Even if you don't understand Lisp syntax, it will probably be obvious
221 which command is displayed for repetition. If you do not change the
222 text, you can be sure the command will repeat exactly as before.
224 If you are in the minibuffer for `C-x <ESC>' and the command shown
225 to you is not the one you want to repeat, you can move around the list
226 of previous commands using `M-n' and `M-p'. `M-p' replaces the
227 contents of the minibuffer with the next earlier recorded command, and
228 `M-n' replaces it with the next later command. After finding the
229 desired previous command, you can edit its expression and then resubmit
230 it by typing <RET>. Any editing you have done on the command to be
231 repeated is lost if you use `M-n' or `M-p'.
233 `M-n' and `M-p' are specially defined within `C-x <ESC>' to run the
234 commands `previous-history-element' and `next-history-element'.
236 The list of previous commands using the minibuffer is stored as a
237 Lisp list in the variable `command-history'. Each element of the list
238 is a Lisp expression which describes one command and its arguments.
239 Lisp programs can reexecute a command by feeding the corresponding
240 `command-history' element to `eval'.
243 File: xemacs.info, Node: M-x, Next: Help, Prev: Minibuffer, Up: Top
245 Running Commands by Name
246 ************************
248 The Emacs commands that are used often or that must be quick to type
249 are bound to keys--short sequences of characters--for convenient use.
250 Other Emacs commands that are used more rarely are not bound to keys;
251 to run them, you must refer to them by name.
253 A command name consists, by convention, of one or more words,
254 separated by hyphens: for example, `auto-fill-mode' or `manual-entry'.
255 The use of English words makes the command name easier to remember than
256 a key made up of obscure characters, even though it results in more
257 characters to type. You can run any command by name, even if it can be
260 To run a command by name, start with `M-x', then type the command
261 name, and finish with <RET>. `M-x' uses the minibuffer to read the
262 command name. <RET> exits the minibuffer and runs the command.
264 Emacs uses the minibuffer for reading input for many different
265 purposes; on this occasion, the string `M-x' is displayed at the
266 beginning of the minibuffer as a "prompt" to remind you that your input
267 should be the name of a command to be run. *Note Minibuffer::, for
268 full information on the features of the minibuffer.
270 You can use completion to enter a command name. For example, to
271 invoke the command `forward-char', type:
273 M-x forward-char <RET>
277 After you type in `M-x fo TAB' emacs will give you a possible list of
278 completions from which you can choose. Note that `forward-char' is the
279 same command that you invoke with the key `C-f'. You can call any
280 command (interactively callable function) defined in Emacs by its name
281 using `M-x' regardless of whether or not any keys are bound to it.
283 If you type `C-g' while Emacs reads the command name, you cancel the
284 `M-x' command and get out of the minibuffer, ending up at top level.
286 To pass a numeric argument to a command you are invoking with `M-x',
287 specify the numeric argument before the `M-x'. `M-x' passes the
288 argument along to the function that it calls. The argument value
289 appears in the prompt while the command name is being read.
291 You can use the command `M-x interactive' to specify a way of
292 parsing arguments for interactive use of a function. For example,
295 (defun foo (arg) "Doc string" (interactive "p") ...use arg...)
297 to make `arg' be the prefix argument when `foo' is called as a
298 command. The call to `interactive' is actually a declaration rather
299 than a function; it tells `call-interactively' how to read arguments to
300 pass to the function. When actually called, `interactive' returns
303 The argument of INTERACTIVE is usually a string containing a code
304 letter followed by a prompt. Some code letters do not use I/O to get
305 the argument and do not need prompts. To prompt for multiple arguments,
306 you must provide a code letter, its prompt, a newline, and another code
307 letter, and so forth. If the argument is not a string, it is evaluated
308 to get a list of arguments to pass to the function. If you do not
309 provide an argument to `interactive', no arguments are passed when
310 calling interactively.
312 Available code letters are:
315 Function name: symbol with a function definition
318 Name of existing buffer
321 Name of buffer, possibly nonexistent
327 Command name: symbol with interactive function definition
330 Value of point as number (does not do I/O)
342 Possibly nonexistent file name
345 Key sequence (string)
348 Value of mark as number (does not do I/O)
351 Number read using minibuffer
354 Prefix arg converted to number, or if none, do like code `n'
357 Prefix arg converted to number (does not do I/O)
360 Prefix arg in raw form (does not do I/O)
363 Region: point and mark as two numeric arguments, smallest first
373 Variable name: symbol that is `user-variable-p'
376 Lisp expression read but not evaluated
379 Lisp expression read and evaluated
381 In addition, if the string begins with `*', an error is signaled if
382 the buffer is read-only. This happens before reading any arguments.
383 If the string begins with `@', the window the mouse is over is selected
384 before anything else is done. You may use both `@' and `*'; they are
385 processed in the order that they appear.
387 Normally, when describing a command that is run by name, we omit the
388 <RET> that is needed to terminate the name. Thus we may refer to `M-x
389 auto-fill-mode' rather than `M-x auto-fill-mode' <RET>. We mention the
390 <RET> only when it is necessary to emphasize its presence, for example,
391 when describing a sequence of input that contains a command name and
392 arguments that follow it.
394 `M-x' is defined to run the command `execute-extended-command',
395 which is responsible for reading the name of another command and
399 File: xemacs.info, Node: Help, Next: Mark, Prev: M-x, Up: Top
404 Emacs provides extensive help features which revolve around a single
405 character, `C-h'. `C-h' is a prefix key that is used only for
406 documentation-printing commands. The characters you can type after
407 `C-h' are called "help options". One help option is `C-h'; you use it
408 to ask for help about using `C-h'.
410 `C-h C-h' prints a list of the possible help options, and then asks
411 you to type the desired option. It prompts with the string:
413 A, B, C, F, I, K, L, M, N, S, T, V, W, C-c, C-d, C-n, C-w or C-h for more help:
415 You should type one of those characters.
417 Typing a third `C-h' displays a description of what the options mean;
418 Emacs still waits for you to type an option. To cancel, type `C-g'.
420 Here is a summary of the defined help commands.
423 Display a list of commands whose names contain STRING (`command-
427 Display a table of all key bindings currently in effect, with
428 local bindings of the current major mode first, followed by all
429 global bindings (`describe-bindings').
432 Print the name of the command that KEY runs (`describe-key-
433 briefly'). `c' is for `character'. For more extensive
434 information on KEY, use `C-h k'.
436 `C-h f FUNCTION <RET>'
437 Display documentation on the Lisp function named FUNCTION
438 (`describe-function'). Note that commands are Lisp functions, so
439 a command name may be used.
442 Run Info, the program for browsing documentation files (`info').
443 The complete Emacs manual is available online in Info.
446 Display name and documentation of the command KEY runs
450 Display a description of the last 100 characters you typed
454 Display documentation of the current major mode (`describe-mode').
457 Display documentation of Emacs changes, most recent first
461 Display a table of all mouse bindings currently in effect now, with
462 local bindings of the current major mode first, followed by all
463 global bindings (`describe-pointer').
466 Display current contents of the syntax table, plus an explanation
467 of what they mean (`describe-syntax').
470 Display the Emacs tutorial (`help-with-tutorial').
473 Display the documentation of the Lisp variable VAR (`describe-
476 `C-h w COMMAND <RET>'
477 Print which keys run the command named COMMAND (`where-is').
480 Show all symbols whose names contain matches for REGEXP.
482 Documentation for a Key
483 =======================
485 The most basic `C-h' options are `C-h c' (`describe-key-briefly')
487 (`describe-key'). `C-h c KEY' prints the name of the command that KEY
488 is bound to in the echo area. For example, `C-h c C-f' prints
489 `forward-char'. Since command names are chosen to describe what the
490 command does, using this option is a good way to get a somewhat cryptic
491 description of what KEY does.
493 `C-h k KEY' is similar to `C-h c' but gives more information. It
494 displays the documentation string of the function KEY is bound to as
495 well as its name. KEY is a string or vector of events. When called
496 interactively, KEY may also be a menu selection. This information does
497 not usually fit into the echo area, so a window is used for the display.
499 Help by Command or Variable Name
500 ================================
502 `C-h f' (`describe-function') reads the name of a Lisp function
503 using the minibuffer, then displays that function's documentation
504 string in a window. Since commands are Lisp functions, you can use the
505 argument FUNCTION to get the documentation of a command that you know
506 by name. For example,
508 C-h f auto-fill-mode <RET>
510 displays the documentation for `auto-fill-mode'. Using `C-h f' is the
511 only way to see the documentation of a command that is not bound to any
512 key, that is, a command you would normally call using `M-x'. If the
513 variable `describe-function-show-arglist' is `t', `describe-function'
514 shows its arglist if the FUNCTION is not an autoload function.
516 `C-h f' is also useful for Lisp functions you are planning to use in
517 a Lisp program. For example, if you have just written the code
518 `(make-vector len)' and want to make sure you are using `make-vector'
519 properly, type `C-h f make-vector <RET>'. Because `C-h f' allows all
520 function names, not just command names, you may find that some of your
521 favorite abbreviations that work in `M-x' don't work in `C-h f'. An
522 abbreviation may be unique among command names, yet fail to be unique
523 when other function names are allowed.
525 If you type <RET>, leaving the minibuffer empty, `C-h f' by default
526 describes the function called by the innermost Lisp expression in the
527 buffer around point, provided that that is a valid, defined Lisp
528 function name. For example, if point is located following the text
529 `(make-vector (car x)', the innermost list containing point is the one
530 starting with `(make-vector', so the default is to describe the
531 function `make-vector'.
533 `C-h f' is often useful just to verify that you have the right
534 spelling for the function name. If `C-h f' mentions a default in the
535 prompt, you have typed the name of a defined Lisp function. If that is
536 what you wanted to know, just type `C-g' to cancel the `C-h f' command
537 and continue editing.
539 `C-h w COMMAND <RET>' (`where-s') tells you what keys are bound to
540 COMMAND. It prints a list of the keys in the echo area. Alternatively,
541 it informs you that a command is not bound to any keys, which implies
542 that you must use `M-x' to call the command.
544 `C-h v' (`describe-variable') is like `C-h f' but describes Lisp
545 variables instead of Lisp functions. Its default is the Lisp symbol
546 around or before point, if that is the name of a known Lisp variable.
553 Show only symbols that are names of commands (`command-apropos').
556 Show all symbols whose names comtain matches for REGEXP.
558 It is possible to ask a question like, "What are the commands for
559 working with files?" To do this, type `C-h a file <RET>', which
560 displays a list of all command names that contain `file', such as
561 `copy-file', `find-file', and so on. With each command name a brief
562 description of its use and information on the keys you can use to
563 invoke it is displayed. For example, you would be informed that you
564 can invoke `find-file' by typing `C-x C-f'. The `a' in `C-h a' stands
565 for `Apropos'; `C-h a' runs the Lisp function `command-apropos'.
567 Because `C-h a' looks only for functions whose names contain the
568 string you specify, you must use ingenuity in choosing the string. If
569 you are looking for commands for killing backwards and `C-h a
570 kill-backwards <RET>' doesn't reveal any commands, don't give up. Try
571 just `kill', or just `backwards', or just `back'. Be persistent.
572 Pretend you are playing Adventure. Also note that you can use a
573 regular expression as the argument (*note Regexps::.).
575 Here is a set of arguments to give to `C-h a' that covers many
576 classes of Emacs commands, since there are strong conventions for naming
577 standard Emacs commands. By giving you a feeling for the naming
578 conventions, this set of arguments can also help you develop a
579 technique for picking `apropos' strings.
581 char, line, word, sentence, paragraph, region, page, sexp, list,
582 defun, buffer, frame, window, file, dir, register, mode,
583 beginning, end, forward, backward, next, previous, up, down,
584 search, goto, kill, delete, mark, insert, yank, fill, indent, case,
585 change, set, what, list, find, view, describe.
587 To list all Lisp symbols that contain a match for a regexp, not just
588 the ones that are defined as commands, use the command `M-x apropos'
594 `C-h i' (`info') runs the Info program, which is used for browsing
595 through structured documentation files. The entire Emacs manual is
596 available within Info. Eventually all the documentation of the GNU
597 system will be available. Type `h' after entering Info to run a
598 tutorial on using Info.
600 If something surprising happens, and you are not sure what commands
601 you typed, use `C-h l' (`view-lossage'). `C-h l' prints the last 100
602 command characters you typed. If you see commands you don't know, use
603 `C-h c' to find out what they do.
605 Emacs has several major modes. Each mode redefines a few keys and
606 makes a few other changes in how editing works. `C-h m'
607 (`describe-mode') prints documentation on the current major mode, which
608 normally describes all the commands that are changed in this mode.
610 `C-h b' (`describe-bindings') and `C-h s' (`describe-syntax')
611 present information about the current Emacs mode that is not covered by
612 `C-h m'. `C-h b' displays a list of all key bindings currently in
613 effect, with the local bindings of the current major mode first,
614 followed by the global bindings (*note Key Bindings::.). `C-h s'
615 displays the contents of the syntax table with explanations of each
616 character's syntax (*note Syntax::.).
618 The other `C-h' options display various files of useful information.
619 `C-h C-w' (`describe-no-warranty') displays details on the complete
620 absence of warranty for XEmacs. `C-h n' (`view-emacs-news') displays
621 the file `emacs/etc/NEWS', which contains documentation on Emacs
622 changes arranged chronologically. `C-h t' (`help-with-tutorial')
623 displays the learn-by-doing Emacs tutorial. `C-h C-c'
624 (`describe-copying') displays the file `emacs/etc/COPYING', which tells
625 you the conditions you must obey in distributing copies of Emacs. `C-h
626 C-d' (`describe-distribution') displays another file named
627 `emacs/etc/DISTRIB', which tells you how you can order a copy of the
628 latest version of Emacs.
631 File: xemacs.info, Node: Mark, Next: Mouse Selection, Prev: Help, Up: Top
636 Many Emacs commands operate on an arbitrary contiguous part of the
637 current buffer. You can select text in two ways:
639 * You use special keys to select text by defining a region between
642 * If you are running XEmacs under X, you can also select text with
645 The Mark and the Region
646 =======================
648 To specify the text for a command to operate on, set "the mark" at
649 one end of it, and move point to the other end. The text between point
650 and the mark is called "the region". You can move point or the mark to
651 adjust the boundaries of the region. It doesn't matter which one is
652 set first chronologically, or which one comes earlier in the text.
654 Once the mark has been set, it remains until it is set again at
655 another place. The mark remains fixed with respect to the preceding
656 character if text is inserted or deleted in a buffer. Each Emacs
657 buffer has its own mark; when you return to a buffer that had been
658 selected previously, it has the same mark it had before.
660 Many commands that insert text, such as `C-y' (`yank') and `M-x
661 insert-buffer', position the mark at one end of the inserted text--the
662 opposite end from where point is positioned, so that the region
663 contains the text just inserted.
665 Aside from delimiting the region, the mark is useful for marking a
666 spot that you may want to go back to. To make this feature more useful,
667 Emacs remembers 16 previous locations of the mark in the `mark ring'.
671 * Setting Mark:: Commands to set the mark.
672 * Using Region:: Summary of ways to operate on contents of the region.
673 * Marking Objects:: Commands to put region around textual units.
674 * Mark Ring:: Previous mark positions saved so you can go back there.
677 File: xemacs.info, Node: Setting Mark, Next: Using Region, Prev: Mark, Up: Mark
682 Here are some commands for setting the mark:
685 Set the mark where point is (`set-mark-command').
691 Interchange mark and point (`exchange-point-and-mark').
694 Pushes a mark at the beginning of the buffer.
697 Pushes a mark at the end of the buffer.
699 For example, to convert part of the buffer to all upper-case, you
700 can use the `C-x C-u' (`upcase-region') command, which operates on the
701 text in the region. First go to the beginning of the text you want to
702 capitalize and type `C-<SPC>' to put the mark there, then move to the
703 end, and then type `C-x C-u' to capitalize the selected region. You
704 can also set the mark at the end of the text, move to the beginning,
705 and then type `C-x C-u'. Most commands that operate on the text in the
706 region have the word `region' in their names.
708 The most common way to set the mark is with the `C-<SPC>' command
709 (`set-mark-command'). This command sets the mark where point is. You
710 can then move point away, leaving the mark behind. It is actually
711 incorrect to speak of the character `C-<SPC>'; there is no such
712 character. When you type <SPC> while holding down <CTRL>, you get the
713 character `C-@' on most terminals. This character is actually bound to
714 `set-mark-command'. But unless you are unlucky enough to have a
715 terminal where typing `C-<SPC>' does not produce `C-@', you should
716 think of this character as `C-<SPC>'.
718 Since terminals have only one cursor, Emacs cannot show you where the
719 mark is located. Most people use the mark soon after they set it, before
720 they forget where it is. But you can see where the mark is with the
721 command `C-x C-x' (`exchange-point-and-mark') which puts the mark where
722 point was and point where the mark was. The extent of the region is
723 unchanged, but the cursor and point are now at the previous location of
726 Another way to set the mark is to push the mark to the beginning of a
727 buffer while leaving point at its original location. If you supply an
728 argument to `C-<' (`mark-beginning-of-buffer'), the mark is pushed N/10
729 of the way from the true beginning of the buffer. You can also set the
730 mark at the end of a buffer with `C->' (`mark-end-of-buffer'). It
731 pushes the mark to the end of the buffer, leaving point alone.
732 Supplying an argument to the command pushes the mark N/10 of the way
733 from the true end of the buffer.
735 If you are using XEmacs under the X window system, you can set the
736 variable `zmacs-regions' to `t'. This makes the current region (defined
737 by point and mark) highlight and makes it available as the X clipboard
738 selection, which means you can use the menu bar items on it. *Note
739 Active Regions::, for more information.
741 `C-x C-x' is also useful when you are satisfied with the location of
742 point but want to move the mark; do `C-x C-x' to put point there and
743 then you can move it. A second use of `C-x C-x', if necessary, puts
744 the mark at the new location with point back at its original location.
747 File: xemacs.info, Node: Using Region, Next: Marking Objects, Prev: Setting Mark, Up: Mark
749 Operating on the Region
750 -----------------------
752 Once you have created an active region, you can do many things to
754 * Kill it with `C-w' (*note Killing::.).
756 * Save it in a register with `C-x r s' (*note Registers::.).
758 * Save it in a buffer or a file (*note Accumulating Text::.).
760 * Convert case with `C-x C-l' or `C-x C-u'
763 * Evaluate it as Lisp code with `M-x eval-region' (*note Lisp
766 * Fill it as text with `M-q' (*note Filling::.).
768 * Print hardcopy with `M-x print-region' (*note Hardcopy::.).
770 * Indent it with `C-x <TAB>' or `C-M-\' (*note Indentation::.).
773 File: xemacs.info, Node: Marking Objects, Next: Mark Ring, Prev: Using Region, Up: Mark
775 Commands to Mark Textual Objects
776 --------------------------------
778 There are commands for placing point and the mark around a textual
779 object such as a word, list, paragraph or page.
782 Set mark after end of next word (`mark-word'). This command and
783 the following one do not move point.
786 Set mark after end of next Lisp expression (`mark-sexp').
789 Put region around current paragraph (`mark-paragraph').
792 Put region around current Lisp defun (`mark-defun').
795 Put region around entire buffer (`mark-whole-buffer').
798 Put region around current page (`mark-page').
800 `M-@' (`mark-word') puts the mark at the end of the next word, while
801 `C-M-@' (`mark-sexp') puts it at the end of the next Lisp expression.
802 These characters sometimes save you some typing.
804 A number of commands are available that set both point and mark and
805 thus delimit an object in the buffer. `M-h' (`mark-paragraph') moves
806 point to the beginning of the paragraph that surrounds or follows
807 point, and puts the mark at the end of that paragraph (*note
808 Paragraphs::.). You can then indent, case-convert, or kill the whole
809 paragraph. In the same fashion, `C-M-h' (`mark-defun') puts point
810 before and the mark after the current or following defun (*note
811 Defuns::.). `C-x C-p' (`mark-page') puts point before the current page
812 (or the next or previous, depending on the argument), and mark at the
813 end (*note Pages::.). The mark goes after the terminating page
814 delimiter (to include it), while point goes after the preceding page
815 delimiter (to exclude it). Finally, `C-x h' (`mark-whole-buffer') sets
816 up the entire buffer as the region by putting point at the beginning
817 and the mark at the end.
820 File: xemacs.info, Node: Mark Ring, Prev: Marking Objects, Up: Mark
825 Aside from delimiting the region, the mark is also useful for marking
826 a spot that you may want to go back to. To make this feature more
827 useful, Emacs remembers 16 previous locations of the mark in the "mark
828 ring". Most commands that set the mark push the old mark onto this
829 ring. To return to a marked location, use `C-u C-<SPC>' (or `C-u
830 C-@'); this is the command `set-mark-command' given a numeric argument.
831 The command moves point to where the mark was, and restores the mark
832 from the ring of former marks. Repeated use of this command moves point
833 to all the old marks on the ring, one by one. The marks you have seen
834 go to the end of the ring, so no marks are lost.
836 Each buffer has its own mark ring. All editing commands use the
837 current buffer's mark ring. In particular, `C-u C-<SPC>' always stays
840 Many commands that can move long distances, such as `M-<'
841 (`beginning-of-buffer'), start by setting the mark and saving the old
842 mark on the mark ring. This makes it easier for you to move back
843 later. Searches set the mark, unless they do not actually move point.
844 When a command sets the mark, `Mark Set' is printed in the echo area.
846 The variable `mark-ring-max' is the maximum number of entries to
847 keep in the mark ring. If that many entries exist and another entry is
848 added, the last entry in the list is discarded. Repeating `C-u
849 C-<SPC>' circulates through the entries that are currently in the ring.
851 The variable `mark-ring' holds the mark ring itself, as a list of
852 marker objects in the order most recent first. This variable is local
856 File: xemacs.info, Node: Mouse Selection, Next: Additional Mouse Operations, Prev: Mark, Up: Top
858 Selecting Text with the Mouse
859 =============================
861 If you are using XEmacs under X, you can use the mouse pointer to
862 select text. (The normal mouse pointer is an I-beam, the same pointer
865 The glyph variable `text-pointer-glyph' controls the shape of the
866 mouse pointer when over text. You can also control the shape of the
867 mouse pointer when over nontext using `nontext-pointer-glyph', and the
868 shape of the mouse pointer when over the modeline using
869 `modeline-pointer-glyph'. (Remember, you should use `set-glyph-image',
870 not `setq', to set one of these variables.)
872 If you want to get fancy, you can set the foreground and background
873 colors of the mouse pointer by setting the `pointer' face.
875 There are two ways to select a region of text with the mouse:
877 To select a word in text, double-click with the left mouse button
878 while the mouse cursor is over the word. The word is highlighted when
879 selected. On monochrome monitors, a stippled background indicates that a
880 region of text has been highlighted. On color monitors, a color
881 background indicates highlighted text. You can triple-click to select
884 To select an arbitrary region of text:
886 1. Move the mouse cursor over the character at the beginning of the
887 region of text you want to select.
889 2. Press and hold the left mouse button.
891 3. While holding the left mouse button down, drag the cursor to the
892 character at the end of the region of text you want to select.
894 4. Release the left mouse button.
895 The selected region of text is highlighted.
897 Once a region of text is selected, it becomes the primary X selection
898 (*note Using X Selections::.) as well as the Emacs selected region. You
899 can paste it into other X applications and use the options from the
900 Edit pull-down menu on it. Since it is also the Emacs region, you can
901 use Emacs region commands on it.
904 File: xemacs.info, Node: Additional Mouse Operations, Next: Killing, Prev: Mouse Selection, Up: Top
906 Additional Mouse Operations
907 ===========================
909 XEmacs also provides the following mouse functions. Most of these
910 are not bound to mouse gestures by default, but they are provided for
911 your customization pleasure. For example, if you wanted `shift-left'
912 (that is, holding down the <Shift> key and clicking the left mouse
913 button) to delete the character at which you are pointing, then you
916 (global-set-key '(shift button1) 'mouse-del-char)
919 Delete the character pointed to by the mouse.
921 `mouse-delete-window'
922 Delete the Emacs window that the mouse is on.
924 `mouse-keep-one-window'
925 Select the Emacs window that the mouse is on, then delete all other
926 windows on this frame.
929 Kill the line pointed to by the mouse.
932 Print the length of the line indicated by the pointer.
935 Scroll point to the mouse position.
938 Select the Emacs window the mouse is on.
940 `mouse-select-and-split'
941 Select the Emacs window mouse is on, then split it vertically in
945 Select the Emacs window the mouse is on and set the mark at the
946 mouse position. Display the cursor at that position for a second.
949 Select the Emacs window that the mouse is on and move point to the
953 Make a selection with the mouse. This is the default binding of
954 the left mouse button (<button1>).
957 Extend the existing selection. This is the default binding of
960 `mouse-track-and-copy-to-cutbuffer'
961 Make a selection like `mouse-track', but also copy it to the cut
964 `mouse-track-delete-and-insert'
965 Make a selection with the mouse and insert it at point. This is
966 the default binding of <control-shift-button1>.
969 Make a selection with the mouse and insert it at point. This is
970 the default binding of <control-button1>.
972 `mouse-window-to-region'
973 Narrow a window to the region between the cursor and the mouse
976 The `M-x mouse-track' command should be bound to a mouse button. If
977 you click-and-drag, the selection is set to the region between the
978 point of the initial click and the point at which you release the
979 button. These positions do not need to be ordered.
981 If you click-and-release without moving the mouse, the point is
982 moved, and the selection is disowned (there will be no selection
983 owner.) The mark will be set to the previous position of point.
985 If you double-click, the selection will extend by symbols instead of
986 by characters. If you triple-click, the selection will extend by lines.
988 If you drag the mouse off the top or bottom of the window, you can
989 select pieces of text that are larger than the visible part of the
990 buffer; the buffer will scroll as necessary.
992 The selected text becomes the current X selection, and is also
993 copied to the top of the kill ring. Point will be left at the position
994 at which you released the button and the mark will be left at the
995 initial click position. Bind a mouse click to
996 `mouse-track-and-copy-to-cutbuffer' to copy selections to the cut
997 buffer. (See also the `mouse-track-adjust' command, on
1000 The `M-x mouse-track-adjust' command should be bound to a mouse
1001 button. The selection will be enlarged or shrunk so that the point of
1002 the mouse click is one of its endpoints. This is only meaningful after
1003 the `mouse-track' command (<button1>) has been executed.
1005 The `M-x mouse-track-delete-and-insert' command is exactly the same
1006 as the `mouse-track' command on <button1>, except that point is not
1007 moved; the selected text is immediately inserted after being selected;
1008 and the text of the selection is deleted.
1010 The `M-x mouse-track-insert' command is exactly the same as the
1011 `mouse-track' command on <button1>, except that point is not moved; the
1012 selected text is immediately inserted after being selected; and the
1013 selection is immediately disowned afterwards.
1016 File: xemacs.info, Node: Killing, Next: Yanking, Prev: Additional Mouse Operations, Up: Top
1018 Deletion and Killing
1019 ====================
1021 Most commands that erase text from the buffer save it. You can get
1022 the text back if you change your mind, or you can move or copy it to
1023 other parts of the buffer. Commands which erase text and save it in the
1024 kill ring are known as "kill" commands. Some other commands erase text
1025 but do not save it; they are known as "delete" commands. (This
1026 distinction is made only for erasing text in the buffer.)
1028 The commands' names and individual descriptions use the words `kill'
1029 and `delete' to indicate what they do. If you perform a kill or delete
1030 command by mistake, use the `C-x u' (`undo') command to undo it (*note
1031 Undo::.). The delete commands include `C-d' (`delete-char') and <DEL>
1032 (`delete-backward-char'), which delete only one character at a time,
1033 and those commands that delete only spaces or newlines. Commands that
1034 can destroy significant amounts of nontrivial data usually kill.
1040 Delete next character (`delete-char').
1043 Delete previous character (`delete-backward-char').
1046 Delete spaces and tabs around point (`delete-horizontal-space').
1049 Delete spaces and tabs around point, leaving one space
1053 Delete blank lines around the current line (`delete-blank-lines').
1056 Join two lines by deleting the intervening newline, and any
1057 indentation following it (`delete-indentation').
1059 The most basic delete commands are `C-d' (`delete-char') and <DEL>
1060 (`delete-backward-char'). `C-d' deletes the character after point, the
1061 one the cursor is "on top of". Point doesn't move. <DEL> deletes the
1062 character before the cursor, and moves point back. You can delete
1063 newlines like any other characters in the buffer; deleting a newline
1064 joins two lines. Actually, `C-d' and <DEL> aren't always delete
1065 commands; if you give them an argument, they kill instead, since they
1066 can erase more than one character this way.
1068 The other delete commands delete only formatting characters: spaces,
1069 tabs and newlines. `M-\' (`delete-horizontal-space') deletes all
1070 spaces and tab characters before and after point. `M-<SPC>'
1071 (`just-one-space') does the same but leaves a single space after point,
1072 regardless of the number of spaces that existed previously (even zero).
1074 `C-x C-o' (`delete-blank-lines') deletes all blank lines after the
1075 current line. If the current line is blank, it deletes all blank lines
1076 preceding the current line as well as leaving one blank line, the
1077 current line. `M-^' (`delete-indentation') joins the current line and
1078 the previous line, or, if given an argument, joins the current line and
1079 the next line by deleting a newline and all surrounding spaces, possibly
1080 leaving a single space. *Note M-^: Indentation.
1086 Kill rest of line or one or more lines (`kill-line').
1088 The simplest kill command is `C-k'. If given at the beginning of a
1089 line, it kills all the text on the line, leaving the line blank. If
1090 given on a blank line, the blank line disappears. As a consequence, a
1091 line disappears completely if you go to the front of a non-blank line
1092 and type `C-k' twice.
1094 More generally, `C-k' kills from point up to the end of the line,
1095 unless it is at the end of a line. In that case, it kills the newline
1096 following the line, thus merging the next line into the current one.
1097 Emacs ignores invisible spaces and tabs at the end of the line when
1098 deciding which case applies: if point appears to be at the end of the
1099 line, you can be sure the newline will be killed.
1101 If you give `C-k' a positive argument, it kills that many lines and
1102 the newlines that follow them (however, text on the current line before
1103 point is not killed). With a negative argument, `C-k' kills back to a
1104 number of line beginnings. An argument of -2 means kill back to the
1105 second line beginning. If point is at the beginning of a line, that
1106 line beginning doesn't count, so `C-u - 2 C-k' with point at the front
1107 of a line kills the two previous lines.
1109 `C-k' with an argument of zero kills all the text before point on the
1116 Kill region (from point to the mark) (`kill-region'). *Note
1120 Kill word (`kill-word').
1123 Kill word backwards (`backward-kill-word').
1126 Kill back to beginning of sentence (`backward-kill-sentence').
1130 Kill to end of sentence (`kill-sentence').
1133 Kill sexp (`kill-sexp'). *Note Lists::.
1136 Kill up to next occurrence of CHAR (`zap-to-char').
1138 `C-w' (`kill-region') is a very general kill command; it kills
1139 everything between point and the mark. You can use this command to kill
1140 any contiguous sequence of characters by first setting the mark at one
1141 end of a sequence of characters, then going to the other end and typing
1144 A convenient way of killing is combined with searching: `M-z'
1145 (`zap-to-char') reads a character and kills from point up to (but not
1146 including) the next occurrence of that character in the buffer. If
1147 there is no next occurrence, killing goes to the end of the buffer. A
1148 numeric argument acts as a repeat count. A negative argument means to
1149 search backward and kill text before point.
1151 Other syntactic units can be killed: words, with `M-<DEL>' and `M-d'
1152 (*note Words::.); sexps, with `C-M-k' (*note Lists::.); and sentences,
1153 with `C-x <DEL>' and `M-k' (*note Sentences::.).
1156 File: xemacs.info, Node: Yanking, Next: Using X Selections, Prev: Killing, Up: Top
1161 "Yanking" means getting back text which was killed. Some systems
1162 call this "pasting". The usual way to move or copy text is to kill it
1163 and then yank it one or more times.
1166 Yank last killed text (`yank').
1169 Replace re-inserted killed text with the previously killed text
1173 Save region as last killed text without actually killing it
1174 (`copy-region-as-kill').
1177 Append next kill to last batch of killed text (`append-next-kill').
1181 * Kill Ring:: Where killed text is stored. Basic yanking.
1182 * Appending Kills:: Several kills in a row all yank together.
1183 * Earlier Kills:: Yanking something killed some time ago.
1186 File: xemacs.info, Node: Kill Ring, Next: Appending Kills, Prev: Yanking, Up: Yanking
1191 All killed text is recorded in the "kill ring", a list of blocks of
1192 text that have been killed. There is only one kill ring, used in all
1193 buffers, so you can kill text in one buffer and yank it in another
1194 buffer. This is the usual way to move text from one file to another.
1195 (*Note Accumulating Text::, for some other ways.)
1197 If you have two separate Emacs processes, you cannot use the kill
1198 ring to move text. If you are using XEmacs under X, however, you can
1199 use the X selection mechanism to move text from one to another.
1201 If you are using XEmacs under X and have one Emacs process with
1202 multiple frames, they do share the same kill ring. You can kill or
1203 copy text in one Emacs frame, then yank it in the other frame belonging
1204 to the same process.
1206 The command `C-y' (`yank') reinserts the text of the most recent
1207 kill. It leaves the cursor at the end of the text and sets the mark at
1208 the beginning of the text. *Note Mark::.
1210 `C-u C-y' yanks the text, leaves the cursor in front of the text,
1211 and sets the mark after it, if the argument is with just a `C-u'. Any
1212 other argument, including `C-u' and digits, has different results,
1213 described below, under "Yanking Earlier Kills".
1215 To copy a block of text, you can also use `M-w'
1216 (`copy-region-as-kill'), which copies the region into the kill ring
1217 without removing it from the buffer. `M-w' is similar to `C-w' followed
1218 by `C-y' but does not mark the buffer as "modified" and does not
1219 actually cut anything.
projects / chise / xemacs-chise.git.1 / blob