[Emacs-diffs] Changes to emacs/lispref/objects.texi

[Eli Zaretskii]

Index: emacs/lispref/objects.texi
diff -c emacs/lispref/objects.texi:1.38 emacs/lispref/objects.texi:1.39
*** emacs/lispref/objects.texi:1.38     Tue Oct 21 22:46:08 2003
--- emacs/lispref/objects.texi  Sun Nov  2 01:29:58 2003
***************
*** 216,222 ****
  
  @node Character Type
  @subsection Character Type
! @cindex @sc{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
--- 216,222 ----
  
  @node Character Type
  @subsection Character Type
! @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
***************
*** 228,235 ****
  
    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 address@hidden (@pxref{Non-ASCII Characters}).  Characters that 
represent
  keyboard input have a much wider range, to encode modifier keys such as
  Control, Meta and Shift.
  
--- 228,235 ----
  
    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 address@hidden (@pxref{Non-ASCII Characters}).  Characters that 
represent
  keyboard input have a much wider range, to encode modifier keys such as
  Control, Meta and Shift.
  
***************
*** 323,331 ****
  @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
  any character into a control character with @samp{C-}.  The character
! codes for these address@hidden control characters include the
  @tex
  @math{2^{26}}
  @end tex
--- 323,331 ----
  @end example
  
    In strings and buffers, the only control characters allowed are those
! that exist in @acronym{ASCII}; but for keyboard input purposes, you can turn
  any character into a control character with @samp{C-}.  The character
! codes for these address@hidden control characters include the
  @tex
  @math{2^{26}}
  @end tex
***************
*** 333,339 ****
  2**26
  @end ifnottex
  bit as well as the code for the corresponding non-control
! character.  Ordinary terminals have no way of generating address@hidden
  control characters, but you can generate them straightforwardly using X
  and other window systems.
  
--- 333,339 ----
  2**26
  @end ifnottex
  bit as well as the code for the corresponding non-control
! character.  Ordinary terminals have no way of generating address@hidden
  control characters, but you can generate them straightforwardly using X
  and other window systems.
  
***************
*** 375,383 ****
  @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.)
  
--- 375,383 ----
  @ifnottex
  2**7
  @end ifnottex
! 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.)
  
***************
*** 389,396 ****
  @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
  character is upper case or lower case.  Emacs uses the
  @tex
  @math{2^{25}}
--- 389,396 ----
  @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, @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}}
***************
*** 432,440 ****
  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, it is preferred only when the precise octal value is more
! important than the @sc{ascii} representation.
  
  @example
  @group
--- 432,440 ----
  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 @acronym{ASCII}
  character, it is preferred only when the precise octal value is more
! important than the @acronym{ASCII} representation.
  
  @example
  @group
***************
*** 915,925 ****
  @end example
  
  @node Non-ASCII in Strings
! @subsubsection address@hidden Characters in Strings
  
!   You can include a address@hidden international character in a string
  constant by writing it literally.  There are two text representations
! for address@hidden 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
--- 915,925 ----
  @end example
  
  @node Non-ASCII in Strings
! @subsubsection address@hidden Characters in Strings
  
!   You can include a address@hidden international character in a string
  constant by writing it literally.  There are two text representations
! for address@hidden 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
***************
*** 927,935 ****
  unibyte source, then the character is read as unibyte and that makes the
  string unibyte.
  
!   You can also represent a multibyte address@hidden character with its
  character code: use a hex escape, @address@hidden, with as many
! digits as necessary.  (Multibyte address@hidden 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 @address@hidden }} (backslash and space) to
--- 927,935 ----
  unibyte source, then the character is read as unibyte and that makes the
  string unibyte.
  
!   You can also represent a multibyte address@hidden character with its
  character code: use a hex escape, @address@hidden, with as many
! digits as necessary.  (Multibyte address@hidden 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 @address@hidden }} (backslash and space) to
***************
*** 939,945 ****
  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 address@hidden character with its character code,
  which must be in the range from 128 (0200 octal) to 255 (0377 octal).
  This forces a unibyte string.
  
--- 939,945 ----
  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 address@hidden character with its character code,
  which must be in the range from 128 (0200 octal) to 255 (0377 octal).
  This forces a unibyte string.
  
***************
*** 958,969 ****
  
    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.
  
    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
  @tex
--- 958,969 ----
  
    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 @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
! 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
***************
*** 1877,1883 ****
  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}).
  
  @example
  @group
--- 1877,1883 ----
  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 @acronym{ASCII} (@pxref{Text Representations}).
  
  @example
  @group