diff options
author | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
---|---|---|
committer | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
commit | e0c6872cf40896c7be36b11dcc744620f10adf1d (patch) | |
tree | 60335e10d2f4354b0674ec22d7b53f0f8abee672 /support/dktools/dk3str.c |
Initial commit
Diffstat (limited to 'support/dktools/dk3str.c')
-rw-r--r-- | support/dktools/dk3str.c | 4640 |
1 files changed, 4640 insertions, 0 deletions
diff --git a/support/dktools/dk3str.c b/support/dktools/dk3str.c new file mode 100644 index 0000000000..4b6067158f --- /dev/null +++ b/support/dktools/dk3str.c @@ -0,0 +1,4640 @@ +/* + WARNING: This file was generated by dkct. + Changes you make here will be lost if dkct is run again! + You should modify the original source and run dkct on it. + Original source: dk3str.ctr +*/ + +/* +Copyright (C) 2011-2017, Dirk Krause + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above opyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. +* Neither the name of the author nor the names of contributors may be used + to endorse or promote products derived from this software without specific + prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/** @file dk3str.c The dk3str module. +*/ + + +#line 1426 "dk3str.ctr" + +#include "dk3all.h" + + + + +#line 1431 "dk3str.ctr" + + +/* ************************************************************************ */ +/* * * */ +/* * Static data * */ +/* * * */ +/* ************************************************************************ */ + + +#line 1436 "dk3str.ctr" + + +/** 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. */ + + +#line 1850 "dk3str.ctr" + 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; + } + } + } + } + +#line 1869 "dk3str.ctr" +#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. */ + + +#line 2855 "dk3str.ctr" + 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; + } + } + } + +#line 2866 "dk3str.ctr" + 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. */ + + +#line 2901 "dk3str.ctr" + 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; + } + } + } + +#line 2912 "dk3str.ctr" + 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. */ + + +#line 2941 "dk3str.ctr" + 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++; + } + } + } + +#line 2960 "dk3str.ctr" + 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. */ + + +#line 3004 "dk3str.ctr" + if(str) { + ptr = str; + wh = (whsp ? whsp : c32_def_whsp); + state = 0; + while((state < 2) && (*ptr)) { + if(dk3str_c32_chr(wh, *ptr)) { + +#line 3010 "dk3str.ctr" + if(state == 1) { + state = 2; + *(ptr++) = 0UL; + back = dk3str_c32_start(ptr, wh); + } else { + ptr++; + } + } else { + state = 1; ptr++; + } + } + } + +#line 3022 "dk3str.ctr" + 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. */ + + +#line 3050 "dk3str.ctr" + 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'; } + } + + +#line 3064 "dk3str.ctr" +} + + + +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. */ + + +#line 3320 "dk3str.ctr" + 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; + } + } + } + } + + +#line 3352 "dk3str.ctr" + 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. */ + + +#line 3472 "dk3str.ctr" + if((ar) && (str)) { + i = 0; ptr = ar; + while((*ptr) && (back == -1)) { + + +#line 3476 "dk3str.ctr" + if(dk3str_c8_is_abbr(str, *ptr, sp, cs)) { + back = i; + } + if(back == -1) { + ptr++; i++; + } + + +#line 3483 "dk3str.ctr" + } + } + +#line 3485 "dk3str.ctr" + 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. */ + + +#line 3497 "dk3str.ctr" + if((arr) && (str)) { + +#line 3498 "dk3str.ctr" + i = 0; ptr = arr; + while((*ptr) && (back == -1)) { + +#line 3500 "dk3str.ctr" + if(dk3str_c16_is_abbr(str, *ptr, sp, cs)) { + +#line 3501 "dk3str.ctr" + back = i; + } else { + +#line 3503 "dk3str.ctr" + } + if(back == -1) { + ptr++; i++; + } + +#line 3507 "dk3str.ctr" + } + +#line 3508 "dk3str.ctr" + } + +#line 3509 "dk3str.ctr" + 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. */ + + +#line 3558 "dk3str.ctr" + if(str) { + if(dk3str_c8_array_abbr(dk3str_c8_bool_kw,str,'$',0) >= 0) { + back = 1; + } + } + +#line 3563 "dk3str.ctr" + 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. */ + + +#line 3631 "dk3str.ctr" + if(str) { + if(dk3str_c8_array_abbr(dk3str_c8_bool_kw,str,'$',0) >= INDEX_OF_FIRST_BOOLEAN_TRUE) { + back = 1; + } + } + +#line 3636 "dk3str.ctr" + 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, dk3_c16_t 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, dk3_c32_t 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; + + +#line 3984 "dk3str.ctr" + 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 + } + } + +#line 4001 "dk3str.ctr" + 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. */ + + + +#line 4178 "dk3str.ctr" + if((d) && (sz) && (n)) { + if(dk3str_c32_is_abs_path(n)) { + +#line 4180 "dk3str.ctr" + 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 { + +#line 4190 "dk3str.ctr" + 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) { + +#line 4233 "dk3str.ctr" + } + +#line 4234 "dk3str.ctr" + 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. */ + + +#line 4411 "dk3str.ctr" + 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) { + +#line 4458 "dk3str.ctr" + /* 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); + } + } + } + } + +#line 4488 "dk3str.ctr" + 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. */ + + +#line 4693 "dk3str.ctr" + 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) { + +#line 4744 "dk3str.ctr" + /* 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); + } + } + } + } + +#line 4797 "dk3str.ctr" + 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; + + +#line 4923 "dk3str.ctr" + if(s) { + back = dk3str_i_cnv_c8u(NULL, s, app, DK3_ENCODING_UNICODE); + } + +#line 4926 "dk3str.ctr" + 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. */ + + +#line 5348 "dk3str.ctr" + 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) { + +#line 5412 "dk3str.ctr" + /* 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); + } + } + } + } + +#line 5439 "dk3str.ctr" + 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; + + +#line 5838 "dk3str.ctr" + if((d) && (dsz) && (s)) { +#if DK3_CHAR_SIZE > 1 +#if DK3_CHAR_SIZE > 2 + + +#line 5842 "dk3str.ctr" + back = dk3str_cnv_c8u_to_c32_app(d, dsz, s, app); +#else + + +#line 5845 "dk3str.ctr" + back = dk3str_cnv_c8u_to_c16_app(d, dsz, s, app); +#endif +#else + switch(de) { + case DK3_ENCODING_UTF8: { + + +#line 5851 "dk3str.ctr" + 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: { + + +#line 5863 "dk3str.ctr" + back = dk3str_cnv_c8u_to_c8p_app(d, dsz, s, app); + } break; + } +#endif + } + +#line 5868 "dk3str.ctr" + return back; +} + + + +int +dk3str_to_c8_app(char *dp, size_t szdp, dkChar const *src, dk3_app_t *app) +{ + int back = 0; + + +#line 5878 "dk3str.ctr" + 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 + } + +#line 5895 "dk3str.ctr" + return back; +} + + + + + + +/* vim: set ai sw=2 : */ + |