xemacs-beta: man/lispref/objects.texi comparison

comparison man/lispref/objects.texi @ 5791:9fae6227ede5

Silence texinfo 5.2 warnings, primarily by adding next, prev, and up pointers to all nodes. See xemacs-patches message with ID <5315f7bf.sHpFD7lXYR05GH6E%james@xemacs.org>.

author	Jerry James <james@xemacs.org>
date	Thu, 27 Mar 2014 08:59:03 -0600
parents	d967d96ca043
children

comparison

equal deleted inserted replaced

-:dcf9067f26bb
+:9fae6227ede5
 * Window-System Types::         Types specific to windowing systems.
 * Type Predicates::             Tests related to types.
 * Equality Predicates::         Tests of equality between any two objects.
 @end menu
-@node Printed Representation
+@node Printed Representation, Comments, Lisp Data Types, Lisp Data Types
 @section Printed Representation and Read Syntax
 @cindex printed representation
 @cindex read syntax
 The @dfn{printed representation} of an object is the format of the
 evaluation and reading are separate activities.  Reading returns the
 Lisp object represented by the text that is read; the object may or may
 not be evaluated later.  @xref{Input Functions}, for a description of
 @code{read}, the basic function for reading objects.
-@node Comments
+@node Comments, Primitive Types, Printed Representation, Lisp Data Types
 @section Comments
 @cindex comments
 @cindex @samp{;} in comment
 A @dfn{comment} is text that is written in a program only for the sake
 data.  The XEmacs Lisp byte compiler uses this in its output files
 (@pxref{Byte Compilation}).  It isn't meant for source files, however.
 @xref{Comment Tips}, for conventions for formatting comments.
-@node Primitive Types
+@node Primitive Types, Programming Types, Comments, Lisp Data Types
 @section Primitive Types
 @cindex primitive types
 For reference, here is a list of all the primitive types that may
 exist in XEmacs.  Note that some of these types may not exist
 symbol-value-varalias
 @item
 toolbar-data
 @end itemize
-@node Programming Types
+@node Programming Types, Editing Types, Primitive Types, Lisp Data Types
 @section Programming Types
 @cindex programming types
 There are two general categories of types in XEmacs Lisp: those having
 to do with Lisp programming, and those having to do with editing.  The
 * Hash Table Type::     A fast mapping between Lisp objects.
 * Range Table Type::    A mapping from ranges of integers to Lisp objects.
 * Weak List Type::      A list with special garbage-collection properties.
 @end menu
-@node Integer Type
+@node Integer Type, Floating Point Type, Programming Types, Programming Types
 @subsection Integer Type
 In XEmacs Lisp, integers can be fixnums (that is, fixed-precision
 integers) or bignums (arbitrary-precision integers), if compile-time
 configuration supports this.  The read syntax for the two types is the
 @end group
 @end example
 @xref{Numbers}, for more information.
-@node Floating Point Type
+@node Floating Point Type, Character Type, Integer Type, Programming Types
 @subsection Floating Point Type
 XEmacs supports floating point numbers.  The precise range of floating
 point numbers is machine-specific.
 @samp{1.5e3}, and @samp{.15e4} are five ways of writing a floating point
 number whose value is 1500.  They are all equivalent.
 @xref{Numbers}, for more information.
-@node Character Type
+@node Character Type, Symbol Type, Floating Point Type, Programming Types
 @subsection Character Type
 @cindex @sc{ascii} character codes
 @cindex char-int confoundance disease
 In XEmacs version 19, and in all versions of FSF GNU Emacs, a
 Lisp code.  Also add a backslash before whitespace characters such as
 space, tab, newline and formfeed.  However, it is cleaner to use one of
 the easily readable escape sequences, such as @samp{\t}, instead of an
 actual whitespace character such as a tab.
-@node Symbol Type
+@node Symbol Type, Sequence Type, Character Type, Programming Types
 @subsection Symbol Type
 A @dfn{symbol} in XEmacs Lisp is an object with a name.  The symbol
 name serves as the printed representation of the symbol.  In ordinary
 use, the name is unique---no two symbols have the same name.
 +-*/_~!@@$%^&=:<>@{@}  ; @r{A symbol named @samp{+-*/_~!@@$%^&=:<>@{@}}.}
 ;   @r{These characters need not be escaped.}
 @end group
 @end example
-@node Sequence Type
+@node Sequence Type, Cons Cell Type, Symbol Type, Programming Types
 @subsection Sequence Types
 A @dfn{sequence} is a Lisp object that represents an ordered set of
 elements.  There are two kinds of sequence in XEmacs Lisp, lists and
 arrays.  Thus, an object of type list or of type array is also
 always created anew upon reading.  If you read the read syntax for a
 sequence twice, you get two sequences with equal contents.  There is one
 exception: the empty list @code{()} always stands for the same object,
 @code{nil}.
-@node Cons Cell Type
+@node Cons Cell Type, Array Type, Sequence Type, Programming Types
 @subsection Cons Cell and List Types
 @cindex address field of register
 @cindex decrement field of register
 A @dfn{cons cell} is an object comprising two pointers named the
 @menu
 * Dotted Pair Notation::        An alternative syntax for lists.
 * Association List Type::       A specially constructed list.
 @end menu
-@node Dotted Pair Notation
+@node Dotted Pair Notation, Association List Type, Cons Cell Type, Cons Cell Type
 @subsubsection Dotted Pair Notation
 @cindex dotted pair notation
 @cindex @samp{.} in lists
 @dfn{Dotted pair notation} is an alternative syntax for cons cells
 --> rose     --> violet   --> buttercup
 @end group
 @end example
 @end ifinfo
-@node Association List Type
+@node Association List Type,  , Dotted Pair Notation, Cons Cell Type
 @subsubsection Association List Type
 An @dfn{association list} or @dfn{alist} is a specially-constructed
 list whose elements are cons cells.  In each element, the @sc{car} is
 considered a @dfn{key}, and the @sc{cdr} is considered an
 first element, @code{rose} is the key and @code{red} is the value.
 @xref{Association Lists}, for a further explanation of alists and for
 functions that work on alists.
-@node Array Type
+@node Array Type, String Type, Cons Cell Type, Programming Types
 @subsection Array Type
 An @dfn{array} is composed of an arbitrary number of slots for
 referring to other Lisp objects, arranged in a contiguous block of
 memory.  Accessing any element of an array takes the same amount of
 indices 0, 1, 2, @w{and 3}.
 The array type is contained in the sequence type and contains the
 string type, the vector type, and the bit vector type.
-@node String Type
+@node String Type, Vector Type, Array Type, Programming Types
 @subsection String Type
 A @dfn{string} is an array of characters.  Strings are used for many
 purposes in XEmacs, as can be expected in a text editor; for example, as
 the names of Lisp symbols, as messages for the user, and to represent
 that range.
 @end ignore
 @xref{Strings and Characters}, for functions that work on strings.
-@node Vector Type
+@node Vector Type, Bit Vector Type, String Type, Programming Types
 @subsection Vector Type
 A @dfn{vector} is a one-dimensional array of elements of any type.  It
 takes a constant amount of time to access any element of a vector.  (In
 a list, the access time of an element is proportional to the distance of
 @result{} [1 "two" (three)]
 @end example
 @xref{Vectors}, for functions that work with vectors.
-@node Bit Vector Type
+@node Bit Vector Type, Function Type, Vector Type, Programming Types
 @subsection Bit Vector Type
 A @dfn{bit vector} is a one-dimensional array of 1's and 0's.  It
 takes a constant amount of time to access any element of a bit vector,
 as for vectors.  Bit vectors have an extremely compact internal
 @result{} #*00101000
 @end example
 @xref{Bit Vectors}, for functions that work with bit vectors.
-@node Function Type
+@node Function Type, Macro Type, Bit Vector Type, Programming Types
 @subsection Function Type
 Just as functions in other programming languages are executable,
 @dfn{Lisp function} objects are pieces of executable code.  However,
 functions in Lisp are primarily Lisp objects, and only secondarily the
 Most of the time, functions are called when their names are written in
 Lisp expressions in Lisp programs.  However, you can construct or obtain
 a function object at run time and then call it with the primitive
 functions @code{funcall} and @code{apply}.  @xref{Calling Functions}.
-@node Macro Type
+@node Macro Type, Primitive Function Type, Function Type, Programming Types
 @subsection Macro Type
 A @dfn{Lisp macro} is a user-defined construct that extends the Lisp
 language.  It is represented as an object much like a function, but with
 different parameter-passing semantics.  A Lisp macro has the form of a
 Lisp macro objects are usually defined with the built-in
 @code{defmacro} function, but any list that begins with @code{macro} is
 a macro as far as XEmacs is concerned.  @xref{Macros}, for an explanation
 of how to write a macro.
-@node Primitive Function Type
+@node Primitive Function Type, Compiled-Function Type, Macro Type, Programming Types
 @subsection Primitive Function Type
 @cindex special operators
 A @dfn{primitive function} is a function callable from Lisp but
 written in the C programming language.  Primitive functions are also
 (subrp (symbol-function 'car))  ; @r{Is this a primitive function?}
 @result{} t                       ; @r{Yes.}
 @end group
 @end example
-@node Compiled-Function Type
+@node Compiled-Function Type, Autoload Type, Primitive Function Type, Programming Types
 @subsection Compiled-Function Type
 The byte compiler produces @dfn{compiled-function objects}.  The
 evaluator handles this data type specially when it appears as a function
 to be called.  @xref{Byte Compilation}, for information about the byte
 The printed representation for a compiled-function object is normally
 @samp{#<compiled-function...>}.  If @code{print-readably} is true,
 however, it is @samp{#[...]}.
-@node Autoload Type
+@node Autoload Type, Char Table Type, Compiled-Function Type, Programming Types
 @subsection Autoload Type
 An @dfn{autoload object} is a list whose first element is the symbol
 @code{autoload}.  It is stored as the function definition of a symbol as
 a placeholder for the real definition; it says that the real definition
 An autoload object is usually created with the function
 @code{autoload}, which stores the object in the function cell of a
 symbol.  @xref{Autoload}, for more details.
-@node Char Table Type
+@node Char Table Type, Hash Table Type, Autoload Type, Programming Types
 @subsection Char Table Type
 @cindex char table type
 (not yet documented)
-@node Hash Table Type
+@node Hash Table Type, Range Table Type, Char Table Type, Programming Types
 @subsection Hash Table Type
 @cindex hash table type
 A @dfn{hash table} is a table providing an arbitrary mapping from
 one Lisp object to another, using an internal indexing method
 @end example
 @xref{Hash Tables}, for information on how to create and work with hash
 tables.
-@node Range Table Type
+@node Range Table Type, Weak List Type, Hash Table Type, Programming Types
 @subsection Range Table Type
 @cindex range table type
 A @dfn{range table} is a table that maps from ranges of fixnums to
 arbitrary Lisp objects.  Range tables automatically combine overlapping
 @end example
 @xref{Range Tables}, for information on how to create and work with range
 tables.
-@node Weak List Type
+@node Weak List Type,  , Range Table Type, Programming Types
 @subsection Weak List Type
 @cindex weak list type
 (not yet documented)
-@node Editing Types
+@node Editing Types, Window-System Types, Programming Types, Lisp Data Types
 @section Editing Types
 @cindex editing types
 The types in the previous section are common to many Lisp dialects.
 XEmacs Lisp provides several additional data types for purposes connected
 different textual encodings, under XEmacs/MULE.
 * ToolTalk Message Type:: A message, in the ToolTalk IPC protocol.
 * ToolTalk Pattern Type:: A pattern, in the ToolTalk IPC protocol.
 @end menu
-@node Buffer Type
+@node Buffer Type, Marker Type, Editing Types, Editing Types
 @subsection Buffer Type
 A @dfn{buffer} is an object that holds text that can be edited
 (@pxref{Buffers}).  Most buffers hold the contents of a disk file
 (@pxref{Files}) so they can be edited, but some are used for other
 (current-buffer)
 @result{} #<buffer "objects.texi">
 @end group
 @end example
-@node Marker Type
+@node Marker Type, Extent Type, Buffer Type, Editing Types
 @subsection Marker Type
 A @dfn{marker} denotes a position in a specific buffer.  Markers
 therefore have two components: one for the buffer, and one for the
 position.  Changes in the buffer's text automatically relocate the
 @end example
 @xref{Markers}, for information on how to test, create, copy, and move
 markers.
-@node Extent Type
+@node Extent Type, Window Type, Marker Type, Editing Types
 @subsection Extent Type
 An @dfn{extent} specifies temporary alteration of the display
 appearance of a part of a buffer (or string).  It contains markers
 delimiting a range of the buffer, plus a property list (a list whose
 @xref{Extents}, for how to create and use extents.
 Extents are used to implement text properties.  @xref{Text Properties}.
-@node Window Type
+@node Window Type, Frame Type, Extent Type, Editing Types
 @subsection Window Type
 A @dfn{window} describes the portion of the frame that XEmacs uses to
 display a buffer. (In standard window-system usage, a @dfn{window} is
 what XEmacs calls a @dfn{frame}; XEmacs confusingly uses the term
 @end group
 @end example
 @xref{Windows}, for a description of the functions that work on windows.
-@node Frame Type
+@node Frame Type, Device Type, Window Type, Editing Types
 @subsection Frame Type
 A @var{frame} is a rectangle on the screen (a @dfn{window} in standard
 window-system terminology) that contains one or more non-overlapping
 Emacs windows (@dfn{panes} in standard window-system terminology).  A
 @end group
 @end example
 @xref{Frames}, for a description of the functions that work on frames.
-@node Device Type
+@node Device Type, Console Type, Frame Type, Editing Types
 @subsection Device Type
 A @dfn{device} represents a single display on which frames exist.
 Normally, there is only one device object, but there may be more
 than one if XEmacs is being run on a multi-headed display (e.g. an
 @end example
 @xref{Consoles and Devices}, for a description of several functions
 related to devices.
-@node Console Type
+@node Console Type, Window Configuration Type, Device Type, Editing Types
 @subsection Console Type
 A @dfn{console} represents a single keyboard to which devices
 (i.e. displays on which frames exist) are connected.  Normally, there is
 only one console object, but there may be more than one if XEmacs is
 @end example
 @xref{Consoles and Devices}, for a description of several functions
 related to consoles.
-@node Window Configuration Type
+@node Window Configuration Type, Event Type, Console Type, Editing Types
 @subsection Window Configuration Type
 @cindex screen layout
 A @dfn{window configuration} stores information about the positions,
 sizes, and contents of the windows in a frame, so you can recreate the
 @end example
 @xref{Window Configurations}, for a description of several functions
 related to window configurations.
-@node Event Type
+@node Event Type, Process Type, Window Configuration Type, Editing Types
 @subsection Event Type
 (not yet documented)
-@node Process Type
+@node Process Type, Stream Type, Event Type, Editing Types
 @subsection Process Type
 The word @dfn{process} usually means a running program.  XEmacs itself
 runs in a process of this sort.  However, in XEmacs Lisp, a process is a
 Lisp object that designates a subprocess created by the XEmacs process.
 @xref{Processes}, for information about functions that create, delete,
 return information about, send input or signals to, and receive output
 from processes.
-@node Stream Type
+@node Stream Type, Keymap Type, Process Type, Editing Types
 @subsection Stream Type
 A @dfn{stream} is an object that can be used as a source or sink for
 characters---either to supply characters for input or to accept them as
 output.  Many different types can be used this way: markers, buffers,
 print as whatever primitive type they are.
 @xref{Read and Print}, for a description of functions
 related to streams, including parsing and printing functions.
-@node Keymap Type
+@node Keymap Type, Syntax Table Type, Stream Type, Editing Types
 @subsection Keymap Type
 A @dfn{keymap} maps keys typed by the user to commands.  This mapping
 controls how the user's command input is executed.
 @code{keymap}.
 @xref{Keymaps}, for information about creating keymaps, handling prefix
 keys, local as well as global keymaps, and changing key bindings.
-@node Syntax Table Type
+@node Syntax Table Type, Display Table Type, Keymap Type, Editing Types
 @subsection Syntax Table Type
 Under XEmacs 20, a @dfn{syntax table} is a particular type of char
 table.  Under XEmacs 19, a syntax table is a vector of 256 integers.  In
 both cases, each element defines how one character is interpreted when it
 instead of @samp{(} and @samp{)} would be impossible.
 @xref{Syntax Tables}, for details about syntax classes and how to make
 and modify syntax tables.
-@node Display Table Type
+@node Display Table Type, Database Type, Syntax Table Type, Editing Types
 @subsection Display Table Type
 A @dfn{display table} specifies how to display each character code.
 Each buffer and each window can have its own display table.  A display
 table is actually a vector of length 256, although in XEmacs 20 this may
 change to be a particular type of char table.  @xref{Display Tables}.
-@node Database Type
+@node Database Type, Charset Type, Display Table Type, Editing Types
 @subsection Database Type
 @cindex database type
 (not yet documented)
-@node Charset Type
+@node Charset Type, Coding System Type, Database Type, Editing Types
 @subsection Charset Type
 @cindex charset type
 (not yet documented)
-@node Coding System Type
+@node Coding System Type, ToolTalk Message Type, Charset Type, Editing Types
 @subsection Coding System Type
 @cindex coding system type
 (not yet documented)
-@node ToolTalk Message Type
+@node ToolTalk Message Type, ToolTalk Pattern Type, Coding System Type, Editing Types
 @subsection ToolTalk Message Type
 (not yet documented)
-@node ToolTalk Pattern Type
+@node ToolTalk Pattern Type,  , ToolTalk Message Type, Editing Types
 @subsection ToolTalk Pattern Type
 (not yet documented)
-@node Window-System Types
+@node Window-System Types, Type Predicates, Editing Types, Lisp Data Types
 @section Window-System Types
 @cindex window system types
 XEmacs also has some types that represent objects such as faces
 (collections of display characters), fonts, and pixmaps that are
 appearing in a buffer.
 * X Resource Type::     A miscellaneous X resource, if Epoch support was
 compiled into XEmacs.
 @end menu
-@node Face Type
+@node Face Type, Glyph Type, Window-System Types, Window-System Types
 @subsection Face Type
 @cindex face type
 (not yet documented)
-@node Glyph Type
+@node Glyph Type, Specifier Type, Face Type, Window-System Types
 @subsection Glyph Type
 @cindex glyph type
 (not yet documented)
-@node Specifier Type
+@node Specifier Type, Font Instance Type, Glyph Type, Window-System Types
 @subsection Specifier Type
 @cindex specifier type
 (not yet documented)
-@node Font Instance Type
+@node Font Instance Type, Color Instance Type, Specifier Type, Window-System Types
 @subsection Font Instance Type
 @cindex font instance type
 (not yet documented)
-@node Color Instance Type
+@node Color Instance Type, Image Instance Type, Font Instance Type, Window-System Types
 @subsection Color Instance Type
 @cindex color instance type
 (not yet documented)
-@node Image Instance Type
+@node Image Instance Type, Toolbar Button Type, Color Instance Type, Window-System Types
 @subsection Image Instance Type
 @cindex image instance type
 (not yet documented)
-@node Toolbar Button Type
+@node Toolbar Button Type, Subwindow Type, Image Instance Type, Window-System Types
 @subsection Toolbar Button Type
 @cindex toolbar button type
 (not yet documented)
-@node Subwindow Type
+@node Subwindow Type, X Resource Type, Toolbar Button Type, Window-System Types
 @subsection Subwindow Type
 @cindex subwindow type
 (not yet documented)
-@node X Resource Type
+@node X Resource Type,  , Subwindow Type, Window-System Types
 @subsection X Resource Type
 @cindex X resource type
 (not yet documented)
-@node Type Predicates
+@node Type Predicates, Equality Predicates, Window-System Types, Lisp Data Types
 @section Type Predicates
 @cindex predicates
 @cindex type checking
 @kindex wrong-type-argument
 (type-of '(x))
 @result{} cons
 @end example
 @end defun
-@node Equality Predicates
+@node Equality Predicates,  , Type Predicates, Lisp Data Types
 @section Equality Predicates
 @cindex equality
 Here we describe functions that test for equality between any two
 objects.  Other functions test equality between objects of specific

Mercurial > hg > xemacs-beta

comparison man/lispref/objects.texi @ 5791:9fae6227ede5