/** 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; }