883 lines
22 KiB
C++
883 lines
22 KiB
C++
//#pragma title( "UString.hpp - Common string and character functions" )
|
|
/*
|
|
Copyright (c) 1995-1998, Mission Critical Software, Inc. All rights reserved.
|
|
===============================================================================
|
|
Module - UString.hpp
|
|
System - Common
|
|
Author - Tom Bernhardt, Rich Denham
|
|
Created - 1995-08-25
|
|
Description - Common string and character functions.
|
|
Many string and character functions defined in "string.h" are redefined
|
|
here as overloaded inline functions with several extensions:
|
|
o Both ANSI and UNICODE strings are supported.
|
|
o Both ANSI and UNICODE characters are supported.
|
|
o For ANSI, characters can be "char signed" or "char unsigned".
|
|
o Functions that allow a length field, such as "lstrcpy" vs "lstrcpyn",
|
|
are implemented as overloaded functions with optional arguments.
|
|
o Some functions, UStrCpy in particular, can perform conversion between
|
|
ANSI and UNICODE strings.
|
|
The function names defined here consist of "U" concatenated to the base
|
|
name from "string.h". The first letter of words or word abbreviations
|
|
are capitalized, e.g. "strcpy" becomes "UStrCpy".
|
|
Updates -
|
|
===============================================================================
|
|
*/
|
|
|
|
#ifndef MCSINC_UString_hpp
|
|
#define MCSINC_UString_hpp
|
|
|
|
#define safecopy(trg,src) (UStrCpy(trg,src,DIM(trg)))
|
|
|
|
#ifdef WIN16_VERSION
|
|
#ifndef UCHAR
|
|
#define UCHAR unsigned char
|
|
#endif
|
|
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#endif // WIN16_VERSION
|
|
|
|
int _inline // ret-length in chars
|
|
UStrLen(
|
|
char const * s1 // in -ANSI string
|
|
)
|
|
{
|
|
return strlen( s1 );
|
|
}
|
|
|
|
|
|
int _inline // ret-length in chars
|
|
UStrLen(
|
|
UCHAR const * s1 // in -ANSI string
|
|
)
|
|
{
|
|
return strlen( (char const *) s1 );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
char * aTarget ,// out-ANSI target string
|
|
char const * aSource // in -ANSI source string
|
|
)
|
|
{
|
|
strcpy( aTarget, aSource );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
char * aTarget ,// out-ANSI target string
|
|
UCHAR const * aSource // in -ANSI source string
|
|
)
|
|
{
|
|
UStrCpy( aTarget, (char const *) aSource );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
UCHAR * aTarget ,// out-ANSI target string
|
|
char const * aSource // in -ANSI source string
|
|
)
|
|
{
|
|
UStrCpy( (char *) aTarget, aSource );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
UCHAR * aTarget ,// out-ANSI target string
|
|
UCHAR const * aSource // in -ANSI source string
|
|
)
|
|
{
|
|
UStrCpy( (char *) aTarget, (char const *) aSource );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
char * aTarget ,// out-ANSI target string
|
|
char const * aSource ,// in -ANSI source string
|
|
int len // in -copy length in chars
|
|
)
|
|
{
|
|
int copylen = UStrLen( aSource ) + 1;
|
|
|
|
copylen = min( copylen, len );
|
|
|
|
if ( copylen )
|
|
{
|
|
strncpy( aTarget, aSource, copylen );
|
|
aTarget[copylen-1] = '\0';
|
|
}
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
char * aTarget ,// out-ANSI target string
|
|
UCHAR const * aSource ,// in -ANSI source string
|
|
int len // in -copy length in chars
|
|
)
|
|
{
|
|
UStrCpy( aTarget, (char const *) aSource, len );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
UCHAR * aTarget ,// out-ANSI target string
|
|
char const * aSource ,// in -ANSI source string
|
|
int len // in -copy length in chars
|
|
)
|
|
{
|
|
UStrCpy( (char *) aTarget, aSource, len );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
UCHAR * aTarget ,// out-ANSI target string
|
|
UCHAR const * aSource ,// in -ANSI source string
|
|
int len // in -copy length in chars
|
|
)
|
|
{
|
|
UStrCpy( (char *) aTarget, (char const *) aSource, len );
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrCmp(
|
|
char const * s1 ,// in -ANSI string 1
|
|
char const * s2 // in -ANSI string 2
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strcmp( s1, s2 );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
s1,
|
|
-1,
|
|
s2,
|
|
-1 ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrCmp(
|
|
char const * s1 ,// in -ANSI string 1
|
|
UCHAR const * s2 // in -ANSI string 2
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strcmp( s1, (char const *) s2 );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
s1,
|
|
-1,
|
|
(char const *) s2,
|
|
-1 ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrCmp(
|
|
UCHAR const * s1 ,// in -ANSI string 1
|
|
char const * s2 // in -ANSI string 2
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strcmp( (char const *) s1, s2 );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
(char const *) s1,
|
|
-1,
|
|
s2,
|
|
-1 ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrCmp(
|
|
UCHAR const * s1 ,// in -ANSI string 1
|
|
UCHAR const * s2 // in -ANSI string 2
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strcmp( (char const *) s1, (char const *) s2 );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
(char const *) s1,
|
|
-1,
|
|
(char const *) s2,
|
|
-1 ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrCmp(
|
|
char const * s1 ,// in -ANSI string 1
|
|
char const * s2 ,// in -ANSI string 2
|
|
int len // in -compare length in chars
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strncmp( s1, s2, len );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
s1,
|
|
len,
|
|
s2,
|
|
len ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrCmp(
|
|
char const * s1 ,// in -ANSI string 1
|
|
UCHAR const * s2 ,// in -ANSI string 2
|
|
int len // in -compare length in chars
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strncmp( s1, (char const *) s2, len );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
s1,
|
|
len,
|
|
(char const *) s2,
|
|
len ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrCmp(
|
|
UCHAR const * s1 ,// in -ANSI string 1
|
|
char const * s2 ,// in -ANSI string 2
|
|
int len // in -compare length in chars
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strncmp( (char const *) s1, s2, len );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
(char const *) s1,
|
|
len,
|
|
s2,
|
|
len ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrCmp(
|
|
UCHAR const * s1 ,// in -ANSI string 1
|
|
UCHAR const * s2 ,// in -ANSI string 2
|
|
int len // in -compare length in chars
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strncmp( (char const *) s1, (char const *) s2, len );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
(char const *) s1,
|
|
len,
|
|
(char const *) s2,
|
|
len ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrICmp(
|
|
char const * s1 ,// in -ANSI string 1
|
|
char const * s2 // in -ANSI string 2
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return stricmp( s1, s2 );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
s1,
|
|
-1,
|
|
s2,
|
|
-1 ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrICmp(
|
|
char const * s1 ,// in -ANSI string 1
|
|
UCHAR const * s2 // in -ANSI string 2
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return stricmp( s1, (char const *) s2 );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
s1,
|
|
-1,
|
|
(char const *) s2,
|
|
-1 ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrICmp(
|
|
UCHAR const * s1 ,// in -ANSI string 1
|
|
char const * s2 // in -ANSI string 2
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return stricmp( (char const *) s1, s2 );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
(char const *) s1,
|
|
-1,
|
|
s2,
|
|
-1 ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrICmp(
|
|
UCHAR const * s1 ,// in -ANSI string 1
|
|
UCHAR const * s2 // in -ANSI string 2
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return stricmp( (char const *) s1, (char const *) s2 );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
(char const *) s1,
|
|
-1,
|
|
(char const *) s2,
|
|
-1 ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrICmp(
|
|
char const * s1 ,// in -ANSI string 1
|
|
char const * s2 ,// in -ANSI string 2
|
|
int len // in -compare length in chars
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strnicmp( s1, s2, len );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
s1,
|
|
len,
|
|
s2,
|
|
len ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrICmp(
|
|
char const * s1 ,// in -ANSI string 1
|
|
UCHAR const * s2 ,// in -ANSI string 2
|
|
int len // in -compare length in chars
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strnicmp( s1, (char const *) s2, len );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
s1,
|
|
len,
|
|
(char const *) s2,
|
|
len ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrICmp(
|
|
UCHAR const * s1 ,// in -ANSI string 1
|
|
char const * s2 ,// in -ANSI string 2
|
|
int len // in -compare length in chars
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strnicmp( (char const *) s1, s2, len );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
(char const *) s1,
|
|
len,
|
|
s2,
|
|
len ) - 2;
|
|
#endif
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrICmp(
|
|
UCHAR const * s1 ,// in -ANSI string 1
|
|
UCHAR const * s2 ,// in -ANSI string 2
|
|
int len // in -compare length in chars
|
|
)
|
|
{
|
|
#ifdef WIN16_VERSION
|
|
return strnicmp( (char const *) s1, (char const *) s2, len );
|
|
#else
|
|
return CompareStringA(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
(char const *) s1,
|
|
len,
|
|
(char const *) s2,
|
|
len ) - 2;
|
|
#endif
|
|
}
|
|
|
|
char _inline *
|
|
UStrLwr(
|
|
char * s // i/o-ANSI string
|
|
)
|
|
{
|
|
return strlwr( s );
|
|
}
|
|
|
|
UCHAR _inline *
|
|
UStrLwr(
|
|
UCHAR * s // i/o-ANSI string
|
|
)
|
|
{
|
|
return (UCHAR *) strlwr( (char *) s );
|
|
}
|
|
|
|
char _inline *
|
|
UStrUpr(
|
|
char * s // i/o-ANSI string
|
|
)
|
|
{
|
|
return strupr( s );
|
|
}
|
|
|
|
UCHAR _inline *
|
|
UStrUpr(
|
|
UCHAR * s // i/o-ANSI string
|
|
)
|
|
{
|
|
return (UCHAR *) strupr( (char *) s );
|
|
}
|
|
|
|
char _inline
|
|
UToLower(
|
|
char c // in -ANSI char
|
|
)
|
|
{
|
|
return tolower( c );
|
|
}
|
|
|
|
UCHAR _inline
|
|
UToLower(
|
|
UCHAR c // in -ANSI char
|
|
)
|
|
{
|
|
return tolower( (char) c );
|
|
}
|
|
|
|
char _inline
|
|
UToUpper(
|
|
char c // in -ANSI char
|
|
)
|
|
{
|
|
return toupper( c );
|
|
}
|
|
|
|
UCHAR _inline
|
|
UToUpper(
|
|
UCHAR c // in -ANSI char
|
|
)
|
|
{
|
|
return toupper( (char) c );
|
|
}
|
|
|
|
// Left-trim string in place
|
|
_inline UCHAR *
|
|
LTrim(
|
|
UCHAR * s // i/o-ANSI string
|
|
)
|
|
{
|
|
UCHAR * strorg = s;
|
|
|
|
while ( *strorg == ' ' )
|
|
strorg++;
|
|
if ( strorg > s )
|
|
{
|
|
while ( *(strorg-1) )
|
|
*s++ = *strorg++;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
_inline char *
|
|
LTrim(
|
|
char * s // i/o-ANSI string
|
|
)
|
|
{
|
|
return (char *) LTrim( (UCHAR *) s );
|
|
}
|
|
|
|
// Right-trim string in place
|
|
_inline UCHAR *
|
|
RTrim(
|
|
UCHAR * s // i/o-ANSI string
|
|
)
|
|
{
|
|
UCHAR * strend = s + UStrLen(s);
|
|
|
|
while ( (strend > s) && (*(strend-1) == ' ') )
|
|
strend--;
|
|
*strend = '\0';
|
|
return s;
|
|
}
|
|
|
|
_inline char *
|
|
RTrim(
|
|
char * s // i/o-ANSI string
|
|
)
|
|
{
|
|
return (char *) RTrim( (UCHAR *) s );
|
|
}
|
|
|
|
// Trim string in place
|
|
_inline UCHAR *
|
|
Trim(
|
|
UCHAR * s // i/o-ANSI string
|
|
)
|
|
{
|
|
return LTrim( RTrim( s ) );
|
|
}
|
|
|
|
_inline char *
|
|
Trim(
|
|
char * s // i/o-ANSI string
|
|
)
|
|
{
|
|
return LTrim( RTrim( s ) );
|
|
}
|
|
|
|
#ifndef WIN16_VERSION
|
|
|
|
int _inline // ret-length in chars
|
|
UStrLen(
|
|
WCHAR const * s1 // in -UNICODE string
|
|
)
|
|
{
|
|
return lstrlenW( s1 );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
char * aTarget ,// out-ANSI target string
|
|
WCHAR const * wSource // in -UNICODE source string
|
|
)
|
|
{
|
|
int copylen = UStrLen( wSource ) + 1;
|
|
|
|
if ( copylen )
|
|
{
|
|
WideCharToMultiByte( CP_ACP, 0, wSource, copylen, aTarget, copylen, NULL, NULL );
|
|
aTarget[copylen-1] = '\0';
|
|
}
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
UCHAR * aTarget ,// out-ANSI target string
|
|
WCHAR const * wSource // in -UNICODE source string
|
|
)
|
|
{
|
|
UStrCpy( (char *) aTarget, wSource );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
WCHAR * wTarget ,// out-UNICODE target string
|
|
char const * aSource // in -ANSI source string
|
|
)
|
|
{
|
|
int copylen = UStrLen( aSource ) + 1;
|
|
|
|
if ( copylen )
|
|
{
|
|
MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, aSource, copylen, wTarget, copylen );
|
|
wTarget[copylen-1] = L'\0';
|
|
}
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
WCHAR * wTarget ,// out-UNICODE target string
|
|
UCHAR const * aSource // in -ANSI source string
|
|
)
|
|
{
|
|
UStrCpy( wTarget, (char const *) aSource );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
WCHAR * wTarget ,// out-UNICODE target string
|
|
WCHAR const * wSource // in -UNICODE source string
|
|
)
|
|
{
|
|
lstrcpyW( wTarget, wSource );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
char * aTarget ,// out-ANSI target string
|
|
WCHAR const * wSource ,// in -UNICODE source string
|
|
int len // in -copy length in chars
|
|
)
|
|
{
|
|
int copylen = UStrLen( wSource ) + 1;
|
|
|
|
copylen = min( copylen, len );
|
|
|
|
if ( copylen )
|
|
{
|
|
WideCharToMultiByte( CP_ACP, 0, wSource, copylen, aTarget, copylen, NULL, NULL );
|
|
aTarget[copylen-1] = '\0';
|
|
}
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
UCHAR * aTarget ,// out-ANSI target string
|
|
WCHAR const * wSource ,// in -UNICODE source string
|
|
int len // in -copy length in chars
|
|
)
|
|
{
|
|
UStrCpy( (char *) aTarget, wSource, len );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
WCHAR * wTarget ,// out-UNICODE target string
|
|
char const * aSource ,// in -ANSI source string
|
|
int len // in -copy length in chars
|
|
)
|
|
{
|
|
int copylen = UStrLen( aSource ) + 1;
|
|
|
|
copylen = min( copylen, len );
|
|
|
|
if ( copylen )
|
|
{
|
|
MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, aSource, copylen, wTarget, copylen );
|
|
wTarget[copylen-1] = L'\0';
|
|
}
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
WCHAR * wTarget ,// out-UNICODE target string
|
|
UCHAR const * aSource ,// in -ANSI source string
|
|
int len // in -copy length in chars
|
|
)
|
|
{
|
|
UStrCpy( wTarget, (char const *) aSource, len );
|
|
}
|
|
|
|
void _inline
|
|
UStrCpy(
|
|
WCHAR * wTarget ,// out-UNICODE target string
|
|
WCHAR const * wSource ,// in -UNICODE source string
|
|
int len // in -copy length in chars
|
|
)
|
|
{
|
|
int copylen = UStrLen( wSource ) + 1;
|
|
|
|
copylen = min( copylen, len );
|
|
|
|
if ( copylen )
|
|
{
|
|
lstrcpynW( wTarget, wSource, copylen );
|
|
wTarget[copylen-1] = L'\0';
|
|
}
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrCmp(
|
|
WCHAR const * s1 ,// in -UNICODE string 1
|
|
WCHAR const * s2 // in -UNICODE string 2
|
|
)
|
|
{
|
|
return CompareStringW(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
s1,
|
|
-1,
|
|
s2,
|
|
-1 ) - 2;
|
|
// return wcscmp( s1, s2 );
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrCmp(
|
|
WCHAR const * s1 ,// in -UNICODE string 1
|
|
WCHAR const * s2 ,// in -UNICODE string 2
|
|
int len // in -compare length in chars
|
|
)
|
|
{
|
|
return CompareStringW(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
s1,
|
|
len,
|
|
s2,
|
|
len ) - 2;
|
|
// return wcsncmp( s1, s2, len );
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrICmp(
|
|
WCHAR const * s1 ,// in -UNICODE string 1
|
|
WCHAR const * s2 // in -UNICODE string 2
|
|
)
|
|
{
|
|
return CompareStringW(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
s1,
|
|
-1,
|
|
s2,
|
|
-1 ) - 2;
|
|
// return wcsicmp( s1, s2 );
|
|
}
|
|
|
|
int _inline // ret-compare result
|
|
UStrICmp(
|
|
WCHAR const * s1 ,// in -UNICODE string 1
|
|
WCHAR const * s2 ,// in -UNICODE string 2
|
|
int len // in -compare length in chars
|
|
)
|
|
{
|
|
return CompareStringW(
|
|
LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
s1,
|
|
len,
|
|
s2,
|
|
len ) - 2;
|
|
// return wcsnicmp( s1, s2, len );
|
|
}
|
|
|
|
WCHAR _inline *
|
|
UStrLwr(
|
|
WCHAR * s // i/o-UNICODE string
|
|
)
|
|
{
|
|
return wcslwr( s );
|
|
}
|
|
|
|
WCHAR _inline *
|
|
UStrUpr(
|
|
WCHAR * s // i/o-UNICODE string
|
|
)
|
|
{
|
|
return wcsupr( s );
|
|
}
|
|
|
|
WCHAR _inline
|
|
UToLower(
|
|
WCHAR c // in -UNICODE char
|
|
)
|
|
{
|
|
return towlower( c );
|
|
}
|
|
|
|
WCHAR _inline
|
|
UToUpper(
|
|
WCHAR c // in -UNICODE char
|
|
)
|
|
{
|
|
return towupper( c );
|
|
}
|
|
|
|
// Left-trim string in place
|
|
_inline WCHAR *
|
|
LTrim(
|
|
WCHAR * s // i/o-UNICODE string
|
|
)
|
|
{
|
|
WCHAR * strorg = s;
|
|
|
|
while ( *strorg == L' ' )
|
|
strorg++;
|
|
if ( strorg > s )
|
|
{
|
|
while ( *(strorg-1) )
|
|
*s++ = *strorg++;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
// Right-trim string in place
|
|
_inline WCHAR *
|
|
RTrim(
|
|
WCHAR * s // i/o-UNICODE string
|
|
)
|
|
{
|
|
WCHAR * strend = s + UStrLen(s);
|
|
|
|
while ( (strend > s) && (*(strend-1) == L' ') )
|
|
strend--;
|
|
*strend = L'\0';
|
|
return s;
|
|
}
|
|
|
|
// Trim string in place
|
|
_inline WCHAR *
|
|
Trim(
|
|
WCHAR * s // i/o-UNICODE string
|
|
)
|
|
{
|
|
return LTrim( RTrim( s ) );
|
|
}
|
|
|
|
char * _cdecl // ret-target string
|
|
UStrJoin(
|
|
char * target ,// out-target string
|
|
size_t sizeTarget ,// in -maximum size of target in chars
|
|
char const * source1 ,// in -first source string or NULL
|
|
... // in -remainder of source strings
|
|
);
|
|
|
|
WCHAR * _cdecl // ret-target string
|
|
UStrJoin(
|
|
WCHAR * target ,// out-target string
|
|
size_t sizeTarget ,// in -maximum size of target in chars
|
|
WCHAR const * source1 ,// in -first source string or NULL
|
|
... // in -remainder of source strings
|
|
);
|
|
|
|
#endif // WIN16_VERSION
|
|
|
|
#endif // MCSINC_UString_hpp
|
|
|
|
// UString.hpp - end of file
|