BOOL AFXAPI AfxComparePath(LPCTSTR lpszPath1, LPCTSTR lpszPath2)
{
#ifdef _MAC
FSSpec fssTemp1;
FSSpec fssTemp2;
if (!UnwrapFile(lpszPath1, &fssTemp1) || !UnwrapFile(lpszPath2, &fssTemp2))
return FALSE;
return fssTemp1.vRefNum == fssTemp2.vRefNum &&
fssTemp1.parID == fssTemp2.parID &&
EqualString(fssTemp1.name, fssTemp2.name, false, true);
#else
// use case insensitive compare as a starter
if (lstrcmpi(lpszPath1, lpszPath2) != 0)
return FALSE;
// on non-DBCS systems, we are done
if (!GetSystemMetrics(SM_DBCSENABLED))
return TRUE;
// on DBCS systems, the file name may not actually be the same
// in particular, the file system is case sensitive with respect to
// "full width" roman characters.
// (ie. fullwidth-R is different from fullwidth-r).
int nLen = lstrlen(lpszPath1);
if (nLen != lstrlen(lpszPath2))
return FALSE;
ASSERT(nLen < _MAX_PATH);
// need to get both CT_CTYPE1 and CT_CTYPE3 for each filename
LCID lcid = GetThreadLocale();
WORD aCharType11[_MAX_PATH];
VERIFY(GetStringTypeEx(lcid, CT_CTYPE1, lpszPath1, -1, aCharType11));
WORD aCharType13[_MAX_PATH];
VERIFY(GetStringTypeEx(lcid, CT_CTYPE3, lpszPath1, -1, aCharType13));
WORD aCharType21[_MAX_PATH];
VERIFY(GetStringTypeEx(lcid, CT_CTYPE1, lpszPath2, -1, aCharType21));
#ifdef _DEBUG
WORD aCharType23[_MAX_PATH];
VERIFY(GetStringTypeEx(lcid, CT_CTYPE3, lpszPath2, -1, aCharType23));
#endif
// for every C3_FULLWIDTH character, make sure it has same C1 value
int i = 0;
for (LPCTSTR lpsz = lpszPath1; *lpsz != 0; lpsz = _tcsinc(lpsz))
{
// check for C3_FULLWIDTH characters only
if (aCharType13[i] & C3_FULLWIDTH)
{
ASSERT(aCharType23[i] & C3_FULLWIDTH); // should always match!
// if CT_CTYPE1 is different then file system considers these
// file names different.
if (aCharType11[i] != aCharType21[i])
return FALSE;
}
++i; // look at next character type
}
return TRUE; // otherwise file name is truly the same
#endif
}
_WCRTLINK int _ismbcpunct( unsigned int ch )
{
#ifdef __NT__
BOOL rc;
int len;
char mbc[ MB_LEN_MAX + 1 ];
WORD char_type[ MB_LEN_MAX + 1 ];
_mbvtop( ch, mbc );
len = _mbclen( mbc );
mbc[ len ] = '\0';
rc = GetStringTypeEx( LOCALE_USER_DEFAULT, CT_CTYPE1, mbc, -1, char_type );
if( rc == FALSE ) return( 0 );
if( (char_type[ 0 ] & C1_PUNCT) == 0 ) return( 0 );
return( 1 );
#else /* OS/2 and others */
if( SINGLE_BYTE_CHAR( ch ) ) {
if( __MBCodePage == 932 ) {
return( ispnkana( ch ) );
} else {
return( ispunct( ch ) );
}
} else {
return( 0 );
}
#endif
}
_WCRTLINK int _ismbcprint( unsigned int ch )
{
#ifdef __NT__
BOOL rc;
int len;
char mbc[ MB_LEN_MAX + 1 ];
WORD char_type[ MB_LEN_MAX + 1 ];
_mbvtop( ch, mbc );
len = _mbclen( mbc );
mbc[ len ] = '\0';
rc = GetStringTypeEx( LOCALE_USER_DEFAULT, CT_CTYPE1, mbc, -1, char_type );
if( rc == FALSE ) return( 0 );
if( (char_type[ 0 ] & C1_CNTRL) != 0 ) return( 0 );
if( (char_type[ 0 ] & (C1_UPPER | C1_LOWER | C1_DIGIT | C1_SPACE |
C1_PUNCT | C1_BLANK | C1_XDIGIT | C1_ALPHA)) == 0 )
return( 0 );
return( 1 );
#else /* OS/2 and others */
if( SINGLE_BYTE_CHAR( ch ) ) {
return( isprint( ch ) );
} else {
if( __MBCodePage == 932 ) {
return( _ismbdprint( ch ) );
} else {
return( 0 );
}
}
#endif
}
_WCRTLINK int _ismbcalpha( unsigned int ch )
{
#ifdef __NT__
BOOL rc;
int len;
char mbc[ MB_LEN_MAX + 1 ];
WORD char_type[ MB_LEN_MAX + 1 ];
_mbvtop( ch, mbc );
len = _mbclen( mbc );
mbc[ len ] = '\0';
rc = GetStringTypeEx( LOCALE_USER_DEFAULT, CT_CTYPE1, mbc, -1, char_type );
if( rc == FALSE ) return( 0 );
if( (char_type[ 0 ] & C1_ALPHA) == 0 ) return( 0 );
return( 1 );
#else /* OS/2 and others */
if( __MBCodePage == 932 ) { /* Japanese code page */
if( SINGLE_BYTE_CHAR( ch ) ) {
if( ch >= 0xA6 && ch <= 0xDF ) { /* Katakana letters */
return( 1 );
} else {
return( isalpha( ch ) );
}
} else { /* double-byte chars */
return( _ismbdalpha( ch ) );
}
} else {
if( SINGLE_BYTE_CHAR( ch ) ) {
return( isalpha( ch ) );
} else {
return( 0 );
}
}
#endif
}
INT32 CLRTypeName::GetCharacterInfoHelper(WCHAR c, INT32 CharInfoType)
{
unsigned short result=0;
if (!GetStringTypeEx(LOCALE_USER_DEFAULT, CharInfoType, &(c), 1, &result)) {
_ASSERTE(!"This should not happen, verify the arguments passed to GetStringTypeEx()");
}
return(INT32)result;
}
_WCRTLINK int _ismbcalnum( unsigned int ch )
{
#ifdef __NT__
BOOL rc;
int len;
char mbc[ MB_LEN_MAX + 1 ];
WORD char_type[ MB_LEN_MAX + 1 ];
_mbvtop( ch, mbc );
len = _mbclen( mbc );
mbc[ len ] = '\0';
rc = GetStringTypeEx( LOCALE_USER_DEFAULT, CT_CTYPE1, mbc, -1, char_type );
if( rc == FALSE ) return( 0 );
if( (char_type[ 0 ] & (C1_DIGIT | C1_ALPHA)) == 0 ) return( 0 );
return( 1 );
#else /* OS/2 and others */
return( _ismbcalpha( ch ) || _ismbcdigit( ch ) );
#endif
}
_WCRTLINK int _ismbclegal( unsigned int ch )
{
#ifdef __NT__
BOOL rc;
int len;
char mbc[ MB_LEN_MAX + 1 ];
WORD char_type[ MB_LEN_MAX + 1 ];
_mbvtop( ch, mbc );
len = _mbclen( mbc );
mbc[ len ] = '\0';
if( len <= 1 ) return( 0 );
rc = GetStringTypeEx( LOCALE_USER_DEFAULT, CT_CTYPE1, mbc, -1, char_type );
if( rc == FALSE ) return( 0 );
if( char_type[ 0 ] == 0 ) return( 0 );
return( 1 );
#else /* OS/2 and others */
return( _ismbblead( ch >> 8 ) && _ismbbtrail( ch & 0xFF ) );
#endif
}
_WCRTLINK int _ismbccntrl( unsigned int ch )
{
#ifdef __NT__
BOOL rc;
int len;
unsigned char mbc[ MB_LEN_MAX + 1 ];
WORD char_type[ MB_LEN_MAX + 1 ];
_mbvtop( ch, mbc );
len = _mbclen( mbc );
mbc[len] = '\0';
rc = GetStringTypeEx( LOCALE_USER_DEFAULT, CT_CTYPE1, (char *)mbc, -1, char_type );
if( rc == FALSE ) return( 0 );
if( (char_type[ 0 ] & C1_CNTRL) == 0 ) return( 0 );
return( 1 );
#else /* OS/2 and others */
if( SINGLE_BYTE_CHAR( ch ) ) {
return( iscntrl( ch ) );
} else {
return( 0 );
}
#endif
}
// works like sprintf
///////////////////////////////////////////////////////////////
void EWCharString::Format( const EWCSChar* p_Str, ... )
{
va_list Arg_List;
va_start(Arg_List, p_Str);
va_list Arg_List_Save = Arg_List;
// make a guess at the maximum length of the resulting string
int Max_Len = 0;
for (const EWCSChar* p_Tmp = p_Str; *p_Tmp != '\0'; p_Tmp = KSInc(p_Tmp))
{
// handle '%' character, but watch out for '%%'
if (*p_Tmp != '%' || *(p_Tmp = KSInc(p_Tmp)) == '%')
{
Max_Len += EWCSCharLen(p_Tmp);
continue;
}
int Item_Len = 0;
// handle '%' character with format
int Width = 0;
for (; *p_Tmp != '\0'; p_Tmp = KSInc(p_Tmp))
{
// check for valid flags
if (*p_Tmp == '#')
Max_Len += 2; // for '0x'
else if (*p_Tmp == '*')
Width = va_arg(Arg_List, int);
else if (*p_Tmp == '-' || *p_Tmp == '+' || *p_Tmp == '0' ||
*p_Tmp == ' ')
;
else // hit non-flag character
break;
}
// get width and skip it
if ( Width == 0)
{
// width indicated by
Width = KToI(p_Tmp);
unsigned short buffer;
for (; *p_Tmp != '\0'; )
{
GetStringTypeEx(LOCALE_SYSTEM_DEFAULT, CT_CTYPE1, p_Tmp, 1, &buffer);
if (buffer == C1_DIGIT || buffer == C1_XDIGIT)
p_Tmp = KSInc(p_Tmp);
else
break;
}
}
gosASSERT( Width >= 0);
int Precision = 0;
if (*p_Tmp == '.')
{
// skip past '.' separator (width.precision)
p_Tmp = KSInc(p_Tmp);
// get precision and skip it
if (*p_Tmp == '*')
{
Precision = va_arg(Arg_List, int);
p_Tmp = KSInc(p_Tmp);
}
/*
* CRchTxtPtr::ChangeCase(cch, Type, publdr)
*
* @mfunc
* Change case of cch chars starting at this text ptr according to Type,
* which has the possible values:
*
* tomSentenceCase = 0: capitalize first letter of each sentence
* tomLowerCase = 1: change all letters to lower case
* tomUpperCase = 2: change all letters to upper case
* tomTitleCase = 3: capitalize the first letter of each word
* tomToggleCase = 4: toggle the case of each letter
*
* @rdesc
* TRUE iff a change occurred
*
* @devnote
* Since this routine only changes the case of characters, it has no
* effect on rich-text formatting. However it is part of the CRchTxtPtr
* class in order to notify the display of changes. CTxtRanges are also
* notified just in case the text blocks are modified.
*/
BOOL CRchTxtPtr::ChangeCase (
LONG cch, //@parm # chars to change case for
LONG Type, //@parm Type of change case command
IUndoBuilder *publdr) //@parm UndoBuilder to receive anti-event
// for any replacements
{
TRACEBEGIN(TRCSUBSYSBACK, TRCSCOPEINTERN, "CRchTxtPtr::ChangeCase");
_TEST_INVARIANT_
#define BUFFERLEN 256
LONG cchChunk, cchFirst, cchGet, cchLast;
BOOL fAlpha, fToUpper, fUpper; // Flags controling case change
BOOL fChange = FALSE; // No change yet
BOOL fStart = TRUE; // Start of Word/Sentence
TCHAR * pch; // Ptr to walk rgCh with
WORD * pType; // Ptr to walk rgType with
TCHAR rgCh[BUFFERLEN]; // Char buffer to work in
WORD rgType[BUFFERLEN]; // C1_TYPE array for rgCh
if( GetCp() )
{
if( Type == tomSentenceCase )
{
fStart = _rpTX.IsAtBOSentence();
}
else if( Type == tomTitleCase )
{
// check to see if we are at the beginning of
// a word. This is the case if the character preceeding
// our current position is white space.
fStart = IsWhiteSpace(_rpTX.PrevChar());
_rpTX.AdvanceCp(1);
}
}
while(cch > 0) // Do 'em all (or as many as
{ // in story)
cchChunk = min(BUFFERLEN, cch); // Get next bufferful
cch -= cchChunk; // Decrement the count
cchGet = _rpTX.GetText(cchChunk, rgCh); // Manipulate chars in buffer
if(cchGet < cchChunk) // (for undo, need to use
{ // ReplaceRange())
cch = 0; // No more chars in story,
if(!cchGet) // so we'll be done
break; // We're done already
cchChunk = cchGet; // Something in this chunk
}
GetStringTypeEx(0, CT_CTYPE1, rgCh, // Find out whether chars are
cchChunk, rgType); // UC, LC, or neither
cchLast = 0; // Default nothing to replace
cchFirst = -1;
for(pch = rgCh, pType = rgType; // Process buffered chars
cchChunk;
cchChunk--, pch++, pType++)
{
fAlpha = *pType & (C1_UPPER | C1_LOWER); // Nonzero if UC or LC
fUpper = (*pType & C1_UPPER) != 0; // TRUE if UC
fToUpper = fStart ? TRUE : fUpper; // capitalize first letter of a
// sentence
switch(Type)
{ // Decide whether to change
case tomLowerCase: // case and determine start
fToUpper = FALSE; // of word/sentence for title
break; // and sentence cases
case tomUpperCase:
fToUpper = TRUE;
break;
case tomToggleCase:
fToUpper = !fUpper;
break;
case tomSentenceCase:
if(*pch == TEXT('.')) // If sentence terminator,
fStart = TRUE; // capitalize next alpha
if(fAlpha) // If this char is alpha, next
fStart = FALSE; // char can't start a
break; // sentence
case tomTitleCase: // If this char is alpha, next
fStart = (fAlpha == 0); // char can't start a word
break;
default:
return FALSE;
}
if(fAlpha && (fToUpper ^ fUpper)) // Only change case if it
{ // makes a difference (saves
if(fToUpper) // on system calls and undos)
CharUpperBuff(pch, 1);
else
CharLowerBuff(pch, 1);
fChange = TRUE; // Return value: change made
if( cchFirst == -1 ) // Save cch of unchanged
cchFirst = cchGet-cchChunk; // leading string
cchLast = cchChunk - 1; // Save cch of unchanged
} // trailing string
}
if( cchFirst == -1 )
{
Assert(cchLast == 0);
cchFirst = cchGet;
}
Advance(cchFirst); // Skip unchanged leading
cchGet -= cchFirst + cchLast; // string. cchGet = cch of
ReplaceRange(cchGet, cchGet, rgCh // changed span
+ cchFirst, publdr, tomUndefined);
Advance(cchLast); // Skip unchanged trailing
} // string
return fChange;
}
