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

comparison man/lispref/strings.texi @ 444:576fb035e263 r21-2-37

Import from CVS: tag r21-2-37

author	cvs
date	Mon, 13 Aug 2007 11:36:19 +0200
parents	abe6d1db359e
children	c3cf7db99b98

comparison

equal deleted inserted replaced

-:a8296e22da4e
+:576fb035e263
 @c -*-texinfo-*-
 @c This is part of the XEmacs Lisp Reference Manual.
 @c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
 @c See the file lispref.texi for copying conditions.
 @setfilename ../../info/strings.info
 @node Strings and Characters, Lists, Numbers, Top
 @chapter Strings and Characters
 @cindex strings
 @result{} ""
 @end example
 Analogous functions operating on other data types include @code{list},
 @code{cons} (@pxref{Building Lists}), @code{vector} (@pxref{Vectors})
 and @code{bit-vector} (@pxref{Bit Vectors}).  This function has not been
 available in XEmacs prior to 21.0 and FSF Emacs prior to 20.3.
 @end defun
-@defun make-string count character
+@defun make-string length character
-This function returns a string made up of @var{count} repetitions of
+This function returns a new string consisting entirely of @var{length}
-@var{character}.  If @var{count} is negative, an error is signaled.
+successive copies of @var{character}.  @var{length} must be a
+non-negative integer.
 @example
 (make-string 5 ?x)
 @result{} "xxxxx"
 (make-string 0 ?x)
 from the string @code{"abcdefg"}.  The index 3 marks the character
 position up to which the substring is copied.  The character whose index
 is 3 is actually the fourth character in the string.
 A negative number counts from the end of the string, so that @minus{}1
 signifies the index of the last character of the string.  For example:
 @example
 @group
 (substring "abcdefg" -3 -1)
 @result{} "ef"
 @end defun
 @node Character Codes
 @section Character Codes
-@defun char-int ch
+@defun char-int character
 This function converts a character into an equivalent integer.
 The resulting integer will always be non-negative.  The integers in
 the range 0 - 255 map to characters as follows:
 @table @asis
 @need 2000
 @node Text Comparison
 @section Comparison of Characters and Strings
 @cindex string equality
-@defun char-equal character1 character2
+@defun char-equal character1 character2 &optional buffer
 This function returns @code{t} if the arguments represent the same
 character, @code{nil} otherwise.  This function ignores differences
-in case if @code{case-fold-search} is non-@code{nil}.
+in case if the value of @code{case-fold-search} is non-@code{nil} in
+@var{buffer}, which defaults to the current buffer.
 @example
 (char-equal ?x ?x)
 @result{} t
 (let ((case-fold-search t))
 (string< "abc" "")
 @result{} nil
 (string< "abc" "ab")
 @result{} nil
 (string< "" "")
 @result{} nil
 @end group
 @end example
 @end defun
 @defun string-lessp string1 string2
 See also the function @code{format} in @ref{Formatting Strings}.
 @end defun
 @defun string-to-number string &optional base
 @cindex string to number
-This function returns the numeric value of the characters in
+This function returns the numeric value represented by @var{string},
-@var{string}, read in @var{base}.  It skips spaces and tabs at the
+read in @var{base}.  It skips spaces and tabs at the beginning of
-beginning of @var{string}, then reads as much of @var{string} as it can
+@var{string}, then reads as much of @var{string} as it can interpret as
-interpret as a number.  (On some systems it ignores other whitespace at
+a number.  (On some systems it ignores other whitespace at the
-the beginning, not just spaces and tabs.)  If the first character after
+beginning, not just spaces and tabs.)  If the first character after the
-the ignored whitespace is not a digit or a minus sign, this function
+ignored whitespace is not a digit or a minus sign, this function returns
-returns 0.
+0.
 If @var{base} is not specified, it defaults to ten.  With @var{base}
 other than ten, only integers can be read.
 @example
 formatting feature described here; they differ from @code{format} only
 in how they use the result of formatting.
 @defun format string &rest objects
 This function returns a new string that is made by copying
 @var{string} and then replacing any format specification
 in the copy with encodings of the corresponding @var{objects}.  The
 arguments @var{objects} are the computed values to be formatted.
 @end defun
 @cindex @samp{%} in format
 @result{} "The name of this buffer is strings.texi."
 (format "The buffer object prints as %s." (current-buffer))
 @result{} "The buffer object prints as #<buffer strings.texi>."
 (format "The octal value of %d is %o,
 and the hex value is %x." 18 18 18)
 @result{} "The octal value of 18 is 22,
 and the hex value is 12."
 @end group
 @end example
 There are many additional flags and specifications that can occur
 A @dfn{repositioning} specification changes which argument to
 @code{format} is used by the current and all following format
 specifications.  Normally the first specification uses the first
 argument, the second specification uses the second argument, etc.  Using
 a repositioning specification, you can change this.  By placing a number
-@var{N} followed by a @samp{$} between the @samp{%} and the format
+@var{n} followed by a @samp{$} between the @samp{%} and the format
-character, you cause the specification to use the @var{N}th argument.
+character, you cause the specification to use the @var{n}th argument.
-The next specification will use the @var{N}+1'th argument, etc.
+The next specification will use the @var{n}+1'th argument, etc.
 For example:
 @example
 @group
 of 7.  In the first case, the string inserted in place of @samp{%7s} has
 only 3 letters, so 4 blank spaces are inserted for padding.  In the
 second case, the string @code{"specification"} is 13 letters wide but is
 not truncated.  In the third case, the padding is on the right.
 @smallexample
 @group
 (format "The word `%7s' actually has %d letters in it."
 "foo" (length "foo"))
 @result{} "The word `    foo' actually has 3 letters in it."
 @end group
 @group
 (format "The word `%7s' actually has %d letters in it."
 "specification" (length "specification"))
 @result{} "The word `specification' actually has 13 letters in it."
 @end group
 @group
 (format "The word `%-7s' actually has %d letters in it."
 "foo" (length "foo"))
 @result{} "The word `foo    ' actually has 3 letters in it."
 @end group
 @end smallexample
 @cindex format precision
 @cindex precision of formatted numbers
 conversions.
 @end itemize
 @node Character Case
 @section Character Case
 @cindex upper case
 @cindex lower case
 @cindex character case
 The character case functions change the case of single characters or
 of the contents of strings.  The functions convert only alphabetic
 characters (the letters @samp{A} through @samp{Z} and @samp{a} through
 @samp{z}); other characters are not altered.  The functions do not
 modify the strings that are passed to them as 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
+@defun downcase string-or-char &optional buffer
 This function converts a character or a string to lower case.
 When the argument to @code{downcase} is a string, the function creates
 and returns a new string in which each letter in the argument that is
 upper case is converted to lower case.  When the argument to
 @code{downcase} is a character, @code{downcase} returns the
 corresponding lower case character. (This value is actually an integer
 under XEmacs 19.) If the original character is lower case, or is not a
 letter, then the value equals the original character.
+Optional second arg @var{buffer} specifies which buffer's case tables to
+use, and defaults to the current buffer.
 @example
 (downcase "The cat in the hat")
 @result{} "the cat in the hat"
 (downcase ?X)
 @result{} 120  ;; @r{Under XEmacs 19.}
 @end example
 @end defun
-@defun upcase string-or-char
+@defun upcase string-or-char &optional buffer
 This function converts a character or a string to upper case.
 When the argument to @code{upcase} is a string, the function creates
 and returns a new string in which each letter in the argument that is
 lower case is converted to upper case.
 When the argument to @code{upcase} is a character, @code{upcase} returns
 the corresponding upper case character. (This value is actually an
 integer under XEmacs 19.)  If the original character is upper case, or
 is not a letter, then the value equals the original character.
+Optional second arg @var{buffer} specifies which buffer's case tables to
+use, and defaults to the current buffer.
 @example
 (upcase "The cat in the hat")
 @result{} "THE CAT IN THE HAT"
 (upcase ?x)
 @result{} ?X   ;; @r{Under XEmacs 20.}
 @result{} 88   ;; @r{Under XEmacs 19.}
 @end example
 @end defun
-@defun capitalize string-or-char
+@defun capitalize string-or-char &optional buffer
 @cindex capitalization
 This function capitalizes strings or characters.  If
 @var{string-or-char} is a string, the function creates and returns a new
 string, whose contents are a copy of @var{string-or-char} in which each
 word has been capitalized.  This means that the first character of each
 table (@pxref{Syntax Class Table}).
 When the argument to @code{capitalize} is a character, @code{capitalize}
 has the same result as @code{upcase}.
+Optional second arg @var{buffer} specifies which buffer's case tables to
+use, and defaults to the current buffer.
 @example
 (capitalize "The cat in the hat")
 @result{} "The Cat In The Hat"
 (capitalize "THE 77TH-HATTED CAT")
 @defun case-table-p object
 This predicate returns non-@code{nil} if @var{object} is a valid case
 table.
 @end defun
-@defun set-standard-case-table table
+@defun set-standard-case-table case-table
-This function makes @var{table} the standard case table, so that it will
+This function makes @var{case-table} the standard case table, so that it
-apply to any buffers created subsequently.
+will apply to any buffers created subsequently.
 @end defun
 @defun standard-case-table
 This returns the standard case table.
 @end defun
-@defun current-case-table
+@defun current-case-table &optional buffer
-This function returns the current buffer's case table.
+This function returns the case table of @var{buffer}, which defaults to
-@end defun
+the current buffer.
+@end defun
-@defun set-case-table table
-This sets the current buffer's case table to @var{table}.
+@defun set-case-table case-table
+This sets the current buffer's case table to @var{case-table}.
 @end defun
 The following three functions are convenient subroutines for packages
 that define non-@sc{ascii} character sets.  They modify a string
 @var{downcase-table} provided as an argument; this should be a string to
 Used for syntax tables, which specify the syntax of a particular
 character.  Higher-level Lisp functions are provided for
 working with syntax tables.  The valid values are integers.
 @end table
-@defun char-table-type table
+@defun char-table-type char-table
-This function returns the type of char table @var{table}.
+This function returns the type of char table @var{char-table}.
 @end defun
 @defun char-table-type-list
 This function returns a list of the recognized char table types.
 @end defun
 This function makes a new, empty char table of type @var{type}.
 @var{type} should be a symbol, one of @code{char}, @code{category},
 @code{display}, @code{generic}, or @code{syntax}.
 @end defun
-@defun put-char-table range val table
+@defun put-char-table range value char-table
-This function sets the value for chars in @var{range} to be @var{val} in
+This function sets the value for chars in @var{range} to be @var{value} in
-@var{table}.
+@var{char-table}.
 @var{range} specifies one or more characters to be affected and should be
 one of the following:
 @itemize @bullet
 (only allowed when @sc{mule} support is present)
 @item
 A single character
 @end itemize
-@var{val} must be a value appropriate for the type of @var{table}.
+@var{value} must be a value appropriate for the type of @var{char-table}.
 @end defun
-@defun get-char-table ch table
+@defun get-char-table character char-table
-This function finds the value for char @var{ch} in @var{table}.
+This function finds the value for @var{character} in @var{char-table}.
 @end defun
-@defun get-range-char-table range table &optional multi
+@defun get-range-char-table range char-table &optional multi
-This function finds the value for a range in @var{table}.  If there is
+This function finds the value for a range in @var{char-table}.  If there is
 more than one value, @var{multi} is returned (defaults to @code{nil}).
 @end defun
-@defun reset-char-table table
+@defun reset-char-table char-table
-This function resets a char table to its default state.
+This function resets @var{char-table} to its default state.
 @end defun
-@defun map-char-table function table &optional range
+@defun map-char-table function char-table &optional range
-This function maps @var{function} over entries in @var{table}, calling
+This function maps @var{function} over entries in @var{char-table}, calling
 it with two args, each key and value in the table.
 @var{range} specifies a subrange to map over and is in the same format
 as the @var{range} argument to @code{put-range-table}.  If omitted or
 @code{t}, it defaults to the entire table.

Mercurial > hg > xemacs-beta

comparison man/lispref/strings.texi @ 444:576fb035e263 r21-2-37