void ForeignToUpper(_TCHAR *buffer)
{
int i = 0;
while (buffer[i])
{
if (gLangIDNum != F4LANG_ENGLISH)
{
// Check for special characters
if ((uchar)(buffer[i]) >= 224 && (uchar)(buffer[i]) <=253)
buffer[i] -= 32;
else if (_istlower(buffer[i]))
buffer[i] = _toupper(buffer[i]);
/*
switch (buffer[i])
{
case 'è':
case 'é':
case 'ë':
case 'ê':
buffer[i] = 'E';
break;
case 'â':
case 'à':
case 'á':
case 'ä':
buffer[i] = 'A';
break;
case 'ì':
case 'í':
case 'î':
case 'ï':
buffer[i] = 'I';
break;
case 'û':
case 'ú':
case 'ù':
case 'ü':
buffer[i] = 'U';
break;
case 'ç':
buffer[i] = 'C';
break;
case 'ñ':
buffer[i] = 'N';
break;
case 'ô':
case 'ö':
buffer[i] = 'O';
break;
default:
if (_istlower(buffer[i]))
buffer[i] = _toupper(buffer[i]);
}
*/
}
else if (_istlower(buffer[i]))
buffer[i] = _toupper(buffer[i]);
i++;
}
}
void ShiftAnd::compile(const String &pattern, bool ignoreCase) {
m_patternLen = (int)pattern.length();
if(m_patternLen >= 64) {
throwException(_T("<%s> too long for shiftand-search. max length is 63"), pattern.cstr());
}
memset(m_mask, -1, sizeof(m_mask));
for(int i = 0; i < m_patternLen; i++) {
const _TUCHAR ch = pattern[i];
m_mask[ch] &= ~((UINT64)1 << i);
if (ignoreCase) {
if (_istlower(ch)) {
m_mask[_toupper(ch)] &= ~((UINT64)1 << i);
} else if(_istupper(ch)) {
m_mask[_tolower(ch)] &= ~((UINT64)1 << i);
}
}
}
m_s = (UINT64)1 << m_patternLen;
#ifdef _TEST_CLASS
for(int i = 0; i < ARRAYSIZE(m_mask); i++) {
const UINT64 mask = m_mask[i];
if(mask != -1) {
_tprintf(_T("mask[%c]:%s\n"), i, sprintbin(mask).cstr());
}
}
#endif
}
String firstLetterToUpperCase(const String &str) { // Return a copy of str, with first non-space letter changed to uppercase.
String result(str);
_TUCHAR *s;
for(s = (_TUCHAR*)result.cstr(); _istspace(*s); s++);
if(_istascii(*s) && _istlower(*s)) {
*s = _totupper(*s);
}
return result;
}
static int
prolog_complete(RlcCompleteData data)
{ Line ln = data->line;
switch(data->call_type)
{ case COMPLETE_INIT:
{ size_t start = ln->point;
wint_t c;
if ( !ln->data ) /* we donot want to complete on all atoms */
return FALSE;
while(start > 0 && (_istalnum((c=ln->data[start-1])) || c == '_') )
start--;
if ( start > 0 )
{ _TINT cs = ln->data[start-1];
if ( _tcschr(_T("'/\\.~"), cs) )
return FALSE; /* treat as a filename */
}
if ( _istlower(ln->data[start]) ) /* Lower, Aplha ...: an atom */
{ size_t patlen = ln->point - start;
_tcsncpy(data->buf_handle, &ln->data[start], patlen);
data->buf_handle[patlen] = '\0';
if ( PL_atom_generator_w(data->buf_handle,
data->candidate,
sizeof(data->candidate)/sizeof(TCHAR),
FALSE) )
{ data->replace_from = (int)start;
data->function = prolog_complete;
return TRUE;
}
}
return FALSE;
}
case COMPLETE_ENUMERATE:
{ if ( PL_atom_generator_w(data->buf_handle,
data->candidate,
sizeof(data->candidate)/sizeof(TCHAR),
TRUE) )
return TRUE;
return FALSE;
}
case COMPLETE_CLOSE:
return TRUE;
default:
return FALSE;
}
}
void COXFileChanger::ReverseCase(CString& sText)
// --- In : sText, the text to reverse case
// --- Out :
// --- Returns : a string with reversed case for each character
// --- Effect : reverse every character's case in a string
{
TCHAR ch;
for (int i = 0; i < sText.GetLength(); i++)
{
ch = sText[i];
sText.SetAt(i, (_istlower(ch) ? (TCHAR)_totupper(ch) : (TCHAR)_totlower(ch)));
}
}
LPTSTR strToUpper(LPTSTR dest, LPCTSTR src)
{
LPTSTR start = dest;
while (*dest = *src) {
if (_istlower(*dest))
*dest = _toupper(*dest);
dest++;
src++;
}
return start;
}
size_t KString::AlphabetToValue(TCHAR cChar)
{
if(_istdigit(cChar))
return cChar - TEXT('0');
if(_istupper(cChar))
return cChar - TEXT('A') + 10;
if(_istlower(cChar))
return cChar - TEXT('a') + (10 + 26);
return UINT_MAX;
}
// Add or remove ANSICON to AutoRun.
void process_autorun( TCHAR cmd )
{
HKEY cmdkey;
TCHAR ansicon[MAX_PATH+8];
LPTSTR autorun, ansirun;
DWORD len, type, exist;
BOOL inst;
len = GetModuleFileName( NULL, ansicon+2, MAX_PATH );
ansicon[0] = '&';
ansicon[1] = ansicon[2+len] = '"';
_tcscpy( ansicon + 3+len, L" -p" );
len += 6;
inst = (_totlower( cmd ) == 'i');
RegCreateKeyEx( (_istlower( cmd )) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
CMDKEY, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
&cmdkey, &exist );
exist = 0;
RegQueryValueEx( cmdkey, AUTORUN, NULL, NULL, NULL, &exist );
autorun = malloc( exist + len * sizeof(TCHAR) + sizeof(TCHAR) );
// Let's assume there's sufficient memory.
if (exist > sizeof(TCHAR))
{
exist += sizeof(TCHAR);
RegQueryValueEx( cmdkey, AUTORUN, NULL, &type, (PBYTE)autorun, &exist );
ansirun = _tcsstr( autorun, ansicon+1 );
if (inst)
{
if (!ansirun)
{
_tcscpy( (LPTSTR)((PBYTE)autorun + exist - sizeof(TCHAR)), ansicon );
RegSetValueEx( cmdkey, AUTORUN, 0, type, (PBYTE)autorun,
exist + len*sizeof(TCHAR) );
}
}
else
{
if (ansirun)
{
if (ansirun == autorun && exist == len*sizeof(TCHAR))
RegDeleteValue( cmdkey, AUTORUN );
else
{
if (ansirun > autorun && ansirun[-1] == '&')
--ansirun;
else if (autorun[len-1] != '&')
--len;
memcpy( ansirun, ansirun + len, exist - len*sizeof(TCHAR) );
RegSetValueEx( cmdkey, AUTORUN, 0, type, (PBYTE)autorun,
exist - len*sizeof(TCHAR) );
}
}
}
}
else if (inst)
{
RegSetValueEx( cmdkey, AUTORUN, 0, REG_SZ, (PBYTE)(ansicon+1),
len*sizeof(TCHAR) );
}
free( autorun );
RegCloseKey( cmdkey );
}
int islower( int c ) { return _istlower(c); }
bool Character::IsSmallLetter(TCHAR character)
{
return (_istlower(character) != 0) ? true : false;
}
