-This is ../info/xemacs.info, produced by makeinfo version 3.12s from
+This is ../info/xemacs.info, produced by makeinfo version 4.0 from
xemacs/xemacs.texi.
INFO-DIR-SECTION XEmacs Editor
translation approved by the author instead of in the original English.
\1f
+File: xemacs.info, Node: Interactive Shell, Next: Shell Mode, Prev: Single Shell, Up: Shell
+
+Interactive Inferior Shell
+--------------------------
+
+ To run a subshell interactively with its typescript in an XEmacs
+buffer, use `M-x shell'. This creates (or reuses) a buffer named
+`*shell*' and runs a subshell with input coming from and output going
+to that buffer. That is to say, any "terminal output" from the subshell
+will go into the buffer, advancing point, and any "terminal input" for
+the subshell comes from text in the buffer. To give input to the
+subshell, go to the end of the buffer and type the input, terminated by
+<RET>.
+
+ XEmacs does not wait for the subshell to do anything. You can switch
+windows or buffers and edit them while the shell is waiting, or while
+it is running a command. Output from the subshell waits until XEmacs
+has time to process it; this happens whenever XEmacs is waiting for
+keyboard input or for time to elapse.
+
+ To get multiple subshells, change the name of buffer `*shell*' to
+something different by using `M-x rename-buffer'. The next use of `M-x
+shell' creates a new buffer `*shell*' with its own subshell. By
+renaming this buffer as well you can create a third one, and so on.
+All the subshells run independently and in parallel.
+
+ The file name used to load the subshell is the value of the variable
+`explicit-shell-file-name', if that is non-`nil'. Otherwise, the
+environment variable `ESHELL' is used, or the environment variable
+`SHELL' if there is no `ESHELL'. If the file name specified is
+relative, the directories in the list `exec-path' are searched (*note
+Single Shell Commands: Single Shell.).
+
+ As soon as the subshell is started, it is sent as input the contents
+of the file `~/.emacs_SHELLNAME', if that file exists, where SHELLNAME
+is the name of the file that the shell was loaded from. For example,
+if you use `csh', the file sent to it is `~/.emacs_csh'.
+
+ `cd', `pushd', and `popd' commands given to the inferior shell are
+watched by XEmacs so it can keep the `*shell*' buffer's default
+directory the same as the shell's working directory. These commands
+are recognized syntactically by examining lines of input that are sent.
+If you use aliases for these commands, you can tell XEmacs to
+recognize them also. For example, if the value of the variable
+`shell-pushd-regexp' matches the beginning of a shell command line,
+that line is regarded as a `pushd' command. Change this variable when
+you add aliases for `pushd'. Likewise, `shell-popd-regexp' and
+`shell-cd-regexp' are used to recognize commands with the meaning of
+`popd' and `cd'.
+
+ `M-x shell-resync-dirs' queries the shell and resynchronizes XEmacs'
+idea of what the current directory stack is. `M-x
+shell-dirtrack-toggle' turns directory tracking on and off.
+
+ XEmacs keeps a history of the most recent commands you have typed in
+the `*shell*' buffer. If you are at the beginning of a shell command
+line and type <M-p>, the previous shell input is inserted into the
+buffer before point. Immediately typing <M-p> again deletes that input
+and inserts the one before it. By repeating <M-p> you can move
+backward through your commands until you find one you want to repeat.
+You may then edit the command before typing <RET> if you wish. <M-n>
+moves forward through the command history, in case you moved backward
+past the one you wanted while using <M-p>. If you type the first few
+characters of a previous command and then type <M-p>, the most recent
+shell input starting with those characters is inserted. This can be
+very convenient when you are repeating a sequence of shell commands.
+The variable `input-ring-size' controls how many commands are saved in
+your input history. The default is 30.
+
+\1f
+File: xemacs.info, Node: Shell Mode, Next: Terminal emulator, Prev: Interactive Shell, Up: Shell
+
+Shell Mode
+----------
+
+ The shell buffer uses Shell mode, which defines several special keys
+attached to the `C-c' prefix. They are chosen to resemble the usual
+editing and job control characters present in shells that are not under
+XEmacs, except that you must type `C-c' first. Here is a list of the
+special key bindings of Shell mode:
+
+`<RET>'
+ At end of buffer send line as input; otherwise, copy current line
+ to end of buffer and send it (`send-shell-input'). When a line is
+ copied, any text at the beginning of the line that matches the
+ variable `shell-prompt-pattern' is left out; this variable's value
+ should be a regexp string that matches the prompts that you use in
+ your subshell.
+
+`C-c C-d'
+ Send end-of-file as input, probably causing the shell or its
+ current subjob to finish (`shell-send-eof').
+
+`C-d'
+ If point is not at the end of the buffer, delete the next
+ character just like most other modes. If point is at the end of
+ the buffer, send end-of-file as input, instead of generating an
+ error as in other modes (`comint-delchar-or-maybe-eof').
+
+`C-c C-u'
+ Kill all text that has yet to be sent as input
+ (`kill-shell-input').
+
+`C-c C-w'
+ Kill a word before point (`backward-kill-word').
+
+`C-c C-c'
+ Interrupt the shell or its current subjob if any
+ (`interrupt-shell-subjob').
+
+`C-c C-z'
+ Stop the shell or its current subjob if any (`stop-shell-subjob').
+
+`C-c C-\'
+ Send quit signal to the shell or its current subjob if any
+ (`quit-shell-subjob').
+
+`C-c C-o'
+ Delete last batch of output from shell (`kill-output-from-shell').
+
+`C-c C-r'
+ Scroll top of last batch of output to top of window
+ (`show-output-from-shell').
+
+`C-c C-y'
+ Copy the previous bunch of shell input and insert it into the
+ buffer before point (`copy-last-shell-input'). No final newline
+ is inserted, and the input copied is not resubmitted until you type
+ <RET>.
+
+`M-p'
+ Move backward through the input history. Search for a matching
+ command if you have typed the beginning of a command
+ (`comint-previous-input').
+
+`M-n'
+ Move forward through the input history. Useful when you are using
+ <M-p> quickly and go past the desired command
+ (`comint-next-input').
+
+`<TAB>'
+ Complete the file name preceding point (`comint-dynamic-complete').
+
+\1f
+File: xemacs.info, Node: Terminal emulator, Next: Term Mode, Prev: Shell Mode, Up: Shell
+
+Interactive Inferior Shell with Terminal Emulator
+-------------------------------------------------
+
+ To run a subshell in a terminal emulator, putting its typescript in
+an XEmacs buffer, use `M-x term'. This creates (or reuses) a buffer
+named `*term*' and runs a subshell with input coming from your keyboard
+and output going to that buffer.
+
+ All the normal keys that you type are sent without any interpretation
+by XEmacs directly to the subshell, as "terminal input." Any "echo" of
+your input is the responsibility of the subshell. (The exception is
+the terminal escape character, which by default is `C-c'. *note Term
+Mode::.) Any "terminal output" from the subshell goes into the buffer,
+advancing point.
+
+ Some programs (such as XEmacs itself) need to control the appearance
+on the terminal screen in detail. They do this by sending special
+control codes. The exact control codes needed vary from terminal to
+terminal, but nowadays most terminals and terminal emulators (including
+xterm) understand the so-called "ANSI escape sequences" (first
+popularized by the Digital's VT100 family of terminal). The term mode
+also understands these escape sequences, and for each control code does
+the appropriate thing to change the buffer so that the appearance of
+the window will match what it would be on a real terminal. Thus you
+can actually run XEmacs inside an XEmacs Term window!
+
+ XEmacs does not wait for the subshell to do anything. You can switch
+windows or buffers and edit them while the shell is waiting, or while
+it is running a command. Output from the subshell waits until XEmacs
+has time to process it; this happens whenever XEmacs is waiting for
+keyboard input or for time to elapse.
+
+ To make multiple terminal emulators, rename the buffer `*term*' to
+something different using `M-x rename-uniquely', just as with Shell
+mode.
+
+ The file name used to load the subshell is determined the same way
+as for Shell mode.
+
+ Unlike Shell mode, Term mode does not track the current directory by
+examining your input. Instead, if you use a programmable shell, you
+can have it tell Term what the current directory is. This is done
+automatically by bash for version 1.15 and later.
+
+\1f
+File: xemacs.info, Node: Term Mode, Next: Paging in Term, Prev: Terminal emulator, Up: Shell
+
+Term Mode
+---------
+
+ Term uses Term mode, which has two input modes: In line mode, Term
+basically acts like Shell mode. *Note Shell Mode::. In Char mode,
+each character is sent directly to the inferior subshell, except for
+the Term escape character, normally `C-c'.
+
+ To switch between line and char mode, use these commands:
+ findex term-char-mode
+
+`C-c C-k'
+ Switch to line mode. Do nothing if already in line mode.
+
+`C-c C-j'
+ Switch to char mode. Do nothing if already in char mode.
+
+ The following commands are only available in Char mode:
+`C-c C-c'
+ Send a literal <C-c> to the sub-shell.
+
+`C-c C-x'
+ A prefix command to conveniently access the global <C-x> commands.
+ For example, `C-c C-x o' invokes the global binding of `C-x o',
+ which is normally `other-window'.
+
+\1f
+File: xemacs.info, Node: Paging in Term, Prev: Term Mode, Up: Shell
+
+Paging in the terminal emulator
+-------------------------------
+
+ Term mode has a pager feature. When the pager is enabled, term mode
+will pause at the end of each screenful.
+
+`C-c C-q'
+ Toggles the pager feature: Disables the pager if it is enabled,
+ and vice versa. This works in both line and char modes. If the
+ pager enabled, the mode-line contains the word `page'.
+
+ If the pager is enabled, and Term receives more than a screenful of
+output since your last input, Term will enter More break mode. This is
+indicated by `**MORE**' in the mode-line. Type a `Space' to display
+the next screenful of output. Type `?' to see your other options. The
+interface is similar to the Unix `more' program.
+
+\1f
+File: xemacs.info, Node: Narrowing, Next: Hardcopy, Prev: Shell, Up: Top
+
+Narrowing
+=========
+
+ "Narrowing" means focusing in on some portion of the buffer, making
+the rest temporarily invisible and inaccessible. Cancelling the
+narrowing and making the entire buffer once again visible is called
+"widening". The amount of narrowing in effect in a buffer at any time
+is called the buffer's "restriction".
+
+`C-x n n'
+ Narrow down to between point and mark (`narrow-to-region').
+
+`C-x n w'
+ Widen to make the entire buffer visible again (`widen').
+
+ Narrowing sometimes makes it easier to concentrate on a single
+subroutine or paragraph by eliminating clutter. It can also be used to
+restrict the range of operation of a replace command or repeating
+keyboard macro. The word `Narrow' appears in the mode line whenever
+narrowing is in effect. When you have narrowed to a part of the
+buffer, that part appears to be all there is. You can't see the rest,
+can't move into it (motion commands won't go outside the visible part),
+and can't change it in any way. However, the invisible text is not
+gone; if you save the file, it will be saved.
+
+ The primary narrowing command is `C-x n n' (`narrow-to-region'). It
+sets the current buffer's restrictions so that the text in the current
+region remains visible but all text before the region or after the
+region is invisible. Point and mark do not change.
+
+ Because narrowing can easily confuse users who do not understand it,
+`narrow-to-region' is normally a disabled command. Attempting to use
+this command asks for confirmation and gives you the option of enabling
+it; once you enable the command, confirmation will no longer be
+required. *Note Disabling::.
+
+ To undo narrowing, use `C-x n w' (`widen'). This makes all text in
+the buffer accessible again.
+
+ Use the `C-x =' command to get information on what part of the
+buffer you narrowed down. *Note Position Info::.
+
+\1f
+File: xemacs.info, Node: Hardcopy, Next: Recursive Edit, Prev: Narrowing, Up: Top
+
+Hardcopy Output
+===============
+
+ The XEmacs commands for making hardcopy derive their names from the
+Unix commands `print' and `lpr'.
+
+`M-x print-buffer'
+ Print hardcopy of current buffer using Unix command `print'
+ (`lpr -p'). This command adds page headings containing the file
+ name and page number.
+
+`M-x lpr-buffer'
+ Print hardcopy of current buffer using Unix command `lpr'. This
+ command does not add page headings.
+
+`M-x print-region'
+ Like `print-buffer', but prints only the current region.
+
+`M-x lpr-region'
+ Like `lpr-buffer', but prints only the current region.
+
+ All the hardcopy commands pass extra switches to the `lpr' program
+based on the value of the variable `lpr-switches'. Its value should be
+a list of strings, each string a switch starting with `-'. For
+example, the value could be `("-Pfoo")' to print on printer `foo'.
+
+\1f
+File: xemacs.info, Node: Recursive Edit, Next: Dissociated Press, Prev: Hardcopy, Up: Top
+
+Recursive Editing Levels
+========================
+
+ A "recursive edit" is a situation in which you are using XEmacs
+commands to perform arbitrary editing while in the middle of another
+XEmacs command. For example, when you type `C-r' inside a
+`query-replace', you enter a recursive edit in which you can change the
+current buffer. When you exit from the recursive edit, you go back to
+the `query-replace'.
+
+ "Exiting" a recursive edit means returning to the unfinished
+command, which continues execution. For example, exiting the recursive
+edit requested by `C-r' in `query-replace' causes query replacing to
+resume. Exiting is done with `C-M-c' (`exit-recursive-edit').
+
+ You can also "abort" a recursive edit. This is like exiting, but
+also quits the unfinished command immediately. Use the command `C-]'
+(`abort-recursive-edit') for this. *Note Quitting::.
+
+ The mode line shows you when you are in a recursive edit by
+displaying square brackets around the parentheses that always surround
+the major and minor mode names. Every window's mode line shows the
+square brackets, since XEmacs as a whole, rather than any particular
+buffer, is in a recursive edit.
+
+ It is possible to be in recursive edits within recursive edits. For
+example, after typing `C-r' in a `query-replace', you might type a
+command that entered the debugger. In such a case, two or more sets of
+square brackets appear in the mode line(s). Exiting the inner
+recursive edit (here with the debugger `c' command) resumes the
+query-replace command where it called the debugger. After the end of
+the query-replace command, you would be able to exit the first
+recursive edit. Aborting exits only one level of recursive edit; it
+returns to the command level of the previous recursive edit. You can
+then abort that one as well.
+
+ The command `M-x top-level' aborts all levels of recursive edits,
+returning immediately to the top level command reader.
+
+ The text you edit inside the recursive edit need not be the same text
+that you were editing at top level. If the command that invokes the
+recursive edit selects a different buffer first, that is the buffer you
+will edit recursively. You can switch buffers within the recursive edit
+in the normal manner (as long as the buffer-switching keys have not been
+rebound). While you could theoretically do the rest of your editing
+inside the recursive edit, including visiting files, this could have
+surprising effects (such as stack overflow) from time to time. It is
+best if you always exit or abort a recursive edit when you no longer
+need it.
+
+ In general, XEmacs tries to avoid using recursive edits. It is
+usually preferable to allow users to switch among the possible editing
+modes in any order they like. With recursive edits, the only way to get
+to another state is to go "back" to the state that the recursive edit
+was invoked from.
+
+\1f
+File: xemacs.info, Node: Dissociated Press, Next: CONX, Prev: Recursive Edit, Up: Top
+
+Dissociated Press
+=================
+
+ `M-x dissociated-press' is a command for scrambling a file of text
+either word by word or character by character. Starting from a buffer
+of straight English, it produces extremely amusing output. The input
+comes from the current XEmacs buffer. Dissociated Press writes its
+output in a buffer named `*Dissociation*', and redisplays that buffer
+after every couple of lines (approximately) to facilitate reading it.
+
+ `dissociated-press' asks every so often whether to continue
+operating. Answer `n' to stop it. You can also stop at any time by
+typing `C-g'. The dissociation output remains in the `*Dissociation*'
+buffer for you to copy elsewhere if you wish.
+
+ Dissociated Press operates by jumping at random from one point in the
+buffer to another. In order to produce plausible output rather than
+gibberish, it insists on a certain amount of overlap between the end of
+one run of consecutive words or characters and the start of the next.
+That is, if it has just printed out `president' and then decides to
+jump to a different point in the file, it might spot the `ent' in
+`pentagon' and continue from there, producing `presidentagon'. Long
+sample texts produce the best results.
+
+ A positive argument to `M-x dissociated-press' tells it to operate
+character by character, and specifies the number of overlap characters.
+A negative argument tells it to operate word by word and specifies the
+number of overlap words. In this mode, whole words are treated as the
+elements to be permuted, rather than characters. No argument is
+equivalent to an argument of two. For your againformation, the output
+goes only into the buffer `*Dissociation*'. The buffer you start with
+is not changed.
+
+ Dissociated Press produces nearly the same results as a Markov chain
+based on a frequency table constructed from the sample text. It is,
+however, an independent, ignoriginal invention. Dissociated Press
+techniquitously copies several consecutive characters from the sample
+between random choices, whereas a Markov chain would choose randomly for
+each word or character. This makes for more plausible sounding results
+and runs faster.
+
+ It is a mustatement that too much use of Dissociated Press can be a
+developediment to your real work. Sometimes to the point of outragedy.
+And keep dissociwords out of your documentation, if you want it to be
+well userenced and properbose. Have fun. Your buggestions are welcome.
+
+\1f
+File: xemacs.info, Node: CONX, Next: Amusements, Prev: Dissociated Press, Up: Top
+
+CONX
+====
+
+ Besides producing a file of scrambled text with Dissociated Press,
+you can generate random sentences by using CONX.
+
+`M-x conx'
+ Generate random sentences in the `*conx*' buffer.
+
+`M-x conx-buffer'
+ Absorb the text in the current buffer into the `conx' database.
+
+`M-x conx-init'
+ Forget the current word-frequency tree.
+
+`M-x conx-load'
+ Load a `conx' database that has been previously saved with `M-x
+ conx-save'.
+
+`M-x conx-region'
+ Absorb the text in the current buffer into the `conx' database.
+
+`M-x conx-save'
+ Save the current `conx' database to a file for future retrieval.
+
+ Copy text from a buffer using `M-x conx-buffer' or `M-x conx-region'
+and then type `M-x conx'. Output is continuously generated until you
+type <^G>. You can save the `conx' database to a file with `M-x
+conx-save', which you can retrieve with `M-x conx-load'. To clear the
+database, use `M-x conx-init'.
+
+\1f
+File: xemacs.info, Node: Amusements, Next: Emulation, Prev: CONX, Up: Top
+
+Other Amusements
+================
+
+ If you are a little bit bored, you can try `M-x hanoi'. If you are
+considerably bored, give it a numeric argument. If you are very, very
+bored, try an argument of 9. Sit back and watch.
+
+ When you are frustrated, try the famous Eliza program. Just do `M-x
+doctor'. End each input by typing `RET' twice.
+
+ When you are feeling strange, type `M-x yow'.
+
+\1f
+File: xemacs.info, Node: Emulation, Next: Customization, Prev: Amusements, Up: Top
+
+Emulation
+=========
+
+ XEmacs can be programmed to emulate (more or less) most other
+editors. Standard facilities can emulate these:
+
+Viper (a vi emulator)
+ In XEmacs, Viper is the preferred emulation of vi within XEmacs.
+ Viper is designed to allow you to take advantage of the best
+ features of XEmacs while still doing your basic editing in a
+ familiar, vi-like fashion. Viper provides various different
+ levels of vi emulation, from a quite complete emulation that
+ allows almost no access to native XEmacs commands, to an "expert"
+ mode that combines the most useful vi commands with the most
+ useful XEmacs commands.
+
+ To start Viper, put the command
+
+ (viper-mode)
+
+ in your init file. *Note Init File::.
+
+ Viper comes with a separate manual that is provided standard with
+ the XEmacs distribution.
+
+EDT (DEC VMS editor)
+ Turn on EDT emulation with `M-x edt-emulation-on'. `M-x
+ edt-emulation-off' restores normal Emacs command bindings.
+
+ Most of the EDT emulation commands are keypad keys, and most
+ standard Emacs key bindings are still available. The EDT
+ emulation rebindings are done in the global keymap, so there is no
+ problem switching buffers or major modes while in EDT emulation.
+
+Gosling Emacs
+ Turn on emulation of Gosling Emacs (aka Unipress Emacs) with `M-x
+ set-gosmacs-bindings'. This redefines many keys, mostly on the
+ `C-x' and `ESC' prefixes, to work as they do in Gosmacs. `M-x
+ set-gnu-bindings' returns to normal XEmacs by rebinding the same
+ keys to the definitions they had at the time `M-x
+ set-gosmacs-bindings' was done.
+
+ It is also possible to run Mocklisp code written for Gosling Emacs.
+ *Note Mocklisp::.
+
+\1f
+File: xemacs.info, Node: Customization, Next: Quitting, Prev: Emulation, Up: Top
+
+Customization
+*************
+
+ This chapter talks about various topics relevant to adapting the
+behavior of Emacs in minor ways.
+
+ All kinds of customization affect only the particular Emacs job that
+you do them in. They are completely lost when you kill the Emacs job,
+and have no effect on other Emacs jobs you may run at the same time or
+later. The only way an Emacs job can affect anything outside of it is
+by writing a file; in particular, the only way to make a customization
+`permanent' is to put something in your init file or other appropriate
+file to do the customization in each session. *Note Init File::.
+
+* Menu:
+
+* Minor Modes:: Each minor mode is one feature you can turn on
+ independently of any others.
+* Variables:: Many Emacs commands examine Emacs variables
+ to decide what to do; by setting variables,
+ you can control their functioning.
+* Keyboard Macros:: A keyboard macro records a sequence of keystrokes
+ to be replayed with a single command.
+* Key Bindings:: The keymaps say what command each key runs.
+ By changing them, you can "redefine keys".
+* Syntax:: The syntax table controls how words and expressions
+ are parsed.
+* Init File:: How to write common customizations in the init file.
+* Audible Bell:: Changing how Emacs sounds the bell.
+* Faces:: Changing the fonts and colors of a region of text.
+* Frame Components:: Controlling the presence and positions of the
+ menubar, toolbars, and gutters.
+* X Resources:: X resources controlling various aspects of the
+ behavior of XEmacs.
+
+\1f
+File: xemacs.info, Node: Minor Modes, Next: Variables, Up: Customization
+
+Minor Modes
+===========
+
+ Minor modes are options which you can use or not. For example, Auto
+Fill mode is a minor mode in which <SPC> breaks lines between words as
+you type. All the minor modes are independent of each other and of the
+selected major mode. Most minor modes inform you in the mode line when
+they are on; for example, `Fill' in the mode line means that Auto Fill
+mode is on.
+
+ Append `-mode' to the name of a minor mode to get the name of a
+command function that turns the mode on or off. Thus, the command to
+enable or disable Auto Fill mode is called `M-x auto-fill-mode'. These
+commands are usually invoked with `M-x', but you can bind keys to them
+if you wish. With no argument, the function turns the mode on if it was
+off and off if it was on. This is known as "toggling". A positive
+argument always turns the mode on, and an explicit zero argument or a
+negative argument always turns it off.
+
+ Auto Fill mode allows you to enter filled text without breaking lines
+explicitly. Emacs inserts newlines as necessary to prevent lines from
+becoming too long. *Note Filling::.
+
+ Overwrite mode causes ordinary printing characters to replace
+existing text instead of moving it to the right. For example, if point
+is in front of the `B' in `FOOBAR', and you type a `G' in Overwrite
+mode, it changes to `FOOGAR', instead of `FOOGBAR'.
+
+ Abbrev mode allows you to define abbreviations that automatically
+expand as you type them. For example, `amd' might expand to `abbrev
+mode'. *Note Abbrevs::, for full information.
+
+\1f
+File: xemacs.info, Node: Variables, Next: Keyboard Macros, Prev: Minor Modes, Up: Customization
+
+Variables
+=========
+
+ A "variable" is a Lisp symbol which has a value. Variable names can
+contain any characters, but by convention they are words separated by
+hyphens. A variable can also have a documentation string, which
+describes what kind of value it should have and how the value will be
+used.
+
+ Lisp allows any variable to have any kind of value, but most
+variables that Emacs uses require a value of a certain type. Often the
+value has to be a string or a number. Sometimes we say that a certain
+feature is turned on if a variable is "non-`nil'," meaning that if the
+variable's value is `nil', the feature is off, but the feature is on
+for any other value. The conventional value to turn on the
+feature--since you have to pick one particular value when you set the
+variable--is `t'.
+
+ Emacs uses many Lisp variables for internal recordkeeping, as any
+Lisp program must, but the most interesting variables for you are the
+ones that exist for the sake of customization. Emacs does not
+(usually) change the values of these variables; instead, you set the
+values, and thereby alter and control the behavior of certain Emacs
+commands. These variables are called "options". Most options are
+documented in this manual and appear in the Variable Index (*note
+Variable Index::).
+
+ One example of a variable which is an option is `fill-column', which
+specifies the position of the right margin (as a number of characters
+from the left margin) to be used by the fill commands (*note Filling::).
+
+* Menu:
+
+* Examining:: Examining or setting one variable's value.
+* Easy Customization:: Convenient and easy customization of variables.
+* Edit Options:: Examining or editing list of all variables' values.
+* Locals:: Per-buffer values of variables.
+* File Variables:: How files can specify variable values.
+
+\1f
+File: xemacs.info, Node: Examining, Next: Easy Customization, Up: Variables
+
+Examining and Setting Variables
+-------------------------------
+
+`C-h v'
+`M-x describe-variable'
+ Print the value and documentation of a variable.
+
+`M-x set-variable'
+ Change the value of a variable.
+
+ To examine the value of a single variable, use `C-h v'
+(`describe-variable'), which reads a variable name using the
+minibuffer, with completion. It prints both the value and the
+documentation of the variable.
+
+ C-h v fill-column <RET>
+
+prints something like:
+
+ fill-column's value is 75
+
+ Documentation:
+ *Column beyond which automatic line-wrapping should happen.
+ Automatically becomes local when set in any fashion.
+
+The star at the beginning of the documentation indicates that this
+variable is an option. `C-h v' is not restricted to options; it allows
+any variable name.
+
+ If you know which option you want to set, you can use `M-x
+set-variable' to set it. This prompts for the variable name in the
+minibuffer (with completion), and then prompts for a Lisp expression
+for the new value using the minibuffer a second time. For example,
+
+ M-x set-variable <RET> fill-column <RET> 75 <RET>
+
+sets `fill-column' to 75, as if you had executed the Lisp expression
+`(setq fill-column 75)'.
+
+ Setting variables in this way, like all means of customizing Emacs
+except where explicitly stated, affects only the current Emacs session.
+
+\1f
+File: xemacs.info, Node: Easy Customization, Next: Edit Options, Prev: Examining, Up: Variables
+
+Easy Customization Interface
+----------------------------
+
+ A convenient way to find the user option variables that you want to
+change, and then change them, is with `M-x customize'. This command
+creates a "customization buffer" with which you can browse through the
+Emacs user options in a logically organized structure, then edit and
+set their values. You can also use the customization buffer to save
+settings permanently. (Not all Emacs user options are included in this
+structure as of yet, but we are adding the rest.)
+
+* Menu:
+
+* Groups: Customization Groups.
+ How options are classified in a structure.
+* Changing an Option:: How to edit a value and set an option.
+* Face Customization:: How to edit the attributes of a face.
+* Specific Customization:: Making a customization buffer for specific
+ options, faces, or groups.
+
+\1f
+File: xemacs.info, Node: Customization Groups, Next: Changing an Option, Up: Easy Customization
+
+Customization Groups
+....................
+
+ For customization purposes, user options are organized into "groups"
+to help you find them. Groups are collected into bigger groups, all
+the way up to a master group called `Emacs'.
+
+ `M-x customize' creates a customization buffer that shows the
+top-level `Emacs' group and the second-level groups immediately under
+it. It looks like this, in part:
+
+ /- Emacs group: ---------------------------------------------------\
+ [State]: visible group members are all at standard settings.
+ Customization of the One True Editor.
+ See also [Manual].
+
+ [Open] Editing group
+ Basic text editing facilities.
+
+ [Open] External group
+ Interfacing to external utilities.
+
+ MORE SECOND-LEVEL GROUPS
+
+ \- Emacs group end ------------------------------------------------/
+
+This says that the buffer displays the contents of the `Emacs' group.
+The other groups are listed because they are its contents. But they
+are listed differently, without indentation and dashes, because _their_
+contents are not included. Each group has a single-line documentation
+string; the `Emacs' group also has a `[State]' line.
+
+ Most of the text in the customization buffer is read-only, but it
+typically includes some "editable fields" that you can edit. There are
+also "active fields"; this means a field that does something when you
+"invoke" it. To invoke an active field, either click on it with
+`Mouse-1', or move point to it and type <RET>.
+
+ For example, the phrase `[Open]' that appears in a second-level
+group is an active field. Invoking the `[Open]' field for a group
+opens up a new customization buffer, which shows that group and its
+contents. This field is a kind of hypertext link to another group.
+
+ The `Emacs' group does not include any user options itself, but
+other groups do. By examining various groups, you will eventually find
+the options and faces that belong to the feature you are interested in
+customizing. Then you can use the customization buffer to set them.
+
+ You can view the structure of customization groups on a larger scale
+with `M-x customize-browse'. This command creates a special kind of
+customization buffer which shows only the names of the groups (and
+options and faces), and their structure.
+
+ In this buffer, you can show the contents of a group by invoking
+`[+]'. When the group contents are visible, this button changes to
+`[-]'; invoking that hides the group contents.
+
+ Each group, option or face name in this buffer has an active field
+which says `[Group]', `[Option]' or `[Face]'. Invoking that active
+field creates an ordinary customization buffer showing just that group
+and its contents, just that option, or just that face. This is the way
+to set values in it.
+
+\1f
File: xemacs.info, Node: Changing an Option, Next: Face Customization, Prev: Customization Groups, Up: Easy Customization
Changing an Option
Setting the option changes its value in the current Emacs session;
"saving" the value changes it for future sessions as well. This works
-by writing code into your `~/.emacs' file so as to set the option
-variable again each time you start Emacs. To save the option, invoke
-`[State]' and select the `Save for Future Sessions' operation.
+by writing code into your init file so as to set the option variable
+again each time you start Emacs. *Note Init File::. To save the
+option, invoke `[State]' and select the `Save for Future Sessions'
+operation.
You can also restore the option to its standard value by invoking
`[State]' and selecting the `Reset' operation. There are actually
(default-value 'fill-column)
-\1f
-File: xemacs.info, Node: File Variables, Prev: Locals, Up: Variables
-
-Local Variables in Files
-------------------------
-
- A file can contain a "local variables list", which specifies the
-values to use for certain Emacs variables when that file is edited.
-Visiting the file checks for a local variables list and makes each
-variable in the list local to the buffer in which the file is visited,
-with the value specified in the file.
-
- A local variables list goes near the end of the file, in the last
-page. (It is often best to put it on a page by itself.) The local
-variables list starts with a line containing the string `Local
-Variables:', and ends with a line containing the string `End:'. In
-between come the variable names and values, one set per line, as
-`VARIABLE: VALUE'. The VALUEs are not evaluated; they are used
-literally.
-
- The line which starts the local variables list does not have to say
-just `Local Variables:'. If there is other text before `Local
-Variables:', that text is called the "prefix", and if there is other
-text after, that is called the "suffix". If a prefix or suffix are
-present, each entry in the local variables list should have the prefix
-before it and the suffix after it. This includes the `End:' line. The
-prefix and suffix are included to disguise the local variables list as
-a comment so the compiler or text formatter will ignore it. If you do
-not need to disguise the local variables list as a comment in this way,
-there is no need to include a prefix or a suffix.
-
- Two "variable" names are special in a local variables list: a value
-for the variable `mode' sets the major mode, and a value for the
-variable `eval' is simply evaluated as an expression and the value is
-ignored. These are not real variables; setting them in any other
-context does not have the same effect. If `mode' is used in a local
-variables list, it should be the first entry in the list.
-
- Here is an example of a local variables list:
- ;;; Local Variables: ***
- ;;; mode:lisp ***
- ;;; comment-column:0 ***
- ;;; comment-start: ";;; " ***
- ;;; comment-end:"***" ***
- ;;; End: ***
-
- Note that the prefix is `;;; ' and the suffix is ` ***'. Note also
-that comments in the file begin with and end with the same strings.
-Presumably the file contains code in a language which is enough like
-Lisp for Lisp mode to be useful but in which comments start and end
-differently. The prefix and suffix are used in the local variables
-list to make the list look like several lines of comments when the
-compiler or interpreter for that language reads the file.
-
- The start of the local variables list must be no more than 3000
-characters from the end of the file, and must be in the last page if the
-file is divided into pages. Otherwise, Emacs will not notice it is
-there. The purpose is twofold: a stray `Local Variables:' not in the
-last page does not confuse Emacs, and Emacs never needs to search a
-long file that contains no page markers and has no local variables list.
-
- You may be tempted to turn on Auto Fill mode with a local variable
-list. That is inappropriate. Whether you use Auto Fill mode or not is
-a matter of personal taste, not a matter of the contents of particular
-files. If you want to use Auto Fill, set up major mode hooks with your
-`.emacs' file to turn it on (when appropriate) for you alone (*note
-Init File::). Don't try to use a local variable list that would impose
-your taste on everyone working with the file.
-
- XEmacs allows you to specify local variables in the first line of a
-file, in addition to specifying them in the `Local Variables' section
-at the end of a file.
-
- If the first line of a file contains two occurrences of ``-*-'',
-XEmacs uses the information between them to determine what the major
-mode and variable settings should be. For example, these are all legal:
-
- ;;; -*- mode: emacs-lisp -*-
- ;;; -*- mode: postscript; version-control: never -*-
- ;;; -*- tags-file-name: "/foo/bar/TAGS" -*-
-
- For historical reasons, the syntax ``-*- modename -*-'' is allowed
-as well; for example, you can use:
-
- ;;; -*- emacs-lisp -*-
-
- The variable `enable-local-variables' controls the use of local
-variables lists in files you visit. The value can be `t', `nil', or
-something else. A value of `t' means local variables lists are obeyed;
-`nil' means they are ignored; anything else means query.
-
- The command `M-x normal-mode' always obeys local variables lists and
-ignores this variable.
-
-\1f
-File: xemacs.info, Node: Keyboard Macros, Next: Key Bindings, Prev: Variables, Up: Customization
-
-Keyboard Macros
-===============
-
- A "keyboard macro" is a command defined by the user to abbreviate a
-sequence of keys. For example, if you discover that you are about to
-type `C-n C-d' forty times, you can speed your work by defining a
-keyboard macro to invoke `C-n C-d' and calling it with a repeat count
-of forty.
-
-`C-x ('
- Start defining a keyboard macro (`start-kbd-macro').
-
-`C-x )'
- End the definition of a keyboard macro (`end-kbd-macro').
-
-`C-x e'
- Execute the most recent keyboard macro (`call-last-kbd-macro').
-
-`C-u C-x ('
- Re-execute last keyboard macro, then add more keys to its
- definition.
-
-`C-x q'
- When this point is reached during macro execution, ask for
- confirmation (`kbd-macro-query').
-
-`M-x name-last-kbd-macro'
- Give a command name (for the duration of the session) to the most
- recently defined keyboard macro.
-
-`M-x insert-kbd-macro'
- Insert in the buffer a keyboard macro's definition, as Lisp code.
-
- Keyboard macros differ from other Emacs commands in that they are
-written in the Emacs command language rather than in Lisp. This makes
-it easier for the novice to write them and makes them more convenient as
-temporary hacks. However, the Emacs command language is not powerful
-enough as a programming language to be useful for writing anything
-general or complex. For such things, Lisp must be used.
-
- You define a keyboard macro by executing the commands which are its
-definition. Put differently, as you are defining a keyboard macro, the
-definition is being executed for the first time. This way, you see
-what the effects of your commands are, and don't have to figure them
-out in your head. When you are finished, the keyboard macro is defined
-and also has been executed once. You can then execute the same set of
-commands again by invoking the macro.
-
-* Menu:
-
-* Basic Kbd Macro:: Defining and running keyboard macros.
-* Save Kbd Macro:: Giving keyboard macros names; saving them in files.
-* Kbd Macro Query:: Keyboard macros that do different things each use.
-
-\1f
-File: xemacs.info, Node: Basic Kbd Macro, Next: Save Kbd Macro, Up: Keyboard Macros
-
-Basic Use
----------
-
- To start defining a keyboard macro, type `C-x ('
-(`start-kbd-macro'). From then on, anything you type continues to be
-executed, but also becomes part of the definition of the macro. `Def'
-appears in the mode line to remind you of what is going on. When you
-are finished, the `C-x )' command (`end-kbd-macro') terminates the
-definition, without becoming part of it.
-
- For example,
-
- C-x ( M-f foo C-x )
-
-defines a macro to move forward a word and then insert `foo'.
-
- You can give `C-x )' a repeat count as an argument, in which case it
-repeats the macro that many times right after defining it, but defining
-the macro counts as the first repetition (since it is executed as you
-define it). If you give `C-x )' an argument of 4, it executes the
-macro immediately 3 additional times. An argument of zero to `C-x e'
-or `C-x )' means repeat the macro indefinitely (until it gets an error
-or you type `C-g').
-
- Once you have defined a macro, you can invoke it again with the `C-x
-e' command (`call-last-kbd-macro'). You can give the command a repeat
-count numeric argument to execute the macro many times.
-
- To repeat an operation at regularly spaced places in the text,
-define a macro and include as part of the macro the commands to move to
-the next place you want to use it. For example, if you want to change
-each line, you should position point at the start of a line, and define
-a macro to change that line and leave point at the start of the next
-line. Repeating the macro will then operate on successive lines.
-
- After you have terminated the definition of a keyboard macro, you
-can add to the end of its definition by typing `C-u C-x ('. This is
-equivalent to plain `C-x (' followed by retyping the whole definition
-so far. As a consequence it re-executes the macro as previously
-defined.
-
-\1f
-File: xemacs.info, Node: Save Kbd Macro, Next: Kbd Macro Query, Prev: Basic Kbd Macro, Up: Keyboard Macros
-
-Naming and Saving Keyboard Macros
----------------------------------
-
- To save a keyboard macro for longer than until you define the next
-one, you must give it a name using `M-x name-last-kbd-macro'. This
-reads a name as an argument using the minibuffer and defines that name
-to execute the macro. The macro name is a Lisp symbol, and defining it
-in this way makes it a valid command name for calling with `M-x' or for
-binding a key to with `global-set-key' (*note Keymaps::). If you
-specify a name that has a prior definition other than another keyboard
-macro, Emacs prints an error message and nothing is changed.
-
- Once a macro has a command name, you can save its definition in a
-file. You can then use it in another editing session. First visit the
-file you want to save the definition in. Then use the command:
-
- M-x insert-kbd-macro <RET> MACRONAME <RET>
-
-This inserts some Lisp code that, when executed later, will define the
-same macro with the same definition it has now. You need not
-understand Lisp code to do this, because `insert-kbd-macro' writes the
-Lisp code for you. Then save the file. You can load the file with
-`load-file' (*note Lisp Libraries::). If the file you save in is your
-initialization file `~/.emacs' (*note Init File::), then the macro will
-be defined each time you run Emacs.
-
- If you give `insert-kbd-macro' a prefix argument, it creates
-additional Lisp code to record the keys (if any) that you have bound to
-the keyboard macro, so that the macro is reassigned the same keys when
-you load the file.
-
-\1f
-File: xemacs.info, Node: Kbd Macro Query, Prev: Save Kbd Macro, Up: Keyboard Macros
-
-Executing Macros With Variations
---------------------------------
-
- You can use `C-x q' (`kbd-macro-query'), to get an effect similar to
-that of `query-replace'. The macro asks you each time whether to make
-a change. When you are defining the macro, type `C-x q' at the point
-where you want the query to occur. During macro definition, the `C-x
-q' does nothing, but when you invoke the macro, `C-x q' reads a
-character from the terminal to decide whether to continue.
-
- The special answers to a `C-x q' query are <SPC>, <DEL>, `C-d',
-`C-l', and `C-r'. Any other character terminates execution of the
-keyboard macro and is then read as a command. <SPC> means to continue.
-<DEL> means to skip the remainder of this repetition of the macro,
-starting again from the beginning in the next repetition. `C-d' means
-to skip the remainder of this repetition and cancel further repetition.
-`C-l' redraws the frame and asks you again for a character to specify
-what to do. `C-r' enters a recursive editing level, in which you can
-perform editing that is not part of the macro. When you exit the
-recursive edit using `C-M-c', you are asked again how to continue with
-the keyboard macro. If you type a <SPC> at this time, the rest of the
-macro definition is executed. It is up to you to leave point and the
-text in a state such that the rest of the macro will do what you want.
-
- `C-u C-x q', which is `C-x q' with a numeric argument, performs a
-different function. It enters a recursive edit reading input from the
-keyboard, both when you type it during the definition of the macro and
-when it is executed from the macro. During definition, the editing you
-do inside the recursive edit does not become part of the macro. During
-macro execution, the recursive edit gives you a chance to do some
-particularized editing. *Note Recursive Edit::.
-
-\1f
-File: xemacs.info, Node: Key Bindings, Next: Syntax, Prev: Keyboard Macros, Up: Customization
-
-Customizing Key Bindings
-========================
-
- This section deals with the "keymaps" that define the bindings
-between keys and functions, and shows how you can customize these
-bindings.
-
- A command is a Lisp function whose definition provides for
-interactive use. Like every Lisp function, a command has a function
-name, which is a Lisp symbol whose name usually consists of lower case
-letters and hyphens.
-
-* Menu:
-
-* Keymaps:: Definition of the keymap data structure.
- Names of Emacs's standard keymaps.
-* Rebinding:: How to redefine one key's meaning conveniently.
-* Disabling:: Disabling a command means confirmation is required
- before it can be executed. This is done to protect
- beginners from surprises.
-
-\1f
-File: xemacs.info, Node: Keymaps, Next: Rebinding, Up: Key Bindings
-
-Keymaps
--------
-
- The bindings between characters and command functions are recorded in
-data structures called "keymaps". Emacs has many of these. One, the
-"global" keymap, defines the meanings of the single-character keys that
-are defined regardless of major mode. It is the value of the variable
-`global-map'.
-
- Each major mode has another keymap, its "local keymap", which
-contains overriding definitions for the single-character keys that are
-redefined in that mode. Each buffer records which local keymap is
-installed for it at any time, and the current buffer's local keymap is
-the only one that directly affects command execution. The local keymaps
-for Lisp mode, C mode, and many other major modes always exist even when
-not in use. They are the values of the variables `lisp-mode-map',
-`c-mode-map', and so on. For less frequently used major modes, the
-local keymap is sometimes constructed only when the mode is used for the
-first time in a session, to save space.
-
- There are local keymaps for the minibuffer, too; they contain various
-completion and exit commands.
-
- * `minibuffer-local-map' is used for ordinary input (no completion).
-
- * `minibuffer-local-ns-map' is similar, except that <SPC> exits just
- like <RET>. This is used mainly for Mocklisp compatibility.
-
- * `minibuffer-local-completion-map' is for permissive completion.
-
- * `minibuffer-local-must-match-map' is for strict completion and for
- cautious completion.
-
- * `repeat-complex-command-map' is for use in `C-x <ESC>'.
-
- * `isearch-mode-map' contains the bindings of the special keys which
- are bound in the pseudo-mode entered with `C-s' and `C-r'.
-
- Finally, each prefix key has a keymap which defines the key sequences
-that start with it. For example, `ctl-x-map' is the keymap used for
-characters following a `C-x'.
-
- * `ctl-x-map' is the variable name for the map used for characters
- that follow `C-x'.
-
- * `help-map' is used for characters that follow `C-h'.
-
- * `esc-map' is for characters that follow <ESC>. All Meta characters
- are actually defined by this map.
-
- * `ctl-x-4-map' is for characters that follow `C-x 4'.
-
- * `mode-specific-map' is for characters that follow `C-c'.
-
- The definition of a prefix key is the keymap to use for looking up
-the following character. Sometimes the definition is actually a Lisp
-symbol whose function definition is the following character keymap. The
-effect is the same, but it provides a command name for the prefix key
-that you can use as a description of what the prefix key is for. Thus
-the binding of `C-x' is the symbol `Ctl-X-Prefix', whose function
-definition is the keymap for `C-x' commands, the value of `ctl-x-map'.
-
- Prefix key definitions can appear in either the global map or a
-local map. The definitions of `C-c', `C-x', `C-h', and <ESC> as prefix
-keys appear in the global map, so these prefix keys are always
-available. Major modes can locally redefine a key as a prefix by
-putting a prefix key definition for it in the local map.
-
- A mode can also put a prefix definition of a global prefix character
-such as `C-x' into its local map. This is how major modes override the
-definitions of certain keys that start with `C-x'. This case is
-special, because the local definition does not entirely replace the
-global one. When both the global and local definitions of a key are
-other keymaps, the next character is looked up in both keymaps, with
-the local definition overriding the global one. The character after the
-`C-x' is looked up in both the major mode's own keymap for redefined
-`C-x' commands and in `ctl-x-map'. If the major mode's own keymap for
-`C-x' commands contains `nil', the definition from the global keymap
-for `C-x' commands is used.
-
-\1f
-File: xemacs.info, Node: Rebinding, Next: Disabling, Prev: Keymaps, Up: Key Bindings
-
-Changing Key Bindings
----------------------
-
- You can redefine an Emacs key by changing its entry in a keymap.
-You can change the global keymap, in which case the change is effective
-in all major modes except those that have their own overriding local
-definitions for the same key. Or you can change the current buffer's
-local map, which affects all buffers using the same major mode.
-
-* Menu:
-
-* Interactive Rebinding:: Changing Key Bindings Interactively
-* Programmatic Rebinding:: Changing Key Bindings Programmatically
-* Key Bindings Using Strings::Using Strings for Changing Key Bindings
-
-\1f
-File: xemacs.info, Node: Interactive Rebinding, Next: Programmatic Rebinding, Up: Rebinding
-
-Changing Key Bindings Interactively
-...................................
-
-`M-x global-set-key <RET> KEY CMD <RET>'
- Defines KEY globally to run CMD.
-
-`M-x local-set-key <RET> KEYS CMD <RET>'
- Defines KEY locally (in the major mode now in effect) to run CMD.
-
-`M-x local-unset-key <RET> KEYS <RET>'
- Removes the local binding of KEY.
-
- CMD is a symbol naming an interactively-callable function.
-
- When called interactively, KEY is the next complete key sequence
-that you type. When called as a function, KEY is a string, a vector of
-events, or a vector of key-description lists as described in the
-`define-key' function description. The binding goes in the current
-buffer's local map, which is shared with other buffers in the same
-major mode.
-
- The following example:
-
- M-x global-set-key <RET> C-f next-line <RET>
-
-redefines `C-f' to move down a line. The fact that CMD is read second
-makes it serve as a kind of confirmation for KEY.
-
- These functions offer no way to specify a particular prefix keymap as
-the one to redefine in, but that is not necessary, as you can include
-prefixes in KEY. KEY is read by reading characters one by one until
-they amount to a complete key (that is, not a prefix key). Thus, if
-you type `C-f' for KEY, Emacs enters the minibuffer immediately to read
-CMD. But if you type `C-x', another character is read; if that
-character is `4', another character is read, and so on. For example,
-
- M-x global-set-key <RET> C-x 4 $ spell-other-window <RET>
-
-redefines `C-x 4 $' to run the (fictitious) command
-`spell-other-window'.
-
- The most general way to modify a keymap is the function
-`define-key', used in Lisp code (such as your `.emacs' file).
-`define-key' takes three arguments: the keymap, the key to modify in
-it, and the new definition. *Note Init File::, for an example.
-`substitute-key-definition' is used similarly; it takes three
-arguments, an old definition, a new definition, and a keymap, and
-redefines in that keymap all keys that were previously defined with the
-old definition to have the new definition instead.
-
-\1f
-File: xemacs.info, Node: Programmatic Rebinding, Next: Key Bindings Using Strings, Prev: Interactive Rebinding, Up: Rebinding
-
-Changing Key Bindings Programmatically
-......................................
-
- You can use the functions `global-set-key' and `define-key' to
-rebind keys under program control.
-
-``(global-set-key KEYS CMD)''
- Defines KEYS globally to run CMD.
-
-``(define-key KEYMAP KEYS DEF)''
- Defines KEYS to run DEF in the keymap KEYMAP.
-
- KEYMAP is a keymap object.
-
- KEYS is the sequence of keystrokes to bind.
-
- DEF is anything that can be a key's definition:
-
- * `nil', meaning key is undefined in this keymap
-
- * A command, that is, a Lisp function suitable for interactive
- calling
-
- * A string or key sequence vector, which is treated as a keyboard
- macro
-
- * A keymap to define a prefix key
-
- * A symbol so that when the key is looked up, the symbol stands for
- its function definition, which should at that time be one of the
- above, or another symbol whose function definition is used, and so
- on
-
- * A cons, `(string . defn)', meaning that DEFN is the definition
- (DEFN should be a valid definition in its own right)
-
- * A cons, `(keymap . char)', meaning use the definition of CHAR in
- map KEYMAP
-
- For backward compatibility, XEmacs allows you to specify key
-sequences as strings. However, the preferred method is to use the
-representations of key sequences as vectors of keystrokes. *Note
-Keystrokes::, for more information about the rules for constructing key
-sequences.
-
- Emacs allows you to abbreviate representations for key sequences in
-most places where there is no ambiguity. Here are some rules for
-abbreviation:
-
- * The keysym by itself is equivalent to a list of just that keysym,
- i.e., `f1' is equivalent to `(f1)'.
-
- * A keystroke by itself is equivalent to a vector containing just
- that keystroke, i.e., `(control a)' is equivalent to `[(control
- a)]'.
-
- * You can use ASCII codes for keysyms that have them. i.e., `65' is
- equivalent to `A'. (This is not so much an abbreviation as an
- alternate representation.)
-
- Here are some examples of programmatically binding keys:
-
-
- ;;; Bind `my-command' to <f1>
- (global-set-key 'f1 'my-command)
-
- ;;; Bind `my-command' to Shift-f1
- (global-set-key '(shift f1) 'my-command)
-
- ;;; Bind `my-command' to C-c Shift-f1
- (global-set-key '[(control c) (shift f1)] 'my-command)
-
- ;;; Bind `my-command' to the middle mouse button.
- (global-set-key 'button2 'my-command)
-
- ;;; Bind `my-command' to <META> <CTL> <Right Mouse Button>
- ;;; in the keymap that is in force when you are running `dired'.
- (define-key dired-mode-map '(meta control button3) 'my-command)
-
-\1f
-File: xemacs.info, Node: Key Bindings Using Strings, Prev: Programmatic Rebinding, Up: Rebinding
-
-Using Strings for Changing Key Bindings
-.......................................
-
- For backward compatibility, you can still use strings to represent
-key sequences. Thus you can use commands like the following:
-
- ;;; Bind `end-of-line' to C-f
- (global-set-key "\C-f" 'end-of-line)
-
- Note, however, that in some cases you may be binding more than one
-key sequence by using a single command. This situation can arise
-because in ASCII, `C-i' and <TAB> have the same representation.
-Therefore, when Emacs sees:
-
- (global-set-key "\C-i" 'end-of-line)
-
- it is unclear whether the user intended to bind `C-i' or <TAB>. The
-solution XEmacs adopts is to bind both of these key sequences.
-
- After binding a command to two key sequences with a form like:
-
- (define-key global-map "\^X\^I" 'command-1)
-
- it is possible to redefine only one of those sequences like so:
-
- (define-key global-map [(control x) (control i)] 'command-2)
- (define-key global-map [(control x) tab] 'command-3)
-
- This applies only when running under a window system. If you are
-talking to Emacs through an ASCII-only channel, you do not get any of
-these features.
-
- Here is a table of pairs of key sequences that behave in a similar
-fashion:
-
- control h backspace
- control l clear
- control i tab
- control m return
- control j linefeed
- control [ escape
- control @ control space
-
-\1f
-File: xemacs.info, Node: Disabling, Prev: Rebinding, Up: Key Bindings
-
-Disabling Commands
-------------------
-
- Disabling a command marks it as requiring confirmation before it can
-be executed. The purpose of disabling a command is to prevent
-beginning users from executing it by accident and being confused.
-
- The direct mechanism for disabling a command is to have a non-`nil'
-`disabled' property on the Lisp symbol for the command. These
-properties are normally set by the user's `.emacs' file with Lisp
-expressions such as:
-
- (put 'delete-region 'disabled t)
-
- If the value of the `disabled' property is a string, that string is
-included in the message printed when the command is used:
-
- (put 'delete-region 'disabled
- "Text deleted this way cannot be yanked back!\n")
-
- You can disable a command either by editing the `.emacs' file
-directly or with the command `M-x disable-command', which edits the
-`.emacs' file for you. *Note Init File::.
-
- When you attempt to invoke a disabled command interactively in Emacs,
-a window is displayed containing the command's name, its documentation,
-and some instructions on what to do next; then Emacs asks for input
-saying whether to execute the command as requested, enable it and
-execute, or cancel it. If you decide to enable the command, you are
-asked whether to do this permanently or just for the current session.
-Enabling permanently works by automatically editing your `.emacs' file.
-You can use `M-x enable-command' at any time to enable any command
-permanently.
-
- Whether a command is disabled is independent of what key is used to
-invoke it; it also applies if the command is invoked using `M-x'.
-Disabling a command has no effect on calling it as a function from Lisp
-programs.
-
-\1f
-File: xemacs.info, Node: Syntax, Next: Init File, Prev: Key Bindings, Up: Customization
-
-The Syntax Table
-================
-
- All the Emacs commands which parse words or balance parentheses are
-controlled by the "syntax table". The syntax table specifies which
-characters are opening delimiters, which are parts of words, which are
-string quotes, and so on. Actually, each major mode has its own syntax
-table (though sometimes related major modes use the same one) which it
-installs in each buffer that uses that major mode. The syntax table
-installed in the current buffer is the one that all commands use, so we
-call it "the" syntax table. A syntax table is a Lisp object, a vector
-of length 256 whose elements are numbers.
-
-* Menu:
-
-* Entry: Syntax Entry. What the syntax table records for each character.
-* Change: Syntax Change. How to change the information.
-
-\1f
-File: xemacs.info, Node: Syntax Entry, Next: Syntax Change, Up: Syntax
-
-Information About Each Character
---------------------------------
-
- The syntax table entry for a character is a number that encodes six
-pieces of information:
-
- * The syntactic class of the character, represented as a small
- integer
-
- * The matching delimiter, for delimiter characters only (the
- matching delimiter of `(' is `)', and vice versa)
-
- * A flag saying whether the character is the first character of a
- two-character comment starting sequence
-
- * A flag saying whether the character is the second character of a
- two-character comment starting sequence
-
- * A flag saying whether the character is the first character of a
- two-character comment ending sequence
-
- * A flag saying whether the character is the second character of a
- two-character comment ending sequence
-
- The syntactic classes are stored internally as small integers, but
-are usually described to or by the user with characters. For example,
-`(' is used to specify the syntactic class of opening delimiters. Here
-is a table of syntactic classes, with the characters that specify them.
-
-` '
- The class of whitespace characters.
-
-`w'
- The class of word-constituent characters.
-
-`_'
- The class of characters that are part of symbol names but not
- words. This class is represented by `_' because the character `_'
- has this class in both C and Lisp.
-
-`.'
- The class of punctuation characters that do not fit into any other
- special class.
-
-`('
- The class of opening delimiters.
-
-`)'
- The class of closing delimiters.
-
-`''
- The class of expression-adhering characters. These characters are
- part of a symbol if found within or adjacent to one, and are part
- of a following expression if immediately preceding one, but are
- like whitespace if surrounded by whitespace.
-
-`"'
- The class of string-quote characters. They match each other in
- pairs, and the characters within the pair all lose their syntactic
- significance except for the `\' and `/' classes of escape
- characters, which can be used to include a string-quote inside the
- string.
-
-`$'
- The class of self-matching delimiters. This is intended for TeX's
- `$', which is used both to enter and leave math mode. Thus, a
- pair of matching `$' characters surround each piece of math mode
- TeX input. A pair of adjacent `$' characters act like a single
- one for purposes of matching.
-
-`/'
- The class of escape characters that always just deny the following
- character its special syntactic significance. The character after
- one of these escapes is always treated as alphabetic.
-
-`\'
- The class of C-style escape characters. In practice, these are
- treated just like `/'-class characters, because the extra
- possibilities for C escapes (such as being followed by digits)
- have no effect on where the containing expression ends.
-
-`<'
- The class of comment-starting characters. Only single-character
- comment starters (such as `;' in Lisp mode) are represented this
- way.
-
-`>'
- The class of comment-ending characters. Newline has this syntax in
- Lisp mode.
-
- The characters flagged as part of two-character comment delimiters
-can have other syntactic functions most of the time. For example, `/'
-and `*' in C code, when found separately, have nothing to do with
-comments. The comment-delimiter significance overrides when the pair of
-characters occur together in the proper order. Only the list and sexp
-commands use the syntax table to find comments; the commands
-specifically for comments have other variables that tell them where to
-find comments. Moreover, the list and sexp commands notice comments
-only if `parse-sexp-ignore-comments' is non-`nil'. This variable is set
-to `nil' in modes where comment-terminator sequences are liable to
-appear where there is no comment, for example, in Lisp mode where the
-comment terminator is a newline but not every newline ends a comment.
-
-\1f
-File: xemacs.info, Node: Syntax Change, Prev: Syntax Entry, Up: Syntax
-
-Altering Syntax Information
----------------------------
-
- It is possible to alter a character's syntax table entry by storing
-a new number in the appropriate element of the syntax table, but it
-would be hard to determine what number to use. Emacs therefore
-provides a command that allows you to specify the syntactic properties
-of a character in a convenient way.
-
- `M-x modify-syntax-entry' is the command to change a character's
-syntax. It can be used interactively and is also used by major modes
-to initialize their own syntax tables. Its first argument is the
-character to change. The second argument is a string that specifies the
-new syntax. When called from Lisp code, there is a third, optional
-argument, which specifies the syntax table in which to make the change.
-If not supplied, or if this command is called interactively, the third
-argument defaults to the current buffer's syntax table.
-
- 1. The first character in the string specifies the syntactic class.
- It is one of the characters in the previous table (*note Syntax
- Entry::).
-
- 2. The second character is the matching delimiter. For a character
- that is not an opening or closing delimiter, this should be a
- space, and may be omitted if no following characters are needed.
-
- 3. The remaining characters are flags. The flag characters allowed
- are:
-
- `1'
- Flag this character as the first of a two-character comment
- starting sequence.
-
- `2'
- Flag this character as the second of a two-character comment
- starting sequence.
-
- `3'
- Flag this character as the first of a two-character comment
- ending sequence.
-
- `4'
- Flag this character as the second of a two-character comment
- ending sequence.
-
- Use `C-h s' (`describe-syntax') to display a description of the
-contents of the current syntax table. The description of each
-character includes both the string you have to pass to
-`modify-syntax-entry' to set up that character's current syntax, and
-some English to explain that string if necessary.
-