--- /dev/null
+This is Info file ../../info/xemacs.info, produced by Makeinfo version
+1.68 from the input file xemacs.texi.
+
+INFO-DIR-SECTION XEmacs Editor
+START-INFO-DIR-ENTRY
+* XEmacs: (xemacs). XEmacs Editor.
+END-INFO-DIR-ENTRY
+
+ This file documents the XEmacs editor.
+
+ Copyright (C) 1985, 1986, 1988 Richard M. Stallman. Copyright (C)
+1991, 1992, 1993, 1994 Lucid, Inc. Copyright (C) 1993, 1994 Sun
+Microsystems, Inc. Copyright (C) 1995 Amdahl Corporation.
+
+ Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+ Permission is granted to copy and distribute modified versions of
+this manual under the conditions for verbatim copying, provided also
+that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
+General Public License" are included exactly as in the original, and
+provided that the entire resulting derived work is distributed under the
+terms of a permission notice identical to this one.
+
+ Permission is granted to copy and distribute translations of this
+manual into another language, under the above conditions for modified
+versions, except that the sections entitled "The GNU Manifesto",
+"Distribution" and "GNU General Public License" may be included in a
+translation approved by the author instead of in the original English.
+
+\1f
+File: xemacs.info, Node: Completion, Next: Repetition, Prev: Minibuffer Edit, Up: Minibuffer
+
+Completion
+==========
+
+ When appropriate, the minibuffer provides a "completion" facility.
+You type the beginning of an argument and one of the completion keys,
+and Emacs visibly fills in the rest, depending on what you have already
+typed.
+
+ When completion is available, certain keys--<TAB>, <RET>, and
+<SPC>--are redefined to complete an abbreviation present in the
+minibuffer into a longer string that it stands for, by matching it
+against a set of "completion alternatives" provided by the command
+reading the argument. `?' is defined to display a list of possible
+completions of what you have inserted.
+
+ For example, when the minibuffer is being used by `Meta-x' to read
+the name of a command, it is given a list of all available Emacs command
+names to complete against. The completion keys match the text in the
+minibuffer against all the command names, find any additional
+characters of the name that are implied by the ones already present in
+the minibuffer, and add those characters to the ones you have given.
+
+ Case is normally significant in completion because it is significant
+in most of the names that you can complete (buffer names, file names,
+and command names). Thus, `fo' will not complete to `Foo'. When you
+are completing a name in which case does not matter, case may be ignored
+for completion's sake if specified by program.
+
+ When a completion list is displayed, the completions will highlight
+as you move the mouse over them. Clicking the middle mouse button on
+any highlighted completion will "select" it just as if you had typed it
+in and hit <RET>.
+
+A Completion Example
+--------------------
+
+ Consider the following example. If you type `Meta-x au <TAB>',
+<TAB> looks for alternatives (in this case, command names) that start
+with `au'. There are only two commands: `auto-fill-mode' and
+`auto-save-mode'. They are the same as far as `auto-', so the `au' in
+the minibuffer changes to `auto-'.
+
+ If you type <TAB> again immediately, there are multiple possibilities
+for the very next character--it could be `s' or `f'--so no more
+characters are added; but a list of all possible completions is
+displayed in another window.
+
+ If you go on to type `f <TAB>', this <TAB> sees `auto-f'. The only
+command name starting this way is `auto-fill-mode', so completion
+inserts the rest of that command. You now have `auto-fill-mode' in the
+minibuffer after typing just `au <TAB> f <TAB>'. Note that <TAB> has
+this effect because in the minibuffer it is bound to the function
+`minibuffer-complete' when completion is supposed to be done.
+
+Completion Commands
+-------------------
+
+ Here is a list of all the completion commands defined in the
+minibuffer when completion is available.
+
+`<TAB>'
+ Complete the text in the minibuffer as much as possible
+ (`minibuffer-complete').
+
+`<SPC>'
+ Complete the text in the minibuffer but don't add or fill out more
+ than one word (`minibuffer-complete-word').
+
+`<RET>'
+ Submit the text in the minibuffer as the argument, possibly
+ completing first as described below
+ (`minibuffer-complete-and-exit').
+
+`?'
+ Print a list of all possible completions of the text in the
+ minibuffer (`minibuffer-list-completions').
+
+`<button2>'
+ Select the highlighted text under the mouse as a minibuffer
+ response. When the minibuffer is being used to prompt the user
+ for a completion, any valid completions which are visible on the
+ screen will be highlighted when the mouse moves over them.
+ Clicking <button2> will select the highlighted completion and exit
+ the minibuffer. (`minibuf-select-highlighted-completion').
+
+ <SPC> completes in a way that is similar to <TAB>, but it never goes
+beyond the next hyphen or space. If you have `auto-f' in the
+minibuffer and type <SPC>, it finds that the completion is
+`auto-fill-mode', but it stops completing after `fill-'. The result is
+`auto-fill-'. Another <SPC> at this point completes all the way to
+`auto-fill-mode'. <SPC> in the minibuffer runs the function
+`minibuffer-complete-word' when completion is available.
+
+ There are three different ways that <RET> can work in completing
+minibuffers, depending on how the argument will be used.
+
+ * "Strict" completion is used when it is meaningless to give any
+ argument except one of the known alternatives. For example, when
+ `C-x k' reads the name of a buffer to kill, it is meaningless to
+ give anything but the name of an existing buffer. In strict
+ completion, <RET> refuses to exit if the text in the minibuffer
+ does not complete to an exact match.
+
+ * "Cautious" completion is similar to strict completion, except that
+ <RET> exits only if the text was an exact match already, not
+ needing completion. If the text is not an exact match, <RET> does
+ not exit, but it does complete the text. If it completes to an
+ exact match, a second <RET> will exit.
+
+ Cautious completion is used for reading file names for files that
+ must already exist.
+
+ * "Permissive" completion is used when any string is meaningful, and
+ the list of completion alternatives is just a guide. For example,
+ when `C-x C-f' reads the name of a file to visit, any file name is
+ allowed, in case you want to create a file. In permissive
+ completion, <RET> takes the text in the minibuffer exactly as
+ given, without completing it.
+
+ The completion commands display a list of all possible completions
+in a window whenever there is more than one possibility for the very
+next character. Typing `?' explicitly requests such a list. The list
+of completions counts as help text, so `C-M-v' typed in the minibuffer
+scrolls the list.
+
+ When completion is done on file names, certain file names are usually
+ignored. The variable `completion-ignored-extensions' contains a list
+of strings; a file whose name ends in any of those strings is ignored
+as a possible completion. The standard value of this variable has
+several elements including `".o"', `".elc"', `".dvi"' and `"~"'. The
+effect is that, for example, `foo' completes to `foo.c' even though
+`foo.o' exists as well. If the only possible completions are files
+that end in "ignored" strings, they are not ignored.
+
+ If a completion command finds the next character is undetermined, it
+automatically displays a list of all possible completions. If the
+variable `completion-auto-help' is set to `nil', this does not happen,
+and you must type `?' to display the possible completions.
+
+ If the variable `minibuffer-confirm-incomplete' is set to `t', then
+in contexts where `completing-read' allows answers that are not valid
+completions, an extra <RET> must be typed to confirm the response.
+This is helpful for catching typos.
+
+\1f
+File: xemacs.info, Node: Repetition, Prev: Completion, Up: Minibuffer
+
+Repeating Minibuffer Commands
+=============================
+
+ Every command that uses the minibuffer at least once is recorded on a
+special history list, together with the values of the minibuffer
+arguments, so that you can repeat the command easily. In particular,
+every use of `Meta-x' is recorded, since `M-x' uses the minibuffer to
+read the command name.
+
+`C-x <ESC>'
+ Re-execute a recent minibuffer command
+ (`repeat-complex-command').
+
+`M-p'
+ Within `C-x <ESC>', move to previous recorded command
+ (`previous-history-element').
+
+`M-n'
+ Within `C-x <ESC>', move to the next (more recent) recorded
+ command (`next-history-element').
+
+`M-x list-command-history'
+ Display the entire command history, showing all the commands `C-x
+ <ESC>' can repeat, most recent first.
+
+ `C-x <ESC>' is used to re-execute a recent command that used the
+minibuffer. With no argument, it repeats the last command. A numeric
+argument specifies which command to repeat; 1 means the last one, and
+larger numbers specify earlier commands.
+
+ `C-x <ESC>' works by turning the previous command into a Lisp
+expression and then entering a minibuffer initialized with the text for
+that expression. If you type just <RET>, the command is repeated as
+before. You can also change the command by editing the Lisp expression.
+The expression you finally submit will be executed. The repeated
+command is added to the front of the command history unless it is
+identical to the most recently executed command already there.
+
+ Even if you don't understand Lisp syntax, it will probably be obvious
+which command is displayed for repetition. If you do not change the
+text, you can be sure the command will repeat exactly as before.
+
+ If you are in the minibuffer for `C-x <ESC>' and the command shown
+to you is not the one you want to repeat, you can move around the list
+of previous commands using `M-n' and `M-p'. `M-p' replaces the
+contents of the minibuffer with the next earlier recorded command, and
+`M-n' replaces it with the next later command. After finding the
+desired previous command, you can edit its expression and then resubmit
+it by typing <RET>. Any editing you have done on the command to be
+repeated is lost if you use `M-n' or `M-p'.
+
+ `M-n' and `M-p' are specially defined within `C-x <ESC>' to run the
+commands `previous-history-element' and `next-history-element'.
+
+ The list of previous commands using the minibuffer is stored as a
+Lisp list in the variable `command-history'. Each element of the list
+is a Lisp expression which describes one command and its arguments.
+Lisp programs can reexecute a command by feeding the corresponding
+`command-history' element to `eval'.
+
+\1f
+File: xemacs.info, Node: M-x, Next: Help, Prev: Minibuffer, Up: Top
+
+Running Commands by Name
+************************
+
+ The Emacs commands that are used often or that must be quick to type
+are bound to keys--short sequences of characters--for convenient use.
+Other Emacs commands that are used more rarely are not bound to keys;
+to run them, you must refer to them by name.
+
+ A command name consists, by convention, of one or more words,
+separated by hyphens: for example, `auto-fill-mode' or `manual-entry'.
+The use of English words makes the command name easier to remember than
+a key made up of obscure characters, even though it results in more
+characters to type. You can run any command by name, even if it can be
+run by keys as well.
+
+ To run a command by name, start with `M-x', then type the command
+name, and finish with <RET>. `M-x' uses the minibuffer to read the
+command name. <RET> exits the minibuffer and runs the command.
+
+ Emacs uses the minibuffer for reading input for many different
+purposes; on this occasion, the string `M-x' is displayed at the
+beginning of the minibuffer as a "prompt" to remind you that your input
+should be the name of a command to be run. *Note Minibuffer::, for
+full information on the features of the minibuffer.
+
+ You can use completion to enter a command name. For example, to
+invoke the command `forward-char', type:
+
+ M-x forward-char <RET>
+ or
+ M-x fo <TAB> c <RET>
+
+After you type in `M-x fo TAB' emacs will give you a possible list of
+completions from which you can choose. Note that `forward-char' is the
+same command that you invoke with the key `C-f'. You can call any
+command (interactively callable function) defined in Emacs by its name
+using `M-x' regardless of whether or not any keys are bound to it.
+
+ If you type `C-g' while Emacs reads the command name, you cancel the
+`M-x' command and get out of the minibuffer, ending up at top level.
+
+ To pass a numeric argument to a command you are invoking with `M-x',
+specify the numeric argument before the `M-x'. `M-x' passes the
+argument along to the function that it calls. The argument value
+appears in the prompt while the command name is being read.
+
+ You can use the command `M-x interactive' to specify a way of
+parsing arguments for interactive use of a function. For example,
+write:
+
+ (defun foo (arg) "Doc string" (interactive "p") ...use arg...)
+
+ to make `arg' be the prefix argument when `foo' is called as a
+command. The call to `interactive' is actually a declaration rather
+than a function; it tells `call-interactively' how to read arguments to
+pass to the function. When actually called, `interactive' returns
+`nil'.
+
+ The argument of INTERACTIVE is usually a string containing a code
+letter followed by a prompt. Some code letters do not use I/O to get
+the argument and do not need prompts. To prompt for multiple arguments,
+you must provide a code letter, its prompt, a newline, and another code
+letter, and so forth. If the argument is not a string, it is evaluated
+to get a list of arguments to pass to the function. If you do not
+provide an argument to `interactive', no arguments are passed when
+calling interactively.
+
+ Available code letters are:
+
+`a'
+ Function name: symbol with a function definition
+
+`b'
+ Name of existing buffer
+
+`B'
+ Name of buffer, possibly nonexistent
+
+`c'
+ Character
+
+`C'
+ Command name: symbol with interactive function definition
+
+`d'
+ Value of point as number (does not do I/O)
+
+`D'
+ Directory name
+
+`e'
+ Last mouse event
+
+`f'
+ Existing file name
+
+`F'
+ Possibly nonexistent file name
+
+`k'
+ Key sequence (string)
+
+`m'
+ Value of mark as number (does not do I/O)
+
+`n'
+ Number read using minibuffer
+
+`N'
+ Prefix arg converted to number, or if none, do like code `n'
+
+`p'
+ Prefix arg converted to number (does not do I/O)
+
+`P'
+ Prefix arg in raw form (does not do I/O)
+
+`r'
+ Region: point and mark as two numeric arguments, smallest first
+ (does not do I/O)
+
+`s'
+ Any string
+
+`S'
+ Any symbol
+
+`v'
+ Variable name: symbol that is `user-variable-p'
+
+`x'
+ Lisp expression read but not evaluated
+
+`X'
+ Lisp expression read and evaluated
+
+ In addition, if the string begins with `*', an error is signaled if
+the buffer is read-only. This happens before reading any arguments.
+If the string begins with `@', the window the mouse is over is selected
+before anything else is done. You may use both `@' and `*'; they are
+processed in the order that they appear.
+
+ Normally, when describing a command that is run by name, we omit the
+<RET> that is needed to terminate the name. Thus we may refer to `M-x
+auto-fill-mode' rather than `M-x auto-fill-mode' <RET>. We mention the
+<RET> only when it is necessary to emphasize its presence, for example,
+when describing a sequence of input that contains a command name and
+arguments that follow it.
+
+ `M-x' is defined to run the command `execute-extended-command',
+which is responsible for reading the name of another command and
+invoking it.
+
+\1f
+File: xemacs.info, Node: Help, Next: Mark, Prev: M-x, Up: Top
+
+Help
+****
+
+ Emacs provides extensive help features which revolve around a single
+character, `C-h'. `C-h' is a prefix key that is used only for
+documentation-printing commands. The characters you can type after
+`C-h' are called "help options". One help option is `C-h'; you use it
+to ask for help about using `C-h'.
+
+ `C-h C-h' prints a list of the possible help options, and then asks
+you to type the desired option. It prompts with the string:
+
+ 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:
+
+You should type one of those characters.
+
+ Typing a third `C-h' displays a description of what the options mean;
+Emacs still waits for you to type an option. To cancel, type `C-g'.
+
+ Here is a summary of the defined help commands.
+
+`C-h a STRING <RET>'
+ Display a list of commands whose names contain STRING (`command-
+ apropos').
+
+`C-h b'
+ Display a table of all key bindings currently in effect, with
+ local bindings of the current major mode first, followed by all
+ global bindings (`describe-bindings').
+
+`C-h c KEY'
+ Print the name of the command that KEY runs (`describe-key-
+ briefly'). `c' is for `character'. For more extensive
+ information on KEY, use `C-h k'.
+
+`C-h f FUNCTION <RET>'
+ Display documentation on the Lisp function named FUNCTION
+ (`describe-function'). Note that commands are Lisp functions, so
+ a command name may be used.
+
+`C-h i'
+ Run Info, the program for browsing documentation files (`info').
+ The complete Emacs manual is available online in Info.
+
+`C-h k KEY'
+ Display name and documentation of the command KEY runs
+ (`describe-key').
+
+`C-h l'
+ Display a description of the last 100 characters you typed
+ (`view-lossage').
+
+`C-h m'
+ Display documentation of the current major mode (`describe-mode').
+
+`C-h n'
+ Display documentation of Emacs changes, most recent first
+ (`view-emacs-news').
+
+`C-h p'
+ Display a table of all mouse bindings currently in effect now, with
+ local bindings of the current major mode first, followed by all
+ global bindings (`describe-pointer').
+
+`C-h s'
+ Display current contents of the syntax table, plus an explanation
+ of what they mean (`describe-syntax').
+
+`C-h t'
+ Display the Emacs tutorial (`help-with-tutorial').
+
+`C-h v VAR <RET>'
+ Display the documentation of the Lisp variable VAR (`describe-
+ variable').
+
+`C-h w COMMAND <RET>'
+ Print which keys run the command named COMMAND (`where-is').
+
+`M-x apropos REGEXP'
+ Show all symbols whose names contain matches for REGEXP.
+
+Documentation for a Key
+=======================
+
+ The most basic `C-h' options are `C-h c' (`describe-key-briefly')
+and `C-h k'
+(`describe-key'). `C-h c KEY' prints the name of the command that KEY
+is bound to in the echo area. For example, `C-h c C-f' prints
+`forward-char'. Since command names are chosen to describe what the
+command does, using this option is a good way to get a somewhat cryptic
+description of what KEY does.
+
+ `C-h k KEY' is similar to `C-h c' but gives more information. It
+displays the documentation string of the function KEY is bound to as
+well as its name. KEY is a string or vector of events. When called
+interactively, KEY may also be a menu selection. This information does
+not usually fit into the echo area, so a window is used for the display.
+
+Help by Command or Variable Name
+================================
+
+ `C-h f' (`describe-function') reads the name of a Lisp function
+using the minibuffer, then displays that function's documentation
+string in a window. Since commands are Lisp functions, you can use the
+argument FUNCTION to get the documentation of a command that you know
+by name. For example,
+
+ C-h f auto-fill-mode <RET>
+
+displays the documentation for `auto-fill-mode'. Using `C-h f' is the
+only way to see the documentation of a command that is not bound to any
+key, that is, a command you would normally call using `M-x'. If the
+variable `describe-function-show-arglist' is `t', `describe-function'
+shows its arglist if the FUNCTION is not an autoload function.
+
+ `C-h f' is also useful for Lisp functions you are planning to use in
+a Lisp program. For example, if you have just written the code
+`(make-vector len)' and want to make sure you are using `make-vector'
+properly, type `C-h f make-vector <RET>'. Because `C-h f' allows all
+function names, not just command names, you may find that some of your
+favorite abbreviations that work in `M-x' don't work in `C-h f'. An
+abbreviation may be unique among command names, yet fail to be unique
+when other function names are allowed.
+
+ If you type <RET>, leaving the minibuffer empty, `C-h f' by default
+describes the function called by the innermost Lisp expression in the
+buffer around point, provided that that is a valid, defined Lisp
+function name. For example, if point is located following the text
+`(make-vector (car x)', the innermost list containing point is the one
+starting with `(make-vector', so the default is to describe the
+function `make-vector'.
+
+ `C-h f' is often useful just to verify that you have the right
+spelling for the function name. If `C-h f' mentions a default in the
+prompt, you have typed the name of a defined Lisp function. If that is
+what you wanted to know, just type `C-g' to cancel the `C-h f' command
+and continue editing.
+
+ `C-h w COMMAND <RET>' (`where-s') tells you what keys are bound to
+COMMAND. It prints a list of the keys in the echo area. Alternatively,
+it informs you that a command is not bound to any keys, which implies
+that you must use `M-x' to call the command.
+
+ `C-h v' (`describe-variable') is like `C-h f' but describes Lisp
+variables instead of Lisp functions. Its default is the Lisp symbol
+around or before point, if that is the name of a known Lisp variable.
+*Note Variables::.
+
+Apropos
+=======
+
+`C-h a'
+ Show only symbols that are names of commands (`command-apropos').
+
+`M-x apropos REGEXP'
+ Show all symbols whose names comtain matches for REGEXP.
+
+ It is possible to ask a question like, "What are the commands for
+working with files?" To do this, type `C-h a file <RET>', which
+displays a list of all command names that contain `file', such as
+`copy-file', `find-file', and so on. With each command name a brief
+description of its use and information on the keys you can use to
+invoke it is displayed. For example, you would be informed that you
+can invoke `find-file' by typing `C-x C-f'. The `a' in `C-h a' stands
+for `Apropos'; `C-h a' runs the Lisp function `command-apropos'.
+
+ Because `C-h a' looks only for functions whose names contain the
+string you specify, you must use ingenuity in choosing the string. If
+you are looking for commands for killing backwards and `C-h a
+kill-backwards <RET>' doesn't reveal any commands, don't give up. Try
+just `kill', or just `backwards', or just `back'. Be persistent.
+Pretend you are playing Adventure. Also note that you can use a
+regular expression as the argument (*note Regexps::.).
+
+ Here is a set of arguments to give to `C-h a' that covers many
+classes of Emacs commands, since there are strong conventions for naming
+standard Emacs commands. By giving you a feeling for the naming
+conventions, this set of arguments can also help you develop a
+technique for picking `apropos' strings.
+
+ char, line, word, sentence, paragraph, region, page, sexp, list,
+ defun, buffer, frame, window, file, dir, register, mode,
+ beginning, end, forward, backward, next, previous, up, down,
+ search, goto, kill, delete, mark, insert, yank, fill, indent, case,
+ change, set, what, list, find, view, describe.
+
+ To list all Lisp symbols that contain a match for a regexp, not just
+the ones that are defined as commands, use the command `M-x apropos'
+instead of `C-h a'.
+
+Other Help Commands
+===================
+
+ `C-h i' (`info') runs the Info program, which is used for browsing
+through structured documentation files. The entire Emacs manual is
+available within Info. Eventually all the documentation of the GNU
+system will be available. Type `h' after entering Info to run a
+tutorial on using Info.
+
+ If something surprising happens, and you are not sure what commands
+you typed, use `C-h l' (`view-lossage'). `C-h l' prints the last 100
+command characters you typed. If you see commands you don't know, use
+`C-h c' to find out what they do.
+
+ Emacs has several major modes. Each mode redefines a few keys and
+makes a few other changes in how editing works. `C-h m'
+(`describe-mode') prints documentation on the current major mode, which
+normally describes all the commands that are changed in this mode.
+
+ `C-h b' (`describe-bindings') and `C-h s' (`describe-syntax')
+present information about the current Emacs mode that is not covered by
+`C-h m'. `C-h b' displays a list of all key bindings currently in
+effect, with the local bindings of the current major mode first,
+followed by the global bindings (*note Key Bindings::.). `C-h s'
+displays the contents of the syntax table with explanations of each
+character's syntax (*note Syntax::.).
+
+ The other `C-h' options display various files of useful information.
+`C-h C-w' (`describe-no-warranty') displays details on the complete
+absence of warranty for XEmacs. `C-h n' (`view-emacs-news') displays
+the file `emacs/etc/NEWS', which contains documentation on Emacs
+changes arranged chronologically. `C-h t' (`help-with-tutorial')
+displays the learn-by-doing Emacs tutorial. `C-h C-c'
+(`describe-copying') displays the file `emacs/etc/COPYING', which tells
+you the conditions you must obey in distributing copies of Emacs. `C-h
+C-d' (`describe-distribution') displays another file named
+`emacs/etc/DISTRIB', which tells you how you can order a copy of the
+latest version of Emacs.
+
+\1f
+File: xemacs.info, Node: Mark, Next: Mouse Selection, Prev: Help, Up: Top
+
+Selecting Text
+**************
+
+ Many Emacs commands operate on an arbitrary contiguous part of the
+current buffer. You can select text in two ways:
+
+ * You use special keys to select text by defining a region between
+ point and the mark.
+
+ * If you are running XEmacs under X, you can also select text with
+ the mouse.
+
+The Mark and the Region
+=======================
+
+ To specify the text for a command to operate on, set "the mark" at
+one end of it, and move point to the other end. The text between point
+and the mark is called "the region". You can move point or the mark to
+adjust the boundaries of the region. It doesn't matter which one is
+set first chronologically, or which one comes earlier in the text.
+
+ Once the mark has been set, it remains until it is set again at
+another place. The mark remains fixed with respect to the preceding
+character if text is inserted or deleted in a buffer. Each Emacs
+buffer has its own mark; when you return to a buffer that had been
+selected previously, it has the same mark it had before.
+
+ Many commands that insert text, such as `C-y' (`yank') and `M-x
+insert-buffer', position the mark at one end of the inserted text--the
+opposite end from where point is positioned, so that the region
+contains the text just inserted.
+
+ Aside from delimiting the region, the mark is useful for marking a
+spot that you may want to go back to. To make this feature more useful,
+Emacs remembers 16 previous locations of the mark in the `mark ring'.
+
+* Menu:
+
+* Setting Mark:: Commands to set the mark.
+* Using Region:: Summary of ways to operate on contents of the region.
+* Marking Objects:: Commands to put region around textual units.
+* Mark Ring:: Previous mark positions saved so you can go back there.
+
+\1f
+File: xemacs.info, Node: Setting Mark, Next: Using Region, Prev: Mark, Up: Mark
+
+Setting the Mark
+----------------
+
+ Here are some commands for setting the mark:
+
+`C-<SPC>'
+ Set the mark where point is (`set-mark-command').
+
+`C-@'
+ The same.
+
+`C-x C-x'
+ Interchange mark and point (`exchange-point-and-mark').
+
+`C-<'
+ Pushes a mark at the beginning of the buffer.
+
+`C->'
+ Pushes a mark at the end of the buffer.
+
+ For example, to convert part of the buffer to all upper-case, you
+can use the `C-x C-u' (`upcase-region') command, which operates on the
+text in the region. First go to the beginning of the text you want to
+capitalize and type `C-<SPC>' to put the mark there, then move to the
+end, and then type `C-x C-u' to capitalize the selected region. You
+can also set the mark at the end of the text, move to the beginning,
+and then type `C-x C-u'. Most commands that operate on the text in the
+region have the word `region' in their names.
+
+ The most common way to set the mark is with the `C-<SPC>' command
+(`set-mark-command'). This command sets the mark where point is. You
+can then move point away, leaving the mark behind. It is actually
+incorrect to speak of the character `C-<SPC>'; there is no such
+character. When you type <SPC> while holding down <CTRL>, you get the
+character `C-@' on most terminals. This character is actually bound to
+`set-mark-command'. But unless you are unlucky enough to have a
+terminal where typing `C-<SPC>' does not produce `C-@', you should
+think of this character as `C-<SPC>'.
+
+ Since terminals have only one cursor, Emacs cannot show you where the
+mark is located. Most people use the mark soon after they set it, before
+they forget where it is. But you can see where the mark is with the
+command `C-x C-x' (`exchange-point-and-mark') which puts the mark where
+point was and point where the mark was. The extent of the region is
+unchanged, but the cursor and point are now at the previous location of
+the mark.
+
+ Another way to set the mark is to push the mark to the beginning of a
+buffer while leaving point at its original location. If you supply an
+argument to `C-<' (`mark-beginning-of-buffer'), the mark is pushed N/10
+of the way from the true beginning of the buffer. You can also set the
+mark at the end of a buffer with `C->' (`mark-end-of-buffer'). It
+pushes the mark to the end of the buffer, leaving point alone.
+Supplying an argument to the command pushes the mark N/10 of the way
+from the true end of the buffer.
+
+ If you are using XEmacs under the X window system, you can set the
+variable `zmacs-regions' to `t'. This makes the current region (defined
+by point and mark) highlight and makes it available as the X clipboard
+selection, which means you can use the menu bar items on it. *Note
+Active Regions::, for more information.
+
+ `C-x C-x' is also useful when you are satisfied with the location of
+point but want to move the mark; do `C-x C-x' to put point there and
+then you can move it. A second use of `C-x C-x', if necessary, puts
+the mark at the new location with point back at its original location.
+
+\1f
+File: xemacs.info, Node: Using Region, Next: Marking Objects, Prev: Setting Mark, Up: Mark
+
+Operating on the Region
+-----------------------
+
+ Once you have created an active region, you can do many things to
+the text in it:
+ * Kill it with `C-w' (*note Killing::.).
+
+ * Save it in a register with `C-x r s' (*note Registers::.).
+
+ * Save it in a buffer or a file (*note Accumulating Text::.).
+
+ * Convert case with `C-x C-l' or `C-x C-u'
+ (*note Case::.).
+
+ * Evaluate it as Lisp code with `M-x eval-region' (*note Lisp
+ Eval::.).
+
+ * Fill it as text with `M-q' (*note Filling::.).
+
+ * Print hardcopy with `M-x print-region' (*note Hardcopy::.).
+
+ * Indent it with `C-x <TAB>' or `C-M-\' (*note Indentation::.).
+
+\1f
+File: xemacs.info, Node: Marking Objects, Next: Mark Ring, Prev: Using Region, Up: Mark
+
+Commands to Mark Textual Objects
+--------------------------------
+
+ There are commands for placing point and the mark around a textual
+object such as a word, list, paragraph or page.
+
+`M-@'
+ Set mark after end of next word (`mark-word'). This command and
+ the following one do not move point.
+
+`C-M-@'
+ Set mark after end of next Lisp expression (`mark-sexp').
+
+`M-h'
+ Put region around current paragraph (`mark-paragraph').
+
+`C-M-h'
+ Put region around current Lisp defun (`mark-defun').
+
+`C-x h'
+ Put region around entire buffer (`mark-whole-buffer').
+
+`C-x C-p'
+ Put region around current page (`mark-page').
+
+ `M-@' (`mark-word') puts the mark at the end of the next word, while
+`C-M-@' (`mark-sexp') puts it at the end of the next Lisp expression.
+These characters sometimes save you some typing.
+
+ A number of commands are available that set both point and mark and
+thus delimit an object in the buffer. `M-h' (`mark-paragraph') moves
+point to the beginning of the paragraph that surrounds or follows
+point, and puts the mark at the end of that paragraph (*note
+Paragraphs::.). You can then indent, case-convert, or kill the whole
+paragraph. In the same fashion, `C-M-h' (`mark-defun') puts point
+before and the mark after the current or following defun (*note
+Defuns::.). `C-x C-p' (`mark-page') puts point before the current page
+(or the next or previous, depending on the argument), and mark at the
+end (*note Pages::.). The mark goes after the terminating page
+delimiter (to include it), while point goes after the preceding page
+delimiter (to exclude it). Finally, `C-x h' (`mark-whole-buffer') sets
+up the entire buffer as the region by putting point at the beginning
+and the mark at the end.
+
+\1f
+File: xemacs.info, Node: Mark Ring, Prev: Marking Objects, Up: Mark
+
+The Mark Ring
+-------------
+
+ Aside from delimiting the region, the mark is also useful for marking
+a spot that you may want to go back to. To make this feature more
+useful, Emacs remembers 16 previous locations of the mark in the "mark
+ring". Most commands that set the mark push the old mark onto this
+ring. To return to a marked location, use `C-u C-<SPC>' (or `C-u
+C-@'); this is the command `set-mark-command' given a numeric argument.
+The command moves point to where the mark was, and restores the mark
+from the ring of former marks. Repeated use of this command moves point
+to all the old marks on the ring, one by one. The marks you have seen
+go to the end of the ring, so no marks are lost.
+
+ Each buffer has its own mark ring. All editing commands use the
+current buffer's mark ring. In particular, `C-u C-<SPC>' always stays
+in the same buffer.
+
+ Many commands that can move long distances, such as `M-<'
+(`beginning-of-buffer'), start by setting the mark and saving the old
+mark on the mark ring. This makes it easier for you to move back
+later. Searches set the mark, unless they do not actually move point.
+When a command sets the mark, `Mark Set' is printed in the echo area.
+
+ The variable `mark-ring-max' is the maximum number of entries to
+keep in the mark ring. If that many entries exist and another entry is
+added, the last entry in the list is discarded. Repeating `C-u
+C-<SPC>' circulates through the entries that are currently in the ring.
+
+ The variable `mark-ring' holds the mark ring itself, as a list of
+marker objects in the order most recent first. This variable is local
+in every buffer.
+
+\1f
+File: xemacs.info, Node: Mouse Selection, Next: Additional Mouse Operations, Prev: Mark, Up: Top
+
+Selecting Text with the Mouse
+=============================
+
+ If you are using XEmacs under X, you can use the mouse pointer to
+select text. (The normal mouse pointer is an I-beam, the same pointer
+that `xterm' uses.)
+
+ The glyph variable `text-pointer-glyph' controls the shape of the
+mouse pointer when over text. You can also control the shape of the
+mouse pointer when over nontext using `nontext-pointer-glyph', and the
+shape of the mouse pointer when over the modeline using
+`modeline-pointer-glyph'. (Remember, you should use `set-glyph-image',
+not `setq', to set one of these variables.)
+
+ If you want to get fancy, you can set the foreground and background
+colors of the mouse pointer by setting the `pointer' face.
+
+ There are two ways to select a region of text with the mouse:
+
+ To select a word in text, double-click with the left mouse button
+while the mouse cursor is over the word. The word is highlighted when
+selected. On monochrome monitors, a stippled background indicates that a
+region of text has been highlighted. On color monitors, a color
+background indicates highlighted text. You can triple-click to select
+whole lines.
+
+ To select an arbitrary region of text:
+
+ 1. Move the mouse cursor over the character at the beginning of the
+ region of text you want to select.
+
+ 2. Press and hold the left mouse button.
+
+ 3. While holding the left mouse button down, drag the cursor to the
+ character at the end of the region of text you want to select.
+
+ 4. Release the left mouse button.
+ The selected region of text is highlighted.
+
+ Once a region of text is selected, it becomes the primary X selection
+(*note Using X Selections::.) as well as the Emacs selected region. You
+can paste it into other X applications and use the options from the
+Edit pull-down menu on it. Since it is also the Emacs region, you can
+use Emacs region commands on it.
+
+\1f
+File: xemacs.info, Node: Additional Mouse Operations, Next: Killing, Prev: Mouse Selection, Up: Top
+
+Additional Mouse Operations
+===========================
+
+ XEmacs also provides the following mouse functions. Most of these
+are not bound to mouse gestures by default, but they are provided for
+your customization pleasure. For example, if you wanted `shift-left'
+(that is, holding down the <Shift> key and clicking the left mouse
+button) to delete the character at which you are pointing, then you
+could do this:
+
+ (global-set-key '(shift button1) 'mouse-del-char)
+
+`mouse-del-char'
+ Delete the character pointed to by the mouse.
+
+`mouse-delete-window'
+ Delete the Emacs window that the mouse is on.
+
+`mouse-keep-one-window'
+ Select the Emacs window that the mouse is on, then delete all other
+ windows on this frame.
+
+`mouse-kill-line'
+ Kill the line pointed to by the mouse.
+
+`mouse-line-length'
+ Print the length of the line indicated by the pointer.
+
+`mouse-scroll'
+ Scroll point to the mouse position.
+
+`mouse-select'
+ Select the Emacs window the mouse is on.
+
+`mouse-select-and-split'
+ Select the Emacs window mouse is on, then split it vertically in
+ half.
+
+`mouse-set-mark'
+ Select the Emacs window the mouse is on and set the mark at the
+ mouse position. Display the cursor at that position for a second.
+
+`mouse-set-point'
+ Select the Emacs window that the mouse is on and move point to the
+ mouse position.
+
+`mouse-track'
+ Make a selection with the mouse. This is the default binding of
+ the left mouse button (<button1>).
+
+`mouse-track-adjust'
+ Extend the existing selection. This is the default binding of
+ <Shift-button1>.
+
+`mouse-track-and-copy-to-cutbuffer'
+ Make a selection like `mouse-track', but also copy it to the cut
+ buffer.
+
+`mouse-track-delete-and-insert'
+ Make a selection with the mouse and insert it at point. This is
+ the default binding of <control-shift-button1>.
+
+`mouse-track-insert'
+ Make a selection with the mouse and insert it at point. This is
+ the default binding of <control-button1>.
+
+`mouse-window-to-region'
+ Narrow a window to the region between the cursor and the mouse
+ pointer.
+
+ The `M-x mouse-track' command should be bound to a mouse button. If
+you click-and-drag, the selection is set to the region between the
+point of the initial click and the point at which you release the
+button. These positions do not need to be ordered.
+
+ If you click-and-release without moving the mouse, the point is
+moved, and the selection is disowned (there will be no selection
+owner.) The mark will be set to the previous position of point.
+
+ If you double-click, the selection will extend by symbols instead of
+by characters. If you triple-click, the selection will extend by lines.
+
+ If you drag the mouse off the top or bottom of the window, you can
+select pieces of text that are larger than the visible part of the
+buffer; the buffer will scroll as necessary.
+
+ The selected text becomes the current X selection, and is also
+copied to the top of the kill ring. Point will be left at the position
+at which you released the button and the mark will be left at the
+initial click position. Bind a mouse click to
+`mouse-track-and-copy-to-cutbuffer' to copy selections to the cut
+buffer. (See also the `mouse-track-adjust' command, on
+`Shift-button1'.)
+
+ The `M-x mouse-track-adjust' command should be bound to a mouse
+button. The selection will be enlarged or shrunk so that the point of
+the mouse click is one of its endpoints. This is only meaningful after
+the `mouse-track' command (<button1>) has been executed.
+
+ The `M-x mouse-track-delete-and-insert' command is exactly the same
+as the `mouse-track' command on <button1>, except that point is not
+moved; the selected text is immediately inserted after being selected;
+and the text of the selection is deleted.
+
+ The `M-x mouse-track-insert' command is exactly the same as the
+`mouse-track' command on <button1>, except that point is not moved; the
+selected text is immediately inserted after being selected; and the
+selection is immediately disowned afterwards.
+
+\1f
+File: xemacs.info, Node: Killing, Next: Yanking, Prev: Additional Mouse Operations, Up: Top
+
+Deletion and Killing
+====================
+
+ Most commands that erase text from the buffer save it. You can get
+the text back if you change your mind, or you can move or copy it to
+other parts of the buffer. Commands which erase text and save it in the
+kill ring are known as "kill" commands. Some other commands erase text
+but do not save it; they are known as "delete" commands. (This
+distinction is made only for erasing text in the buffer.)
+
+ The commands' names and individual descriptions use the words `kill'
+and `delete' to indicate what they do. If you perform a kill or delete
+command by mistake, use the `C-x u' (`undo') command to undo it (*note
+Undo::.). The delete commands include `C-d' (`delete-char') and <DEL>
+(`delete-backward-char'), which delete only one character at a time,
+and those commands that delete only spaces or newlines. Commands that
+can destroy significant amounts of nontrivial data usually kill.
+
+Deletion
+--------
+
+`C-d'
+ Delete next character (`delete-char').
+
+`<DEL>'
+ Delete previous character (`delete-backward-char').
+
+`M-\'
+ Delete spaces and tabs around point (`delete-horizontal-space').
+
+`M-<SPC>'
+ Delete spaces and tabs around point, leaving one space
+ (`just-one-space').
+
+`C-x C-o'
+ Delete blank lines around the current line (`delete-blank-lines').
+
+`M-^'
+ Join two lines by deleting the intervening newline, and any
+ indentation following it (`delete-indentation').
+
+ The most basic delete commands are `C-d' (`delete-char') and <DEL>
+(`delete-backward-char'). `C-d' deletes the character after point, the
+one the cursor is "on top of". Point doesn't move. <DEL> deletes the
+character before the cursor, and moves point back. You can delete
+newlines like any other characters in the buffer; deleting a newline
+joins two lines. Actually, `C-d' and <DEL> aren't always delete
+commands; if you give them an argument, they kill instead, since they
+can erase more than one character this way.
+
+ The other delete commands delete only formatting characters: spaces,
+tabs and newlines. `M-\' (`delete-horizontal-space') deletes all
+spaces and tab characters before and after point. `M-<SPC>'
+(`just-one-space') does the same but leaves a single space after point,
+regardless of the number of spaces that existed previously (even zero).
+
+ `C-x C-o' (`delete-blank-lines') deletes all blank lines after the
+current line. If the current line is blank, it deletes all blank lines
+preceding the current line as well as leaving one blank line, the
+current line. `M-^' (`delete-indentation') joins the current line and
+the previous line, or, if given an argument, joins the current line and
+the next line by deleting a newline and all surrounding spaces, possibly
+leaving a single space. *Note M-^: Indentation.
+
+Killing by Lines
+----------------
+
+`C-k'
+ Kill rest of line or one or more lines (`kill-line').
+
+ The simplest kill command is `C-k'. If given at the beginning of a
+line, it kills all the text on the line, leaving the line blank. If
+given on a blank line, the blank line disappears. As a consequence, a
+line disappears completely if you go to the front of a non-blank line
+and type `C-k' twice.
+
+ More generally, `C-k' kills from point up to the end of the line,
+unless it is at the end of a line. In that case, it kills the newline
+following the line, thus merging the next line into the current one.
+Emacs ignores invisible spaces and tabs at the end of the line when
+deciding which case applies: if point appears to be at the end of the
+line, you can be sure the newline will be killed.
+
+ If you give `C-k' a positive argument, it kills that many lines and
+the newlines that follow them (however, text on the current line before
+point is not killed). With a negative argument, `C-k' kills back to a
+number of line beginnings. An argument of -2 means kill back to the
+second line beginning. If point is at the beginning of a line, that
+line beginning doesn't count, so `C-u - 2 C-k' with point at the front
+of a line kills the two previous lines.
+
+ `C-k' with an argument of zero kills all the text before point on the
+current line.
+
+Other Kill Commands
+-------------------
+
+`C-w'
+ Kill region (from point to the mark) (`kill-region'). *Note
+ Words::.
+
+`M-d'
+ Kill word (`kill-word').
+
+`M-<DEL>'
+ Kill word backwards (`backward-kill-word').
+
+`C-x <DEL>'
+ Kill back to beginning of sentence (`backward-kill-sentence').
+ *Note Sentences::.
+
+`M-k'
+ Kill to end of sentence (`kill-sentence').
+
+`C-M-k'
+ Kill sexp (`kill-sexp'). *Note Lists::.
+
+`M-z CHAR'
+ Kill up to next occurrence of CHAR (`zap-to-char').
+
+ `C-w' (`kill-region') is a very general kill command; it kills
+everything between point and the mark. You can use this command to kill
+any contiguous sequence of characters by first setting the mark at one
+end of a sequence of characters, then going to the other end and typing
+`C-w'.
+
+ A convenient way of killing is combined with searching: `M-z'
+(`zap-to-char') reads a character and kills from point up to (but not
+including) the next occurrence of that character in the buffer. If
+there is no next occurrence, killing goes to the end of the buffer. A
+numeric argument acts as a repeat count. A negative argument means to
+search backward and kill text before point.
+
+ Other syntactic units can be killed: words, with `M-<DEL>' and `M-d'
+(*note Words::.); sexps, with `C-M-k' (*note Lists::.); and sentences,
+with `C-x <DEL>' and `M-k' (*note Sentences::.).
+
+\1f
+File: xemacs.info, Node: Yanking, Next: Using X Selections, Prev: Killing, Up: Top
+
+Yanking
+=======
+
+ "Yanking" means getting back text which was killed. Some systems
+call this "pasting". The usual way to move or copy text is to kill it
+and then yank it one or more times.
+
+`C-y'
+ Yank last killed text (`yank').
+
+`M-y'
+ Replace re-inserted killed text with the previously killed text
+ (`yank-pop').
+
+`M-w'
+ Save region as last killed text without actually killing it
+ (`copy-region-as-kill').
+
+`C-M-w'
+ Append next kill to last batch of killed text (`append-next-kill').
+
+* Menu:
+
+* Kill Ring:: Where killed text is stored. Basic yanking.
+* Appending Kills:: Several kills in a row all yank together.
+* Earlier Kills:: Yanking something killed some time ago.
+
+\1f
+File: xemacs.info, Node: Kill Ring, Next: Appending Kills, Prev: Yanking, Up: Yanking
+
+The Kill Ring
+-------------
+
+ All killed text is recorded in the "kill ring", a list of blocks of
+text that have been killed. There is only one kill ring, used in all
+buffers, so you can kill text in one buffer and yank it in another
+buffer. This is the usual way to move text from one file to another.
+(*Note Accumulating Text::, for some other ways.)
+
+ If you have two separate Emacs processes, you cannot use the kill
+ring to move text. If you are using XEmacs under X, however, you can
+use the X selection mechanism to move text from one to another.
+
+ If you are using XEmacs under X and have one Emacs process with
+multiple frames, they do share the same kill ring. You can kill or
+copy text in one Emacs frame, then yank it in the other frame belonging
+to the same process.
+
+ The command `C-y' (`yank') reinserts the text of the most recent
+kill. It leaves the cursor at the end of the text and sets the mark at
+the beginning of the text. *Note Mark::.
+
+ `C-u C-y' yanks the text, leaves the cursor in front of the text,
+and sets the mark after it, if the argument is with just a `C-u'. Any
+other argument, including `C-u' and digits, has different results,
+described below, under "Yanking Earlier Kills".
+
+ To copy a block of text, you can also use `M-w'
+(`copy-region-as-kill'), which copies the region into the kill ring
+without removing it from the buffer. `M-w' is similar to `C-w' followed
+by `C-y' but does not mark the buffer as "modified" and does not
+actually cut anything.
+
projects / chise / xemacs-chise.git / blobdiff