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

[Eli Zaretskii]

Index: emacs/lispref/strings.texi
diff -c emacs/lispref/strings.texi:1.30 emacs/lispref/strings.texi:1.31
*** emacs/lispref/strings.texi:1.30     Mon Oct 27 10:54:13 2003
--- emacs/lispref/strings.texi  Sun Nov  2 01:29:59 2003
***************
*** 44,50 ****
    The length of a string (like any array) is fixed, and cannot be
  altered once the string exists.  Strings in Lisp are @emph{not}
  terminated by a distinguished character code.  (By contrast, strings in
! C are terminated by a character with @sc{ascii} code 0.)
  
    Since strings are arrays, and therefore sequences as well, you can
  operate on them with the general array and sequence functions.
--- 44,50 ----
    The length of a string (like any array) is fixed, and cannot be
  altered once the string exists.  Strings in Lisp are @emph{not}
  terminated by a distinguished character code.  (By contrast, strings in
! C are terminated by a character with @acronym{ASCII} code 0.)
  
    Since strings are arrays, and therefore sequences as well, you can
  operate on them with the general array and sequence functions.
***************
*** 52,61 ****
  change individual characters in a string using the functions @code{aref}
  and @code{aset} (@pxref{Array Functions}).
  
!   There are two text representations for address@hidden characters in
  Emacs strings (and in buffers): unibyte and multibyte (@pxref{Text
! Representations}).  An @sc{ascii} character always occupies one byte in a
! string; in fact, when a string is all @sc{ascii}, there is no real
  difference between the unibyte and multibyte representations.
  For most Lisp programming, you don't need to be concerned with these two
  representations.
--- 52,61 ----
  change individual characters in a string using the functions @code{aref}
  and @code{aset} (@pxref{Array Functions}).
  
!   There are two text representations for address@hidden characters in
  Emacs strings (and in buffers): unibyte and multibyte (@pxref{Text
! Representations}).  An @acronym{ASCII} character always occupies one byte in a
! string; in fact, when a string is all @acronym{ASCII}, there is no real
  difference between the unibyte and multibyte representations.
  For most Lisp programming, you don't need to be concerned with these two
  representations.
***************
*** 66,73 ****
  codes in the range 128 to 255.
  
    Strings cannot hold characters that have the hyper, super or alt
! modifiers; they can hold @sc{ascii} control characters, but no other
! control characters.  They do not distinguish case in @sc{ascii} control
  characters.  If you want to store such characters in a sequence, such as
  a key sequence, you must use a vector instead of a string.
  @xref{Character Type}, for more information about the representation of meta
--- 66,73 ----
  codes in the range 128 to 255.
  
    Strings cannot hold characters that have the hyper, super or alt
! modifiers; they can hold @acronym{ASCII} control characters, but no other
! control characters.  They do not distinguish case in @acronym{ASCII} control
  characters.  If you want to store such characters in a sequence, such as
  a key sequence, you must use a vector instead of a string.
  @xref{Character Type}, for more information about the representation of meta
***************
*** 417,423 ****
  strings.  When @code{equal} (@pxref{Equality Predicates}) compares two
  strings, it uses @code{string=}.
  
! If the strings contain address@hidden characters, and one is unibyte
  while the other is multibyte, then they cannot be equal.  @xref{Text
  Representations}.
  @end defun
--- 417,423 ----
  strings.  When @code{equal} (@pxref{Equality Predicates}) compares two
  strings, it uses @code{string=}.
  
! If the strings contain address@hidden characters, and one is unibyte
  while the other is multibyte, then they cannot be equal.  @xref{Text
  Representations}.
  @end defun
***************
*** 439,449 ****
  
  Pairs of characters are compared according to their character codes.
  Keep in mind that lower case letters have higher numeric values in the
! @sc{ascii} character set than their upper case counterparts; digits and
  many punctuation characters have a lower numeric value than upper case
! letters.  An @sc{ascii} character is less than any address@hidden
! character; a unibyte address@hidden character is always less than any
! multibyte address@hidden character (@pxref{Text Representations}).
  
  @example
  @group
--- 439,449 ----
  
  Pairs of characters are compared according to their character codes.
  Keep in mind that lower case letters have higher numeric values in the
! @acronym{ASCII} character set than their upper case counterparts; digits and
  many punctuation characters have a lower numeric value than upper case
! letters.  An @acronym{ASCII} character is less than any address@hidden
! character; a unibyte address@hidden character is always less than any
! multibyte address@hidden character (@pxref{Text Representations}).
  
  @example
  @group
***************
*** 551,557 ****
  @cindex string to character
    This function returns the first character in @var{string}.  If the
  string is empty, the function returns 0.  The value is also 0 when the
! first character of @var{string} is the null character, @sc{ascii} code
  0.
  
  @example
--- 551,557 ----
  @cindex string to character
    This function returns the first character in @var{string}.  If the
  string is empty, the function returns 0.  The value is also 0 when the
! first character of @var{string} is the null character, @acronym{ASCII} code
  0.
  
  @example
***************
*** 846,852 ****
    The character case functions change the case of single characters or
  of the contents of strings.  The functions normally convert only
  alphabetic characters (the letters @samp{A} through @samp{Z} and
! @samp{a} through @samp{z}, as well as address@hidden letters); other
  characters are not altered.  You can specify a different case
  conversion mapping by specifying a case table (@pxref{Case Tables}).
  
--- 846,852 ----
    The character case functions change the case of single characters or
  of the contents of strings.  The functions normally convert only
  alphabetic characters (the letters @samp{A} through @samp{Z} and
! @samp{a} through @samp{z}, as well as address@hidden letters); other
  characters are not altered.  You can specify a different case
  conversion mapping by specifying a case table (@pxref{Case Tables}).
  
***************
*** 854,860 ****
  arguments.
  
    The examples below use the characters @samp{X} and @samp{x} which have
! @sc{ascii} codes 88 and 120 respectively.
  
  @defun downcase string-or-char
  This function converts a character or a string to lower case.
--- 854,860 ----
  arguments.
  
    The examples below use the characters @samp{X} and @samp{x} which have
! @acronym{ASCII} codes 88 and 120 respectively.
  
  @defun downcase string-or-char
  This function converts a character or a string to lower case.
***************
*** 1001,1007 ****
  
    The extra table @var{equivalences} is a map that cyclicly permutes
  each equivalence class (of characters with the same canonical
! equivalent).  (For ordinary @sc{ascii}, this would map @samp{a} into
  @samp{A} and @samp{A} into @samp{a}, and likewise for each set of
  equivalent characters.)
  
--- 1001,1007 ----
  
    The extra table @var{equivalences} is a map that cyclicly permutes
  each equivalence class (of characters with the same canonical
! equivalent).  (For ordinary @acronym{ASCII}, this would map @samp{a} into
  @samp{A} and @samp{A} into @samp{a}, and likewise for each set of
  equivalent characters.)
  
***************
*** 1038,1044 ****
  @end defun
  
    The following three functions are convenient subroutines for packages
! that define address@hidden character sets.  They modify the specified
  case table @var{case-table}; they also modify the standard syntax table.
  @xref{Syntax Tables}.  Normally you would use these functions to change
  the standard case table.
--- 1038,1044 ----
  @end defun
  
    The following three functions are convenient subroutines for packages
! that define address@hidden character sets.  They modify the specified
  case table @var{case-table}; they also modify the standard syntax table.
  @xref{Syntax Tables}.  Normally you would use these functions to change
  the standard case table.