emacs-diffs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

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


From: Miles Bader
Subject: [Emacs-diffs] Changes to emacs/lispref/objects.texi [lexbind]
Date: Thu, 20 Nov 2003 19:36:48 -0500

Index: emacs/lispref/objects.texi
diff -c emacs/lispref/objects.texi:1.31.2.2 emacs/lispref/objects.texi:1.31.2.3
*** emacs/lispref/objects.texi:1.31.2.2 Tue Oct 14 19:10:12 2003
--- emacs/lispref/objects.texi  Thu Nov 20 19:35:47 2003
***************
*** 161,184 ****
  @node Integer Type
  @subsection Integer Type
  
!   The range of values for integers in Emacs Lisp is @minus{}134217728 to
! 134217727 (28 bits; i.e.,
  @ifnottex
! -2**27
  @end ifnottex
  @tex
! @math{-2^{27}}
  @end tex
  to
  @ifnottex
! 2**27 - 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
! for overflow.  Thus @code{(1+ 134217727)} is @minus{}134217728 on most
  machines.
  
    The read syntax for integers is a sequence of (base ten) digits with an
--- 161,184 ----
  @node Integer Type
  @subsection Integer Type
  
!   The range of values for integers in Emacs Lisp is @minus{}268435456 to
! 268435455 (29 bits; i.e.,
  @ifnottex
! -2**28
  @end ifnottex
  @tex
! @math{-2^{28}}
  @end tex
  to
  @ifnottex
! 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
! 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
***************
*** 192,198 ****
  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.}
  @end group
  @end example
  
--- 192,198 ----
  1                ; @r{The integer 1.}
  1.               ; @r{Also the integer 1.}
  +1               ; @r{Also the integer 1.}
! 536870913        ; @r{Also the integer 1 on a 29-bit implementation.}
  @end group
  @end example
  
***************
*** 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.
  
***************
*** 365,373 ****
  @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.
  
    In a string, the
  @tex
--- 365,372 ----
  @ifnottex
  2**27
  @end ifnottex
! 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
***************
*** 376,384 ****
  @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.)
  
***************
*** 390,397 ****
  @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}}
***************
*** 433,441 ****
  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
***************
*** 916,926 ****
  @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
***************
*** 928,936 ****
  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
***************
*** 940,946 ****
  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.
  
***************
*** 959,970 ****
  
    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
***************
*** 1878,1884 ****
  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




reply via email to

[Prev in Thread] Current Thread [Next in Thread]