Jerry James  committed 9fae622

Silence texinfo 5.2 warnings, primarily by adding next, prev, and up
pointers to all nodes. See xemacs-patches message with ID

  • Participants
  • Parent commits dcf9067
  • Branches default

Comments (0)

Files changed (69)

+2014-02-11  Jerry James  <>
+	* .hgignore: Add man/Makefile.
 2013-10-28  Marcus Crestani  <>
 	* Disable ASLR on Mavericks.

File man/ChangeLog

+2014-02-11  Jerry James  <>
+	* lispref/consoles-devices.texi:
+	* lispref/control.texi:
+	* lispref/customize.texi:
+	* lispref/databases.texi:
+	* lispref/debugging.texi:
+	* lispref/dialog.texi:
+	* lispref/display.texi:
+	* lispref/eval.texi:
+	* lispref/extents.texi:
+	* lispref/faces.texi:
+	* lispref/files.texi:
+	* lispref/frames.texi:
+	* lispref/functions.texi:
+	* lispref/glyphs.texi:
+	* lispref/gutter.texi:
+	* lispref/hash-tables.texi:
+	* lispref/help.texi:
+	* lispref/internationalization.texi:
+	* lispref/intro.texi:
+	* lispref/keymaps.texi:
+	* lispref/ldap.texi:
+	* lispref/lispref.texi:
+	* lispref/lists.texi:
+	* lispref/loading.texi:
+	* lispref/macros.texi:
+	* lispref/markers.texi:
+	* lispref/menus.texi:
+	* lispref/minibuf.texi:
+	* lispref/modes.texi:
+	* lispref/mule.texi:
+	* lispref/numbers.texi:
+	* lispref/objects.texi:
+	* lispref/os.texi:
+	* lispref/positions.texi:
+	* lispref/postgresql.texi:
+	* lispref/processes.texi:
+	* lispref/range-tables.texi:
+	* lispref/scrollbars.texi:
+	* lispref/searching.texi:
+	* lispref/sequences.texi:
+	* lispref/specifiers.texi:
+	* lispref/streams.texi:
+	* lispref/strings.texi:
+	* lispref/symbols.texi:
+	* lispref/syntax.texi:
+	* lispref/text.texi:
+	* lispref/tips.texi:
+	* lispref/toolbar.texi:
+	* lispref/tooltalk.texi:
+	* lispref/variables.texi:
+	* lispref/windows.texi:
+	* lispref/x-windows.texi:
+	* xemacs/custom.texi:
+	* xemacs/menus.texi:
+	* xemacs/programs.texi:
+	Add next, prev, and up pointers to each node for texinfo 5.2.
+	* texinfo/fdl.texi:
+	* texinfo/texinfo.texi:
+	* texinfo/version.texi:
+	Sync with texinfo 5.2.
 2013-09-15  Mats Lidell  <>
 	* xemacs/files.texi (Saving): New variable

File man/internals/internals.texi

 and has attempted to be the "face" of XEmacs on the newsgroups and
 mailing lists.
-Steve Youngs, Ville Skyttand now Norbert Koch have taken turns
+Steve Youngs, Ville Skyttand now Norbert Koch have taken turns
 maintaining the packages.
 Vin Shelton maintains the stable releases.
-    @itemize
     they would be character->character and operate next to the
     internal data; this means that coding systems need to be able
     important: we need a way of specifying how detecting works
     when we have more than one coding system.  we might need more
     than a single priority list.  need to think about this.
-    @end itemize
     @end enumerate
   text when it's written out.  We need two levels
-    @itemize
     first, a "safe-charset" level that checks before any actual
     encoding to see if all characters in the document can safely
     same thing (error checking, list of alternatives, etc.) needs
     to happen when reading!  all of this will be a lot of work!
-    @end itemize
     @end enumerate
   @end itemize
 @end itemize

File man/lispref/abbrevs.texi

 * Standard Abbrev Tables::      Abbrev tables used by various major modes.
 @end menu
-@node Abbrev Mode
+@node Abbrev Mode, Abbrev Tables, Abbrevs, Abbrevs
 @section Setting Up Abbrev Mode
   Abbrev mode is a minor mode controlled by the value of the variable
 This is the same as @code{(default-value 'abbrev-mode)}.
 @end defvar
-@node Abbrev Tables
+@node Abbrev Tables, Defining Abbrevs, Abbrev Mode, Abbrevs
 @section Abbrev Tables
   This section describes how to create and manipulate abbrev tables.
 is currently defined.
 @end defun
-@node Defining Abbrevs
+@node Defining Abbrevs, Abbrev Files, Abbrev Tables, Abbrevs
 @section Defining Abbrevs
   These functions define an abbrev in a specified abbrev table.
 @end defopt
-@node Abbrev Files
+@node Abbrev Files, Abbrev Expansion, Defining Abbrevs, Abbrevs
 @section Saving Abbrevs in Files
   A file of saved abbrev definitions is actually a file of Lisp code.
 define the same abbrevs.  This function returns @code{nil}.
 @end deffn
-@node Abbrev Expansion
+@node Abbrev Expansion, Standard Abbrev Tables, Abbrev Files, Abbrevs
 @section Looking Up and Expanding Abbreviations
   Abbrevs are usually expanded by commands for interactive use,
           (error "Not expanding this abbrev"))))
 @end smallexample
-@node Standard Abbrev Tables
+@node Standard Abbrev Tables,  , Abbrev Expansion, Abbrevs
 @section Standard Abbrev Tables
   Here we list the variables that hold the abbrev tables for the

File man/lispref/annotations.texi

 @c Copyright (C) 1995 Ben Wing.
 @c See the file lispref.texi for copying conditions.
 @setfilename ../../info/
-@node Annotations, Display, Glyphs, top
+@node Annotations, Display, Glyphs, Top
 @chapter Annotations
 @cindex annotation
 				  annotation's lifetime.
 @end menu
-@node Annotation Basics
+@node Annotation Basics, Annotation Primitives, Annotations, Annotations
 @section Annotation Basics
 @cindex margin
 space to display in.
-@node Annotation Primitives
+@node Annotation Primitives, Annotation Properties, Annotation Basics, Annotations
 @section Annotation Primitives
 @defun make-annotation glyph &optional position layout buffer with-event d-glyph rightp
 @code{nil} otherwise.
 @end defun
-@node Annotation Properties
+@node Annotation Properties, Locating Annotations, Annotation Primitives, Annotations
 @section Annotation Properties
 @defun annotation-glyph annotation
 This function restores @var{annotation}'s glyph, making it visible.
 @end defun
-@node Locating Annotations
+@node Locating Annotations, Margin Primitives, Annotation Properties, Annotations
 @section Locating Annotations
 @defun annotations-in-region start end buffer
 @end defun
-@node Margin Primitives
+@node Margin Primitives, Annotation Hooks, Locating Annotations, Annotations
 @section Margin Primitives
 @cindex margin width
 @code{Emacs.left-margin.foreground}; likewise for the right margin.
-@node Annotation Hooks
+@node Annotation Hooks,  , Margin Primitives, Annotations
 @section Annotation Hooks
 @cindex annotation hooks

File man/lispref/backups.texi

 * Reverting::      @code{revert-buffer}, and how to customize what it does.
 @end menu
-@node Backup Files
+@node Backup Files, Auto-Saving, Backups and Auto-Saving, Backups and Auto-Saving
 @section Backup Files
 @cindex backup file
 * Backup Names::       How backup file names are computed; customization.
 @end menu
-@node Making Backups
+@node Making Backups, Rename or Copy, Backup Files, Backup Files
 @subsection Making Backup Files
 @defun backup-buffer
 @code{make-backup-files} instead.
 @end defvar
-@node Rename or Copy
+@node Rename or Copy, Numbered Backups, Making Backups, Backup Files
 @subsection Backup by Renaming or by Copying?
 @cindex backup files, how to make them
 @end defvar
-@node Numbered Backups
+@node Numbered Backups, Backup Names, Rename or Copy, Backup Files
 @subsection Making and Deleting Numbered Backup Files
   If a file's name is @file{foo}, the names of its numbered backup
 file.  The default value is 2.
 @end defopt
-@node Backup Names
+@node Backup Names,  , Numbered Backups, Backup Files
 @subsection Naming Backup Files
   The functions in this section are documented mainly because you can
 automatically compare a file with its most recent backup.
 @end defun
-@node Auto-Saving
+@node Auto-Saving, Reverting, Backup Files, Backups and Auto-Saving
 @section Auto-Saving
 @cindex auto-saving
 @end defvar
-@node Reverting
+@node Reverting,  , Auto-Saving, Backups and Auto-Saving
 @section Reverting
   If you have made extensive changes to a file and then change your mind

File man/lispref/buffers.texi

 * Indirect Buffers::    An indirect buffer shares text with some other buffer.
 @end menu
-@node Buffer Basics
+@node Buffer Basics, Current Buffer, Buffers, Buffers
 @section Buffer Basics
 @code{nil} otherwise.
 @end defun
-@node Current Buffer
+@node Current Buffer, Buffer Names, Buffer Basics, Buffers
 @section The Current Buffer
 @cindex selecting a buffer
 @cindex changing to another buffer
 identified by @var{buffer-or-name}.
 @end defun
-@node Buffer Names
+@node Buffer Names, Buffer File Name, Current Buffer, Buffers
 @section Buffer Names
 @cindex buffer names
 @end defun
-@node Buffer File Name
+@node Buffer File Name, Buffer Modification, Buffer Names, Buffers
 @section Buffer File Name
 @cindex visited file
 @cindex buffer file name
 visited file name.  Dired buffers use this variable.
 @end defvar
-@node Buffer Modification
+@node Buffer Modification, Modification Time, Buffer File Name, Buffers
 @section Buffer Modification
 @cindex buffer modification
 @cindex modification flag (of buffer)
 @var{buffer} is @code{nil} (or omitted), the current buffer is used.
 @end defun
-@node Modification Time
+@node Modification Time, Read Only Buffers, Buffer Modification, Buffers
 @section Comparison of Modification Time
 @cindex comparison of modification time
 @cindex modification time, comparison of
 See also the file locking mechanism in @ref{File Locks}.
 @end defun
-@node Read Only Buffers
+@node Read Only Buffers, The Buffer List, Modification Time, Buffers
 @section Read-Only Buffers
 @cindex read-only buffer
 @cindex buffer, read-only
 checked.  See @code{extent-in-region-p} for a fuller discussion.
 @end defun
-@node The Buffer List
+@node The Buffer List, Creating Buffers, Read Only Buffers, Buffers
 @section The Buffer List
 @cindex buffer list
 @code{replace-buffer-in-windows}.  @xref{Buffers and Windows}.
 @end deffn
-@node Creating Buffers
+@node Creating Buffers, Killing Buffers, The Buffer List, Buffers
 @section Creating Buffers
 @cindex creating buffers
 @cindex buffers, creating
 @end defun
-@node Killing Buffers
+@node Killing Buffers, Indirect Buffers, Creating Buffers, Buffers
 @section Killing Buffers
 @cindex killing buffers
 @cindex buffers, killing
 when set for any reason.  @xref{Buffer-Local Variables}.
 @end defvar
-@node Indirect Buffers
+@node Indirect Buffers,  , Killing Buffers, Buffers
 @section Indirect Buffers
 @cindex indirect buffers
 @cindex base buffer

File man/lispref/building.texi

 * Garbage Collection::  Reclaiming space for Lisp objects no longer used.
 @end menu
-@node Building XEmacs
+@node Building XEmacs, Garbage Collection, Building XEmacs and Object Allocation, Building XEmacs and Object Allocation
 @appendixsec Building XEmacs
 @cindex building XEmacs
 @pindex temacs
 20.1, the value is 1.
 @end defvar
-@node Garbage Collection
+@node Garbage Collection,  , Building XEmacs, Building XEmacs and Object Allocation
 @appendixsec Garbage Collection
 @cindex garbage collector

File man/lispref/commands.texi

 * Keyboard Macros::     How keyboard macros are implemented.
 @end menu
-@node Command Overview
+@node Command Overview, Defining Commands, Command Loop, Command Loop
 @section Command Loop Overview
   The command loop in XEmacs is a standard event loop, reading events
 these hooks, it terminates execution of the hook, but that is all it
-@node Defining Commands
+@node Defining Commands, Interactive Call, Command Overview, Command Loop
 @section Defining Commands
 @cindex defining commands
 @cindex commands, defining
 * Interactive Examples::  Examples of how to read interactive arguments.
 @end menu
-@node Using Interactive
+@node Using Interactive, Interactive Codes, Defining Commands, Defining Commands
 @subsection Using @code{interactive}
   This section describes how to write the @code{interactive} form that
 @var{function} is not interactive, @code{nil} will be returned.
 @end defun
-@node Interactive Codes
+@node Interactive Codes, Interactive Examples, Using Interactive, Defining Commands
 @subsection Code Characters for @code{interactive}
 @cindex interactive code description
 @cindex description for interactive codes
 value becomes the argument for the command.  Prompt.
 @end table
-@node Interactive Examples
+@node Interactive Examples,  , Interactive Codes, Defining Commands
 @subsection Examples of Using @code{interactive}
 @cindex examples of using @code{interactive}
 @cindex @code{interactive}, examples of using
 @end group
 @end example
-@node Interactive Call
+@node Interactive Call, Command Loop Info, Defining Commands, Command Loop
 @section Interactive Call
 @cindex interactive call
 @end example
 @end defun
-@node Command Loop Info
+@node Command Loop Info, Events, Interactive Call, Command Loop
 @section Information from the Command Loop
 The editor command loop sets several Lisp variables to keep status
 If the value is zero, then command input is not echoed.
 @end defvar
-@node Events
+@node Events, Reading Input, Command Loop Info, Command Loop
 @section Events
 @cindex events
 @cindex input events
 @end menu
-@node Event Types
+@node Event Types, Event Contents, Events, Events
 @subsection Event Types
 Events represent keyboard or mouse activity or status changes of various
 @code{dispatch-event}.  @xref{Dispatching an Event}.
 @end table
-@node Event Contents
+@node Event Contents, Event Predicates, Event Types, Events
 @subsection Contents of the Different Types of Events
   Every event, no matter what type it is, contains a timestamp (which is
 @end table
 @end defun
-@node Event Predicates
+@node Event Predicates, Accessing Mouse Event Positions, Event Contents, Events
 @subsection Event Predicates
 The following predicates return whether an object is an event of a
 This is true if @var{object} is any event that has not been deallocated.
 @end defun
-@node Accessing Mouse Event Positions
+@node Accessing Mouse Event Positions, Accessing Other Event Info, Event Predicates, Events
 @subsection Accessing the Position of a Mouse Event
 Unlike other events, mouse events (i.e. motion, button-press,
 * Other Event Position Info::
 @end menu
-@node Frame-Level Event Position Info
+@node Frame-Level Event Position Info, Window-Level Event Position Info, Accessing Mouse Event Positions, Accessing Mouse Event Positions
 @subsubsection Frame-Level Event Position Info
 The following functions return frame-level information about where
 This will signal an error if the event is not a mouse event.
 @end defun
-@node Window-Level Event Position Info
+@node Window-Level Event Position Info, Event Text Position Info, Frame-Level Event Position Info, Accessing Mouse Event Positions
 @subsubsection Window-Level Event Position Info
 The following functions return window-level information about where
 button-release, or misc-user event.
 @end defun
-@node Event Text Position Info
+@node Event Text Position Info, Event Glyph Position Info, Window-Level Event Position Info, Accessing Mouse Event Positions
 @subsubsection Event Text Position Info
 The following functions return information about the text (including the
 it is below a window, the value of @code{(window-end)} is returned.
 @end defun
-@node Event Glyph Position Info
+@node Event Glyph Position Info, Event Toolbar Position Info, Event Text Position Info, Accessing Mouse Event Positions
 @subsubsection Event Glyph Position Info
 The following functions return information about the glyph (if any) that
 @end defun
-@node Event Toolbar Position Info
+@node Event Toolbar Position Info, Other Event Position Info, Event Glyph Position Info, Accessing Mouse Event Positions
 @subsubsection Event Toolbar Position Info
 @defun event-over-toolbar-p event
 Otherwise, @code{nil} is returned.
 @end defun
-@node Other Event Position Info
+@node Other Event Position Info,  , Event Toolbar Position Info, Accessing Mouse Event Positions
 @subsubsection Other Event Position Info
 @defun event-over-border-p event
 Otherwise, @code{nil} is returned.
 @end defun
-@node Accessing Other Event Info
+@node Accessing Other Event Info, Working With Events, Accessing Mouse Event Positions, Events
 @subsection Accessing the Other Contents of Events
 The following functions allow access to the contents of events other than
 This function returns the process of the given process event.
 @end defun
-@node Working With Events
+@node Working With Events, Converting Events, Accessing Other Event Info, Events
 @subsection Working With Events
 XEmacs provides primitives for creating, copying, and destroying event
 it is safe to do so.
 @end defun
-@node Converting Events
+@node Converting Events,  , Working With Events, Events
 @subsection Converting Events
 XEmacs provides some auxiliary functions for converting between events
 Optional arg @var{no-mice} means that button events are not allowed.
 @end defun
-@node Reading Input
+@node Reading Input, Waiting, Events, Command Loop
 @section Reading Input
   The editor command loop reads keyboard input using the function
 * Peeking and Discarding::    	How to reread or throw away input events.
 @end menu
-@node Key Sequence Input
+@node Key Sequence Input, Reading One Event, Reading Input, Reading Input
 @subsection Key Sequence Input
 @cindex key sequence input
 converts the character to lower case.  Note that @code{lookup-key} does
 not perform case conversion in this way.
-@node Reading One Event
+@node Reading One Event, Dispatching an Event, Key Sequence Input, Reading Input
 @subsection Reading One Event
   The lowest level functions for command input are those which read a
 eval event will be the next event read after all pending events.
 @end defun
-@node Dispatching an Event
+@node Dispatching an Event, Quoted Character Input, Reading One Event, Reading Input
 @subsection Dispatching an Event
 @cindex dispatching an event
 (such as Expose events).
 @end defun
-@node Quoted Character Input
+@node Quoted Character Input, Peeking and Discarding, Dispatching an Event, Reading Input
 @subsection Quoted Character Input
 @cindex quoted character input
 @end defun
 @need 2000
-@node Peeking and Discarding
+@node Peeking and Discarding,  , Quoted Character Input, Reading Input
 @subsection Miscellaneous Event Input Features
 This section describes how to ``peek ahead'' at events without using
 @end example
 @end defun
-@node Waiting
+@node Waiting, Quitting, Reading Input, Command Loop
 @section Waiting for Elapsed Time or Input
 @cindex pausing
 @cindex waiting
   @xref{Time of Day}, for functions to get the current time.
-@node Quitting
+@node Quitting, Prefix Command Arguments, Waiting, Command Loop
 @section Quitting
 @cindex @kbd{C-g}
 @cindex quitting
   You can specify a character other than @kbd{C-g} to use for quitting.
 See the function @code{set-input-mode} in @ref{Terminal Input}.
-@node Prefix Command Arguments
+@node Prefix Command Arguments, Recursive Editing, Quitting, Command Loop
 @section Prefix Command Arguments
 @cindex prefix argument
 @cindex raw prefix argument
 call this command yourself unless you know what you are doing.
 @end deffn
-@node Recursive Editing
+@node Recursive Editing, Disabling Commands, Prefix Command Arguments, Command Loop
 @section Recursive Editing
 @cindex recursive command loop
 @cindex recursive editing level
 recursive edit is active, it returns 0.
 @end defun
-@node Disabling Commands
+@node Disabling Commands, Command History, Recursive Editing, Command Loop
 @section Disabling Commands
 @cindex disabled command
 the user whether to proceed.
 @end defvar
-@node Command History
+@node Command History, Keyboard Macros, Disabling Commands, Command Loop
 @section Command History
 @cindex command history
 @cindex complex command
 minibuffer, the history commands used are the same ones available in any
-@node Keyboard Macros
+@node Keyboard Macros,  , Command History, Command Loop
 @section Keyboard Macros
 @cindex keyboard macros

File man/lispref/compile.texi

 * Different Behavior::          When compiled code gives different results.
 @end menu
-@node Speed of Byte-Code
+@node Speed of Byte-Code, Compilation Functions, Byte Compilation, Byte Compilation
 @section Performance of Byte-Compiled Code
   A byte-compiled function is not as efficient as a primitive function
 whereas the byte-compiled code required 6 seconds.  These results are
 representative, but actual results will vary greatly.
-@node Compilation Functions
+@node Compilation Functions, Compilation Options, Speed of Byte-Code, Byte Compilation
 @comment  node-name,  next,  previous,  up
 @section The Compilation Functions
 @cindex compilation functions
 code without an associated argument list.
 @end defun
-@node Compilation Options
+@node Compilation Options, Docs and Compilation, Compilation Functions, Byte Compilation
 @section Options for the Byte Compiler
 @cindex compilation options
 @end example
 @end defun
-@node Docs and Compilation
+@node Docs and Compilation, Dynamic Loading, Compilation Options, Byte Compilation
 @section Documentation Strings and Compilation
 @cindex dynamic loading of documentation
 @samp{#$} construct, which stands for ``the name of this file, as a
 string.''  It is best not to use these constructs in Lisp source files.
-@node Dynamic Loading
+@node Dynamic Loading, Eval During Compile, Docs and Compilation, Byte Compilation
 @section Dynamic Loading of Individual Functions
 @cindex dynamic loading of functions
 @var{function} may be a compiled-function object or a function name.
 @end defun
-@node Eval During Compile
+@node Eval During Compile, Compiled-Function Objects, Dynamic Loading, Byte Compilation
 @section Evaluation During Compilation
   These features permit you to write code to be evaluated during
 @code{eval-when-compile} does.
 @end defmac
-@node Compiled-Function Objects
+@node Compiled-Function Objects, Disassembly, Eval During Compile, Byte Compilation
 @section Compiled-Function Objects
 @cindex compiled function
 @cindex byte-code function
 @xref{Domain Specification}.
 @end defun
-@node Disassembly
+@node Disassembly, Different Behavior, Compiled-Function Objects, Byte Compilation
 @section Disassembled Byte-Code
 @cindex disassembled byte-code
 @end example
-@node Different Behavior
+@node Different Behavior,  , Disassembly, Byte Compilation
 @section Different Behavior
 The intent is that compiled byte-code and the corresponding code

File man/lispref/consoles-devices.texi

 @c Copyright (C) 1995, 1996 Ben Wing.
 @c See the file lispref.texi for copying conditions.
 @setfilename ../../info/
-@node Consoles and Devices, Positions, Frames, top
+@node Consoles and Devices, Positions, Frames, Top
 @chapter Consoles and Devices
 @cindex devices
 @cindex consoles

File man/lispref/control.texi

 * Nonlocal Exits::         Jumping out of a sequence.
 @end menu
-@node Sequencing
+@node Sequencing, Conditionals, Control Structures, Control Structures
 @section Sequencing
   Evaluating forms in the order they appear is the most common way
 @end example
 @end deffn
-@node Conditionals
+@node Conditionals, Combining Conditions, Sequencing, Control Structures
 @section Conditionals
 @cindex conditional evaluation
 @end group
 @end example
-@node Combining Conditions
+@node Combining Conditions, Iteration, Conditionals, Control Structures
 @section Constructs for Combining Conditions
   This section describes three constructs that are often used together
 @var{arg3})} never evaluates any argument more than once.
 @end deffn
-@node Iteration
+@node Iteration, Nonlocal Exits, Combining Conditions, Control Structures
 @section Iteration
 @cindex iteration
 @cindex recursion
 just the end test (which also does the real work of moving point).
 @end deffn
-@node Nonlocal Exits
+@node Nonlocal Exits,  , Iteration, Control Structures
 @section Nonlocal Exits
 @cindex nonlocal exits
 * Cleanups::            Arranging to run a cleanup form if an error happens.
 @end menu
-@node Catch and Throw
+@node Catch and Throw, Examples of Catch, Nonlocal Exits, Nonlocal Exits
 @subsection Explicit Nonlocal Exits: @code{catch} and @code{throw}
   Most control constructs affect only the flow of control within the
 error is signaled with data @code{(@var{tag} @var{value})}.
 @end defun
-@node Examples of Catch
+@node Examples of Catch, Errors, Catch and Throw, Nonlocal Exits
 @subsection Examples of @code{catch} and @code{throw}
   One way to use @code{catch} and @code{throw} is to exit from a doubly
 encountered idiom is to bind a local variable to @code{(cons nil nil)},
 and use the variable as the formal tag.
-@node Errors
+@node Errors, Cleanups, Examples of Catch, Nonlocal Exits
 @subsection Errors
 @cindex errors
 * Error Symbols::         How errors are classified for trapping them.
 @end menu
-@node Signaling Errors
+@node Signaling Errors, Processing of Errors, Errors, Errors
 @subsubsection How to Signal an Error
 @cindex signaling errors
 @end example
 @end defmac
-@node Processing of Errors
+@node Processing of Errors, Handling Errors, Signaling Errors, Errors
 @subsubsection How XEmacs Processes Errors
 When an error is signaled, @code{signal} searches for an active
 in the environment of the error, so that you can examine values of
 variables precisely as they were at the time of the error.
-@node Handling Errors
+@node Handling Errors, Error Symbols, Processing of Errors, Errors
 @subsubsection Writing Code to Handle Errors
 @cindex error handler
 @cindex handling errors
 @end group
 @end smallexample
-@node Error Symbols
+@node Error Symbols,  , Handling Errors, Errors
 @subsubsection Error Symbols and Condition Names
 @cindex error symbol
 @cindex error name
   @xref{Standard Errors}, for a list of all the standard error symbols
 and their conditions.
-@node Cleanups
+@node Cleanups,  , Errors, Nonlocal Exits
 @subsection Cleaning Up from Nonlocal Exits
   The @code{unwind-protect} construct is essential whenever you

File man/lispref/customize.texi

 @c Copyright (C) 1997, 1998 Free Software Foundation, Inc.
 @c See the file lispref.texi for copying conditions.
 @setfilename ../info/customize
-@node Customization, , , Top
+@node Customization, Loading, Macros, Top
 @chapter Writing Customization Definitions
   This chapter describes how to declare user options for customization,
 * Enabling Behavior::
 @end menu
-@node Common Keywords
+@node Common Keywords, Group Definitions, Customization, Customization
 @section Common Keywords for All Kinds of Items
   All kinds of customization declarations (for variables and groups, and
 any effect unless the code which implements the mode is loaded.
 @end table
-@node Group Definitions
+@node Group Definitions, Variable Definitions, Common Keywords, Customization
 @section Defining Custom Groups
   Each Emacs Lisp package should have one main customization group which
 @c the @code{:prefix} specifications which give unclear results, and then
 @c turn this feature back on, if someone would like to do the work.
-@node Variable Definitions
+@node Variable Definitions, Face Definitions, Group Definitions, Customization
 @section Defining Customization Variables
   Use @code{defcustom} to declare user-editable variables.
 * Defining New Types::
 @end menu
-@node Simple Types
+@node Simple Types, Composite Types, Customization Types, Customization Types
 @subsection Simple Types
   This section describes all the simple customization types.
 meaning of the alternative.
 @end table
-@node Composite Types
+@node Composite Types, Splicing into Lists, Simple Types, Customization Types
 @subsection Composite Types
   When none of the simple types is appropriate, you can use composite
 more elements or removing elements.
 @end table
-@node Splicing into Lists
+@node Splicing into Lists, Type Keywords, Composite Types, Customization Types
 @subsection Splicing into Lists
   The @code{:inline} feature lets you splice a variable number of
 the user chooses the second alternative, then the overall list has three
 elements and the second and third must be strings.
-@node Type Keywords
+@node Type Keywords, Defining New Types, Splicing into Lists, Customization Types
 @subsection Type Keywords
 You can specify keyword-argument pairs in a customization type after the
 @end ignore
 @end table
+@node Defining New Types,  , Type Keywords, Customization Types
+@subsection Defining New Types
-@node Enabling Behavior, , Customization Types, Customization
-@subsection Enabling Behavior
+In the previous sections we have described how to construct elaborate
+type specifications for @code{defcustom}.  In some cases you may want to
+give such a type specification a name.  The obvious case is when you are
+using the same type for many user options, rather than repeat the
+specification for each option, you can give the type specification a
+name once, and use that name each @code{defcustom}.  The other case is
+when a user option accept a recursive datastructure.  To make it
+possible for a datatype to refer to itself, it needs to have a name.
+Since custom types are implemented as widgets, the way to define a new
+customize type is to define a new widget.  We are not going to describe
+the widget interface here in details, see @ref{Top, , Introduction,
+widget, The Emacs Widget Library}, for that.  Instead we are going to
+demonstrate the minimal functionality needed for defining new customize
+types by a simple example.
+(define-widget 'binary-tree-of-string 'lazy
+  "A binary tree made of cons-cells and strings."
+  :offset 4
+  :tag "Node"
+  :type '(choice (string :tag "Leaf" :value "")
+                 (cons :tag "Interior"
+                       :value ("" . "")
+                       binary-tree-of-string
+                       binary-tree-of-string)))
+(defcustom foo-bar ""
+  "Sample variable holding a binary tree of strings."
+  :type 'binary-tree-of-string)
+@end example
+The function to define a new widget is name @code{define-widget}.  The
+first argument is the symbol we want to make a new widget type.  The
+second argument is a symbol representing an existing widget, the new
+widget is going to be defined in terms of difference from the existing
+widget.  For the purpose of defining new customization types, the
+@code{lazy} widget is perfect, because it accept a @code{:type} keyword
+argument with the same syntax as the keyword argument to
+@code{defcustom} with the same name.  The third argument is a
+documentation string for the new widget.  You will be able to see that
+string with the @kbd{M-x widget-browse @key{ret} binary-tree-of-string
+@key{ret}} command.
+After these mandatory arguments follows the keyword arguments.  The most
+important is @code{:type}, which describes the datatype we want to match
+with this widget.  Here a @code{binary-tree-of-string} is described as
+being either a string, or a cons-cell whose car and cdr are themselves
+both @code{binary-tree-of-string}.  Note the reference to the widget
+type we are currently in the process of defining.  The @code{:tag}
+attribute is a string to name the widget in the user interface, and the
+@code{:offset} argument are there to ensure that child nodes are
+indented four spaces relatively to the parent node, making the tree
+structure apparent in the customization buffer.
+The @code{defcustom} shows how the new widget can be used as an ordinary
+customization type.
+@node Enabling Behavior,  , Customization Types, Customization
+@section Enabling Behavior
 @cindex behavior
 @c #### Does this belong here?
 Called interactively, prompt the user for @var{behavior}, and take
 @var{force} from the prefix argument.
 @end defun
-@node Defining New Types
-@subsection Defining New Types
-In the previous sections we have described how to construct elaborate
-type specifications for @code{defcustom}.  In some cases you may want to
-give such a type specification a name.  The obvious case is when you are
-using the same type for many user options, rather than repeat the
-specification for each option, you can give the type specification a
-name once, and use that name each @code{defcustom}.  The other case is
-when a user option accept a recursive datastructure.  To make it
-possible for a datatype to refer to itself, it needs to have a name.
-Since custom types are implemented as widgets, the way to define a new
-customize type is to define a new widget.  We are not going to describe
-the widget interface here in details, see @ref{Top, , Introduction,
-widget, The Emacs Widget Library}, for that.  Instead we are going to
-demonstrate the minimal functionality needed for defining new customize
-types by a simple example.
-(define-widget 'binary-tree-of-string 'lazy
-  "A binary tree made of cons-cells and strings."
-  :offset 4
-  :tag "Node"
-  :type '(choice (string :tag "Leaf" :value "")
-                 (cons :tag "Interior"
-                       :value ("" . "") 
-                       binary-tree-of-string
-                       binary-tree-of-string)))
-(defcustom foo-bar ""
-  "Sample variable holding a binary tree of strings."
-  :type 'binary-tree-of-string)
-@end example
-The function to define a new widget is name @code{define-widget}.  The
-first argument is the symbol we want to make a new widget type.  The
-second argument is a symbol representing an existing widget, the new
-widget is going to be defined in terms of difference from the existing
-widget.  For the purpose of defining new customization types, the
-@code{lazy} widget is perfect, because it accept a @code{:type} keyword
-argument with the same syntax as the keyword argument to
-@code{defcustom} with the same name.  The third argument is a
-documentation string for the new widget.  You will be able to see that
-string with the @kbd{M-x widget-browse @key{ret} binary-tree-of-string
-@key{ret}} command.  
-After these mandatory arguments follows the keyword arguments.  The most
-important is @code{:type}, which describes the datatype we want to match
-with this widget.  Here a @code{binary-tree-of-string} is described as
-being either a string, or a cons-cell whose car and cdr are themselves
-both @code{binary-tree-of-string}.  Note the reference to the widget
-type we are currently in the process of defining.  The @code{:tag}
-attribute is a string to name the widget in the user interface, and the
-@code{:offset} argument are there to ensure that child nodes are
-indented four spaces relatively to the parent node, making the tree
-structure apparent in the customization buffer.
-The @code{defcustom} shows how the new widget can be used as an ordinary
-customization type. 

File man/lispref/databases.texi

 @c Copyright (C) 1996 Ben Wing.
 @c See the file lispref.texi for copying conditions.
 @setfilename ../../info/
-@node Databases, Processes, Range Tables, top
+@node Databases, Processes, Range Tables, Top
 @chapter Databases
 @cindex database
 * Other Database Functions::
 @end menu
-@node Connecting to a Database
+@node Connecting to a Database, Working With a Database, Databases, Databases
 @section Connecting to a Database
 @defun open-database file &optional type subtype access mode
 @end defun
-@node Working With a Database
+@node Working With a Database, Other Database Functions, Connecting to a Database, Databases
 @section Working With a Database
 @defun get-database key database &optional default
 This function removes @var{key} from @var{database}.
 @end defun
-@node Other Database Functions
+@node Other Database Functions,  , Working With a Database, Databases
 @section Other Database Functions
 @defun database-file-name database

File man/lispref/debugging.texi

   For debugging problems in terminal descriptions, the
 @code{open-termscript} function can be useful.  @xref{Terminal Output}.
-@node Debugger
+@node Debugger, Syntax Errors, Debugging, Debugging
 @section The Lisp Debugger
 @cindex debugger
 @cindex Lisp debugger
 * Internals of Debugger:: Subroutines of the debugger, and global variables.
 @end menu
-@node Error Debugging
+@node Error Debugging, Infinite Loops, Debugger, Debugger
 @subsection Entering the Debugger on an Error
 @cindex error debugging
 @cindex debugging errors
           '(lambda () (setq debug-on-error t)))
 @end example
-@node Infinite Loops
+@node Infinite Loops, Function Debugging, Error Debugging, Debugger
 @subsection Debugging Infinite Loops
 @cindex infinite loops
 @cindex loops, infinite
 when you quit.  @xref{Quitting}.
 @end defopt
-@node Function Debugging
+@node Function Debugging, Explicit Debug, Infinite Loops, Debugger
 @subsection Entering the Debugger on a Function Call
 @cindex function call debugging
 @cindex debugging specific functions
 returns @var{function-name}.
 @end deffn
-@node Explicit Debug
+@node Explicit Debug, Using Debugger, Function Debugging, Debugger
 @subsection Explicit Entry to the Debugger
   You can cause the debugger to be called at a certain point in your
 program!)  The most common suitable places are inside a @code{progn} or
 an implicit @code{progn} (@pxref{Sequencing}).
-@node Using Debugger
+@node Using Debugger, Debugger Commands, Explicit Debug, Debugger
 @subsection Using the Debugger
   When the debugger is entered, it displays the previously selected
 @need 3000
-@node Debugger Commands
+@node Debugger Commands, Invoking the Debugger, Using Debugger, Debugger
 @subsection Debugger Commands
 @cindex debugger command list
 until the problem is corrected.
 @end table
-@node Invoking the Debugger
+@node Invoking the Debugger, Internals of Debugger, Debugger Commands, Debugger
 @subsection Invoking the Debugger
   Here we describe fully the function used to invoke the debugger.
 @need 5000
-@node Internals of Debugger
+@node Internals of Debugger,  , Invoking the Debugger, Debugger
 @subsection Internals of the Debugger
   This section describes functions and variables used internally by the
 @end defun
-@node Syntax Errors
+@node Syntax Errors, Compilation Errors, Debugger, Debugging
 @section Debugging Invalid Lisp Syntax
   The Lisp reader reports invalid syntax, but cannot say where the real
 * Excess Close::    How to find a spurious close paren or missing open.
 @end menu
-@node Excess Open
+@node Excess Open, Excess Close, Syntax Errors, Syntax Errors
 @subsection Excess Open Parentheses
   The first step is to find the defun that is unbalanced.  If there is
 and you have put back those parentheses, @kbd{C-M-q} should not change
-@node Excess Close
+@node Excess Close,  , Excess Open, Syntax Errors
 @subsection Excess Close Parentheses
   To deal with an excess close parenthesis, first insert an open

File man/lispref/dialog.texi

 * Dialog Box Functions::
 @end menu
-@node Dialog Box Format
+@node Dialog Box Format, Dialog Box Functions, Dialog Boxes, Dialog Boxes
 @section Dialog Box Format
 A dialog box description is a list.
    dialog       :=  '(' name [ button ]+ [ partition [ button ]+ ] ')'
 @end example
-@node Dialog Box Functions
+@node Dialog Box Functions,  , Dialog Box Format, Dialog Boxes
 @section Dialog Box Functions
 @defun popup-dialog-box dbox-desc

File man/lispref/display.texi

 * Beeping::             Audible signal to the user.
 @end menu
-@node Refresh Screen
+@node Refresh Screen, Truncation, Display, Display
 @section Refreshing the Screen
 The function @code{redraw-frame} redisplays the entire contents of a
 which defaults to the selected frame.
 @end defun
-@node Truncation
+@node Truncation, The Echo Area, Refresh Screen, Display
 @section Truncation
 @cindex line wrapping
 @cindex continuation lines
 @end defvar
 @end ignore
-@node The Echo Area
+@node The Echo Area, Warnings, Truncation, Display
 @section The Echo Area
 @cindex error display
 @cindex echo area
 * Customizing Message Display::
 @end menu
-@node Customizing Message Display
+@node Customizing Message Display,  , The Echo Area, The Echo Area
 @subsection Customizing Message Display
 Message display function specify message intended for echo area by
 of @code{(sit-for 2)} is run.
 @end defvar
-@node Warnings
+@node Warnings, Invisible Text, The Echo Area, Display
 @section Warnings
 XEmacs contains a facility for unified display of various warnings.
 buffer will not be automatically popped up.
 @end defvar
-@node Invisible Text
+@node Invisible Text, Selective Display, Warnings, Display
 @section Invisible Text
 @cindex invisible text
 slow-down of these commands it is turned off by default, controlled by
 the variable @code{line-move-ignore-invisible}.
-@node Selective Display
+@node Selective Display, Overlay Arrow, Invisible Text, Display
 @section Selective Display
 @cindex selective display
 (@samp{@dots{}}).  @xref{Display Tables}.
 @end defvar
-@node Overlay Arrow
+@node Overlay Arrow, Temporary Displays, Selective Display, Display
 @section The Overlay Arrow
 @cindex overlay arrow
   You can do the same job by creating an extent with a
 @code{begin-glyph} property.  @xref{Extent Properties}.
-@node Temporary Displays
+@node Temporary Displays, Blinking, Overlay Arrow, Display
 @section Temporary Displays
   Temporary displays are used by commands to put output into a buffer
 and go.
 @end defun
-@node Blinking
+@node Blinking, Usual Display, Temporary Displays, Display
 @section Blinking Parentheses
 @cindex parenthesis matching
 @cindex blinking
 @end smallexample
 @end deffn
-@node Usual Display
+@node Usual Display, Display Tables, Blinking, Display
 @section Usual Display Conventions
   The usual display conventions define how to display each character
 stops used by the command @code{tab-to-tab-stop}.  @xref{Indent Tabs}.
 @end defopt
-@node Display Tables
+@node Display Tables, Beeping, Usual Display, Display
 @section Display Tables
 @cindex display table
 				  to support the ISO Latin 1 character set.
 @end ignore
-@node Display Table Format
+@node Display Table Format, Active Display Table, Display Tables, Display Tables
 @subsection Display Table Format
   A display table is an array of 256 elements. (In FSF Emacs, a display
   (aset disptab 127 "^?"))
 @end example
-@node Active Display Table
+@node Active Display Table, Character Descriptors, Display Table Format, Display Tables
 @subsection Active Display Table
 @cindex active display table
   If no display table can be determined for a particular window,
 then XEmacs uses the usual display conventions.  @xref{Usual Display}.
-@node Character Descriptors
+@node Character Descriptors, , Active Display Table, Display Tables
 @subsection Character Descriptors
 @cindex character descriptor
 @end ignore
-@node Beeping
+@node Beeping,  , Display Tables, Display
 @section Beeping
 @cindex beeping
 @cindex bell

File man/lispref/eval.texi

 * Multiple values:: Functions may return more than one result.
 @end menu
-@node Intro Eval
+@node Intro Eval, Eval, Evaluation, Evaluation
 @section Introduction to Evaluation
   The Lisp interpreter, or evaluator, is the program that computes
   The details of what evaluation means for each kind of form are
 described below (@pxref{Forms}).
-@node Eval
+@node Eval, Forms, Intro Eval, Evaluation
 @section Eval
 @c ??? Perhaps this should be the last section in the chapter.
 @end example
 @end defvar
-@node Forms
+@node Forms, Quoting, Eval, Evaluation
 @section Kinds of Forms
   A Lisp object that is intended to be evaluated is called a @dfn{form}.
                               containing their real definitions.
 @end menu
-@node Self-Evaluating Forms
+@node Self-Evaluating Forms, Symbol Forms, Forms, Forms
 @subsection Self-Evaluating Forms
 @cindex vector evaluation
 @cindex literal evaluation
 @end group
 @end example
-@node Symbol Forms
+@node Symbol Forms, Classifying Lists, Self-Evaluating Forms, Forms
 @subsection Symbol Forms
 @cindex symbol evaluation
 these two symbols act like self-evaluating forms, even though
 @code{eval} treats them like any other symbol.
-@node Classifying Lists
+@node Classifying Lists, Function Indirection, Symbol Forms, Forms
 @subsection Classification of List Forms
 @cindex list form evaluation
 @emph{not} evaluated, as it would be in some Lisp dialects such as
-@node Function Indirection
+@node Function Indirection, Function Forms, Classifying Lists, Forms
 @subsection Symbol Function Indirection
 @cindex symbol function indirection
 @cindex indirection
 @end smallexample
 @end defun
-@node Function Forms
+@node Function Forms, Macro Forms, Function Indirection, Forms
 @subsection Evaluation of Function Forms
 @cindex function form evaluation
 @cindex function call
 in the function body are evaluated in order, and the value of the last
 body form becomes the value of the function call.
-@node Macro Forms
+@node Macro Forms, Special Operators, Function Forms, Forms
 @subsection Lisp Macro Evaluation
 @cindex macro call evaluation
 @xref{Macros}, for a complete description of XEmacs Lisp macros.
-@node Special Operators
+@node Special Operators, Autoloading, Macro Forms, Forms
 @subsection Special Operators
 @cindex special operator evaluation
 @cindex special form
 multiple values).@refill
 @end quotation
-@node Autoloading
+@node Autoloading,  , Special Operators, Forms
 @subsection Autoloading
   The @dfn{autoload} feature allows you to call a function or macro
 function automatically loads the specified file; then it calls the real
 definition loaded from that file.  @xref{Autoload}.
-@node Quoting
+@node Quoting, Multiple values, Forms, Evaluation
 @section Quoting
 @cindex quoting
 to be compiled, and @samp{`} (@pxref{Backquote}), which is used to quote
 only part of a list, while computing and substituting other parts.
-@node Multiple values
+@node Multiple values,  , Quoting, Evaluation
 @section Multiple values
 @cindex multiple values

File man/lispref/extents.texi

 @c Copyright (C) 1996 Ben Wing.
 @c See the file lispref.texi for copying conditions.
 @setfilename ../../info/
-@node Extents, Specifiers, Abbrevs, top
+@node Extents, Specifiers, Abbrevs, Top
 @chapter Extents
 @cindex extent
 * Atomic Extents::	   Treating a block of text as a single entity.
 @end menu
-@node Intro to Extents
+@node Intro to Extents, Creating and Modifying Extents, Extents, Extents
 @section Introduction to Extents
 @cindex extent priority
 @cindex priority of an extent
 be re-inserted.  This mechanism is used in the kill, yank, and undo
 commands.  @xref{Duplicable Extents}.
-@node Creating and Modifying Extents
+@node Creating and Modifying Extents, Extent Endpoints, Intro to Extents, Extents
 @section Creating and Modifying Extents
 @defun make-extent from to &optional buffer-or-string
 been deleted, and @code{nil} otherwise.
 @end defun
-@node Extent Endpoints
+@node Extent Endpoints, Finding Extents, Creating and Modifying Extents, Extents
 @section Extent Endpoints
 @cindex extent endpoint
 @cindex extent start position
 @end defun
-@node Finding Extents
+@node Finding Extents, Mapping Over Extents, Extent Endpoints, Extents
 @section Finding Extents
 @cindex extents, locating
 string, this returns the last extent in the buffer or string.
 @end defun
-@node Mapping Over Extents
+@node Mapping Over Extents, Extent Properties, Finding Extents, Extents
 @section Mapping Over Extents
 @cindex extents, mapping
 @var{extent} if called with the given arguments.
 @end defun
-@node Extent Properties
+@node Extent Properties, Detached Extents, Mapping Over Extents, Extents
 @section Properties of Extents
 @cindex extent property
 @cindex property of an extent
 extent to @var{function}.
 @end defun
-@node Detached Extents
+@node Detached Extents, Extent Parents, Extent Properties, Extents
 @section Detached Extents
 @cindex detached extent
 @xref{Duplicable Extents}.
 @end defun
-@node Extent Parents
+@node Extent Parents, Duplicable Extents, Detached Extents, Extents
 @section Extent Parents
 @cindex extent parent
 @cindex extent children
 to any children of @var{extent}, until no more children can be found.
 @end defun
-@node Duplicable Extents
+@node Duplicable Extents, Extents and Events, Extent Parents, Extents
 @section Duplicable Extents
 @cindex duplicable extent
 @cindex unique extents
 @code{paste-function} will not be called.
 @end itemize
-@node Extents and Events
+@node Extents and Events, Atomic Extents, Duplicable Extents, Extents
 @section Interaction of Extents with Keyboard and Mouse Events
   If an extent has the @code{mouse-face} property set, it will be
 @code{point} is within the extent.  The behavior of mouse clicks and
 keystrokes not defined in the keymap is as normal for the buffer.
-@node Atomic Extents
+@node Atomic Extents,  , Extents and Events, Extents
 @section Atomic Extents
 @cindex atomic extent

File man/lispref/faces.texi

 @c Copyright (C) 1995 Ben Wing.
 @c See the file lispref.texi for copying conditions.
 @setfilename ../../info/
-@node Faces and Window-System Objects, Glyphs, Specifiers, top
+@node Faces and Window-System Objects, Glyphs, Specifiers, Top
 @chapter Faces and Window-System Objects
 @cindex faces
 @cindex window-system objects
 * Colors::		Controlling the color of text and pixmaps.
 @end menu
-@node Faces
+@node Faces, Fonts, Faces and Window-System Objects, Faces and Window-System Objects
 @section Faces
 A @dfn{face} is a named collection of graphical properties: font,
 				  a face appears.
 @end menu
-@node Merging Faces
+@node Merging Faces, Basic Face Functions, Faces, Faces
 @subsection Merging Faces for Display
   Here are all the ways to specify which face to use for display of text:
 used; if it is a bitmap, the face's foreground and background colors are
 used to color it.
-@node Basic Face Functions
+@node Basic Face Functions, Face Properties, Merging Faces, Faces
 @subsection Basic Functions for Working with Faces
   The properties a face can specify include the font, the foreground
-@node Face Properties
+@node Face Properties, Face Convenience Functions, Basic Face Functions, Faces
 @subsection Face Properties
   You can examine and modify the properties of an existing face with the
 in @code{specifier-instance}.  @xref{Specifiers}.
 @end defun
-@node Face Convenience Functions
+@node Face Convenience Functions, Other Face Display Functions, Face Properties, Faces
 @subsection Face Convenience Functions
 @deffn Command set-face-foreground face color &optional locale tag-set how-to-add
 @end defun
-@node Other Face Display Functions
+@node Other Face Display Functions,  , Face Convenience Functions, Faces
 @subsection Other Face Display Functions
 @deffn Command invert-face face &optional locale
 the default face.  @var{domain} is as in @code{face-property-instance}.
 @end defun
-@node Fonts
+@node Fonts, Colors, Faces, Faces and Window-System Objects
 @section Fonts
 @cindex fonts
 				  of a font specifier.
 @end menu
-@node Font Specifiers
+@node Font Specifiers, Font Instances, Fonts, Fonts
 @subsection Font Specifiers
 @defun font-specifier-p object
 @end itemize
 @end defun
-@node Font Instances
+@node Font Instances, Font Instance Names, Font Specifiers, Fonts
 @subsection Font Instances
 @defun font-instance-p object
 these objects are GCed, the underlying X data is deallocated as well.
 @end defun
-@node Font Instance Names
+@node Font Instance Names, Font Instance Size, Font Instances, Fonts
 @subsection Font Instance Names
 @cindex font instance name
 @cindex available fonts
 (but not necessarily its only unambiguous name).
 @end defun
-@node Font Instance Size
+@node Font Instance Size, Font Instance Characteristics, Font Instance Names, Fonts
 @subsection Font Instance Size
 @cindex font instance size
 that is defined.
 @end defun
-@node Font Instance Characteristics
+@node Font Instance Characteristics, Font Convenience Functions, Font Instance Size, Fonts
 @subsection Font Instance Characteristics
 @cindex font instance characteristics
 @cindex characteristics of font instances
 font.  If it fails, it returns @code{nil}.
 @end defun
-@node Font Convenience Functions
+@node Font Convenience Functions,  , Font Instance Characteristics, Fonts
 @subsection Font Convenience Functions
 @defun font-name font &optional domain
 applying @code{font-instance-properties} to the result.
 @end defun
-@node Colors
+@node Colors,  , Fonts, Faces and Window-System Objects
 @section Colors
 @cindex colors
 				  of a color specifier.
 @end menu
-@node Color Specifiers
+@node Color Specifiers, Color Instances, Colors, Colors
 @subsection Color Specifiers
 @defun color-specifier-p object
 @end defun
-@node Color Instances
+@node Color Instances, Color Instance Properties, Color Specifiers, Colors
 @subsection Color Instances
 @cindex color instances
 This function returns non-@code{nil} if @var{object} is a color-instance.
 @end defun
-@node Color Instance Properties
+@node Color Instance Properties, Color Convenience Functions, Color Instances, Colors
 @subsection Color Instance Properties
 @defun color-instance-name color-instance
 @end example
 @end defun
-@node Color Convenience Functions
+@node Color Convenience Functions,  , Color Instance Properties, Colors
 @subsection Color Convenience Functions
 @defun color-name color &optional domain

File man/lispref/files.texi

 * Files and MS-DOS::         Distinguishing text and binary files on MS-DOS.
 @end menu
-@node Visiting Files
+@node Visiting Files, Saving Buffers, Files, Files
 @section Visiting Files
 @cindex finding files
 @cindex visiting files
 * Subroutines of Visiting::    Lower-level subroutines that they use.
 @end menu
-@node Visiting Functions
+@node Visiting Functions, Subroutines of Visiting, Visiting Files, Visiting Files
 @subsection Functions for Visiting Files
   This section describes the functions normally used to visit files.
 used and they may not all be called.
 @end defvar
-@node Subroutines of Visiting
+@node Subroutines of Visiting,  , Visiting Functions, Visiting Files
 @subsection Subroutines of Visiting
   The @code{find-file-noselect} function uses the
 in @code{find-file-hooks}.
 @end defun
-@node Saving Buffers
+@node Saving Buffers, Reading from Files, Visiting Files, Files
 @section Saving Buffers
   When you edit a file in XEmacs, you are actually working on a buffer
 major modes set it to @code{t} in particular buffers.
 @end defopt
-@node Reading from Files
+@node Reading from Files, Writing to Files, Saving Buffers, Files
 @section Reading from Files
   You can copy a file from the disk and insert it into a buffer
 program can read the file, use the function @code{file-local-copy}; see
 @ref{Magic File Names}.
-@node Writing to Files
+@node Writing to Files, File Locks, Reading from Files, Files
 @section Writing to Files
   You can write the contents of a buffer, or part of a buffer, directly
 files that the user does not need to know about.
 @end deffn
-@node File Locks
+@node File Locks, Information about Files, Writing to Files, Files
 @section File Locks
 @cindex file locks
 for its usual definition is in @file{userlock.el}.
 @end defun
-@node Information about Files
+@node Information about Files, Changing File Attributes, File Locks, Files
 @section Information about Files
   The functions described in this section all operate on strings that
 * File Attributes::         How large is it?  Any other names?  Etc.
 @end menu
-@node Testing Accessibility
+@node Testing Accessibility, Kinds of Files, Information about Files, Information about Files
 @subsection Testing Accessibility
 @cindex accessibility of a file
 @cindex file accessibility
 time as a list of two numbers.  @xref{File Attributes}.
 @end defun
-@node Kinds of Files
+@node Kinds of Files, Truenames, Testing Accessibility, Information about Files
 @subsection Distinguishing Kinds of Files
   This section describes how to distinguish various kinds of files, such
 other I/O device).
 @end defun
-@node Truenames
+@node Truenames, File Attributes, Kinds of Files, Information about Files
 @subsection Truenames
 @cindex truename (of file)
   @xref{Buffer File Name}, for related information.
-@node File Attributes
+@node File Attributes,  , Truenames, Information about Files
 @subsection Other Information about Files
   This section describes the functions for getting detailed information
 @end table
 @end defun
-@node Changing File Attributes
+@node Changing File Attributes, File Names, Information about Files, Files
 @section Changing File Names and Attributes
 @cindex renaming files
 @cindex copying files
 @samp{.bat} or @samp{.exe}.  This is reflected in the values returned
 by @code{file-modes} and @code{file-attributes}.
-@node File Names
+@node File Names, Contents of Directories, Changing File Attributes, Files
 @section File Names
 @cindex file names
 * User Name Completion::  Finding the completions for a given user name.
 @end menu
-@node File Name Components
+@node File Name Components, Directory Names, File Names, File Names
 @subsection File Name Components
 @cindex directory part (of file name)
 @cindex nondirectory part (of file name)
 @end example
 @end defun
-@node Directory Names
+@node Directory Names, Relative File Names, File Name Components, File Names
 @subsection Directory Names
 @cindex directory name
 @cindex file name of directory
 @c directory.
 @c @end defun
-@node Relative File Names
+@node Relative File Names, File Name Expansion, Directory Names, File Names
 @subsection Absolute and Relative File Names
 @cindex absolute file name
 @cindex relative file name
 @end example
 @end defun