@@StringManipulation.CharacterSearchandReplace
<GROUP StringManipulation>
<TITLE Character Search and Replace>
<TOPICORDER 100>
--------------------------------------------------------------------------------
@@StringManipulation.CharacterTestRoutines
<GROUP StringManipulation>
<TITLE Character Test Routines>
<TOPICORDER 200>
--------------------------------------------------------------------------------
@@StringManipulation.CharacterTransformationRoutines
<GROUP StringManipulation>
<TITLE Character Transformation Routines>
<TOPICORDER 300>
--------------------------------------------------------------------------------
@@StringManipulation.Miscellaneous
<GROUP StringManipulation>
<TITLE Miscellaneous>
<TOPICORDER 400>
--------------------------------------------------------------------------------
@@StringManipulation.MultiSz
<GROUP StringManipulation>
<TITLE MultiSz>
<TOPICORDER 500>
--------------------------------------------------------------------------------
@@StringManipulation.PCharVector
<GROUP StringManipulation>
<TITLE PCharVector>
<TOPICORDER 600>
--------------------------------------------------------------------------------
@@StringManipulation.StringExtraction
<GROUP StringManipulation>
<TITLE String Extraction>
<TOPICORDER 700>
--------------------------------------------------------------------------------
@@StringManipulation.StringManagement
<GROUP StringManipulation>
<TITLE String Management>
<TOPICORDER 800>
--------------------------------------------------------------------------------
@@StringManipulation.StringSearchandReplaceRoutines
<GROUP StringManipulation>
<TITLE String Search and Replace Routines>
<TOPICORDER 900>
--------------------------------------------------------------------------------
@@StringManipulation.StringTestRoutines
<GROUP StringManipulation>
<TITLE String Test Routines>
<TOPICORDER 1000>
--------------------------------------------------------------------------------
@@StringManipulation.StringTransformationRoutines
<GROUP StringManipulation>
<TITLE String Transformation Routines>
<TOPICORDER 1100>
--------------------------------------------------------------------------------
@@StringManipulation.Tabulation
<GROUP StringManipulation>
<TITLE Tabulation>
<TOPICORDER 1150>
--------------------------------------------------------------------------------
@@StringManipulation.TStringsManipulation
<GROUP StringManipulation>
<TITLE TStrings Manipulation>
<TOPICORDER 1200>
--------------------------------------------------------------------------------
@@StrIsAlpha
<GROUP StringManipulation.StringTestRoutines>
Summary:
  Tests whether S contains only alpha characters.
Description:
  StrIsAlpha tests whether the supplied string consists only of alpha characters.
  That is, whether or not all individual characters come from the ['a'..'z', 'A'..'Z']
  set.
Parameters:
  S - The string to test
Result:
  If S contains only alpha characters the result is True, otherwise the result is False.
Notes:
  If S is an empty string the result is False.
See also:
  StrConsistsOfNumberChars
  StrIsAlphaNum
Donator:
  Nick Hodges
--------------------------------------------------------------------------------
@@StrIsAlphaNum
<GROUP StringManipulation.StringTestRoutines>
Summary:
  Tests whether S contains only alpha-numerical characters.
Description:
  StrIsAlphaNum tests whether the supplied string consists only of alpha-numerical
  characters. That is, whether or not all individual characters come from
  the ['a'..'z', 'A'..'Z', '0'..'9'] set.
Parameters:
  S - The string to test
Result:
  If S contains only alpha-numerical characters the result is True, otherwise the result is False.
Notes:
  If S is an empty string the result is False.
See also:
  StrIsAlpha
  StrConsistsOfNumberChars
  StrIsAlphaNumUnderscore
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrIsAlphaNumUnderscore
<GROUP StringManipulation.StringTestRoutines>
Summary:
  Tests whether S contains only alpha-numerical and underscore characters.
Description:
  StrIsAlphaNum tests whether the supplied string consists only of alpha-numerical
  and underscore characters. That is, whether or not all individual characters come
  from the ['a'..'z', 'A'..'Z', '0'..'9', '_'] set.
Parameters:
  S - The string to test
Result:
  If S contains only alpha-numerical and underscore characters the result is True,
  otherwise the result is False.
Notes:
  If S is an empty string the result is False.
See also:
  StrIsAlpha
  StrConsistsOfNumberChars
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrContainsChars
<GROUP StringManipulation.StringTestRoutines>
Summary:
  Determines whether a string contains a specified set of characters.
Description:
  StrContainsChars checks whether the specified string contains at least one character
  that matches one of the characters in the Chars set. If CheckAll is True, the
  function checks whether all characters in the Chars set appear at least once in
  the specified string.
Parameters:
  S - The string to test.
  Chars - The characters for which to test.
  CheckAll - If True, all characters from Chars must appear at least once in the specified string. If False, at least one of the characters in Chars must appear at least once in the specified string.
Result:
  Returns True if the condition is met, otherwise it returns False.
Donator:
  Petr Vones
--------------------------------------------------------------------------------
@@StrIsDigit
<GROUP StringManipulation.StringTestRoutines>
Summary:
  Tests whether S contains only numerical characters.
Description:
  StrConsistsOfNumberChars tests whether the supplied string consists only of numerical characters.
  That is, whether or not all individual characters come from the ['0'..'9'] set.
  The test does not include the decimal separator. To include it in the test
  use StrConsistsOfNumberChars instead.
Parameters:
  S - The string to test
Result:
  If S contains only numerical characters the result is True, otherwise the result is False.
Notes:
  If S is an empty string the result is False.
See also:
  StrIsAlpha
  StrIsAlphaNum
  StrConsistsOfNumberChars
Donator:
  Martin Kubecka
--------------------------------------------------------------------------------
@@StrConsistsOfNumberChars
<GROUP StringManipulation.StringTestRoutines>
Summary:
  Tests whether S contains only numerical characters.
Description:
  StrConsistsOfNumberChars tests whether the supplied string consists only of numerical characters.
  That is, whether or not all individual characters come from the ['0'..'9'] set
  including the decimal separator. To test for numerical characters without the
  decimal separator, use StrIsDigit instead;
Parameters:
  S - The string to test
Result:
  If S contains only numerical characters the result is True, otherwise the result is False.
Notes:
  If S is an empty string the result is False.
See also:
  StrIsAlpha
  StrIsAlphaNum
  StrIsDigit
Donator:
  Nick Hodges
--------------------------------------------------------------------------------
@@StrIsSubset
<GROUP StringManipulation.StringTestRoutines>
Summary:
  Tests whether S contains only characters from the supplied set.
Description:
  StrIsSubset tests whether the supplied string contains only characters from the
  supplied character set. Keep in mind that the test is case-sensitive.
Parameters:
  S - The string to test.
  ValidChars - The set of characters allowed in S.
Result:
  If the string contains only characters from the supplied set the result is True,
  otherwise the result is False.
Notes:
  If the supplied string is empty, the result is always True. If the supplied character
  set is empty, the result is always False. Empty string overules empty set.
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrSame
<GROUP StringManipulation.StringTestRoutines>
Summary:
  Tests two strings for equality.
Description:
  StrSame compares the two supplied strings and returns whether or not they are
  identical.
Parameters:
  S1 - First string to compare.
  S2 - Second string to compare.
Result:
  If the two strings are identical the return value is True, if they are not the
  return value is False.
See also:
  StrCompare
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrCenter
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Centers a string.
Description:
  The StrCenter routine takes the specified string and pads it
  on both the left and right side with the specified character
  until the resulting string is of the specified length. While
  doing this the original string is kept centered. That is,
  there is the same amount of padding at the left side as there
  is on the right side.

  If the specified length is smaller than the length of the
  original the string remains unchanged. In cases where an odd
  number of padding chars have to be inserted there is always
  one more padding char on the right side than on the left
  side.
Parameters:
  C - The character to use for padding.
  L - The desired length of the resulting string.
  S - The string to center.
Result:
  Returns the centered string.
Donator:
  Alexander Radchenko
--------------------------------------------------------------------------------
@@StrDoubleQuote
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Returns a double-quoted version of the string.
Description:
  StrDoubleQuote returns a copy of the string encapsulated in double quotes (").
  That is, if you pass in 'Project JEDI' you'll get '"Project JEDI"' back. If double
  quotes (") are already at the beginning and the end of the string they are added again.
  If they should be added only if they are not already there use StrQuote instead.
Parameters:
  S - The string to encapsulate in quotes. Even an empty string.
Result:
  The double-quoted version of the string.
See also:
  StrQuote
  StrSingleQuote
  StrTrimQuotes
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrEnsurePrefix
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Forces Text to start with Prefix.
Description:
  StrEnsurePrefix tests whether the supplied text start with the supplied prefix.
  If it doesn't then the prefix is prepended to the string otherwise the function
  does nothing. Note that if Text is an empty string then the result will be Prefix.
Parameters:
  Prefix - The prefix to test for and apply.
  Text - The string which must be forced to have a prefix.
Result:
  The function result is a copy of the supplied Text, prefixed with Prefix.
See also:
  StrEnsureNoPrefix
  StrEnsureSuffix
Donator:
  Nick Hodges
--------------------------------------------------------------------------------
@@StrEnsureNoPrefix
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Eventually removes Prefix from Text.
Description:
  StrEnsureNoPrefix tests whether the supplied text start with the supplied prefix.
  If it does then the prefix is deleted from the string otherwise the function
  does nothing.
Parameters:
  Prefix - The prefix to test for and apply.
  Text - The string which must not have a prefix.
Result:
  The function result is a copy of the supplied Text, eventually minus the prefix.
See also:
  StrEnsurePrefix
  StrEnsureNoSuffix
Donator:
  Olivier Sannier
--------------------------------------------------------------------------------
@@StrEnsureSuffix
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Forces Text to end with Suffix.
Description:
  StrEnsureSuffix tests whether the supplied text ends in the supplied suffix.
  If it doesn't then the suffix is appended to the string otherwise the function
  does nothing. Note that if Text is an empty string then the result will be Suffix.
Parameters:
  Suffix - The suffix to test for and apply.
  Text - The string which must be forced to have a suffix.
Result:
  The function result is a copy of the supplied Text, with the suffix.
See also:
  StrEnsureNoSuffix
  StrEnsurePrefix
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrEnsureNoSuffix
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Eventually removes Suffix from Text.
Description:
  StrEnsureSuffix tests whether the supplied text ends in the supplied suffix.
  If it does then the suffix is deleted from the string otherwise the function
  does nothing.
Parameters:
  Suffix - The suffix to test for and apply.
  Text - The string which must not have a suffix.
Result:
  The function result is a copy of the supplied Text, eventually minus the suffix.
See also:
  StrEnsureSuffix
  StrEnsureNoPrefix
Donator:
  Olivier Sannier
--------------------------------------------------------------------------------
@@StrEscapedToString
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Converts an escaped string to a string.
Description:
  StrEscapedToString converts a string which contains escape characters to a string
  without escape characters by replacing all escape characters with their string
  counterparts. For example, a string which contains a '\a' sequence will
  have the '\a' sequence replaced with the BELL character #7.
  The supported escape characters are:
   <TABLE>
Character  Value  Constant   Description
---------  -----  ---------  ------------------
\a         #7     BELL       Bell
\b         #8     BACKSPACE  Backspace
\f         #12    FF         Form Feed
\n         #10    LR         Line Feed
\r         #13    CR         Carrage Return
\t         #9     TAB        Tabulator
\v         #11    VT         Vertical Tabulator
\\         N/A    N/A        Backslash
\"         N/A    N/A        Double quotes
</TABLE>

  In addition it supports hexadecimal escape sequences (sequences that start with \x)
  and octal escape sequences (sequences starting with '\0', '\1' ... '\9').
  The StrStringToEscaped is the "inverse" of this function.
Parameters:
  S - The "escaped" string to convert to a "normal" string.
Result:
  The string with all escape characters replaced with their string counterparts.
See also:
  StrStringToEscaped
Donator:
  Robert Marquardt
--------------------------------------------------------------------------------
@@StrLower
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Lowercases all characters in a string.
Description:
  StrLower returns a copy of the string, converted to lowercase. That is, if you pass in 'Project JEDI' you'll get 'project jedi'.
Parameters:
  S - String to convert to lowercase.
See also:
  StrLowerInPLace
  StrLowerBuff
  StrUpper
  StrUpperInPlace
  StrUpperBuff
Donator:
  Pelle F. S. Liljendal
--------------------------------------------------------------------------------
@@StrLowerInPlace
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Lowercases all characters in a string.
Description:
  StrLower converts all characters in the supplied string to lowercase.
Parameters:
  S - String to convert to lowercase.
See also:
  StrLower
  StrLowerBuff
  StrUpper
  StrUpperInPlace
  StrUpperBuff
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrLowerBuff
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Lowercases all characters in a string.
Description:
  StrLowerBuff converts all characters in the supplied string to lowercase.
Parameters:
  P - String to convert to lowercase.
See also:
  StrLower
  StrLowerInPlace
  StrUpper
  StrUpperInPlace
  StrUpperBuff
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrMove
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Copies a sub-string from one string to another.
Description:
  StrMove copies Count characters starting at FromIndex in the source string to
  the destination string starting at ToIndex. The function checks the passed
  parameters and if any is illegal the function does nothing. This includes
  illegal indices and, for example, a zero-length destination string.
Parameters:
  Dest - The destination string which the sub-string is copied to.
  Source - The source string from which the sub-string is copied.
  ToIndex - The index into the destination string at which the sub-string is copied.
  FromIndex - The starting index into the source string from which count characters are copied.
  Count - Length of the sub-string to copy in characters.
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrPadLeft
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Left pads a string with characters.
Description:
  StrPadLeft left pads a string with the specified character until the resulting
  string is Len characters long. If the source string is already greater than or
  equal in length to Len the function does nothing.
Parameters:
  S - Source string to left pad.
  Len - The length of the resulting string.
  C - The character to pad the string with.
Result:
  The string left padded with the specified character.
See also:
  StrPadRight
  StrCenter
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrPadRight
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Right pads a string with characters.
Description:
  StrPadRight right pads a string with the specified character until the resulting
  string is Len characters long. If the source string is already greater than or equal
  in length to Len the function does nothing.
Parameters:
  S - Source string to right pad.
  Len - The length of the resulting string.
  C - The character to pad the string with.
Result:
  The string right padded with the specified character.
See also:
  StrPadLeft
  StrCenter
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrProper
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Lowercases the supplied string and uppercases the first character.
Description:
  The StrProper routine lowercases the entire string and subsequently uppercases
  the first character.
Parameters:
  S - The string to transform.
Result:
  The transformed string.
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrProperBuff
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Lowercases the supplied string and uppercases the first character.
Description:
  The StrProper routine lowercases the entire string and subsequently uppercases
  the first character.
Parameters:
  S - The string to transform.
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrQuote
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Quotes a string with a specific character.
Description:
  StrQuote quotes the string with a specified character. Upon return the string is
  guarenteed to begin and end with the specified character. Note that if the string
  already starts or ends with this character, it is not added again.
Parameters:
  S - The string to quote.
  C - The character with which to quote the string.
Result:
  The quoted string.
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrRemoveChars
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Removes a set of characters from a string.
Description:
  StrRemoveChars removes all instances of the characters in the set from the source
  string. For example, if you pass in 'Joint Endeavour of Delphi Innovators' and
  specify ['e', 'a', 'o', 'u', 'i'] the resulting string will be 'Jnt Endvr f Dlph Innvtrs'.
Parameters:
  S - The source string from which to remove the characters.
  Chars - The set of characters which are removed from S.
Result:
  The string with all characters from the supplied set removed.
Notes:
  The function is case sensitive. That is, specifying 'e' will not remove 'E'.
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrRepeat
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Repeats a string Count number of times.
Description:
  The StrRepeat routine returns a string consisting of the specified string, repeated
  Count number of times. For example, StrRepeat('He', 3) returns 'HeHeHe'.
Parameters:
  S - The string to repeat.
  Count - The number of times to repeat the specified string.
Result:
  The specified string, repeated Count number of times.
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrReverse
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Reverses a string.
Description:
  StrReverse returns a reversed copy of S. That is, if you pass in 'Delphi' the
  function result will be 'ihpleD'. Note that the original string remains unmodified,
  as the const modifier indicates. If you don't need the original string after
  reversing it, then do not write code like S := StrReverse(S) but instead use
  the StrReverseInPlace function because it's much faster.
Parameters:
  S - The string to reverse.
Result:
  A reversed copy of the supplied string.
See also:
  StrReverseInPlace
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrReverseInPlace
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Reverses a string.
Description:
  StrReverse reverses S. That is, if you pass in 'Delphi' then after the function
  returns S contains the string 'ihpleD'. If you need to retain the original
  string then use the StrReverse function instead.
Parameters:
  S - The string to reverse.
See also:
  StrReverse
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrSingleQuote
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Returns a single-quoted version of the string.
Description:
  StrSingleQuote returns a copy of the string encapsulated in single quotes (').
  That is, if you pass in 'Project JEDI' you'll get ''Project JEDI'' back.
Parameters:
  S - The string to encapsulate in quotes. Even an empty string.
Result:
  The single-quoted version of the string.
See also:
  StrDoubleQuote
  StrTrimQuotes
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrSmartCase
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Converts a string to 'smartcase' or 'camelcase'.
Description:
  StrSmartCase converts specified characters within the supplied source string to
  uppercase. The characters that are uppercased are determined by the Delimiters
  character set. Each time the function finds a character in the source string that
  is also present in the Delimiters set it uppercases the next character
  in the source string. In addition, the function always converts the first character
  to uppercase. For example, if you call StrSmartCase('project jedi rules', [' '])
  the function returns 'Project Jedi Rules'. As you can see, all characters that
  immediately follow a space (as specified by Delimiters) are uppercased.
Parameters:
  S - Source string.
  Delimiters - Set of characters to use as delimiters. These characters determine which other
  characters are uppercased. If you supply an empty set the function assumes you want to use a
  space only. That is, it sets Delimiters to [' '].
Result:
  The string converted to smart case.
Notes:
  Original author is John C Molyneux (jaymol@hotmail.com). Function was rewritten by
  Marcel van Brakel.
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrStringToEscaped
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Converts a string to an escaped string.
Description:
  StrStringToEscaped converts a string to an escaped string by replacing non-visual
  character sequences with their escape characters. For example, if a string contains
  the character #7 the resulting string will have the #7 character replaced with the '\a'
  sequence. This function is the inverse of StrEscapedToString.
  The function supports the following escape characters:
   <TABLE>
Character  Value  Constant   Description
---------  -----  ---------  ------------------
\a         #7     BELL       Bell
\b         #8     BACKSPACE  Backspace
\f         #12    FF         Form Feed
\n         #10    LR         Line Feed
\r         #13    CR         Carrage Return
\t         #9     TAB        Tabulator
\v         #11    VT         Vertical Tabulator
\\         N/A    N/A        Backslash
\"         N/A    N/A        Double quotes
</TABLE>

  All other characters whose ordinal value are smaller than Ord(' ') are escaped
  as a hexadecimal sequence like '\x01'. The StrEscapedToString is the "inverse"
  of this function.
Parameters:
  S - The string to convert to an escaped string.
Result:
  The "escaped" string.
See also:
  StrEscapedToString
Donator:
  Robert Marquardt
--------------------------------------------------------------------------------
@@StrStripNonNumberChars
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Removes all non-number characters from a string.
Description:
  StrStripNonNumberChars removes all non-number characters from the specified string.
  Hence the resulting string will contain only number characters. Testing whether
  the individual characters are numbers is done using the CharIsNumberChar routine and
  therefore characters that qualify are all digits (0..9), signs (+, -) and decimal
  separators.
Parameters:
  S - The string from which to remove non-number characters.
Result:
  The string after all non-number characters are removed.
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrTrimQuotes
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Removes surrounding quotes from the supplied string.
Description:
  StrTrimQuotes removes surrounding quotes, either single or double-quotes, from
  the string. For example if you pass in ''Project JEDI'' you'll get 'Project JEDI'
  back. Note that this function only removes quotes if the string both begins and
  ends with the same quote character.
Parameters:
  S - The string to unquote.
Result:
  The unquoted string.
See also:
  StrSingleQuote
  StrDoubleQuote
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrToHex
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Converts a string of hex digit pairs to the corresponding bytes.
Description:
  The Source string is expected to contain pairs of hex digit
  characters ['0'..'9', 'a'..'f', 'A'..'F']. Each pair is converted to a single
  byte thus converting '40' to '@'. Any character not from the hex set
  results in an empty string. If the string length of the Source is odd
  then a '0' is prepended internally to make up the first byte.
Parameters:
  S - A string of hex digit pairs to be converted.
Result:
  The string of converted bytes.
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrTrimCharLeft
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Removes leading characters from a string.
Description:
  The StrTrimCharLeft routine removes leading characters from the specified string.
  For example, StrTrimCharLeft('000123', '0') returns '123'.
Parameters:
  S - The source string from which the leading characters need to be removed.
  C - The character to remove.
Result:
  The function returns the source string S without any leading characters C.
See also:
  StrTrimCharRight
Donator:
  Jack N.A. Bakker
--------------------------------------------------------------------------------
@@StrTrimCharRight
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Removes trailing characters from a string.
Description:
  The StrTrimCharRight routine removes trailing characters from the specified string.
  For example, StrTrimCharRight('123000', '0') returns '123'.
Parameters:
  S - The source string from which the trailing characters need to be removed.
  C - The character to remove.
Result:
  The function returns the source string S without any trailing characters C.
See also:
  StrTrimCharLeft
Donator:
  Jack N.A. Bakker
--------------------------------------------------------------------------------
@@StrUpper
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Uppercases all characters in a string
Description:
  StrUpper returns a copy of the string, converted to uppercase. That is, if you pass
  in 'Project JEDI' you'll get 'PROJECT JEDI'.
Parameters:
  S - String to convert to uppercase.
See also:
  StrUpperInPlace
  StrUpperBuff
  StrLower
  StrLowerInPlace
  StrLowerBuff
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrUpperInPlace
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Uppercases all characters in a string.
Description:
  StrUpper converts all characters in the supplied string to uppercase.
Parameters:
  S - String to convert to uppercase.
See also:
  StrUpper
  StrUpperBuff
  StrLower
  StrLowerInPlace
  StrLowerBuff
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrUpperBuff
<GROUP StringManipulation.StringTransformationRoutines>
Summary:
  Uppercases all characters in a string.
Description:
  StrUpper converts all characters in the supplied string to uppercase.
Parameters:
  S - String to convert to uppercase.
See also:
  StrUpper
  StrUpperInPlace
  StrLower
  StrLowerInPlace
  StrLowerBuff
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrAddRef
<GROUP StringManipulation.StringManagement>
Summary:
  Increments the reference count of a long string.
Description:
  The StrAddRef routine increments the reference count of the specified long string.
  Explicitly incrementing a strings reference count forces Delphi to keep the string
  in memory even if the variable itself goes out of scope and all other references
  were removed already. Note that if the string points to a string constant this
  routine will call UniqueString on it forcing a string copy, after which the
  reference count becomes 1.
Parameters:
  S - The long string whose reference count to increment.
See also:
  StrDecRef
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrAllocSize
<GROUP StringManipulation.StringManagement>
Summary:
  Returns the memory allocated to store the string.
Description:
  A long string variable is a 4 byte pointer to a dynamically allocated block of
  memory. This block of memory holds the actual string data, including a NULL
  character. In addition this block of memory has, at a negative offset, a number
  of 32 bit values used to manage the string. The StringAllocSize function looks
  at this negative offset to determine the total amount of dynamic memory reserved
  to hold the string and management data.
  Note that this function will always return 0 for string literals, string constants
  and string variables that are assigned to string constants, but haven't been
  modified yet. This is not a bug but a result of the way in which Delphi manages
  string constants.
Parameters:
  S - The string for which to determine the total amount of used memory.
Result:
  The amount of dynamic memory allocated for the string or 0 in the exceptions noted
  above. Note that, at least in Delphi 5, the result will always be a multiple of 4.
Notes:
  This function relies on pseudo-undocumented knowledge and should only be used for
  debugging purposes.
See also:
  StrRefCount
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrDecRef
<GROUP StringManipulation.StringManagement>
Summary:
  Decrements the reference count of a long string.
Description:
  The StrDecRef routine decrements the reference count of the specified long string.
  Note that if decrementing the reference count will set it to 0 the string is
  released and the string pointer is set to nil. Therefore the string may be
  inaccessible after calling this routine.
Parameters:
  S - The long string whose reference count to increment. Upon return the string may
  have been freed.
See also:
  StrDecRef
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrLen
<GROUP StringManipulation.StringManagement>
Summary:
  Returns the length of the supplied string.
Description:
  StrLen returns the length of the supplied string, in characters, excluding the
  null terminating character. This function is identical to the StrLen routine from
  SysUtils.pas except that it is much faster.
Parameters:
  S - Pointer to the null terminated string for which to determine the length.
Result:
  The length of the string, in characters.
Donator:
  Robert Lee
--------------------------------------------------------------------------------
@@StrLength
<GROUP StringManipulation.StringManagement>
Summary:
  Returns the length of the supplied string.
Description:
  StrLength returns the length of the supplied string. This is a duplication of the
  standard Delphi Length function and is only supplied for completeness. You should
  prefer the Length function over StrLength.
Parameters:
  S - The string for which to determine the length.
Result:
  The length of the string in characters.
Notes:
  This function relies on pseudo undocumented knowledge.
See also:
  StrAllocSize
  StrRefCount
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrRefCount
<GROUP StringManipulation.StringManagement>
Summary:
  Returns the reference count of the supplied string.
Description:
  StrRefCount returns the reference count of the string. Note that this function
  will always return -1 for string literals, string constants and string variables
  that are assigned to string constants, but haven't been modified yet. This is
  not a bug but a result of the way in which Delphi manages string constants.
Parameters:
  S - String for which to determine the reference count.
Result:
  The reference count of the string or -1 if the string ultimately points to a
  string constant.
Notes:
  This function relies on pseudo-undocumented knowledge and should only be used for
  debugging purposes.
See also:
  StrAllocSize
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrResetLength
<GROUP StringManipulation.StringManagement>
Summary:
  Resets the length of the supplied string.
Description:
  StrResetLength resets the length of the string to encompass only the actual number
  of used characters. This is particularly useful when passing strings to API
  functions which accept PChar's. These kind of functions do modify the string but
  since they are unaware of how Delphi manages strings, the length is not changed
  on return. Depending on how you use the string from that point on the results
  may be incorrect if you do not apply StrResetLength.
  The function resets the length to the C string length, i. e. the length up to the first #0 byte.
Parameters:
  S - The string whose length to reset.
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrCharCount
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Counts the occurrences of a character in a string.
Description:
  StrCharCount returns the number of occurrences of the specified character in the
  supplied string.
Parameters:
  S - Source string.
  C - The character whose occurrences to count.
Result:
  The number of occurrences of C in S.
Donator:
  Massimo Maria Ghisalberti
--------------------------------------------------------------------------------
@@StrCompare
<GROUP StringManipulation.StringTestRoutines>
Summary:
  Compares two strings.
Description:
  StrCompare implements a case-insensitive comparison between the two supplied
  strings. If the two strings match the function returns 0 otherwise it returns
  the number of different characters. If the supplied strings are of equal length
  but are not identical the function returns the difference of the first mismatched
  character. The table below demonstrates this:
   <TABLE>
S1            S2            Result
------------  ------------  ------------------------------
jedi          jedi          0
jedi          je            2
di            jedi          -2
project jedi  jedi          8
jedi          project jedi  -8
jedi          judi          Ord('e') - Ord('u')
JEDI          Judi          Ord(LowerCase('E')) - Ord('u')
</TABLE>

Parameters:
  S1 - First string to compare.
  S2 - Second string to compare.
Result:
  StrCompare returns 0 if the two strings match or the number of different characters
  in case of a mismatch.
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrCompareRange
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Description:
  StrCompareRange compares, case-sensitive, a sub-string from the
  first supplied string with the second string. If the two
  strings are identical the function returns 0 otherwise it
  returns an indication of difference between the two strings,
  The result is equal to the result returned by StrCompare. This
  function is particularly useful to avoid code such as: "if
  Copy(S, 1, 4) = 'JEDI' then ..." which is quite inefficient.
  This code would be rewritten to: "if StrCompareRange(S1,
  'JEDI', 1, 4) = 0 then ...".
Summary:
  Compares two (sub) strings.
Parameters:
  Count - Number of characters of the sub-string in S1 to compare to S2.
  Index - Starting index of sub-string in S1 to.
  S1 - First string to compare.
  S2 - Second string to compare.
Result:
  StrCompareRange returns 0 if the two strings match or the
  number of different characters in case of a mismatch.
See also:
  StrCompare
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrFillChar
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Creates a string consisting of the specified character repeated Count times.
Description:
  The StrFillChar routine returns a string consisting of the specified character
  repeated Count number of times.
Parameters:
  C - The character to repeat.
  Count - The number of times to repeat the character.
Result:
  A string consisting of the specified character repeated Count times.
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrFind
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns the index of the first character in a specified sub-string that occurs in a given string.
Description:
  StrFind returns the index of the first character in a specified sub-string that
  occurs in a given string. The search starts at the supplied index and is case-insensitive.
Parameters:
  Substr - The sub-string to search for.
  Str - The string in which to search.
  Index - The index in Str at which to start the search.
Result:
  One-based index of the first character of SubStr in Str or 0 if SubStr does not
  occur in the supplied string.
See also:
  StrSearch
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrHasPrefix
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns whether a string is prefixed by one of the supplied strings.
Description:
  StrHasPrefix returns whether the string is prefixed with at least one of the strings
  supplied in the Prefixes array. In other words, for each string in the Prefixes
  array it's determined if the supplied string starts with that prefix. Note that
  the routine exits as soon as a match is found and matching is case-sensitive (use
  StrIHasPrefix for a case-insensitive matching version).
Parameters:
  S - The string to test.
  Prefixes - Array of prefixes to test for.
Result:
  If the supplied string is prefixed with one of the supplied prefixes the routine
  returns True, otherwise it returns False.
See also:
  StrIHasPrefix, StrPrefixIndex
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrIHasPrefix
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns whether a string is prefixed by one of the supplied strings.
Description:
  StrHasPrefix returns whether the string is prefixed with at least one of the strings
  supplied in the Prefixes array. In other words, for each string in the Prefixes
  array it's determined if the supplied string starts with that prefix. Note that
  the routine exits as soon as a match is found and matching is case-insensitive (use
  StrHasPrefix for a case-sensitive matching version).
Parameters:
  S - The string to test.
  Prefixes - Array of prefixes to test for.
Result:
  If the supplied string is prefixed with one of the supplied prefixes the routine
  returns True, otherwise it returns False.
See also:
  StrHasPrefix, StrIPrefixIndex
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrIndex
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns the index of a string in an array of strings.
Description:
  StrIndex returns the index into the List array at which S is positioned. This is
  particularly useful to create a case statement based on string labels. For example:

    case StrIndex(S, ['zero', 'one', 'two']) of
      0: // handle case where S = 'zero'
      1: // handle case where S = 'one'
      2: // handle case where S = 'two'
    else
      //
    end;
    
Parameters:
  S - The string to test.
  List - Array of strings to search in.
Result:
  If the supplied string exists in the List array the zero based index of the position
  at which it appears is returned. If the string doesn't exist in the array -1 is
  returned. Note that the string comparison is case insensitive but is based on the
  current locale (ie it uses AnsiSameText).
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrILastPos
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns the index of the last occurrence of SubStr in S.
Description:
  StrILastPos scans the supplied string and returns the index of the first character
  of the last occurrence of the supplied sub-string. The comparison is case-insensitive.
Parameters:
  SubStr - The sub-string to find the last occurrence of.
  S - The string in which to search.
Result:
  The index of the last occurrence of SubStr in S. If the sub-string does not exist
  at all the result is 0.
See also:
  StrLastPos
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrLastPos
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns the index of the last occurrence of SubStr in S.
Description:
  StrLastPos scans the supplied string and returns the index of the first character
  of the last occurrence of the supplied sub-string. The comparison is case-sensitive.
Parameters:
  SubStr - The sub-string to find the last occurrence of.
  S - The string in which to search.
Result:
  The index of the last occurrence of SubStr in S. If the sub-string does not exist
  at all the result is 0.
See also:
  StrILastPos
Donator:
  Marcel van Brakel
--------------------------------------------------------------------------------
@@StrIPos
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns the index of the first occurrence of SubStr in S.
Description:
  StrIPos scans the supplied string and returns the index of the first character
  of the first occurrence of the supplied sub-string. The comparison is case-insensitive.
Parameters:
  SubStr - The sub-string to find the first occurrence of.
  S - The string in which to search.
Result:
  The index of the first occurrence of SubStr in S. If the sub-string does not exist
  at all the result is 0.
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrIPrefixIndex
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns the index at which a string appears which is used as a prefix.
Description:
  StrPrefixIndex returns the index into the prefixes array at which a string appears
  with which the supplied string is prefixed. For example,
  StrPrefixIndex('banana', ['call', 'ban', 'bana']) will return 1. Note that as
  can be seen from the example, as soon as a prefix is found the routine stops and
  doesn't attempt to find a better (longer) match. Matching is case-insensitive; use
  StrPrefixIndex for a case-insensitive version.
Parameters:
  S - The string to test.
  Prefixes - The list of prefixes.
Result:
  The zero based index into Prefixes at which the first string appears that is used
  as a prefix in the supplied string. If none of the Prefixes array strings qualifies
  the result is -1.
See Also
  StrIHasPrefix, StrPrefixIndex
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrIsOneOf
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Tests whether the supplied string exists in the list of strings.
Description:
  StrIsOneOf tests whether the supplied string exists in the list of strings. Note
  that the comparison is case-insensitive.
Parameters:
  S - The string to test.
  List - The list of string in which to search.
Result:
  If the string exists in the supplied list the result is True, otherwise it's False.
Donator:
  Anthony Steele
--------------------------------------------------------------------------------
@@StrNPos
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns the position of the N-th occurence of a sub-string within a string.
Description:
  StrNPos returns the index into S of the N-th occurence of the specified sub-string.
  This function is case-sensitive and does not work with multibyte character sets.
  If the specified sub-string does not have N occurence in S the function returns 0.
Parameters:
  S - The string in which to search for N occurences of SubStr.
  SubStr - The sub-string to search for.
  Index - The number of occurences of sub-string in S.
Result:
  Index into S where the N-th occurence of SubStr is located. If SubStr has less
  than N occurences in S the result is 0.
Notes:
  This function was inspired by code submitted by George Tasker
See also:
  StrNIPos
Donator:
  Team JCL
--------------------------------------------------------------------------------
@@StrNIPos
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns the position of the N-th occurence of a sub-string within a string.
Description:
  StrNPos returns the index into S of the N-th occurence of the specified sub-string.
  This function is case-insensitive and does not work with multibyte character sets.
  If the specified sub-string does not have N occurence in S the function returns 0.
Parameters:
  S - The string in which to search for N occurences of SubStr.
  SubStr - The sub-string to search for.
  N - The number of occurences of sub-string in S.
Result:
  Index into S where the N-th occurence of SubStr is located. If SubStr has less
  than N occurences in S the result is 0.
Notes:
  This function was inspired by code submitted by George Tasker
See also:
  StrNPos
Donator:
  Team JCL
--------------------------------------------------------------------------------
@@StrMatch
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns the index of the first character in a specified sub-string that occurs in a given string.
Description:
  StrMatch returns the index of the first character in a specified sub-string that
  occurs in a given string. The search starts at the supplied index and is case-insensitive.
  The specified sub-string may contain wildcards. The '?' wildcard matches 1 character
  while the '*' wildcard matches 0 or more occurrences of a character. For example, 'J?DI'
  will find 'JEDI', 'JZDI' and 'JODI' (and more) while 'J*I' will find 'JEDI' and 'JI'.
Parameters:
  Substr - The sub-string to search for. May contain wildcards.
  Str - The string in which to search.
  Index - The index in Str at which to start the search.
Result:
  One-based index of the first character of SubStr in Str or 0 if SubStr does not
  occur in the supplied string.
Notes:
  The '*' wildcard currently doesn't work correctly, it produces the same result as '?'.
See also:
  StrSearch
Donator:
  Azret Botash
--------------------------------------------------------------------------------
@@StrPrefixIndex
<GROUP StringManipulation.StringSearchandReplaceRoutines>
Summary:
  Returns the index at which a string appears which is used as a prefix.
Description:
  StrPrefixIndex returns the index into the prefixes array at which a string appears
  with which the supplied string is prefixed. F…