X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=info%2Fxemacs.info-17;h=0b7a7a7ae0a858773f9a317dd3d4835dc070ec74;hb=60d4c0126ab5ef2d473f35f0769a1ba8b7da7652;hp=34260d26d64f393c5da160e0225a13e585ea0c98;hpb=82da33b61c3e2dd2937db17b75b2838188793053;p=chise%2Fxemacs-chise.git diff --git a/info/xemacs.info-17 b/info/xemacs.info-17 index 34260d2..0b7a7a7 100644 --- a/info/xemacs.info-17 +++ b/info/xemacs.info-17 @@ -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,21 +30,817 @@ versions, except that the sections entitled "The GNU Manifesto", translation approved by the author instead of in the original English.  +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 +init 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 (*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 init 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 init file with Lisp +expressions such as: + + (put 'delete-region 'disabled t) + + *Note Init File::. + + 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 init file directly +or with the command `M-x disable-command', which edits the init 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 init 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. + + File: xemacs.info, Node: Init File, Next: Audible Bell, Prev: Syntax, Up: Customization -The Init File, .emacs -===================== +The Init File +============= - When you start Emacs, it normally loads the file `.emacs' in your -home directory. This file, if it exists, should contain Lisp code. It -is called your initialization file or "init file". Use the command -line switch `-q' to tell Emacs whether to load an init file (*note -Entering Emacs::.). Use the command line switch `-user-init-file' -(*note Command Switches::.) to tell Emacs to load a different file -instead of `~/.emacs'. + When you start Emacs, it normally loads either `.xemacs/init.el' or +the file `.emacs' (whichever comes first) in your home directory. This +file, if it exists, should contain Lisp code. It is called your +initialization file or "init file". Use the command line switch `-q' +to tell Emacs whether to load an init file (*note Entering Emacs::). +Use the command line switch `-user-init-file' (*note Command +Switches::) to tell Emacs to load a different file instead of +`~/.xemacs/init.el'/`~/.emacs'. - When the `.emacs' file is read, the variable `user-init-file' says -which init file was loaded. + When the init file is read, the variable `user-init-file' says which +init file was loaded. At some sites there is a "default init file", which is the library named `default.el', found via the standard search path for libraries. @@ -54,10 +850,8 @@ whenever you start Emacs. But your init file, if any, is loaded first; if it sets `inhibit-default-init' non-`nil', then `default' is not loaded. - If you have a large amount of code in your `.emacs' file, you should -move it into another file named `SOMETHING.el', byte-compile it (*note -Lisp Libraries::.), and load that file from your `.emacs' file using -`load'. + If you have a large amount of code in your init file, you should +byte-compile it to `~/.xemacs/init.elc' or `~/.emacs.elc'. * Menu: @@ -71,16 +865,16 @@ File: xemacs.info, Node: Init Syntax, Next: Init Examples, Up: Init File Init File Syntax ---------------- - The `.emacs' file contains one or more Lisp function call -expressions. Each consists of a function name followed by arguments, -all surrounded by parentheses. For example, `(setq fill-column 60)' -represents a call to the function `setq' which is used to set the -variable `fill-column' (*note Filling::.) to 60. + The init file contains one or more Lisp function call expressions. +Each consists of a function name followed by arguments, all surrounded +by parentheses. For example, `(setq fill-column 60)' represents a call +to the function `setq' which is used to set the variable `fill-column' +(*note Filling::) to 60. The second argument to `setq' is an expression for the new value of the variable. This can be a constant, a variable, or a function call -expression. In `.emacs', constants are used most of the time. They -can be: +expression. In the init file, constants are used most of the time. +They can be: Numbers Integers are written in decimal, with an optional initial minus @@ -191,7 +985,7 @@ Lisp expressions: When the argument to `load' is a relative pathname, not starting with `/' or `~', `load' searches the directories in `load-path' - (*note Loading::.). + (*note Loading::). * Load the compiled Lisp file `foo.elc' from your home directory. @@ -272,16 +1066,16 @@ Thus, terminal types `aaa-48' and `aaa-30-rv' both use the library the full terminal type name. The library's name is constructed by concatenating the value of the -variable `term-file-prefix' and the terminal type. Your `.emacs' file -can prevent the loading of the terminal-specific library by setting -`term-file-prefix' to `nil'. +variable `term-file-prefix' and the terminal type. Your init file can +prevent the loading of the terminal-specific library by setting +`term-file-prefix' to `nil'. *Note Init File::. The value of the variable `term-setup-hook', if not `nil', is called as a function of no arguments at the end of Emacs initialization, after -both your `.emacs' file and any terminal-specific library have been -read. You can set the value in the `.emacs' file to override part of -any of the terminal-specific libraries and to define initializations -for terminals that do not have a library. +both your init file and any terminal-specific library have been read. +*Note Init File::. You can set the value in the init file to override +part of any of the terminal-specific libraries and to define +initializations for terminals that do not have a library.  File: xemacs.info, Node: Audible Bell, Next: Faces, Prev: Init File, Up: Customization @@ -379,760 +1173,3 @@ kernel of Emacs uses. `yes-or-no-p' You type something other than `yes' or `no' - -File: xemacs.info, Node: Faces, Next: X Resources, Prev: Audible Bell, Up: Customization - -Faces -===== - - XEmacs has objects called extents and faces. An "extent" is a -region of text and a "face" is a collection of textual attributes, such -as fonts and colors. Every extent is displayed in some face; -therefore, changing the properties of a face immediately updates the -display of all associated extents. Faces can be frame-local: you can -have a region of text that displays with completely different -attributes when its buffer is viewed from a different X window. - - The display attributes of faces may be specified either in Lisp or -through the X resource manager. - -Customizing Faces ------------------ - - You can change the face of an extent with the functions in this -section. All the functions prompt for a FACE as an argument; use -completion for a list of possible values. - -`M-x invert-face' - Swap the foreground and background colors of the given FACE. - -`M-x make-face-bold' - Make the font of the given FACE bold. When called from a program, - returns `nil' if this is not possible. - -`M-x make-face-bold-italic' - Make the font of the given FACE bold italic. When called from a - program, returns `nil' if not possible. - -`M-x make-face-italic' - Make the font of the given FACE italic. When called from a - program, returns `nil' if not possible. - -`M-x make-face-unbold' - Make the font of the given FACE non-bold. When called from a - program, returns `nil' if not possible. - -`M-x make-face-unitalic' - Make the font of the given FACE non-italic. When called from a - program, returns `nil' if not possible. - -`M-x make-face-larger' - Make the font of the given FACE a little larger. When called from - a program, returns `nil' if not possible. - -`M-x make-face-smaller' - Make the font of the given FACE a little smaller. When called - from a program, returns `nil' if not possible. - -`M-x set-face-background' - Change the background color of the given FACE. - -`M-x set-face-background-pixmap' - Change the background pixmap of the given FACE. - -`M-x set-face-font' - Change the font of the given FACE. - -`M-x set-face-foreground' - Change the foreground color of the given FACE. - -`M-x set-face-underline-p' - Change whether the given FACE is underlined. - - You can exchange the foreground and background color of the selected -FACE with the function `invert-face'. If the face does not specify both -foreground and background, then its foreground and background are set -to the background and foreground of the default face. When calling -this from a program, you can supply the optional argument FRAME to -specify which frame is affected; otherwise, all frames are affected. - - You can set the background color of the specified FACE with the -function `set-face-background'. The argument `color' should be a -string, the name of a color. When called from a program, if the -optional FRAME argument is provided, the face is changed only in that -frame; otherwise, it is changed in all frames. - - You can set the background pixmap of the specified FACE with the -function `set-face-background-pixmap'. The pixmap argument NAME should -be a string, the name of a file of pixmap data. The directories listed -in the `x-bitmap-file-path' variable are searched. The bitmap may also -be a list of the form `(WIDTH HEIGHT DATA)', where WIDTH and HEIGHT are -the size in pixels, and DATA is a string containing the raw bits of the -bitmap. If the optional FRAME argument is provided, the face is -changed only in that frame; otherwise, it is changed in all frames. - - The variable `x-bitmap-file-path' takes as a value a list of the -directories in which X bitmap files may be found. If the value is -`nil', the list is initialized from the `*bitmapFilePath' resource. - - If the environment variable XBMLANGPATH is set, then it is consulted -before the `x-bitmap-file-path' variable. - - You can set the font of the specified FACE with the function -`set-face-font'. The FONT argument should be a string, the name of a -font. When called from a program, if the optional FRAME argument is -provided, the face is changed only in that frame; otherwise, it is -changed in all frames. - - You can set the foreground color of the specified FACE with the -function `set-face-foreground'. The argument COLOR should be a string, -the name of a color. If the optional FRAME argument is provided, the -face is changed only in that frame; otherwise, it is changed in all -frames. - - You can set underline the specified FACE with the function -`set-face-underline-p'. The argument UNDERLINE-P can be used to make -underlining an attribute of the face or not. If the optional FRAME -argument is provided, the face is changed only in that frame; -otherwise, it is changed in all frames. - - -File: xemacs.info, Node: X Resources, Prev: Faces, Up: Customization - -X Resources -=========== - - Historically, XEmacs has used the X resource application class -`Emacs' for its resources. Unfortunately, GNU Emacs uses the same -application class, and resources are not compatible between the two -Emacsen. This sharing of the application class often leads to trouble -if you want to run both variants. - - Starting with XEmacs 21, XEmacs uses the class `XEmacs' if it finds -any XEmacs resources in the resource database when the X connection is -initialized. Otherwise, it will use the class `Emacs' for backwards -compatability. The variable X-EMACS-APPLICATION-CLASS may be consulted -to determine the application class being used. - - The examples in this section assume the application class is `Emacs'. - - The Emacs resources are generally set per-frame. Each Emacs frame -can have its own name or the same name as another, depending on the -name passed to the `make-frame' function. - - You can specify resources for all frames with the syntax: - - Emacs*parameter: value - -or - - Emacs*EmacsFrame.parameter:value - -You can specify resources for a particular frame with the syntax: - - Emacs*FRAME-NAME.parameter: value - -* Menu: - -* Geometry Resources:: Controlling the size and position of frames. -* Iconic Resources:: Controlling whether frames come up iconic. -* Resource List:: List of resources settable on a frame or device. -* Face Resources:: Controlling faces using resources. -* Widgets:: The widget hierarchy for XEmacs. -* Menubar Resources:: Specifying resources for the menubar. - - -File: xemacs.info, Node: Geometry Resources, Next: Iconic Resources, Up: X Resources - -Geometry Resources ------------------- - - To make the default size of all Emacs frames be 80 columns by 55 -lines, do this: - - Emacs*EmacsFrame.geometry: 80x55 - -To set the geometry of a particular frame named `fred', do this: - - Emacs*fred.geometry: 80x55 - -Important! Do not use the following syntax: - - Emacs*geometry: 80x55 - -You should never use `*geometry' with any X application. It does not -say "make the geometry of Emacs be 80 columns by 55 lines." It really -says, "make Emacs and all subwindows thereof be 80x55 in whatever units -they care to measure in." In particular, that is both telling the -Emacs text pane to be 80x55 in characters, and telling the menubar pane -to be 80x55 pixels, which is surely not what you want. - - As a special case, this geometry specification also works (and sets -the default size of all Emacs frames to 80 columns by 55 lines): - - Emacs.geometry: 80x55 - -since that is the syntax used with most other applications (since most -other applications have only one top-level window, unlike Emacs). In -general, however, the top-level shell (the unmapped ApplicationShell -widget named `Emacs' that is the parent of the shell widgets that -actually manage the individual frames) does not have any interesting -resources on it, and you should set the resources on the frames instead. - - The `-geometry' command-line argument sets only the geometry of the -initial frame created by Emacs. - - A more complete explanation of geometry-handling is - - * The `-geometry' command-line option sets the `Emacs.geometry' - resource, that is, the geometry of the ApplicationShell. - - * For the first frame created, the size of the frame is taken from - the ApplicationShell if it is specified, otherwise from the - geometry of the frame. - - * For subsequent frames, the order is reversed: First the frame, and - then the ApplicationShell. - - * For the first frame created, the position of the frame is taken - from the ApplicationShell (`Emacs.geometry') if it is specified, - otherwise from the geometry of the frame. - - * For subsequent frames, the position is taken only from the frame, - and never from the ApplicationShell. - - This is rather complicated, but it does seem to provide the most -intuitive behavior with respect to the default sizes and positions of -frames created in various ways. - - -File: xemacs.info, Node: Iconic Resources, Next: Resource List, Prev: Geometry Resources, Up: X Resources - -Iconic Resources ----------------- - - Analogous to `-geometry', the `-iconic' command-line option sets the -iconic flag of the ApplicationShell (`Emacs.iconic') and always applies -to the first frame created regardless of its name. However, it is -possible to set the iconic flag on particular frames (by name) by using -the `Emacs*FRAME-NAME.iconic' resource. - - -File: xemacs.info, Node: Resource List, Next: Face Resources, Prev: Iconic Resources, Up: X Resources - -Resource List -------------- - - Emacs frames accept the following resources: - -`geometry' (class `Geometry'): string - Initial geometry for the frame. *Note Geometry Resources::, for a - complete discussion of how this works. - -`iconic' (class `Iconic'): boolean - Whether this frame should appear in the iconified state. - -`internalBorderWidth' (class `InternalBorderWidth'): int - How many blank pixels to leave between the text and the edge of the - window. - -`interline' (class `Interline'): int - How many pixels to leave between each line (may not be - implemented). - -`menubar' (class `Menubar'): boolean - Whether newly-created frames should initially have a menubar. Set - to true by default. - -`initiallyUnmapped' (class `InitiallyUnmapped'): boolean - Whether XEmacs should leave the initial frame unmapped when it - starts up. This is useful if you are starting XEmacs as a server - (e.g. in conjunction with gnuserv or the external client widget). - You can also control this with the `-unmapped' command-line option. - -`barCursor' (class `BarColor'): boolean - Whether the cursor should be displayed as a bar, or the - traditional box. - -`cursorColor' (class `CursorColor'): color-name - The color of the text cursor. - -`scrollBarWidth' (class `ScrollBarWidth'): integer - How wide the vertical scrollbars should be, in pixels; 0 means no - vertical scrollbars. You can also use a resource specification of - the form `*scrollbar.width', or the usual toolkit scrollbar - resources: `*XmScrollBar.width' (Motif), `*XlwScrollBar.width' - (Lucid), or `*Scrollbar.thickness' (Athena). We don't recommend - that you use the toolkit resources, though, because they're - dependent on how exactly your particular build of XEmacs was - configured. - -`scrollBarHeight' (class `ScrollBarHeight'): integer - How high the horizontal scrollbars should be, in pixels; 0 means no - horizontal scrollbars. You can also use a resource specification - of the form `*scrollbar.height', or the usual toolkit scrollbar - resources: `*XmScrollBar.height' (Motif), `*XlwScrollBar.height' - (Lucid), or `*Scrollbar.thickness' (Athena). We don't recommend - that you use the toolkit resources, though, because they're - dependent on how exactly your particular build of XEmacs was - configured. - -`scrollBarPlacement' (class `ScrollBarPlacement'): string - Where the horizontal and vertical scrollbars should be positioned. - This should be one of the four strings `BOTTOM_LEFT', - `BOTTOM_RIGHT', `TOP_LEFT', and `TOP_RIGHT'. Default is - `BOTTOM_RIGHT' for the Motif and Lucid scrollbars and - `BOTTOM_LEFT' for the Athena scrollbars. - -`topToolBarHeight' (class `TopToolBarHeight'): integer -`bottomToolBarHeight' (class `BottomToolBarHeight'): integer -`leftToolBarWidth' (class `LeftToolBarWidth'): integer -`rightToolBarWidth' (class `RightToolBarWidth'): integer - Height and width of the four possible toolbars. - -`topToolBarShadowColor' (class `TopToolBarShadowColor'): color-name -`bottomToolBarShadowColor' (class `BottomToolBarShadowColor'): color-name - Color of the top and bottom shadows for the toolbars. NOTE: These - resources do *not* have anything to do with the top and bottom - toolbars (i.e. the toolbars at the top and bottom of the frame)! - Rather, they affect the top and bottom shadows around the edges of - all four kinds of toolbars. - -`topToolBarShadowPixmap' (class `TopToolBarShadowPixmap'): pixmap-name -`bottomToolBarShadowPixmap' (class `BottomToolBarShadowPixmap'): pixmap-name - Pixmap of the top and bottom shadows for the toolbars. If set, - these resources override the corresponding color resources. NOTE: - These resources do *not* have anything to do with the top and - bottom toolbars (i.e. the toolbars at the top and bottom of the - frame)! Rather, they affect the top and bottom shadows around the - edges of all four kinds of toolbars. - -`toolBarShadowThickness' (class `ToolBarShadowThickness'): integer - Thickness of the shadows around the toolbars, in pixels. - -`visualBell' (class `VisualBell'): boolean - Whether XEmacs should flash the screen rather than making an - audible beep. - -`bellVolume' (class `BellVolume'): integer - Volume of the audible beep. - -`useBackingStore' (class `UseBackingStore'): boolean - Whether XEmacs should set the backing-store attribute of the X - windows it creates. This increases the memory usage of the X - server but decreases the amount of X traffic necessary to update - the screen, and is useful when the connection to the X server goes - over a low-bandwidth line such as a modem connection. - - Emacs devices accept the following resources: - -`textPointer' (class `Cursor'): cursor-name - The cursor to use when the mouse is over text. This resource is - used to initialize the variable `x-pointer-shape'. - -`selectionPointer' (class `Cursor'): cursor-name - The cursor to use when the mouse is over a selectable text region - (an extent with the `highlight' property; for example, an Info - cross-reference). This resource is used to initialize the variable - `x-selection-pointer-shape'. - -`spacePointer' (class `Cursor'): cursor-name - The cursor to use when the mouse is over a blank space in a buffer - (that is, after the end of a line or after the end-of-file). This - resource is used to initialize the variable - `x-nontext-pointer-shape'. - -`modeLinePointer' (class `Cursor'): cursor-name - The cursor to use when the mouse is over a modeline. This - resource is used to initialize the variable `x-mode-pointer-shape'. - -`gcPointer' (class `Cursor'): cursor-name - The cursor to display when a garbage-collection is in progress. - This resource is used to initialize the variable - `x-gc-pointer-shape'. - -`scrollbarPointer' (class `Cursor'): cursor-name - The cursor to use when the mouse is over the scrollbar. This - resource is used to initialize the variable - `x-scrollbar-pointer-shape'. - -`pointerColor' (class `Foreground'): color-name -`pointerBackground' (class `Background'): color-name - The foreground and background colors of the mouse cursor. These - resources are used to initialize the variables - `x-pointer-foreground-color' and `x-pointer-background-color'. - - -File: xemacs.info, Node: Face Resources, Next: Widgets, Prev: Resource List, Up: X Resources - -Face Resources --------------- - - The attributes of faces are also per-frame. They can be specified as: - - Emacs.FACE_NAME.parameter: value - -or - - Emacs*FRAME_NAME.FACE_NAME.parameter: value - -Faces accept the following resources: - -`attributeFont' (class `AttributeFont'): font-name - The font of this face. - -`attributeForeground' (class `AttributeForeground'): color-name -`attributeBackground' (class `AttributeBackground'): color-name - The foreground and background colors of this face. - -`attributeBackgroundPixmap' (class `AttributeBackgroundPixmap'): file-name - The name of an XBM file (or XPM file, if your version of Emacs - supports XPM), to use as a background stipple. - -`attributeUnderline' (class `AttributeUnderline'): boolean - Whether text in this face should be underlined. - - All text is displayed in some face, defaulting to the face named -`default'. To set the font of normal text, use -`Emacs*default.attributeFont'. To set it in the frame named `fred', use -`Emacs*fred.default.attributeFont'. - - These are the names of the predefined faces: - -`default' - Everything inherits from this. - -`bold' - If this is not specified in the resource database, Emacs tries to - find a bold version of the font of the default face. - -`italic' - If this is not specified in the resource database, Emacs tries to - find an italic version of the font of the default face. - -`bold-italic' - If this is not specified in the resource database, Emacs tries to - find a bold-italic version of the font of the default face. - -`modeline' - This is the face that the modeline is displayed in. If not - specified in the resource database, it is determined from the - default face by reversing the foreground and background colors. - -`highlight' - This is the face that highlighted extents (for example, Info - cross-references and possible completions, when the mouse passes - over them) are displayed in. - -`left-margin' -`right-margin' - These are the faces that the left and right annotation margins are - displayed in. - -`zmacs-region' - This is the face that mouse selections are displayed in. - -`isearch' - This is the face that the matched text being searched for is - displayed in. - -`info-node' - This is the face of info menu items. If unspecified, it is copied - from `bold-italic'. - -`info-xref' - This is the face of info cross-references. If unspecified, it is - copied from `bold'. (Note that, when the mouse passes over a - cross-reference, the cross-reference's face is determined from a - combination of the `info-xref' and `highlight' faces.) - - Other packages might define their own faces; to see a list of all -faces, use any of the interactive face-manipulation commands such as -`set-face-font' and type `?' when you are prompted for the name of a -face. - - If the `bold', `italic', and `bold-italic' faces are not specified -in the resource database, then XEmacs attempts to derive them from the -font of the default face. It can only succeed at this if you have -specified the default font using the XLFD (X Logical Font Description) -format, which looks like - - *-courier-medium-r-*-*-*-120-*-*-*-*-*-* - -If you use any of the other, less strict font name formats, some of -which look like - - lucidasanstypewriter-12 - fixed - 9x13 - - then XEmacs won't be able to guess the names of the bold and italic -versions. All X fonts can be referred to via XLFD-style names, so you -should use those forms. See the man pages for `X(1)', `xlsfonts(1)', -and `xfontsel(1)'. - - -File: xemacs.info, Node: Widgets, Next: Menubar Resources, Prev: Face Resources, Up: X Resources - -Widgets -------- - - There are several structural widgets between the terminal EmacsFrame -widget and the top level ApplicationShell; the exact names and types of -these widgets change from release to release (for example, they changed -between 19.8 and 19.9, 19.9 and 19.10, and 19.10 and 19.12) and are -subject to further change in the future, so you should avoid mentioning -them in your resource database. The above-mentioned syntaxes should be -forward- compatible. As of 19.13, the exact widget hierarchy is as -follows: - - INVOCATION-NAME "shell" "container" FRAME-NAME - x-emacs-application-class "EmacsShell" "EmacsManager" "EmacsFrame" - - where INVOCATION-NAME is the terminal component of the name of the -XEmacs executable (usually `xemacs'), and `x-emacs-application-class' -is generally `Emacs'. - - -File: xemacs.info, Node: Menubar Resources, Prev: Widgets, Up: X Resources - -Menubar Resources ------------------ - - As the menubar is implemented as a widget which is not a part of -XEmacs proper, it does not use the fac" mechanism for specifying fonts -and colors: It uses whatever resources are appropriate to the type of -widget which is used to implement it. - - If Emacs was compiled to use only the Motif-lookalike menu widgets, -then one way to specify the font of the menubar would be - - Emacs*menubar*font: *-courier-medium-r-*-*-*-120-*-*-*-*-*-* - - If the Motif library is being used, then one would have to use - - Emacs*menubar*fontList: *-courier-medium-r-*-*-*-120-*-*-*-*-*-* - - because the Motif library uses the `fontList' resource name instead -of `font', which has subtly different semantics. - - The same is true of the scrollbars: They accept whichever resources -are appropriate for the toolkit in use. - - -File: xemacs.info, Node: Quitting, Next: Lossage, Prev: Customization, Up: Top - -Quitting and Aborting -===================== - -`C-g' - Quit. Cancel running or partially typed command. - -`C-]' - Abort innermost recursive editing level and cancel the command - which invoked it (`abort-recursive-edit'). - -`M-x top-level' - Abort all recursive editing levels that are currently executing. - -`C-x u' - Cancel an already-executed command, usually (`undo'). - - There are two ways of cancelling commands which are not finished -executing: "quitting" with `C-g', and "aborting" with `C-]' or `M-x -top-level'. Quitting is cancelling a partially typed command or one -which is already running. Aborting is getting out of a recursive -editing level and cancelling the command that invoked the recursive -edit. - - Quitting with `C-g' is used for getting rid of a partially typed -command or a numeric argument that you don't want. It also stops a -running command in the middle in a relatively safe way, so you can use -it if you accidentally start executing a command that takes a long -time. In particular, it is safe to quit out of killing; either your -text will ALL still be there, or it will ALL be in the kill ring (or -maybe both). Quitting an incremental search does special things -documented under searching; in general, it may take two successive -`C-g' characters to get out of a search. `C-g' works by setting the -variable `quit-flag' to `t' the instant `C-g' is typed; Emacs Lisp -checks this variable frequently and quits if it is non-`nil'. `C-g' is -only actually executed as a command if it is typed while Emacs is -waiting for input. - - If you quit twice in a row before the first `C-g' is recognized, you -activate the "emergency escape" feature and return to the shell. *Note -Emergency Escape::. - - You can use `C-]' (`abort-recursive-edit') to get out of a recursive -editing level and cancel the command which invoked it. Quitting with -`C-g' does not do this, and could not do this because it is used to -cancel a partially typed command within the recursive editing level. -Both operations are useful. For example, if you are in the Emacs -debugger (*note Lisp Debug::.) and have typed `C-u 8' to enter a -numeric argument, you can cancel that argument with `C-g' and remain in -the debugger. - - The command `M-x top-level' is equivalent to "enough" `C-]' commands -to get you out of all the levels of recursive edits that you are in. -`C-]' only gets you out one level at a time, but `M-x top-level' goes -out all levels at once. Both `C-]' and `M-x top-level' are like all -other commands and unlike `C-g' in that they are effective only when -Emacs is ready for a command. `C-]' is an ordinary key and has its -meaning only because of its binding in the keymap. *Note Recursive -Edit::. - - `C-x u' (`undo') is not strictly speaking a way of cancelling a -command, but you can think of it as cancelling a command already -finished executing. *Note Undo::. - - -File: xemacs.info, Node: Lossage, Next: Bugs, Prev: Quitting, Up: Top - -Dealing With Emacs Trouble -========================== - - This section describes various conditions in which Emacs fails to -work, and how to recognize them and correct them. - -* Menu: - -* Stuck Recursive:: `[...]' in mode line around the parentheses. -* Screen Garbled:: Garbage on the screen. -* Text Garbled:: Garbage in the text. -* Unasked-for Search:: Spontaneous entry to incremental search. -* Emergency Escape:: Emergency escape-- - What to do if Emacs stops responding. -* Total Frustration:: When you are at your wits' end. - - -File: xemacs.info, Node: Stuck Recursive, Next: Screen Garbled, Prev: Lossage, Up: Lossage - -Recursive Editing Levels ------------------------- - - Recursive editing levels are important and useful features of Emacs, -but they can seem like malfunctions to the user who does not understand -them. - - If the mode line has square brackets `[...]' around the parentheses -that contain the names of the major and minor modes, you have entered a -recursive editing level. If you did not do this on purpose, or if you -don't understand what that means, you should just get out of the -recursive editing level. To do so, type `M-x top-level'. This is -called getting back to top level. *Note Recursive Edit::. - - -File: xemacs.info, Node: Screen Garbled, Next: Text Garbled, Prev: Stuck Recursive, Up: Lossage - -Garbage on the Screen ---------------------- - - If the data on the screen looks wrong, the first thing to do is see -whether the text is actually wrong. Type `C-l', to redisplay the -entire screen. If the text appears correct after this, the problem was -entirely in the previous screen update. - - Display updating problems often result from an incorrect termcap -entry for the terminal you are using. The file `etc/TERMS' in the Emacs -distribution gives the fixes for known problems of this sort. -`INSTALL' contains general advice for these problems in one of its -sections. Very likely there is simply insufficient padding for certain -display operations. To investigate the possibility that you have this -sort of problem, try Emacs on another terminal made by a different -manufacturer. If problems happen frequently on one kind of terminal but -not another kind, the real problem is likely to be a bad termcap entry, -though it could also be due to a bug in Emacs that appears for terminals -that have or lack specific features. - - -File: xemacs.info, Node: Text Garbled, Next: Unasked-for Search, Prev: Screen Garbled, Up: Lossage - -Garbage in the Text -------------------- - - If `C-l' shows that the text is wrong, try undoing the changes to it -using `C-x u' until it gets back to a state you consider correct. Also -try `C-h l' to find out what command you typed to produce the observed -results. - - If a large portion of text appears to be missing at the beginning or -end of the buffer, check for the word `Narrow' in the mode line. If it -appears, the text is still present, but marked off-limits. To make it -visible again, type `C-x n w'. *Note Narrowing::. - - -File: xemacs.info, Node: Unasked-for Search, Next: Emergency Escape, Prev: Text Garbled, Up: Lossage - -Spontaneous Entry to Incremental Search ---------------------------------------- - - If Emacs spontaneously displays `I-search:' at the bottom of the -screen, it means that the terminal is sending `C-s' and `C-q' according -to the poorly designed xon/xoff "flow control" protocol. You should -try to prevent this by putting the terminal in a mode where it will not -use flow control, or by giving it enough padding that it will never -send a `C-s'. If that cannot be done, you must tell Emacs to expect -flow control to be used, until you can get a properly designed terminal. - - Information on how to do these things can be found in the file -`INSTALL' in the Emacs distribution. - - -File: xemacs.info, Node: Emergency Escape, Next: Total Frustration, Prev: Unasked-for Search, Up: Lossage - -Emergency Escape ----------------- - - Because at times there have been bugs causing Emacs to loop without -checking `quit-flag', a special feature causes Emacs to be suspended -immediately if you type a second `C-g' while the flag is already set, -so you can always get out of XEmacs. Normally Emacs recognizes and -clears `quit-flag' (and quits!) quickly enough to prevent this from -happening. - - When you resume Emacs after a suspension caused by multiple `C-g', it -asks two questions before going back to what it had been doing: - - Auto-save? (y or n) - Abort (and dump core)? (y or n) - -Answer each one with `y' or `n' followed by . - - Saying `y' to `Auto-save?' causes immediate auto-saving of all -modified buffers in which auto-saving is enabled. - - Saying `y' to `Abort (and dump core)?' causes an illegal instruction -to be executed, dumping core. This is to enable a wizard to figure out -why Emacs was failing to quit in the first place. Execution does not -continue after a core dump. If you answer `n', execution does -continue. With luck, Emacs will ultimately check `quit-flag' and quit -normally. If not, and you type another `C-g', it is suspended again. - - If Emacs is not really hung, but is just being slow, you may invoke -the double `C-g' feature without really meaning to. In that case, -simply resume and answer `n' to both questions, and you will arrive at -your former state. Presumably the quit you requested will happen soon. - - The double-`C-g' feature may be turned off when Emacs is running -under a window system, since the window system always enables you to -kill Emacs or to create another window and run another program. - - -File: xemacs.info, Node: Total Frustration, Prev: Emergency Escape, Up: Lossage - -Help for Total Frustration --------------------------- - - If using Emacs (or something else) becomes terribly frustrating and -none of the techniques described above solve the problem, Emacs can -still help you. - - First, if the Emacs you are using is not responding to commands, type -`C-g C-g' to get out of it and then start a new one. - - Second, type `M-x doctor '. - - The doctor will make you feel better. Each time you say something to -the doctor, you must end it by typing . This lets the -doctor know you are finished. -