%%	options

copyright owner	=	Dirk Krause
copyright year	=	2011-2014
license		=	bsd

%%	header

#include "dk3conf.h"
#include "dk3types.h"

#ifdef __cplusplus
extern "C" {
#endif

/**	Calculate string length.
 * 	@param	s	String to process.
 * 	@return	String length (number of characters).
 */
size_t
dk3str_c8_len(char const *s);

/**	Calculate string length.
 * 	@param	s	String to process.
 * 	@return	String length (number of characters).
 */
size_t
dk3str_c16_len(dk3_c16_t const *s);

/**	Calculate string length.
 * 	@param	s	String to process.
 * 	@return	String length (number of characters).
 */
size_t
dk3str_c32_len(dk3_c32_t const *s);

/**	Calculate string length.
 * 	@param	s	String to process.
 * 	@return	String length (number of characters).
 */
size_t
dk3str_len(dkChar const *s);

/**	Compare two strings.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@return	1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_c8_cmp(char const *s1, char const *s2);

/**	Compare two strings.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@return	1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_c16_cmp(dk3_c16_t const *s1, dk3_c16_t const *s2);

/**	Compare two strings.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@return	1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_c32_cmp(dk3_c32_t const *s1, dk3_c32_t const *s2);

/**	Compare two strings.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@return	1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_cmp(dkChar const *s1, dkChar const *s2);

/**	Case-insensitve string comparison.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@return 1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_c8_casecmp(char const *s1, char const *s2);


/**	Case-insensitve string comparison.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@return 1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_c16_casecmp(dk3_c16_t const *s1, dk3_c16_t const *s2);

/**	Case-insensitve string comparison.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@return 1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_c32_casecmp(dk3_c32_t const *s1, dk3_c32_t const *s2);

/**	Case-insensitve string comparison.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@return 1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_casecmp(dkChar const *s1, dkChar const *s2);

/**	File name comparison, case-sensitive on some systems,
 *	case-insensitive on other systems.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@return 1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_fncmp(dkChar const *s1, dkChar const *s2) ;

/**	Compare two strings, use only the first \a n characters.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@param	n	Number of characters to use in comparison.
 * 	@return	1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_c8_ncmp(char const *s1, char const *s2, size_t n);

/**	Compare two strings, use only the first \a n characters.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@param	n	Number of characters to use in comparison.
 * 	@return	1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_c16_ncmp(dk3_c16_t const *s1, dk3_c16_t const *s2, size_t n);

/**	Compare two strings, use only the first \a n characters.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@param	n	Number of characters to use in comparison.
 * 	@return	1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_c32_ncmp(dk3_c32_t const *s1, dk3_c32_t const *s2, size_t n);

/**	Compare two strings, use only the first \a n characters.
 * 	@param	s1	Left side string.
 * 	@param	s2	Right side string.
 * 	@param	n	Number of characters to use in comparison.
 * 	@return	1 for s1>s2, 0 for s1=s2, -1 for s1<s2.
 */
int
dk3str_ncmp(dkChar const *s1, dkChar const *s2, size_t n);

/**	Find left-most orrucance of character in string.
 * 	@param	s	String probably containing the character.
 * 	@param	c	Character to search for.
 * 	@return	Pointer to character position on success, NULL on error.
 */
char *
dk3str_c8_chr(char const *s, char c);

/**	Find left-most orrucance of character in string.
 * 	@param	s	String probably containing the character.
 * 	@param	c	Character to search for.
 * 	@return	Pointer to character position on success, NULL on error.
 */
dk3_c16_t *
dk3str_c16_chr(dk3_c16_t const *s, dk3_c16_t c);

/**	Find left-most orrucance of character in string.
 * 	@param	s	String probably containing the character.
 * 	@param	c	Character to search for.
 * 	@return	Pointer to character position on success, NULL on error.
 */
dk3_c32_t *
dk3str_c32_chr(dk3_c32_t const *s, dk3_c32_t c);

/**	Find left-most orrucance of character in string.
 * 	@param	s	String probably containing the character.
 * 	@param	c	Character to search for.
 * 	@return	Pointer to character position on success, NULL on error.
 */
dkChar *
dk3str_chr(dkChar const *s, dkChar c);

/**	Find right-most orrucance of character in string.
 * 	@param	s	String probably containing the character.
 * 	@param	c	Character to search for.
 * 	@return	Pointer to character position on success, NULL on error.
 */
char *
dk3str_c8_rchr(char const *s, char c);

/**	Find right-most orrucance of character in string.
 * 	@param	s	String probably containing the character.
 * 	@param	c	Character to search for.
 * 	@return	Pointer to character position on success, NULL on error.
 */
dk3_c16_t *
dk3str_c16_rchr(dk3_c16_t const *s, dk3_c16_t c);

/**	Find right-most orrucance of character in string.
 * 	@param	s	String probably containing the character.
 * 	@param	c	Character to search for.
 * 	@return	Pointer to character position on success, NULL on error.
 */
dk3_c32_t *
dk3str_c32_rchr(dk3_c32_t const *s, dk3_c32_t c);

/**	Find right-most orrucance of character in string.
 * 	@param	s	String probably containing the character.
 * 	@param	c	Character to search for.
 * 	@return	Pointer to character position on success, NULL on error.
 */
dkChar *
dk3str_rchr(dkChar const *s, dkChar c);

/**	Copy string.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_c8_cpy(char *d, char const *s);

/**	Copy string.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_c16_cpy(dk3_c16_t *d, dk3_c16_t const *s);

/**	Copy string.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_c32_cpy(dk3_c32_t *d, dk3_c32_t const *s);

/**	Copy string.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_cpy(dkChar *d, dkChar const *s);

/**	Copy string.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_c8_cpy_not_overlapped(char *d, char const *s);

/**	Copy string.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_c16_cpy_not_overlapped(dk3_c16_t *d, dk3_c16_t const *s);

/**	Copy string.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_c32_cpy_not_overlapped(dk3_c32_t *d, dk3_c32_t const *s);

/**	Copy string.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_cpy_not_overlapped(dkChar *d, dkChar const *s);

/**	Copy string, cut to buffer size if necessary.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 * 	@param	n	Size of \a d (number of characters).
 */
void
dk3str_c8_ncpy(char *d, char const *s, size_t n);

/**	Copy string, cut to buffer size if necessary.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 * 	@param	n	Size of \a d (number of characters).
 */
void
dk3str_c16_ncpy(dk3_c16_t *d, dk3_c16_t const *s, size_t n);

/**	Copy string, cut to buffer size if necessary.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 * 	@param	n	Size of \a d (number of characters).
 */
void
dk3str_c32_ncpy(dk3_c32_t *d, dk3_c32_t const *s, size_t n);

/**	Copy string, cut to buffer size if necessary.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 * 	@param	n	Size of \a d (number of characters).
 */
void
dk3str_ncpy(dkChar *d, dkChar const *s, size_t n);

/**	Concatenate two strings.
 * 	Do not use this function directly, use dk3str_c8_cat() instead.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_c8_cat(char *d, char const *s);

/**	Concatenate two strings.
 * 	Do not use this function directly, use dk3str_c16_cat() instead.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_c16_cat(dk3_c16_t *d, dk3_c16_t const *s);

/**	Concatenate two strings.
 * 	Do not use this function directly, use dk3str_c32_cat() instead.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_c32_cat(dk3_c32_t *d, dk3_c32_t const *s);

/**	Concatenate two strings.
 * 	Do not use this function directly, use dk3str_c32_cat() instead.
 * 	@param	d	Destination pointer.
 * 	@param	s	Source pointer.
 */
void
dk3str_cat(dkChar *d, dkChar const *s);

/**	Create a string copy in dynamically allocated memory.
	@param	s	Original string.
	@param	app	Application structure for diagnostics.
	@return	Pointer to copy on success, NULL on error.
	The pointer returned on success must be released by
	dk3_release() when done with it.
*/
char *
dk3str_c8_dup_app(char const *s, dk3_app_t *app);

/**	Create a string copy in dynamically allocated memory.
	@param	s	Original string.
	@param	app	Application structure for diagnostics.
	@return	Pointer to copy on success, NULL on error.
	The pointer returned on success must be released by
	dk3_release() when done with it.
*/
dk3_c16_t *
dk3str_c16_dup_app(dk3_c16_t const *s, dk3_app_t *app);

/**	Create a string copy in dynamically allocated memory.
	@param	s	Original string.
	@param	app	Application structure for diagnostics.
	@return	Pointer to copy on success, NULL on error.
	The pointer returned on success must be released by
	dk3_release() when done with it.
*/
dk3_c32_t *
dk3str_c32_dup_app(dk3_c32_t const *s, dk3_app_t *app);

/**	Create a string copy in dynamically allocated memory.
	@param	s	Original string.
	@param	app	Application structure for diagnostics.
	@return	Pointer to copy on success, NULL on error.
	The pointer returned on success must be released by
	dk3_release() when done with it.
*/
dkChar *
dk3str_dup_app(dkChar const *s, dk3_app_t *app);

/**	Convert to lower-case character.
 * 	@param	c	Character to convert.
 * 	@return	Conversion result.
 */
char
dk3str_c8_tolower(char c);

/**	Convert to lower-case character.
 * 	@param	c	Character to convert.
 * 	@return	Conversion result.
 */
dk3_c16_t
dk3str_c16_tolower(dk3_c16_t c);

/**	Convert to lower-case character.
 * 	@param	c	Character to convert.
 * 	@return	Conversion result.
 */
dk3_c32_t
dk3str_c32_tolower(dk3_c32_t c);

/**	Convert to lower-case character.
 * 	@param	c	Character to convert.
 * 	@return	Conversion result.
 */
dkChar
dk3str_tolower(dkChar c);

/**	Convert to upper-case character.
 * 	@param	c	Character to convert.
 * 	@return	Conversion result.
 */
char
dk3str_c8_toupper(char c);

/**	Convert to upper-case character.
 * 	@param	c	Character to convert.
 * 	@return	Conversion result.
 */
dk3_c16_t
dk3str_c16_toupper(dk3_c16_t c);

/**	Convert to upper-case character.
 * 	@param	c	Character to convert.
 * 	@return	Conversion result.
 */
dk3_c32_t
dk3str_c32_toupper(dk3_c32_t c);

/**	Convert to upper-case character.
 * 	@param	c	Character to convert.
 * 	@return	Conversion result.
 */
dkChar
dk3str_toupper(dkChar c);

/**	Find start of string (first non-whitespace).
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 * 	@return	Pointer to first non-whitespace on success, NULL on error.
 */
char *
dk3str_c8_start(char const *str, char const *whsp);

/**	Find start of string (first non-whitespace).
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 * 	@return	Pointer to first non-whitespace on success, NULL on error.
 */
dk3_c16_t *
dk3str_c16_start(dk3_c16_t const *str, dk3_c16_t const *whsp);

/**	Find start of string (first non-whitespace).
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 * 	@return	Pointer to first non-whitespace on success, NULL on error.
 */
dk3_c32_t *
dk3str_c32_start(dk3_c32_t const *str, dk3_c32_t const *whsp);

/**	Find start of string (first non-whitespace).
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 * 	@return	Pointer to first non-whitespace on success, NULL on error.
 */
dkChar *
dk3str_start(dkChar const *str, dkChar const *whsp);

/**	Find start of second text
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 * 	@return	Pointer to second non-whitespace sequence on success, or NULL.
 */
char    *
dk3str_c8_next(char *str, char const *whsp);

/**	Find start of second text
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 * 	@return	Pointer to second non-whitespace sequence on success, or NULL.
 */
dk3_c16_t *
dk3str_c16_next(dk3_c16_t *str, dk3_c16_t const *whsp);

/**	Find start of second text
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 * 	@return	Pointer to second non-whitespace sequence on success, or NULL.
 */
dk3_c32_t *
dk3str_c32_next(dk3_c32_t *str, dk3_c32_t const *whsp);

/**	Find start of second text
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 * 	@return	Pointer to second non-whitespace sequence on success, or NULL.
 */
dkChar *
dk3str_next(dkChar *str, dkChar const *whsp);

/**	Remove trailing whitespaces from string.
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 */
void
dk3str_c8_chomp(char *str, char const *whsp);

/**	Remove trailing whitespaces from string.
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 */
void
dk3str_c16_chomp(dk3_c16_t *str, dk3_c16_t const *whsp);

/**	Remove trailing whitespaces from string.
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 */
void
dk3str_c32_chomp(dk3_c32_t *str, dk3_c32_t const *whsp);

/**	Remove trailing whitespaces from string.
 * 	@param	str	String to process.
 * 	@param	whsp	Whitespaces set (use NULL for default whitespace set).
 */
void
dk3str_chomp(dkChar *str, dkChar const *whsp);

/**	Remove trailing newline.
	@param	str	String to modify.
*/
void
dk3str_c8_delnl(char *str);

/**	Remove trailing newline.
	@param	str	String to modify.
*/
void
dk3str_c16_delnl(dk3_c16_t *str);

/**	Remove trailing newline.
	@param	str	String to modify.
*/
void
dk3str_c32_delnl(dk3_c32_t *str);

/**	Remove trailing newline.
	@param	str	String to modify.
*/
void
dk3str_delnl(dkChar *str);

/**	Find index of a string in an array of patterns.
 * 	@param	a	Patterns array.
 * 	@param	s	String to find.
 * 	@param	c	Flag: Case-sensitive (1) or not (0).
 * 	@return	Index of \a s in \a a on success, -1 on error (not found).
 */
int
dk3str_c8_array_index(char const * const *a, char const *s, int c);

/**	Find index of a string in an array of patterns.
 * 	@param	a	Patterns array.
 * 	@param	s	String to find.
 * 	@param	c	Flag: Case-sensitive (1) or not (0).
 * 	@return	Index of \a s in \a a on success, -1 on error (not found).
 */
int
dk3str_c16_array_index(dk3_c16_t const * const *a, dk3_c16_t const *s, int c);

/**	Find index of a string in an array of patterns.
 * 	@param	a	Patterns array.
 * 	@param	s	String to find.
 * 	@param	c	Flag: Case-sensitive (1) or not (0).
 * 	@return	Index of \a s in \a a on success, -1 on error (not found).
 */
int
dk3str_c32_array_index(dk3_c32_t const * const *a, dk3_c32_t const *s, int c);

/**	Find index of a string in an array of patterns.
 * 	@param	a	Patterns array.
 * 	@param	s	String to find.
 * 	@param	c	Flag: Case-sensitive (1) or not (0).
 * 	@return	Index of \a s in \a a on success, -1 on error (not found).
 */
int
dk3str_array_index(dkChar const * const *a, dkChar const *s, int c);

/**	Check whether a text matches a pattern, the text may be abbreviated.
 * 	@param	line	Text to check.
 * 	@param	pattern	Pattern for comparison.
 * 	@param	spec	Special character marking the abbreviation in the
 *	pattern.
 * 	@param	cs	Flag: Case sensitive (1) or not (0).
 * 	@return	1 for a match, 0 otherwise.
 */
int
dk3str_c8_is_abbr(char const *line,char const *pattern,char spec,int cs);

/**	Check whether a text matches a pattern, the text may be abbreviated.
 * 	@param	line	Text to check.
 * 	@param	pattern	Pattern for comparison.
 * 	@param	spec	Special character marking the abbreviation in the
 *	pattern.
 * 	@param	cs	Flag: Case sensitive (1) or not (0).
 * 	@return	1 for a match, 0 otherwise.
 */
int
dk3str_c16_is_abbr(
  dk3_c16_t const *line, dk3_c16_t const *pattern, dk3_c16_t spec, int cs
);

/**	Check whether a text matches a pattern, the text may be abbreviated.
 * 	@param	line	Text to check.
 * 	@param	pattern	Pattern for comparison.
 * 	@param	spec	Special character marking the abbreviation in the
 *	pattern.
 * 	@param	cs	Flag: Case sensitive (1) or not (0).
 * 	@return	1 for a match, 0 otherwise.
 */
int
dk3str_c32_is_abbr(
  dk3_c32_t const *line, dk3_c32_t const *pattern, dk3_c32_t spec, int cs
);

/**	Check whether a text matches a pattern, the text may be abbreviated.
 * 	@param	line	Text to check.
 * 	@param	pattern	Pattern for comparison.
 * 	@param	spec	Special character marking the abbreviation in the
 *	pattern.
 * 	@param	cs	Flag: Case sensitive (1) or not (0).
 * 	@return	1 for a match, 0 otherwise.
 */
int
dk3str_is_abbr(dkChar const *line, dkChar const *pattern, dkChar spec, int cs);

/**	Search for a string in an array of patterns with abbreviations allowed.
 * 	@param	ar	Pattern array.
 * 	@param	str	String to search for.
 * 	@param	sp	Special character to mark abbreviation position.
 * 	@param	cs	Flag: Case-sensitive (1) or not (0).
 * 	@return	Index of \a str in \a ar on success, -1 on error (not found).
 */
int
dk3str_c8_array_abbr(char const * const *ar, char const *str, char sp, int cs);

/**	Search for a string in an array of patterns with abbreviations allowed.
 * 	@param	arr	Pattern array.
 * 	@param	str	String to search for.
 * 	@param	sp	Special character to mark abbreviation position.
 * 	@param	cs	Flag: Case-sensitive (1) or not (0).
 * 	@return	Index of \a str in \a ar on success, -1 on error (not found).
 */
int
dk3str_c16_array_abbr(
  dk3_c16_t const * const *arr, dk3_c16_t const *str, dk3_c16_t sp, int cs
);

/**	Search for a string in an array of patterns with abbreviations allowed.
 * 	@param	arr	Pattern array.
 * 	@param	str	String to search for.
 * 	@param	sp	Special character to mark abbreviation position.
 * 	@param	cs	Flag: Case-sensitive (1) or not (0).
 * 	@return	Index of \a str in \a ar on success, -1 on error (not found).
 */
int
dk3str_c32_array_abbr(
  dk3_c32_t const * const *arr, dk3_c32_t const *str, dk3_c32_t sp, int cs
);

/**	Search for a string in an array of patterns with abbreviations allowed.
 * 	@param	ar	Pattern array.
 * 	@param	str	String to search for.
 * 	@param	sp	Special character to mark abbreviation position.
 * 	@param	cs	Flag: Case-sensitive (1) or not (0).
 * 	@return	Index of \a str in \a ar on success, -1 on error (not found).
 */
int
dk3str_array_abbr(dkChar const * const *ar,dkChar const *str,dkChar sp,int cs);

/**	Check whether the text represents a boolean value.
 * 	@param	str	Text to process.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_c8_is_bool(char const *str);

/**	Check whether the text represents a boolean value.
 * 	@param	str	Text to process.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_c16_is_bool(dk3_c16_t const *str);

/**	Check whether the text represents a boolean value.
 * 	@param	str	Text to process.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_c32_is_bool(dk3_c32_t const *str);

/**	Check whether the text represents a boolean value.
 * 	@param	str	Text to process.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_is_bool(dkChar const *str);

/**	Check whether the text represents the boolean value "true".
 * 	@param	str	Text to process.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_c8_is_on(char const *str);

/**	Check whether the text represents the boolean value "true".
 * 	@param	str	Text to process.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_c16_is_on(dk3_c16_t const *str);

/**	Check whether the text represents the boolean value "true".
 * 	@param	str	Text to process.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_c32_is_on(dk3_c32_t const *str);

/**	Check whether the text represents the boolean value "true".
 * 	@param	str	Text to process.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_is_on(dkChar const *str);

/**	Explode a string (split string into array of text words).
	@param	array	Destination pointers array.
	@param	sz	Size of \a array (number of elements).
	@param	str	String to process.
	@param	whsp	Whitespaces set (may be NULL).
	@return	Number of elements set in \a array, 0 on error.
*/
size_t
dk3str_c8_explode(char **array, size_t sz, char *str, char const *whsp);

/**	Explode a string (split string into array of text words).
	@param	array	Destination pointers array.
	@param	sz	Size of \a array (number of elements).
	@param	str	String to process.
	@param	whsp	Whitespaces set (may be NULL).
	@return	Number of elements set in \a array, 0 on error.
*/
size_t
dk3str_c16_explode(
  dk3_c16_t **array, size_t sz, dk3_c16_t *str, dk3_c16_t const *whsp
);

/**	Explode a string (split string into array of text words).
	@param	array	Destination pointers array.
	@param	sz	Size of \a array (number of elements).
	@param	str	String to process.
	@param	whsp	Whitespaces set (may be NULL).
	@return	Number of elements set in \a array, 0 on error.
*/
size_t
dk3str_c32_explode(
  dk3_c32_t **array, size_t sz, dk3_c32_t *str, dk3_c32_t const *whsp
);

/**	Explode a string (split string into array of text words).
	@param	array	Destination pointers array.
	@param	sz	Size of \a array (number of elements).
	@param	str	String to process.
	@param	whsp	Whitespaces set (may be NULL).
	@return	Number of elements set in \a array, 0 on error.
*/
size_t
dk3str_explode(dkChar **array, size_t sz, dkChar *str, dkChar const *whsp);

/**	Normalize text line.
	@param	l	Text line to modify.
	@param	w	Whitespaces set (may be NULL).
	@param	s	Separator character.
*/
void
dk3str_c8_normalize(char *l, char const *w, char s);

/**	Normalize text line.
	@param	l	Text line to modify.
	@param	w	Whitespaces set (may be NULL).
	@param	s	Separator character.
*/
void
dk3str_c16_normalize(dk3_c16_t *l, dk3_c16_t const *w, char s);

/**	Normalize text line.
	@param	l	Text line to modify.
	@param	w	Whitespaces set (may be NULL).
	@param	s	Separator character.
*/
void
dk3str_c32_normalize(dk3_c32_t *l, dk3_c32_t const *w, char s);

/**	Normalize text line.
	@param	l	Text line to modify.
	@param	w	Whitespaces set (may be NULL).
	@param	s	Separator character.
*/
void
dk3str_normalize(dkChar *l, dkChar const *w, dkChar s);

/**	Correct file name.
 * 	@param	n	File name to correct.
 */
void
dk3str_c8_correct_filename(char *n);

/**	Correct file name.
 * 	@param	n	File name to correct.
 */
void
dk3str_c16_correct_filename(dk3_c16_t *n);

/**	Correct file name.
 * 	@param	n	File name to correct.
 */
void
dk3str_c32_correct_filename(dk3_c32_t *n);

/**	Correct file name.
 * 	@param	n	File name to correct.
 */
void
dk3str_correct_filename(dkChar *n);

/**	Check whether a file/directory name is an absolute path.
 * 	@param	n	Name to check.
 * 	@return	1 for absolute path, 0 otherwise.
 */
int
dk3str_c8_is_abs_path(char const *n);

/**	Check whether a file/directory name is an absolute path.
 * 	@param	n	Name to check.
 * 	@return	1 for absolute path, 0 otherwise.
 */
int
dk3str_c16_is_abs_path(dk3_c16_t const *n);

/**	Check whether a file/directory name is an absolute path.
 * 	@param	n	Name to check.
 * 	@return	1 for absolute path, 0 otherwise.
 */
int
dk3str_c32_is_abs_path(dk3_c32_t const *n);

/**	Check whether a file/directory name is an absolute path.
 * 	@param	n	Name to check.
 * 	@return	1 for absolute path, 0 otherwise.
 */
int
dk3str_is_abs_path(dkChar const *n);

/**	Append path to a given directory.
 * 	@param	d	In: directory, out: modified path.
 * 	@param	sz	Destination buffer size (number of characters).
 * 	@param	n	Path name to append.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on errors.
 */
int
dk3str_c8_append_path_app(char *d, size_t sz, char const *n, dk3_app_t *app);

/**	Append path to a given directory.
 * 	@param	d	In: directory, out: modified path.
 * 	@param	sz	Destination buffer size (number of characters).
 * 	@param	n	Path name to append.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on errors.
 */
int
dk3str_c16_append_path_app(
  dk3_c16_t *d, size_t sz, dk3_c16_t const *n, dk3_app_t *app
);

/**	Append path to a given directory.
 * 	@param	d	In: directory, out: modified path.
 * 	@param	sz	Destination buffer size (number of characters).
 * 	@param	n	Path name to append.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on errors.
 */
int
dk3str_c32_append_path_app(
  dk3_c32_t *d, size_t sz, dk3_c32_t const *n, dk3_app_t *app
);

/**	Append path to a given directory.
 * 	@param	d	In: directory, out: modified path.
 * 	@param	sz	Destination buffer size (number of characters).
 * 	@param	n	Path name to append.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on errors.
 */
int
dk3str_append_path_app(dkChar *d, size_t sz, dkChar const *n, dk3_app_t *app);


/**	Get file name suffix.
	@param	s	File name.
	@return	Pointer to suffix on success, NULL on error (no
	suffix found).
*/
char *
dk3str_c8_get_suffix(char const *s);

/**	Get file name suffix.
	@param	s	File name.
	@return	Pointer to suffix on success, NULL on error (no
	suffix found).
*/
dk3_c16_t *
dk3str_c16_get_suffix(dk3_c16_t const *s);

/**	Get file name suffix.
	@param	s	File name.
	@return	Pointer to suffix on success, NULL on error (no
	suffix found).
*/
dk3_c32_t *
dk3str_c32_get_suffix(dk3_c32_t const *s);

/**	Get file name suffix.
	@param	s	File name.
	@return	Pointer to suffix on success, NULL on error (no
	suffix found).
*/
dkChar *
dk3str_get_suffix(dkChar const *s);

/**	Convert 16-bit string to 8-bit string (only ASCII characters).
 * 	@param	d	Destination buffer.
 * 	@param	sz	Size of \a d in bytes.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error (illegal characters or buffer too
 *	short).
 */
int
dk3str_c16_to_c8_simple_app(
  char *d, size_t sz, dk3_c16_t const *s, dk3_app_t *app
);

/**	Convert 32-bit string to 8-bit string (only ASCII characters).
 * 	@param	d	Destination buffer.
 * 	@param	sz	Size of \a d in bytes.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error (illegal characters or buffer too
 *	short).
 */
int
dk3str_c32_to_c8_simple_app(
  char *d, size_t sz, dk3_c32_t const *s, dk3_app_t *app
);

/**	Find buffer size needed to convert from 8-bit plain to 8-bit UTF-8.
 * 	@param	s	Source string (ASCII/ISO-LATIN-1 encoded).
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of bytes needed for UTF-8 encoded string,
 * 	the number includes the finalizing 0x00 byte.
 */
size_t
dk3str_cnvsz_c8p_to_c8u_app(char const *s, dk3_app_t *app);

/**	Find buffer size needed to convert from UTF-8 to ISO-LATIN-1.
 * 	@param	s	Source string (UTF-8 encoded).
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of bytes needed for ISO-LATIN-1 encoded string,
 * 	the number includes the finalizing 0x00 byte.
 */
size_t
dk3str_cnvsz_c8u_to_c8p_app(char const *s, dk3_app_t *app);

/**	Find buffer size needed to convert from ISO-LATIN-1 to UTF-16.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of 16-bit characters needed for result
 * 	including the finalizer.
 */
size_t
dk3str_cnvsz_c8p_to_c16_app(char const *s, dk3_app_t *app);

/**	Find buffer size needed to convert from UTF-8 to UTF-16.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of 16-bit characters needed for result
 * 	including the finalizer.
 */
size_t
dk3str_cnvsz_c8u_to_c16_app(char const *s, dk3_app_t *app);

/**	Find buffer size needed to convert from UTF-16 to ISO-LATIN-1.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of bytes needed for result, including finalizer.
 */
size_t
dk3str_cnvsz_c16_to_c8p_app(dk3_c16_t const *s, dk3_app_t *app);

/**	Find buffer size needed to convert from UTF-16 to UTF-8.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of bytes needed for result, including finalizer.
 */
size_t
dk3str_cnvsz_c16_to_c8u_app(dk3_c16_t const *s, dk3_app_t *app);

/**	Find buffer size needed to convert from ISO-LATIN-1 to 32-bit.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of 32-bit characters needed for result,
 * 	including finalizer.
 */
size_t
dk3str_cnvsz_c8p_to_c32_app(char const *s, dk3_app_t *app);

/**	Find buffer size needed to convert from UTF-8 to 32-bit.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of 32-bit characters needed for result,
 * 	including finalizer.
 */
size_t
dk3str_cnvsz_c8u_to_c32_app(char const *s, dk3_app_t *app);

/**	Find buffer size needed to convert from UTF-16 to 32-bit.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of 32-bit characters needed for result,
 * 	including finalizer.
 */
size_t
dk3str_cnvsz_c16_to_c32_app(dk3_c16_t const *s, dk3_app_t *app);

/**	Find buffer size needed to convert from 32-bit to ISO-LATIN-1.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of bytes needed for result, including finalizer.
 */
size_t
dk3str_cnvsz_c32_to_c8p_app(dk3_c32_t const *s, dk3_app_t *app);

/**	Find buffer size needed to convert from 32-bit to UTF-8.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of bytes needed for result, including finalizer.
 */
size_t
dk3str_cnvsz_c32_to_c8u_app(dk3_c32_t const *s, dk3_app_t *app);

/**	Find buffer size needed to convert from 32-bit to UTF-16.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Number of UTF-16 chars needed for result, including finalizer.
 */
size_t
dk3str_cnvsz_c32_to_c16_app(dk3_c32_t const *s, dk3_app_t *app);

/**	Convert ISO-LATIN-1 string to UTF-8.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c8p_to_c8u_app(char *d, size_t ds, char const *s, dk3_app_t *app);

/**	Convert UTF-8 string to ISO-LATIN-1.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c8u_to_c8p_app(char *d, size_t ds, char const *s, dk3_app_t *app);

/**	Convert ISO-LATIN-1 string to UTF-16.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c8p_to_c16_app(
  dk3_c16_t *d, size_t ds, char const *s, dk3_app_t *app
);

/**	Convert UTF-8 string to UTF-16.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c8u_to_c16_app(
  dk3_c16_t *d, size_t ds, char const *s, dk3_app_t *app
);

/**	Convert UTF-16 string to ISO-LATIN-1.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c16_to_c8p_app(
  char *d, size_t ds, dk3_c16_t const *s, dk3_app_t *app
);

/**	Convert UTF-16 string to UTF-8.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c16_to_c8u_app(
  char *d, size_t ds, dk3_c16_t const *s, dk3_app_t *app
);

/**	Convert ISO-LATIN-1 string to 32-bit.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c8p_to_c32_app(
  dk3_c32_t *d, size_t ds, char const *s, dk3_app_t *app
);

/**	Convert UTF-8 string to 32-bit.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c8u_to_c32_app(
  dk3_c32_t *d, size_t ds, char const *s, dk3_app_t *app
);

/**	Convert UTF-16 string to 32-bit.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c16_to_c32_app(
  dk3_c32_t *d, size_t ds, dk3_c16_t const *s, dk3_app_t *app
);

/**	Convert 32-bit string to ISO-LATIN-1.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c32_to_c8p_app(
  char *d, size_t ds, dk3_c32_t const *s, dk3_app_t *app
);

/**	Convert 32-bit string to UTF-8.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c32_to_c8u_app(
  char *d, size_t ds, dk3_c32_t const *s, dk3_app_t *app
);

/**	Convert 32-bit string to UTF-16.
 * 	@param	d	Destination buffer.
 * 	@param	ds	Size of \a d (number of elements).
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	1 on success, 0 on error.
 */
int
dk3str_cnv_c32_to_c16_app(
  dk3_c16_t *d, size_t ds, dk3_c32_t const *s, dk3_app_t *app
);

/**	Convert ISO-LATIN-1 string to UTF-8, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
char *
dk3str_cnvnew_c8p_to_c8u_app(char const *s, dk3_app_t *app);

/**	Convert UTF-8 string to ISO-LATIN-1, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
char *
dk3str_cnvnew_c8u_to_c8p_app(char const *s, dk3_app_t *app);

/**	Convert ISO-LATIN-1 string to UTF-16, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
dk3_c16_t *
dk3str_cnvnew_c8p_to_c16_app(char const *s, dk3_app_t *app);

/**	Convert UTF-8 string to UTF-16, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
dk3_c16_t *
dk3str_cnvnew_c8u_to_c16_app(char const *s, dk3_app_t *app);

/**	Convert UTF-16 string to ISO-LATIN-1, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure, used for diagnostics.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
char *
dk3str_cnvnew_c16_to_c8p_app(dk3_c16_t const *s, dk3_app_t *app);

/**	Convert UTF-16 string to UTF-8, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
char *
dk3str_cnvnew_c16_to_c8u_app(dk3_c16_t const *s, dk3_app_t *app);

/**	Convert ISO-LATIN-1 string to 32-bit, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
dk3_c32_t *
dk3str_cnvnew_c8p_to_c32_app(char const *s, dk3_app_t *app);

/**	Convert UTF-8 string to 32-bit, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
dk3_c32_t *
dk3str_cnvnew_c8u_to_c32_app(char const *s, dk3_app_t *app);

/**	Convert UTF-16 string to 32-bit, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
dk3_c32_t *
dk3str_cnvnew_c16_to_c32_app(dk3_c16_t const *s, dk3_app_t *app);

/**	Convert 32-bit string to ISO_LATIN-1, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
char *
dk3str_cnvnew_c32_to_c8p_app(dk3_c32_t const *s, dk3_app_t *app);

/**	Convert 32-bit string to UTF-8, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
char *
dk3str_cnvnew_c32_to_c8u_app(dk3_c32_t const *s, dk3_app_t *app);

/**	Convert 32-bit to UTF_16, allocate new memory for result.
 * 	@param	s	Source string.
 * 	@param	app	Application structure for diagnostics, may be NULL.
 * 	@return	Pointer to new result string on success, NULL on error.
 */
dk3_c16_t *
dk3str_cnvnew_c32_to_c16_app(dk3_c32_t const *s, dk3_app_t *app);

/**	Convert 8-bit character to 8/16-bit character
	without re-encoding. This function is mainly intended to convert
	pure ASCII characters like numeric values.
	@param	d	Destination buffer.
	@param	sz	Size of \a d in characters.
	@param	s	Source string.
   	@param	app	Application structure for diagnostics, may be NULL.
	@return	1 on success, 0 on error.
*/
int
dk3str_cnv_c8_to_str_app(dkChar *d, size_t sz, char const *s, dk3_app_t *app);

/**	Convert dkChar string to 8-bit (simple version, 
	used to read numeric values).
	@param	db	Destination buffer.
	@param	sz	Size of \a db.
	@param	s	Source string.
	@param	ap	Application structure for diagnostics, may be NULL.
	@return	1 on success, 0 on error
	(buffer too short or character out of range).
*/
int
dk3str_string_to_c8_simple_app(
  char *db,size_t sz,dkChar const *s,dk3_app_t *ap
);

/**	Convert string to all lower-case characters.
	@param	s	String to modify.
*/
void
dk3str_string_tolower(dkChar *s);

/**	Convert 8-bit text to dkChar string.
	@param	dp	Destination pointer.
	@param	ds	Size of \a dp (number of characters).
	@param	sp	Source pointer.
	@param	app	Application structure for diagnostics, may be NULL.
	@return	1 on success, 0 on error (output buffer too small).
*/
int
dk3str_c8_to_str_simple_app(
  dkChar *dp, size_t ds, char const *sp, dk3_app_t *app
);

/**	Convert dkChar string to plain 8-bit text.
	@param	dp	Destination buffer pointer.
	@param	sz	Size of \a dp (number of bytes).
	@param	src	Source text.
	@param	ie	Input encoding (used only for 8-bit characters).
	@param	app	Application structure for diagnostics, may be NULL.
	@return	1 on success, 0 on error.
*/
int
dk3str_to_c8p_app(
  char *dp, size_t sz, dkChar const *src, int ie, dk3_app_t *app
);

/**	Convert dkChar string to UTF-8 text.
	@param	dp	Destination buffer pointer.
	@param	sz	Size of \a dp (number of bytes).
	@param	src	Source text.
	@param	ie	Input encoding (used only for 8-bit characters).
	@param	app	Application structure for diagnostics, may be NULL.
	@return	1 on success, 0 on error.
*/
int
dk3str_to_c8u_app(
  char *dp, size_t sz, dkChar const *src, int ie, dk3_app_t *app
);

/**	Convert UTF-8 encoded string to dkChar string.
	@param	d	Destination buffer.
	@param	dsz	Size of @a d (number of elements).
	@param	de	Destination buffer encoding.
	@param	s	Source string.
	@param	app	Application structure for diagnostics, may be NULL.
	@return	1 on success, 0 on error.
*/
int
dk3str_c8u_to_str_app(
  dkChar 		*d,
  size_t		 dsz,
  int			 de,
  char const		*s,
  dk3_app_t		*app
);

/**	Convert dkChar string to UTF-8 encoded string.
	@param	d	Destination buffer.
	@param	dsz	Size of @a d (number of bytes).
	@param	s	Source string.
	@param	se	Source encoding (used for 8-bit characters only).
	@param	app	Application structure for diagnostics, may be NULL.
	@return	1 on success, 0 on error.
*/
int
dk3str_str_to_c8u_app(
  char		*d,
  size_t	 dsz,
  dkChar const	*s,
  int		 se,
  dk3_app_t	*app
);

/**	Convert dkChar string to 8-bit character string.
	@param	dp	Destination buffer pointer.
	@param	szdp	Size of dp.
	@param	src	Source string.
	@param	app	Application structure for diagnostics, may be NULL.
	@return	1 on success, 0 on error.
*/
int
dk3str_to_c8_app(char *dp, size_t szdp, dkChar const *src, dk3_app_t *app);

#ifdef __cplusplus
}
#endif



%%	module

#include "dk3all.h"


$!trace-include


$*
	Static data
$*


/**	The set of whitespace characters.
*/
static char const dk3str_c8_def_whsp[] = { " \t\r\n" };

/**	The current directory.
*/
static char const dk3str_c8_dot[] = { "." };

/**	The parent directory.
*/
static char const dk3str_c8_dot_dot[] = { ".." };

/**	File name separator.
*/
static char const dk3str_c8_fnsep[] = {
#if DK3_ON_WINDOWS || DK3_HAVE_BACKSLASH
"\\"
#else
"/"
#endif
};


/**	Keywords to set boolean values.
*/
static char const * const dk3str_c8_bool_kw[] = {
  "0",
  "n$o",
  "of$f",
  "f$alse",
  "-",
  "+",
  "1",
  "y$es",
  "on",
  "ok",
  "t$rue",
  NULL
};

/**	Index of first "true" entry in \a dk3str_c8_bool_kw.
*/
#define	INDEX_OF_FIRST_BOOLEAN_TRUE 5


#if DK3_ON_WINDOWS || DK3_HAVE_BACKSLASH
/**	File name separator character.
*/
#define	FNS_C8		'\\'
/**	Not the file name separator character.
*/
#define	NO_FNS_C8	'/'
#else
/**	File name separator character.
*/
#define	FNS_C8		'/'
/**	Not the file name separator character.
*/
#define	NO_FNS_C8	'\\'
#endif



/**	Default white spaces set.
*/
static dk3_c16_t const c16_def_whsp[] = {
  0x0020U, 0x0009U, 0x000AU, 0x000DU, 0U
};

/**	The dot for the current directory.
*/
static dk3_c16_t const c16_dot[] = {
  0x002EU, 0U
};

/**	The dot dot for the parent directory.
*/
static dk3_c16_t const c16_dot_dot[] = {
  0x002EU, 0x002EU, 0U
};

/**	File name separator (slash or backslash).
*/
static dk3_c16_t const c16_fnsep[] = {
#if DK3_ON_WINDOWS || DK3_HAVE_BACKSLASH
0x005CU,
#else
0x002FU,
#endif
0U
};

#if DK3_ON_WINDOWS || DK3_HAVE_BACKSLASH
/**	File name separator for 16-bit character strings.
*/
#define	FNS_C16		0x005CU
/**	Not the file name separator for 16-bit character strings.
*/
#define NO_FNS_C16	0x002FU
#else
/**	File name separator for 16-bit character strings.
*/
#define FNS_C16		0x002FU
/**	Not the file name separator for 16-bit character strings.
*/
#define NO_FNS_C16	0x005CU
#endif



/**	Default whitespaces set.
*/
static dk3_c32_t const c32_def_whsp[] = {
  0x00000020UL, 0x00000009UL, 0x0000000AUL, 0x0000000DUL, 0UL
};

/**	The dot is the current directory.
*/
static dk3_c32_t const c32_dot[] = {
  0x0000002EUL, 0UL
};

/**	The dot dot is the parent directory.
*/
static dk3_c32_t const c32_dot_dot[] = {
  0x0000002EUL, 0x0000002EUL, 0UL
};

/**	File name separator (slash or backslash).
*/
static dk3_c32_t const c32_fnsep[] = {
#if DK3_ON_WINDOWS || DK3_HAVE_BACKSLASH
0x0000005CUL,
#else
0x0000002FUL,
#endif
0U
};

#if DK3_ON_WINDOWS || DK3_HAVE_BACKSLASH
/**	File name separator for 32-bit character strings.
*/
#define	FNS_C32		0x0000005CUL
/**	Not a file name separator for 32-bit character strings.
*/
#define NO_FNS_C32	0x0000002FUL
#else
/**	File name separator for 32-bit character strings.
*/
#define FNS_C32		0x0000002FUL
/**	Not a file name separator for 32-bit character strings.
*/
#define NO_FNS_C32	0x0000005CUL
#endif



size_t
dk3str_c8_len(char const *s)
{
  register size_t back;		/* Function result. */
#if DK3_HAVE_STRLEN
  back = strlen(s);
#else
  register char const *ptr;	/* Pointer to traverse s. */
  back = 0; ptr = s;
  while(*(ptr++)) back++;
#endif
  return back;
}



size_t
dk3str_c16_len(dk3_c16_t const *s)
{
  register size_t back;
#if (DK3_HAVE_WCSLEN) && (DK3_SIZEOF_WCHAR_T == 2)
  back = wcslen(s);
#else
#if (DK3_HAVE__WCSLEN) && (DK3_SIZEOF_WCHAR_T == 2)
  back = _wcslen(s);
#else
  register dk3_c16_t const *ptr;	/* Traverse string. */
  back = 0; ptr = s;
  while(*(ptr++)) back++;
#endif
#endif
  return back;
}



size_t
dk3str_c32_len(dk3_c32_t const *s)
{
  register size_t back;
#if (DK3_HAVE_WCSLEN) && (DK3_SIZEOF_WCHAR_T == 4)
  back = wcslen(s);
#else
#if (DK3_HAVE__WCSLEN) && (DK3_SIZEOF_WCHAR_T == 4)
  back = _wcslen(s);
#else
  register dk3_c32_t const *ptr;	/* Traverse source string. */
  back = 0; ptr = s;
  while(*(ptr++)) back++;
#endif
#endif
  return back;
}



size_t
dk3str_len(dkChar const *s)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_len(s));
#else
  return(dk3str_c16_len(s));
#endif
#else
  return(dk3str_c8_len(s));
#endif
}



int
dk3str_c8_cmp(char const *s1, char const *s2)
{
  register int back;		/* Function result. */
#if DK3_HAVE_STRCMP
  back = strcmp(s1, s2);
#else
  register char const *p1;	/* Pointer to traverse s1. */
  register char const *p2;	/* Pointer to traverse s2. */
  register int  cc;		/* Flag: Can continue. */
  back = 0; p1 = s1; p2 = s2; cc = 1;
  while((cc) && (back == 0)) {
    if(*p1 > *p2) {
      back = 1;
    } else {
      if(*p1 < *p2) {
        back = -1;
      } else {
        if((*p1) && (*p2)) {
	  p1++; p2++;
	} else {
	  cc = 0;
	}
      }
    }
  }
#endif
  return back;
}



int
dk3str_c16_cmp(dk3_c16_t const *s1, dk3_c16_t const *s2)
{
  register int back;
#if (DK3_HAVE_WCSCPY) && (DK3_SIZEOF_WCHAR_T == 2)
  back = wcscmp(s1, s2);
#else
#if (DK3_HAVE__WCSCPY) && (DK3_SIZEOF_WCHAR_T == 2)
  back = _wcscmp(s1, s2);
#else
  register dk3_c16_t const *p1;	/* Traverse left string. */
  register dk3_c16_t const *p2;	/* Traverse right string. */
  register int cc;		/* Flag: Can continue. */

  back = 0; p1 = s1; p2 = s2; cc = 1;
  while((cc) && (back == 0)) {
    if(*p1 > *p2) {
      back = 1;
    } else {
      if(*p1 < *p2) {
        back = -1;
      } else {
        if((*p1) && (*p2)) {
	  p1++; p2++;
	} else {
	  cc = 0;
	}
      }
    }
  }
#endif
#endif
  return back;
}



int
dk3str_c32_cmp(dk3_c32_t const *s1, dk3_c32_t const *s2)
{
  register int back;
#if (DK3_HAVE_WCSCMP) && (DK3_SIZEOF_WCHAR_T == 4)
  back = wcscmp(s1, s2);
#else
#if (DK3_HAVE__WCSCMP) && (DK3_SIZEOF_WCHAR_T == 4)
  back = _wcscmp(s1, s2);
#else
  register dk3_c32_t const *p1;	/* Traverse left string. */
  register dk3_c32_t const *p2;	/* Traverse right string. */
  register int cc;		/* Flag: Can continue. */

  back = 0; p1 = s1; p2 = s2; cc = 1;
  while((cc) && (back == 0)) {
    if(*p1 > *p2) {
      back = 1;
    } else {
      if(*p1 < *p2) {
        back = -1;
      } else {
        if((*p1) && (*p2)) {
	  p1++; p2++;
	} else {
	  cc = 0;
	}
      }
    }
  }
#endif
#endif
  return back;
}



int
dk3str_cmp(dkChar const *s1, dkChar const *s2)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_cmp(s1, s2));
#else
  return(dk3str_c16_cmp(s1, s2));
#endif
#else
  return(dk3str_c8_cmp(s1, s2));
#endif
}



int
dk3str_c8_casecmp(char const *s1, char const *s2)
{
  register int back;		/* Function result. */
#if DK3_HAVE_STRCASECMP
  back = strcasecmp(s1, s2);
#else
#if DK3_HAVE_STRICMP && (!DK3_ON_WINDOWS)
  back = stricmp(s1, s2);
#else
#if DK3_HAVE__STRICMP || DK3_ON_WINDOWS
  back = _stricmp(s1, s2);
#else
  register char const *p1;	/* Pointer to traverse s1. */
  register char const *p2;	/* Pointer to traverse s2. */
  register char c1;		/* Current character from s1. */
  register char c2;		/* Current character from s2. */
  register int cc;		/* Flag: Can continue. */
  back = 0; p1 = s1; p2 = s2; cc = 1;
  while((cc) && (back == 0)) {
    c1 = *p1; c2 = *p2;
    if((c1 >= 'A') && (c1 <= 'Z')) { c1 = 'a' + (c1 - 'A'); }
    if((c2 >= 'A') && (c2 <= 'Z')) { c2 = 'a' + (c2 - 'A'); }
    if(c1 > c2) {
      back = 1;
    } else {
      if(c1 < c2) {
        back = -1;
      } else {
        if((c1) && (c2)) {
	  p1++; p2++;
	} else {
	  cc = 0;
	}
      }
    }
  }
#endif
#endif
#endif
  return back;
}



int
dk3str_c16_casecmp(dk3_c16_t const *s1, dk3_c16_t const *s2)
{
  register int back;
#if (DK3_HAVE_WCSICMP) && (DK3_SIZEOF_WCHAR_T == 2)
  back = wcsicmp(s1, s2);
#else
#if (DK3_HAVE__WCSICMP) && (DK3_SIZEOF_WCHAR_T == 2)
  back = _wcsicmp(s1, s2);
#else
  register dk3_c16_t const *p1;	/* Traverse left string. */
  register dk3_c16_t const *p2;	/* Traverse right string. */
  register dk3_c16_t c1;	/* Left character. */
  register dk3_c16_t c2;	/* Right character. */
  register int cc;		/* Flag: Can continue. */
  $? "+ dk3str_c16_casecmp_fb \"%ls\" <> \"%ls\"", s1, s2
  back = 0; p1 = s1; p2 = s2; cc = 1;
  while((cc) && (back == 0)) {
    c1 = *p1; c2 = *p2;
    if((c1 >= 0x0041U) && (c1 <= 0x005AU)) { c1 = 0x0061U + (c1 - 0x0041U); }
    if((c2 >= 0x0041U) && (c2 <= 0x005AU)) { c2 = 0x0061U + (c2 - 0x0041U); }
    if(c1 > c2) {
      back = 1;
    } else {
      if(c1 < c2) {
        back = -1;
      } else {
        if((c1) && (c2)) {
	  p1++; p2++;
	} else {
	  cc = 0;
	}
      }
    }
  } $? "- dk3str_c16_casecmp_fb %d", back
#endif
#endif
  return back;
}



int
dk3str_c32_casecmp(dk3_c32_t const *s1, dk3_c32_t const *s2)
{
  register int back;
#if (DK3_HAVE_WCSICMP) && (DK3_SIZEOF_WCHAR_T == 4)
  back = wcsicmp(s1, s2);
#else
#if (DK3_HAVE__WCSICMP) && (DK3_SIZEOF_WCHAR_T == 4)
  back = _wcsicmp(s1, s2);
#else
  register dk3_c32_t const *p1;	/* Traverse left string. */
  register dk3_c32_t const *p2;	/* Traverse right string. */
  register dk3_c32_t c1;	/* Left character. */
  register dk3_c32_t c2;	/* Right character. */
  register int cc;		/* Flag: Can continue. */

  back = 0; p1 = s1; p2 = s2; cc = 1;
  while((cc) && (back == 0)) {
    c1 = *p1; c2 = *p2;
    if((c1 >= (dk3_c32_t)0x00000041UL) && (c1 <= (dk3_c32_t)0x0000005AUL)) {
      c1 = 0x00000061UL + (c1 - 0x00000041UL);
    }
    if((c2 >= (dk3_c32_t)0x00000041UL) && (c2 <= (dk3_c32_t)0x0000005AUL)) {
      c2 = 0x00000061UL + (c2 - 0x00000041UL);
    }
    if(c1 > c2) {
      back = 1;
    } else {
      if(c1 < c2) {
        back = -1;
      } else {
        if((c1) && (c2)) {
	  p1++; p2++;
	} else {
	  cc = 0;
	}
      }
    }
  }
#endif
#endif
  return back;
}



int
dk3str_casecmp(dkChar const *s1, dkChar const *s2)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_casecmp(s1, s2));
#else
  return(dk3str_c16_casecmp(s1, s2));
#endif
#else
  return(dk3str_c8_casecmp(s1, s2));
#endif
}



int
dk3str_fncmp(dkChar const *s1, dkChar const *s2)
{
#if DK3_ON_WINDOWS || DK3_HAVE_FNCASEINS
  return(dk3str_casecmp(s1, s2));
#else
  return(dk3str_cmp(s1, s2));
#endif
}


int
dk3str_c8_ncmp(char const *s1, char const *s2, size_t n)
{
  register int back;		/* Function result. */
#if DK3_HAVE_STRNCMP
  back = strncmp(s1, s2, n);
#else
  register char const *p1;	/* Pointer to traverse s1. */
  register char const *p2;	/* Pointer to traverse s2. */
  register size_t max;		/* Register copy of n. */
  register size_t used;		/* Number of chars already used. */
  back = 0; p1 = s1; p2 = s2; max = n; used = 0;
  while((used < max) && (back == 0)) {
    if(*p1 > *p2) {
      back = 1;
    } else {
      if(*p1 < *p2) {
        back = -1;
      } else {
        if((*p1) && (*p2)) {
	  p1++; p2++; used++;
	} else {
	  used = max;
	}
      }
    }
  }
#endif
  return back;
}



int
dk3str_c16_ncmp(dk3_c16_t const *s1, dk3_c16_t const *s2, size_t n)
{
  register int back;
#if (DK3_HAVE_WCSNCMP) && (DK3_SIZEOF_WCHAR_T == 2)
  back = wcsncmp(s1, s2, n);
#else
#if (DK3_HAVE__WCSNCMP) && (DK3_SIZEOF_WCHAR_T == 2)
  back = _wcsncmp(s1, s2, n);
#else
  register dk3_c16_t const *p1;	/* Traverse left string. */
  register dk3_c16_t const *p2;	/* Traverse right string. */
  register size_t max;		/* Maximum number of characters to compare. */
  register size_t used;		/* Number of characters already compared. */

  back = 0; p1 = s1; p2 = s2; max = n; used = 0;
  while((used < max) && (back == 0)) {
    if(*p1 > *p2) {
      back = 1;
    } else {
      if(*p1 < *p2) {
        back = -1;
      } else {
        if((*p1) && (*p2)) {
	  p1++; p2++; used++;
	} else {
	  used = max;
	}
      }
    }
  }
#endif
#endif
  return back;
}



int
dk3str_c32_ncmp(dk3_c32_t const *s1, dk3_c32_t const *s2, size_t n)
{
  register int back;
#if (DK3_HAVE_WCSNCMP) && (DK3_SIZEOF_WCHAR_T == 4)
  back = wcsncmp(s1, s2, n);
#else
#if (DK3_HAVE__WCSNCMP) && (DK3_SIZEOF_WCHAR_T == 4)
  back = _wcsncmp(s1, s2, n);
#else
  register dk3_c32_t const *p1;	/* Traverse left string. */
  register dk3_c32_t const *p2;	/* Traverse right string. */
  register size_t max;		/* Maximum number of characters to compare. */
  register size_t used;		/* Number of characters used. */

  back = 0; p1 = s1; p2 = s2; max = n; used = 0;
  while((used < max) && (back == 0)) {
    if(*p1 > *p2) {
      back = 1;
    } else {
      if(*p1 < *p2) {
        back = -1;
      } else {
        if((*p1) && (*p2)) {
	  p1++; p2++; used++;
	} else {
	  used = max;
	}
      }
    }
  }
#endif
#endif
  return back;
}



int
dk3str_ncmp(dkChar const *s1, dkChar const *s2, size_t n)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_ncmp(s1, s2, n));
#else
  return(dk3str_c16_ncmp(s1, s2, n));
#endif
#else
  return(dk3str_c8_ncmp(s1, s2, n));
#endif
}



char *
dk3str_c8_chr(char const *s, char c)
{
  register char *back;		/* Function result. */
#if DK3_HAVE_STRCHR
  back = strchr(s, c);
#else
  register char const *ptr;	/* Pointer to traverse s. */
  register char chr;		/* Register copy of c. */
  back = NULL; ptr = s; chr = c;
  while((*ptr) && (back == NULL)) {
    if(*ptr == chr) { back = (char *)ptr; } else { ptr++; }
  }
#endif
  return back;
}



dk3_c16_t *
dk3str_c16_chr(dk3_c16_t const *s, dk3_c16_t c)
{
  register dk3_c16_t *back;
#if (DK3_HAVE_WCSCHR) && (DK3_SIZEOF_WCHAR_T == 2)
  back = wcschr(s, c);
#else
#if (DK3_HAVE__WCSCHR) && (DK3_SIZEOF_WCHAR_T == 2)
  back = _wcschr(s, c);
#else
  register dk3_c16_t const *ptr;	/* Traverse source string. */
  register dk3_c16_t chr;		/* Character to search for. */
  back = NULL; ptr = s; chr = c;
  while((*ptr) && (back == NULL)) {
    if(*ptr == chr) { back = (dk3_c16_t *)ptr; } else { ptr++; }
  }
#endif
#endif
  return back;
}



dk3_c32_t *
dk3str_c32_chr(dk3_c32_t const *s, dk3_c32_t c)
{
  register dk3_c32_t *back;
#if (DK3_HAVE_WCSCHR) && (DK3_SIZEOF_WCHAR_T == 4)
  back = wcschr(s, c);
#else
#if (DK3_HAVE__WCSCHR) && (DK3_SIZEOF_WCHAR_T == 4)
  back = _wcschr(s, c);
#else
  register dk3_c32_t const *ptr;	/* Traverse source string. */
  register dk3_c32_t chr;		/* Character to find. */

  back = NULL; ptr = s; chr = c;
  while((*ptr) && (back == NULL)) {
    if(*ptr == chr) { back = (dk3_c32_t *)ptr; } else { ptr++; }
  }
#endif
#endif
  return back;
}



dkChar *
dk3str_chr(dkChar const *s, dkChar c)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_chr(s, c));
#else
  return(dk3str_c16_chr(s, c));
#endif
#else
  return(dk3str_c8_chr(s, c));
#endif
}


char *
dk3str_c8_rchr(char const *s, char c)
{
  register char *back;		/* Function result. */
#if DK3_HAVE_STRRCHR
  back = strrchr(s, c);
#else
  register char const *ptr;	/* Pointer to traverse s. */
  register char chr;		/* Register copy of c. */
  back = NULL; ptr = s; chr = c;
  while(*ptr) {
    if(*ptr == chr) { back = (char *)ptr; }
    ptr++;
  }
#endif
  return back;
}




dk3_c16_t *
dk3str_c16_rchr(dk3_c16_t const *s, dk3_c16_t c)
{
  register dk3_c16_t *back;
#if (DK3_HAVE_WCSRCHR) && (DK3_SIZEOF_WCHAR_T == 2)
  back = wcsrchr(s, c);
#else
#if (DK3_HAVE__WCSRCHR) && (DK3_SIZEOF_WCHAR_T == 2)
  back = _wcsrchr(s, c);
#else
  register dk3_c16_t const *ptr;	/* Traverse the string. */
  register dk3_c16_t chr;		/* Character to search for. */
  back = NULL; ptr = s; chr = c;
  while(*ptr) {
    if(*ptr == chr) { back = (dk3_c16_t *)ptr; }
    ptr++;
  }
#endif
#endif
  return back;
}



dk3_c32_t *
dk3str_c32_rchr(dk3_c32_t const *s, dk3_c32_t c)
{
  register dk3_c32_t *back;
#if (DK3_HAVE_WCSRCHR) && (DK3_SIZEOF_WCHAR_T == 4)
  back = wcsrchr(s, c);
#else
#if (DK3_HAVE__WCSRCHR) && (DK3_SIZEOF_WCHAR_T == 4)
  back = _wcsrchr(s, c);
#else
  register dk3_c32_t const *ptr;	/* Traverse source string. */
  register dk3_c32_t chr;		/* Character to search for. */

  back = NULL; ptr = s; chr = c;
  while(*ptr) {
    if(*ptr == chr) { back = (dk3_c32_t *)ptr; }
    ptr++;
  }
#endif
#endif
  return back;
}



dkChar *
dk3str_rchr(dkChar const *s, dkChar c)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_rchr(s, c));
#else
  return(dk3str_c16_rchr(s, c));
#endif
#else
  return(dk3str_c8_rchr(s, c));
#endif
}


void
dk3str_c8_cpy(char *d, char const *s)
{
  register char *dp;		/* Destination buffer pointer. */
  register char const *sp;	/* Source buffer pointer. */
  register char x;
  dp = d; sp = s;
  while(*sp) { x = *(sp++); *(dp++) = x; }
  *dp = '\0';
}



void
dk3str_c16_cpy(dk3_c16_t *d, dk3_c16_t const *s)
{
  register dk3_c16_t *dp;	/* Destination pointer. */
  register dk3_c16_t const *sp;	/* Source pointer. */
  register dk3_c16_t x;		/* Current character. */

  dp = d; sp = s;
  while(*sp) { x = *(sp++); *(dp++) = x; }
  *dp = 0U;
}



void
dk3str_c32_cpy(dk3_c32_t *d, dk3_c32_t const *s)
{
  register dk3_c32_t *dp;	/* Destination pointer. */
  register dk3_c32_t const *sp;	/* Source pointer. */
  register dk3_c32_t x;		/* Current character. */
  dp = d; sp = s;
  while(*sp) { x = *(sp++); *(dp++) = x; }
  *dp = 0UL;
}



void
dk3str_cpy(dkChar *d, dkChar const *s)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  dk3str_c32_cpy(d, s);
#else
  dk3str_c16_cpy(d, s);
#endif
#else
  dk3str_c8_cpy(d, s);
#endif
}


void
dk3str_c8_cpy_not_overlapped(char *d, char const *s)
{
#if DK3_HAVE_STRCPY
  strcpy(d, s);
#else
#if DK3_HAVE_STRLEN
  size_t	sz;
  int		ec	=	0;
  sz = dk3mem_add_size_t(1, strlen(s), &ec);
  if((0 != sz) && (0 == ec)) {
    dk3mem_cpy(d,s,sz);
  } else {
    dk3str_c8_cpy(d, s);
  }
#else
  dk3str_c8_cpy(d, s);
#endif
#endif
}



void
dk3str_c16_cpy_not_overlapped(dk3_c16_t *d, dk3_c16_t const *s)
{
#if (DK3_HAVE_WCSCPY) && (DK3_SIZEOF_WCHAR_T == 2)
  wcscpy(d, s);
#else
#if (DK3_HAVE__WCSCPY) && (DK3_SIZEOF_WCHAR_T == 2)
  _wcscpy(d, s);
#else
#if (DK3_HAVE_WCSLEN) && (DK3_SIZEOF_WCHAR_T == 2)
  size_t	sz;
  int		ec	= 0;
  sz = dk3mem_mul_size_t(2, dk3mem_add_size_t(1, wcslen(s), &ec), &ec);
  if((0 != sz) && (0 == ec)) {
    dk3mem_cpy(d, s, sz);
  } else {
    dk3str_c16_cpy(d,s);
  }
#else
#if (DK3_HAVE__WCSLEN) && (DK3_SIZEOF_WCHAR_T == 2)
  size_t	sz;
  int		ec	= 0;
  sz = dk3mem_mul_size_t(2, dk3mem_add_size_t(1, _wcslen(s), &ec), &ec);
  if((0 != sz) && (0 == ec)) {
    dk3mem_cpy(d, s, sz);
  } else {
    dk3str_c16_cpy(d,s);
  }
#else
  dk3str_c16_cpy(d,s);
#endif
#endif
#endif
#endif
}



void
dk3str_c32_cpy_not_overlapped(dk3_c32_t *d, dk3_c32_t const *s)
{
#if (DK3_HAVE_WCSCPY) && (DK3_SIZEOF_WCHAR_T == 4)
  wcscpy(d, s);
#else
#if (DK3_HAVE__WCSCPY) && (DK3_SIZEOF_WCHAR_T == 4)
  _wcscpy(d, s);
#else
#if (DK3_HAVE_WCSLEN) && (DK3_SIZEOF_WCHAR_T == 4)
  size_t	sz;
  int		ec	= 0;
  sz = dk3mem_mul_size_t(4, dk3mem_add_size_t(1, wcslen(s), &ec), &ec);
  if((0 != sz) && (0 == ec)) {
    dk3mem_cpy(d, s, sz);
  } else {
    dk3str_c32_cpy(d,s);
  }
#else
#if (DK3_HAVE__WCSLEN) && (DK3_SIZEOF_WCHAR_T == 4)
  size_t	sz;
  int		ec	= 0;
  sz = dk3mem_mul_size_t(4, dk3mem_add_size_t(1, _wcslen(s), &ec), &ec);
  if((0 != sz) && (0 == ec)) {
    dk3mem_cpy(d, s, sz);
  } else {
    dk3str_c32_cpy(d,s);
  }
#else
  dk3str_c32_cpy(d,s);
#endif
#endif
#endif
#endif
}



void
dk3str_cpy_not_overlapped(dkChar *d, dkChar const *s)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  dk3str_c32_cpy_not_overlapped(d, s);
#else
  dk3str_c16_cpy_not_overlapped(d, s);
#endif
#else
  dk3str_c8_cpy_not_overlapped(d, s);
#endif
}


void
dk3str_c8_ncpy(char *d, char const *s, size_t n)
{
#if DK3_HAVE_STRNCPY
  strncpy(d,s,n);
  d[n-1] = '\0';
#else
  register char *dp;		/* Destination buffer pointer. */
  register char const *sp;	/* Source buffer pointer. */
  register size_t max;		/* Register copy of n. */
  register size_t used;		/* Number of characters already copied. */
  register char	  x;
  dp = d; sp = s; max = n; used = 0;
  while((*sp) && (used < max)) { x = *(sp++); *(dp++) = x;  used++; }
  if(used < max) { *dp = '\0'; }
  else		 { d[max - 1] = '\0'; }
#endif
}



void
dk3str_c16_ncpy(dk3_c16_t *d, dk3_c16_t const *s, size_t n)
{
#if (DK3_HAVE_WCSNCPY) && (DK3_SIZEOF_WCHAR_T == 2)
  wcsncpy(d,s,n);
  d[n-1] = 0U;
#else
#if (DK3_HAVE__WCSNCPY) && (DK3_SIZEOF_WCHAR_T == 2)
  _wcsncpy(d,s,n);
  d[n-1] = 0U;
#else
  register dk3_c16_t *dp;	/* Destionation pointer. */
  register dk3_c16_t const *sp;	/* Source pointer. */
  register dk3_c16_t x;		/* Current character. */
  register size_t max;		/* Maximum number of characters to copy. */
  register size_t used;		/* Characters already copied. */

  dp = d; sp = s; max = n; used = 0;
  while((*sp) && (used < max)) { x = *(sp++); *(dp++) = x; used++; }
  if(used < max) { *dp = 0U; }
  else { d[max - 1] = 0U; }
#endif
#endif
}



void
dk3str_c32_ncpy(dk3_c32_t *d, dk3_c32_t const *s, size_t n)
{
#if (DK3_HAVE_WCSNCPY) && (DK3_SIZEOF_WCHAR_T == 4)
  wcsncpy(d,s,n);
  d[n-1] = 0UL;
#else
#if (DK3_HAVE__WCSNCPY) && (DK3_SIZEOF_WCHAR_T == 4)
  _wcsncpy(d,s,n);
  d[n-1] = 0UL;
#else
  register dk3_c32_t *dp;	/* Destination pointer. */
  register dk3_c32_t const *sp;	/* Source pointer. */
  register dk3_c32_t x;		/* Current character. */
  register size_t max;		/* Maximum number of characters to copy. */
  register size_t used;		/* Number of characters copied. */

  dp = d; sp = s; max = n; used = 0;
  while((*sp) && (used < max)) { x = *(sp++); *(dp++) = x; used++; }
  if(used < max) { *dp = 0UL; }
  else { d[max - 1] = 0UL; }
#endif
#endif
}



void
dk3str_ncpy(dkChar *d, dkChar const *s, size_t n)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  dk3str_c32_ncpy(d, s, n);
#else
  dk3str_c16_ncpy(d, s, n);
#endif
#else
  dk3str_c8_ncpy(d, s, n);
#endif
}



void
dk3str_c8_cat(char *d, char const *s)
{
#if DK3_HAVE_STRCAT
  strcat(d, s);
#else
  register char *dp;		/* Destination buffer pointer. */
  register char const *sp;	/* Source buffer pointer. */
  register char x;
  dp = d; sp = s;
  while(*dp) dp++;
  while(*sp) { x = *(sp++); *(dp++) = x; }
  *dp = '\0';
#endif
}



void
dk3str_c16_cat(dk3_c16_t *d, dk3_c16_t const *s)
{
#if (DK3_HAVE_WCSCAT) && (DK3_SIZEOF_WCHAR_T == 2)
  wcscat(d, s);
#else
#if (DK3_HAVE__WCSCAT) && (DK3_SIZEOF_WCHAR_T == 2)
  _wcscat(d, s);
#else
  register dk3_c16_t *dp;	/* Destination pointer. */
  register dk3_c16_t const *sp;	/* Source pointer. */
  register dk3_c16_t x;		/* Current character. */
  dp = d; sp = s;
  while(*dp) dp++;
  while(*sp) { x = *(sp++); *(dp++) = x;  }
  *dp = 0U;
#endif
#endif
}



void
dk3str_c32_cat(dk3_c32_t *d, dk3_c32_t const *s)
{
#if (DK3_HAVE_WCSCAT) && (DK3_SIZEOF_WCHAR_T == 4)
  wcscat(d, s);
#else
#if (DK3_HAVE__WCSCAT) && (DK3_SIZEOF_WCHAR_T == 4)
  _wcscat(d, s);
#else
  register dk3_c32_t *dp;	/* Destination pointer. */
  register dk3_c32_t const *sp;	/* Source pointer. */
  register dk3_c32_t x;		/* Current character. */

  dp = d; sp = s;
  while(*dp) dp++;
  while(*sp) { x = *(sp++); *(dp++) = x; }
  *dp = 0UL;
#endif
#endif
}



void
dk3str_cat(dkChar *d, dkChar const *s)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  dk3str_c32_cat(d, s);
#else
  dk3str_c16_cat(d, s);
#endif
#else
  dk3str_c8_cat(d, s);
#endif
}



/**	Report memory allocation error.
	@param	app	Application structure.
	@param	elsize	Size of one character.
	@param	nelem	Number of characters required.
*/
static
void
dk3str_memory_error(dk3_app_t *app, size_t elsize, size_t nelem)
{
#if VERSION_BEFORE_20140716
  dkChar	bu1[64];
  unsigned long	prod;
  prod = (unsigned long)elsize * (unsigned long)nelem;
  dk3sf_sprintf3(bu1, dkT("%lu"), prod);
  dk3app_log_i3(app, DK3_LL_ERROR, 12, 13, bu1);
#else
  dkChar	bu1[64];
  dk3_um_t	prod;
  int		mec = 0;
  prod = dk3ma_um_mul_ok((dk3_um_t)elsize, (dk3_um_t)nelem, &mec);
  if (0 == mec) {
    if (dk3ma_um_to_string(bu1, DK3_SIZEOF(bu1,dkChar), (dk3_um_t)prod)) {
      dk3app_log_i3(app, DK3_LL_ERROR, 12, 13, bu1);
    }
  } else {
    /* Math overflow in size calculation */
    dk3app_log_i1(app, DK3_LL_ERROR, 15);
  }
#endif
}



char *
dk3str_c8_dup_app(char const *s, dk3_app_t *app)
{
  char	*back;
#if DK3_HAVE_STRDUP && (!DK3_ON_WINDOWS)
  back = strdup(s);
  if(!(back)) {
    if(app) {
      dk3str_memory_error(app, 1, (1+strlen(s)));
    }
  }
#else
#if DK3_HAVE__STRDUP || DK3_ON_WINDOWS
  back = _strdup(s);
  if(!(back)) {
    if(app) {
      dk3str_memory_error(app, 1, (1+strlen(s)));
    }
  }
#else
  size_t sz;
  sz = 1 + dk3str_c8_len(s);
  if(app) {
    back = dk3_new_app(char,sz,app);
  } else {
    back = dk3_new(char,sz);
  }
  if(back) {
    dk3str_c8_cpy_not_overlapped(back, s);
  }
#endif
#endif
  return back;
}



dk3_c16_t *
dk3str_c16_dup_app(dk3_c16_t const *s, dk3_app_t *app)
{
  dk3_c16_t *back;
#if (DK3_HAVE_WCSDUP) && (DK3_SIZEOF_WCHAR_T == 2)
  back = wcsdup(s);
  if(!(back)) {
    if(app) {
      dk3str_memory_error(app, 2, (1 + dk3str_c16_len(s)));
    }
  }
#else
#if (DK3_HAVE__WCSDUP) && (DK3_SIZEOF_WCHAR_T == 2)
  back = _wcsdup(s);
  if(!(back)) {
    if(app) {
      dk3str_memory_error(app, 2, (1 + dk3str_c16_len(s)));
    }
  }
#else
  size_t sz;
  sz = 1 + dk3str_c16_len(s);
  if(app) {
    back = dk3_new_app(dk3_c16_t,sz,app);
  } else {
    back = dk3_new(dk3_c16_t,sz);
  }
  if(back) {
    dk3str_c16_cpy_not_overlapped(back, s);
  }
#endif
#endif
  return back;
}



dk3_c32_t *
dk3str_c32_dup_app(dk3_c32_t const *s, dk3_app_t *app)
{
  dk3_c32_t *back;
#if (DK3_HAVE_WCSDUP) && (DK3_SIZEOF_WCHAR_T == 4)
  back = wcsdup(s);
  if(!(back)) {
    if(app) {
      dk3str_memory_error(app, 4, (1 + dk3str_c32_len(s)));
    }
  }
#else
#if (DK3_HAVE__WCSDUP) && (DK3_SIZEOF_WCHAR_T == 4)
  back = _wcsdup(s);
  if(!(back)) {
    if(app) {
      dk3str_memory_error(app, 4, (1 + dk3str_c32_len(s)));
    }
  }
#else
  size_t sz;
  sz = 1 + dk3str_c32_len(s);
  if(app) {
    back = dk3_new_app(dk3_c32_t,sz,app);
  } else {
    back = dk3_new(dk3_c32_t,sz);
  }
  if(back) {
    dk3str_c32_cpy(back, s);
  }
#endif
#endif
  return back;
}



dkChar *
dk3str_dup_app(dkChar const *s, dk3_app_t *app)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_dup_app(s, app));
#else
  return(dk3str_c16_dup_app(s, app));
#endif
#else
  return(dk3str_c8_dup_app(s, app));
#endif
}


char
dk3str_c8_tolower(char c)
{
  char back;		/* Function result. */
  back = c;
  if((back >= 'A') && (back <= 'Z')) {
    back = 'a' + (back - 'A');
  }
  return back;
}



dk3_c16_t
dk3str_c16_tolower(dk3_c16_t c)
{
  dk3_c16_t back;
  back = c;
  if((back >= 0x0041U) && (back <= 0x005AU)) {
    back = 0x0061U + (back - 0x0041U);
  }
  return back;
}



dk3_c32_t
dk3str_c32_tolower(dk3_c32_t c)
{
  dk3_c32_t back;
  back = c;
  if((back >= (dk3_c32_t)0x00000041UL) && (back <= (dk3_c32_t)0x0000005AUL)) {
    back = (dk3_c32_t)0x00000061UL + (back - (dk3_c32_t)0x00000041UL);
  }
  return back;
}



dkChar
dk3str_tolower(dkChar c)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_tolower(c));
#else
  return(dk3str_c16_tolower(c));
#endif
#else
  return(dk3str_c8_tolower(c));
#endif
}



char
dk3str_c8_toupper(char c)
{
  char back;		/* Function result. */
  back = c;
  if((back >= 'a') && (back <= 'z')) {
    back = 'A' + (back - 'a');
  }
  return back;
}



dk3_c16_t
dk3str_c16_toupper(dk3_c16_t c)
{
  dk3_c16_t back;
  back = c;
  if((back >= 0x0061U) && (back <= 0x007AU)) {
    back = 0x0041U + (back - 0x0061U);
  }
  return back;
}



dk3_c32_t
dk3str_c32_toupper(dk3_c32_t c)
{
  dk3_c32_t back;
  back = c;
  if((back >= (dk3_c32_t)0x00000061UL) && (back <= (dk3_c32_t)0x0000007AUL)) {
    back = (dk3_c32_t)0x00000041UL + (back - (dk3_c32_t)0x00000061UL);
  }
  return back;
}



dkChar
dk3str_toupper(dkChar c)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_toupper(c));
#else
  return(dk3str_c16_toupper(c));
#endif
#else
  return(dk3str_c8_toupper(c));
#endif
}



char *
dk3str_c8_start(char const *str, char const *whsp)
{
  char *back = NULL;	/* Function result. */
  char const *ptr;	/* Pointer to traverse str. */
  char const *wh;	/* Whitespaces set. */
  $? "+ dkstr_start %s", TR_STR(str)
  if(str) {
    wh = (whsp ? whsp : dk3str_c8_def_whsp);
    ptr = str;
    while((*ptr) && (!(back))) {
      if(dk3str_c8_chr(wh,*ptr)) {
	ptr++;
      } else {
	back = (char *)ptr;
      }
    }
  } $? "- dkstr_start %s", TR_STR(back)
  return back;
}



dk3_c16_t *
dk3str_c16_start(dk3_c16_t const *str, dk3_c16_t const *whsp)
{
  dk3_c16_t *back = NULL;
  dk3_c16_t const *ptr;		/* Pointer into string. */
  dk3_c16_t const *wh;		/* Whitespaces set. */

  if(str) {
    wh = (whsp ? whsp : c16_def_whsp);
    ptr = str;
    while((*ptr) && (!(back))) {
      if(dk3str_c16_chr(wh, *ptr)) {
        ptr++;
      } else {
        back = (dk3_c16_t *)ptr;
      }
    }
  }
  return back;
}



dk3_c32_t *
dk3str_c32_start(dk3_c32_t const *str, dk3_c32_t const *whsp)
{
  dk3_c32_t *back = NULL;
  dk3_c32_t const *ptr = NULL;	/* Current character. */
  dk3_c32_t const *wh = NULL;	/* Whitespaces set. */
  $? "+ dk3str_c32_start \"%ls\"", (str ? str : L"NULL")
  if(str) {
    wh = (whsp ? whsp : c32_def_whsp);
    ptr = str;
    while((*ptr) && (!(back))) {
      if(dk3str_c32_chr(wh, *ptr)) {
        ptr++;
      } else {
        back = (dk3_c32_t *)ptr;
      }
    }
  } $? "- dk3str_c32_start \"%ls\"", (back ? back : L"NULL")
  return back;
}



dkChar *
dk3str_start(dkChar const *str, dkChar const *whsp)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_start(str, whsp));
#else
  return(dk3str_c16_start(str, whsp));
#endif
#else
  return(dk3str_c8_start(str, whsp));
#endif
}



char    *
dk3str_c8_next(char *str, char const *whsp)
{
  char *back = NULL;		/* Function result. */
  char *ptr = NULL;		/* Pointer to traverse str. */
  char const *wh = NULL;	/* Whitespaces set to use. */
  int state = 0;		/* Current processing state. */
  $? "+ dkstr_next %s", TR_STR(str)
  if(str) {
    ptr = str;
    wh = (whsp ? whsp : dk3str_c8_def_whsp);
    state = 0;
    while((state < 2) && (*ptr)) {
      if(dk3str_c8_chr(wh, *ptr)) {
	if(state == 1) {
	  state = 2;
	  *(ptr++) = '\0';
	  back = dk3str_c8_start(ptr, wh);
	} else {
	  ptr++;
	}
      } else {
	state = 1;
	ptr++;
      }
    }
  } $? "- dkstr_next %s", TR_STR(back)
  return back;
}



dk3_c16_t *
dk3str_c16_next(dk3_c16_t *str, dk3_c16_t const *whsp)
{
  dk3_c16_t *back = NULL;
  dk3_c16_t *ptr;		/* Pointer into string. */
  dk3_c16_t const *wh;		/* Whitespaces set. */
  int state;			/* Current state. */

  if(str) {
    ptr = str;
    wh = (whsp ? whsp : c16_def_whsp);
    state = 0;
    while((state < 2) && (*ptr)) {
      if(dk3str_c16_chr(wh, *ptr)) {
        if(state == 1) {
	  state = 2;
	  *(ptr++) = 0U;
	  back = dk3str_c16_start(ptr, wh);
	} else {
	  ptr++;
	}
      } else {
        state = 1; ptr++;
      }
    }
  }
  return back;
}



dk3_c32_t *
dk3str_c32_next(dk3_c32_t *str, dk3_c32_t const *whsp)
{
  dk3_c32_t *back = NULL;
  dk3_c32_t *ptr = NULL;	/* Pointer into string. */
  dk3_c32_t const *wh = NULL;	/* Whitespaces. */
  int state = 0;		/* Current processing state. */
  $? "+ dk3str_c32_next \"%ls\"\n", str
  if(str) {
    ptr = str;
    wh = (whsp ? whsp : c32_def_whsp);
    state = 0;
    while((state < 2) && (*ptr)) {
      if(dk3str_c32_chr(wh, *ptr)) {	$? ". loop state=%d ptr=\"%ls\"", state, (ptr ? ptr : L"NULL")
        if(state == 1) {
	  state = 2;
	  *(ptr++) = 0UL;
	  back = dk3str_c32_start(ptr, wh);
	} else {
	  ptr++;
	}
      } else {
        state = 1; ptr++;
      }
    }
  } $? "- dk3str_c32_next \"%ls\"\n", (back ? back : L"NULL")
  return back;
}



dkChar *
dk3str_next(dkChar *str, dkChar const *whsp)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_next(str, whsp));
#else
  return(dk3str_c16_next(str, whsp));
#endif
#else
  return(dk3str_c8_next(str, whsp));
#endif
}



void
dk3str_c8_chomp(char *str, char const *whsp)
{
  char const *wh;	/* Whitespaces set to use. */
  char *ptr;		/* Pointer to traverse str. */
  char *x;		/* Start position of final space sequence. */
  $? "+ dkstr_chomp %s", TR_STR(str)
  if(str) {
    wh = (whsp ? whsp : dk3str_c8_def_whsp);
    x = NULL; ptr = str;
    while(*ptr) {
      if(dk3str_c8_chr(wh, *ptr)) {
	if(!(x)) { x = ptr; }
      } else {
	x = NULL;
      }
      ptr++;
    }
    if(x) { *x = '\0'; }
  }
  $? "- dkstr_chomp %s", TR_STR(str)
}



void
dk3str_c16_chomp(dk3_c16_t *str, dk3_c16_t const *whsp)
{
  dk3_c16_t const *wh;	/* Whitespaces set. */
  dk3_c16_t *ptr;	/* Pointer into string. */
  dk3_c16_t *x;		/* Test pointer for whitespaces set. */

  if(str) {
    wh = (whsp ? whsp : c16_def_whsp);
    x = NULL; ptr = str;
    while(*ptr) {
      if(dk3str_c16_chr(wh, *ptr)) {
        if(!(x)) x = ptr;
      } else {
        x = NULL;
      }
      ptr++;
    }
    if(x) { *x = 0U; }
  }
}



void
dk3str_c32_chomp(dk3_c32_t *str, dk3_c32_t const *whsp)
{
  dk3_c32_t const *wh = NULL;	/* Whitespaces set. */
  dk3_c32_t *ptr = NULL;	/* Pointer into string. */
  dk3_c32_t *x = NULL;		/* For whitespace-set test. */

  if(str) {
    wh = (whsp ? whsp : c32_def_whsp);
    x = NULL; ptr = str;
    while(*ptr) {
      if(dk3str_c32_chr(wh, *ptr)) {
        if(!(x)) x = ptr;
      } else {
        x = NULL;
      }
      ptr++;
    }
    if(x) { *x = 0UL; }
  }
}



void
dk3str_chomp(dkChar *str, dkChar const *whsp)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  dk3str_c32_chomp(str, whsp);
#else
  dk3str_c16_chomp(str, whsp);
#endif
#else
  dk3str_c8_chomp(str, whsp);
#endif
}



void
dk3str_c8_delnl(char *str)
{
  char *ptr;
  if(str) {
    ptr = str;
    while(*ptr) {
      if(*ptr == 0x0D) {
        if(ptr[1] == 0x0A) {
	  *ptr = '\0';
	} else {
	  ptr++;
	}
      } else {
        if(*ptr == 0x0A) {
	  *ptr = '\0';
	} else {
	  ptr++;
	}
      }
    }
  }
}



void
dk3str_c16_delnl(dk3_c16_t *str)
{
  dk3_c16_t *ptr;
  if(str) {
    ptr = str;
    while(*ptr) {
      if(*ptr == 0x000DU) {
        if(ptr[1] == 0x000AU) {
	  *ptr = (dk3_c16_t)0U;
	} else {
	  ptr++;
	}
      } else {
        if(*ptr == 0x000AU) {
	  *ptr = (dk3_c16_t)0U;
	} else {
	  ptr++;
	}
      }
    }
  }
}



void
dk3str_c32_delnl(dk3_c32_t *str)
{
  dk3_c32_t	*ptr;
  if(str) {
    ptr = str;
    while(*ptr) {
      if(*ptr == 0x0000000DUL) {
        if(ptr[1] == 0x0000000AUL) {
	  *ptr = (dk3_c32_t)0UL;
	} else {
	  ptr++;
	}
      } else {
        if(*ptr == 0x0000000AUL) {
	  *ptr = (dk3_c32_t)0UL;
	} else {
	  ptr++;
	}
      }
    }
  }
}



void
dk3str_delnl(dkChar *str)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  dk3str_c32_delnl(str);
#else
  dk3str_c16_delnl(str);
#endif
#else
  dk3str_c8_delnl(str);
#endif
}



int
dk3str_c8_array_index(char const * const *a, char const *s, int c)
{
  int back = -1;		/* Function result. */
  int ci;			/* Current array index for test. */
  char const * const *ap;	/* Pointer to traverse array a. */
  if((a) && (s)) {
    ap = a; ci = 0;
    while((*ap) && (back == -1)) {
      if(c) {
        if(dk3str_c8_cmp(*ap, s) == 0) back = ci;
      } else {
        if(dk3str_c8_casecmp(*ap, s) == 0) back = ci;
      }
      if(back == -1) { ap++; ci++; }
    }
  }
  return back;
}



int
dk3str_c16_array_index(dk3_c16_t const * const *a, dk3_c16_t const *s, int c)
{
  int back = -1;
  int ci;			/* Current index. */
  dk3_c16_t const * const *ap;	/* Pointer into array. */
  if((a) && (s)) {
    ap = a; ci = 0;
    while((*ap) && (back == -1)) {
      if(c) {
        if(dk3str_c16_cmp(*ap, s) == 0) back = ci;
      } else {
        if(dk3str_c16_casecmp(*ap, s) == 0) back = ci;
      }
      if(back == -1) { ap++; ci++; }
    }
  }
  return back;
}



int
dk3str_c32_array_index(dk3_c32_t const * const *a, dk3_c32_t const *s, int c)
{
  int back = -1;
  int ci;			/* Current index. */
  dk3_c32_t const * const *ap;	/* Pointer into array. */

  if((a) && (s)) {
    ap = a; ci = 0;
    while((*ap) && (back == -1)) {
      if(c) {
        if(dk3str_c32_cmp(*ap, s) == 0) back = ci;
      } else {
        if(dk3str_c32_casecmp(*ap, s) == 0) back = ci;
      }
      if(back == -1) { ap++; ci++; }
    }
  }
  return back;
}



int
dk3str_array_index(dkChar const * const *a, dkChar const *s, int c)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_array_index(a, s, c));
#else
  return(dk3str_c16_array_index(a, s, c));
#endif
#else
  return(dk3str_c8_array_index(a, s, c));
#endif
}



int
dk3str_c8_is_abbr(char const *line,char const *pattern,char spec,int cs)
{
  int back = 0;			/* Function result. */
  char cl;			/* Current character from line. */
  char cp;			/* Current character from pattern. */
  char const *lptr = NULL;	/* Pointer to traverse line. */
  char const *pptr = NULL;	/* Pointer to traverse pattern. */
  int afterspec = 0;		/* Flag: cs was already found in the pattern. */
  int cc = 0;			/* Flag: Can continue. */
  $? "+ dkstr_is_abbr %s %s %c %d", TR_STR(line), TR_STR(pattern), spec, cs
  if((line) && (pattern)) {
    lptr = line; pptr = pattern; afterspec = 0; cc = 1;
    while(cc) {
      if(*pptr) {
        if((!afterspec) && (*pptr == spec)) {
	  afterspec = 1; pptr++;
	} else {
	  if(*lptr) {
	    cl = *lptr; cp = *pptr;
	    if(!cs) {
	      cl = dk3str_c8_toupper(cl);
	      cp = dk3str_c8_toupper(cp);
	    }
	    if(cl == cp) {
	      lptr++; pptr++;
	    } else {
	      cc = 0; back = 0;
	    }
	  } else {
	    cc = 0;
	    if(afterspec) back = 1;
	  }
	}
      } else {
        cc = 0;
	if(!(*lptr)) {
	  back = 1;
	}
      }
    }
  }
  $? "- dkstr_is_abbr %d", back
  return back;
}



int
dk3str_c16_is_abbr(dk3_c16_t const *line, dk3_c16_t const *pattern, dk3_c16_t spec, int cs)
{
  int back = 0;
  dk3_c16_t cl;			/* Current character from line. */
  dk3_c16_t cp;			/* Current character from pattern. */
  dk3_c16_t const *lptr;	/* Input text to check. */
  dk3_c16_t const *pptr;	/* Pattern. */
  int afterspec;		/* Flag: Abbreviation inidicator found. */
  int cc;			/* Flag: Can continue. */

  if((line) && (pattern)) {
    lptr = line; pptr = pattern; afterspec = 0; cc = 1;
    while(cc) {
      if(*pptr) {
        if((!afterspec) && (*pptr == spec)) {
	  afterspec = 1; pptr++;
	} else {
	  if(*lptr) {
	    cl = *lptr; cp = *pptr;
	    if(!cs) {
	      cl = dk3str_c16_toupper(cl);
	      cp = dk3str_c16_toupper(cp);
	    }
	    if(cl == cp) {
	      lptr++; pptr++;
	    } else {
	      cc = 0; back = 0;
	    }
	  } else {
	    cc = 0;
	    if(afterspec) back = 1;
	  }
	}
      } else {
        cc = 0;
	if(!(*lptr)) {
	  back = 1;
	}
      }
    }
  }
  return back;
}



int
dk3str_c32_is_abbr(dk3_c32_t const *line, dk3_c32_t const *pattern, dk3_c32_t spec, int cs)
{
  int back = 0;
  dk3_c32_t cl = 0UL;		/* Text character. */
  dk3_c32_t cp = 0UL;		/* Pattern character. */
  dk3_c32_t const *lptr = NULL;	/* Pointer into text. */
  dk3_c32_t const *pptr = NULL;	/* Pointer into pattern. */
  int afterspec = 0;		/* Flag: Abbreviation indicator was found. */
  int cc = 0;			/* Flag: Can continue. */

  if((line) && (pattern)) {
    lptr = line; pptr = pattern; afterspec = 0; cc = 1;
    while(cc) {
      if(*pptr) {
        if((!afterspec) && (*pptr == spec)) {
	  afterspec = 1; pptr++;
	} else {
	  if(*lptr) {
	    cl = *lptr; cp = *pptr;
	    if(!cs) {
	      cl = dk3str_c32_toupper(cl);
	      cp = dk3str_c32_toupper(cp);
	    }
	    if(cl == cp) {
	      lptr++; pptr++;
	    } else {
	      cc = 0; back = 0;
	    }
	  } else {
	    cc = 0;
	    if(afterspec) back = 1;
	  }
	}
      } else {
        cc = 0;
	if(!(*lptr)) { back = 1; }
      }
    }
  }
  return back;
}



int
dk3str_is_abbr(dkChar const *line, dkChar const *pattern, dkChar spec, int cs)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_is_abbr(line, pattern, spec, cs));
#else
  return(dk3str_c16_is_abbr(line, pattern, spec, cs));
#endif
#else
  return(dk3str_c8_is_abbr(line, pattern, spec, cs));
#endif
}



int
dk3str_c8_array_abbr(char const * const *ar, char const *str, char sp, int cs)
{
  int back = -1;		/* Function result. */
  char const * const *ptr;	/* Pointer to traverse array ar. */
  int i;			/* Current index of ptr in ar. */
  $? "+ dk3str_c8_array_abbr %s %s %d", TR_PTR(ar), TR_STR(str), cs
  if((ar) && (str)) {
    i = 0; ptr = ar;
    while((*ptr) && (back == -1)) {
      $? ". i=%d ptr=%s", i, TR_STR(*ptr)
      if(dk3str_c8_is_abbr(str, *ptr, sp, cs)) {
        back = i;
      }
      if(back == -1) {
	ptr++; i++;
      }
      $? ". back=%d", back
    }
  } $? "- dk3str_c8_array_abbr %d", back
  return back;
}



int
dk3str_c16_array_abbr(dk3_c16_t const * const *arr, dk3_c16_t const *str, dk3_c16_t sp, int cs)
{
  int back = -1;
  dk3_c16_t const * const *ptr;	/* Pointer into array. */
  int i;			/* Current index. */
  $? "+ dk3str_c16_array_abbr"
  if((arr) && (str)) {	$? ". arguments ok"
    i = 0; ptr = arr;
    while((*ptr) && (back == -1)) {			$? ". loop start"
#if DK3_CHAR_SIZE > 1
      $? ". compare \"%ls\" <=> \"%ls\"", *ptr, str
#else
      $? ". compare \"%s\" <=> \"%s\"", *ptr, str
#endif
      if(dk3str_c16_is_abbr(str, *ptr, sp, cs)) {	$? ". match"
        back = i;
      } else {						$? "! no match"
      }
      if(back == -1) {
        ptr++; i++;
      }							$? ". loop end"
    }				$? ". after loop"
  } $? "- dk3str_array_abbr %d", back
  return back;
}



int
dk3str_c32_array_abbr(dk3_c32_t const * const *arr, dk3_c32_t const *str, dk3_c32_t sp, int cs)
{
  int back = -1;
  dk3_c32_t const * const *ptr = NULL;	/* Pointer into array. */
  int i = 0;				/* Current index. */

  if((arr) && (str)) {
    i = 0; ptr = arr;
    while((*ptr) && (back == -1)) {
      if(dk3str_c32_is_abbr(str, *ptr, sp, cs)) {
        back = i;
      }
      if(back == -1) {
        ptr++; i++;
      }
    }
  }
  return back;
}



int
dk3str_array_abbr(dkChar const * const *ar,dkChar const *str,dkChar sp,int cs)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_array_abbr(ar, str, sp, cs));
#else
  return(dk3str_c16_array_abbr(ar, str, sp, cs));
#endif
#else
  return(dk3str_c8_array_abbr(ar, str, sp, cs));
#endif
}



int
dk3str_c8_is_bool(char const *str)
{
  int back = 0;	/* Function result. */
  $? "+ dkstr_is_bool %s", TR_STR(str)
  if(str) {
    if(dk3str_c8_array_abbr(dk3str_c8_bool_kw,str,'$',0) >= 0) {
      back = 1;
    }
  } $? "- dkstr_is_bool %d", back
  return back;
}



int
dk3str_c16_is_bool(dk3_c16_t const *str)
{
  int back = 0;
  char	mytest[256];	/* 8-bit version of the str text. */
  if(str) {
#if VERSION_BEFORE_20130928
    if(dk3str_c16_to_c8_simple(mytest, sizeof(mytest), str)) {
      back = dk3str_c8_is_bool(mytest);
    }
#else
    if(dk3str_cnv_c16_to_c8u_app(mytest, sizeof(mytest), str, NULL)) {
      back = dk3str_c8_is_bool(mytest);
    }
#endif
  }
  return back;
}



int
dk3str_c32_is_bool(dk3_c32_t const *str)
{
  int back = 0;
  char mytest[256];	/* 8-bit text copy of str. */
  if(str) {
#if VERSION_BEFORE_20130928
    if(dk3str_c32_to_c8_simple(mytest, sizeof(mytest), str)) {
      back = dk3str_c8_is_bool(mytest);
    }
#else
    if(dk3str_cnv_c32_to_c8u_app(mytest, sizeof(mytest), str, NULL)) {
      back = dk3str_c8_is_bool(mytest);
    }
#endif
  }
  return back;
}



int
dk3str_is_bool(dkChar const *str)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_is_bool(str));
#else
  return(dk3str_c16_is_bool(str));
#endif
#else
  return(dk3str_c8_is_bool(str));
#endif
}



int
dk3str_c8_is_on(char const *str)
{
  int back = 0;	/* Function result. */
  $? "+ dkstr_is_on %s",TR_STR(str)
  if(str) {
    if(dk3str_c8_array_abbr(dk3str_c8_bool_kw,str,'$',0) >= INDEX_OF_FIRST_BOOLEAN_TRUE) {
      back = 1;
    }
  } $? "- dkstr_is_on %d", back
  return back;
}



int
dk3str_c16_is_on(dk3_c16_t const *str)
{
  int back = 0;
  char	mytest[256];	/* 8-bit version of the str text. */
  if(str) {
#if VERSION_BEFORE_20130928
    if(dk3str_c16_to_c8_simple(mytest, sizeof(mytest), str)) {
      back = dk3str_c8_is_on(mytest);
    }
#else
    if(dk3str_cnv_c16_to_c8u_app(mytest, sizeof(mytest), str, NULL)) {
      back = dk3str_c8_is_on(mytest);
    }
#endif
  }
  return back;
}



int
dk3str_c32_is_on(dk3_c32_t const *str)
{
  int back = 0;
  char mytest[256];	/* 8-bit copy of str text. */
  if(str) {
#if VERSION_BEFORE_20130928
    if(dk3str_c32_to_c8_simple(mytest, sizeof(mytest), str)) {
      back = dk3str_c8_is_on(mytest);
    }
#else
    if(dk3str_cnv_c32_to_c8u_app(mytest, sizeof(mytest), str, NULL)) {
      back = dk3str_c8_is_on(mytest);
    }
#endif
  }
  return back;
}



int
dk3str_is_on(dkChar const *str)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_is_on(str));
#else
  return(dk3str_c16_is_on(str));
#endif
#else
  return(dk3str_c8_is_on(str));
#endif
}



size_t
dk3str_c8_explode(char **array, size_t sz, char *str, char const *whsp)
{
  size_t	back = 0;	/* Function result. */
  char const	*wh = NULL;	/* White spaces set to use. */
  char		*current = NULL; /* Current text word to process. */
  char		*next = NULL;	/* Remaining text after processing the word. */
  char		**ptr = NULL;	/* Pointer to current array element. */
  size_t 	i = 0;		/* Number of remaining usable array elements. */
  if((array) && (sz > 1) && (str)) {
    wh = (whsp ? whsp : dk3str_c8_def_whsp);
    ptr = array; i = sz;
    while(i--) { *(ptr++) = NULL; }
    ptr = array; i = 0;
    current = dk3str_c8_start(str, wh);
    while((current) && (i < (sz - 1))) {
      next = dk3str_c8_next(current,wh);
      *(ptr++) = current; i++; back++;
      current = next;
    }
  }
  return back;
}



size_t
dk3str_c16_explode(dk3_c16_t **array, size_t sz, dk3_c16_t *str, dk3_c16_t const *whsp)
{
  size_t		back = 0;
  dk3_c16_t const	*wh = NULL;	/* Whitespaces set. */
  dk3_c16_t		*current = NULL;	/* Start of current word. */
  dk3_c16_t		*next = NULL;	/* Start of next word after current. */
  dk3_c16_t		**ptr = NULL;	/* Pointer into array. */
  size_t		i = 0;		/* Number of words found. */

  if((array) && (sz > 1) && (str)) {
    wh = (whsp ? whsp : c16_def_whsp);
    ptr = array; i = sz;
    while(i--) { *(ptr++) = NULL; }
    ptr = array; i = 0;
    current = dk3str_c16_start(str, wh);
    while((current) && (i < (sz - 1))) {
      next = dk3str_c16_next(current, wh);
      *(ptr++) = current; i++; back++;
      current = next;
    }
  }
  return back;
}



size_t
dk3str_c32_explode(dk3_c32_t **array, size_t sz, dk3_c32_t *str, dk3_c32_t const *whsp)
{
  size_t		back = 0;
  dk3_c32_t const	*wh = NULL;	/* Whitespace set. */
  dk3_c32_t		*current = NULL;	/* Current word. */
  dk3_c32_t		*next = NULL;	/* Next word. */
  dk3_c32_t		**ptr = NULL;	/* Pointer into destination array. */
  size_t		i = 0;		/* Current index. */
  if((array) && (sz > 1) && (str)) {
    wh = (whsp ? whsp : c32_def_whsp);
    ptr = array; i = sz;
    while(i--) { *(ptr++) = NULL; }
    ptr = array; i = 0;
    current = dk3str_c32_start(str, wh);
    while((current) && (i < (sz - 1))) {
      next = dk3str_c32_next(current, wh);
      *(ptr++) = current; i++; back++;
      current = next;
    }
  }
  return back;
}



size_t
dk3str_explode(dkChar **array, size_t sz, dkChar *str, dkChar const *whsp)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_explode(array, sz, str, whsp));
#else
  return(dk3str_c16_explode(array, sz, str, whsp));
#endif
#else
  return(dk3str_c8_explode(array, sz, str, whsp));
#endif
}



void
dk3str_c8_normalize(char *l, char const *w, char s)
{
  char		*parts[256];	/* All the text words. */
  char		*dp = NULL;	/* Destination pointer. */
  char		*sp = NULL;	/* Source pointer. */
  size_t	np = 0;		/* Number of parts used. */
  size_t	i = 0;		/* Current word to process. */
  if(l) {
    np = dk3str_c8_explode(parts, 255, l, w);
    if(np > 0) {
      dp = l;
      for(i = 0; i < np; i++) {
        sp = parts[i];
	if(i) { *(dp++) = s; }
	while(*sp) { *(dp++) = *(sp++); }
      }
      *dp = '\0';
    }
  }
}



void
dk3str_c16_normalize(dk3_c16_t *l, dk3_c16_t const *w, char s)
{
  dk3_c16_t		*parts[256];	/* Pointers to the words. */
  dk3_c16_t		*dp = NULL;	/* Destination pointer. */
  dk3_c16_t		*sp = NULL;	/* Source pointer. */
  size_t		np = 0;		/* Number of parts. */
  size_t		i = 0;		/* Index of current part. */

  if(l) {
    np = dk3str_c16_explode(parts, 255, l, w);
    if(np > 0) {
      dp = l;
      for(i = 0; i < np; i++) {
        sp = parts[i];
	if(i) { *(dp++) = s; }
	while(*sp) { *(sp++) = *(dp++); }
      }
      *dp = 0U;
    }
  }
}



void
dk3str_c32_normalize(dk3_c32_t *l, dk3_c32_t const *w, char s)
{
  dk3_c32_t	*parts[256];	/* Words. */
  dk3_c32_t	*dp = NULL;	/* Destination pointer. */
  dk3_c32_t	*sp = NULL;	/* Source pointer. */
  size_t	np = 0;	/* Number of words. */
  size_t	i = 0;		/* Index of current word. */
  if(l) {
    np = dk3str_c32_explode(parts, 255, l, w);
    if(np > 0) {
      dp = l;
      for(i = 0; i < np; i++) {
        sp = parts[i];
	if(i) { *(dp++) = s; }
	while(*sp) { *(dp++) = *(sp++); }
      }
      *dp = 0UL;
    }
  }
}



void
dk3str_normalize(dkChar *l, dkChar const *w, dkChar s)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  dk3str_c32_normalize(l, w, s);
#else
  dk3str_c16_normalize(l, w, s);
#endif
#else
  dk3str_c8_normalize(l, w, s);
#endif
}



void
dk3str_c8_correct_filename(char *n)
{
  register char *p;
  p = n;
  while(*p) { if(*p == NO_FNS_C8) { *p = FNS_C8; } p++; }
}



void
dk3str_c16_correct_filename(dk3_c16_t *n)
{
  register dk3_c16_t *p;
  p = n;
  while(*p) { if(*p == NO_FNS_C16) { *p = FNS_C16; } p++;}
}



void
dk3str_c32_correct_filename(dk3_c32_t *n)
{
  register dk3_c32_t *p;	/* Pointer into text. */
  p = n;
  while(*p) { if(*p == NO_FNS_C32) { *p = FNS_C32; } p++;}
} 



void
dk3str_correct_filename(dkChar *n)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  dk3str_c32_correct_filename(n);
#else
  dk3str_c16_correct_filename(n);
#endif
#else
  dk3str_c8_correct_filename(n);
#endif
}



int
dk3str_c8_is_abs_path(char const *n)
{
  int back = 0;
  if(n) {
    if(*n == FNS_C8) {
      back = 1;
    } else {
#if DK3_ON_WINDOWS
      if(((*n >= 'A') && (*n <= 'Z')) || ((*n >= 'a') && (*n <= 'z'))) {
        if(n[1] == ':') {
	  if(n[2] == FNS_C8) {
	    back = 1;
	  }
	}
      }
#endif
    }
  }
  return back;
}



int
dk3str_c16_is_abs_path(dk3_c16_t const *n)
{
  int back = 0;
  if(n) {
    if(*n == FNS_C16) {
      back = 1;
    } else {
#if DK3_ON_WINDOWS
      if(((*n >= 0x0061U) && (*n <= 0x007AU))
         || ((*n >= 0x0041U) && (*n <= 0x005AU)))
      {
        if(n[1] == 0x003AU) {
	  if(n[2] == FNS_C16) {
	    back = 1;
	  }
	}
      }
#endif
    }
  }
  return back;
}



int
dk3str_c32_is_abs_path(dk3_c32_t const *n)
{
  int back = 0;
  $? "+ dk3str_c32_is_abs_path \"%ls\"", n
  if(n) {
    if(*n == FNS_C32) {
      back = 1;
    } else {
#if DK3_ON_WINDOWS
      if(((*n >= 0x00000061UL) && (*n <= 0x0000007AUL))
        || ((*n >= 0x00000041UL) && (*n <= 0x0000005AUL)))
      {
        if(n[1] == 0x0000003AUL) {
	  if(n[2] == FNS_C32) {
	    back = 1;
	  }
	}
      }
#endif
    }
  } $? "- dk3str_c32_is_abs_path %d", back
  return back;
}



int
dk3str_is_abs_path(dkChar const *n)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_is_abs_path(n));
#else
  return(dk3str_c16_is_abs_path(n));
#endif
#else
  return(dk3str_c8_is_abs_path(n));
#endif
}



int
dk3str_c8_append_path_app(char *d, size_t sz, char const *n, dk3_app_t *app)
{
  int		 back = 0;		/* Function result. */
  char		 myn[DK3_MAX_PATH];	/* My editable copy of n. */
  char 		*p1 = NULL;		/* Current name part. */
  char 		*p2 = NULL;		/* Remaining text. */
  char		*p3 = NULL;		/* Used to delete one part from path. */
  size_t	 tsz;			/* Size for tests. */
  if((d) && (sz) && (n)) {
    if(dk3str_c8_is_abs_path(n)) {	/* Absolute path, copy. */
      if(dk3str_c8_len(n) < sz) {
        dk3str_c8_cpy(d,n);
	back = 1;
      } else {
        if(app) {
	  /* ERROR: Name n too long! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 109);
	}
      }
    } else {				/* Relative path, append. */
      if(dk3str_c8_len(n) < sizeof(myn)) {
        back = 1;
        dk3str_c8_cpy(myn,n);
	p1 = myn;
	while((p1) && (back)) {
	  p2 = dk3str_c8_chr(p1,FNS_C8);
	  if(p2) { *(p2++) = '\0'; }
	  if(dk3str_c8_cmp(dk3str_c8_dot,p1)) {
	    if(dk3str_c8_cmp(dk3str_c8_dot_dot,p1)) {	/* Add another part. */
	      tsz =	dk3str_c8_len(d) + dk3str_c8_len(dk3str_c8_fnsep)
	      		+ dk3str_c8_len(p1);
	      if(tsz < sz) {
	        dk3str_c8_cat(d,dk3str_c8_fnsep);
		dk3str_c8_cat(d,p1);
	      } else {
	        if(app) {
		  /* ERROR: Result too long for destination buffer! */
		  dk3app_log_i1(app, DK3_LL_ERROR, 38);
		}
	      }
	    } else {			/* Remove last part. */
	      p3 = dk3str_c8_rchr(d,FNS_C8);
	      if(p3) {
	        *p3 = '\0';
	      } else {
	        if(app) {
		  /* ERROR: Too many ".." entries! */
#if DK3_CHAR_SIZE == 1
		  dk3app_log_i3(app, DK3_LL_ERROR, 110, 111, n);
#else
		  dk3app_log_i1(app, DK3_LL_ERROR, 126);
#endif
		}
	      }
	    }
	  }
	  p1 = p2;
	}
      } else {
        if(app) {
	  /* ERROR: Name n too long! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 109);
	}
      }
    }
  }
  return back;
}



int
dk3str_c16_append_path_app(dk3_c16_t *d, size_t sz, dk3_c16_t const *n, dk3_app_t *app)
{
  int back = 0;
  dk3_c16_t	myn[DK3_MAX_PATH];
  dk3_c16_t	*p1 = NULL;		/* Path component to process. */
  dk3_c16_t	*p2 = NULL;		/* Remainder of path. */
  dk3_c16_t	*p3 = NULL;		/* Last path component to remove. */
  size_t	 tsz;			/* Test size. */

  if((d) && (sz) && (n)) {
    if(dk3str_c16_is_abs_path(n)) {
      if(dk3str_c16_len(n) < sz) {
        dk3str_c16_cpy(d,n) ;
	back = 1;
      } else {
        if(app) {
	  /* ERROR: Name n too long! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 109);
	}
      }
    } else {
      if(dk3str_c16_len(n) < DK3_SIZEOF(myn,dk3_c16_t)) {
        back = 1;
	dk3str_c16_cpy(myn,n) ;
	p1 = myn;
	while((p1) && (back)) {
	  p2 = dk3str_c16_chr(p1, FNS_C16);
	  if(p2) { *(p2++) = 0U; }
	  if(dk3str_c16_cmp(c16_dot,p1)) {
	    if(dk3str_c16_cmp(c16_dot_dot,p1)) {
	      tsz =	dk3str_c16_len(d) + dk3str_c16_len(c16_fnsep)
	      		+ dk3str_c16_len(p1);
	      if(tsz < sz) {
	        dk3str_c16_cat(d,c16_fnsep);
		dk3str_c16_cat(d,p1);
	      } else {
	        if(app) {
		  /* ERROR: Result too long for destination buffer! */
		  dk3app_log_i1(app, DK3_LL_ERROR, 38);
		}
	      }
	    } else {
	      p3 = dk3str_c16_rchr(d,FNS_C16);
	      if(p3) {
	        *p3 = 0U;
	      } else {
	        if(app) {
		  /* ERROR: Too many ".." entries! */
#if DK3_CHAR_SIZE == 2
		  dk3app_log_i3(app, DK3_LL_ERROR, 110, 111, n);
#else
		  dk3app_log_i1(app, DK3_LL_ERROR, 126);
#endif
		}
	      }
	    }
	  }
	  p1 = p2;
	}
      } else {
        if(app) {
	  /* ERROR: Name n too long! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 109);
	}
      }
    }
  }
  return back;
}



int
dk3str_c32_append_path_app(dk3_c32_t *d, size_t sz, dk3_c32_t const *n, dk3_app_t *app)
{
  int back = 0;
  dk3_c32_t	myn[DK3_MAX_PATH];	/* My editable copy of n. */
  dk3_c32_t	*p1 = NULL;		/* Current name part. */
  dk3_c32_t	*p2 = NULL;		/* Remaining text. */
  dk3_c32_t	*p3 = NULL;		/* Used to delete one part from path. */
  size_t	 tsz;			/* Test size. */

  $? "+ dk3str_c32_append_path_app \"%ls\" \"%ls\"", d, n
  if((d) && (sz) && (n)) {
    if(dk3str_c32_is_abs_path(n)) {	$? ". abs"
      if(dk3str_c32_len(n) < sz) {
        dk3str_c32_cpy(d,n) ;
	back = 1;
      } else {
        if(app) {
	  /* ERROR: Name n too long! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 109);
	}
      }
    } else {				$? ". rel"
      if(dk3str_c32_len(n) < DK3_SIZEOF(myn,dk3_c32_t)) {
        back = 1;
	dk3str_c32_cpy(myn,n) ;
	p1 = myn;
	while((p1) && (back)) {
	  p2 = dk3str_c32_chr(p1,FNS_C32);
	  if(p2) { *(p2++) = 0UL; }
	  if(dk3str_c32_cmp(c32_dot,p1)) {
	    if(dk3str_c32_cmp(c32_dot_dot,p1)) {
	      tsz =	dk3str_c32_len(d) + dk3str_c32_len(c32_fnsep)
	      		+ dk3str_c32_len(p1);
	      if(tsz < sz) {
	        dk3str_c32_cat(d,c32_fnsep);
		dk3str_c32_cat(d,p1);
	      } else {
	        if(app) {
		  /* ERROR: Result too long for destination buffer! */
		  dk3app_log_i1(app, DK3_LL_ERROR, 38);
		}
	      }
	    } else {
	      p3 = dk3str_c32_rchr(d,FNS_C32);
	      if(p3) {
	        *p3 = 0UL;
	      } else {
	        if(app) {
		  /* ERROR: Too many ".." entries! */
		  dk3app_log_i1(app, DK3_LL_ERROR, 110);
		}
	      }
	    }
	  }
	  p1 = p2;
	}
      } else {
        if(app) {
	  /* ERROR: Name n too long! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 109);
	}
      }
    }
  }
  if(back) {	$? ". result \"%ls\"", d
  } $? "- dk3str_c32_append_path_app %d", back
  return back;
}



int
dk3str_append_path_app(dkChar *d, size_t sz, dkChar const *n, dk3_app_t *app)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_append_path_app(d, sz, n, app));
#else
  return(dk3str_c16_append_path_app(d, sz, n, app));
#endif
#else
  return(dk3str_c8_append_path_app(d, sz, n, app));
#endif
}



char *
dk3str_c8_get_suffix(char const *s)
{
  char *back = NULL;
  char const *ptr;
  if(s) {
    ptr = s;
    while(*ptr) {
      if(*ptr == '.') {
        back = (char *)ptr;
      } else {
	if(*ptr == FNS_C8) {
	  back = NULL;
	}
      }
      ptr++;
    }
  }
  return back;
}



dk3_c16_t *
dk3str_c16_get_suffix(dk3_c16_t const *s)
{
  dk3_c16_t *back = NULL;
  dk3_c16_t const *ptr;

  if(s) {
    ptr = s;
    while(*ptr) {
      if(*ptr == 0x002EU) {
        back = (dk3_c16_t *)ptr;
      } else {
        if(*ptr == FNS_C16) {
	  back = NULL;
	}
      }
      ptr++;
    }
  }
  return back;
}



dk3_c32_t *
dk3str_c32_get_suffix(dk3_c32_t const *s)
{
  dk3_c32_t *back = NULL;
  dk3_c32_t const *ptr;
  if(s) {
    ptr = s;
    while(*ptr) {
      if(*ptr == 0x0000002EUL) {
        back = (dk3_c32_t *)ptr;
      } else {
        if(*ptr == FNS_C32) {
	  back = NULL;
	}
      }
      ptr++;
    }
  }
  return back;
}



dkChar *
dk3str_get_suffix(dkChar const *s)
{
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  return(dk3str_c32_get_suffix(s));
#else
  return(dk3str_c16_get_suffix(s));
#endif
#else
  return(dk3str_c8_get_suffix(s));
#endif
}



int
dk3str_c32_to_c8_simple_app(char *d, size_t sz, dk3_c32_t const *s, dk3_app_t *app)
{
  int back = 0;
  dk3_c32_t const *ptr = NULL;	/* Pointer into source string. */
  dk3_c32_t c = 0UL;		/* Source character. */
  unsigned char uc = 0x00;	/* Destination character. */
  char *dptr = NULL;		/* Destination pointer. */

  if((d) && (sz) && (s)) {
    if(dk3str_c32_len(s) < sz) {
      back = 1; ptr = s; dptr = d;
      while(0UL != (c = *ptr)) {
        if(c < (dk3_c32_t)0x00000100UL) {
	  uc = (unsigned char)c;
	  *(dptr++) = (char)uc;
	} else {
	  if((back == 1) && (app)) {
	    /* ERROR: Illegal character(s) in source string! */
	    dk3app_log_i1(app, DK3_LL_ERROR, 112);
	  }
	  back = 0;
	}
	ptr++;
      }
      *dptr = '\0';
    } else {
      d[0] = '\0';
      if(app) {
        /* ERROR: Source string too long! */
	dk3app_log_i1(app, DK3_LL_ERROR, 108);
      }
    }
  }
  return back;
}







/**	Convert 8-bit plain text to other encodings.
	@param	d	Destination buffer (NULL to just count result elements).
	@param	s	Source string.
	@param	app	Application structure for diagnostics, may be NULL.
	@param	enc	Destination encoding (DK3_ENCODING_xxx).
	@return	Number of destination elements created.
*/
static
size_t
dk3str_i_cnv_c8p(void *d, char const *s, dk3_app_t *app, int enc)
{
  size_t	back = 0;
  int		error = 0;	/* Flag: Error occured. */
  char const	*sptr = NULL;	/* Source pointer. */
  char 		*dp8 = NULL;	/* Pointer to 8-bit destination. */
  dk3_c16_t	*dp16 = NULL;	/* Pointer to 16-bit destination. */
  dk3_c32_t	*dp32 = NULL;	/* Pointer to 32-bit destination. */
  char		c = 0x00;	/* Current source character to process. */
  unsigned char	uc = 0x00;	/* Destination byte. */
  dk3_c32_t	ul = 0UL;	/* Conversion result. */
  unsigned char	myuc[16];	/* Conversion result buffer. */
  dk3_c16_t	myc16[16];	/* Conversion result buffer. */
  size_t	u8u = 0;	/* UTF-8 bytes used for encoding. */
  size_t	u16u = 0;	/* UTF-16 characters used for encoding. */
  size_t	sl = 0;		/* Number of remaining characters in source. */
  size_t	i = 0;		/* Copy converted characters to destination. */
  $? "+ dk3str_i_cnv_c8p"
  if(s) {
    sptr = s; sl = dk3str_c8_len(s);
    if(d) {
      switch(enc) {
        case DK3_ENCODING_UTF8: { dp8 = (char *)d; } break;
	case DK3_ENCODING_UTF16: { dp16 = (dk3_c16_t *)d; } break;
	case DK3_ENCODING_UNICODE: { dp32 = (dk3_c32_t *)d; } break;
	default: {
	  if(app) {
	    /* ERROR: Illegal destination encoding! */
	    dk3app_log_i1(app, DK3_LL_ERROR, 114);
	  }
	} break;
      }
    }
    while((sl) && (0 == error)) {
      c = *(sptr++); sl--;
      uc = (unsigned char)c;
      ul = (dk3_c32_t)uc;
      ul &= 0x000000FFUL;
      switch(enc) {
        case DK3_ENCODING_UTF8: {
	  u8u = dk3enc_uc2utf8(ul, myuc, 16);
	  if(u8u) {
	    back = dk3mem_add_size_t(back, u8u, &error);
	    if(d) {
	      for(i = 0; i < u8u; i++) { *(dp8++) = myuc[i]; }
	    }
	  } else {
	    if(0 == error) {
	      if(app) {
	        /* ERROR: Conversion to UTF-8 failed! */
		dk3app_log_i1(app, DK3_LL_ERROR, 115);
	      }
	    } error = 1;
	  }
	} break;
	case DK3_ENCODING_UTF16: {
	  u16u = dk3enc_uc2utf16(ul, myc16, 16);
	  if(u16u) {
	    back = dk3mem_add_size_t(back, u16u, &error);
	    if(d) {
	      for(i = 0; i < u16u; i++) { *(dp16++) = myc16[i]; }
	    }
	  } else {
	    if(0 == error) {
	      if(app) {		$? "! conversion to UTF-16"
	        /* ERROR: Conversion to UTF-16 failed! */
		dk3app_log_i1(app, DK3_LL_ERROR, 116);
	      }
	    } error = 1;
	  }
	} break;
	case DK3_ENCODING_UNICODE: {
	  back = dk3mem_add_size_t(back, 1, &error);
	  if(d) { *(dp32++) = ul; }
	} break;
      }
    }
    if(d) {
      switch(enc) {
        case DK3_ENCODING_UTF8: { *dp8 = '\0'; } break;
	case DK3_ENCODING_UTF16: { *dp16 = 0U; } break;
	case DK3_ENCODING_UNICODE: { *dp32 = 0UL; } break;
      }
    }
    back = dk3mem_add_size_t(back, 1, &error);
    if(error) {
      back = 0;
      if(error == DK3_ERROR_MATH_OVERFLOW) {
        if(app) {
	  /* ERROR: Input string too long for conversion! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 108);
	}
      }
    }
  } $? "- dk3str_i_cnv_c8p %u", (unsigned)back
  return back;
}




size_t
dk3str_cnvsz_c8p_to_c8u_app(char const *s, dk3_app_t *app)
{
  size_t back = 0;
  if(s) {
    back = dk3str_i_cnv_c8p(NULL, s, app, DK3_ENCODING_UTF8);
  }
  return back;
}


int
dk3str_cnv_c8p_to_c8u_app(char *d, size_t ds, char const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Number of chars produced. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c8p(NULL, s, app, DK3_ENCODING_UTF8);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c8p((void *)d, s, app, DK3_ENCODING_UTF8)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Destination buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}



char *
dk3str_cnvnew_c8p_to_c8u_app(char const *s, dk3_app_t *app)
{
  char		*back = NULL;
  size_t	sz;		/* Number of characters produced. */
  if(s) {
    sz = dk3str_i_cnv_c8p(NULL, s, app, DK3_ENCODING_UTF8);
    if(sz) {
      back = dk3_new_app(char,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c8p((void *)back, s, app, DK3_ENCODING_UTF8)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}



size_t
dk3str_cnvsz_c8p_to_c16_app(char const *s, dk3_app_t *app)
{
  size_t back = 0;
  if(s) {
    back = dk3str_i_cnv_c8p(NULL, s, app, DK3_ENCODING_UTF16);
  }
  return back;
}



int
dk3str_cnv_c8p_to_c16_app(dk3_c16_t *d, size_t ds, char const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Destination buffer length needed. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c8p(NULL, s, app, DK3_ENCODING_UTF16);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c8p((void *)d, s, app, DK3_ENCODING_UTF16)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Destination buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}



dk3_c16_t *
dk3str_cnvnew_c8p_to_c16_app(char const *s, dk3_app_t *app)
{
  dk3_c16_t	*back = NULL;
  size_t	sz;		/* Destination buffer length needed. */
  if(s) {
    sz = dk3str_i_cnv_c8p(NULL, s, app, DK3_ENCODING_UTF16);
    if(sz) {
      back = dk3_new_app(dk3_c16_t,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c8p((void *)back, s, app, DK3_ENCODING_UTF16)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}



size_t
dk3str_cnvsz_c8p_to_c32_app(char const *s, dk3_app_t *app)
{
  size_t back = 0;
  if(s) {
    back = dk3str_i_cnv_c8p(NULL, s, app, DK3_ENCODING_UNICODE);
  }
  return back;
}



int
dk3str_cnv_c8p_to_c32_app(dk3_c32_t *d, size_t ds, char const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Destination buffer length needed. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c8p(NULL, s, app, DK3_ENCODING_UNICODE);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c8p((void *)d, s, app, DK3_ENCODING_UNICODE)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Destination buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}



dk3_c32_t *
dk3str_cnvnew_c8p_to_c32_app(char const *s, dk3_app_t *app)
{
  dk3_c32_t	*back = NULL;
  size_t	sz;		/* Destination buffer length needed. */
  if(s) {
    sz = dk3str_i_cnv_c8p(NULL, s, app, DK3_ENCODING_UNICODE);
    if(sz) {
      back = dk3_new_app(dk3_c32_t,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c8p((void *)back, s, app, DK3_ENCODING_UNICODE)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}



/**	Convert UTF-8 string to other encodings.
	@param	d	Destination pointer, may be NULL.
	@param	s	Source string.
	@param	app	Application structure for diagnostics, may be NULL.
	@param	enc	Destination encoding.
	@return	Buffer length used (d!=NULL) or needed (d==NULL).
*/
static
size_t
dk3str_i_cnv_c8u(void *d, char const *s, dk3_app_t *app, int enc)
{
  size_t		back = 0;
  int			error = 0;	/* Flag: Error occued. */
  char			*dp8 = NULL;	/* Pointer to 8-bit destination. */
  dk3_c16_t		*dp16 = NULL;	/* Pointer to 16-bit destination. */
  dk3_c32_t		*dp32 = NULL;	/* Pointer to 32-bit destination. */
  dk3_c16_t		myc16[16];	/* Conversion result buffer. */
  dk3_c32_t		c32 = 0UL;	/* Conversion result. */
  unsigned char		uc = 0x00;	/* Result character. */
  char			c = 0x00;	/* Current character to process. */
  unsigned char const	*sptr = NULL;	/* Source ponter. */
  size_t		u8u = 0;	/* Number of UTF-8 bytes used. */
  size_t		u16u = 0;	/* Number of UTF-16 chars produced. */
  size_t		i = 0;		/* Copy buffer to destination. */
  size_t		sl = 0;		/* Remaining source string length. */
  $? "+ dk3str_i_cnv_c8u \"%s\"", TR_STR(s)
  if(s) {
    /* Initialize variables */
    sptr = (unsigned char const *)s; sl = dk3str_c8_len(s);
    if(d) {
      switch(enc) {
        case DK3_ENCODING_PLAIN: { dp8 = (char *)d; } break;
	case DK3_ENCODING_UTF16: { dp16 = (dk3_c16_t *)d; } break;
	case DK3_ENCODING_UNICODE: { dp32 = (dk3_c32_t *)d; } break;
	default: {
	  if(0 == error) {
	    if(app) {
	      /* ERROR: Illegal output encoding! */
	      dk3app_log_i1(app, DK3_LL_ERROR, 114);
	    }
	  } error = 1;
	} break;
      }
    }
    /* Process input */
    while((sl) && (0 == error)) {
      u8u = 0;
      if(dk3enc_utf82uc(&c32, sptr, sl, &u8u)) {
        if(u8u) {
	  switch(enc) {
            case DK3_ENCODING_PLAIN: {
	      if(c32 < (dk3_c32_t)0x00000100UL) {
		back = dk3mem_add_size_t(back, 1, &error);
		if(d) {
	          uc = (unsigned char)c32;
		  c = (char)uc;
		  *(dp8++) = c;
		}
	      } else {
	        if(0 == error) {
		  if(app) {
		    /* ERROR: Result character out of range! */
		    dk3app_log_i1(app, DK3_LL_ERROR, 117);
		  }
		} error = 1;
	      }
	    } break;
	    case DK3_ENCODING_UTF16: {
	      u16u = dk3enc_uc2utf16(c32, myc16, 16);
	      if(u16u) {
		back = dk3mem_add_size_t(back, u16u, &error);
		if(d) {
		  for(i = 0; i < u16u; i++) { *(dp16++) = myc16[i]; }
		}
	      } else {
	        if(0 == error) {
		  if(app) {		$? "! conversion to UTF-16"
		    /* ERROR: Conversion to UTF-16 failed! */
		    dk3app_log_i1(app, DK3_LL_ERROR, 116);
		  }
		} error = 1;
	      }
	    } break;
	    case DK3_ENCODING_UNICODE: {
	      back = dk3mem_add_size_t(back, 1, &error);
	      if(d) { *(dp32++) = c32; }
	    } break;
	  }
	  if(sl >= u8u) {
	    sl = sl - u8u;
	    sptr = &(sptr[u8u]);
	  } else {
	    sl = 0;
	  }
	} else {
	  if(0 == error) {
	    if(app) {
	      /* ERROR: UTF-8 decode operation failed! */
	      dk3app_log_i1(app, DK3_LL_ERROR, 118);
	    }
	  } error = 1;
	}
      } else {
        if(0 == error) {
	  if(app) {
	    /* ERROR: UTF-8 decode operation failed! */
	    dk3app_log_i1(app, DK3_LL_ERROR, 118);
	  }
	} error = 1;
      }
    }
    /* Finalize output */
    back = dk3mem_add_size_t(back, 1, &error);
    if(d) {
      switch(enc) {
        case DK3_ENCODING_PLAIN: { *dp8 = '\0'; } break;
	case DK3_ENCODING_UTF16: { *dp16 = 0U; } break;
	case DK3_ENCODING_UNICODE: { *dp32 = 0UL; } break;
      }
    }
    if(error) {
      back = 0;
      if(error == DK3_ERROR_MATH_OVERFLOW) {
        if(app) {
	  /* ERROR: Input string too long for conversion! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 108);
	}
      }
    }
  } $? "- dk3str_i_cnv_c8u %u", (unsigned)back
  return back;
}



size_t
dk3str_cnvsz_c8u_to_c8p_app(char const *s, dk3_app_t *app)
{
  size_t back = 0;
  if(s) {
    back = dk3str_i_cnv_c8u(NULL, s, app, DK3_ENCODING_PLAIN);
  }
  return back;
}



int
dk3str_cnv_c8u_to_c8p_app(char *d, size_t ds, char const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Destination buffer length needed. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c8u(NULL, s, app, DK3_ENCODING_PLAIN);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c8u((void *)d, s, app, DK3_ENCODING_PLAIN)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Destination buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}


char *
dk3str_cnvnew_c8u_to_c8p_app(char const *s, dk3_app_t *app)
{
  char		*back = NULL;
  size_t	sz;		/* Destination buffer length needed. */
  if(s) {
    sz = dk3str_i_cnv_c8u(NULL, s, app, DK3_ENCODING_PLAIN);
    if(sz) {
      back = dk3_new_app(char,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c8u((void *)back, s, app, DK3_ENCODING_PLAIN)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}




size_t
dk3str_cnvsz_c8u_to_c16_app(char const *s, dk3_app_t *app)
{
  size_t back = 0;
  if(s) {
    back = dk3str_i_cnv_c8u(NULL, s, app, DK3_ENCODING_UTF16);
  }
  return back;
}



int
dk3str_cnv_c8u_to_c16_app(dk3_c16_t *d, size_t ds, char const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Destination buffer length needed. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c8u(NULL, s, app, DK3_ENCODING_UTF16);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c8u((void *)d, s, app, DK3_ENCODING_UTF16)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Destination buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}



dk3_c16_t *
dk3str_cnvnew_c8u_to_c16_app(char const *s, dk3_app_t *app)
{
  dk3_c16_t	*back = NULL;
  size_t	sz;		/* Destination buffer length needed. */
  if(s) {
    sz = dk3str_i_cnv_c8u(NULL, s, app, DK3_ENCODING_UTF16);
    if(sz) {
      back = dk3_new_app(dk3_c16_t,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c8u((void *)back, s, app, DK3_ENCODING_UTF16)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}



size_t
dk3str_cnvsz_c8u_to_c32_app(char const *s, dk3_app_t *app)
{
  size_t back = 0;
  $? "+ dk3str_cnvsz_c8u_to_c32_app \"%s\"", s
  if(s) {
    back = dk3str_i_cnv_c8u(NULL, s, app, DK3_ENCODING_UNICODE);
  } $? "- dk3str_cnvsz_c8u_to_c32_app %u", (unsigned)back
  return back;
}



int
dk3str_cnv_c8u_to_c32_app(dk3_c32_t *d, size_t ds, char const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Destination buffer length needed. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c8u(NULL, s, app, DK3_ENCODING_UNICODE);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c8u((void *)d, s, app, DK3_ENCODING_UNICODE)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Destination buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}



dk3_c32_t *
dk3str_cnvnew_c8u_to_c32_app(char const *s, dk3_app_t *app)
{
  dk3_c32_t	*back = NULL;
  size_t	sz;		/* Destination buffer length needed. */
  if(s) {
    sz = dk3str_i_cnv_c8u(NULL, s, app, DK3_ENCODING_UNICODE);
    if(sz) {
      back = dk3_new_app(dk3_c32_t,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c8u((void *)back, s, app, DK3_ENCODING_UNICODE)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}



/**	Convert 16-bit character string to other encodings.
	@param	d	Destination pointer (NULL for size check).
	@param	s	Source string.
	@param	app	Application structure for diagnostics.
	@param	enc	Destination encoding.
	@return	Number of destination characters needed/produced.
*/
static
size_t
dk3str_i_cnv_c16(void *d, dk3_c16_t const *s, dk3_app_t *app, int enc)
{
  size_t		back = 0;
  int			error = 0;	/* Flag: Error occured. */
  char			*dp8 = NULL;	/* Pointer to 8-bit destination. */
  dk3_c32_t		*dp32 = NULL;	/* Pointer to 32-bit destination. */
  dk3_c16_t const	*sptr = NULL;	/* Source pointer. */
  dk3_c32_t		c32 = 0UL;	/* Conversion result. */
  unsigned char		uc = 0x00;	/* Current output character. */
  char			c = 0x00;	/* Current output character. */
  unsigned char		myuc[16];	/* Conversion result buffer. */
  size_t		sl = 0;		/* Remaining string length. */
  size_t		u16u = 0;	/* Number of U16 characters used. */
  size_t		u8u = 0;	/* Number of 8-bit chars produced. */
  size_t		i = 0;		/* Copy buffer to destination. */
  if(s) {
    /* Initialize variables */
    sptr = s; sl = dk3str_c16_len(s);
    if(d) {
      switch(enc) {
        case DK3_ENCODING_PLAIN: { dp8 = (char *)d; } break;
	case DK3_ENCODING_UTF8:	{ dp8 = (char *)d; } break;
	case DK3_ENCODING_UNICODE: { dp32 = (dk3_c32_t *)d; } break;
	default: {
	  if(0 == error) {
	    if(app) {
	      /* ERROR: Illegal output encoding! */
	      dk3app_log_i1(app, DK3_LL_ERROR, 114);
	    }
	  } error = 1;
	} break;
      }
    }
    /* Process input */
    while((sl) && (0 == error)) {
      u16u = 0;
      if(dk3enc_utf162uc(&c32, sptr, sl, &u16u)) {
        if(u16u) {
	  if(sl >= u16u) {
	    switch(enc) {
              case DK3_ENCODING_PLAIN: {
	        if(c32 < (dk3_c32_t)0x00000100UL) {
		  back = dk3mem_add_size_t(back, 1, &error);
		  if(d) {
		    uc = (unsigned char)c32; c = (char)uc;
		    *(dp8++) = c;
		  }
		} else {
		  if(0 == error) {
		    if(app) {
		      /* ERROR: Result character out of range! */
		      dk3app_log_i1(app, DK3_LL_ERROR, 117);
		    }
		  } error = 1;
		}
	      } break;
	      case DK3_ENCODING_UTF8:	{
	        u8u = dk3enc_uc2utf8(c32, myuc, 16);
		if(u8u) {
		  back = dk3mem_add_size_t(back, u8u, &error);
		  if(d) {
		    for(i = 0; i < u8u; i++) { *(dp8++) = myuc[i]; }
		  }
		} else {
		  if(0 == error) {
		    if(app) {
		      /* ERROR: Conversion to UTF-8 failed! */
		      dk3app_log_i1(app, DK3_LL_ERROR, 115);
		    }
		  } error = 1;
		}
	      } break;
	      case DK3_ENCODING_UNICODE: {
		back = dk3mem_add_size_t(back, 1, &error);
		if(d) { *(dp32++) = c32; }
	      } break;
	    }
	    sl = sl - u16u;
	    sptr = &(sptr[u16u]);
	  } else {
	    sl = 0;
	  }
	} else {
	  if(0 == error) {
	    if(app) {
	      /* ERROR: UTF-16 decode operation failed! */
	      dk3app_log_i1(app, DK3_LL_ERROR, 119);
	    }
	  } error = 1;
	}
      } else {
        if(0 == error) {
	  if(app) {
	    /* ERROR: UTF-16 decode operation failed! */
	    dk3app_log_i1(app, DK3_LL_ERROR, 119);
	  }
	} error = 1;
      }
    }
    /* Finalize output */
    back = dk3mem_add_size_t(back, 1, &error);
    if(d) {
      switch(enc) {
        case DK3_ENCODING_PLAIN: { *dp8 = '\0'; } break;
	case DK3_ENCODING_UTF8:	{ *dp8 = '\0'; } break;
	case DK3_ENCODING_UNICODE: { *dp32 = 0UL; } break;
      }
    }
    if(error) {
      back = 0;
      if(error == DK3_ERROR_MATH_OVERFLOW) {
        if(app) {
	  /* ERROR: Input string too long for conversion! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 108);
	}
      }
    }
  }
  return back;
}



size_t
dk3str_cnvsz_c16_to_c8p_app(dk3_c16_t const *s, dk3_app_t *app)
{
  size_t back = 0;
  if(s) {
    back = dk3str_i_cnv_c16(NULL, s, app, DK3_ENCODING_PLAIN);
  }
  return back;
}



int
dk3str_cnv_c16_to_c8p_app(char *d, size_t ds, dk3_c16_t const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Destination buffer size needed. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c16(NULL, s, app, DK3_ENCODING_PLAIN);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c16((void *)d, s, app, DK3_ENCODING_PLAIN)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Result buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}



char *
dk3str_cnvnew_c16_to_c8p_app(dk3_c16_t const *s, dk3_app_t *app)
{
  char		*back = NULL;
  size_t	sz;		/* Destination buffer size needed. */
  if(s) {
    sz = dk3str_i_cnv_c16(NULL, s, app, DK3_ENCODING_PLAIN);
    if(sz) {
      back = dk3_new_app(char,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c16((void *)back, s, app, DK3_ENCODING_PLAIN)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}



size_t
dk3str_cnvsz_c16_to_c8u_app(dk3_c16_t const *s, dk3_app_t *app)
{
  size_t back = 0;
  if(s) {
    back = dk3str_i_cnv_c16(NULL, s, app, DK3_ENCODING_UTF8);
  }
  return back;
}



int
dk3str_cnv_c16_to_c8u_app(char *d, size_t ds, dk3_c16_t const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Destination buffer size needed. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c16(NULL, s, app, DK3_ENCODING_UTF8);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c16((void *)d, s, app, DK3_ENCODING_UTF8)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Result buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}


char *
dk3str_cnvnew_c16_to_c8u_app(dk3_c16_t const *s, dk3_app_t *app)
{
  char		*back = NULL;
  size_t	sz;		/* Destination buffer size needed. */
  if(s) {
    sz = dk3str_i_cnv_c16(NULL, s, app, DK3_ENCODING_UTF8);
    if(sz) {
      back = dk3_new_app(char,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c16((void *)back, s, app, DK3_ENCODING_UTF8)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}



int
dk3str_c16_to_c8_simple_app(
  char *d, size_t sz, dk3_c16_t const *s, dk3_app_t *app
)
{
  int back = 0;
  dk3_c16_t const *ptr;	/* Source pointer. */
  dk3_c16_t c;		/* Source character. */
  unsigned char uc;	/* Destination character. */
  char *dptr;		/* Destination pointer. */

  if((d) && (sz) && (s)) {
    if(dk3str_c16_len(s) < sz) {
      back = 1; ptr = s; dptr = d;
      while(0U != (c = *ptr)) {
        if(c < 0x0100U) {
	  uc = (unsigned char)c;
	  *(dptr++) = (char)uc;
	} else {
	  if((back == 1) && (app)) {
	    /* ERROR: Illegal character(s) in source string! */
	    dk3app_log_i1(app, DK3_LL_ERROR, 112);
	  }
	  back = 0;
	}
        ptr++;
      }
      *dptr = '\0';
    } else {
      d[0] = '\0';
      if(app) {
        /* ERROR: Source string too long! */ 
	dk3app_log_i1(app, DK3_LL_ERROR, 108);
      }
    }
  }
  return back;
}


size_t
dk3str_cnvsz_c16_to_c32_app(dk3_c16_t const *s, dk3_app_t *app)
{
  size_t back = 0;
  if(s) {
    back = dk3str_i_cnv_c16(NULL, s, app, DK3_ENCODING_UNICODE);
  }
  return back;
}



int
dk3str_cnv_c16_to_c32_app(dk3_c32_t *d, size_t ds, dk3_c16_t const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Destination buffer size needed. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c16(NULL, s, app, DK3_ENCODING_UNICODE);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c16((void *)d, s, app, DK3_ENCODING_UNICODE)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Result buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}



dk3_c32_t *
dk3str_cnvnew_c16_to_c32_app(dk3_c16_t const *s, dk3_app_t *app)
{
  dk3_c32_t	*back = NULL;
  size_t	sz;		/* Destination buffer size needed. */
  if(s) {
    sz = dk3str_i_cnv_c16(NULL, s, app, DK3_ENCODING_UNICODE);
    if(sz) {
      back = dk3_new_app(dk3_c32_t,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c16((void *)back, s, app, DK3_ENCODING_UNICODE)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}



/**	Convert 32-bit character string to other encodings.
	@param	d	Destination buffer pointer (may be NULL for size check).
	@param	s	Source string.
	@param	app	Application structure for diagnostics.
	@param	enc	Output encoding.
	@return	Number of destination characters produced/needed.
*/
static
size_t
dk3str_i_cnv_c32(void *d, dk3_c32_t const *s, dk3_app_t *app, int enc)
{
  size_t		back = 0;
  int			error = 0;	/* Flag: Error occured. */
  char			*dp8 = NULL;	/* Pointer to 8-bit destination. */
  dk3_c16_t		*dp16 = NULL;	/* Pointer to 16-bit destination. */
  dk3_c32_t const	*sptr = NULL;	/* Source pointer. */
  dk3_c32_t		c32 = 0UL;	/* Current character to process. */
  dk3_c16_t		myc16[16];	/* Conversion result buffer. */
  unsigned char		myuc[16];	/* Conversion result buffer. */
  unsigned char		uc = 0x00;	/* Output character. */
  char			c = 0x00;	/* Output character. */
  size_t		sl = 0;		/* Remaining string length. */
  size_t		u8u = 0;	/* Number of UTF-8 chars produced. */
  size_t		u16u = 0;	/* Numer of UTF-16 chars produced. */
  size_t		i = 0;		/* Copy buffer to destination. */
  $? "+ dk3str_i_cnv_c32"
  if(s) {
    /* Initialize variables */
    sptr = s; sl = dk3str_c32_len(s);
    if(d) {
      switch(enc) {
        case DK3_ENCODING_PLAIN: { dp8 = (char *)d; } break;
	case DK3_ENCODING_UTF8: { dp8 = (char *)d; } break;
	case DK3_ENCODING_UTF16: { dp16 = (dk3_c16_t *)d; } break;
	default: {
	  if(0 == error) {
	    if(app) {
	      /* ERROR: Illegal output encoding! */
	      dk3app_log_i1(app, DK3_LL_ERROR, 114);
	    }
	  } error = 1;
	} break;
      }
    }
    /* Process input */
    while((sl) && (0 == error)) {
      c32 = *(sptr++); sl--;
      switch(enc) {
        case DK3_ENCODING_PLAIN: {
	  if(c32 < (dk3_c32_t)0x00000100UL) {
	    back = dk3mem_add_size_t(back, 1, &error);
	    if(d) {
	      uc = (unsigned char)c32; c = (char)uc;
	      *(dp8++) = c;
	    }
	  } else {
	    if(0 == error) {
	      if(app) {
	        /* ERROR: Output character out of range! */
		dk3app_log_i1(app, DK3_LL_ERROR, 117);
	      }
	    } error = 1;
	  }
	} break;
	case DK3_ENCODING_UTF8: {
	  u8u = dk3enc_uc2utf8(c32, myuc, 16);
	  if(u8u) {
	    back = dk3mem_add_size_t(back, u8u, &error);
	    if(d) {
	      for(i = 0; i < u8u; i++) { *(dp8++) = myuc[i]; }
	    }
	  } else {
	    if(0 == error) {
	      if(app) {
	        /* ERROR: UTF-8 encoding failed! */
		dk3app_log_i1(app, DK3_LL_ERROR, 115);
	      }
	    } error = 1;
	  }
	} break;
	case DK3_ENCODING_UTF16: {
	  u16u = dk3enc_uc2utf16(c32, myc16, 16);
	  if(u16u) {
	    back = dk3mem_add_size_t(back, u16u, &error);
	    if(d) {
	      for(i = 0; i < u16u; i++) { *(dp16++) = myc16[i]; }
	    }
	  } else {
	    if(0 == error) {
	      if(app) {		$? "! conversion to UTF-16"
	        /* ERROR: Conversion to UTF-16 failed! */
		dk3app_log_i1(app, DK3_LL_ERROR, 116);
	      }
	    } error = 1;
	  }
	} break;
      }
    }
    /* Finalize output */
    back = dk3mem_add_size_t(back, 1, &error);
    if(d) {
      switch(enc) {
        case DK3_ENCODING_PLAIN: { *dp8 = '\0'; } break;
	case DK3_ENCODING_UTF8: { *dp8 = '\0'; } break;
	case DK3_ENCODING_UTF16: { *dp16 = 0U; } break;
      }
    }
    if(error) {
      back = 0;
      if(error == DK3_ERROR_MATH_OVERFLOW) {
        if(app) {
	  /* ERROR: Input string too long for conversion! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 108);
	}
      }
    }
  } $? "- dk3str_i_cnv_c32 %u", (unsigned)back
  return back;
}



size_t
dk3str_cnvsz_c32_to_c8p_app(dk3_c32_t const *s, dk3_app_t *app)
{
  size_t back = 0;
  if(s) {
    back = dk3str_i_cnv_c32(NULL, s, app, DK3_ENCODING_PLAIN);
  }
  return back;
}



int
dk3str_cnv_c32_to_c8p_app(char *d, size_t ds, dk3_c32_t const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Destination buffer size needed. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c32(NULL, s, app, DK3_ENCODING_PLAIN);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c32((void *)d, s, app, DK3_ENCODING_PLAIN)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Destination buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}



char *
dk3str_cnvnew_c32_to_c8p_app(dk3_c32_t const *s, dk3_app_t *app)
{
  char		*back = NULL;
  size_t	sz;		/* Destination buffer size needed. */
  if(s) {
    sz = dk3str_i_cnv_c32(NULL, s, app, DK3_ENCODING_PLAIN);
    if(sz) {
      back = dk3_new_app(char,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c32((void *)back, s, app, DK3_ENCODING_PLAIN)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}



size_t
dk3str_cnvsz_c32_to_c8u_app(dk3_c32_t const *s, dk3_app_t *app)
{
  size_t back = 0;
  if(s) {
    back = dk3str_i_cnv_c32(NULL, s, app, DK3_ENCODING_UTF8);
  }
  return back;
}



int
dk3str_cnv_c32_to_c8u_app(char *d, size_t ds, dk3_c32_t const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Destination buffer size needed. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c32(NULL, s, app, DK3_ENCODING_UTF8);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c32((void *)d, s, app, DK3_ENCODING_UTF8)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Destination buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}



char *
dk3str_cnvnew_c32_to_c8u_app(dk3_c32_t const *s, dk3_app_t *app)
{
  char		*back = NULL;
  size_t	sz;		/* Destination buffer size needed. */
  if(s) {
    sz = dk3str_i_cnv_c32(NULL, s, app, DK3_ENCODING_UTF8);
    if(sz) {
      back = dk3_new_app(char,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c32((void *)back, s, app, DK3_ENCODING_UTF8)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}



size_t
dk3str_cnvsz_c32_to_c16_app(dk3_c32_t const *s, dk3_app_t *app)
{
  size_t back = 0;
  if(s) {
    back = dk3str_i_cnv_c32(NULL, s, app, DK3_ENCODING_UTF16);
  }
  return back;
}



int
dk3str_cnv_c32_to_c16_app(dk3_c16_t *d, size_t ds, dk3_c32_t const *s, dk3_app_t *app)
{
  int		back = 0;
  size_t	sz;		/* Destination buffer size needed. */
  if((d) && (ds) && (s)) {
    sz = dk3str_i_cnv_c32(NULL, s, app, DK3_ENCODING_UTF16);
    if(sz) {
      if(ds >= sz) {
        if(dk3str_i_cnv_c32((void *)d, s, app, DK3_ENCODING_UTF16)) {
	  back = 1;
	}
      } else {
        if(app) {
	  /* ERROR: Destination buffer too small! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 38);
	}
      }
    }
  }
  return back;
}



dk3_c16_t *
dk3str_cnvnew_c32_to_c16_app(dk3_c32_t const *s, dk3_app_t *app)
{
  dk3_c16_t	*back = NULL;
  size_t	sz;		/* Destination buffer size needed. */
  if(s) {
    sz = dk3str_i_cnv_c32(NULL, s, app, DK3_ENCODING_UTF16);
    if(sz) {
      back = dk3_new_app(dk3_c16_t,sz,app);
      if(back) {
        if(!dk3str_i_cnv_c32((void *)back, s, app, DK3_ENCODING_UTF16)) {
	  dk3_delete(back); back = NULL;
	}
      }
    }
  }
  return back;
}



int
dk3str_cnv_c8_to_str_app(dkChar *d, size_t sz, char const *s, dk3_app_t *app)
{
  register int		back = 0;
  register size_t	l;		/* Number of destination chars used. */
  register char const	*sptr;		/* Source pointer. */
  register dkChar	*dptr;		/* Destination pointer. */
  register char		x = 0x00;	/* Current character to process. */

  if((d) && (sz) && (s)) {
    sptr = s; dptr = d; l = 0; back = 1;
    while((*sptr) && (l < (sz - 1))) {
      x = *(sptr++);
      *(dptr++) = (dkChar)x;
      l++;
    }
    *dptr = (dkChar)'\0';
    if(*sptr) {
      back = 0;
      if(app) {
        /* ERROR: Destination buffer too small! */
	dk3app_log_i1(app, DK3_LL_ERROR, 38);
      }
    }
  }
  return back;
}



int
dk3str_string_to_c8_simple_app(char *db,size_t sz,dkChar const *s,dk3_app_t *ap)
{
  int			back = 0;
  register dkChar const	*sptr;		/* Source pointer. */
  register dkChar	x;		/* Current source character. */
  register char		*dptr;		/* Destination pointer. */

  if((db) && (sz) && (s)) {
    if(dk3str_len(s) < sz) {
      back = 1;
      sptr = s; dptr = db;
      while(*sptr) {
        x = *(sptr++);
	*(dptr++) = (char)x;
#if DK3_CHAR_SIZE > 1
	if(x > (dkChar)0xFF) {
	  back = 0;
	}
#endif
      }
      *dptr = '\0';
      if(!(back)) {
        if(ap) {
	  /* ERROR: Non-ISO-LATIN-1 characters found! */
	  dk3app_log_i1(ap, DK3_LL_ERROR, 219);
	}
      }
    } else {
      if(ap) {
        /* ERROR: Destination buffer too short! */
	dk3app_log_i1(ap, DK3_LL_ERROR, 38);
      }
    }
  }
  return back;
}



void
dk3str_string_tolower(dkChar *s)
{
  dkChar *ptr;	/* Pointer into string. */
  if(s) {
    ptr = s;
    while(*ptr) {
      *ptr = dk3str_tolower(*ptr);
      ptr++;
    }
  }
}



int
dk3str_c8_to_str_simple_app(
  dkChar *dp, size_t ds, char const *sp, dk3_app_t *app
)
{
  int		 back = 0;
  char const	*sptr;		/* Pointer into source buffer. */
  dkChar	*dptr;		/* Pointer into destination buffer. */
  size_t	 sz;		/* Required destination size. */
  if((dp) && (ds) && (sp)) {
    sz = dk3str_c8_len(sp);
    if(ds > sz) {
      back = 1; sptr = sp; dptr = dp;
      while(*sptr) { *(dptr++) = (dkChar)(*(sptr++)); }
      *dptr = dkT('\0');
    } else {
      if(app) {
        /* ERROR: Destination buffer too short! */
	dk3app_log_i1(app, DK3_LL_ERROR, 38);
      }
    }
  }
  return back;
}



int
dk3str_to_c8p_app(
  char *dp, size_t sz, dkChar const *src, int ie, dk3_app_t *app
)
{
  int back = 0;
  if((dp) && (sz) && (src)) {
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
    back = dk3str_cnv_c32_to_c8p_app(dp, sz, src, app);
#else
    back = dk3str_cnv_c16_to_c8p_app(dp, sz, src, app);
#endif
#else
    if(ie == DK3_ENCODING_PLAIN) {
      if(sz > dk3str_c8_len(src)) {
        dk3str_c8_cpy(dp, src);
	back = 1;
      }
    } else {
      back = dk3str_cnv_c8u_to_c8p_app(dp, sz, src, app);
    }
#endif
  }
  return back;
}



int
dk3str_to_c8u_app(
  char *dp, size_t sz, dkChar const *src, int ie, dk3_app_t *app
)
{
  int back = 0;
  if((dp) && (sz) && (src)) {
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
    back = dk3str_cnv_c32_to_c8u_app(dp, sz, src, app);
#else
    back = dk3str_cnv_c16_to_c8u_app(dp, sz, src, app);
#endif
#else
    if(ie == DK3_ENCODING_PLAIN) {
      back = dk3str_cnv_c8p_to_c8u_app(dp, sz, src, app);
    } else {
      if(sz > dk3str_c8_len(src)) {
        dk3str_c8_cpy(dp, src);
	back = 1;
      }
    }
#endif
  }
  return back;
}



int
dk3str_str_to_c8u_app(
  char		*d,
  size_t	 dsz,
  dkChar const	*s,
  int		 se,
  dk3_app_t	*app
)
{
  int		back = 0;
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
  back = dk3str_cnv_c32_to_c8u_app(d, dsz, s, app);
#else
  back = dk3str_cnv_c16_to_c8u_app(d, dsz, s, app);
#endif
#else
  switch(se) {
    case DK3_ENCODING_UTF8: {
      if(dk3str_c8_len(s) < dsz) {
        dk3str_c8_cpy(d, s);
	back = 1;
      } else {
        if(app) {
	  /* ERROR: String too long! */
	  dk3app_log_i1(app, DK3_LL_ERROR, 108);
	}
      }
    } break;
    default: {
      back = dk3str_cnv_c8p_to_c8u_app(d, dsz, s, app);
    } break;
  }
#endif
  return back;
}



int
dk3str_c8u_to_str_app(
  dkChar 		*d,
  size_t		 dsz,
  int			 de,
  char const		*s,
  dk3_app_t		*app
)
{
  int		 back = 0;
  $? "+ dk3str_c8u_to_str_app"
  if((d) && (dsz) && (s)) {
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
    $? ". 32-bit"
    back = dk3str_cnv_c8u_to_c32_app(d, dsz, s, app);
#else
    $? ". 16-bit"
    back = dk3str_cnv_c8u_to_c16_app(d, dsz, s, app);
#endif
#else
    switch(de) {
      case DK3_ENCODING_UTF8: {
        $? ". UTF-8"
        if(dsz > dk3str_c8_len(s)) {
	  dk3str_c8_cpy(d, s);
	  back = 1;
	} else {
	  if(app) {
	    /* ERROR: Source string too long! */
	    dk3app_log_i1(app, DK3_LL_ERROR, 108);
	  }
	}
      } break;
      default: {
        $? ". LATIN-1"
        back = dk3str_cnv_c8u_to_c8p_app(d, dsz, s, app);
      } break;
    }
#endif
  } $? "- dk3str_c8u_to_str_app %d", back
  return back;
}



int
dk3str_to_c8_app(char *dp, size_t szdp, dkChar const *src, dk3_app_t *app)
{
  int		 back = 0;
  $? "+ dk3str_to_c8_app"
  if((dp) && (szdp) && (src)) {
#if DK3_CHAR_SIZE > 1
#if DK3_CHAR_SIZE > 2
    back = dk3str_cnv_c32_to_c8p_app(dp, szdp, src, app);
#else
    back = dk3str_cnv_c16_to_c8p_app(dp, szdp, src, app);
#endif
#else
    if(strlen(src) < szdp) {
      strcpy(dp, src);
      back = 1;
    } else {
      /* ERROR: Destination buffer too small! */
      dk3app_log_i1(app, DK3_LL_ERROR, 38);
    }
#endif
  } $? "- dk3str_to_c8_app %d", back
  return back;
}






/* vim: set ai sw=2 : */