-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
translation approved by the author instead of in the original English.
\1f
+File: xemacs.info, Node: File Variables, Prev: Locals, Up: Variables
+
+Local Variables in Files
+------------------------
+
+ A file can contain a "local variables list", which specifies the
+values to use for certain Emacs variables when that file is edited.
+Visiting the file checks for a local variables list and makes each
+variable in the list local to the buffer in which the file is visited,
+with the value specified in the file.
+
+ A local variables list goes near the end of the file, in the last
+page. (It is often best to put it on a page by itself.) The local
+variables list starts with a line containing the string `Local
+Variables:', and ends with a line containing the string `End:'. In
+between come the variable names and values, one set per line, as
+`VARIABLE: VALUE'. The VALUEs are not evaluated; they are used
+literally.
+
+ The line which starts the local variables list does not have to say
+just `Local Variables:'. If there is other text before `Local
+Variables:', that text is called the "prefix", and if there is other
+text after, that is called the "suffix". If a prefix or suffix are
+present, each entry in the local variables list should have the prefix
+before it and the suffix after it. This includes the `End:' line. The
+prefix and suffix are included to disguise the local variables list as
+a comment so the compiler or text formatter will ignore it. If you do
+not need to disguise the local variables list as a comment in this way,
+there is no need to include a prefix or a suffix.
+
+ Two "variable" names are special in a local variables list: a value
+for the variable `mode' sets the major mode, and a value for the
+variable `eval' is simply evaluated as an expression and the value is
+ignored. These are not real variables; setting them in any other
+context does not have the same effect. If `mode' is used in a local
+variables list, it should be the first entry in the list.
+
+ Here is an example of a local variables list:
+ ;;; Local Variables: ***
+ ;;; mode:lisp ***
+ ;;; comment-column:0 ***
+ ;;; comment-start: ";;; " ***
+ ;;; comment-end:"***" ***
+ ;;; End: ***
+
+ Note that the prefix is `;;; ' and the suffix is ` ***'. Note also
+that comments in the file begin with and end with the same strings.
+Presumably the file contains code in a language which is enough like
+Lisp for Lisp mode to be useful but in which comments start and end
+differently. The prefix and suffix are used in the local variables
+list to make the list look like several lines of comments when the
+compiler or interpreter for that language reads the file.
+
+ The start of the local variables list must be no more than 3000
+characters from the end of the file, and must be in the last page if the
+file is divided into pages. Otherwise, Emacs will not notice it is
+there. The purpose is twofold: a stray `Local Variables:' not in the
+last page does not confuse Emacs, and Emacs never needs to search a
+long file that contains no page markers and has no local variables list.
+
+ You may be tempted to turn on Auto Fill mode with a local variable
+list. That is inappropriate. Whether you use Auto Fill mode or not is
+a matter of personal taste, not a matter of the contents of particular
+files. If you want to use Auto Fill, set up major mode hooks with your
+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.
+
+\1f
+File: xemacs.info, Node: Keyboard Macros, Next: Key Bindings, Prev: Variables, Up: Customization
+
+Keyboard Macros
+===============
+
+ A "keyboard macro" is a command defined by the user to abbreviate a
+sequence of keys. For example, if you discover that you are about to
+type `C-n C-d' forty times, you can speed your work by defining a
+keyboard macro to invoke `C-n C-d' and calling it with a repeat count
+of forty.
+
+`C-x ('
+ Start defining a keyboard macro (`start-kbd-macro').
+
+`C-x )'
+ End the definition of a keyboard macro (`end-kbd-macro').
+
+`C-x e'
+ Execute the most recent keyboard macro (`call-last-kbd-macro').
+
+`C-u C-x ('
+ Re-execute last keyboard macro, then add more keys to its
+ definition.
+
+`C-x q'
+ When this point is reached during macro execution, ask for
+ confirmation (`kbd-macro-query').
+
+`M-x name-last-kbd-macro'
+ Give a command name (for the duration of the session) to the most
+ recently defined keyboard macro.
+
+`M-x insert-kbd-macro'
+ Insert in the buffer a keyboard macro's definition, as Lisp code.
+
+ Keyboard macros differ from other Emacs commands in that they are
+written in the Emacs command language rather than in Lisp. This makes
+it easier for the novice to write them and makes them more convenient as
+temporary hacks. However, the Emacs command language is not powerful
+enough as a programming language to be useful for writing anything
+general or complex. For such things, Lisp must be used.
+
+ You define a keyboard macro by executing the commands which are its
+definition. Put differently, as you are defining a keyboard macro, the
+definition is being executed for the first time. This way, you see
+what the effects of your commands are, and don't have to figure them
+out in your head. When you are finished, the keyboard macro is defined
+and also has been executed once. You can then execute the same set of
+commands again by invoking the macro.
+
+* Menu:
+
+* Basic Kbd Macro:: Defining and running keyboard macros.
+* Save Kbd Macro:: Giving keyboard macros names; saving them in files.
+* Kbd Macro Query:: Keyboard macros that do different things each use.
+
+\1f
+File: xemacs.info, Node: Basic Kbd Macro, Next: Save Kbd Macro, Up: Keyboard Macros
+
+Basic Use
+---------
+
+ To start defining a keyboard macro, type `C-x ('
+(`start-kbd-macro'). From then on, anything you type continues to be
+executed, but also becomes part of the definition of the macro. `Def'
+appears in the mode line to remind you of what is going on. When you
+are finished, the `C-x )' command (`end-kbd-macro') terminates the
+definition, without becoming part of it.
+
+ For example,
+
+ C-x ( M-f foo C-x )
+
+defines a macro to move forward a word and then insert `foo'.
+
+ You can give `C-x )' a repeat count as an argument, in which case it
+repeats the macro that many times right after defining it, but defining
+the macro counts as the first repetition (since it is executed as you
+define it). If you give `C-x )' an argument of 4, it executes the
+macro immediately 3 additional times. An argument of zero to `C-x e'
+or `C-x )' means repeat the macro indefinitely (until it gets an error
+or you type `C-g').
+
+ Once you have defined a macro, you can invoke it again with the `C-x
+e' command (`call-last-kbd-macro'). You can give the command a repeat
+count numeric argument to execute the macro many times.
+
+ To repeat an operation at regularly spaced places in the text,
+define a macro and include as part of the macro the commands to move to
+the next place you want to use it. For example, if you want to change
+each line, you should position point at the start of a line, and define
+a macro to change that line and leave point at the start of the next
+line. Repeating the macro will then operate on successive lines.
+
+ After you have terminated the definition of a keyboard macro, you
+can add to the end of its definition by typing `C-u C-x ('. This is
+equivalent to plain `C-x (' followed by retyping the whole definition
+so far. As a consequence it re-executes the macro as previously
+defined.
+
+\1f
+File: xemacs.info, Node: Save Kbd Macro, Next: Kbd Macro Query, Prev: Basic Kbd Macro, Up: Keyboard Macros
+
+Naming and Saving Keyboard Macros
+---------------------------------
+
+ To save a keyboard macro for longer than until you define the next
+one, you must give it a name using `M-x name-last-kbd-macro'. This
+reads a name as an argument using the minibuffer and defines that name
+to execute the macro. The macro name is a Lisp symbol, and defining it
+in this way makes it a valid command name for calling with `M-x' or for
+binding a key to with `global-set-key' (*note Keymaps::). If you
+specify a name that has a prior definition other than another keyboard
+macro, Emacs prints an error message and nothing is changed.
+
+ Once a macro has a command name, you can save its definition in a
+file. You can then use it in another editing session. First visit the
+file you want to save the definition in. Then use the command:
+
+ M-x insert-kbd-macro <RET> MACRONAME <RET>
+
+This inserts some Lisp code that, when executed later, will define the
+same macro with the same definition it has now. You need not
+understand Lisp code to do this, because `insert-kbd-macro' writes the
+Lisp code for you. Then save the file. You can load the file with
+`load-file' (*note Lisp Libraries::). If the file you save in is your
+initialization file (*note Init File::), then the macro will be defined
+each time you run Emacs.
+
+ If you give `insert-kbd-macro' a prefix argument, it creates
+additional Lisp code to record the keys (if any) that you have bound to
+the keyboard macro, so that the macro is reassigned the same keys when
+you load the file.
+
+\1f
+File: xemacs.info, Node: Kbd Macro Query, Prev: Save Kbd Macro, Up: Keyboard Macros
+
+Executing Macros With Variations
+--------------------------------
+
+ You can use `C-x q' (`kbd-macro-query'), to get an effect similar to
+that of `query-replace'. The macro asks you each time whether to make
+a change. When you are defining the macro, type `C-x q' at the point
+where you want the query to occur. During macro definition, the `C-x
+q' does nothing, but when you invoke the macro, `C-x q' reads a
+character from the terminal to decide whether to continue.
+
+ The special answers to a `C-x q' query are <SPC>, <DEL>, `C-d',
+`C-l', and `C-r'. Any other character terminates execution of the
+keyboard macro and is then read as a command. <SPC> means to continue.
+<DEL> means to skip the remainder of this repetition of the macro,
+starting again from the beginning in the next repetition. `C-d' means
+to skip the remainder of this repetition and cancel further repetition.
+`C-l' redraws the frame and asks you again for a character to specify
+what to do. `C-r' enters a recursive editing level, in which you can
+perform editing that is not part of the macro. When you exit the
+recursive edit using `C-M-c', you are asked again how to continue with
+the keyboard macro. If you type a <SPC> at this time, the rest of the
+macro definition is executed. It is up to you to leave point and the
+text in a state such that the rest of the macro will do what you want.
+
+ `C-u C-x q', which is `C-x q' with a numeric argument, performs a
+different function. It enters a recursive edit reading input from the
+keyboard, both when you type it during the definition of the macro and
+when it is executed from the macro. During definition, the editing you
+do inside the recursive edit does not become part of the macro. During
+macro execution, the recursive edit gives you a chance to do some
+particularized editing. *Note Recursive Edit::.
+
+\1f
+File: xemacs.info, Node: Key Bindings, Next: Syntax, Prev: Keyboard Macros, Up: Customization
+
+Customizing Key Bindings
+========================
+
+ This section deals with the "keymaps" that define the bindings
+between keys and functions, and shows how you can customize these
+bindings.
+
+ A command is a Lisp function whose definition provides for
+interactive use. Like every Lisp function, a command has a function
+name, which is a Lisp symbol whose name usually consists of lower case
+letters and hyphens.
+
+* Menu:
+
+* Keymaps:: Definition of the keymap data structure.
+ Names of Emacs's standard keymaps.
+* Rebinding:: How to redefine one key's meaning conveniently.
+* Disabling:: Disabling a command means confirmation is required
+ before it can be executed. This is done to protect
+ beginners from surprises.
+
+\1f
+File: xemacs.info, Node: Keymaps, Next: Rebinding, Up: Key Bindings
+
+Keymaps
+-------
+
+ The bindings between characters and command functions are recorded in
+data structures called "keymaps". Emacs has many of these. One, the
+"global" keymap, defines the meanings of the single-character keys that
+are defined regardless of major mode. It is the value of the variable
+`global-map'.
+
+ Each major mode has another keymap, its "local keymap", which
+contains overriding definitions for the single-character keys that are
+redefined in that mode. Each buffer records which local keymap is
+installed for it at any time, and the current buffer's local keymap is
+the only one that directly affects command execution. The local keymaps
+for Lisp mode, C mode, and many other major modes always exist even when
+not in use. They are the values of the variables `lisp-mode-map',
+`c-mode-map', and so on. For less frequently used major modes, the
+local keymap is sometimes constructed only when the mode is used for the
+first time in a session, to save space.
+
+ There are local keymaps for the minibuffer, too; they contain various
+completion and exit commands.
+
+ * `minibuffer-local-map' is used for ordinary input (no completion).
+
+ * `minibuffer-local-ns-map' is similar, except that <SPC> exits just
+ like <RET>. This is used mainly for Mocklisp compatibility.
+
+ * `minibuffer-local-completion-map' is for permissive completion.
+
+ * `minibuffer-local-must-match-map' is for strict completion and for
+ cautious completion.
+
+ * `repeat-complex-command-map' is for use in `C-x <ESC>'.
+
+ * `isearch-mode-map' contains the bindings of the special keys which
+ are bound in the pseudo-mode entered with `C-s' and `C-r'.
+
+ Finally, each prefix key has a keymap which defines the key sequences
+that start with it. For example, `ctl-x-map' is the keymap used for
+characters following a `C-x'.
+
+ * `ctl-x-map' is the variable name for the map used for characters
+ that follow `C-x'.
+
+ * `help-map' is used for characters that follow `C-h'.
+
+ * `esc-map' is for characters that follow <ESC>. All Meta characters
+ are actually defined by this map.
+
+ * `ctl-x-4-map' is for characters that follow `C-x 4'.
+
+ * `mode-specific-map' is for characters that follow `C-c'.
+
+ The definition of a prefix key is the keymap to use for looking up
+the following character. Sometimes the definition is actually a Lisp
+symbol whose function definition is the following character keymap. The
+effect is the same, but it provides a command name for the prefix key
+that you can use as a description of what the prefix key is for. Thus
+the binding of `C-x' is the symbol `Ctl-X-Prefix', whose function
+definition is the keymap for `C-x' commands, the value of `ctl-x-map'.
+
+ Prefix key definitions can appear in either the global map or a
+local map. The definitions of `C-c', `C-x', `C-h', and <ESC> as prefix
+keys appear in the global map, so these prefix keys are always
+available. Major modes can locally redefine a key as a prefix by
+putting a prefix key definition for it in the local map.
+
+ A mode can also put a prefix definition of a global prefix character
+such as `C-x' into its local map. This is how major modes override the
+definitions of certain keys that start with `C-x'. This case is
+special, because the local definition does not entirely replace the
+global one. When both the global and local definitions of a key are
+other keymaps, the next character is looked up in both keymaps, with
+the local definition overriding the global one. The character after the
+`C-x' is looked up in both the major mode's own keymap for redefined
+`C-x' commands and in `ctl-x-map'. If the major mode's own keymap for
+`C-x' commands contains `nil', the definition from the global keymap
+for `C-x' commands is used.
+
+\1f
+File: xemacs.info, Node: Rebinding, Next: Disabling, Prev: Keymaps, Up: Key Bindings
+
+Changing Key Bindings
+---------------------
+
+ You can redefine an Emacs key by changing its entry in a keymap.
+You can change the global keymap, in which case the change is effective
+in all major modes except those that have their own overriding local
+definitions for the same key. Or you can change the current buffer's
+local map, which affects all buffers using the same major mode.
+
+* Menu:
+
+* Interactive Rebinding:: Changing Key Bindings Interactively
+* Programmatic Rebinding:: Changing Key Bindings Programmatically
+* Key Bindings Using Strings:: Using Strings for Changing Key Bindings
+
+\1f
+File: xemacs.info, Node: Interactive Rebinding, Next: Programmatic Rebinding, Up: Rebinding
+
+Changing Key Bindings Interactively
+...................................
+
+`M-x global-set-key <RET> KEY CMD <RET>'
+ Defines KEY globally to run CMD.
+
+`M-x local-set-key <RET> KEYS CMD <RET>'
+ Defines KEY locally (in the major mode now in effect) to run CMD.
+
+`M-x local-unset-key <RET> KEYS <RET>'
+ Removes the local binding of KEY.
+
+ CMD is a symbol naming an interactively-callable function.
+
+ When called interactively, KEY is the next complete key sequence
+that you type. When called as a function, KEY is a string, a vector of
+events, or a vector of key-description lists as described in the
+`define-key' function description. The binding goes in the current
+buffer's local map, which is shared with other buffers in the same
+major mode.
+
+ The following example:
+
+ M-x global-set-key <RET> C-f next-line <RET>
+
+redefines `C-f' to move down a line. The fact that CMD is read second
+makes it serve as a kind of confirmation for KEY.
+
+ These functions offer no way to specify a particular prefix keymap as
+the one to redefine in, but that is not necessary, as you can include
+prefixes in KEY. KEY is read by reading characters one by one until
+they amount to a complete key (that is, not a prefix key). Thus, if
+you type `C-f' for KEY, Emacs enters the minibuffer immediately to read
+CMD. But if you type `C-x', another character is read; if that
+character is `4', another character is read, and so on. For example,
+
+ M-x global-set-key <RET> C-x 4 $ spell-other-window <RET>
+
+redefines `C-x 4 $' to run the (fictitious) command
+`spell-other-window'.
+
+ The most general way to modify a keymap is the function
+`define-key', used in Lisp code (such as your 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.
+
+\1f
+File: xemacs.info, Node: Programmatic Rebinding, Next: Key Bindings Using Strings, Prev: Interactive Rebinding, Up: Rebinding
+
+Changing Key Bindings Programmatically
+......................................
+
+ You can use the functions `global-set-key' and `define-key' to
+rebind keys under program control.
+
+``(global-set-key KEYS CMD)''
+ Defines KEYS globally to run CMD.
+
+``(define-key KEYMAP KEYS DEF)''
+ Defines KEYS to run DEF in the keymap KEYMAP.
+
+ KEYMAP is a keymap object.
+
+ KEYS is the sequence of keystrokes to bind.
+
+ DEF is anything that can be a key's definition:
+
+ * `nil', meaning key is undefined in this keymap
+
+ * A command, that is, a Lisp function suitable for interactive
+ calling
+
+ * A string or key sequence vector, which is treated as a keyboard
+ macro
+
+ * A keymap to define a prefix key
+
+ * A symbol so that when the key is looked up, the symbol stands for
+ its function definition, which should at that time be one of the
+ above, or another symbol whose function definition is used, and so
+ on
+
+ * A cons, `(string . defn)', meaning that DEFN is the definition
+ (DEFN should be a valid definition in its own right)
+
+ * A cons, `(keymap . char)', meaning use the definition of CHAR in
+ map KEYMAP
+
+ For backward compatibility, XEmacs allows you to specify key
+sequences as strings. However, the preferred method is to use the
+representations of key sequences as vectors of keystrokes. *Note
+Keystrokes::, for more information about the rules for constructing key
+sequences.
+
+ Emacs allows you to abbreviate representations for key sequences in
+most places where there is no ambiguity. Here are some rules for
+abbreviation:
+
+ * The keysym by itself is equivalent to a list of just that keysym,
+ i.e., `f1' is equivalent to `(f1)'.
+
+ * A keystroke by itself is equivalent to a vector containing just
+ that keystroke, i.e., `(control a)' is equivalent to `[(control
+ a)]'.
+
+ * You can use ASCII codes for keysyms that have them. i.e., `65' is
+ equivalent to `A'. (This is not so much an abbreviation as an
+ alternate representation.)
+
+ Here are some examples of programmatically binding keys:
+
+
+ ;;; Bind `my-command' to <f1>
+ (global-set-key 'f1 'my-command)
+
+ ;;; Bind `my-command' to Shift-f1
+ (global-set-key '(shift f1) 'my-command)
+
+ ;;; Bind `my-command' to C-c Shift-f1
+ (global-set-key '[(control c) (shift f1)] 'my-command)
+
+ ;;; Bind `my-command' to the middle mouse button.
+ (global-set-key 'button2 'my-command)
+
+ ;;; Bind `my-command' to <META> <CTL> <Right Mouse Button>
+ ;;; in the keymap that is in force when you are running `dired'.
+ (define-key dired-mode-map '(meta control button3) 'my-command)
+
+\1f
+File: xemacs.info, Node: Key Bindings Using Strings, Prev: Programmatic Rebinding, Up: Rebinding
+
+Using Strings for Changing Key Bindings
+.......................................
+
+ For backward compatibility, you can still use strings to represent
+key sequences. Thus you can use commands like the following:
+
+ ;;; Bind `end-of-line' to C-f
+ (global-set-key "\C-f" 'end-of-line)
+
+ Note, however, that in some cases you may be binding more than one
+key sequence by using a single command. This situation can arise
+because in ASCII, `C-i' and <TAB> have the same representation.
+Therefore, when Emacs sees:
+
+ (global-set-key "\C-i" 'end-of-line)
+
+ it is unclear whether the user intended to bind `C-i' or <TAB>. The
+solution XEmacs adopts is to bind both of these key sequences.
+
+ After binding a command to two key sequences with a form like:
+
+ (define-key global-map "\^X\^I" 'command-1)
+
+ it is possible to redefine only one of those sequences like so:
+
+ (define-key global-map [(control x) (control i)] 'command-2)
+ (define-key global-map [(control x) tab] 'command-3)
+
+ This applies only when running under a window system. If you are
+talking to Emacs through an ASCII-only channel, you do not get any of
+these features.
+
+ Here is a table of pairs of key sequences that behave in a similar
+fashion:
+
+ control h backspace
+ control l clear
+ control i tab
+ control m return
+ control j linefeed
+ control [ escape
+ control @ control space
+
+\1f
+File: xemacs.info, Node: Disabling, Prev: Rebinding, Up: Key Bindings
+
+Disabling Commands
+------------------
+
+ Disabling a command marks it as requiring confirmation before it can
+be executed. The purpose of disabling a command is to prevent
+beginning users from executing it by accident and being confused.
+
+ The direct mechanism for disabling a command is to have a non-`nil'
+`disabled' property on the Lisp symbol for the command. These
+properties are normally set by the user's 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.
+
+\1f
+File: xemacs.info, Node: Syntax, Next: Init File, Prev: Key Bindings, Up: Customization
+
+The Syntax Table
+================
+
+ All the Emacs commands which parse words or balance parentheses are
+controlled by the "syntax table". The syntax table specifies which
+characters are opening delimiters, which are parts of words, which are
+string quotes, and so on. Actually, each major mode has its own syntax
+table (though sometimes related major modes use the same one) which it
+installs in each buffer that uses that major mode. The syntax table
+installed in the current buffer is the one that all commands use, so we
+call it "the" syntax table. A syntax table is a Lisp object, a vector
+of length 256 whose elements are numbers.
+
+* Menu:
+
+* Entry: Syntax Entry. What the syntax table records for each character.
+* Change: Syntax Change. How to change the information.
+
+\1f
+File: xemacs.info, Node: Syntax Entry, Next: Syntax Change, Up: Syntax
+
+Information About Each Character
+--------------------------------
+
+ The syntax table entry for a character is a number that encodes six
+pieces of information:
+
+ * The syntactic class of the character, represented as a small
+ integer
+
+ * The matching delimiter, for delimiter characters only (the
+ matching delimiter of `(' is `)', and vice versa)
+
+ * A flag saying whether the character is the first character of a
+ two-character comment starting sequence
+
+ * A flag saying whether the character is the second character of a
+ two-character comment starting sequence
+
+ * A flag saying whether the character is the first character of a
+ two-character comment ending sequence
+
+ * A flag saying whether the character is the second character of a
+ two-character comment ending sequence
+
+ The syntactic classes are stored internally as small integers, but
+are usually described to or by the user with characters. For example,
+`(' is used to specify the syntactic class of opening delimiters. Here
+is a table of syntactic classes, with the characters that specify them.
+
+` '
+ The class of whitespace characters.
+
+`w'
+ The class of word-constituent characters.
+
+`_'
+ The class of characters that are part of symbol names but not
+ words. This class is represented by `_' because the character `_'
+ has this class in both C and Lisp.
+
+`.'
+ The class of punctuation characters that do not fit into any other
+ special class.
+
+`('
+ The class of opening delimiters.
+
+`)'
+ The class of closing delimiters.
+
+`''
+ The class of expression-adhering characters. These characters are
+ part of a symbol if found within or adjacent to one, and are part
+ of a following expression if immediately preceding one, but are
+ like whitespace if surrounded by whitespace.
+
+`"'
+ The class of string-quote characters. They match each other in
+ pairs, and the characters within the pair all lose their syntactic
+ significance except for the `\' and `/' classes of escape
+ characters, which can be used to include a string-quote inside the
+ string.
+
+`$'
+ The class of self-matching delimiters. This is intended for TeX's
+ `$', which is used both to enter and leave math mode. Thus, a
+ pair of matching `$' characters surround each piece of math mode
+ TeX input. A pair of adjacent `$' characters act like a single
+ one for purposes of matching.
+
+`/'
+ The class of escape characters that always just deny the following
+ character its special syntactic significance. The character after
+ one of these escapes is always treated as alphabetic.
+
+`\'
+ The class of C-style escape characters. In practice, these are
+ treated just like `/'-class characters, because the extra
+ possibilities for C escapes (such as being followed by digits)
+ have no effect on where the containing expression ends.
+
+`<'
+ The class of comment-starting characters. Only single-character
+ comment starters (such as `;' in Lisp mode) are represented this
+ way.
+
+`>'
+ The class of comment-ending characters. Newline has this syntax in
+ Lisp mode.
+
+ The characters flagged as part of two-character comment delimiters
+can have other syntactic functions most of the time. For example, `/'
+and `*' in C code, when found separately, have nothing to do with
+comments. The comment-delimiter significance overrides when the pair of
+characters occur together in the proper order. Only the list and sexp
+commands use the syntax table to find comments; the commands
+specifically for comments have other variables that tell them where to
+find comments. Moreover, the list and sexp commands notice comments
+only if `parse-sexp-ignore-comments' is non-`nil'. This variable is set
+to `nil' in modes where comment-terminator sequences are liable to
+appear where there is no comment, for example, in Lisp mode where the
+comment terminator is a newline but not every newline ends a comment.
+
+\1f
+File: xemacs.info, Node: Syntax Change, Prev: Syntax Entry, Up: Syntax
+
+Altering Syntax Information
+---------------------------
+
+ It is possible to alter a character's syntax table entry by storing
+a new number in the appropriate element of the syntax table, but it
+would be hard to determine what number to use. Emacs therefore
+provides a command that allows you to specify the syntactic properties
+of a character in a convenient way.
+
+ `M-x modify-syntax-entry' is the command to change a character's
+syntax. It can be used interactively and is also used by major modes
+to initialize their own syntax tables. Its first argument is the
+character to change. The second argument is a string that specifies the
+new syntax. When called from Lisp code, there is a third, optional
+argument, which specifies the syntax table in which to make the change.
+If not supplied, or if this command is called interactively, the third
+argument defaults to the current buffer's syntax table.
+
+ 1. The first character in the string specifies the syntactic class.
+ It is one of the characters in the previous table (*note Syntax
+ Entry::).
+
+ 2. The second character is the matching delimiter. For a character
+ that is not an opening or closing delimiter, this should be a
+ space, and may be omitted if no following characters are needed.
+
+ 3. The remaining characters are flags. The flag characters allowed
+ are:
+
+ `1'
+ Flag this character as the first of a two-character comment
+ starting sequence.
+
+ `2'
+ Flag this character as the second of a two-character comment
+ starting sequence.
+
+ `3'
+ Flag this character as the first of a two-character comment
+ ending sequence.
+
+ `4'
+ Flag this character as the second of a two-character comment
+ ending sequence.
+
+ Use `C-h s' (`describe-syntax') to display a description of the
+contents of the current syntax table. The description of each
+character includes both the string you have to pass to
+`modify-syntax-entry' to set up that character's current syntax, and
+some English to explain that string if necessary.
+
+\1f
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.
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:
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
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.
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.
\1f
File: xemacs.info, Node: Audible Bell, Next: Faces, Prev: Init File, Up: Customization
`yes-or-no-p'
You type something other than `yes' or `no'
-\1f
-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.
-
-\1f
-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.
-
-\1f
-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.
-
-\1f
-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.
-
-\1f
-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'.
-
-\1f
-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)'.
-
-\1f
-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'.
-
-\1f
-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.
-
-\1f
-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::.
-
-\1f
-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.
-
-\1f
-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::.
-
-\1f
-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.
-
-\1f
-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::.
-
-\1f
-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.
-
-\1f
-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 <RET>.
-
- 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.
-
-\1f
-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 <RET>'.
-
- The doctor will make you feel better. Each time you say something to
-the doctor, you must end it by typing <RET> <RET>. This lets the
-doctor know you are finished.
-