This is ../info/lispref.info, produced by makeinfo version 4.8 from
lispref/lispref.texi.

INFO-DIR-SECTION XEmacs Editor
START-INFO-DIR-ENTRY
* Lispref: (lispref).		XEmacs Lisp Reference Manual.
END-INFO-DIR-ENTRY

   Edition History:

   GNU Emacs Lisp Reference Manual Second Edition (v2.01), May 1993 GNU
Emacs Lisp Reference Manual Further Revised (v2.02), August 1993 Lucid
Emacs Lisp Reference Manual (for 19.10) First Edition, March 1994
XEmacs Lisp Programmer's Manual (for 19.12) Second Edition, April 1995
GNU Emacs Lisp Reference Manual v2.4, June 1995 XEmacs Lisp
Programmer's Manual (for 19.13) Third Edition, July 1995 XEmacs Lisp
Reference Manual (for 19.14 and 20.0) v3.1, March 1996 XEmacs Lisp
Reference Manual (for 19.15 and 20.1, 20.2, 20.3) v3.2, April, May,
November 1997 XEmacs Lisp Reference Manual (for 21.0) v3.3, April 1998

   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995 Free Software
Foundation, Inc.  Copyright (C) 1994, 1995 Sun Microsystems, Inc.
Copyright (C) 1995, 1996 Ben Wing.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Foundation.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the section entitled "GNU General Public License" is included
exactly as in the original, and provided that the entire resulting
derived work is distributed under the terms of a permission notice
identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the section entitled "GNU General Public License"
may be included in a translation approved by the Free Software
Foundation instead of in the original English.


File: lispref.info,  Node: Characters to be preserved,  Next: The program to decode to internal format,  Prev: Numeric to ASCII-hexadecimal conversion,  Up: CCL Example

63.7.5.4 Characters to be preserved
...................................

And finally, the last of these tables.  URL encoding says that
alphanumeric characters, the underscore, hyphen and the full stop (1)
retain their ASCII encoding, and don't undergo transformation.
`url-coding-should-preserve-table' is an array in which the entries are
one if the corresponding ASCII character should be left as-is, and zero
if they should be transformed.  So the entries for all the control and
most of the punctuation charcters are zero.  Lisp programmers will
observe that this initialization is particularly inefficient, but
they'll also be aware that this is a long way from an inner loop where
every nanosecond counts.

     (defvar url-coding-should-preserve-table
       (let ((preserve
     	 (list ?- ?_ ?. ?a ?b ?c ?d ?e ?f ?g ?h ?i ?j ?k ?l ?m ?n ?o
     	       ?p ?q ?r ?s ?t ?u ?v ?w ?x ?y ?z ?A ?B ?C ?D ?E ?F ?G
     	       ?H ?I ?J ?K ?L ?M ?N ?O ?P ?Q ?R ?S ?T ?U ?V ?W ?X ?Y
     	       ?Z ?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))
     	(i 0)
     	(res (make-vector 256 0)))
         (while (< i 256)
           (when (member (int-char i) preserve)
     	(aset res i 1))
           (setq i (1+ i)))
         res)
       "A 256-entry array of flags, indicating whether or not to preserve an
     octet as its ASCII encoding.")

   ---------- Footnotes ----------

   (1) That's what the standards call it, though my North American
readers will be more familiar with it as the period character.


File: lispref.info,  Node: The program to decode to internal format,  Next: The program to encode from internal format,  Prev: Characters to be preserved,  Up: CCL Example

63.7.5.5 The program to decode to internal format
.................................................

After the almost interminable tables, we get to the CCL.  The first CCL
program, `ccl-decode-urlcoding' decodes from the URL coding to our
internal format; since this version of CCL doesn't have support for
error checking on the input, we don't do any verification on it.

   The buffer magnification-approximate ratio of the size of the output
buffer to the size of the input buffer-is declared as one, because
fractional values aren't allowed. (Since all those %20's will map to `
', the length of the output text will be less than that of the input
text.)

   So, first we read an octet from the input buffer into register `r0',
to set up the loop.  Next, we start the loop, with a `(loop ...)'
statement, and we check if the value in `r0' is a percentage sign.
(Note the comma before `url-coding-escape-character-code'; since CCL is
a Lisp macro language, we can break out of the macro evaluation with a
comman, and as such, "`,url-coding-escape-character-code'" will be
evaluated as a literal `37.')

   If it is a percentage sign, we read the next two octets into `r2'
and `r3', and convert them into their hexadecimal numeric values, using
the `url-coding-latin-1-as-hex-table' array declared above.  (But
again, it'll be interpreted as a literal array.)  We then left shift
the first by four bits, mask the two together, and write the result to
the output buffer.

   If it isn't a percentage sign, and it is a `+' sign, we write a
space-hexadecimal 20-to the output buffer.

   If none of those things are true, we pass the octet to the output
buffer untransformed.  (This could be a place to put error checking, in
a more expressive language.)  We then read one more octet from the input
buffer, and move to the next iteration of the loop.

     (define-ccl-program ccl-decode-urlcoding
       `(1
         ((read r0)
          (loop
            (if (r0 == ,url-coding-escape-character-code)
     	   ((read r2 r3)
     	    ;; Assign the value at offset r2 in the url-coding-hex-digit-table
     	    ;; to r3.
     	    (r2 = r2 ,url-coding-latin-1-as-hex-table)
     	    (r3 = r3 ,url-coding-latin-1-as-hex-table)
     	    (r2 <<= 4)
     	    (r3 |= r2)
     	    (write r3))
     	 (if (r0 == ,url-coding-escaped-space-code)
     	     (write #x20)
     	   (write r0)))
            (read r0)
            (repeat))))
       "CCL program to take URI-encoded ASCII text and transform it to our
     internal encoding. ")


File: lispref.info,  Node: The program to encode from internal format,  Next: The actual coding system,  Prev: The program to decode to internal format,  Up: CCL Example

63.7.5.6 The program to encode from internal format
...................................................

Next, we see the CCL program to encode ASCII text as URL coded text.
Here, the buffer magnification is specified as three, to account for ` '
mapping to %20, etc.  As before, we read an octet from the input into
`r0', and move into the body of the loop.  Next, we check if we should
preserve the value of this octet, by reading from offset `r0' in the
`url-coding-should-preserve-table' into `r1'.  Then we have an `if'
statement predicated on the value in `r1'; for the true branch, we
write the input octet directly.  For the false branch, we write a
percentage sign, the ASCII encoding of the high four bits in hex, and
then the ASCII encoding of the low four bits in hex.

   We then read an octet from the input into `r0', and repeat the loop.

     (define-ccl-program ccl-encode-urlcoding
       `(3
         ((read r0)
          (loop
            (r1 = r0 ,url-coding-should-preserve-table)
            ;; If we should preserve the value, just write the octet directly.
            (if r1
     	   (write r0)
     	 ;; else, write a percentage sign, and the hex value of the octet, in
     	 ;; an ASCII-friendly format.
     	 ((write ,url-coding-escape-character-code)
     	  (write r0 ,url-coding-high-order-nybble-as-ascii)
     	  (write r0 ,url-coding-low-order-nybble-as-ascii)))
            (read r0)
            (repeat))))
       "CCL program to encode octets (almost) according to RFC 1738")


File: lispref.info,  Node: The actual coding system,  Prev: The program to encode from internal format,  Up: CCL Example

63.7.5.7 The actual coding system
.................................

To actually create the coding system, we call `make-coding-system'.
The first argument is the symbol that is to be the name of the coding
system, in our case `url-coding'. The second specifies that the coding
system is to be of type `ccl'--there are several other coding system
types available, including, see the documentation for
`make-coding-system' for the full list. Then there's a documentation
string describing the wherefore and caveats of the coding system, and
the final argument is a property list giving information about the CCL
programs and the coding system's mnemonic.

     (make-coding-system
      'url-coding 'ccl
      "The coding used by application/x-www-form-urlencoded HTTP applications.
     This coding form doesn't specify anything about non-ASCII characters, so
     make sure you've transformed to a seven-bit coding system first."
      '(decode ccl-decode-urlcoding
        encode ccl-encode-urlcoding
        mnemonic "URLenc"))

   If you're lucky, the `url-coding' coding system describe here should
be available in the XEmacs package system. Otherwise, downloading it
from `http://www.parhasard.net/url-coding.el' should work for the
foreseeable future.


File: lispref.info,  Node: Category Tables,  Next: Unicode Support,  Prev: CCL,  Up: MULE

63.8 Category Tables
====================

A category table is a type of char table used for keeping track of
categories.  Categories are used for classifying characters for use in
regexps--you can refer to a category rather than having to use a
complicated [] expression (and category lookups are significantly
faster).

   There are 95 different categories available, one for each printable
character (including space) in the ASCII charset.  Each category is
designated by one such character, called a "category designator".  They
are specified in a regexp using the syntax `\cX', where X is a category
designator. (This is not yet implemented.)

   A category table specifies, for each character, the categories that
the character is in.  Note that a character can be in more than one
category.  More specifically, a category table maps from a character to
either the value `nil' (meaning the character is in no categories) or a
95-element bit vector, specifying for each of the 95 categories whether
the character is in that category.

   Special Lisp functions are provided that abstract this, so you do not
have to directly manipulate bit vectors.

 -- Function: category-table-p object
     This function returns `t' if OBJECT is a category table.

 -- Function: category-table &optional buffer
     This function returns the current category table.  This is the one
     specified by the current buffer, or by BUFFER if it is non-`nil'.

 -- Function: standard-category-table
     This function returns the standard category table.  This is the
     one used for new buffers.

 -- Function: copy-category-table &optional category-table
     This function returns a new category table which is a copy of
     CATEGORY-TABLE, which defaults to the standard category table.

 -- Function: set-category-table category-table &optional buffer
     This function selects CATEGORY-TABLE as the new category table for
     BUFFER.  BUFFER defaults to the current buffer if omitted.

 -- Function: category-designator-p object
     This function returns `t' if OBJECT is a category designator (a
     char in the range `' '' to `'~'').

 -- Function: category-table-value-p object
     This function returns `t' if OBJECT is a category table value.
     Valid values are `nil' or a bit vector of size 95.


File: lispref.info,  Node: Unicode Support,  Next: Charset Unification,  Prev: Category Tables,  Up: MULE

63.9 Unicode Support
====================

Unicode support was added by Ben Wing to XEmacs 21.5.6.

 -- Function: set-language-unicode-precedence-list list
     Set the language-specific precedence list used for Unicode
     decoding.  This is a list of charsets, which are consulted in
     order for a translation matching a given Unicode character.  If no
     matches are found, the charsets in the default precedence list (see
     `set-default-unicode-precedence-list') are consulted, and then all
     remaining charsets, in some arbitrary order.

     The language-specific precedence list is meant to be set as part
     of the language environment initialization; the default precedence
     list is meant to be set by the user.

 -- Function: language-unicode-precedence-list
     Return the language-specific precedence list used for Unicode
     decoding.  See `set-language-unicode-precedence-list' for more
     information.

 -- Function: set-default-unicode-precedence-list list
     Set the default precedence list used for Unicode decoding.  This
     is meant to be set by the user.  See
     `set-language-unicode-precedence-list' for more information.

 -- Function: default-unicode-precedence-list
     Return the default precedence list used for Unicode decoding.  See
     `set-language-unicode-precedence-list' for more information.

 -- Function: set-unicode-conversion character code
     Add conversion information between Unicode codepoints and
     characters.  CHARACTER is one of the following:

     - A character (in which case CODE must be a non-negative integer)
     - A vector of characters (in which case CODE must be a vector of
     non-negative integers of the same length)

     Values of CODE above 2^20 - 1 are allowed for the purpose of
     specifying private characters, but will cause errors when
     converted to UTF-16 or UTF-32.  UCS-4 and UTF-8 can handle values
     to 2^31 - 1, but XEmacs Lisp integers top out at 2^30 - 1.

 -- Function: character-to-unicode character
     Convert CHARACTER to Unicode codepoint.  When there is no
     international support (i.e. MULE is not defined), this function
     simply does `char-to-int'.

 -- Function: unicode-to-character code [charsets]
     Convert Unicode codepoint CODE to character.  CODE should be a
     non-negative integer.  If CHARSETS is given, it should be a list
     of charsets, and only those charsets will be consulted, in the
     given order, for a translation.  Otherwise, the default ordering
     of all charsets will be given (see
     `set-unicode-charset-precedence').

     When there is no international support (i.e. MULE is not defined),
     this function simply does `int-to-char' and ignores the CHARSETS
     argument.

 -- Function: parse-unicode-translation-table filename charset start
          end offset flags
     Parse Unicode translation data in FILENAME for MULE CHARSET.  Data
     is text, in the form of one translation per line - charset
     codepoint followed by Unicode codepoint.  Numbers are decimal or
     hex \(preceded by 0x).  Comments are marked with a #.  Charset
     codepoints for two-dimensional charsets should have the first
     octet stored in the high 8 bits of the hex number and the second
     in the low 8 bits.

     If START and END are given, only charset codepoints within the
     given range will be processed.  If OFFSET is given, that value
     will be added to all charset codepoints in the file to obtain the
     internal charset codepoint.  START and END apply to the codepoints
     in the file, before OFFSET is applied.

     (Note that, as usual, we assume that octets are in the range 32 to
     127 or 33 to 126.  If you have a table in kuten form, with octets
     in the range 1 to 94, you will have to use an offset of 5140, i.e.
     0x2020.)

     FLAGS, if specified, control further how the tables are interpreted
     and are used to special-case certain known table weirdnesses in the
     Unicode tables:

    `ignore-first-column''
          Exactly as it sounds.  The JIS X 0208 tables have 3 columns
          of data instead of 2; the first is the Shift-JIS codepoint.

    `big5'
          The charset codepoint is a Big Five codepoint; convert it to
          the proper hacked-up codepoint in `chinese-big5-1' or
          `chinese-big5-2'.


File: lispref.info,  Node: Charset Unification,  Next: Charsets and Coding Systems,  Prev: Unicode Support,  Up: MULE

63.10 Character Set Unification
===============================

Mule suffers from a design defect that causes it to consider the ISO
Latin character sets to be disjoint.  This results in oddities such as
files containing both ISO 8859/1 and ISO 8859/15 codes, and using ISO
2022 control sequences to switch between them, as well as more plausible
but often unnecessary combinations like ISO 8859/1 with ISO 8859/2.
This can be very annoying when sending messages or even in simple
editing on a single host.  Unification works around the problem by
converting as many characters as possible to use a single Latin coded
character set before saving the buffer.

   This node and its children were ripp'd untimely from
`latin-unity.texi', and have been quickly converted for use here.
However as APIs are likely to diverge, beware of inaccuracies.  Please
report any you discover with `M-x report-xemacs-bug RET', as well as
any ambiguities or downright unintelligible passages.

   A lot of the stuff here doesn't belong here; it belongs in the *Note
Top: (xemacs)Top.  Report those as bugs, too, preferably with patches.

* Menu:

* Overview::                    Unification history and general information.
* Usage::                       An overview of the operation of Unification.
* Configuration::               Configuring Unification for use.
* Theory of Operation::         How Unification works.
* What Unification Cannot Do for You::  Inherent problems of 8-bit charsets.
* Charsets and Coding Systems:: Reference lists with annotations.
* Unification Internals::       Utilities and implementation details.


File: lispref.info,  Node: Overview,  Next: Usage,  Prev: Charset Unification,  Up: Charset Unification

63.10.1 An Overview of Unification
----------------------------------

Mule suffers from a design defect that causes it to consider the ISO
Latin character sets to be disjoint.  This manifests itself when a user
enters characters using input methods associated with different coded
character sets into a single buffer.

   A very important example involves email.  Many sites, especially in
the U.S., default to use of the ISO 8859/1 coded character set (also
called "Latin 1," though these are somewhat different concepts).
However, ISO 8859/1 provides a generic CURRENCY SIGN character.  Now
that the Euro has become the official currency of most countries in
Europe, this is unsatisfactory (and in practice, useless).  So
Europeans generally use ISO 8859/15, which is nearly identical to ISO
8859/1 for most languages, except that it substitutes EURO SIGN for
CURRENCY SIGN.

   Suppose a European user yanks text from a post encoded in ISO 8859/1
into a message composition buffer, and enters some text including the
Euro sign.  Then Mule will consider the buffer to contain both ISO
8859/1 and ISO 8859/15 text, and MUAs such as Gnus will (if naively
programmed) send the message as a multipart mixed MIME body!

   This is clearly stupid.  What is not as obvious is that, just as any
European can include American English in their text because ASCII is a
subset of ISO 8859/15, most European languages which use Latin
characters (eg, German and Polish) can typically be mixed while using
only one Latin coded character set (in this case, ISO 8859/2).  However,
this often depends on exactly what text is to be encoded.

   Unification works around the problem by converting as many
characters as possible to use a single Latin coded character set before
saving the buffer.


File: lispref.info,  Node: Usage,  Next: Configuration,  Prev: Overview,  Up: Charset Unification

63.10.2 Operation of Unification
--------------------------------

Normally, Unification works in the background by installing
`unity-sanity-check' on `write-region-pre-hook'.  This is done by
default for the ISO 8859 Latin family of character sets.  The user
activates this functionality for other character set families by
invoking `enable-unification', either interactively or in her init
file.  *Note Init File: (xemacs)Init File.  Unification can be
deactivated by invoking `disable-unification'.

   Unification also provides a few functions for remapping or recoding
the buffer by hand.  To "remap" a character means to change the buffer
representation of the character by using another coded character set.
Remapping never changes the identity of the character, but may involve
altering the code point of the character.  To "recode" a character
means to simply change the coded character set.  Recoding never alters
the code point of the character, but may change the identity of the
character.  *Note Theory of Operation::.

   There are a few variables which determine which coding systems are
always acceptable to Unification:  `unity-ucs-list',
`unity-preferred-coding-system-list', and
`unity-preapproved-coding-system-list'.  The latter two default to
`()', and should probably be avoided because they short-circuit the
sanity check.  If you find you need to use them, consider reporting it
as a bug or request for enhancement.  Because they seem unsafe, the
recommended interface is likely to change.

* Menu:

* Basic Functionality::            User interface and customization.
* Interactive Usage::              Treating text by hand.
                                   Also documents the hook function(s).


File: lispref.info,  Node: Basic Functionality,  Next: Interactive Usage,  Up: Usage

63.11 Basic Functionality
=========================

These functions and user options initialize and configure Unification.
In normal use, none of these should be needed.

   *These APIs are certain to change.*

 -- Function: enable-unification
     Set up hooks and initialize variables for latin-unity.

     There are no arguments.

     This function is idempotent.  It will reinitialize any hooks or
     variables that are not in initial state.

 -- Function: disable-unification
     There are no arguments.

     Clean up hooks and void variables used by latin-unity.

 -- User Option: unity-ucs-list
     List of coding systems considered to be universal.

     The default value is `'(utf-8 iso-2022-7 ctext escape-quoted)'.

     Order matters; coding systems earlier in the list will be
     preferred when recommending a coding system.  These coding systems
     will not be used without querying the user (unless they are also
     present in `unity-preapproved-coding-system-list'), and follow the
     `unity-preferred-coding-system-list' in the list of suggested
     coding systems.

     If none of the preferred coding systems are feasible, the first in
     this list will be the default.

     Notes on certain coding systems:  `escape-quoted' is a special
     coding system used for autosaves and compiled Lisp in Mule.  You
     should never delete this, although it is rare that a user would
     want to use it directly.  Unification does not try to be \"smart\"
     about other general ISO 2022 coding systems, such as ISO-2022-JP.
     (They are not recognized as equivalent to `iso-2022-7'.)  If your
     preferred coding system is one of these, you may consider adding
     it to `unity-ucs-list'.  However, this will typically have the
     side effect that (eg) ISO 8859/1 files will be saved in 7-bit form
     with ISO 2022 escape sequences.

   Coding systems which are not Latin and not in `unity-ucs-list' are
handled by short circuiting checks of coding system against the next
two variables.

 -- User Option: unity-preapproved-coding-system-list
     List of coding systems used without querying the user if feasible.

     The default value is `(buffer-default preferred)'.

     The first feasible coding system in this list is used.  The
     special values `preferred' and `buffer-default' may be present:

    `buffer-default'
          Use the coding system used by `write-region', if feasible.

    `preferred'
          Use the coding system specified by `prefer-coding-system' if
          feasible.

     "Feasible" means that all characters in the buffer can be
     represented by the coding system.  Coding systems in
     `unity-ucs-list' are always considered feasible.  Other feasible
     coding systems are computed by
     `unity-representations-feasible-region'.

     Note that the first universal coding system in this list shadows
     all other coding systems.  In particular, if your preferred coding
     system is a universal coding system, and `preferred' is a member
     of this list, unification will blithely convert all your files to
     that coding system.  This is considered a feature, but it may
     surprise most users.  Users who don't like this behavior should
     put `preferred' in `unity-preferred-coding-system-list'.

 -- User Option: unity-preferred-coding-system-list
     List of coding systems suggested to the user if feasible.

     The default value is `(iso-8859-1 iso-8859-15 iso-8859-2 iso-8859-3
     iso-8859-4 iso-8859-9)'.

     If none of the coding systems in
     `unity-preapproved-coding-system-list' are feasible, this list
     will be recommended to the user, followed by the `unity-ucs-list'.
     The first coding system in this list is default.  The special
     values `preferred' and `buffer-default' may be present:

    `buffer-default'
          Use the coding system used by `write-region', if feasible.

    `preferred'
          Use the coding system specified by `prefer-coding-system' if
          feasible.

     "Feasible" means that all characters in the buffer can be
     represented by the coding system.  Coding systems in
     `unity-ucs-list' are always considered feasible.  Other feasible
     coding systems are computed by
     `unity-representations-feasible-region'.

 -- Variable: unity-iso-8859-1-aliases
     List of coding systems to be treated as aliases of ISO 8859/1.

     The default value is '(iso-8859-1).

     This is not a user variable; to customize input of coding systems
     or charsets, `unity-coding-system-alias-alist' or
     `unity-charset-alias-alist'.


File: lispref.info,  Node: Interactive Usage,  Prev: Basic Functionality,  Up: Usage

63.12 Interactive Usage
=======================

First, the hook function `unity-sanity-check' is documented.  (It is
placed here because it is not an interactive function, and there is not
yet a programmer's section of the manual.)

   These functions provide access to internal functionality (such as the
remapping function) and to extra functionality (the recoding functions
and the test function).

 -- Function: unity-sanity-check begin end filename append visit
          lockname &optional coding-system
     Check if CODING-SYSTEM can represent all characters between BEGIN
     and END.

     For compatibility with old broken versions of `write-region',
     CODING-SYSTEM defaults to `buffer-file-coding-system'.  FILENAME,
     APPEND, VISIT, and LOCKNAME are ignored.

     Return nil if buffer-file-coding-system is not
     (ISO-2022-compatible) Latin.  If `buffer-file-coding-system' is
     safe for the charsets actually present in the buffer, return it.
     Otherwise, ask the user to choose a coding system, and return that.

     This function does _not_ do the safe thing when
     `buffer-file-coding-system' is nil (aka no-conversion).  It
     considers that "non-Latin," and passes it on to the Mule detection
     mechanism.

     This function is intended for use as a `write-region-pre-hook'.  It
     does nothing except return CODING-SYSTEM if `write-region'
     handlers are inhibited.

 -- Function: unity-buffer-representations-feasible
     There are no arguments.

     Apply unity-region-representations-feasible to the current buffer.

 -- Function: unity-region-representations-feasible begin end &optional
          buf
     Return character sets that can represent the text from BEGIN to
     END in BUF.

     BUF defaults to the current buffer.  Called interactively, will be
     applied to the region.  Function assumes BEGIN <= END.

     The return value is a cons.  The car is the list of character sets
     that can individually represent all of the non-ASCII portion of the
     buffer, and the cdr is the list of character sets that can
     individually represent all of the ASCII portion.

     The following is taken from a comment in the source.  Please refer
     to the source to be sure of an accurate description.

     The basic algorithm is to map over the region, compute the set of
     charsets that can represent each character (the "feasible
     charset"), and take the intersection of those sets.

     The current implementation takes advantage of the fact that ASCII
     characters are common and cannot change asciisets.  Then using
     skip-chars-forward makes motion over ASCII subregions very fast.

     This same strategy could be applied generally by precomputing
     classes of characters equivalent according to their effect on
     latinsets, and adding a whole class to the skip-chars-forward
     string once a member is found.

     Probably efficiency is a function of the number of characters
     matched, or maybe the length of the match string?  With
     `skip-category-forward' over a precomputed category table it
     should be really fast.  In practice for Latin character sets there
     are only 29 classes.

 -- Function: unity-remap-region begin end character-set &optional
          coding-system
     Remap characters between BEGIN and END to equivalents in
     CHARACTER-SET.  Optional argument CODING-SYSTEM may be a coding
     system name (a symbol) or nil.  Characters with no equivalent are
     left as-is.

     When called interactively, BEGIN and END are set to the beginning
     and end, respectively, of the active region, and the function
     prompts for CHARACTER-SET.  The function does completion, knows
     how to guess a character set name from a coding system name, and
     also provides some common aliases.  See `unity-guess-charset'.
     There is no way to specify CODING-SYSTEM, as it has no useful
     function interactively.

     Return CODING-SYSTEM if CODING-SYSTEM can encode all characters in
     the region, t if CODING-SYSTEM is nil and the coding system with
     G0 = 'ascii and G1 = CHARACTER-SET can encode all characters, and
     otherwise nil.  Note that a non-null return does _not_ mean it is
     safe to write the file, only the specified region.  (This behavior
     is useful for multipart MIME encoding and the like.)

     Note:  by default this function is quite fascist about universal
     coding systems.  It only admits `utf-8', `iso-2022-7', and
     `ctext'.  Customize `unity-approved-ucs-list' to change this.

     This function remaps characters that are artificially
     distinguished by Mule internal code.  It may change the code point
     as well as the character set.  To recode characters that were
     decoded in the wrong coding system, use `unity-recode-region'.

 -- Function: unity-recode-region begin end wrong-cs right-cs
     Recode characters between BEGIN and END from WRONG-CS to RIGHT-CS.

     WRONG-CS and RIGHT-CS are character sets.  Characters retain the
     same code point but the character set is changed.  Only characters
     from WRONG-CS are changed to RIGHT-CS.  The identity of the
     character may change.  Note that this could be dangerous, if
     characters whose identities you do not want changed are included
     in the region.  This function cannot guess which characters you
     want changed, and which should be left alone.

     When called interactively, BEGIN and END are set to the beginning
     and end, respectively, of the active region, and the function
     prompts for WRONG-CS and RIGHT-CS.  The function does completion,
     knows how to guess a character set name from a coding system name,
     and also provides some common aliases.  See `unity-guess-charset'.

     Another way to accomplish this, but using coding systems rather
     than character sets to specify the desired recoding, is
     `unity-recode-coding-region'.  That function may be faster but is
     somewhat more dangerous, because it may recode more than one
     character set.

     To change from one Mule representation to another without changing
     identity of any characters, use `unity-remap-region'.

 -- Function: unity-recode-coding-region begin end wrong-cs right-cs
     Recode text between BEGIN and END from WRONG-CS to RIGHT-CS.

     WRONG-CS and RIGHT-CS are coding systems.  Characters retain the
     same code point but the character set is changed.  The identity of
     characters may change.  This is an inherently dangerous function;
     multilingual text may be recoded in unexpected ways.  #### It's
     also dangerous because the coding systems are not sanity-checked
     in the current implementation.

     When called interactively, BEGIN and END are set to the beginning
     and end, respectively, of the active region, and the function
     prompts for WRONG-CS and RIGHT-CS.  The function does completion,
     knows how to guess a coding system name from a character set name,
     and also provides some common aliases.  See
     `unity-guess-coding-system'.

     Another, safer, way to accomplish this, using character sets rather
     than coding systems to specify the desired recoding, is to use
     `unity-recode-region'.

     To change from one Mule representation to another without changing
     identity of any characters, use `unity-remap-region'.

   Helper functions for input of coding system and character set names.

 -- Function: unity-guess-charset candidate
     Guess a charset based on the symbol CANDIDATE.

     CANDIDATE itself is not tried as the value.

     Uses the natural mapping in `unity-cset-codesys-alist', and the
     values in `unity-charset-alias-alist'."

 -- Function: unity-guess-coding-system candidate
     Guess a coding system based on the symbol CANDIDATE.

     CANDIDATE itself is not tried as the value.

     Uses the natural mapping in `unity-cset-codesys-alist', and the
     values in `unity-coding-system-alias-alist'."

 -- Function: unity-example
     A cheesy example for Unification.

     At present it just makes a multilingual buffer.  To test, setq
     buffer-file-coding-system to some value, make the buffer dirty (eg
     with RET BackSpace), and save.


File: lispref.info,  Node: Configuration,  Next: Theory of Operation,  Prev: Usage,  Up: Charset Unification

63.12.1 Configuring Unification for Use
---------------------------------------

If you want Unification to be automatically initialized, invoke
`enable-unification' with no arguments in your init file.  *Note Init
File: (xemacs)Init File.  If you are using GNU Emacs or an XEmacs
earlier than 21.1, you should also load `auto-autoloads' using the full
path (_never_ `require' `auto-autoloads' libraries).

   You may wish to define aliases for commonly used character sets and
coding systems for convenience in input.

 -- User Option: unity-charset-alias-alist
     Alist mapping aliases to Mule charset names (symbols)."

     The default value is
             ((latin-1 . latin-iso8859-1)
              (latin-2 . latin-iso8859-2)
              (latin-3 . latin-iso8859-3)
              (latin-4 . latin-iso8859-4)
              (latin-5 . latin-iso8859-9)
              (latin-9 . latin-iso8859-15)
              (latin-10 . latin-iso8859-16))

     If a charset does not exist on your system, it will not complete
     and you will not be able to enter it in response to prompts.  A
     real charset with the same name as an alias in this list will
     shadow the alias.

 -- User Option: unity-coding-system-alias-alist nil
     Alist mapping aliases to Mule coding system names (symbols).

     The default value is `nil'.


File: lispref.info,  Node: Theory of Operation,  Next: What Unification Cannot Do for You,  Prev: Configuration,  Up: Charset Unification

63.12.2 Theory of Operation
---------------------------

Standard encodings suffer from the design defect that they do not
provide a reliable way to recognize which coded character sets in use.
*Note What Unification Cannot Do for You::.  There are scores of
character sets which can be represented by a single octet (8-bit byte),
whose union contains many hundreds of characters.  Obviously this
results in great confusion, since you can't tell the players without a
scorecard, and there is no scorecard.

   There are two ways to solve this problem.  The first is to create a
universal coded character set.  This is the concept behind Unicode.
However, there have been satisfactory (nearly) universal character sets
for several decades, but even today many Westerners resist using Unicode
because they consider its space requirements excessive.  On the other
hand, Asians dislike Unicode because they consider it to be incomplete.
(This is partly, but not entirely, political.)

   In any case, Unicode only solves the internal representation problem.
Many data sets will contain files in "legacy" encodings, and Unicode
does not help distinguish among them.

   The second approach is to embed information about the encodings used
in a document in its text.  This approach is taken by the ISO 2022
standard.  This would solve the problem completely from the users' of
view, except that ISO 2022 is basically not implemented at all, in the
sense that few applications or systems implement more than a small
subset of ISO 2022 functionality.  This is due to the fact that
mono-literate users object to the presence of escape sequences in their
texts (which they, with some justification, consider data corruption).
Programmers are more than willing to cater to these users, since
implementing ISO 2022 is a painstaking task.

   In fact, Emacs/Mule adopts both of these approaches.  Internally it
uses a universal character set, "Mule code".  Externally it uses ISO
2022 techniques both to save files in forms robust to encoding issues,
and as hints when attempting to "guess" an unknown encoding.  However,
Mule suffers from a design defect, namely it embeds the character set
information that ISO 2022 attaches to runs of characters by introducing
them with a control sequence in each character.  That causes Mule to
consider the ISO Latin character sets to be disjoint.  This manifests
itself when a user enters characters using input methods associated with
different coded character sets into a single buffer.

   There are two problems stemming from this design.  First, Mule
represents the same character in different ways.  Abstractly, 'ó'
(LATIN SMALL LETTER O WITH ACUTE) can get represented as
[latin-iso8859-1 #x73] or as [latin-iso8859-2 #x73].  So what looks like
'óó' in the display might actually be represented [latin-iso8859-1
#x73][latin-iso8859-2 #x73] in the buffer, and saved as [#xF3 ESC - B
#xF3 ESC - A] in the file.  In some cases this treatment would be
appropriate (consider HYPHEN, MINUS SIGN, EN DASH, EM DASH, and U+4E00
(the CJK ideographic character meaning "one")), and although arguably
incorrect it is convenient when mixing the CJK scripts.  But in the case
of the Latin scripts this is wrong.

   Worse yet, it is very likely to occur when mixing "different"
encodings (such as ISO 8859/1 and ISO 8859/15) that differ only in a
few code points that are almost never used.  A very important example
involves email.  Many sites, especially in the U.S., default to use of
the ISO 8859/1 coded character set (also called "Latin 1," though these
are somewhat different concepts).  However, ISO 8859/1 provides a
generic CURRENCY SIGN character.  Now that the Euro has become the
official currency of most countries in Europe, this is unsatisfactory
(and in practice, useless).  So Europeans generally use ISO 8859/15,
which is nearly identical to ISO 8859/1 for most languages, except that
it substitutes EURO SIGN for CURRENCY SIGN.

   Suppose a European user yanks text from a post encoded in ISO 8859/1
into a message composition buffer, and enters some text including the
Euro sign.  Then Mule will consider the buffer to contain both ISO
8859/1 and ISO 8859/15 text, and MUAs such as Gnus will (if naively
programmed) send the message as a multipart mixed MIME body!

   This is clearly stupid.  What is not as obvious is that, just as any
European can include American English in their text because ASCII is a
subset of ISO 8859/15, most European languages which use Latin
characters (eg, German and Polish) can typically be mixed while using
only one Latin coded character set (in the case of German and Polish,
ISO 8859/2).  However, this often depends on exactly what text is to be
encoded (even for the same pair of languages).

   Unification works around the problem by converting as many
characters as possible to use a single Latin coded character set before
saving the buffer.

   Because the problem is rarely noticeable in editing a buffer, but
tends to manifest when that buffer is exported to a file or process, the
Unification package uses the strategy of examining the buffer prior to
export.  If use of multiple Latin coded character sets is detected,
Unification attempts to unify them by finding a single coded character
set which contains all of the Latin characters in the buffer.

   The primary purpose of Unification is to fix the problem by giving
the user the choice to change the representation of all characters to
one character set and give sensible recommendations based on context.
In the 'ó' example, either ISO 8859/1 or ISO 8859/2 is satisfactory,
and both will be suggested.  In the EURO SIGN example, only ISO 8859/15
makes sense, and that is what will be recommended.  In both cases, the
user will be reminded that there are universal encodings available.

   I call this "remapping" (from the universal character set to a
particular ISO 8859 coded character set).  It is mere accident that this
letter has the same code point in both character sets.  (Not entirely,
but there are many examples of Latin characters that have different code
points in different Latin-X sets.)

   Note that, in the 'ó' example, that treating the buffer in this way
will result in a representation such as [latin-iso8859-2
#x73][latin-iso8859-2 #x73], and the file will be saved as [#xF3 #xF3].
This is guaranteed to occasionally result in the second problem you
observed, to which we now turn.

   This problem is that, although the file is intended to be an
ISO-8859/2-encoded file, in an ISO 8859/1 locale Mule (and every POSIX
compliant program--this is required by the standard, obvious if you
think a bit, *note What Unification Cannot Do for You::) will read that
file as [latin-iso8859-1 #x73] [latin-iso8859-1 #x73].  Of course this
is no problem if all of the characters in the file are contained in ISO
8859/1, but suppose there are some which are not, but are contained in
the (intended) ISO 8859/2.

   You now want to fix this, but not by finding the same character in
another set.  Instead, you want to simply change the character set that
Mule associates with that buffer position without changing the code.
(This is conceptually somewhat distinct from the first problem, and
logically ought to be handled in the code that defines coding systems.
However, unification is not an unreasonable place for it.)  Unification
provides two functions (one fast and dangerous, the other slow and
careful) to handle this.  I call this "recoding", because the
transformation actually involves _encoding_ the buffer to file
representation, then _decoding_ it to buffer representation (in a
different character set).  This cannot be done automatically because
Mule can have no idea what the correct encoding is--after all, it
already gave you its best guess.  *Note What Unification Cannot Do for
You::.  So these functions must be invoked by the user.  *Note
Interactive Usage::.


File: lispref.info,  Node: What Unification Cannot Do for You,  Next: Unification Internals,  Prev: Theory of Operation,  Up: Charset Unification

63.12.3 What Unification Cannot Do for You
------------------------------------------

Unification *cannot* save you if you insist on exporting data in 8-bit
encodings in a multilingual environment.  _You will eventually corrupt
data if you do this._  It is not Mule's, or any application's, fault.
You will have only yourself to blame; consider yourself warned.  (It is
true that Mule has bugs, which make Mule somewhat more dangerous and
inconvenient than some naive applications.  We're working to address
those, but no application can remedy the inherent defect of 8-bit
encodings.)

   Use standard universal encodings, preferably Unicode (UTF-8) unless
applicable standards indicate otherwise.  The most important such case
is Internet messages, where MIME should be used, whether or not the
subordinate encoding is a universal encoding.  (Note that since one of
the important provisions of MIME is the `Content-Type' header, which
has the charset parameter, MIME is to be considered a universal
encoding for the purposes of this manual.  Of course, technically
speaking it's neither a coded character set nor a coding extension
technique compliant with ISO 2022.)

   As mentioned earlier, the problem is that standard encodings suffer
from the design defect that they do not provide a reliable way to
recognize which coded character sets are in use.  There are scores of
character sets which can be represented by a single octet (8-bit byte),
whose union contains many hundreds of characters.  Thus any 8-bit coded
character set must contain characters that share code points used for
different characters in other coded character sets.

   This means that a given file's intended encoding cannot be identified
with 100% reliability unless it contains encoding markers such as those
provided by MIME or ISO 2022.

   Unification actually makes it more likely that you will have
problems of this kind.  Traditionally Mule has been "helpful" by simply
using an ISO 2022 universal coding system when the current buffer
coding system cannot handle all the characters in the buffer.  This has
the effect that, because the file contains control sequences, it is not
recognized as being in the locale's normal 8-bit encoding.  It may be
annoying if you are not a Mule expert, but your data is automatically
recoverable with a tool you already have: Mule.

   However, with unification, Mule converts to a single 8-bit character
set when possible.  But typically this will _not_ be in your usual
locale.  Ie, the times that an ISO 8859/1 user will need Unification is
when there are ISO 8859/2 characters in the buffer.  But then most
likely the file will be saved in a pure 8-bit encoding that is not ISO
8859/1, ie, ISO 8859/2.  Mule's autorecognizer (which is probably the
most sophisticated yet available) cannot tell the difference between ISO
8859/1 and ISO 8859/2, and in a Western European locale will choose the
former even though the latter was intended.  Even the extension
("statistical recognition") planned for XEmacs 22 is unlikely to be at
all accurate in the case of mixed codes.

   So now consider adding some additional ISO 8859/1 text to the buffer.
If it includes any ISO 8859/1 codes that are used by different
characters in ISO 8859/2, you now have a file that cannot be
mechanically disentangled.  You need a human being who can recognize
that _this is German and Swedish_ and stays in Latin-1, while _that is
Polish_ and needs to be recoded to Latin-2.

   Moral: switch to a universal coded character set, preferably Unicode
using the UTF-8 transformation format.  If you really need the space,
compress your files.


File: lispref.info,  Node: Unification Internals,  Prev: What Unification Cannot Do for You,  Up: Charset Unification

63.12.4 Internals
-----------------

No internals documentation yet.

   `unity-utils.el' provides one utility function.

 -- Function: unity-dump-tables
     Dump the temporary table created by loading `unity-utils.el' to
     `unity-tables.el'.  Loading the latter file initializes
     `unity-equivalences'.


File: lispref.info,  Node: Charsets and Coding Systems,  Prev: Charset Unification,  Up: MULE

63.12.5 Charsets and Coding Systems
-----------------------------------

This section provides reference lists of Mule charsets and coding
systems.  Mule charsets are typically named by character set and
standard.

*ASCII variants*
     Identification of equivalent characters in these sets is not
     properly implemented.  Unification does not distinguish the two
     charsets.

     `ascii' `latin-jisx0201'

*Extended Latin*
     Characters from the following ISO 2022 conformant charsets are
     identified with equivalents in other charsets in the group by
     Unification.

     `latin-iso8859-1' `latin-iso8859-15' `latin-iso8859-2'
     `latin-iso8859-3' `latin-iso8859-4' `latin-iso8859-9'
     `latin-iso8859-13' `latin-iso8859-16'

     The follow charsets are Latin variants which are not understood by
     Unification.  In addition, many of the Asian language standards
     provide ASCII, at least, and sometimes other Latin characters.
     None of these are identified with their ISO 8859 equivalents.

     `vietnamese-viscii-lower' `vietnamese-viscii-upper'

*Other character sets*
     `arabic-1-column' `arabic-2-column' `arabic-digit'
     `arabic-iso8859-6' `chinese-big5-1' `chinese-big5-2'
     `chinese-cns11643-1' `chinese-cns11643-2' `chinese-cns11643-3'
     `chinese-cns11643-4' `chinese-cns11643-5' `chinese-cns11643-6'
     `chinese-cns11643-7' `chinese-gb2312' `chinese-isoir165'
     `cyrillic-iso8859-5' `ethiopic' `greek-iso8859-7'
     `hebrew-iso8859-8' `ipa' `japanese-jisx0208'
     `japanese-jisx0208-1978' `japanese-jisx0212' `katakana-jisx0201'
     `korean-ksc5601' `sisheng' `thai-tis620' `thai-xtis'

*Non-graphic charsets*
     `control-1'

*No conversion*
     Some of these coding systems may specify EOL conventions.  Note
     that `iso-8859-1' is a no-conversion coding system, not an ISO 2022
     coding system.  Although unification attempts to compensate for
     this, it is possible that the `iso-8859-1' coding system will
     behave differently from other ISO 8859 coding systems.

     `binary' `no-conversion' `raw-text' `iso-8859-1'

*Latin coding systems*
     These coding systems are all single-byte, 8-bit ISO 2022 coding
     systems, combining ASCII in the GL register (bytes with high-bit
     clear) and an extended Latin character set in the GR register
     (bytes with high-bit set).

     `iso-8859-15' `iso-8859-2' `iso-8859-3' `iso-8859-4' `iso-8859-9'
     `iso-8859-13' `iso-8859-14' `iso-8859-16'

     These coding systems are single-byte, 8-bit coding systems that do
     not conform to international standards.  They should be avoided in
     all potentially multilingual contexts, including any text
     distributed over the Internet and World Wide Web.

     `windows-1251'

*Multilingual coding systems*
     The following ISO-2022-based coding systems are useful for
     multilingual text.

     `ctext' `iso-2022-lock' `iso-2022-7' `iso-2022-7bit'
     `iso-2022-7bit-ss2' `iso-2022-8' `iso-2022-8bit-ss2'

     XEmacs also supports Unicode with the Mule-UCS package.  These are
     the preferred coding systems for multilingual use.  (There is a
     possible exception for texts that mix several Asian ideographic
     character sets.)

     `utf-16-be' `utf-16-be-no-signature' `utf-16-le'
     `utf-16-le-no-signature' `utf-7' `utf-7-safe' `utf-8' `utf-8-ws'

     Development versions of XEmacs (the 21.5 series) support Unicode
     internally, with (at least) the following coding systems
     implemented:

     `utf-16-be' `utf-16-be-bom' `utf-16-le' `utf-16-le-bom' `utf-8'
     `utf-8-bom'

*Asian ideographic languages*
     The following coding systems are based on ISO 2022, and are more
     or less suitable for encoding multilingual texts.  They all can
     represent ASCII at least, and sometimes several other foreign
     character sets, without resort to arbitrary ISO 2022 designations.
     However, these subsets are not identified with the corresponding
     national standards in XEmacs Mule.

     `chinese-euc' `cn-big5' `cn-gb-2312' `gb2312' `hz' `hz-gb-2312'
     `old-jis' `japanese-euc' `junet' `euc-japan' `euc-jp' `iso-2022-jp'
     `iso-2022-jp-1978-irv' `iso-2022-jp-2' `euc-kr' `korean-euc'
     `iso-2022-kr' `iso-2022-int-1'

     The following coding systems cannot be used for general
     multilingual text and do not cooperate well with other coding
     systems.

     `big5' `shift_jis'

*Other languages*
     The following coding systems are based on ISO 2022.  Though none
     of them provides any Latin characters beyond ASCII, XEmacs Mule
     allows (and up to 21.4 defaults to) use of ISO 2022 control
     sequences to designate other character sets for inclusion the text.

     `iso-8859-5' `iso-8859-7' `iso-8859-8' `ctext-hebrew'

     The following are character sets that do not conform to ISO 2022
     and thus cannot be safely used in a multilingual context.

     `alternativnyj' `koi8-r' `tis-620' `viqr' `viscii' `vscii'

*Special coding systems*
     Mule uses the following coding systems for special purposes.

     `automatic-conversion' `undecided' `escape-quoted'

     `escape-quoted' is especially important, as it is used internally
     as the coding system for autosaved data.

     The following coding systems are aliases for others, and are used
     for communication with the host operating system.

     `file-name' `keyboard' `terminal'


   Mule detection of coding systems is actually limited to detection of
classes of coding systems called "coding categories".  These coding
categories are identified by the ISO 2022 control sequences they use, if
any, by their conformance to ISO 2022 restrictions on code points that
may be used, and by characteristic patterns of use of 8-bit code points.

   `no-conversion' `utf-8' `ucs-4' `iso-7' `iso-lock-shift' `iso-8-1'
`iso-8-2' `iso-8-designate' `shift-jis' `big5'


File: lispref.info,  Node: Tips,  Next: Building XEmacs and Object Allocation,  Prev: MULE,  Up: Top

Appendix A Tips and Standards
*****************************

This chapter describes no additional features of XEmacs Lisp.  Instead
it gives advice on making effective use of the features described in
the previous chapters.

* Menu:

* Style Tips::                Writing clean and robust programs.
* Compilation Tips::          Making compiled code run fast.
* Documentation Tips::        Writing readable documentation strings.
* Comment Tips::	      Conventions for writing comments.
* Library Headers::           Standard headers for library packages.


File: lispref.info,  Node: Style Tips,  Next: Compilation Tips,  Prev: Tips,  Up: Tips

A.1 Writing Clean Lisp Programs
===============================

Here are some tips for avoiding common errors in writing Lisp code
intended for widespread use:

   * Since all global variables share the same name space, and all
     functions share another name space, you should choose a short word
     to distinguish your program from other Lisp programs.  Then take
     care to begin the names of all global variables, constants, and
     functions with the chosen prefix.  This helps avoid name conflicts.

     This recommendation applies even to names for traditional Lisp
     primitives that are not primitives in XEmacs Lisp--even to `cadr'.
     Believe it or not, there is more than one plausible way to define
     `cadr'.  Play it safe; append your name prefix to produce a name
     like `foo-cadr' or `mylib-cadr' instead.

     If you write a function that you think ought to be added to Emacs
     under a certain name, such as `twiddle-files', don't call it by
     that name in your program.  Call it `mylib-twiddle-files' in your
     program, and send mail to `bug-gnu-emacs@prep.ai.mit.edu'
     suggesting we add it to Emacs.  If and when we do, we can change
     the name easily enough.

     If one prefix is insufficient, your package may use two or three
     alternative common prefixes, so long as they make sense.

     Separate the prefix from the rest of the symbol name with a hyphen,
     `-'.  This will be consistent with XEmacs itself and with most
     Emacs Lisp programs.

   * It is often useful to put a call to `provide' in each separate
     library program, at least if there is more than one entry point to
     the program.

   * If a file requires certain other library programs to be loaded
     beforehand, then the comments at the beginning of the file should
     say so.  Also, use `require' to make sure they are loaded.

   * If one file FOO uses a macro defined in another file BAR, FOO
     should contain this expression before the first use of the macro:

          (eval-when-compile (require 'BAR))

     (And BAR should contain `(provide 'BAR)', to make the `require'
     work.)  This will cause BAR to be loaded when you byte-compile
     FOO.  Otherwise, you risk compiling FOO without the necessary
     macro loaded, and that would produce compiled code that won't work
     right.  *Note Compiling Macros::.

     Using `eval-when-compile' avoids loading BAR when the compiled
     version of FOO is _used_.

   * If you define a major mode, make sure to run a hook variable using
     `run-hooks', just as the existing major modes do.  *Note Hooks::.

   * If the purpose of a function is to tell you whether a certain
     condition is true or false, give the function a name that ends in
     `p'.  If the name is one word, add just `p'; if the name is
     multiple words, add `-p'.  Examples are `framep' and
     `frame-live-p'.

   * If a user option variable records a true-or-false condition, give
     it a name that ends in `-flag'.

   * Please do not define `C-c LETTER' as a key in your major modes.
     These sequences are reserved for users; they are the *only*
     sequences reserved for users, so we cannot do without them.

     Instead, define sequences consisting of `C-c' followed by a
     non-letter.  These sequences are reserved for major modes.

     Changing all the major modes in Emacs 18 so they would follow this
     convention was a lot of work.  Abandoning this convention would
     make that work go to waste, and inconvenience users.

   * Sequences consisting of `C-c' followed by `{', `}', `<', `>', `:'
     or `;' are also reserved for major modes.

   * Sequences consisting of `C-c' followed by any other punctuation
     character are allocated for minor modes.  Using them in a major
     mode is not absolutely prohibited, but if you do that, the major
     mode binding may be shadowed from time to time by minor modes.

   * You should not bind `C-h' following any prefix character (including
     `C-c').  If you don't bind `C-h', it is automatically available as
     a help character for listing the subcommands of the prefix
     character.

   * You should not bind a key sequence ending in <ESC> except following
     another <ESC>.  (That is, it is ok to bind a sequence ending in
     `<ESC> <ESC>'.)

     The reason for this rule is that a non-prefix binding for <ESC> in
     any context prevents recognition of escape sequences as function
     keys in that context.

   * Applications should not bind mouse events based on button 1 with
     the shift key held down.  These events include `S-mouse-1',
     `M-S-mouse-1', `C-S-mouse-1', and so on.  They are reserved for
     users.

   * Modes should redefine `mouse-2' as a command to follow some sort of
     reference in the text of a buffer, if users usually would not want
     to alter the text in that buffer by hand.  Modes such as Dired,
     Info, Compilation, and Occur redefine it in this way.

   * When a package provides a modification of ordinary Emacs behavior,
     it is good to include a command to enable and disable the feature,
     Provide a command named `WHATEVER-mode' which turns the feature on
     or off, and make it autoload (*note Autoload::).  Design the
     package so that simply loading it has no visible effect--that
     should not enable the feature.  Users will request the feature by
     invoking the command.

   * It is a bad idea to define aliases for the Emacs primitives.  Use
     the standard names instead.

   * Redefining an Emacs primitive is an even worse idea.  It may do
     the right thing for a particular program, but there is no telling
     what other programs might break as a result.

   * If a file does replace any of the functions or library programs of
     standard XEmacs, prominent comments at the beginning of the file
     should say which functions are replaced, and how the behavior of
     the replacements differs from that of the originals.

   * Please keep the names of your XEmacs Lisp source files to 13
     characters or less.  This way, if the files are compiled, the
     compiled files' names will be 14 characters or less, which is
     short enough to fit on all kinds of Unix systems.

   * Don't use `next-line' or `previous-line' in programs; nearly
     always, `forward-line' is more convenient as well as more
     predictable and robust.  *Note Text Lines::.

   * Don't call functions that set the mark, unless setting the mark is
     one of the intended features of your program.  The mark is a
     user-level feature, so it is incorrect to change the mark except
     to supply a value for the user's benefit.  *Note The Mark::.

     In particular, don't use these functions:

        * `beginning-of-buffer', `end-of-buffer'

        * `replace-string', `replace-regexp'

     If you just want to move point, or replace a certain string,
     without any of the other features intended for interactive users,
     you can replace these functions with one or two lines of simple
     Lisp code.

   * Use lists rather than vectors, except when there is a particular
     reason to use a vector.  Lisp has more facilities for manipulating
     lists than for vectors, and working with lists is usually more
     convenient.

     Vectors are advantageous for tables that are substantial in size
     and are accessed in random order (not searched front to back),
     provided there is no need to insert or delete elements (only lists
     allow that).

   * The recommended way to print a message in the echo area is with
     the `message' function, not `princ'.  *Note The Echo Area::.

   * When you encounter an error condition, call the function `error'
     (or `signal').  The function `error' does not return.  *Note
     Signaling Errors::.

     Do not use `message', `throw', `sleep-for', or `beep' to report
     errors.

   * An error message should start with a capital letter but should not
     end with a period.

   * Try to avoid using recursive edits.  Instead, do what the Rmail `e'
     command does: use a new local keymap that contains one command
     defined to switch back to the old local keymap.  Or do what the
     `edit-options' command does: switch to another buffer and let the
     user switch back at will.  *Note Recursive Editing::.

   * In some other systems there is a convention of choosing variable
     names that begin and end with `*'.  We don't use that convention
     in Emacs Lisp, so please don't use it in your programs.  (Emacs
     uses such names only for program-generated buffers.)  The users
     will find Emacs more coherent if all libraries use the same
     conventions.

   * Indent each function with `C-M-q' (`indent-sexp') using the
     default indentation parameters.

   * Don't make a habit of putting close-parentheses on lines by
     themselves; Lisp programmers find this disconcerting.  Once in a
     while, when there is a sequence of many consecutive
     close-parentheses, it may make sense to split them in one or two
     significant places.

   * Please put a copyright notice on the file if you give copies to
     anyone.  Use the same lines that appear at the top of the Lisp
     files in XEmacs itself.  If you have not signed papers to assign
     the copyright to the Foundation, then place your name in the
     copyright notice in place of the Foundation's name.


File: lispref.info,  Node: Compilation Tips,  Next: Documentation Tips,  Prev: Style Tips,  Up: Tips

A.2 Tips for Making Compiled Code Fast
======================================

Here are ways of improving the execution speed of byte-compiled Lisp
programs.

   * Use the `profile' library to profile your program.  See the file
     `profile.el' for instructions.

   * Use iteration rather than recursion whenever possible.  Function
     calls are slow in XEmacs Lisp even when a compiled function is
     calling another compiled function.

   * Using the primitive list-searching functions `memq', `member',
     `assq', or `assoc' is even faster than explicit iteration.  It may
     be worth rearranging a data structure so that one of these
     primitive search functions can be used.

   * Certain built-in functions are handled specially in byte-compiled
     code, avoiding the need for an ordinary function call.  It is a
     good idea to use these functions rather than alternatives.  To see
     whether a function is handled specially by the compiler, examine
     its `byte-compile' property.  If the property is non-`nil', then
     the function is handled specially.

     For example, the following input will show you that `aref' is
     compiled specially (*note Array Functions::) while `elt' is not
     (*note Sequence Functions::):

          (get 'aref 'byte-compile)
               => byte-compile-two-args

          (get 'elt 'byte-compile)
               => nil

   * If calling a small function accounts for a  substantial part of
     your program's running time, make the function inline.  This
     eliminates the function call overhead.  Since making a function
     inline reduces the flexibility of changing the program, don't do
     it unless it gives a noticeable speedup in something slow enough
     that users care about the speed.  *Note Inline Functions::.


File: lispref.info,  Node: Documentation Tips,  Next: Comment Tips,  Prev: Compilation Tips,  Up: Tips

A.3 Tips for Documentation Strings
==================================

Here are some tips for the writing of documentation strings.

   * Every command, function, or variable intended for users to know
     about should have a documentation string.

   * An internal variable or subroutine of a Lisp program might as well
     have a documentation string.  In earlier Emacs versions, you could
     save space by using a comment instead of a documentation string,
     but that is no longer the case.

   * The first line of the documentation string should consist of one
     or two complete sentences that stand on their own as a summary.
     `M-x apropos' displays just the first line, and if it doesn't
     stand on its own, the result looks bad.  In particular, start the
     first line with a capital letter and end with a period.

     The documentation string can have additional lines that expand on
     the details of how to use the function or variable.  The
     additional lines should be made up of complete sentences also, but
     they may be filled if that looks good.

   * For consistency, phrase the verb in the first sentence of a
     documentation string as an infinitive with "to" omitted.  For
     instance, use "Return the cons of A and B." in preference to
     "Returns the cons of A and B."  Usually it looks good to do
     likewise for the rest of the first paragraph.  Subsequent
     paragraphs usually look better if they have proper subjects.

   * Write documentation strings in the active voice, not the passive,
     and in the present tense, not the future.  For instance, use
     "Return a list containing A and B." instead of "A list containing
     A and B will be returned."

   * Avoid using the word "cause" (or its equivalents) unnecessarily.
     Instead of, "Cause Emacs to display text in boldface," write just
     "Display text in boldface."

   * Do not start or end a documentation string with whitespace.

   * Format the documentation string so that it fits in an Emacs window
     on an 80-column screen.  It is a good idea for most lines to be no
     wider than 60 characters.  The first line can be wider if
     necessary to fit the information that ought to be there.

     However, rather than simply filling the entire documentation
     string, you can make it much more readable by choosing line breaks
     with care.  Use blank lines between topics if the documentation
     string is long.

   * *Do not* indent subsequent lines of a documentation string so that
     the text is lined up in the source code with the text of the first
     line.  This looks nice in the source code, but looks bizarre when
     users view the documentation.  Remember that the indentation
     before the starting double-quote is not part of the string!

   * A variable's documentation string should start with `*' if the
     variable is one that users would often want to set interactively.
     If the value is a long list, or a function, or if the variable
     would be set only in init files, then don't start the
     documentation string with `*'.  *Note Defining Variables::.

   * The documentation string for a variable that is a yes-or-no flag
     should start with words such as "Non-nil means...", to make it
     clear that all non-`nil' values are equivalent and indicate
     explicitly what `nil' and non-`nil' mean.

   * When a function's documentation string mentions the value of an
     argument of the function, use the argument name in capital letters
     as if it were a name for that value.  Thus, the documentation
     string of the function `/' refers to its second argument as
     `DIVISOR', because the actual argument name is `divisor'.

     Also use all caps for meta-syntactic variables, such as when you
     show the decomposition of a list or vector into subunits, some of
     which may vary.

   * When a documentation string refers to a Lisp symbol, write it as it
     would be printed (which usually means in lower case), with
     single-quotes around it.  For example: `lambda'.  There are two
     exceptions: write t and nil without single-quotes.  (In this
     manual, we normally do use single-quotes for those symbols.)

   * Don't write key sequences directly in documentation strings.
     Instead, use the `\\[...]' construct to stand for them.  For
     example, instead of writing `C-f', write `\\[forward-char]'.  When
     Emacs displays the documentation string, it substitutes whatever
     key is currently bound to `forward-char'.  (This is normally `C-f',
     but it may be some other character if the user has moved key
     bindings.)  *Note Keys in Documentation::.

   * In documentation strings for a major mode, you will want to refer
     to the key bindings of that mode's local map, rather than global
     ones.  Therefore, use the construct `\\<...>' once in the
     documentation string to specify which key map to use.  Do this
     before the first use of `\\[...]'.  The text inside the `\\<...>'
     should be the name of the variable containing the local keymap for
     the major mode.

     It is not practical to use `\\[...]' very many times, because
     display of the documentation string will become slow.  So use this
     to describe the most important commands in your major mode, and
     then use `\\{...}' to display the rest of the mode's keymap.


File: lispref.info,  Node: Comment Tips,  Next: Library Headers,  Prev: Documentation Tips,  Up: Tips

A.4 Tips on Writing Comments
============================

We recommend these conventions for where to put comments and how to
indent them:

`;'
     Comments that start with a single semicolon, `;', should all be
     aligned to the same column on the right of the source code.  Such
     comments usually explain how the code on the same line does its
     job.  In Lisp mode and related modes, the `M-;'
     (`indent-for-comment') command automatically inserts such a `;' in
     the right place, or aligns such a comment if it is already present.

     This and following examples are taken from the Emacs sources.

          (setq base-version-list                 ; there was a base
                (assoc (subseq fn 0 start-vn)     ; version to which
                       file-version-assoc-list))  ; this looks like
                                                  ; a subversion

`;;'
     Comments that start with two semicolons, `;;', should be aligned to
     the same level of indentation as the code.  Such comments usually
     describe the purpose of the following lines or the state of the
     program at that point.  For example:

          (prog1 (setq auto-fill-function
                       ...
                       ...
            ;; update modeline
            (redraw-modeline)))

     Every function that has no documentation string (because it is
     used only internally within the package it belongs to), should
     have instead a two-semicolon comment right before the function,
     explaining what the function does and how to call it properly.
     Explain precisely what each argument means and how the function
     interprets its possible values.

`;;;'
     Comments that start with three semicolons, `;;;', should start at
     the left margin.  Such comments are used outside function
     definitions to make general statements explaining the design
     principles of the program.  For example:

          ;;; This Lisp code is run in XEmacs
          ;;; when it is to operate as a server
          ;;; for other processes.

     Another use for triple-semicolon comments is for commenting out
     lines within a function.  We use triple-semicolons for this
     precisely so that they remain at the left margin.

          (defun foo (a)
          ;;; This is no longer necessary.
          ;;;  (force-mode-line-update)
            (message "Finished with %s" a))

`;;;;'
     Comments that start with four semicolons, `;;;;', should be aligned
     to the left margin and are used for headings of major sections of a
     program.  For example:

          ;;;; The kill ring

The indentation commands of the Lisp modes in XEmacs, such as `M-;'
(`indent-for-comment') and <TAB> (`lisp-indent-line') automatically
indent comments according to these conventions, depending on the number
of semicolons.  *Note Manipulating Comments: (xemacs)Comments.


File: lispref.info,  Node: Library Headers,  Prev: Comment Tips,  Up: Tips

A.5 Conventional Headers for XEmacs Libraries
=============================================

XEmacs has conventions for using special comments in Lisp libraries to
divide them into sections and give information such as who wrote them.
This section explains these conventions.  First, an example:

     ;;; lisp-mnt.el --- minor mode for Emacs Lisp maintainers

     ;; Copyright (C) 1992 Free Software Foundation, Inc.

     ;; Author: Eric S. Raymond <esr@snark.thyrsus.com>
     ;; Maintainer: Eric S. Raymond <esr@snark.thyrsus.com>
     ;; Created: 14 Jul 1992
     ;; Version: 1.2
     ;; Keywords: docs

     ;; This file is part of XEmacs.
     COPYING PERMISSIONS...

   The very first line should have this format:

     ;;; FILENAME --- DESCRIPTION

The description should be complete in one line.

   After the copyright notice come several "header comment" lines, each
beginning with `;; HEADER-NAME:'.  Here is a table of the conventional
possibilities for HEADER-NAME:

`Author'
     This line states the name and net address of at least the principal
     author of the library.

     If there are multiple authors, you can list them on continuation
     lines led by `;;' and a tab character, like this:

          ;; Author: Ashwin Ram <Ram-Ashwin@cs.yale.edu>
          ;;      Dave Sill <de5@ornl.gov>
          ;;      Dave Brennan <brennan@hal.com>
          ;;      Eric Raymond <esr@snark.thyrsus.com>

`Maintainer'
     This line should contain a single name/address as in the Author
     line, or an address only, or the string `FSF'.  If there is no
     maintainer line, the person(s) in the Author field are presumed to
     be the maintainers.  The example above is mildly bogus because the
     maintainer line is redundant.

     The idea behind the `Author' and `Maintainer' lines is to make
     possible a Lisp function to "send mail to the maintainer" without
     having to mine the name out by hand.

     Be sure to surround the network address with `<...>' if you
     include the person's full name as well as the network address.

`Created'
     This optional line gives the original creation date of the file.
     For historical interest only.

`Version'
     If you wish to record version numbers for the individual Lisp
     program, put them in this line.

`Adapted-By'
     In this header line, place the name of the person who adapted the
     library for installation (to make it fit the style conventions, for
     example).

`Keywords'
     This line lists keywords for the `finder-by-keyword' help command.
     This field is important; it's how people will find your package
     when they're looking for things by topic area.  To separate the
     keywords, you can use spaces, commas, or both.

   Just about every Lisp library ought to have the `Author' and
`Keywords' header comment lines.  Use the others if they are
appropriate.  You can also put in header lines with other header
names--they have no standard meanings, so they can't do any harm.

   We use additional stylized comments to subdivide the contents of the
library file.  Here is a table of them:

`;;; Commentary:'
     This begins introductory comments that explain how the library
     works.  It should come right after the copying permissions.

`;;; Change log:'
     This begins change log information stored in the library file (if
     you store the change history there).  For most of the Lisp files
     distributed with XEmacs, the change history is kept in the file
     `ChangeLog' and not in the source file at all; these files do not
     have a `;;; Change log:' line.

`;;; Code:'
     This begins the actual code of the program.

`;;; FILENAME ends here'
     This is the "footer line"; it appears at the very end of the file.
     Its purpose is to enable people to detect truncated versions of
     the file from the lack of a footer line.


File: lispref.info,  Node: Building XEmacs and Object Allocation,  Next: Standard Errors,  Prev: Tips,  Up: Top

Appendix B Building XEmacs; Allocation of Objects
*************************************************

This chapter describes how the runnable XEmacs executable is dumped
with the preloaded Lisp libraries in it and how storage is allocated.

   There is an entire separate document, the `XEmacs Internals Manual',
devoted to the internals of XEmacs from the perspective of the C
programmer.  It contains much more detailed information about the build
process, the allocation and garbage-collection process, and other
aspects related to the internals of XEmacs.

* Menu:

* Building XEmacs::     How to preload Lisp libraries into XEmacs.
* Garbage Collection::  Reclaiming space for Lisp objects no longer used.


File: lispref.info,  Node: Building XEmacs,  Next: Garbage Collection,  Prev: Building XEmacs and Object Allocation,  Up: Building XEmacs and Object Allocation

B.1 Building XEmacs
===================

This section explains the steps involved in building the XEmacs
executable.  You don't have to know this material to build and install
XEmacs, since the makefiles do all these things automatically.  This
information is pertinent to XEmacs maintenance.

   The `XEmacs Internals Manual' contains more information about this.

   Compilation of the C source files in the `src' directory produces an
executable file called `temacs'.  It contains the XEmacs Lisp
interpreter and I/O routines, but not the editing commands.

   Before XEmacs is actually usable, a number of Lisp files need to be
loaded.  These define all the editing commands, plus most of the startup
code and many very basic Lisp primitives.  This is accomplished by
loading the file `loadup.el', which in turn loads all of the other
standardly-loaded Lisp files.

   It takes a substantial time to load the standard Lisp files.
Luckily, you don't have to do this each time you run XEmacs; `temacs'
can dump out an executable program called `xemacs' that has these files
preloaded.  `xemacs' starts more quickly because it does not need to
load the files.  This is the XEmacs executable that is normally
installed.

   To create `xemacs', use the command `temacs -batch -l loadup dump'.
The purpose of `-batch' here is to tell `temacs' to run in
non-interactive, command-line mode. (`temacs' can _only_ run in this
fashion.  Part of the code required to initialize frames and faces is
in Lisp, and must be loaded before XEmacs is able to create any frames.)
The argument `dump' tells `loadup.el' to dump a new executable named
`xemacs'.

   The dumping process is highly system-specific, and some operating
systems don't support dumping.  On those systems, you must start XEmacs
with the `temacs -batch -l loadup run-temacs' command each time you use
it.  This takes a substantial time, but since you need to start Emacs
once a day at most--or once a week if you never log out--the extra time
is not too severe a problem. (In older versions of Emacs, you started
Emacs from `temacs' using `temacs -l loadup'.)

   You are free to start XEmacs directly from `temacs' if you want,
even if there is already a dumped `xemacs'.  Normally you wouldn't want
to do that; but the Makefiles do this when you rebuild XEmacs using
`make all-elc', which builds XEmacs and simultaneously compiles any
out-of-date Lisp files. (You need `xemacs' in order to compile Lisp
files.  However, you also need the compiled Lisp files in order to dump
out `xemacs'.  If both of these are missing or corrupted, you are out
of luck unless you're able to bootstrap `xemacs' from `temacs'.  Note
that `make all-elc' actually loads the alternative loadup file
`loadup-el.el', which works like `loadup.el' but forces XEmacs to
ignore any compiled Lisp files even if they exist.)

   You can specify additional files to preload by writing a library
named `site-load.el' that loads them.  However, the advantage of
preloading additional files decreases as machines get faster.  On modern
machines, it is often not advisable, especially if the Lisp code is on
a file system local to the machine running XEmacs.

   You can specify other Lisp expressions to execute just before dumping
by putting them in a library named `site-init.el'.  However, if they
might alter the behavior that users expect from an ordinary unmodified
XEmacs, it is better to put them in `default.el', so that users can
override them if they wish.  *Note Start-up Summary::.

   Before `loadup.el' dumps the new executable, it finds the
documentation strings for primitive and preloaded functions (and
variables) in the file where they are stored, by calling
`Snarf-documentation' (*note Accessing Documentation::).  These strings
were moved out of the `xemacs' executable to make it smaller.  *Note
Documentation Basics::.

 -- Function: dump-emacs to-file from-file
     This function dumps the current state of XEmacs into an executable
     file TO-FILE.  It takes symbols from FROM-FILE (this is normally
     the executable file `temacs').

     If you use this function in an XEmacs that was already dumped, you
     must set `command-line-processed' to `nil' first for good results.
     *Note Command Line Arguments::.

 -- Function: run-emacs-from-temacs &rest args
     This is the function that implements the `run-temacs' command-line
     argument.  It is called from `loadup.el' as appropriate.  You
     should most emphatically _not_ call this yourself; it will
     reinitialize your XEmacs process and you'll be sorry.

 -- Command: emacs-version &optional arg
     This function returns a string describing the version of XEmacs
     that is running.  It is useful to include this string in bug
     reports.

     When called interactively with a prefix argument, insert string at
     point.  Don't use this function in programs to choose actions
     according to the system configuration; look at
     `system-configuration' instead.

          (emacs-version)
            => "XEmacs 20.1 [Lucid] (i586-unknown-linux2.0.29)
                           of Mon Apr  7 1997 on altair.xemacs.org"

     Called interactively, the function prints the same information in
     the echo area.

 -- Variable: emacs-build-time
     The value of this variable is the time at which XEmacs was built
     at the local site.

          emacs-build-time "Mon Apr  7 20:28:52 1997"
               =>

 -- Variable: emacs-version
     The value of this variable is the version of Emacs being run.  It
     is a string, e.g. `"20.1 XEmacs Lucid"'.

   The following two variables did not exist before FSF GNU Emacs
version 19.23 and XEmacs version 19.10, which reduces their usefulness
at present, but we hope they will be convenient in the future.

 -- Variable: emacs-major-version
     The major version number of Emacs, as an integer.  For XEmacs
     version 20.1, the value is 20.

 -- Variable: emacs-minor-version
     The minor version number of Emacs, as an integer.  For XEmacs
     version 20.1, the value is 1.


File: lispref.info,  Node: Garbage Collection,  Prev: Building XEmacs,  Up: Building XEmacs and Object Allocation

B.2 Garbage Collection
======================

When a program creates a list or the user defines a new function (such
as by loading a library), that data is placed in normal storage.  If
normal storage runs low, then XEmacs asks the operating system to
allocate more memory in blocks of 2k bytes.  Each block is used for one
type of Lisp object, so symbols, cons cells, markers, etc., are
segregated in distinct blocks in memory.  (Vectors, long strings,
buffers and certain other editing types, which are fairly large, are
allocated in individual blocks, one per object, while small strings are
packed into blocks of 8k bytes. [More correctly, a string is allocated
in two sections: a fixed size chunk containing the length, list of
extents, etc.; and a chunk containing the actual characters in the
string.  It is this latter chunk that is either allocated individually
or packed into 8k blocks.  The fixed size chunk is packed into 2k
blocks, as for conses, markers, etc.])

   It is quite common to use some storage for a while, then release it
by (for example) killing a buffer or deleting the last pointer to an
object.  XEmacs provides a "garbage collector" to reclaim this
abandoned storage.  (This name is traditional, but "garbage recycler"
might be a more intuitive metaphor for this facility.)

   The garbage collector operates by finding and marking all Lisp
objects that are still accessible to Lisp programs.  To begin with, it
assumes all the symbols, their values and associated function
definitions, and any data presently on the stack, are accessible.  Any
objects that can be reached indirectly through other accessible objects
are also accessible.

   When marking is finished, all objects still unmarked are garbage.  No
matter what the Lisp program or the user does, it is impossible to refer
to them, since there is no longer a way to reach them.  Their space
might as well be reused, since no one will miss them.  The second
("sweep") phase of the garbage collector arranges to reuse them.

   The sweep phase puts unused cons cells onto a "free list" for future
allocation; likewise for symbols, markers, extents, events, floats,
compiled-function objects, and the fixed-size portion of strings.  It
compacts the accessible small string-chars chunks so they occupy fewer
8k blocks; then it frees the other 8k blocks.  Vectors, buffers,
windows, and other large objects are individually allocated and freed
using `malloc' and `free'.

     Common Lisp note: unlike other Lisps, XEmacs Lisp does not call
     the garbage collector when the free list is empty.  Instead, it
     simply requests the operating system to allocate more storage, and
     processing continues until `gc-cons-threshold' bytes have been
     used.

     This means that you can make sure that the garbage collector will
     not run during a certain portion of a Lisp program by calling the
     garbage collector explicitly just before it (provided that portion
     of the program does not use so much space as to force a second
     garbage collection).

 -- Command: garbage-collect
     This command runs a garbage collection, and returns information on
     the amount of space in use.  (Garbage collection can also occur
     spontaneously if you use more than `gc-cons-threshold' bytes of
     Lisp data since the previous garbage collection.)

     `garbage-collect' returns a list containing the following
     information:

          ((USED-CONSES . FREE-CONSES)
           (USED-SYMS . FREE-SYMS)
           (USED-MARKERS . FREE-MARKERS)
           USED-STRING-CHARS
           USED-VECTOR-SLOTS
           (PLIST))

          => ((73362 . 8325) (13718 . 164)
          (5089 . 5098) 949121 118677
          (conses-used 73362 conses-free 8329 cons-storage 658168
          symbols-used 13718 symbols-free 164 symbol-storage 335216
          bit-vectors-used 0 bit-vectors-total-length 0
          bit-vector-storage 0 vectors-used 7882
          vectors-total-length 118677 vector-storage 537764
          compiled-functions-used 1336 compiled-functions-free 37
          compiled-function-storage 44440 short-strings-used 28829
          long-strings-used 2 strings-free 7722
          short-strings-total-length 916657 short-string-storage 1179648
          long-strings-total-length 32464 string-header-storage 441504
          floats-used 3 floats-free 43 float-storage 2044 markers-used 5089
          markers-free 5098 marker-storage 245280 events-used 103
          events-free 835 event-storage 110656 extents-used 10519
          extents-free 2718 extent-storage 372736
          extent-auxiliarys-used 111 extent-auxiliarys-freed 3
          extent-auxiliary-storage 4440 window-configurations-used 39
          window-configurations-on-free-list 5
          window-configurations-freed 10 window-configuration-storage 9492
          popup-datas-used 3 popup-data-storage 72 toolbar-buttons-used 62
          toolbar-button-storage 4960 toolbar-datas-used 12
          toolbar-data-storage 240 symbol-value-buffer-locals-used 182
          symbol-value-buffer-local-storage 5824
          symbol-value-lisp-magics-used 22
          symbol-value-lisp-magic-storage 1496
          symbol-value-varaliases-used 43
          symbol-value-varalias-storage 1032 opaque-lists-used 2
          opaque-list-storage 48 color-instances-used 12
          color-instance-storage 288 font-instances-used 5
          font-instance-storage 180 opaques-used 11 opaque-storage 312
          range-tables-used 1 range-table-storage 16 faces-used 34
          face-storage 2584 glyphs-used 124 glyph-storage 4464
          specifiers-used 775 specifier-storage 43869 weak-lists-used 786
          weak-list-storage 18864 char-tables-used 40
          char-table-storage 41920 buffers-used 25 buffer-storage 7000
          extent-infos-used 457 extent-infos-freed 73
          extent-info-storage 9140 keymaps-used 275 keymap-storage 12100
          consoles-used 4 console-storage 384 command-builders-used 2
          command-builder-storage 120 devices-used 2 device-storage 344
          frames-used 3 frame-storage 624 image-instances-used 47
          image-instance-storage 3008 windows-used 27 windows-freed 2
          window-storage 9180 lcrecord-lists-used 15
          lcrecord-list-storage 360 hash-tables-used 631
          hash-table-storage 25240 streams-used 1 streams-on-free-list 3
          streams-freed 12 stream-storage 91))

     Here is a table explaining each element:

    USED-CONSES
          The number of cons cells in use.

    FREE-CONSES
          The number of cons cells for which space has been obtained
          from the operating system, but that are not currently being
          used.

    USED-SYMS
          The number of symbols in use.

    FREE-SYMS
          The number of symbols for which space has been obtained from
          the operating system, but that are not currently being used.

    USED-MARKERS
          The number of markers in use.

    FREE-MARKERS
          The number of markers for which space has been obtained from
          the operating system, but that are not currently being used.

    USED-STRING-CHARS
          The total size of all strings, in characters.

    USED-VECTOR-SLOTS
          The total number of elements of existing vectors.

    PLIST
          A list of alternating keyword/value pairs providing more
          detailed information. (As you can see above, quite a lot of
          information is provided.)

 -- User Option: gc-cons-threshold
     The value of this variable is the number of bytes of storage that
     must be allocated for Lisp objects after one garbage collection in
     order to trigger another garbage collection.  A cons cell counts
     as eight bytes, a string as one byte per character plus a few
     bytes of overhead, and so on; space allocated to the contents of
     buffers does not count.  Note that the subsequent garbage
     collection does not happen immediately when the threshold is
     exhausted, but only the next time the Lisp evaluator is called.

     The initial threshold value is 500,000.  If you specify a larger
     value, garbage collection will happen less often.  This reduces the
     amount of time spent garbage collecting, but increases total
     memory use.  You may want to do this when running a program that
     creates lots of Lisp data.

     You can make collections more frequent by specifying a smaller
     value, down to 10,000.  A value less than 10,000 will remain in
     effect only until the subsequent garbage collection, at which time
     `garbage-collect' will set the threshold back to 10,000. (This does
     not apply if XEmacs was configured with `--debug'.  Therefore, be
     careful when setting `gc-cons-threshold' in that case!)

 -- Variable: pre-gc-hook
     This is a normal hook to be run just before each garbage
     collection.  Interrupts, garbage collection, and errors are
     inhibited while this hook runs, so be extremely careful in what
     you add here.  In particular, avoid consing, and do not interact
     with the user.

 -- Variable: post-gc-hook
     This is a normal hook to be run just after each garbage collection.
     Interrupts, garbage collection, and errors are inhibited while
     this hook runs, so be extremely careful in what you add here.  In
     particular, avoid consing, and do not interact with the user.

 -- Variable: gc-message
     This is a string to print to indicate that a garbage collection is
     in progress.  This is printed in the echo area.  If the selected
     frame is on a window system and `gc-pointer-glyph' specifies a
     value (i.e. a pointer image instance) in the domain of the
     selected frame, the mouse cursor will change instead of this
     message being printed.

 -- Glyph: gc-pointer-glyph
     This holds the pointer glyph used to indicate that a garbage
     collection is in progress.  If the selected window is on a window
     system and this glyph specifies a value (i.e. a pointer image
     instance) in the domain of the selected window, the cursor will be
     changed as specified during garbage collection.  Otherwise, a
     message will be printed in the echo area, as controlled by
     `gc-message'.  *Note Glyphs::.

   If XEmacs was configured with `--debug', you can set the following
two variables to get direct information about all the allocation that
is happening in a segment of Lisp code.

 -- Variable: debug-allocation
     If non-zero, print out information to stderr about all objects
     allocated.

 -- Variable: debug-allocation-backtrace
     Length (in stack frames) of short backtrace printed out by
     `debug-allocation'.


File: lispref.info,  Node: Standard Errors,  Next: Standard Buffer-Local Variables,  Prev: Building XEmacs and Object Allocation,  Up: Top

Appendix C Standard Errors
**************************

Here is the complete list of the error symbols in standard Emacs,
grouped by concept.  The list includes each symbol's message (on the
`error-message' property of the symbol) and a cross reference to a
description of how the error can occur.

   Each error symbol has an `error-conditions' property that is a list
of symbols.  Normally this list includes the error symbol itself and
the symbol `error'.  Occasionally it includes additional symbols, which
are intermediate classifications, narrower than `error' but broader
than a single error symbol.  For example, all the errors in accessing
files have the condition `file-error'.

   As a special exception, the error symbol `quit' does not have the
condition `error', because quitting is not considered an error.

   *Note Errors::, for an explanation of how errors are generated and
handled.

`SYMBOL'
     STRING; REFERENCE.

`error'
     `"error"'
     *Note Errors::.

`quit'
     `"Quit"'
     *Note Quitting::.

`args-out-of-range'
     `"Args out of range"'
     *Note Sequences Arrays Vectors::.

`arith-error'
     `"Arithmetic error"'
     See `/' and `%' in *Note Numbers::.

`beginning-of-buffer'
     `"Beginning of buffer"'
     *Note Motion::.

`buffer-read-only'
     `"Buffer is read-only"'
     *Note Read Only Buffers::.

`cyclic-function-indirection'
     `"Symbol's chain of function indirections contains a loop"'
     *Note Function Indirection::.

`domain-error'
     `"Arithmetic domain error"'
`end-of-buffer'
     `"End of buffer"'
     *Note Motion::.

`end-of-file'
     `"End of file during parsing"'
     This is not a `file-error'.
     *Note Input Functions::.

`file-error'
     This error and its subcategories do not have error-strings,
     because the error message is constructed from the data items alone
     when the error condition `file-error' is present.
     *Note Files::.

`file-locked'
     This is a `file-error'.
     *Note File Locks::.

`file-already-exists'
     This is a `file-error'.
     *Note Writing to Files::.

`file-supersession'
     This is a `file-error'.
     *Note Modification Time::.

`invalid-byte-code'
     `"Invalid byte code"'
     *Note Byte Compilation::.

`invalid-function'
     `"Invalid function"'
     *Note Classifying Lists::.

`invalid-read-syntax'
     `"Invalid read syntax"'
     *Note Input Functions::.

`invalid-regexp'
     `"Invalid regexp"'
     *Note Regular Expressions::.

`mark-inactive'
     `"The mark is not active now"'
`no-catch'
     `"No catch for tag"'
     *Note Catch and Throw::.

`overflow-error'
     `"Arithmetic overflow error"'
`protected-field'
     `"Attempt to modify a protected field"'
`range-error'
     `"Arithmetic range error"'
`search-failed'
     `"Search failed"'
     *Note Searching and Matching::.

`setting-constant'
     `"Attempt to set a constant symbol"'
     *Note Variables that Never Change: Constant Variables.

`singularity-error'
     `"Arithmetic singularity error"'
`tooltalk-error'
     `"ToolTalk error"'
     *Note ToolTalk Support::.

`undefined-keystroke-sequence'
     `"Undefined keystroke sequence"'
`void-function'
     `"Symbol's function definition is void"'
     *Note Function Cells::.

`void-variable'
     `"Symbol's value as variable is void"'
     *Note Accessing Variables::.

`wrong-number-of-arguments'
     `"Wrong number of arguments"'
     *Note Classifying Lists::.

`wrong-type-argument'
     `"Wrong type argument"'
     *Note Type Predicates::.

   These error types, which are all classified as special cases of
`arith-error', can occur on certain systems for invalid use of
mathematical functions.

`domain-error'
     `"Arithmetic domain error"'
     *Note Math Functions::.

`overflow-error'
     `"Arithmetic overflow error"'
     *Note Math Functions::.

`range-error'
     `"Arithmetic range error"'
     *Note Math Functions::.

`singularity-error'
     `"Arithmetic singularity error"'
     *Note Math Functions::.

`underflow-error'
     `"Arithmetic underflow error"'
     *Note Math Functions::.


File: lispref.info,  Node: Standard Buffer-Local Variables,  Next: Standard Keymaps,  Prev: Standard Errors,  Up: Top

Appendix D Buffer-Local Variables
*********************************

The table below lists the general-purpose Emacs variables that are
automatically local (when set) in each buffer.  Many Lisp packages
define such variables for their internal use; we don't list them here.

`abbrev-mode'
     *note Abbrevs::

`auto-fill-function'
     *note Auto Filling::

`buffer-auto-save-file-name'
     *note Auto-Saving::

`buffer-backed-up'
     *note Backup Files::

`buffer-display-count'
     *Note Buffers and Windows::.

`buffer-display-table'
     *note Display Tables::

`buffer-display-time'
     *Note Buffers and Windows::.

`buffer-file-format'
     *note Format Conversion::

`buffer-file-name'
     *note Buffer File Name::

`buffer-file-number'
     *note Buffer File Name::

`buffer-file-truename'
     *note Buffer File Name::

`buffer-file-type'
     *note Files and MS-DOS::

`buffer-invisibility-spec'
     *note Invisible Text::

`buffer-offer-save'
     *note Saving Buffers::

`buffer-read-only'
     *note Read Only Buffers::

`buffer-saved-size'
     *note Point::

`buffer-undo-list'
     *note Undo::

`cache-long-line-scans'
     *note Text Lines::

`case-fold-search'
     *note Searching and Case::

`ctl-arrow'
     *note Usual Display::

`comment-column'
     *note Comments: (xemacs)Comments.

`default-directory'
     *note System Environment::

`defun-prompt-regexp'
     *note List Motion::

`fill-column'
     *note Auto Filling::

`goal-column'
     *note Moving Point: (xemacs)Moving Point.

`left-margin'
     *note Indentation::

`local-abbrev-table'
     *note Abbrevs::

`local-write-file-hooks'
     *note Saving Buffers::

`major-mode'
     *note Mode Help::

`mark-active'
     *note The Mark::

`mark-ring'
     *note The Mark::

`minor-modes'
     *note Minor Modes::

`modeline-format'
     *note Modeline Data::

`modeline-buffer-identification'
     *note Modeline Variables::

`modeline-format'
     *note Modeline Data::

`modeline-modified'
     *note Modeline Variables::

`modeline-process'
     *note Modeline Variables::

`mode-name'
     *note Modeline Variables::

`overwrite-mode'
     *note Insertion::

`paragraph-separate'
     *note Standard Regexps::

`paragraph-start'
     *note Standard Regexps::

`point-before-scroll'
     Used for communication between mouse commands and scroll-bar
     commands.

`require-final-newline'
     *note Insertion::

`selective-display'
     *note Selective Display::

`selective-display-ellipses'
     *note Selective Display::

`tab-width'
     *note Usual Display::

`truncate-lines'
     *note Truncation::

`vc-mode'
     *note Modeline Variables::


File: lispref.info,  Node: Standard Keymaps,  Next: Standard Hooks,  Prev: Standard Buffer-Local Variables,  Up: Top

Appendix E Standard Keymaps
***************************

The following symbols are used as the names for various keymaps.  Some
of these exist when XEmacs is first started, others are loaded only
when their respective mode is used.  This is not an exhaustive list.

   Almost all of these maps are used as local maps.  Indeed, of the
modes that presently exist, only Vip mode and Terminal mode ever change
the global keymap.

`bookmark-map'
     A keymap containing bindings to bookmark functions.

`Buffer-menu-mode-map'
     A keymap used by Buffer Menu mode.

`c++-mode-map'
     A keymap used by C++ mode.

`c-mode-map'
     A keymap used by C mode.  A sparse keymap used by C mode.

`command-history-map'
     A keymap used by Command History mode.

`ctl-x-4-map'
     A keymap for subcommands of the prefix `C-x 4'.

`ctl-x-5-map'
     A keymap for subcommands of the prefix `C-x 5'.

`ctl-x-map'
     A keymap for `C-x' commands.

`debugger-mode-map'
     A keymap used by Debugger mode.

`dired-mode-map'
     A keymap for `dired-mode' buffers.

`edit-abbrevs-map'
     A keymap used in `edit-abbrevs'.

`edit-tab-stops-map'
     A keymap used in `edit-tab-stops'.

`electric-buffer-menu-mode-map'
     A keymap used by Electric Buffer Menu mode.

`electric-history-map'
     A keymap used by Electric Command History mode.

`emacs-lisp-mode-map'
     A keymap used by Emacs Lisp mode.

`help-map'
     A keymap for characters following the Help key.

`Helper-help-map'
     A keymap used by the help utility package.
     It has the same keymap in its value cell and in its function cell.

`Info-edit-map'
     A keymap used by the `e' command of Info.

`Info-mode-map'
     A keymap containing Info commands.

`isearch-mode-map'
     A keymap that defines the characters you can type within
     incremental search.

`itimer-edit-map'
     A keymap used when in Itimer Edit mode.

`lisp-interaction-mode-map'
     A keymap used by Lisp mode.

`lisp-mode-map'
     A keymap used by Lisp mode.

     A keymap for minibuffer input with completion.

`minibuffer-local-isearch-map'
     A keymap for editing isearch strings in the minibuffer.

`minibuffer-local-map'
     Default keymap to use when reading from the minibuffer.

`minibuffer-local-must-match-map'
     A keymap for minibuffer input with completion, for exact match.

`mode-specific-map'
     The keymap for characters following `C-c'.  Note, this is in the
     global map.  This map is not actually mode specific: its name was
     chosen to be informative for the user in `C-h b'
     (`display-bindings'), where it describes the main use of the `C-c'
     prefix key.

`modeline-map'
     The keymap consulted for mouse-clicks on the modeline of a window.

`objc-mode-map'
     A keymap used in Objective C mode as a local map.

`occur-mode-map'
     A local keymap used by Occur mode.

`overriding-local-map'
     A keymap that overrides all other local keymaps.

`query-replace-map'
     A local keymap used for responses in `query-replace' and related
     commands; also for `y-or-n-p' and `map-y-or-n-p'.  The functions
     that use this map do not support prefix keys; they look up one
     event at a time.

`read-expression-map'
     The minibuffer keymap used for reading Lisp expressions.

`read-shell-command-map'
     The minibuffer keymap used by `shell-command' and related commands.

`shared-lisp-mode-map'
     A keymap for commands shared by all sorts of Lisp modes.

`text-mode-map'
     A keymap used by Text mode.

`toolbar-map'
     The keymap consulted for mouse-clicks over a toolbar.

`view-mode-map'
     A keymap used by View mode.


File: lispref.info,  Node: Standard Hooks,  Next: Index,  Prev: Standard Keymaps,  Up: Top

Appendix F Standard Hooks
*************************

The following is a list of hook variables that let you provide
functions to be called from within Emacs on suitable occasions.

   Most of these variables have names ending with `-hook'.  They are
"normal hooks", run by means of `run-hooks'.  The value of such a hook
is a list of functions.  The recommended way to put a new function on
such a hook is to call `add-hook'.  *Note Hooks::, for more information
about using hooks.

   The variables whose names end in `-function' have single functions
as their values.  Usually there is a specific reason why the variable is
not a normal hook, such as the need to pass arguments to the function.
(In older Emacs versions, some of these variables had names ending in
`-hook' even though they were not normal hooks.)

   The variables whose names end in `-hooks' or `-functions' have lists
of functions as their values, but these functions are called in a
special way (they are passed arguments, or else their values are used).

`activate-menubar-hook'

`activate-popup-menu-hook'

`ad-definition-hooks'

`adaptive-fill-function'

`add-log-current-defun-function'

`after-change-functions'

`after-delete-annotation-hook'

`after-init-hook'

`after-insert-file-functions'

`after-revert-hook'

`after-save-hook'

`after-set-visited-file-name-hooks'

`after-write-file-hooks'

`auto-fill-function'

`auto-save-hook'

`before-change-functions'

`before-delete-annotation-hook'

`before-init-hook'

`before-revert-hook'

`blink-paren-function'

`buffers-menu-switch-to-buffer-function'

`c++-mode-hook'

`c-delete-function'

`c-mode-common-hook'

`c-mode-hook'

`c-special-indent-hook'

`calendar-load-hook'

`change-major-mode-hook'

`command-history-hook'

`comment-indent-function'

`compilation-buffer-name-function'

`compilation-exit-message-function'

`compilation-finish-function'

`compilation-parse-errors-function'

`compilation-mode-hook'

`create-console-hook'

`create-device-hook'

`create-frame-hook'

`dabbrev-friend-buffer-function'

`dabbrev-select-buffers-function'

`delete-console-hook'

`delete-device-hook'

`delete-frame-hook'

`deselect-frame-hook'

`diary-display-hook'

`diary-hook'

`dired-after-readin-hook'

`dired-before-readin-hook'

`dired-load-hook'

`dired-mode-hook'

`disabled-command-hook'

`display-buffer-function'

`ediff-after-setup-control-frame-hook'

`ediff-after-setup-windows-hook'

`ediff-before-setup-control-frame-hook'

`ediff-before-setup-windows-hook'

`ediff-brief-help-message-function'

`ediff-cleanup-hook'

`ediff-control-frame-position-function'

`ediff-display-help-hook'

`ediff-focus-on-regexp-matches-function'

`ediff-forward-word-function'

`ediff-hide-regexp-matches-function'

`ediff-keymap-setup-hook'

`ediff-load-hook'

`ediff-long-help-message-function'

`ediff-make-wide-display-function'

`ediff-merge-split-window-function'

`ediff-meta-action-function'

`ediff-meta-redraw-function'

`ediff-mode-hook'

`ediff-prepare-buffer-hook'

`ediff-quit-hook'

`ediff-registry-setup-hook'

`ediff-select-hook'

`ediff-session-action-function'

`ediff-session-group-setup-hook'

`ediff-setup-diff-regions-function'

`ediff-show-registry-hook'

`ediff-show-session-group-hook'

`ediff-skip-diff-region-function'

`ediff-split-window-function'

`ediff-startup-hook'

`ediff-suspend-hook'

`ediff-toggle-read-only-function'

`ediff-unselect-hook'

`ediff-window-setup-function'

`edit-picture-hook'

`electric-buffer-menu-mode-hook'

`electric-command-history-hook'

`electric-help-mode-hook'

`emacs-lisp-mode-hook'

`fill-paragraph-function'

`find-file-hooks'

`find-file-not-found-hooks'

`first-change-hook'

`font-lock-after-fontify-buffer-hook'

`font-lock-beginning-of-syntax-function'

`font-lock-mode-hook'

`fume-found-function-hook'

`fume-list-mode-hook'

`fume-rescan-buffer-hook'

`fume-sort-function'

`gnus-startup-hook'

`hack-local-variables-hook'

`highlight-headers-follow-url-function'

`hyper-apropos-mode-hook'

`indent-line-function'

`indent-mim-hook'

`indent-region-function'

`initial-calendar-window-hook'

`isearch-mode-end-hook'

`isearch-mode-hook'

`java-mode-hook'

`kill-buffer-hook'

`kill-buffer-query-functions'

`kill-emacs-hook'

`kill-emacs-query-functions'

`kill-hooks'

`LaTeX-mode-hook'

`latex-mode-hook'

`ledit-mode-hook'

`lisp-indent-function'

`lisp-interaction-mode-hook'

`lisp-mode-hook'

`list-diary-entries-hook'

`load-read-function'

`log-message-filter-function'

`m2-mode-hook'

`mail-citation-hook'

`mail-mode-hook'

`mail-setup-hook'

`make-annotation-hook'

`makefile-mode-hook'

`map-frame-hook'

`mark-diary-entries-hook'

`medit-mode-hook'

`menu-no-selection-hook'

`mh-compose-letter-hook'

`mh-folder-mode-hook'

`mh-letter-mode-hook'

`mim-mode-hook'

`minibuffer-exit-hook'

`minibuffer-setup-hook'

`mode-motion-hook'

`mouse-enter-frame-hook'

`mouse-leave-frame-hook'

`mouse-track-cleanup-hook'

`mouse-track-click-hook'

`mouse-track-down-hook'

`mouse-track-drag-hook'

`mouse-track-drag-up-hook'

`mouse-track-up-hook'

`mouse-yank-function'

`news-mode-hook'

`news-reply-mode-hook'

`news-setup-hook'

`nongregorian-diary-listing-hook'

`nongregorian-diary-marking-hook'

`nroff-mode-hook'

`objc-mode-hook'

`outline-mode-hook'

`perl-mode-hook'

`plain-TeX-mode-hook'

`post-command-hook'

`post-gc-hook'

`pre-abbrev-expand-hook'

`pre-command-hook'

`pre-display-buffer-function'

`pre-gc-hook'

`pre-idle-hook'

`print-diary-entries-hook'

`prolog-mode-hook'

`protect-innocence-hook'

`remove-message-hook'

`revert-buffer-function'

`revert-buffer-insert-contents-function'

`rmail-edit-mode-hook'

`rmail-mode-hook'

`rmail-retry-setup-hook'

`rmail-summary-mode-hook'

`scheme-indent-hook'

`scheme-mode-hook'

`scribe-mode-hook'

`select-frame-hook'

`send-mail-function'

`shell-mode-hook'

`shell-set-directory-error-hook'

`special-display-function'

`suspend-hook'

`suspend-resume-hook'

`temp-buffer-show-function'

`term-setup-hook'

`terminal-mode-hook'

`terminal-mode-break-hook'

`TeX-mode-hook'

`tex-mode-hook'

`text-mode-hook'

`today-visible-calendar-hook'

`today-invisible-calendar-hook'

`tooltalk-message-handler-hook'

`tooltalk-pattern-handler-hook'

`tooltalk-unprocessed-message-hook'

`unmap-frame-hook'

`vc-checkin-hook'

`vc-checkout-writable-buffer-hook'

`vc-log-after-operation-hook'

`vc-make-buffer-writable-hook'

`view-hook'

`vm-arrived-message-hook'

`vm-arrived-messages-hook'

`vm-chop-full-name-function'

`vm-display-buffer-hook'

`vm-edit-message-hook'

`vm-forward-message-hook'

`vm-iconify-frame-hook'

`vm-inhibit-write-file-hook'

`vm-key-functions'

`vm-mail-hook'

`vm-mail-mode-hook'

`vm-menu-setup-hook'

`vm-mode-hook'

`vm-quit-hook'

`vm-rename-current-buffer-function'

`vm-reply-hook'

`vm-resend-bounced-message-hook'

`vm-resend-message-hook'

`vm-retrieved-spooled-mail-hook'

`vm-select-message-hook'

`vm-select-new-message-hook'

`vm-select-unread-message-hook'

`vm-send-digest-hook'

`vm-summary-mode-hook'

`vm-summary-pointer-update-hook'

`vm-summary-redo-hook'

`vm-summary-update-hook'

`vm-undisplay-buffer-hook'

`vm-visit-folder-hook'

`window-setup-hook'

`write-contents-hooks'

`write-file-data-hooks'

`write-file-hooks'

`write-region-annotate-functions'

`x-lost-selection-hooks'

`x-sent-selection-hooks'

`zmacs-activate-region-hook'

`zmacs-deactivate-region-hook'

`zmacs-update-region-hook'

