--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/man/lispref/specifiers.texi	Mon Aug 13 08:45:50 2007 +0200
@@ -0,0 +1,1056 @@
+@c -*-texinfo-*-
+@c This is part of the XEmacs Lisp Reference Manual.
+@c Copyright (C) 1995, 1996 Ben Wing.
+@c See the file lispref.texi for copying conditions.
+@setfilename ../../info/specifiers.info
+@node Specifiers, Faces and Window-System Objects, Extents, top
+@chapter Specifiers
+@cindex specifier
+
+A specifier is an object used to keep track of a property whose value
+may vary depending on the particular situation (e.g. particular buffer
+displayed in a particular window) that it is used in.  The value of many
+built-in properties, such as the font, foreground, background, and such
+properties of a face and variables such as
+@code{modeline-shadow-thickness} and @code{top-toolbar-height}, is
+actually a specifier object.  The specifier object, in turn, is
+``instanced'' in a particular situation to yield the real value
+of the property in that situation.
+
+@defun specifierp object
+This function returns non-@code{nil} if @var{object} is a specifier.
+@end defun
+
+@menu
+* Introduction to Specifiers::	Specifiers provide a clean way for
+				display and other properties to vary
+				(under user control) in a wide variety
+				of contexts.
+* Specifiers In-Depth::		Gory details about specifier innards.
+* Specifier Instancing::	Instancing means obtaining the ``value'' of
+				a specifier in a particular context.
+* Specifier Types::		Specifiers come in different flavors.
+* Adding Specifications::	Specifications control a specifier's ``value''
+				by giving conditions under which a
+				particular value is valid.
+* Retrieving Specifications::	Querying a specifier's specifications.
+* Specifier Tag Functions::	Working with specifier tags.
+* Specifier Instancing Functions::
+				Functions to instance a specifier.
+* Specifier Example::		Making all this stuff clearer.
+* Creating Specifiers::		Creating specifiers for your own use.
+* Specifier Validation Functions::
+				Validating the components of a specifier.
+* Other Specification Functions::
+				Other ways of working with specifications.
+@end menu
+
+@node Introduction to Specifiers
+@section Introduction to Specifiers
+
+Sometimes you may want the value of a property to vary depending on
+the context the property is used in.  A simple example of this in XEmacs
+is buffer-local variables.  For example, the variable
+@code{modeline-format}, which controls the format of the modeline, can
+have different values depending on the particular buffer being edited.
+The variable has a default value which most modes will use, but a
+specialized package such as Calendar might change the variable so
+as to tailor the modeline to its own purposes.
+
+Other properties (such as those that can be changed by the
+@code{modify-frame-parameters} function, for example the color of the
+text cursor) can have frame-local values, although it might also make
+sense for them to have buffer-local values.  In other cases, you might
+want the property to vary depending on the particular window within the
+frame that applies (e.g. the top or bottom window in a split frame), the
+device type that that frame appears on (X or tty), etc.  Perhaps you can
+envision some more complicated scenario where you want a particular
+value in a specified buffer, another value in all other buffers
+displayed on a particular frame, another value in all other buffers
+displayed in all other frames on any mono (two-color, e.g. black and
+white only) displays, and a default value in all other circumstances.
+
+A @dfn{specifier} is a generalization of this, allowing a great deal
+of flexibility in controlling exactly what value a property has in which
+circumstances.  It is most commonly used for display properties, such as
+an image or the foreground color of a face.  As a simple example, you can
+specify that the foreground of the default face be
+
+@itemize @bullet
+@item
+blue for a particular buffer
+@item
+green for all other buffers
+@end itemize
+
+As a more complicated example, you could specify that the foreground of
+the default face be
+
+@itemize @bullet
+@item
+forest green for all buffers displayed in a particular Emacs window, or
+green if the X server doesn't recognize the color @samp{forest green}
+@item
+blue for all buffers displayed in a particular frame
+@item
+red for all other buffers displayed on a color device
+@item
+white for all other buffers
+@end itemize
+
+@node Specifiers In-Depth
+@section In-Depth Overview of a Specifier
+@cindex specification (in a specifier)
+@cindex domain (in a specifier)
+@cindex locale (in a specifier)
+@cindex instantiator (in a specifier)
+@cindex instancing (in a specifier)
+@cindex instance (in a specifier)
+@cindex inst-list (in a specifier)
+@cindex inst-pair (in a specifier)
+@cindex tag (in a specifier)
+@cindex tag set (in a specifier)
+@cindex specifier, specification
+@cindex specifier, domain
+@cindex specifier, locale
+@cindex specifier, instantiator
+@cindex specifier, instancing
+@cindex specifier, instance
+@cindex specifier, inst-list
+@cindex specifier, inst-pair
+@cindex specifier, tag
+@cindex specifier, tag set
+
+A specifier object encapsulates a set of @dfn{specifications}, each of
+which says what its value should be if a particular condition applies.
+For example, one specification might be ``The value should be
+darkseagreen2 on X devices'' another might be ``The value should be blue
+in the *Help* buffer''.  In specifier terminology, these conditions are
+called @dfn{locales} and the values are called @dfn{instantiators}.
+Given a specifier, a logical question is ``What is its value in a
+particular situation?'' This involves looking through the specifications
+to see which ones apply to this particular situation, and perhaps
+preferring one over another if more than one applies.  In specifier
+terminology, a ``particular situation'' is called a @dfn{domain}, and
+determining its value in a particular domain is called @dfn{instancing}.
+Most of the time, a domain is identified by a particular window.  For
+example, if the redisplay engine is drawing text in the default face in
+a particular window, it retrieves the specifier for the foreground color
+of the default face and @dfn{instances} it in the domain given by that
+window; in other words, it asks the specifier, ``What is your value in
+this window?''.
+
+More specifically, a specifier contains a set of @dfn{specifications},
+each of which associates a @dfn{locale} (a buffer object, a window
+object, a frame object, a device object, or the symbol @code{global})
+with an @dfn{inst-list}, which is a list of one or more
+@dfn{inst-pairs}. (For each possible locale, there can be at most one
+specification containing that locale.) Each inst-pair is a cons of a
+@dfn{tag set} (an unordered list of zero or more symbols, or @dfn{tags})
+and an @dfn{instantiator} (the allowed form of this varies depending on
+the type of specifier).  In a given specification, there may be more
+than one inst-pair with the same tag set; this is unlike for locales.
+
+The tag set is used to restrict the sorts of devices over which the
+instantiator is valid and to uniquely identify instantiators added by a
+particular application, so that different applications can work on the
+same specifier and not interfere with each other.  Each tag can have a
+@dfn{predicate} associated with it, which is a function of one argument
+(a device) that specifies whether the tag matches that particular
+device. (If a tag does not have a predicate, it matches all devices.)
+All tags in a tag set must match a device for the associated inst-pair
+to be instantiable over that device.  (A null tag set is perfectly
+valid.)
+
+The valid device types (normally @code{x}, @code{tty}, and
+@code{stream}) and device classes (normally @code{color},
+@code{grayscale}, and @code{mono}) can always be used as tags, and match
+devices of the associated type or class (@pxref{Consoles and Devices}).
+User-defined tags may be defined, with an optional predicate specified.
+An application can create its own tag, use it to mark all its
+instantiators, and be fairly confident that it will not interfere with
+other applications that modify the same specifier -- Functions that add
+a specification to a specifier usually only overwrite existing
+inst-pairs with the same tag set as was given, and a particular tag or
+tag set can be specified when removing instantiators.
+
+When a specifier is instanced in a domain, both the locale and the tag
+set can be viewed as specifying necessary conditions that must apply in
+that domain for an instantiator to be considered as a possible result of
+the instancing.  More specific locales always override more general
+locales (thus, there is no particular ordering of the specifications in
+a specifier); however, the tag sets are simply considered in the order
+that the inst-pairs occur in the specification's inst-list.
+
+Note also that the actual object that results from the instancing
+(called an @dfn{instance object}) may not be the same as the instantiator
+from which it was derived.  For some specifier types (such as integer
+specifiers and boolean specifiers), the instantiator will be returned
+directly as the instance object.  For other types, however, this
+is not the case.  For example, for font specifiers, the instantiator
+is a font-description string and the instance object is a font-instance
+object, which describes how the font is displayed on a particular device.
+A font-instance object encapsulates such things as the actual font name
+used to display the font on that device (a font-description string
+under X is usually a wildcard specification that may resolve to
+different font names, with possibly different foundries, widths, etc.,
+on different devices), the extra properties of that font on that
+device, etc.  Furthermore, this conversion (called @dfn{instantiation})
+might fail -- a font or color might not exist on a particular device,
+for example.
+
+@node Specifier Instancing
+@section How a Specifier Is Instanced
+@cindex fallback (in a specifier)
+@cindex specifier, fallback
+
+Instancing of a specifier in a particular window domain proceeds as
+follows:
+
+@itemize @bullet
+@item
+First, XEmacs searches for a specification whose locale is the same as
+the window's buffer.  If that fails, the search is repeated, looking for
+a locale that is the same as the window itself.  If that fails, the
+search is repeated using the window's frame, then using the device that
+frame is on.  Finally, the specification whose locale is the symbol
+@code{global} (if there is such a specification) is considered.
+@item
+The inst-pairs contained in the specification that was found are
+considered in their order in the inst-list, looking for one whose tag
+set matches the device that is derived from the window domain. (The
+tag set is an unordered list of zero or more tag symbols.  For all
+tags that have predicates associated with them, the predicate must
+match the device.)
+@item
+If a matching tag set is found, the corresponding instantiator is passed
+to the specifier's instantiation method, which is specific to the type
+of the specifier.  If it succeeds, the resulting instance object is
+returned as the result of the instancing and the instancing is done.
+Otherwise, the operation continues, looking for another matching
+inst-pair in the current specification.
+@item
+When there are no more inst-pairs to be considered in the current
+specification, the search starts over, looking for another specification
+as in the first step above.
+@item
+If all specifications are exhausted and no instance object can be
+derived, the instancing fails. (Actually, this is not completely true.
+Some specifier objects for built-in properties have a @dfn{fallback}
+value, which is either an inst-list or another specifier object, that is
+consulted if the instancing is about to fail.  If it is an inst-list,
+the searching proceeds using the inst-pairs in that list.  If it is a
+specifier, the entire instancing starts over using that specifier
+instead of the given one.  Fallback values are set by the C code and
+cannot be modified, except perhaps indirectly, using any Lisp functions.
+The purpose of them is to supply some values to make sure that
+instancing of built-in properties can't fail and to implement some basic
+specifier inheritance, such as the fact that faces inherit their
+properties from the @code{default} face.)
+@end itemize
+
+It is also possible to instance a specifier over a frame domain or
+device domain instead of over a window domain.  The C code, for example,
+instances the @code{top-toolbar-height} variable over a frame domain in
+order to determine the height of a frame's top toolbar.  Instancing over
+a frame or device is similar to instancing over a window except that
+specifications for locales that cannot be derived from the domain are
+ignored.  Specifically, instancing over a frame looks first for frame
+locales, then device locales, then the @code{global} locale.  Instancing
+over a device domain looks only for device locales and the @code{global}
+locale.
+
+@node Specifier Types
+@section Specifier Types
+
+There are various different types of specifiers.  The type of a
+specifier controls what sorts of instantiators are valid, how an
+instantiator is instantiated, etc.  Here is a list of built-in specifier
+types:
+
+@table @code
+@item boolean
+The valid instantiators are the symbols @code{t} and @code{nil}.
+Instance objects are the same as instantiators so no special
+instantiation function is needed.
+
+@item integer
+The valid instantiators are integers.  Instance objects are the same as
+instantiators so no special instantiation function is needed.
+@code{modeline-shadow-thickness} is an example of an integer specifier
+(negative thicknesses indicate that the shadow is drawn recessed instead
+of raised).
+
+@item natnum
+The valid instantiators are natnums (non-negative integers).  Instance
+objects are the same as instantiators so no special instantiation
+function is needed.  Natnum specifiers are used for dimension variables
+such as @code{top-toolbar-height}.
+
+@item generic
+All Lisp objects are valid instantiators.  Instance objects are the same
+as instantiators so no special instantiation function is needed.
+
+@item font
+The valid instantiators are strings describing fonts or vectors
+indicating inheritance from the font of some face.  Instance objects
+are font-instance objects, which are specific to a particular device.
+The instantiation method in this specifier can fail, unlike for
+integer, natnum, boolean, and generic specifiers.
+
+@item color
+The valid instantiators are strings describing colors or vectors
+indicating inheritance from the foreground or background of some face.
+Instance objects are color-instance objects, which are specific to a
+particular device.  The instantiation method in this specifier can fail,
+as for font specifiers.
+
+@item image
+Images are perhaps the most complicated type of built-in specifier.  The
+valid instantiators are strings (a filename, inline data for a pixmap,
+or text to be displayed in a text glyph) or vectors describing inline
+data of various sorts or indicating inheritance from the
+background-pixmap property of some face.  Instance objects are either
+strings (for text images), image-instance objects (for pixmap images),
+or subwindow objects (for subwindow images).  The instantiation method
+in this specifier can fail, as for font and color specifiers.
+
+@item face-boolean
+The valid instantiators are the symbols @code{t} and @code{nil} and
+vectors indicating inheritance from a boolean property of some face.
+Specifiers of this sort are used for all of the built-in boolean
+properties of faces.  Instance objects are either the symbol @code{t}
+or the symbol @code{nil}.
+
+@item toolbar
+The valid instantiators are toolbar descriptors, which are lists
+of toolbar-button descriptors (each of which is a vector of two
+or four elements).  @xref{Toolbar} for more information.
+@end table
+
+@xref{Faces and Window-System Objects} for more information on fonts,
+colors, and face-boolean specifiers.  @xref{Glyphs} for more information
+about image specifiers.  @xref{Toolbar} for more information on toolbar
+specifiers.
+
+@defun specifier-type specifier
+This function returns the type of @var{specifier}.  The returned value
+will be a symbol: one of @code{integer}, @code{boolean}, etc., as
+listed in the above table.
+@end defun
+
+Functions are also provided to query whether an object is a particular
+kind of specifier:
+
+@defun boolean-specifier-p object
+This function returns non-@code{nil} if @var{object} is a boolean
+specifier.
+@end defun
+
+@defun integer-specifier-p object
+This function returns non-@code{nil} if @var{object} is an integer
+specifier.
+@end defun
+
+@defun natnum-specifier-p object
+This function returns non-@code{nil} if @var{object} is a natnum
+specifier.
+@end defun
+
+@defun generic-specifier-p object
+This function returns non-@code{nil} if @var{object} is a generic
+specifier.
+@end defun
+
+@defun face-boolean-specifier-p object
+This function returns non-@code{nil} if @var{object} is a face-boolean
+specifier.
+@end defun
+
+@defun toolbar-specifier-p object
+This function returns non-@code{nil} if @var{object} is a toolbar
+specifier.
+@end defun
+
+@defun font-specifier-p object
+This function returns non-@code{nil} if @var{object} is a font
+specifier.
+@end defun
+
+@defun color-specifier-p object
+This function returns non-@code{nil} if @var{object} is a color
+specifier.
+@end defun
+
+@defun image-specifier-p object
+This function returns non-@code{nil} if @var{object} is an image
+specifier.
+@end defun
+
+@node Adding Specifications
+@section Adding specifications to a Specifier
+
+@defun add-spec-to-specifier specifier instantiator &optional locale tag-set how-to-add
+This function adds a specification to @var{specifier}.  The
+specification maps from @var{locale} (which should be a buffer, window,
+frame, device, or the symbol @code{global}, and defaults to
+@code{global}) to @var{instantiator}, whose allowed values depend on the
+type of the specifier.  Optional argument @var{tag-set} limits the
+instantiator to apply only to the specified tag set, which should be a
+list of tags all of which must match the device being instantiated over
+(tags are a device type, a device class, or tags defined with
+@code{define-specifier-tag}).  Specifying a single symbol for
+@var{tag-set} is equivalent to specifying a one-element list containing
+that symbol.  Optional argument @var{how-to-add} specifies what to do if
+there are already specifications in the specifier.  It should be one of
+
+@table @code
+@item prepend
+Put at the beginning of the current list of instantiators for @var{locale}.
+@item append
+Add to the end of the current list of instantiators for @var{locale}.
+@item remove-tag-set-prepend
+This is the default.  Remove any existing instantiators whose tag set is
+the same as @var{tag-set}; then put the new instantiator at the
+beginning of the current list.
+@item remove-tag-set-append
+Remove any existing instantiators whose tag set is the same as
+@var{tag-set}; then put the new instantiator at the end of the current
+list.
+@item remove-locale
+Remove all previous instantiators for this locale before adding the new
+spec.
+@item remove-locale-type
+Remove all specifications for all locales of the same type as
+@var{locale} (this includes @var{locale} itself) before adding the new
+spec.
+@item remove-all
+Remove all specifications from the specifier before adding the new spec.
+@end table
+
+@code{remove-tag-set-prepend} is the default.
+
+You can retrieve the specifications for a particular locale or locale type
+with the function @code{specifier-spec-list} or @code{specifier-specs}.
+@end defun
+
+@defun add-spec-list-to-specifier specifier spec-list &optional how-to-add
+This function adds a @dfn{spec-list} (a list of specifications) to
+@var{specifier}.  The format of a spec-list is
+
+@example
+  @code{((@var{locale} (@var{tag-set} . @var{instantiator}) ...) ...)}
+@end example
+
+where
+
+@itemize @bullet
+@item
+@var{locale} := a buffer, a window, a frame, a device, or @code{global}
+@item
+@var{tag-set} := an unordered list of zero or more @var{tags}, each of
+which is a symbol
+@item
+@var{tag} := a device class (@pxref{Consoles and Devices}), a device type,
+or a tag defined with @code{define-specifier-tag}
+@item
+@var{instantiator} := format determined by the type of specifier
+@end itemize
+
+The pair @code{(@var{tag-set} . @var{instantiator})} is called an
+@dfn{inst-pair}.  A list of inst-pairs is called an @dfn{inst-list}.
+The pair @code{(@var{locale} . @var{inst-list})} is called a
+@dfn{specification}.  A spec-list, then, can be viewed as a list of
+specifications.
+
+@var{how-to-add} specifies how to combine the new specifications with
+the existing ones, and has the same semantics as for
+@code{add-spec-to-specifier}.
+
+In many circumstances, the higher-level function @code{set-specifier} is
+more convenient and should be used instead.
+@end defun
+
+@defun set-specifier specifier value &optional how-to-add
+This function adds some specifications to @var{specifier}.  @var{value}
+can be a single instantiator or tagged instantiator (added as a global
+specification), a list of tagged and/or untagged instantiators (added as
+a global specification), a cons of a locale and instantiator or locale
+and instantiator list, a list of such conses, or nearly any other
+reasonable form.  More specifically, @var{value} can be anything
+accepted by @code{canonicalize-spec-list}.
+
+@var{how-to-add} is the same as in @code{add-spec-to-specifier}.
+
+Note that @code{set-specifier} is exactly complementary to
+@code{specifier-specs} except in the case where @var{specifier} has no
+specs at all in it but @code{nil} is a valid instantiator (in that case,
+@code{specifier-specs} will return @code{nil} (meaning no specs) and
+@code{set-specifier} will interpret the @code{nil} as meaning ``I'm
+adding a global instantiator and its value is @code{nil}''), or in
+strange cases where there is an ambiguity between a spec-list and an
+inst-list, etc. (The built-in specifier types are designed in such a way
+as to avoid any such ambiguities.)
+
+If you want to work with spec-lists, you should probably not use these
+functions, but should use the lower-level functions
+@code{specifier-spec-list} and @code{add-spec-list-to-specifier}.  These
+functions always work with fully-qualified spec-lists; thus, there is no
+ambiguity.
+@end defun
+
+@defun canonicalize-inst-pair inst-pair specifier-type &optional noerror
+This function canonicalizes the given @var{inst-pair}.
+
+@var{specifier-type} specifies the type of specifier that this
+@var{spec-list} will be used for.
+
+Canonicalizing means converting to the full form for an inst-pair, i.e.
+@code{(@var{tag-set} . @var{instantiator})}.  A single, untagged
+instantiator is given a tag set of @code{nil} (the empty set), and a
+single tag is converted into a tag set consisting only of that tag.
+
+If @var{noerror} is non-@code{nil}, signal an error if the inst-pair is
+invalid; otherwise return @code{t}.
+@end defun
+
+@defun canonicalize-inst-list inst-list specifier-type &optional noerror
+This function canonicalizes the given @var{inst-list} (a list of
+inst-pairs).
+
+@var{specifier-type} specifies the type of specifier that this @var{inst-list}
+will be used for.
+
+Canonicalizing means converting to the full form for an inst-list, i.e.
+@code{((@var{tag-set} . @var{instantiator}) ...)}.  This function
+accepts a single inst-pair or any abbrevation thereof or a list of
+(possibly abbreviated) inst-pairs. (See @code{canonicalize-inst-pair}.)
+
+If @var{noerror} is non-@code{nil}, signal an error if the inst-list is
+invalid; otherwise return @code{t}.
+@end defun
+
+@defun canonicalize-spec spec specifier-type &optional noerror
+This function canonicalizes the given @var{spec} (a specification).
+
+@var{specifier-type} specifies the type of specifier that this
+@var{spec-list} will be used for.
+
+Canonicalizing means converting to the full form for a spec, i.e.
+@code{(@var{locale} (@var{tag-set} . @var{instantiator}) ...)}.  This
+function accepts a possibly abbreviated inst-list or a cons of a locale
+and a possibly abbreviated inst-list. (See
+@code{canonicalize-inst-list}.)
+
+If @var{noerror} is @code{nil}, signal an error if the specification is
+invalid; otherwise return @code{t}.
+@end defun
+
+@defun canonicalize-spec-list spec-list specifier-type &optional noerror
+This function canonicalizes the given @var{spec-list} (a list of
+specifications).
+
+@var{specifier-type} specifies the type of specifier that this
+@var{spec-list} will be used for.
+
+Canonicalizing means converting to the full form for a spec-list, i.e.
+@code{((@var{locale} (@var{tag-set} . @var{instantiator}) ...) ...)}.
+This function accepts a possibly abbreviated specification or a list of
+such things. (See @code{canonicalize-spec}.) This is the function used
+to convert spec-lists accepted by @code{set-specifier} and such into a
+form suitable for @code{add-spec-list-to-specifier}.
+
+This function tries extremely hard to resolve any ambiguities,
+and the built-in specifier types (font, image, toolbar, etc.) are
+designed so that there won't be any ambiguities.
+
+If @var{noerror} is @code{nil}, signal an error if the spec-list is
+invalid; otherwise return @code{t}.
+@end defun
+
+@node Retrieving Specifications
+@section Retrieving the Specifications from a Specifier
+
+@defun specifier-spec-list specifier &optional locale tag-set exact-p
+This function returns the spec-list of specifications for
+@var{specifier} in @var{locale}.
+
+If @var{locale} is a particular locale (a buffer, window, frame, device,
+or the symbol @code{global}), a spec-list consisting of the
+specification for that locale will be returned.
+
+If @var{locale} is a locale type (i.e. a symbol @code{buffer},
+@code{window}, @code{frame}, or @code{device}), a spec-list of the
+specifications for all locales of that type will be returned.
+
+If @var{locale} is @code{nil} or the symbol @code{all}, a spec-list of
+all specifications in @var{specifier} will be returned.
+
+@var{locale} can also be a list of locales, locale types, and/or
+@code{all}; the result is as if @code{specifier-spec-list} were called
+on each element of the list and the results concatenated together.
+
+Only instantiators where @var{tag-set} (a list of zero or more tags) is
+a subset of (or possibly equal to) the instantiator's tag set are
+returned.  (The default value of@code{ nil} is a subset of all tag sets,
+so in this case no instantiators will be screened out.) If @var{exact-p}
+is non-@code{nil}, however, @var{tag-set} must be equal to an
+instantiator's tag set for the instantiator to be returned.
+@end defun
+
+@defun specifier-specs specifier &optional locale tag-set exact-p
+This function returns the specification(s) for @var{specifier} in
+@var{locale}.
+
+If @var{locale} is a single locale or is a list of one element
+containing a single locale, then a ``short form'' of the instantiators
+for that locale will be returned.  Otherwise, this function is identical
+to @code{specifier-spec-list}.
+
+The ``short form'' is designed for readability and not for ease of use
+in Lisp programs, and is as follows:
+
+@enumerate
+@item
+If there is only one instantiator, then an inst-pair (i.e. cons of tag
+and instantiator) will be returned; otherwise a list of inst-pairs will
+be returned.
+@item
+For each inst-pair returned, if the instantiator's tag is @code{any},
+the tag will be removed and the instantiator itself will be returned
+instead of the inst-pair.
+@item
+If there is only one instantiator, its value is @code{nil}, and its tag
+is @code{any}, a one-element list containing @code{nil} will be returned
+rather than just @code{nil}, to distinguish this case from there being
+no instantiators at all.
+@end enumerate
+
+@end defun
+
+@defun specifier-fallback specifier
+This function returns the fallback value for @var{specifier}.  Fallback
+values are provided by the C code for certain built-in specifiers to
+make sure that instancing won't fail even if all specs are removed from
+the specifier, or to implement simple inheritance behavior (e.g. this
+method is used to ensure that faces other than @code{default} inherit
+their attributes from @code{default}).  By design, you cannot change the
+fallback value, and specifiers created with @code{make-specifier} will
+never have a fallback (although a similar, Lisp-accessible capability
+may be provided in the future to allow for inheritance).
+
+The fallback value will be an inst-list that is instanced like
+any other inst-list, a specifier of the same type as @var{specifier}
+(results in inheritance), or @code{nil} for no fallback.
+
+When you instance a specifier, you can explicitly request that the
+fallback not be consulted. (The C code does this, for example, when
+merging faces.) See @code{specifier-instance}.
+@end defun
+
+@node Specifier Tag Functions
+@section Working With Specifier Tags
+
+A specifier tag set is an entity that is attached to an instantiator
+and can be used to restrict the scope of that instantiator to a
+particular device class or device type and/or to mark instantiators
+added by a particular package so that they can be later removed.
+
+A specifier tag set consists of a list of zero of more specifier tags,
+each of which is a symbol that is recognized by XEmacs as a tag.  (The
+valid device types and device classes are always tags, as are any tags
+defined by @code{define-specifier-tag}.) It is called a ``tag set'' (as
+opposed to a list) because the order of the tags or the number of times
+a particular tag occurs does not matter.
+
+Each tag has a predicate associated with it, which specifies whether
+that tag applies to a particular device.  The tags which are device
+types and classes match devices of that type or class.  User-defined
+tags can have any predicate, or none (meaning that all devices match).
+When attempting to instance a specifier, a particular instantiator is
+only considered if the device of the domain being instanced over matches
+all tags in the tag set attached to that instantiator.
+
+Most of the time, a tag set is not specified, and the instantiator gets
+a null tag set, which matches all devices.
+
+@defun valid-specifier-tag-p tag
+This function returns non-@code{nil} if @var{tag} is a valid specifier
+tag.
+@end defun
+
+@defun valid-specifier-tag-set-p tag-set
+This function returns non-@code{nil} if @var{tag-set} is a valid
+specifier tag set.
+@end defun
+
+@defun canonicalize-tag-set tag-set
+This function canonicalizes the given tag set.  Two canonicalized tag
+sets can be compared with @code{equal} to see if they represent the same
+tag set. (Specifically, canonicalizing involves sorting by symbol name
+and removing duplicates.)
+@end defun
+
+@defun device-matches-specifier-tag-set-p device tag-set
+This function returns non-@code{nil} if @var{device} matches specifier
+tag set @var{tag-set}.  This means that @var{device} matches each tag in
+the tag set.
+@end defun
+
+@defun define-specifier-tag tag &optional predicate
+This function defines a new specifier tag.  If @var{predicate} is
+specified, it should be a function of one argument (a device) that
+specifies whether the tag matches that particular device.  If
+@var{predicate} is omitted, the tag matches all devices.
+
+You can redefine an existing user-defined specifier tag.  However, you
+cannot redefine the built-in specifier tags (the device types and
+classes) or the symbols @code{nil}, @code{t}, @code{all}, or
+@code{global}.
+@end defun
+
+@defun device-matching-specifier-tag-list &optional device
+This function returns a list of all specifier tags matching
+@var{device}.  @var{device} defaults to the selected device if omitted.
+@end defun
+
+@defun specifier-tag-list
+This function returns a list of all currently-defined specifier tags.
+This includes the built-in ones (the device types and classes).
+@end defun
+
+@defun specifier-tag-predicate tag
+This function returns the predicate for the given specifier tag.
+@end defun
+
+@node Specifier Instancing Functions
+@section Functions for Instancing a Specifier
+
+@defun specifier-instance specifier &optional domain default no-fallback
+This function instantiates @var{specifier} (return its value) in
+@var{domain}.  If no instance can be generated for this domain, return
+@var{default}.
+
+@var{domain} should be a window, frame, or device.  Other values that
+are legal as a locale (e.g. a buffer) are not valid as a domain because
+they do not provide enough information to identify a particular device
+(see @code{valid-specifier-domain-p}).  @var{domain} defaults to the
+selected window if omitted.
+
+@dfn{Instantiating} a specifier in a particular domain means determining
+the specifier's ``value'' in that domain.  This is accomplished by
+searching through the specifications in the specifier that correspond to
+all locales that can be derived from the given domain, from specific to
+general.  In most cases, the domain is an Emacs window.  In that case
+specifications are searched for as follows:
+
+@enumerate
+@item
+A specification whose locale is the window's buffer;
+@item
+A specification whose locale is the window itself;
+@item
+A specification whose locale is the window's frame;
+@item
+A specification whose locale is the window's frame's device;
+@item
+A specification whose locale is the symbol @code{global}.
+@end enumerate
+
+If all of those fail, then the C-code-provided fallback value for this
+specifier is consulted (see @code{specifier-fallback}).  If it is an
+inst-list, then this function attempts to instantiate that list just as
+when a specification is located in the first five steps above.  If the
+fallback is a specifier, @code{specifier-instance} is called recursively
+on this specifier and the return value used.  Note, however, that if the
+optional argument @var{no-fallback} is non-@code{nil}, the fallback
+value will not be consulted.
+
+Note that there may be more than one specification matching a particular
+locale; all such specifications are considered before looking for any
+specifications for more general locales.  Any particular specification
+that is found may be rejected because it is tagged to a particular
+device class (e.g. @code{color}) or device type (e.g. @code{x}) or both
+and the device for the given domain does not match this, or because the
+specification is not valid for the device of the given domain (e.g.  the
+font or color name does not exist for this particular X server).
+
+The returned value is dependent on the type of specifier.  For example,
+for a font specifier (as returned by the @code{face-font} function), the
+returned value will be a font-instance object.  For images, the returned
+value will be a string, pixmap, or subwindow.
+@end defun
+
+@defun specifier-instance-from-inst-list specifier domain inst-list &optional default
+This function attempts to convert a particular inst-list into an
+instance.  This attempts to instantiate @var{inst-list} in the given
+@var{domain}, as if @var{inst-list} existed in a specification in
+@var{specifier}.  If the instantiation fails, @var{default} is returned.
+In most circumstances, you should not use this function; use
+@code{specifier-instance} instead.
+@end defun
+
+@node Specifier Example
+@section Example of Specifier Usage
+
+Now let us present an example to clarify the theoretical discussions we
+have been through.  In this example, we will use the general specifier
+functions for clarity.  Keep in mind that many types of specifiers, and
+some other types of objects that are associated with specifiers
+(e.g. faces), provide convenience functions making it easier to work
+with objects of that type.
+
+Let us consider the background color of the default face.  A specifier
+is used to specify how that color will appear in different domains.
+First, let's retrieve the specifier:
+
+@example
+(setq sp (face-property 'default 'background))
+    @result{}   #<color-specifier 0x3da>
+@end example
+
+@example
+(specifier-specs sp)
+    @result{}   ((#<buffer "device.c"> (nil . "forest green"))
+                 (#<window on "Makefile" 0x8a2b> (nil . "hot pink"))
+                 (#<x-frame "emacs" 0x4ac> (nil . "puke orange")
+					   (nil . "moccasin"))
+                 (#<x-frame "VM" 0x4ac> (nil . "magenta"))
+		 (global ((tty) . "cyan") (nil . "white"))
+                )
+@end example
+
+Then, say we want to determine what the background color of the default
+face is for the window currently displaying the buffer @samp{*scratch*}.
+We call
+
+@example
+(get-buffer-window "*scratch*")
+    @result{} #<window on "*scratch*" 0x4ad>
+(window-frame (get-buffer-window "*scratch*"))
+    @result{} #<x-frame "emacs" 0x4ac>
+(specifier-instance sp (get-buffer-window "*scratch*"))
+    @result{} #<color-instance moccasin 47=(FFFF,E4E4,B5B5) 0x6309>
+@end example
+
+Note that we passed a window to @code{specifier-instance}, not a buffer.
+We cannot pass a buffer because a buffer by itself does not provide enough
+information.  The buffer might not be displayed anywhere at all, or
+could be displayed in many different frames on different devices.
+
+The result is arrived at like this:
+
+@enumerate
+@item
+First, we look for a specification matching the buffer displayed in the
+window, i.e. @samp{*scratch}.  There are none, so we proceed.
+@item
+Then, we look for a specification matching the window itself.  Again, there
+are none.
+@item
+Then, we look for a specification matching the window's frame.  The
+specification @code{(#<x-frame "emacs" 0x4ac> . "puke orange")} is
+found.  We call the instantiation method for colors, passing it the
+locale we were searching over (i.e. the window, in this case) and the
+instantiator (@samp{"puke orange"}).  However, the particular device
+which this window is on (let's say it's an X connection) doesn't
+recognize the color @samp{"puke orange"}, so the specification is
+rejected.
+@item
+So we continue looking for a specification matching the window's frame.
+We find @samp{(#<x-frame "emacs" 0x4ac> . "moccasin")}.  Again, we
+call the instantiation method for colors.  This time, the X server
+our window is on recognizes the color @samp{moccasin}, and so the
+instantiation method succeeds and returns a color instance.
+@end enumerate
+
+@node Creating Specifiers
+@section Creating New Specifier Objects
+
+@defun make-specifier type
+This function creates a new specifier.
+
+A specifier is an object that can be used to keep track of a property
+whose value can be per-buffer, per-window, per-frame, or per-device,
+and can further be restricted to a particular device-type or device-class.
+Specifiers are used, for example, for the various built-in properties of a
+face; this allows a face to have different values in different frames,
+buffers, etc.  For more information, see `specifier-instance',
+`specifier-specs', and `add-spec-to-specifier'; or, for a detailed
+description of specifiers, including how they are instantiated over a
+particular domain (i.e. how their value in that domain is determined),
+see the chapter on specifiers in the XEmacs Lisp Reference Manual.
+
+@var{type} specifies the particular type of specifier, and should be one
+of the symbols @code{generic}, @code{integer}, @code{natnum},
+@code{boolean}, @code{color}, @code{font}, @code{image},
+@code{face-boolean}, or @code{toolbar}.
+
+For more information on particular types of specifiers, see the
+functions @code{generic-specifier-p}, @code{integer-specifier-p},
+@code{natnum-specifier-p}, @code{boolean-specifier-p},
+@code{color-specifier-p}, @code{font-specifier-p},
+@code{image-specifier-p}, @code{face-boolean-specifier-p}, and
+@code{toolbar-specifier-p}.
+@end defun
+
+@defun make-specifier-and-init type spec-list &optional dont-canonicalize
+This function creates and initialize a new specifier.
+
+This is a front-end onto @code{make-specifier} that allows you to create
+a specifier and add specs to it at the same time.  @var{type} specifies
+the specifier type.  @var{spec-list} supplies the specification(s) to be
+added to the specifier. Normally, almost any reasonable abbreviation of
+the full spec-list form is accepted, and is converted to the full form;
+however, if optional argument @var{dont-canonicalize} is non-@code{nil},
+this conversion is not performed, and the @var{spec-list} must already
+be in full form.  See @code{canonicalize-spec-list}.
+@end defun
+
+@node Specifier Validation Functions
+@section Functions for Checking the Validity of Specifier Components
+
+@defun valid-specifier-domain-p domain
+This function returns non-@code{nil} if @var{domain} is a valid
+specifier domain.  A domain is used to instance a specifier
+(i.e. determine the specifier's value in that domain).  Valid domains
+are a window, frame, or device.  (@code{nil} is not valid.)
+@end defun
+
+@defun valid-specifier-locale-p locale
+This function returns non-@code{nil} if @var{locale} is a valid
+specifier locale.  Valid locales are a device, a frame, a window, a
+buffer, and @code{global}.  (@code{nil} is not valid.)
+@end defun
+
+@defun valid-specifier-locale-type-p locale-type
+Given a specifier @var{locale-type}, this function returns non-nil if it
+is valid.  Valid locale types are the symbols @code{global},
+@code{device}, @code{frame}, @code{window}, and @code{buffer}. (Note,
+however, that in functions that accept either a locale or a locale type,
+@code{global} is considered an individual locale.)
+@end defun
+
+@defun valid-specifier-type-p specifier-type
+Given a @var{specifier-type}, this function returns non-@code{nil} if it
+is valid.  Valid types are @code{generic}, @code{integer},
+@code{boolean}, @code{color}, @code{font}, @code{image},
+@code{face-boolean}, and @code{toolbar}.
+@end defun
+
+@defun valid-specifier-tag-p tag
+This function returns non-@code{nil} if @var{tag} is a valid specifier
+tag.
+@end defun
+
+@defun valid-instantiator-p instantiator specifier-type
+This function returns non-@code{nil} if @var{instantiator} is valid for
+@var{specifier-type}.
+@end defun
+
+@defun valid-inst-list-p inst-list type
+This function returns non-@code{nil} if @var{inst-list} is valid for
+specifier type @var{type}.
+@end defun
+
+@defun valid-spec-list-p spec-list type
+This function returns non-@code{nil} if @var{spec-list} is valid for
+specifier type @var{type}.
+@end defun
+
+@defun check-valid-instantiator instantiator specifier-type
+This function signals an error if @var{instantiator} is invalid for
+@var{specifier-type}.
+@end defun
+
+@defun check-valid-inst-list inst-list type
+This function signals an error if @var{inst-list} is invalid for
+specifier type @var{type}.
+@end defun
+
+@defun check-valid-spec-list spec-list type
+This function signals an error if @var{spec-list} is invalid for
+specifier type @var{type}.
+@end defun
+
+@node Other Specification Functions
+@section Other Functions for Working with Specifications in a Specifier
+
+@defun copy-specifier specifier &optional dest locale tag-set exact-p how-to-add
+This function copies @var{specifier} to @var{dest}, or creates a new one
+if @var{dest} is @code{nil}.
+
+If @var{dest} is @code{nil} or omitted, a new specifier will be created
+and the specifications copied into it.  Otherwise, the specifications
+will be copied into the existing specifier in @var{dest}.
+
+If @var{locale} is @code{nil} or the symbol @code{all}, all
+specifications will be copied.  If @var{locale} is a particular locale,
+the specification for that particular locale will be copied.  If
+@var{locale} is a locale type, the specifications for all locales of
+that type will be copied.  @var{locale} can also be a list of locales,
+locale types, and/or @code{all}; this is equivalent to calling
+@code{copy-specifier} for each of the elements of the list.  See
+@code{specifier-spec-list} for more information about @var{locale}.
+
+Only instantiators where @var{tag-set} (a list of zero or more tags) is
+a subset of (or possibly equal to) the instantiator's tag set are
+copied.  (The default value of @code{nil} is a subset of all tag sets,
+so in this case no instantiators will be screened out.) If @var{exact-p}
+is non-@code{nil}, however, @var{tag-set} must be equal to an
+instantiator's tag set for the instantiator to be copied.
+
+Optional argument @var{how-to-add} specifies what to do with existing
+specifications in @var{dest}.  If nil, then whichever locales or locale
+types are copied will first be completely erased in @var{dest}.
+Otherwise, it is the same as in @code{add-spec-to-specifier}.
+@end defun
+
+@defun remove-specifier specifier &optional locale tag-set exact-p
+This function removes specification(s) for @var{specifier}.
+
+If @var{locale} is a particular locale (a buffer, window, frame, device,
+or the symbol @code{global}), the specification for that locale will be
+removed.
+
+If instead, @var{locale} is a locale type (i.e. a symbol @code{buffer},
+@code{window}, @code{frame}, or @code{device}), the specifications for
+all locales of that type will be removed.
+
+If @var{locale} is @code{nil} or the symbol @code{all}, all
+specifications will be removed.
+
+@var{locale} can also be a list of locales, locale types, and/or
+@code{all}; this is equivalent to calling @code{remove-specifier} for
+each of the elements in the list.
+
+Only instantiators where @var{tag-set} (a list of zero or more tags) is
+a subset of (or possibly equal to) the instantiator's tag set are
+removed.  (The default value of @code{nil} is a subset of all tag sets,
+so in this case no instantiators will be screened out.) If @var{exact-p}
+is non-@code{nil}, however, @var{tag-set} must be equal to an
+instantiator's tag set for the instantiator to be removed.
+@end defun
+
+@defun map-specifier specifier func &optional locale maparg
+This function applies @var{func} to the specification(s) for
+@var{locale} in @var{specifier}.
+
+If @var{locale} is a locale, @var{func} will be called for that locale.
+If @var{locale} is a locale type, @var{func} will be mapped over all
+locales of that type.  If @var{locale} is @code{nil} or the symbol
+@code{all}, @var{func} will be mapped over all locales in
+@var{specifier}.
+
+@var{func} is called with four arguments: the @var{specifier}, the
+locale being mapped over, the inst-list for that locale, and the
+optional @var{maparg}.  If any invocation of @var{func} returns
+non-@code{nil}, the mapping will stop and the returned value becomes the
+value returned from @code{map-specifier}.  Otherwise,
+@code{map-specifier} returns @code{nil}.
+@end defun
+
+@defun specifier-locale-type-from-locale locale
+Given a specifier @var{locale}, this function returns its type.
+@end defun
+