(lgrep, rgrep): Use add-to-history.

[gnu-emacs] / lispref / objects.texi

diff --git a/lispref/objects.texi b/lispref/objects.texi
index 8904bfba4838672427927254d73e873196ccb64e..5665e5beee6de5e9db8ad51dd9a302deab923fda 100644 (file)
--- a/lispref/objects.texi
+++ b/lispref/objects.texi
@@ -1,7 +1,7 @@
 @c -*-texinfo-*-
 @c This is part of the GNU Emacs Lisp Reference Manual.
 @c -*-texinfo-*-
 @c This is part of the GNU Emacs Lisp Reference Manual.

-@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999
-@c   Free Software Foundation, Inc. 
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2002, 2003,
+@c   2004, 2005, 2006 Free Software Foundation, Inc.

 @c See the file elisp.texi for copying conditions.
 @setfilename ../info/objects
 @node Lisp Data Types, Numbers, Introduction, Top
 @c See the file elisp.texi for copying conditions.
 @setfilename ../info/objects
 @node Lisp Data Types, Numbers, Introduction, Top


@@ -42,7 +42,9 @@ it as a number; Lisp knows it is a vector, not a number.
 variable, and the type is known by the compiler but not represented in
 the data.  Such type declarations do not exist in Emacs Lisp.  A Lisp
 variable can have any type of value, and it remembers whatever value
 variable, and the type is known by the compiler but not represented in
 the data.  Such type declarations do not exist in Emacs Lisp.  A Lisp
 variable can have any type of value, and it remembers whatever value

-you store in it, type and all.
+you store in it, type and all.  (Actually, a small number of Emacs
+Lisp variables can only take on values of a certain type.
+@xref{Variables with Restricted Values}.)

 
   This chapter describes the purpose, printed representation, and read
 syntax of each of the standard types in GNU Emacs Lisp.  Details on how
 
   This chapter describes the purpose, printed representation, and read
 syntax of each of the standard types in GNU Emacs Lisp.  Details on how


@@ -66,36 +68,37 @@ to use these types can be found in later chapters.
 
   The @dfn{printed representation} of an object is the format of the
 output generated by the Lisp printer (the function @code{prin1}) for
 
   The @dfn{printed representation} of an object is the format of the
 output generated by the Lisp printer (the function @code{prin1}) for

-that object.  The @dfn{read syntax} of an object is the format of the
-input accepted by the Lisp reader (the function @code{read}) for that
-object.  @xref{Read and Print}.
-
-  Most objects have more than one possible read syntax.  Some types of
-object have no read syntax, since it may not make sense to enter objects
-of these types directly in a Lisp program.  Except for these cases, the
-printed representation of an object is also a read syntax for it.
-
-  In other languages, an expression is text; it has no other form.  In
-Lisp, an expression is primarily a Lisp object and only secondarily the
-text that is the object's read syntax.  Often there is no need to
-emphasize this distinction, but you must keep it in the back of your
-mind, or you will occasionally be very confused.
+that object.  Every data type has a unique printed representation.
+The @dfn{read syntax} of an object is the format of the input accepted
+by the Lisp reader (the function @code{read}) for that object.  This
+is not necessarily unique; many kinds of object have more than one
+syntax.  @xref{Read and Print}.

 
 @cindex hash notation
 
 @cindex hash notation

-  Every type has a printed representation.  Some types have no read
-syntax---for example, the buffer type has none.  Objects of these types
-are printed in @dfn{hash notation}: the characters @samp{#<} followed by
-a descriptive string (typically the type name followed by the name of
-the object), and closed with a matching @samp{>}.  Hash notation cannot
-be read at all, so the Lisp reader signals the error
-@code{invalid-read-syntax} whenever it encounters @samp{#<}.
-@kindex invalid-read-syntax
+  In most cases, an object's printed representation is also a read
+syntax for the object.  However, some types have no read syntax, since
+it does not make sense to enter objects of these types as constants in
+a Lisp program.  These objects are printed in @dfn{hash notation},
+which consists of the characters @samp{#<}, a descriptive string
+(typically the type name followed by the name of the object), and a
+closing @samp{>}.  For example:

 
 @example
 (current-buffer)
      @result{} #<buffer objects.texi>
 @end example
 
 
 @example
 (current-buffer)
      @result{} #<buffer objects.texi>
 @end example
 

+@noindent
+Hash notation cannot be read at all, so the Lisp reader signals the
+error @code{invalid-read-syntax} whenever it encounters @samp{#<}.
+@kindex invalid-read-syntax
+
+  In other languages, an expression is text; it has no other form.  In
+Lisp, an expression is primarily a Lisp object and only secondarily the
+text that is the object's read syntax.  Often there is no need to
+emphasize this distinction, but you must keep it in the back of your
+mind, or you will occasionally be very confused.
+

   When you evaluate an expression interactively, the Lisp interpreter
 first reads the textual representation of it, producing a Lisp object,
 and then evaluates that object (@pxref{Evaluation}).  However,
   When you evaluate an expression interactively, the Lisp interpreter
 first reads the textual representation of it, producing a Lisp object,
 and then evaluates that object (@pxref{Evaluation}).  However,


@@ -161,24 +164,24 @@ latter are unique to Emacs Lisp.
 @node Integer Type
 @subsection Integer Type
 
 @node Integer Type
 @subsection Integer Type
 

-  The range of values for integers in Emacs Lisp is @minus{}134217728 to
-134217727 (28 bits; i.e.,
+  The range of values for integers in Emacs Lisp is @minus{}268435456 to
+268435455 (29 bits; i.e.,

 @ifnottex
 @ifnottex

--2**27
+-2**28

 @end ifnottex
 @tex
 @end ifnottex
 @tex

-@math{-2^{27}}
+@math{-2^{28}}

 @end tex
 to
 @ifnottex
 @end tex
 to
 @ifnottex

-2**27 - 1)
+2**28 - 1)

 @end ifnottex
 @tex
 @math{2^{28}-1})
 @end tex
 on most machines.  (Some machines may provide a wider range.)  It is
 important to note that the Emacs Lisp arithmetic functions do not check
 @end ifnottex
 @tex
 @math{2^{28}-1})
 @end tex
 on most machines.  (Some machines may provide a wider range.)  It is
 important to note that the Emacs Lisp arithmetic functions do not check

-for overflow.  Thus @code{(1+ 134217727)} is @minus{}134217728 on most
+for overflow.  Thus @code{(1+ 268435455)} is @minus{}268435456 on most

 machines.
 
   The read syntax for integers is a sequence of (base ten) digits with an
 machines.
 
   The read syntax for integers is a sequence of (base ten) digits with an


@@ -192,7 +195,7 @@ leading @samp{+} or a final @samp{.}.
 1                ; @r{The integer 1.}
 1.               ; @r{Also the integer 1.}
 +1               ; @r{Also the integer 1.}
 1                ; @r{The integer 1.}
 1.               ; @r{Also the integer 1.}
 +1               ; @r{Also the integer 1.}

-268435457        ; @r{Also the integer 1 on a 28-bit implementation.}
+536870913        ; @r{Also the integer 1 on a 29-bit implementation.}

 @end group
 @end example
 
 @end group
 @end example
 


@@ -201,9 +204,12 @@ leading @samp{+} or a final @samp{.}.
 @node Floating Point Type
 @subsection Floating Point Type
 
 @node Floating Point Type
 @subsection Floating Point Type
 

-  Emacs supports floating point numbers (though there is a compilation
-option to disable them).  The precise range of floating point numbers is
-machine-specific.
+  Floating point numbers are the computer equivalent of scientific
+notation; you can think of a floating point number as a fraction
+together with a power of ten.  The precise number of significant
+figures and the range of possible exponents is machine-specific; Emacs
+uses the C data type @code{double} to store the value, and internally
+this records a power of 2 rather than a power of 10.

 
   The printed representation for floating point numbers requires either
 a decimal point (with at least one digit following), an exponent, or
 
   The printed representation for floating point numbers requires either
 a decimal point (with at least one digit following), an exponent, or


@@ -215,7 +221,7 @@ number whose value is 1500.  They are all equivalent.
 
 @node Character Type
 @subsection Character Type
 
 @node Character Type
 @subsection Character Type

-@cindex @sc{ascii} character codes
+@cindex @acronym{ASCII} character codes

 
   A @dfn{character} in Emacs Lisp is nothing more than an integer.  In
 other words, characters are represented by their character codes.  For
 
   A @dfn{character} in Emacs Lisp is nothing more than an integer.  In
 other words, characters are represented by their character codes.  For


@@ -225,11 +231,12 @@ example, the character @kbd{A} is represented as the @w{integer 65}.
 common to work with @emph{strings}, which are sequences composed of
 characters.  @xref{String Type}.
 
 common to work with @emph{strings}, which are sequences composed of
 characters.  @xref{String Type}.
 

-  Characters in strings, buffers, and files are currently limited to the
-range of 0 to 524287---nineteen bits.  But not all values in that range
-are valid character codes.  Codes 0 through 127 are @sc{ascii} codes; the
-rest are non-@sc{ascii} (@pxref{Non-ASCII Characters}).  Characters that represent
-keyboard input have a much wider range, to encode modifier keys such as
+  Characters in strings, buffers, and files are currently limited to
+the range of 0 to 524287---nineteen bits.  But not all values in that
+range are valid character codes.  Codes 0 through 127 are
+@acronym{ASCII} codes; the rest are non-@acronym{ASCII}
+(@pxref{Non-ASCII Characters}).  Characters that represent keyboard
+input have a much wider range, to encode modifier keys such as

 Control, Meta and Shift.
 
 @cindex read syntax for characters
 Control, Meta and Shift.
 
 @cindex read syntax for characters


@@ -247,7 +254,7 @@ with a question mark.
   The usual read syntax for alphanumeric characters is a question mark
 followed by the character; thus, @samp{?A} for the character
 @kbd{A}, @samp{?B} for the character @kbd{B}, and @samp{?a} for the
   The usual read syntax for alphanumeric characters is a question mark
 followed by the character; thus, @samp{?A} for the character
 @kbd{A}, @samp{?B} for the character @kbd{B}, and @samp{?a} for the

-character @kbd{a}.  
+character @kbd{a}.

 
   For example:
 
 
   For example:
 


@@ -257,9 +264,9 @@ character @kbd{a}.
 
   You can use the same syntax for punctuation characters, but it is
 often a good idea to add a @samp{\} so that the Emacs commands for
 
   You can use the same syntax for punctuation characters, but it is
 often a good idea to add a @samp{\} so that the Emacs commands for

-editing Lisp code don't get confused.  For example, @samp{?\ } is the
-way to write the space character.  If the character is @samp{\}, you
-@emph{must} use a second @samp{\} to quote it: @samp{?\\}.
+editing Lisp code don't get confused.  For example, @samp{?\(} is the
+way to write the open-paren character.  If the character is @samp{\},
+you @emph{must} use a second @samp{\} to quote it: @samp{?\\}.

 
 @cindex whitespace
 @cindex bell character
 
 @cindex whitespace
 @cindex bell character


@@ -278,13 +285,17 @@ way to write the space character.  If the character is @samp{\}, you
 @cindex @samp{\r}
 @cindex escape
 @cindex @samp{\e}
 @cindex @samp{\r}
 @cindex escape
 @cindex @samp{\e}

-  You can express the characters Control-g, backspace, tab, newline,
-vertical tab, formfeed, return, and escape as @samp{?\a}, @samp{?\b},
-@samp{?\t}, @samp{?\n}, @samp{?\v}, @samp{?\f}, @samp{?\r}, @samp{?\e},
-respectively.  Thus,
+@cindex space
+@cindex @samp{\s}
+  You can express the characters control-g, backspace, tab, newline,
+vertical tab, formfeed, space, return, del, and escape as @samp{?\a},
+@samp{?\b}, @samp{?\t}, @samp{?\n}, @samp{?\v}, @samp{?\f},
+@samp{?\s}, @samp{?\r}, @samp{?\d}, and @samp{?\e}, respectively.
+(@samp{?\s} followed by a dash has a different meaning---it applies
+the ``super'' modifier to the following character.)  Thus,

 
 @example
 
 @example

-?\a @result{} 7                 ; @r{@kbd{C-g}}
+?\a @result{} 7                 ; @r{control-g, @kbd{C-g}}

 ?\b @result{} 8                 ; @r{backspace, @key{BS}, @kbd{C-h}}
 ?\t @result{} 9                 ; @r{tab, @key{TAB}, @kbd{C-i}}
 ?\n @result{} 10                ; @r{newline, @kbd{C-j}}
 ?\b @result{} 8                 ; @r{backspace, @key{BS}, @kbd{C-h}}
 ?\t @result{} 9                 ; @r{tab, @key{TAB}, @kbd{C-i}}
 ?\n @result{} 10                ; @r{newline, @kbd{C-j}}


@@ -292,14 +303,17 @@ respectively.  Thus,
 ?\f @result{} 12                ; @r{formfeed character, @kbd{C-l}}
 ?\r @result{} 13                ; @r{carriage return, @key{RET}, @kbd{C-m}}
 ?\e @result{} 27                ; @r{escape character, @key{ESC}, @kbd{C-[}}
 ?\f @result{} 12                ; @r{formfeed character, @kbd{C-l}}
 ?\r @result{} 13                ; @r{carriage return, @key{RET}, @kbd{C-m}}
 ?\e @result{} 27                ; @r{escape character, @key{ESC}, @kbd{C-[}}

+?\s @result{} 32                ; @r{space character, @key{SPC}}

 ?\\ @result{} 92                ; @r{backslash character, @kbd{\}}
 ?\d @result{} 127               ; @r{delete character, @key{DEL}}
 @end example
 
 @cindex escape sequence
   These sequences which start with backslash are also known as
 ?\\ @result{} 92                ; @r{backslash character, @kbd{\}}
 ?\d @result{} 127               ; @r{delete character, @key{DEL}}
 @end example
 
 @cindex escape sequence
   These sequences which start with backslash are also known as

-@dfn{escape sequences}, because backslash plays the role of an escape
-character; this usage has nothing to do with the character @key{ESC}.
+@dfn{escape sequences}, because backslash plays the role of an
+``escape character''; this terminology has nothing to do with the
+character @key{ESC}.  @samp{\s} is meant for use in character
+constants; in string constants, just write the space.

 
 @cindex control characters
   Control characters may be represented using yet another read syntax.
 
 @cindex control characters
   Control characters may be represented using yet another read syntax.


@@ -316,9 +330,9 @@ equivalent to @samp{?\^I} and to @samp{?\^i}:
 @end example
 
   In strings and buffers, the only control characters allowed are those
 @end example
 
   In strings and buffers, the only control characters allowed are those

-that exist in @sc{ascii}; but for keyboard input purposes, you can turn
+that exist in @acronym{ASCII}; but for keyboard input purposes, you can turn

 any character into a control character with @samp{C-}.  The character
 any character into a control character with @samp{C-}.  The character

-codes for these non-@sc{ascii} control characters include the
+codes for these non-@acronym{ASCII} control characters include the

 @tex
 @math{2^{26}}
 @end tex
 @tex
 @math{2^{26}}
 @end tex


@@ -326,7 +340,7 @@ codes for these non-@sc{ascii} control characters include the
 2**26
 @end ifnottex
 bit as well as the code for the corresponding non-control
 2**26
 @end ifnottex
 bit as well as the code for the corresponding non-control

-character.  Ordinary terminals have no way of generating non-@sc{ascii}
+character.  Ordinary terminals have no way of generating non-@acronym{ASCII}

 control characters, but you can generate them straightforwardly using X
 and other window systems.
 
 control characters, but you can generate them straightforwardly using X
 and other window systems.
 


@@ -358,9 +372,8 @@ modifier key.  The integer that represents such a character has the
 @ifnottex
 2**27
 @end ifnottex
 @ifnottex
 2**27
 @end ifnottex

-bit set (which on most machines makes it a negative number).  We
-use high bits for this and other modifiers to make possible a wide range
-of basic character codes.
+bit set.  We use high bits for this and other modifiers to make
+possible a wide range of basic character codes.

 
   In a string, the
 @tex
 
   In a string, the
 @tex


@@ -369,11 +382,11 @@ of basic character codes.
 @ifnottex
 2**7
 @end ifnottex
 @ifnottex
 2**7
 @end ifnottex

-bit attached to an @sc{ascii} character indicates a meta character; thus, the
-meta characters that can fit in a string have codes in the range from
-128 to 255, and are the meta versions of the ordinary @sc{ascii}
-characters.  (In Emacs versions 18 and older, this convention was used
-for characters outside of strings as well.)
+bit attached to an @acronym{ASCII} character indicates a meta
+character; thus, the meta characters that can fit in a string have
+codes in the range from 128 to 255, and are the meta versions of the
+ordinary @acronym{ASCII} characters.  (In Emacs versions 18 and older,
+this convention was used for characters outside of strings as well.)

 
   The read syntax for meta characters uses @samp{\M-}.  For example,
 @samp{?\M-A} stands for @kbd{M-A}.  You can use @samp{\M-} together with
 
   The read syntax for meta characters uses @samp{\M-}.  For example,
 @samp{?\M-A} stands for @kbd{M-A}.  You can use @samp{\M-} together with


@@ -383,8 +396,8 @@ or as @samp{?\M-\101}.  Likewise, you can write @kbd{C-M-b} as
 @samp{?\M-\C-b}, @samp{?\C-\M-b}, or @samp{?\M-\002}.
 
   The case of a graphic character is indicated by its character code;
 @samp{?\M-\C-b}, @samp{?\C-\M-b}, or @samp{?\M-\002}.
 
   The case of a graphic character is indicated by its character code;

-for example, @sc{ascii} distinguishes between the characters @samp{a}
-and @samp{A}.  But @sc{ascii} has no way to represent whether a control
+for example, @acronym{ASCII} distinguishes between the characters @samp{a}
+and @samp{A}.  But @acronym{ASCII} has no way to represent whether a control

 character is upper case or lower case.  Emacs uses the
 @tex
 @math{2^{25}}
 character is upper case or lower case.  Emacs uses the
 @tex
 @math{2^{25}}


@@ -396,20 +409,22 @@ bit to indicate that the shift key was used in typing a control
 character.  This distinction is possible only when you use X terminals
 or other special terminals; ordinary terminals do not report the
 distinction to the computer in any way.  The Lisp syntax for
 character.  This distinction is possible only when you use X terminals
 or other special terminals; ordinary terminals do not report the
 distinction to the computer in any way.  The Lisp syntax for

-the shift bit is @samp{\S-}; thus, @samp{?\C-\S-o} or @samp{?\C-\S-O} 
+the shift bit is @samp{\S-}; thus, @samp{?\C-\S-o} or @samp{?\C-\S-O}

 represents the shifted-control-o character.
 
 @cindex hyper characters
 @cindex super characters
 @cindex alt characters
 represents the shifted-control-o character.
 
 @cindex hyper characters
 @cindex super characters
 @cindex alt characters

-  The X Window System defines three other modifier bits that can be set
+  The X Window System defines three other
+@anchor{modifier bits}modifier bits that can be set

 in a character: @dfn{hyper}, @dfn{super} and @dfn{alt}.  The syntaxes
 for these bits are @samp{\H-}, @samp{\s-} and @samp{\A-}.  (Case is
 significant in these prefixes.)  Thus, @samp{?\H-\M-\A-x} represents
 in a character: @dfn{hyper}, @dfn{super} and @dfn{alt}.  The syntaxes
 for these bits are @samp{\H-}, @samp{\s-} and @samp{\A-}.  (Case is
 significant in these prefixes.)  Thus, @samp{?\H-\M-\A-x} represents

-@kbd{Alt-Hyper-Meta-x}.
+@kbd{Alt-Hyper-Meta-x}.  (Note that @samp{\s} with no following @samp{-}
+represents the space character.)

 @tex
 @tex

-Numerically, the
-bit values are @math{2^{22}} for alt, @math{2^{23}} for super and @math{2^{24}} for hyper.
+Numerically, the bit values are @math{2^{22}} for alt, @math{2^{23}}
+for super and @math{2^{24}} for hyper.

 @end tex
 @ifnottex
 Numerically, the
 @end tex
 @ifnottex
 Numerically, the


@@ -424,9 +439,9 @@ character code in either octal or hex.  To use octal, write a question
 mark followed by a backslash and the octal character code (up to three
 octal digits); thus, @samp{?\101} for the character @kbd{A},
 @samp{?\001} for the character @kbd{C-a}, and @code{?\002} for the
 mark followed by a backslash and the octal character code (up to three
 octal digits); thus, @samp{?\101} for the character @kbd{A},
 @samp{?\001} for the character @kbd{C-a}, and @code{?\002} for the

-character @kbd{C-b}.  Although this syntax can represent any @sc{ascii}
+character @kbd{C-b}.  Although this syntax can represent any @acronym{ASCII}

 character, it is preferred only when the precise octal value is more
 character, it is preferred only when the precise octal value is more

-important than the @sc{ascii} representation.
+important than the @acronym{ASCII} representation.

 
 @example
 @group
 
 @example
 @group


@@ -439,7 +454,7 @@ important than the @sc{ascii} representation.
 and the hexadecimal character code.  You can use any number of hex
 digits, so you can represent any character code in this way.
 Thus, @samp{?\x41} for the character @kbd{A}, @samp{?\x1} for the
 and the hexadecimal character code.  You can use any number of hex
 digits, so you can represent any character code in this way.
 Thus, @samp{?\x41} for the character @kbd{A}, @samp{?\x1} for the

-character @kbd{C-a}, and @code{?\x8e0} for the character
+character @kbd{C-a}, and @code{?\x8e0} for the Latin-1 character

 @iftex
 @samp{@`a}.
 @end iftex
 @iftex
 @samp{@`a}.
 @end iftex


@@ -452,17 +467,21 @@ a special escape meaning; thus, @samp{?\+} is equivalent to @samp{?+}.
 There is no reason to add a backslash before most characters.  However,
 you should add a backslash before any of the characters
 @samp{()\|;'`"#.,} to avoid confusing the Emacs commands for editing
 There is no reason to add a backslash before most characters.  However,
 you should add a backslash before any of the characters
 @samp{()\|;'`"#.,} to avoid confusing the Emacs commands for editing

-Lisp code.  Also add a backslash before whitespace characters such as
+Lisp code.  You can also add a backslash before whitespace characters such as

 space, tab, newline and formfeed.  However, it is cleaner to use one of
 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.
+the easily readable escape sequences, such as @samp{\t} or @samp{\s},
+instead of an actual whitespace character such as a tab or a space.
+(If you do write backslash followed by a space, you should write
+an extra space after the character constant to separate it from the
+following text.)

 
 @node Symbol Type
 @subsection Symbol Type
 
 
 @node Symbol Type
 @subsection Symbol Type
 

-  A @dfn{symbol} in GNU Emacs 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.
+  A @dfn{symbol} in GNU Emacs Lisp is an object with a name.  The
+symbol name serves as the printed representation of the symbol.  In
+ordinary Lisp use, with one single obarray (@pxref{Creating Symbols},
+a symbol's name is unique---no two symbols have the same name.

 
   A symbol can serve as a variable, as a function name, or to hold a
 property list.  Or it may serve only to be distinct from all other Lisp
 
   A symbol can serve as a variable, as a function name, or to hold a
 property list.  Or it may serve only to be distinct from all other Lisp


@@ -483,7 +502,7 @@ are written with letters, digits, and the punctuation characters
 @samp{-+=*/}.  Such names require no special punctuation; the characters
 of the name suffice as long as the name does not look like a number.
 (If it does, write a @samp{\} at the beginning of the name to force
 @samp{-+=*/}.  Such names require no special punctuation; the characters
 of the name suffice as long as the name does not look like a number.
 (If it does, write a @samp{\} at the beginning of the name to force

-interpretation as a symbol.)  The characters @samp{_~!@@$%^&:<>@{@}} are
+interpretation as a symbol.)  The characters @samp{_~!@@$%^&:<>@{@}?} are

 less often used but also require no special punctuation.  Any other
 characters may be included in a symbol's name by escaping them with a
 backslash.  In contrast to its use in strings, however, a backslash in
 less often used but also require no special punctuation.  Any other
 characters may be included in a symbol's name by escaping them with a
 backslash.  In contrast to its use in strings, however, a backslash in


@@ -503,7 +522,7 @@ Lisp, upper case and lower case letters are distinct.
 
   Here are several examples of symbol names.  Note that the @samp{+} in
 the fifth example is escaped to prevent it from being read as a number.
 
   Here are several examples of symbol names.  Note that the @samp{+} in
 the fifth example is escaped to prevent it from being read as a number.

-This is not necessary in the sixth example because the rest of the name
+This is not necessary in the fourth example because the rest of the name

 makes it invalid as a number.
 
 @example
 makes it invalid as a number.
 
 @example


@@ -529,7 +548,14 @@ char-to-string      ; @r{A symbol named @samp{char-to-string}.}
 @end group
 @end example
 
 @end group
 @end example
 

+@ifinfo
+@c This uses ``colon'' instead of a literal `:' because Info cannot
+@c cope with a `:' in a menu
+@cindex @samp{#@var{colon}} read syntax
+@end ifinfo
+@ifnotinfo

 @cindex @samp{#:} read syntax
 @cindex @samp{#:} read syntax

+@end ifnotinfo

   Normally the Lisp reader interns all symbols (@pxref{Creating
 Symbols}).  To prevent interning, you can write @samp{#:} before the
 name of the symbol.
   Normally the Lisp reader interns all symbols (@pxref{Creating
 Symbols}).  To prevent interning, you can write @samp{#:} before the
 name of the symbol.


@@ -545,11 +571,11 @@ considered a sequence.
   Arrays are further subdivided into strings, vectors, char-tables and
 bool-vectors.  Vectors can hold elements of any type, but string
 elements must be characters, and bool-vector elements must be @code{t}
   Arrays are further subdivided into strings, vectors, char-tables and
 bool-vectors.  Vectors can hold elements of any type, but string
 elements must be characters, and bool-vector elements must be @code{t}

-or @code{nil}.  The characters in a string can have text properties like
-characters in a buffer (@pxref{Text Properties}); vectors and
-bool-vectors do not support text properties even when their elements
-happen to be characters.  Char-tables are like vectors except that they
-are indexed by any valid character code.
+or @code{nil}.  Char-tables are like vectors except that they are
+indexed by any valid character code.  The characters in a string can
+have text properties like characters in a buffer (@pxref{Text
+Properties}), but vectors do not support text properties, even when
+their elements happen to be characters.

 
   Lists, strings and the other array types are different, but they have
 important similarities.  For example, all have a length @var{l}, and all
 
   Lists, strings and the other array types are different, but they have
 important similarities.  For example, all have a length @var{l}, and all


@@ -585,18 +611,10 @@ Lisp are implicit.
 
   A @dfn{list} is a series of cons cells, linked together so that the
 @sc{cdr} slot of each cons cell holds either the next cons cell or the
 
   A @dfn{list} is a series of cons cells, linked together so that the
 @sc{cdr} slot of each cons cell holds either the next cons cell or the

-empty list.  @xref{Lists}, for functions that work on lists.  Because
-most cons cells are used as part of lists, the phrase @dfn{list
-structure} has come to refer to any structure made out of cons cells.
-
-  The names @sc{car} and @sc{cdr} derive from the history of Lisp.  The
-original Lisp implementation ran on an @w{IBM 704} computer which
-divided words into two parts, called the ``address'' part and the
-``decrement''; @sc{car} was an instruction to extract the contents of
-the address part of a register, and @sc{cdr} an instruction to extract
-the contents of the decrement.  By contrast, ``cons cells'' are named
-for the function @code{cons} that creates them, which in turn was named
-for its purpose, the construction of cells.
+empty list.  The empty list is actually the symbol @code{nil}.
+@xref{Lists}, for functions that work on lists.  Because most cons
+cells are used as part of lists, the phrase @dfn{list structure} has
+come to refer to any structure made out of cons cells.

 
 @cindex atom
   Because cons cells are so central to Lisp, we also have a word for
 
 @cindex atom
   Because cons cells are so central to Lisp, we also have a word for


@@ -604,9 +622,21 @@ for its purpose, the construction of cells.
 @dfn{atoms}.
 
 @cindex parenthesis
 @dfn{atoms}.
 
 @cindex parenthesis

+@cindex @samp{(@dots{})} in lists

   The read syntax and printed representation for lists are identical, and
 consist of a left parenthesis, an arbitrary number of elements, and a
   The read syntax and printed representation for lists are identical, and
 consist of a left parenthesis, an arbitrary number of elements, and a

-right parenthesis.
+right parenthesis.  Here are examples of lists:
+
+@example
+(A 2 "A")            ; @r{A list of three elements.}
+()                   ; @r{A list of no elements (the empty list).}
+nil                  ; @r{A list of no elements (the empty list).}
+("A ()")             ; @r{A list of one element: the string @code{"A ()"}.}
+(A ())               ; @r{A list of two elements: @code{A} and the empty list.}
+(A nil)              ; @r{Equivalent to the previous.}
+((A B C))            ; @r{A list of one element}
+                     ;   @r{(which is a list of three elements).}
+@end example

 
    Upon reading, each object inside the parentheses becomes an element
 of the list.  That is, a cons cell is made for each element.  The
 
    Upon reading, each object inside the parentheses becomes an element
 of the list.  That is, a cons cell is made for each element.  The


@@ -615,8 +645,26 @@ slot refers to the next cons cell of the list, which holds the next
 element in the list.  The @sc{cdr} slot of the last cons cell is set to
 hold @code{nil}.
 
 element in the list.  The @sc{cdr} slot of the last cons cell is set to
 hold @code{nil}.
 

+  The names @sc{car} and @sc{cdr} derive from the history of Lisp.  The
+original Lisp implementation ran on an @w{IBM 704} computer which
+divided words into two parts, called the ``address'' part and the
+``decrement''; @sc{car} was an instruction to extract the contents of
+the address part of a register, and @sc{cdr} an instruction to extract
+the contents of the decrement.  By contrast, ``cons cells'' are named
+for the function @code{cons} that creates them, which in turn was named
+for its purpose, the construction of cells.
+
+@menu
+* Box Diagrams::                Drawing pictures of lists.
+* Dotted Pair Notation::        A general syntax for cons cells.
+* Association List Type::       A specially constructed list.
+@end menu
+
+@node Box Diagrams
+@subsubsection Drawing Lists as Box Diagrams

 @cindex box diagrams, for lists
 @cindex diagrams, boxed, for lists
 @cindex box diagrams, for lists
 @cindex diagrams, boxed, for lists

+

   A list can be illustrated by a diagram in which the cons cells are
 shown as pairs of boxes, like dominoes.  (The Lisp reader cannot read
 such an illustration; unlike the textual notation, which can be
   A list can be illustrated by a diagram in which the cons cells are
 shown as pairs of boxes, like dominoes.  (The Lisp reader cannot read
 such an illustration; unlike the textual notation, which can be


@@ -660,26 +708,12 @@ buttercup)}, sketched in a different manner:
 @end group
 @end smallexample
 
 @end group
 @end smallexample
 

-@cindex @samp{(@dots{})} in lists

 @cindex @code{nil} in lists
 @cindex empty list
   A list with no elements in it is the @dfn{empty list}; it is identical
 to the symbol @code{nil}.  In other words, @code{nil} is both a symbol
 and a list.
 
 @cindex @code{nil} in lists
 @cindex empty list
   A list with no elements in it is the @dfn{empty list}; it is identical
 to the symbol @code{nil}.  In other words, @code{nil} is both a symbol
 and a list.
 

-  Here are examples of lists written in Lisp syntax:
-
-@example
-(A 2 "A")            ; @r{A list of three elements.}
-()                   ; @r{A list of no elements (the empty list).}
-nil                  ; @r{A list of no elements (the empty list).}
-("A ()")             ; @r{A list of one element: the string @code{"A ()"}.}
-(A ())               ; @r{A list of two elements: @code{A} and the empty list.}
-(A nil)              ; @r{Equivalent to the previous.}
-((A B C))            ; @r{A list of one element}
-                     ;   @r{(which is a list of three elements).}
-@end example
-

   Here is the list @code{(A ())}, or equivalently @code{(A nil)},
 depicted with boxes and arrows:
 
   Here is the list @code{(A ())}, or equivalently @code{(A nil)},
 depicted with boxes and arrows:
 


@@ -694,27 +728,64 @@ depicted with boxes and arrows:
 @end group
 @end example
 
 @end group
 @end example
 

-@menu
-* Dotted Pair Notation::        An alternative syntax for lists.
-* Association List Type::       A specially constructed list.
-@end menu
+  Here is a more complex illustration, showing the three-element list,
+@code{((pine needles) oak maple)}, the first element of which is a
+two-element list:
+
+@example
+@group
+    --- ---      --- ---      --- ---
+   |   |   |--> |   |   |--> |   |   |--> nil
+    --- ---      --- ---      --- ---
+     |            |            |
+     |            |            |
+     |             --> oak      --> maple
+     |
+     |     --- ---      --- ---
+      --> |   |   |--> |   |   |--> nil
+           --- ---      --- ---
+            |            |
+            |            |
+             --> pine     --> needles
+@end group
+@end example
+
+  The same list represented in the second box notation looks like this:
+
+@example
+@group
+ --------------       --------------       --------------
+| car   | cdr  |     | car   | cdr  |     | car   | cdr  |
+|   o   |   o------->| oak   |   o------->| maple |  nil |
+|   |   |      |     |       |      |     |       |      |
+ -- | ---------       --------------       --------------
+    |
+    |
+    |        --------------       ----------------
+    |       | car   | cdr  |     | car     | cdr  |
+     ------>| pine  |   o------->| needles |  nil |
+            |       |      |     |         |      |
+             --------------       ----------------
+@end group
+@end example

 
 @node Dotted Pair Notation
 
 @node Dotted Pair Notation

-@comment  node-name,  next,  previous,  up

 @subsubsection Dotted Pair Notation
 @cindex dotted pair notation
 @cindex @samp{.} in lists
 
 @subsubsection Dotted Pair Notation
 @cindex dotted pair notation
 @cindex @samp{.} in lists
 

-  @dfn{Dotted pair notation} is an alternative syntax for cons cells
-that represents the @sc{car} and @sc{cdr} explicitly.  In this syntax,
+  @dfn{Dotted pair notation} is a general syntax for cons cells that
+represents the @sc{car} and @sc{cdr} explicitly.  In this syntax,

 @code{(@var{a} .@: @var{b})} stands for a cons cell whose @sc{car} is
 @code{(@var{a} .@: @var{b})} stands for a cons cell whose @sc{car} is

-the object @var{a}, and whose @sc{cdr} is the object @var{b}.  Dotted
-pair notation is therefore more general than list syntax.  In the dotted
-pair notation, the list @samp{(1 2 3)} is written as @samp{(1 .  (2 . (3
-. nil)))}.  For @code{nil}-terminated lists, you can use either
-notation, but list notation is usually clearer and more convenient.
-When printing a list, the dotted pair notation is only used if the
-@sc{cdr} of a cons cell is not a list.
+the object @var{a} and whose @sc{cdr} is the object @var{b}.  Dotted
+pair notation is more general than list syntax because the @sc{cdr}
+does not have to be a list.  However, it is more cumbersome in cases
+where list syntax would work.  In dotted pair notation, the list
+@samp{(1 2 3)} is written as @samp{(1 .  (2 . (3 . nil)))}.  For
+@code{nil}-terminated lists, you can use either notation, but list
+notation is usually clearer and more convenient.  When printing a
+list, the dotted pair notation is only used if the @sc{cdr} of a cons
+cell is not a list.

 
   Here's an example using boxes to illustrate dotted pair notation.
 This example shows the pair @code{(rose . violet)}:
 
   Here's an example using boxes to illustrate dotted pair notation.
 This example shows the pair @code{(rose . violet)}:


@@ -800,7 +871,7 @@ the list.
 
 @example
 (setq alist-of-colors
 
 @example
 (setq alist-of-colors

-      '((rose . red) (lily . white)  (buttercup . yellow)))
+      '((rose . red) (lily . white) (buttercup . yellow)))

 @end example
 
 @noindent
 @end example
 
 @noindent


@@ -839,12 +910,13 @@ Once an array is created, its length is fixed.
 
   All Emacs Lisp arrays are one-dimensional.  (Most other programming
 languages support multidimensional arrays, but they are not essential;
 
   All Emacs Lisp arrays are one-dimensional.  (Most other programming
 languages support multidimensional arrays, but they are not essential;

-you can get the same effect with an array of arrays.)  Each type of
-array has its own read syntax; see the following sections for details.
+you can get the same effect with nested one-dimensional arrays.)  Each
+type of array has its own read syntax; see the following sections for
+details.

 
 

-  The array type is contained in the sequence type and
-contains the string type, the vector type, the bool-vector type, and the
-char-table type.
+  The array type is a subset of the sequence type, and contains the
+string type, the vector type, the bool-vector type, and the char-table
+type.

 
 @node String Type
 @subsection String Type
 
 @node String Type
 @subsection String Type


@@ -891,17 +963,17 @@ ignores an escaped newline while reading a string.  An escaped space
 in documentation strings,
 but the newline is \
 ignored if escaped."
 in documentation strings,
 but the newline is \
 ignored if escaped."

-     @result{} "It is useful to include newlines 
-in documentation strings, 
+     @result{} "It is useful to include newlines
+in documentation strings,

 but the newline is ignored if escaped."
 @end example
 
 @node Non-ASCII in Strings
 but the newline is ignored if escaped."
 @end example
 
 @node Non-ASCII in Strings

-@subsubsection Non-@sc{ascii} Characters in Strings
+@subsubsection Non-@acronym{ASCII} Characters in Strings

 
 

-  You can include a non-@sc{ascii} international character in a string
+  You can include a non-@acronym{ASCII} international character in a string

 constant by writing it literally.  There are two text representations
 constant by writing it literally.  There are two text representations

-for non-@sc{ascii} characters in Emacs strings (and in buffers): unibyte
+for non-@acronym{ASCII} characters in Emacs strings (and in buffers): unibyte

 and multibyte.  If the string constant is read from a multibyte source,
 such as a multibyte buffer or string, or a file that would be visited as
 multibyte, then the character is read as a multibyte character, and that
 and multibyte.  If the string constant is read from a multibyte source,
 such as a multibyte buffer or string, or a file that would be visited as
 multibyte, then the character is read as a multibyte character, and that


@@ -909,9 +981,9 @@ makes the string multibyte.  If the string constant is read from a
 unibyte source, then the character is read as unibyte and that makes the
 string unibyte.
 
 unibyte source, then the character is read as unibyte and that makes the
 string unibyte.
 

-  You can also represent a multibyte non-@sc{ascii} character with its
+  You can also represent a multibyte non-@acronym{ASCII} character with its

 character code: use a hex escape, @samp{\x@var{nnnnnnn}}, with as many
 character code: use a hex escape, @samp{\x@var{nnnnnnn}}, with as many

-digits as necessary.  (Multibyte non-@sc{ascii} character codes are all
+digits as necessary.  (Multibyte non-@acronym{ASCII} character codes are all

 greater than 256.)  Any character which is not a valid hex digit
 terminates this construct.  If the next character in the string could be
 interpreted as a hex digit, write @w{@samp{\ }} (backslash and space) to
 greater than 256.)  Any character which is not a valid hex digit
 terminates this construct.  If the next character in the string could be
 interpreted as a hex digit, write @w{@samp{\ }} (backslash and space) to


@@ -920,11 +992,14 @@ one character, @samp{a} with grave accent.  @w{@samp{\ }} in a string
 constant is just like backslash-newline; it does not contribute any
 character to the string, but it does terminate the preceding hex escape.
 
 constant is just like backslash-newline; it does not contribute any
 character to the string, but it does terminate the preceding hex escape.
 

-  Using a multibyte hex escape forces the string to multibyte.  You can
-represent a unibyte non-@sc{ascii} character with its character code,
-which must be in the range from 128 (0200 octal) to 255 (0377 octal).
-This forces a unibyte string.
-  
+  You can represent a unibyte non-@acronym{ASCII} character with its
+character code, which must be in the range from 128 (0200 octal) to
+255 (0377 octal).  If you write all such character codes in octal and
+the string contains no other characters forcing it to be multibyte,
+this produces a unibyte string.  However, using any hex escape in a
+string (even for an @acronym{ASCII} character) forces the string to be
+multibyte.
+

   @xref{Text Representations}, for more information about the two
 text representations.
 
   @xref{Text Representations}, for more information about the two
 text representations.
 


@@ -940,14 +1015,14 @@ description of the read syntax for characters.
 
   However, not all of the characters you can write with backslash
 escape-sequences are valid in strings.  The only control characters that
 
   However, not all of the characters you can write with backslash
 escape-sequences are valid in strings.  The only control characters that

-a string can hold are the @sc{ascii} control characters.  Strings do not
-distinguish case in @sc{ascii} control characters.
+a string can hold are the @acronym{ASCII} control characters.  Strings do not
+distinguish case in @acronym{ASCII} control characters.

 
   Properly speaking, strings cannot hold meta characters; but when a
 string is to be used as a key sequence, there is a special convention
 
   Properly speaking, strings cannot hold meta characters; but when a
 string is to be used as a key sequence, there is a special convention

-that provides a way to represent meta versions of @sc{ascii} characters in a
-string.  If you use the @samp{\M-} syntax to indicate a meta character
-in a string constant, this sets the
+that provides a way to represent meta versions of @acronym{ASCII}
+characters in a string.  If you use the @samp{\M-} syntax to indicate
+a meta character in a string constant, this sets the

 @tex
 @math{2^{7}}
 @end tex
 @tex
 @math{2^{7}}
 @end tex


@@ -1046,7 +1121,7 @@ Case tables (@pxref{Case Tables}).
 Character category tables (@pxref{Categories}).
 
 @item
 Character category tables (@pxref{Categories}).
 
 @item

-Display Tables (@pxref{Display Tables}).
+Display tables (@pxref{Display Tables}).

 
 @item
 Syntax tables (@pxref{Syntax Tables}).
 
 @item
 Syntax tables (@pxref{Syntax Tables}).


@@ -1063,17 +1138,26 @@ that it begins with @samp{#&} followed by the length.  The string
 constant that follows actually specifies the contents of the bool-vector
 as a bitmap---each ``character'' in the string contains 8 bits, which
 specify the next 8 elements of the bool-vector (1 stands for @code{t},
 constant that follows actually specifies the contents of the bool-vector
 as a bitmap---each ``character'' in the string contains 8 bits, which
 specify the next 8 elements of the bool-vector (1 stands for @code{t},

-and 0 for @code{nil}).  The least significant bits of the character 
-correspond to the lowest indices in the bool-vector.  If the length is not a
-multiple of 8, the printed representation shows extra elements, but
-these extras really make no difference.
+and 0 for @code{nil}).  The least significant bits of the character
+correspond to the lowest indices in the bool-vector.

 
 @example
 (make-bool-vector 3 t)
 
 @example
 (make-bool-vector 3 t)

-     @result{} #&3"\007"
+     @result{} #&3"^G"

 (make-bool-vector 3 nil)
 (make-bool-vector 3 nil)

-     @result{} #&3"\0"
-;; @r{These are equal since only the first 3 bits are used.}
+     @result{} #&3"^@@"
+@end example
+
+@noindent
+These results make sense, because the binary code for @samp{C-g} is
+111 and @samp{C-@@} is the character with code 0.
+
+  If the length is not a multiple of 8, the printed representation
+shows extra elements, but these extras really make no difference.  For
+instance, in the next example, the two bool-vectors are equal, because
+only the first 3 bits are used:
+
+@example

 (equal #&3"\377" #&3"\007")
      @result{} t
 @end example
 (equal #&3"\377" #&3"\007")
      @result{} t
 @end example


@@ -1083,8 +1167,8 @@ these extras really make no difference.
 
     A hash table is a very fast kind of lookup table, somewhat like an
 alist in that it maps keys to corresponding values, but much faster.
 
     A hash table is a very fast kind of lookup table, somewhat like an
 alist in that it maps keys to corresponding values, but much faster.

-Hash tables are a new feature in Emacs 21; they have no read syntax, and
-print using hash notation.  @xref{Hash Tables}.
+Hash tables have no read syntax, and print using hash notation.
+@xref{Hash Tables}, for functions that operate on hash tables.

 
 @example
 (make-hash-table)
 
 @example
 (make-hash-table)


@@ -1466,9 +1550,9 @@ positions.
 @cindex @samp{#@var{n}=} read syntax
 @cindex @samp{#@var{n}#} read syntax
 
 @cindex @samp{#@var{n}=} read syntax
 @cindex @samp{#@var{n}#} read syntax
 

-  In Emacs 21, to represent shared or circular structure within a
-complex of Lisp objects, you can use the reader constructs
-@samp{#@var{n}=} and @samp{#@var{n}#}.
+  To represent shared or circular structures within a complex of Lisp
+objects, you can use the reader constructs @samp{#@var{n}=} and
+@samp{#@var{n}#}.

 
   Use @code{#@var{n}=} before an object to label it for later reference;
 subsequently, you can use @code{#@var{n}#} to refer the same object in
 
   Use @code{#@var{n}=} before an object to label it for later reference;
 subsequently, you can use @code{#@var{n}#} to refer the same object in


@@ -1524,7 +1608,6 @@ to a non-@code{nil} value.  @xref{Output Variables}.
 
 @node Type Predicates
 @section Type Predicates
 
 @node Type Predicates
 @section Type Predicates

-@cindex predicates

 @cindex type checking
 @kindex wrong-type-argument
 
 @cindex type checking
 @kindex wrong-type-argument
 


@@ -1628,6 +1711,9 @@ with references to further information.
 @item functionp
 @xref{Functions, functionp}.
 
 @item functionp
 @xref{Functions, functionp}.
 

+@item hash-table-p
+@xref{Other Hash, hash-table-p}.
+

 @item integer-or-marker-p
 @xref{Predicates on Markers, integer-or-marker-p}.
 
 @item integer-or-marker-p
 @xref{Predicates on Markers, integer-or-marker-p}.
 


@@ -1693,6 +1779,12 @@ with references to further information.
 
 @item windowp
 @xref{Basic Windows, windowp}.
 
 @item windowp
 @xref{Basic Windows, windowp}.

+
+@item booleanp
+@xref{nil and t, booleanp}.
+
+@item string-or-null-p
+@xref{Predicates for Strings, string-or-null-p}.

 @end table
 
   The most general way to check the type of an object is to call the
 @end table
 
   The most general way to check the type of an object is to call the


@@ -1734,8 +1826,7 @@ describing the data type.
 
 @defun eq object1 object2
 This function returns @code{t} if @var{object1} and @var{object2} are
 
 @defun eq object1 object2
 This function returns @code{t} if @var{object1} and @var{object2} are

-the same object, @code{nil} otherwise.  The ``same object'' means that a
-change in one will be reflected by the same change in the other.
+the same object, @code{nil} otherwise.

 
 @code{eq} returns @code{t} if @var{object1} and @var{object2} are
 integers with the same value.  Also, since symbol names are normally
 
 @code{eq} returns @code{t} if @var{object1} and @var{object2} are
 integers with the same value.  Also, since symbol names are normally


@@ -1743,7 +1834,8 @@ unique, if the arguments are symbols with the same name, they are
 @code{eq}.  For other types (e.g., lists, vectors, strings), two
 arguments with the same contents or elements are not necessarily
 @code{eq} to each other: they are @code{eq} only if they are the same
 @code{eq}.  For other types (e.g., lists, vectors, strings), two
 arguments with the same contents or elements are not necessarily
 @code{eq} to each other: they are @code{eq} only if they are the same

-object.
+object, meaning that a change in the contents of one will be reflected
+by the same change in the contents of the other.

 
 @example
 @group
 
 @example
 @group


@@ -1856,10 +1948,14 @@ always true.
 @end group
 @end example
 
 @end group
 @end example
 

+@cindex equality of strings

 Comparison of strings is case-sensitive, but does not take account of
 Comparison of strings is case-sensitive, but does not take account of

-text properties---it compares only the characters in the strings.
-A unibyte string never equals a multibyte string unless the
-contents are entirely @sc{ascii} (@pxref{Text Representations}).
+text properties---it compares only the characters in the strings.  For
+technical reasons, a unibyte string and a multibyte string are
+@code{equal} if and only if they contain the same sequence of
+character codes and all these codes are either in the range 0 through
+127 (@acronym{ASCII}) or 160 through 255 (@code{eight-bit-graphic}).
+(@pxref{Text Representations}).

 
 @example
 @group
 
 @example
 @group


@@ -1884,3 +1980,7 @@ returns @code{t} if and only if both the expressions below return
 
 Because of this recursive method, circular lists may therefore cause
 infinite recursion (leading to an error).
 
 Because of this recursive method, circular lists may therefore cause
 infinite recursion (leading to an error).

+
+@ignore
+   arch-tag: 9711a66e-4749-4265-9e8c-972d55b67096
+@end ignore