/** Function: Suche Zeichenkette in Zeichenkette ohne Beachtung von Gross- und Kleinschreibung **/
static TCHAR *ut_strstri(const TCHAR *txt, const TCHAR *pat)
{
// CharUpper() wandelt sowohl Zeichenketten als auch Zeichen um; da aber Funktion als
// LPTSTR CharUpper(LPTSTR lpsz) deklariert ist, muessen wir Funktionsergebnis fuer Zeichen in TCHAR*
// umwandeln, damit Kompiler Ruhe gibt. Da, wo wir nur CharUpper-Ergebnisse vergleichen,
// kann allerdings Umwandlung des Funktionsergebnisses entfallen. Ausserdem muessen wir Suchzeichen
// in WORD umwandeln, damit keine neg. Vorzeichenerw. passiert ('ü' -> int -4).
TCHAR *htxt1, *hpat2, *htxt2, patchar1;
/* Initialisiere */
if (txt == NULL || pat == NULL || *pat == TEXT('\0'))
return NULL;
patchar1 = (TCHAR)CharUpper((TCHAR*)(WORD)(*pat)); // LCC ignorieren - CharUpper ergibt 32bit-Zeichen,
for (htxt1=(TCHAR*)txt; *htxt1; htxt1++) { // falls Parameter Zeichen ist
/* Ermittele, ob erstes Suchmusterzeichen enthalten ist */
while (*htxt1 && (TCHAR)CharUpper((TCHAR*)(WORD)*htxt1) != patchar1) // LCC ignorieren oder _totupper()
htxt1++;
if (!*htxt1)
return NULL;
hpat2 = (TCHAR*)pat;
htxt2 = (TCHAR*)htxt1;
/* Ermittele, ob auch die nachfolgenden Suchmusterzeichen enthalten sind */
while (CharUpper((TCHAR*)(WORD)*htxt2) == CharUpper((TCHAR*)(WORD)*hpat2)) {
htxt2++;
hpat2++;
/* Falls das Ende des Suchmusters erreicht wurde, ist der Fund bestaetigt */
if (!*hpat2)
return htxt1;
}
}
return NULL;
}
// Takes text r and t, and direction and matching
// Finds in r the first or last instance of t
// Returns the zero based index of t in r, or -1 if not found or if r or t are blank
int find(read r, read t, direction d, matching m) {
// Get lengths
int rlength, tlength;
rlength = length(r);
tlength = length(t);
// If either is blank or r is shorter than t, return not found
if (!rlength || !tlength || rlength < tlength) return -1;
// Variables for loop
bool valid; // Valid tells if the tag is being found
int rindex, tindex; // Scannign indices
WCHAR rchar, tchar; // Characters
// Scan rindex between 0 and rlength - tlength in the desired direction
if (d == Forward) rindex = 0;
else rindex = rlength - tlength;
while (1) {
if (d == Forward) { if (rindex > rlength - tlength) break; }
else { if (rindex < 0) break; }
// Set valid true and look for the tag at rindex, to either break false at first mismatch or finish true
valid = true;
for (tindex = 0; tindex <= tlength - 1; tindex++) {
// Get the pair of characters
rchar = r[rindex + tindex];
tchar = t[tindex];
// Uppercase them if matching was requested
if (m == Matching) {
rchar = (WCHAR)CharUpper((LPTSTR)(ULONG_PTR)MAKELONG((WORD)rchar, 0));
tchar = (WCHAR)CharUpper((LPTSTR)(ULONG_PTR)MAKELONG((WORD)tchar, 0));
}
// Mismatch found, set false and break
if (rchar != tchar) { valid = false; break; }
}
// The tag was found at rindex, return it, done
if (valid) return rindex;
if (d == Forward) rindex++;
else rindex--;
}
// Not found
return -1;
}
void dlgTextEntryKeyboardShowModal(TCHAR *text, int width, unsigned ResID)
{
wf = NULL;
if (width==0) {
width = MAX_TEXTENTRY;
}
max_width = min(MAX_TEXTENTRY, width);
wf = dlgLoadFromXML(CallBackTable, ResID);
if (!wf) return;
// cursor = _tcslen(text);
ClearText();
if (_tcslen(text)>0) {
CharUpper(text);
LK_tcsncpy(edittext, text, max_width-1);
// show previous test.
// this text is replaced by first key down
// but used if "OK" is clicked first for don't reset current value.
}
cursor = _tcslen(edittext);
UpdateTextboxProp();
WindowControl* pBtHelp = wf->FindByName(TEXT("cmdHelp"));
if(pBtHelp) {
pBtHelp->SetVisible(wKeyboardPopupWndProperty && wKeyboardPopupWndProperty->HasHelpText());
}
wf->SetKeyDownNotify(FormKeyDown);
wf->ShowModal();
LK_tcsncpy(text, edittext, max_width-1);
// cursor = _tcslen(text);
delete wf;
wf=NULL;
}
RPC_STATUS
GuidToString(
UUID *Uuid,
LPTSTR StringGuid
)
{
RPC_STATUS Status;
LPTSTR pTempStringGuid;
Status = UuidToString(Uuid, &pTempStringGuid);
if (Status == RPC_S_OK) {
//
// the form we want is all uppercase and with curly brackets around,
// like what OLE does
//
lstrcpy(StringGuid, TEXT("{"));
lstrcat(StringGuid, pTempStringGuid);
lstrcat(StringGuid, TEXT("}"));
CharUpper(StringGuid);
RpcStringFree(&pTempStringGuid);
}
return Status;
} // GuidToString
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 根据文件名获取视频大小
BOOL COpenDlg::GetSize(PCTSTR ptzFileName)
{
INT i;
PTSTR p;
TCHAR tzFileName[MAX_PATH];
// 获取文件名称
lstrcpy(tzFileName, ptzFileName);
CharUpper(tzFileName);
p = _StrRChr(tzFileName, '\\');
_ExIfElse(p == NULL, return(FALSE), p++);
// 根据格式字符串确定大小
for (i = _NumOf(c_tzFormats) - 1; i >= 0; i--)
{
if (_StrStr(p, c_tzFormats[i]))
{
m_riFormat.m_uWidth = c_uFormats[i][0];
m_riFormat.m_iHeight = c_uFormats[i][1];
return TRUE;
}
}
// 根据数字确定大小
INT w, h;
if (guessResolution(p, w, h))
{
m_riFormat.m_uWidth = w;
m_riFormat.m_iHeight = h;
return TRUE;
}
return FALSE;
}
static int WordCmpI(LPCTSTR psz1, LPCTSTR psz2) throw()
{
TCHAR c1 = (TCHAR)CharUpper((LPTSTR)*psz1);
TCHAR c2 = (TCHAR)CharUpper((LPTSTR)*psz2);
while (c1 != NULL && c1 == c2 && c1 != ' ' && c1 != '\t')
{
psz1 = CharNext(psz1);
psz2 = CharNext(psz2);
c1 = (TCHAR)CharUpper((LPTSTR)*psz1);
c2 = (TCHAR)CharUpper((LPTSTR)*psz2);
}
if ((c1 == NULL || c1 == ' ' || c1 == '\t') && (c2 == NULL || c2 == ' ' || c2 == '\t'))
return 0;
return (c1 < c2) ? -1 : 1;
}
unsigned int loctoupper(byte ch)
{
#ifdef _WIN_32
return((int)CharUpper((LPTSTR)ch));
#else
return(toupper(ch));
#endif
}
void cairo_container::transform_text( litehtml::tstring& text, litehtml::text_transform tt )
{
if(text.empty()) return;
#ifndef LITEHTML_UTF8
switch(tt)
{
case litehtml::text_transform_capitalize:
if(!text.empty())
{
text[0] = (WCHAR) CharUpper((LPWSTR) text[0]);
}
break;
case litehtml::text_transform_uppercase:
for(size_t i = 0; i < text.length(); i++)
{
text[i] = (WCHAR) CharUpper((LPWSTR) text[i]);
}
break;
case litehtml::text_transform_lowercase:
for(size_t i = 0; i < text.length(); i++)
{
text[i] = (WCHAR) CharLower((LPWSTR) text[i]);
}
break;
}
#else
LPWSTR txt = cairo_font::utf8_to_wchar(text.c_str());
switch(tt)
{
case litehtml::text_transform_capitalize:
CharUpperBuff(txt, 1);
break;
case litehtml::text_transform_uppercase:
CharUpperBuff(txt, lstrlen(txt));
break;
case litehtml::text_transform_lowercase:
CharLowerBuff(txt, lstrlen(txt));
break;
}
LPSTR txtA = cairo_font::wchar_to_utf8(txt);
text = txtA;
delete txtA;
delete txt;
#endif
}
static DWORD TwoDigitsToBinValue(LPCTSTR szBinValue)
{
TCHAR chDigit1;
TCHAR chDigit2;
// Verify the digits
if(!isxdigit(szBinValue[0]) || !isxdigit(szBinValue[1]))
return (DWORD)0x100;
chDigit2 = (TCHAR)(UINT_PTR)CharUpper((LPTSTR)szBinValue[0]);
chDigit1 = (TCHAR)(UINT_PTR)CharUpper((LPTSTR)szBinValue[1]);
if(chDigit1 > '9')
chDigit1 -= 'A' - '9' - 1;
if(chDigit2 > '9')
chDigit2 -= 'A' - '9' - 1;
return ((chDigit2 - '0') << 0x04) | (chDigit1 - '0');
}
void PrepareUnitStr()
{
for (int i=0; i<UNIT_COUNT; i++)
{
xwcsncpy(UnitStr[i][0],MSG(MListBytes+i),MAX_UNITSTR_SIZE);
wcscpy(UnitStr[i][1],UnitStr[i][0]);
CharLower(UnitStr[i][0]);
CharUpper(UnitStr[i][1]);
}
}
/*
**----------------------------------------------------------------------
** .Klasse: ZeidonSyntax
**
** .Methode: Hash
**
** .Beschreibung: Zerhacken eines Wortes
**
** .Parameter: char* , pWord , I, Pointer auf Wort
**
** .Rueckgabewert: long, der Hashwert
**
** ---------------------------------------------------------------------
**
** .Methodenbeschreibung:
** Leider muss das Wort zuerst in Grossbuchstaben umgesetzt werden
**-----------------------------------------------------------------
*/
inline long ZeidonSyntax::Hash( char *pWord )
{
unsigned long h;
CharUpper( pWord );
for( h=0; *pWord; pWord++ )
h = (64*h + *pWord) % HASH_ARR_SIZE;
return h;
}
TCHAR * AutoReplaceMap::autoReplace(const TCHAR * word)
{
scoped_free<TCHAR> from = _tcslwr(_tcsdup(word));
if (replacements.find(from.get()) == replacements.end())
return NULL;
AutoReplacement &ar = replacements[from.get()];
TCHAR *to;
if (ar.useVariables)
to = variables_parsedup((TCHAR *) ar.replace.c_str(), (TCHAR *) word, NULL);
else
to = _tcsdup(ar.replace.c_str());
// Wich case to use?
size_t len = lstrlen(word);
size_t i;
for (i = 0; i < len; i++)
if (IsCharLower(word[i]))
break;
if (i <= 0)
{
// All lower
return to;
}
else if (i >= len)
{
// All upper
return CharUpper(to);
}
else
{
// First upper
TCHAR tmp[2];
tmp[0] = to[0];
tmp[1] = _T('\0');
CharUpper(tmp);
to[0] = tmp[0];
return to;
}
}
wxString Upper(const wxString & input)
{
#ifdef __WXMSW__
wxWCharBuffer buf = input.c_str();
CharUpper(buf.data());
return buf;
#else
return input.Upper();
#endif
}
char* strupper(char *Str)
{
#ifdef _WIN_32
CharUpper((LPTSTR)Str);
#else
for (char *ChPtr=Str;*ChPtr;ChPtr++)
*ChPtr=(char)loctoupper(*ChPtr);
#endif
return(Str);
}
wxString & MakeUpper(wxString & data)
{
#ifdef __WXMSW__
wxWCharBuffer buf = data.c_str();
CharUpper(buf.data());
return data = buf;
#else
return data.MakeUpper();
#endif
}
inline uint toupperc(byte ch)
{
#if defined(_WIN_32)
return((uint)CharUpper((LPTSTR)(ch)));
#elif defined(_UNIX)
return(ch);
#else
return(toupper(ch));
#endif
}
void Invert(TCHAR *str)
{
while (*str) {
if (IsCharUpper(*str))
*str = (TCHAR)CharLower((LPTSTR)*str);
else if (IsCharLower(*str))
*str = (TCHAR)CharUpper((LPTSTR)*str);
str++;
}
keybd_event(VK_CAPITAL, 0x45, KEYEVENTF_EXTENDEDKEY | 0, 0);
keybd_event(VK_CAPITAL, 0x45, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
}
inline uint toupperc(byte ch,bool ForceCase)
{
if (ForceCase)
return(ch);
#ifdef _WIN_ALL
return((uint)(LPARAM)CharUpper((LPTSTR)(ch)));
#elif defined(_UNIX)
return(ch);
#else
return(toupper(ch));
#endif
}
static void PrepareData(void){
TCHAR sTmp[5];
if (NumberOfAirspaces==0) return;
sNameFilter[0] =_T('\0');
AirspaceSelectInfo = (AirspaceSelectInfo_t*)
malloc(sizeof(AirspaceSelectInfo_t) * NumberOfAirspaces);
if (AirspaceSelectInfo==NULL) {
OutOfMemory(_T(__FILE__),__LINE__);
return;
}
StrIndex = (int*)malloc(sizeof(int)*(NumberOfAirspaces+1));
if (StrIndex==NULL) {
OutOfMemory(_T(__FILE__),__LINE__);
return;
}
int index=0;
double bearing;
double distance;
CAirspaceList Airspaces = CAirspaceManager::Instance().GetAllAirspaces();
CAirspaceList::const_iterator it;
for (it=Airspaces.begin(); it != Airspaces.end(); ++it) {
AirspaceSelectInfo[index].airspace = *it;
distance = DISTANCEMODIFY * (*it)->Range(Longitude, Latitude, bearing);
if (distance<0) distance=0;
AirspaceSelectInfo[index].Distance = distance;
AirspaceSelectInfo[index].Direction = bearing;
LK_tcsncpy(sTmp, (*it)->Name(), 4);
CharUpper(sTmp);
AirspaceSelectInfo[index].FourChars =
(((unsigned)sTmp[0] & 0xff) << 24)
+ (((unsigned)sTmp[1] & 0xff) << 16)
+ (((unsigned)sTmp[2] & 0xff) << 8)
+ (((unsigned)sTmp[3] & 0xff) );
AirspaceSelectInfo[index].Type = (*it)->Type();
index++;
}
qsort(AirspaceSelectInfo, UpLimit,
sizeof(AirspaceSelectInfo_t), AirspaceNameCompare);
}
// turn a file, relative path or other into an absolute path
BOOL AFXAPI AfxFullPath(LPTSTR lpszPathOut, LPCTSTR lpszFileIn)
// lpszPathOut = buffer of _MAX_PATH
// lpszFileIn = file, relative path or absolute path
// (both in ANSI character set)
{
ASSERT(AfxIsValidAddress(lpszPathOut, _MAX_PATH));
// first, fully qualify the path name
LPTSTR lpszFilePart;
if (!GetFullPathName(lpszFileIn, _MAX_PATH, lpszPathOut, &lpszFilePart))
{
#ifdef _DEBUG
if (lpszFileIn[0] != '\0')
TRACE1("Warning: could not parse the path '%s'.\n", lpszFileIn);
#endif
lstrcpyn(lpszPathOut, lpszFileIn, _MAX_PATH); // take it literally
return FALSE;
}
#ifndef _MAC
CString strRoot;
// determine the root name of the volume
AfxGetRoot(lpszPathOut, strRoot);
// get file system information for the volume
DWORD dwFlags, dwDummy;
if (!GetVolumeInformation(strRoot, NULL, 0, NULL, &dwDummy, &dwFlags,
NULL, 0))
{
TRACE1("Warning: could not get volume information '%s'.\n",
(LPCTSTR)strRoot);
return FALSE; // preserving case may not be correct
}
// not all characters have complete uppercase/lowercase
if (!(dwFlags & FS_CASE_IS_PRESERVED))
CharUpper(lpszPathOut);
// assume non-UNICODE file systems, use OEM character set
if (!(dwFlags & FS_UNICODE_STORED_ON_DISK))
{
WIN32_FIND_DATA data;
HANDLE h = FindFirstFile(lpszFileIn, &data);
if (h != INVALID_HANDLE_VALUE)
{
FindClose(h);
lstrcpy(lpszFilePart, data.cFileName);
}
}
#endif
return TRUE;
}
bool PortParameters::SetRealPortName(const char *pNewRealPortName)
{
if (lstrcmpi(realPortName, pNewRealPortName) != 0) {
if (SNPRINTF(realPortName, sizeof(realPortName)/sizeof(realPortName[0]), "%s", pNewRealPortName) <= 0) {
Trace("Invalid real port name '%s'\n", pNewRealPortName);
return FALSE;
}
CharUpper(realPortName);
maskChanged |= m_realPortName;
}
return TRUE;
}
//+---------------------------------------------------------------------------
//
// Member: CString::ComputeCrc
//
// Synopsis: Computes a hash of the string.
//
//----------------------------------------------------------------------------
WORD CString::ComputeCrc() const
{
WORD wHash=0;
const TCHAR* pch;
int i;
pch=*this;
for(i=Length(); i>0; i--,pch++)
{
wHash = wHash << 7^wHash >> (16-7)^(TCHAR)CharUpper((LPTSTR)((DWORD_PTR)(*pch)));
}
return wHash;
}
char *MkTemp (char *Dest, const char *Prefix)
{
if(Dest && Prefix && *Prefix)
{
char TempPath[NM], TempName[NM];
int Len = GetTempPath(sizeof(TempPath),TempPath);
TempPath[Len]=0;
if(GetTempFileName(TempPath,Prefix,0,TempName))
{
strcpy(Dest,CharUpper(TempName));
return Dest;
}
}
return NULL;
}
// this function convert the string to the format with 1 upper case followed by lower case char
void CaseConv(TCHAR *str)
{
TCHAR *pstr;
BOOL nextUp = TRUE;
CharLowerBuff(str, (DWORD)_tcslen(str));
for(pstr = str; *pstr; pstr++) {
if (*pstr == ' ' || *pstr == '-')
nextUp = TRUE;
else {
TCHAR ch = *(TCHAR*)pstr;
if (nextUp)
*pstr = ( TCHAR )CharUpper((LPTSTR)ch);
nextUp = FALSE;
} } }
void Applet::UpdateLabel(LCID lang)
{
// update language label
WCHAR label[MAX_LABEL];
GetLocaleInfo(lang, pSettings->GetDisplayLCType(), (LPWSTR)&label, MAX_LABEL);
if (pSettings->IsUpperCase())
{
CharUpper((LPWSTR)&label);
}
else
{
CharLower((LPWSTR)&label);
}
wcsncpy(displayLabel, label, MAX_LABEL);
}
void CAsyncClient::SetUserInfo( USERINFOPAY& info, const int nCn, const char* szUserId, const char* szUserPass, const char* szGameId, const char* szUserType )
{
info.dwConnectionIndex = nCn;
//strupr( info.szUserId ); // 030430 모든 유저이름을 대문자로 처리한다.
//strcpy( info.szUserId, szUserId );
//strcpy( info.szUserPass, szUserPass );
//strcpy( info.szGameId, szGameId );
//strcpy( info.szUserType, szUserType );
strncpy( info.szUserPass, szUserPass,32 );
strncpy( info.szGameId, szGameId ,32 );
strncpy( info.szUserType, szUserType ,32 );
strncpy( info.szUserId, szUserId, 32 );
CharUpper(info.szUserId);
info.nAliveTime = 0; // 030703 YGI
}
BOOL CLocale::Censor(const CString& csCaption, const CString& csFile, const CString& csKeywords)
{
// for now just use one censor list for all locales
LPSTR lpszTemp;
CString csTemp = csCaption+" "+csFile+" "+csKeywords;
lpszTemp = csTemp.GetBuffer(csTemp.GetLength()*2);
CharUpper(lpszTemp);
csTemp.ReleaseBuffer(-1);
for (int i = 0; CensorList[i]; i++)
{
if (csTemp.Find(CensorList[i]) != -1)
{
return TRUE;
}
}
return FALSE;
}
_WCRTLINK unsigned char _FFAR *_NEARFAR(_mbsupr,_fmbsupr)( unsigned char _FFAR *string )
{
#if defined(__NT__) && !defined(__FARFUNC__)
CharUpper( (char _FFAR *)string ); // call the Win32 API
#else
unsigned int ch;
unsigned char _FFAR *p;
unsigned char mbc[MB_LEN_MAX+1];
p = string;
while( !_NEARFAR(_mbterm,_fmbterm)( p ) ) {
ch = _mbctoupper( _NEARFAR(_mbsnextc,_fmbsnextc)( p ) );
_NEARFAR(_mbvtop,_fmbvtop)( ch, mbc );
mbc[_NEARFAR(_mbclen,_fmbclen)( mbc )] = '\0';
_NEARFAR(_mbccpy,_fmbccpy)( p, mbc );
p = _NEARFAR(_mbsinc,_fmbsinc)( p );
}
#endif
return( string );
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
static BOOL bNewNumber = TRUE;
static int iOperation = '=';
static UINT iNumber, iFirstNum;
HWND hButton;
switch(message) {
case WM_KEYDOWN:
if(wParam != VK_LEFT) break;
wParam = VK_BACK;
case WM_CHAR:
if((wParam = (WPARAM) CharUpper((TCHAR *) wParam)) == VK_RETURN) wParam = '=';
if(hButton = GetDlgItem(hwnd, wParam)) {
SendMessage(hButton, BM_SETSTATE, 1, 0);
Sleep(100);
SendMessage(hButton, BM_SETSTATE, 0, 0);
} else {
MessageBeep(0);
break;
}
case WM_COMMAND:
SetFocus(hwnd);
if(LOWORD(wParam) == VK_BACK) ShowNumber(hwnd, iNumber /= 16);
else if(LOWORD(wParam) == VK_ESCAPE) ShowNumber(hwnd, iNumber = 0);
else if(isxdigit(LOWORD(wParam))) {
if(bNewNumber) {
iFirstNum = iNumber;
iNumber = 0;
}
bNewNumber = FALSE;
if(iNumber <= MAXDWORD >> 4)
ShowNumber(hwnd, iNumber = 16 * iNumber + wParam - (isdigit(wParam) ? '0' : 'A'-10));
else
MessageBeep(0);
} else {
if(!bNewNumber) ShowNumber(hwnd, iNumber = CalcIt(iFirstNum, iOperation, iNumber));
bool PortParameters::InitRealPortName(const char *pRealPortName)
{
if (!lstrcmpi("", pRealPortName)) {
maskExplicit &= ~m_realPortName;
maskChanged &= ~m_realPortName;
return TRUE;
}
if (SNPRINTF(realPortName, sizeof(realPortName)/sizeof(realPortName[0]), "%s", pRealPortName) <= 0) {
Trace("Invalid real port name '%s'\n", pRealPortName);
return FALSE;
}
CharUpper(realPortName);
maskChanged &= ~m_realPortName;
maskExplicit |= m_realPortName;
return TRUE;
}
