+@defun split-string string &optional separators omit-nulls
+This function splits @var{string} into substrings at matches for the
+regular expression @var{separators}. Each match for @var{separators}
+defines a splitting point; the substrings between the splitting points
+are made into a list, which is the value returned by
+@code{split-string}.
+
+If @var{omit-nulls} is @code{nil}, the result contains null strings
+whenever there are two consecutive matches for @var{separators}, or a
+match is adjacent to the beginning or end of @var{string}. If
+@var{omit-nulls} is @code{t}, these null strings are omitted from the
+result list.
+
+If @var{separators} is @code{nil} (or omitted),
+the default is the value of @code{split-string-default-separators}.
+
+As a special case, when @var{separators} is @code{nil} (or omitted),
+null strings are always omitted from the result. Thus:
+
+@example
+(split-string " two words ")
+ @result{} ("two" "words")
+@end example
+
+The result is not @samp{("" "two" "words" "")}, which would rarely be
+useful. If you need such a result, use an explicit value for
+@var{separators}:
+
+@example
+(split-string " two words "
+ split-string-default-separators)
+ @result{} ("" "two" "words" "")
+@end example
+
+More examples:
+
+@example
+(split-string "Soup is good food" "o")
+ @result{} ("S" "up is g" "" "d f" "" "d")
+(split-string "Soup is good food" "o" t)
+ @result{} ("S" "up is g" "d f" "d")
+(split-string "Soup is good food" "o+")
+ @result{} ("S" "up is g" "d f" "d")
+@end example
+
+Empty matches do count, except that @code{split-string} will not look
+for a final empty match when it already reached the end of the string
+using a non-empty match or when @var{string} is empty:
+
+@example
+(split-string "aooob" "o*")
+ @result{} ("" "a" "" "b" "")
+(split-string "ooaboo" "o*")
+ @result{} ("" "" "a" "b" "")
+(split-string "" "")
+ @result{} ("")
+@end example
+
+However, when @var{separators} can match the empty string,
+@var{omit-nulls} is usually @code{t}, so that the subtleties in the
+three previous examples are rarely relevant:
+
+@example
+(split-string "Soup is good food" "o*" t)
+ @result{} ("S" "u" "p" " " "i" "s" " " "g" "d" " " "f" "d")
+(split-string "Nice doggy!" "" t)
+ @result{} ("N" "i" "c" "e" " " "d" "o" "g" "g" "y" "!")
+(split-string "" "" t)
+ @result{} nil
+@end example
+
+Somewhat odd, but predictable, behavior can occur for certain
+``non-greedy'' values of @var{separators} that can prefer empty
+matches over non-empty matches. Again, such values rarely occur in
+practice:
+
+@example
+(split-string "ooo" "o*" t)
+ @result{} nil
+(split-string "ooo" "\\|o+" t)
+ @result{} ("o" "o" "o")
+@end example
+@end defun
+
+@defvar split-string-default-separators
+The default value of @var{separators} for @code{split-string}. Its
+usual value is @w{@samp{"[ \f\t\n\r\v]+"}}.
+@end defvar
+
+@node Modifying Strings
+@section Modifying Strings
+
+ The most basic way to alter the contents of an existing string is with
+@code{aset} (@pxref{Array Functions}). @code{(aset @var{string}
+@var{idx} @var{char})} stores @var{char} into @var{string} at index
+@var{idx}. Each character occupies one or more bytes, and if @var{char}
+needs a different number of bytes from the character already present at
+that index, @code{aset} signals an error.
+
+ A more powerful function is @code{store-substring}:
+
+@defun store-substring string idx obj
+This function alters part of the contents of the string @var{string}, by
+storing @var{obj} starting at index @var{idx}. The argument @var{obj}
+may be either a character or a (smaller) string.
+
+Since it is impossible to change the length of an existing string, it is
+an error if @var{obj} doesn't fit within @var{string}'s actual length,
+or if any new character requires a different number of bytes from the
+character currently present at that point in @var{string}.
+@end defun
+
+ To clear out a string that contained a password, use
+@code{clear-string}:
+
+@defun clear-string string
+This clears the contents of @var{string} to zeros.
+It may also change @var{string}'s length and convert it to
+a unibyte string.
+@end defun
+