X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=info%2Fxemacs.info-16;h=07d3445366d4b75aa9aeb4f9be013f6e6e52acda;hb=6055f790006272b9f8497e9dc6240771220196a1;hp=f5aabf3a87e35ee0e2127eb1d098bfee42547b64;hpb=82da33b61c3e2dd2937db17b75b2838188793053;p=chise%2Fxemacs-chise.git diff --git a/info/xemacs.info-16 b/info/xemacs.info-16 index f5aabf3..07d3445 100644 --- a/info/xemacs.info-16 +++ b/info/xemacs.info-16 @@ -1,5 +1,5 @@ -This is Info file ../info/xemacs.info, produced by Makeinfo version -1.68 from the input file xemacs/xemacs.texi. +This is ../info/xemacs.info, produced by makeinfo version 4.0 from +xemacs/xemacs.texi. INFO-DIR-SECTION XEmacs Editor START-INFO-DIR-ENTRY @@ -30,6 +30,774 @@ versions, except that the sections entitled "The GNU Manifesto", translation approved by the author instead of in the original English.  +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 +. + + 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 , the previous shell input is inserted into the +buffer before point. Immediately typing again deletes that input +and inserts the one before it. By repeating you can move +backward through your commands until you find one you want to repeat. +You may then edit the command before typing if you wish. +moves forward through the command history, in case you moved backward +past the one you wanted while using . If you type the first few +characters of a previous command and then type , 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. + + +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: + +`' + 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 + . + +`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 + quickly and go past the desired command + (`comint-next-input'). + +`' + Complete the file name preceding point (`comint-dynamic-complete'). + + +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. + + +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 to the sub-shell. + +`C-c C-x' + A prefix command to conveniently access the global commands. + For example, `C-c C-x o' invokes the global binding of `C-x o', + which is normally `other-window'. + + +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. + + +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::. + + +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'. + + +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. + + +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. + + +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'. + + +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'. + + +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::. + + +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. + + +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 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. + + +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. + + +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 + +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 fill-column 75 + +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. + + +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. + + +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 . + + 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. + + File: xemacs.info, Node: Changing an Option, Next: Face Customization, Prev: Customization Groups, Up: Easy Customization Changing an Option @@ -132,9 +900,10 @@ insert a newline in an editable field, use `C-o' or `C-q C-j', 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 @@ -202,7 +971,7 @@ field. When the attribute is enabled, you can change the attribute value in the usual ways. Setting, saving and resetting a face work like the same operations -for options (*note Changing an Option::.). +for options (*note Changing an Option::). A face can specify different appearances for different types of display. For example, a face can make text red on a color display, but @@ -261,7 +1030,7 @@ can show their contents in the usual way, by invoking `[Show]'. customize-apropos'. You specify a regular expression as argument; then all options, faces and groups whose names match this regular expression are set up in the customization buffer. If you specify an empty regular -expression, this includes *all* groups, options and faces in the +expression, this includes _all_ groups, options and faces in the customization buffer (but that takes a long time). If you change option values and then decide the change was a mistake, @@ -398,796 +1167,3 @@ explicitly, as in the case of: (default-value 'fill-column) - -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. - - -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. - - -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. - - -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 MACRONAME - -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. - - -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 , , `C-d', -`C-l', and `C-r'. Any other character terminates execution of the -keyboard macro and is then read as a command. means to continue. - 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 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::. - - -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. - - -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 exits just - like . 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 '. - - * `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 . 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 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. - - -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 - - -File: xemacs.info, Node: Interactive Rebinding, Next: Programmatic Rebinding, Up: Rebinding - -Changing Key Bindings Interactively -................................... - -`M-x global-set-key KEY CMD ' - Defines KEY globally to run CMD. - -`M-x local-set-key KEYS CMD ' - Defines KEY locally (in the major mode now in effect) to run CMD. - -`M-x local-unset-key KEYS ' - 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 C-f next-line - -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 C-x 4 $ spell-other-window - -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. - - -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 - (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 - ;;; in the keymap that is in force when you are running `dired'. - (define-key dired-mode-map '(meta control button3) 'my-command) - - -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 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 . 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 - - -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. - - -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. - - -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. - - -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. -