ATF_TC_BODY(wcscspn, tc) { ATF_CHECK_EQ(wcscspn(L"abcdefghijklmnop", L""), 16); ATF_CHECK_EQ(wcscspn(L"abcdefghijklmnop", L"a"), 0); ATF_CHECK_EQ(wcscspn(L"abcdefghijklmnop", L"b"), 1); ATF_CHECK_EQ(wcscspn(L"abcdefghijklmnop", L"cd"), 2); ATF_CHECK_EQ(wcscspn(L"abcdefghijklmnop", L"qrstuvwxyz"), 16); }
void runSuccess() { wchar_t s1[3]; s1[0] = L's'; s1[1] = L'1'; s1[2] = L'\0'; wchar_t s2[3]; s2[0] = L's'; s2[1] = L'2'; s2[2] = L'\0'; //@ assert \valid(s1+(0..2)); //@ assert \exists integer x; s1[x] == L'\0'; //@ assert \valid(s2+(0..2)); //@ assert \exists integer x; s2[x] == L'\0'; wcscspn(s1, s2); wcscspn(s1, s1); }
/// /// Find the next operand, and the delimiter that triggered it. This function returns false if the string is empty, otherwise, it returns true. /// bool FindNextOperand( __in PCWSTR pwzOperand, __in PCWSTR pwzDelimiters, __out PCWSTR *ppwzNextOperand, __out size_t * pcchOperand, __out WCHAR * pchDelimiter ) { if( *pwzOperand == '\0' ) { *ppwzNextOperand = pwzOperand; *pcchOperand = 0; *pchDelimiter = *pwzOperand; return( false ); } *pcchOperand = wcscspn( pwzOperand, pwzDelimiters ); *pchDelimiter = *(pwzOperand + *pcchOperand); if( *pchDelimiter != '\0' ) { *ppwzNextOperand = pwzOperand + *pcchOperand + 1; } else { *ppwzNextOperand = pwzOperand + *pcchOperand; } return( true ); }
int tst_wcscspn (FILE * fp, int debug_flg) { TST_DECL_VARS (size_t); wchar_t *ws1, *ws2; TST_DO_TEST (wcscspn) { TST_HEAD_LOCALE (wcscspn, S_WCSCSPN); TST_DO_REC (wcscspn) { TST_GET_ERRET (wcscspn); ws1 = TST_INPUT (wcscspn).ws1; ws2 = TST_INPUT (wcscspn).ws2; /* external value: size WCSSIZE */ ret = wcscspn (ws1, ws2); if (debug_flg) { fprintf (stderr, "wcscspn: ret = %d\n", ret); } TST_IF_RETURN (S_WCSCSPN) { }; } } return err_count; }
int main( void ) { TESTCASE( wcscspn( wabcde, L"x" ) == 5 ); TESTCASE( wcscspn( wabcde, L"xyz" ) == 5 ); TESTCASE( wcscspn( wabcde, L"zyx" ) == 5 ); TESTCASE( wcscspn( wabcdx, L"x" ) == 4 ); TESTCASE( wcscspn( wabcdx, L"xyz" ) == 4 ); TESTCASE( wcscspn( wabcdx, L"zyx" ) == 4 ); TESTCASE( wcscspn( wabcde, L"a" ) == 0 ); TESTCASE( wcscspn( wabcde, L"abc" ) == 0 ); TESTCASE( wcscspn( wabcde, L"cba" ) == 0 ); return TEST_RESULTS; }
/* * @implemented */ CHString CHString::SpanExcluding(LPCWSTR lpszCharSet) const throw (CHeap_Exception) { int Count; // Get position and then, extract Count = wcscspn(m_pchData, lpszCharSet); return Left(Count); }
/** * Expand wildcards in the given filepath and store results into vector. * If no wildcards are found then just the filepath is stored. * Note: only wildcards in the last filename of the path are expanded. * * @param vect the vector to receive wide-strings with file paths * @param filepath the filepath to process */ void expand_wildcards(vector_t* vect, wchar_t* filepath) { int added = 0; size_t len = wcslen(filepath); size_t index = wcscspn(filepath, L"*?"); /* if a wildcard has been found without a directory separator after it */ if(index < len && wcscspn(filepath + index, L"/\\") >= (len - index)) { wchar_t* parent; WIN32_FIND_DATAW d; HANDLE h; /* find directory separator */ for(; index > 0 && !IS_PATH_SEPARATOR(filepath[index]); index--); parent = (IS_PATH_SEPARATOR(filepath[index]) ? filepath : 0); h = FindFirstFileW(filepath, &d); if(INVALID_HANDLE_VALUE != h) { do { wchar_t* wpath; char* cstr; int failed; if((0 == wcscmp(d.cFileName, L".")) || (0 == wcscmp(d.cFileName, L".."))) continue; if(NULL == (wpath = make_pathw(parent, index + 1, d.cFileName))) continue; cstr = wchar_to_cstr(wpath, WIN_DEFAULT_ENCODING, &failed); /* note: just quietly skip unconvertible file names */ if(!cstr || failed) { free(cstr); free(wpath); continue; } rsh_vector_add_ptr(vect, cstr); added++; } while(FindNextFileW(h, &d)); FindClose(h); } } if(added == 0) { wchar_t* wpath = make_pathw(0, 0, filepath); char* cstr = w2c(wpath); if(cstr) rsh_vector_add_ptr(vect, cstr); } }
CUnicodeString CUnicodeString::SpanExcluding(LPCSTR lpszCharSet) { ASSERT(IsValidString(lpszCharSet)); WCHAR wc[1024]; DWORD dwszLen = strlen(lpszCharSet); ASSERT(dwszLen < 1024); wc[dwszLen] = L'\0'; MultiByteToWideChar(CP_ACP, 0, lpszCharSet, dwszLen, wc, dwszLen); return Left(wcscspn(m_Buffer, wc)); }
void testValues() { wchar_t s1[3]; s1[0] = L's'; s1[1] = L'1'; s1[2] = L'\0'; wchar_t s2[3]; s2[0] = L's'; s2[1] = L'2'; s2[2] = L'\0'; //@ assert \valid(s1+(0..2)); //@ assert \exists integer x; s1[x] == L'\0'; //@ assert \valid(s2+(0..2)); //@ assert \exists integer x; s2[x] == L'\0'; int result = wcscspn(s1, s2); //@ assert 0 <= result <= 2; //@ assert vacuous: \false; }
int _wstat(const WCHAR *path, struct _stat *buffer) { WIN32_FIND_DATA data; HANDLE handle; WCHAR *p; /* Fail if wildcard characters are specified */ if (wcscspn(path, L"?*") != wcslen(path)) return -1; handle = FindFirstFile(path, &data); if (handle == INVALID_HANDLE_VALUE) { errno = GetLastError(); return -1; } FindClose(handle); /* Found: Convert the file times */ buffer->st_mtime = convert_FILETIME_to_time_t(&data.ftLastWriteTime); if (data.ftLastAccessTime.dwLowDateTime || data.ftLastAccessTime.dwHighDateTime) buffer->st_atime = convert_FILETIME_to_time_t(&data.ftLastAccessTime); else buffer->st_atime = buffer->st_mtime; if (data.ftCreationTime.dwLowDateTime || data.ftCreationTime.dwHighDateTime) buffer->st_ctime = convert_FILETIME_to_time_t(&data.ftCreationTime); else buffer->st_ctime = buffer->st_mtime; /* Convert the file modes */ buffer->st_mode = (unsigned short)((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? (S_IFDIR | S_IEXEC) : S_IFREG); buffer->st_mode |= (data.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? S_IREAD : (S_IREAD | S_IWRITE); if((p = wcsrchr(path, L'.')) != NULL) { p++; if (_wcsicmp(p, L".exe") == 0) buffer->st_mode |= S_IEXEC; } buffer->st_mode |= (buffer->st_mode & 0700) >> 3; buffer->st_mode |= (buffer->st_mode & 0700) >> 6; /* Set the other information */ buffer->st_nlink = 1; buffer->st_size = (unsigned long int)data.nFileSizeLow; buffer->st_uid = 0; buffer->st_gid = 0; buffer->st_ino = 0 /*data.dwOID ?*/; buffer->st_dev = 0; return 0; /* success */ }
/////////////////////////////////////////////////////////////////////////////////////////// // common filter void Filter_c::Set ( const wchar_t * szFilter ) { int iLen = wcslen ( szFilter ); if ( wcscspn ( szFilter, L"?*[]" ) == iLen && iLen + 1 < MAX_FILTER_LEN - 2 ) { wchar_t szTemp [MAX_FILTER_LEN]; wcscpy ( &(szTemp [1]), szFilter ); szTemp [0] = L'*'; szTemp [iLen + 1] = L'*'; szTemp [iLen + 2] = L'\0'; BaseFilter_c::Set ( szTemp ); } else BaseFilter_c::Set ( szFilter ); }
/** Identify the type of path pointed to by Path. Paths are classified based upon their initial character sequences. ^\\ Absolute Path ^\. Relative Path ^[^:\\]: Mapping Path .* Relative Path Mapping paths are broken into two parts at the ':'. The part to the left of the ':' is the Map Name, pointed to by Path, and the part to the right of the ':' is pointed to by NewPath. If Path was not a Mapping Path, then NewPath is set to Path. @param[in] Path Pointer to the path to be classified. @param[out] NewPath Pointer to the path portion of a mapping path. @param[out] Length Length of the Map Name portion of the path. @retval PathAbsolute Path is an absolute path. NewPath points to the first '\'. @retval PathRelative Path is a relative path. NewPath = Path. @retval PathMapping Path is a mapping path. NewPath points to the character following ':'. @retval PathError Path is NULL. **/ PATH_CLASS EFIAPI ClassifyPath( IN wchar_t * Path, OUT wchar_t ** NewPath, OUT int * const Length ) { size_t MapLen; if(Path == NULL) { return PathError; // Bad parameter } if(NewPath != NULL) { *NewPath = Path; // Setup default condition } if((*Path == L'\\') || (*Path == L'\0')) { return PathAbsolute; } if(*Path == L'.') { return PathRelative; } /* The easy stuff has been done, now see if this is a mapping path. See if there is a ':' in Path that isn't the first character and is before any '\\' characters. */ MapLen = wcscspn(Path, L"\\:"); if(Length != NULL) { *Length = (int)MapLen; } /* MapLen == 0 means that the first character is a ':' == PathLen means that there are no '\\' or ':' Otherwise, Path[MapLen] == ':' for a mapping path or '\\' for a relative path. */ if(MapLen == 0) { return PathError; } if(Path[MapLen] == L':') { if(NewPath != NULL) { *NewPath = &Path[MapLen + 1]; // Point to character after then ':'. Might be '\0'. } return PathMapping; } return PathRelative; }
wchar_t* wcstok(wchar_t* str, const wchar_t* delim, wchar_t** saveptr) { if ( !str && !*saveptr ) return NULL; if ( !str ) str = *saveptr; str += wcsspn(str, delim); // Skip leading if ( !*str ) return *saveptr = NULL; size_t amount = wcscspn(str, delim); if ( str[amount] ) *saveptr = str + amount + 1; else *saveptr = NULL; str[amount] = L'\0'; return str; }
bool findPackageFromEmbeddedZip(wchar_t* buf, DWORD cbSize) { bool ret = false; CResource zipResource; if (!zipResource.Load(L"DATA", IDR_UPDATE_ZIP)) { return false; } DWORD dwSize = zipResource.GetSize(); if (dwSize < 0x100) { return false; } BYTE* pData = (BYTE*)zipResource.Lock(); HZIP zipFile = OpenZip(pData, dwSize, NULL); ZRESULT zr; int index = 0; do { ZIPENTRY zentry; zr = GetZipItem(zipFile, index, &zentry); if (zr != ZR_OK && zr != ZR_MORE) { break; } if (wcsstr(zentry.name, L"nupkg")) { ZeroMemory(buf, cbSize); int idx = wcscspn(zentry.name, L"-"); memcpy(buf, zentry.name, sizeof(wchar_t) * idx); ret = true; break; } index++; } while (zr == ZR_MORE || zr == ZR_OK); CloseZip(zipFile); zipResource.Release(); return ret; }
/* vi_match(): * Vi go to matching () {} or [] * [%] */ libedit_private el_action_t /*ARGSUSED*/ vi_match(EditLine *el, wint_t c __attribute__((__unused__))) { const wchar_t match_chars[] = L"()[]{}"; wchar_t *cp; size_t delta, i, count; wchar_t o_ch, c_ch; *el->el_line.lastchar = '\0'; /* just in case */ i = wcscspn(el->el_line.cursor, match_chars); o_ch = el->el_line.cursor[i]; if (o_ch == 0) return CC_ERROR; delta = (size_t)(wcschr(match_chars, o_ch) - match_chars); c_ch = match_chars[delta ^ 1]; count = 1; delta = 1 - (delta & 1) * 2; for (cp = &el->el_line.cursor[i]; count; ) { cp += delta; if (cp < el->el_line.buffer || cp >= el->el_line.lastchar) return CC_ERROR; if (*cp == o_ch) count++; else if (*cp == c_ch) count--; } el->el_line.cursor = cp; if (el->el_chared.c_vcmd.action != NOP) { /* NB posix says char under cursor should NOT be deleted for -ve delta - this is different to netbsd vi. */ if (delta > 0) el->el_line.cursor++; cv_delfini(el); return CC_REFRESH; } return CC_CURSOR; }
void MakeDir(wchar_t const* dir) { size_t pos = 0; size_t len = wcslen(dir); while (true) { //找一段目录名 size_t dirNameLen = wcscspn(dir + pos, L"/\\"); if (pos + dirNameLen >= len) break; //最后一段是文件名而非目录名 if (dirNameLen > 0) { wchar_t tempBuffer[FILENAME_MAX] = {}; wcsncpy(tempBuffer, dir,pos + dirNameLen); my_wmkdir(tempBuffer); } pos += (dirNameLen + 1); //跳过当前段和分隔符 } }
TimingEvent* TimerEx::GetTimer( LPCWSTR timerId ) { if( NULL == timerId ) return m_Root; _ASSERT( "init not called" && (m_pDev != NULL) ); size_t len = wcslen(timerId); size_t seperator = wcscspn( timerId, L"/|\\" ); if( seperator < len ) { LPWSTR idCopy = new WCHAR[len+1]; wcscpy_s( idCopy, len+1, timerId ); idCopy[seperator] = 0; TimingEvent* te = m_Root; while( te ) { if( !wcscmp(idCopy, te->m_name ) ) { te = te->GetTimerRec( &idCopy[seperator+1] ); delete[] idCopy; return te; } te = te->m_next; } delete[] idCopy; } else { TimingEvent* te = m_Root; while( te ) { if( !wcscmp(timerId, te->m_name ) ) return te; te = te->m_next; } } return NULL; }
// when this function is called we know we're working on a copy of the name, so we can "destruct" it TimingEvent* TimingEvent::GetTimerRec( LPWSTR timerId ) { size_t len = wcslen(timerId); size_t seperator = wcscspn( timerId, L"/|\\" ); if( seperator<len ) timerId[seperator] = 0; TimingEvent* te = m_firstChild; while( te ) { if( !wcscmp(timerId, te->m_name ) ) { if( seperator<len ) te = te->GetTimerRec( &timerId[seperator+1] ); return te; } te = te->m_next; } return NULL; }
static TACommandVerdict wcscspn_cmd(TAThread thread,TAInputStream stream) { wchar_t* ws1; wchar_t* ws2; size_t res; // Prepare ws1 = (wchar_t*)readPointer(&stream); ws2 = (wchar_t*)readPointer(&stream); START_TARGET_OPERATION(thread); // Execute res = wcscspn(ws1, ws2); END_TARGET_OPERATION(thread); // Response writeSize(thread, res); sendResponse(thread); return taDefaultVerdict; }
TimingEvent* TimingEvent::GetTimer(LPCWSTR timerId) { size_t len = wcslen(timerId); size_t seperator = wcscspn( timerId, L"/|\\" ); if( seperator<len ) { LPWSTR idCopy = new WCHAR[len+1]; wcscpy_s( idCopy, len+1, timerId ); idCopy[seperator] = 0; TimingEvent* te = m_firstChild; while( te ) { if( !wcscmp(idCopy, te->m_name ) ) { te = te->GetTimerRec( &idCopy[seperator+1] ); delete[] idCopy; return te; } te = te->m_next; } delete[] idCopy; } else { TimingEvent* te = m_firstChild; while( te ) { if( !wcscmp(timerId, te->m_name ) ) return te; te = te->m_next; } } return NULL; }
/** * Scrobbles a track. Also finds meta data, length and (possibly) album, for * the current track. */ int Scrobblify::Start(const std::wstring& artist, const std::wstring& track) { // Handle currently playing track if (current_request_id_ > 0) { Stop(); } // Lines are divided into fields terminated by 0x1 const wchar_t kDelimiterChar = 0x1; const wchar_t kDelimiter[] = {kDelimiterChar, _T('\0')}; const size_t kDelimiterLength = 1; const size_t kHashLength = 32; const size_t kLongHashLength = 40; // Search all the meta-data files available for (std::vector<std::wstring>::const_iterator it = metadata_paths_.begin(); it != metadata_paths_.end(); ++it) { // Go get some meta data FILE *metadata_file; if (_wfopen_s(&metadata_file, (*it).c_str(), _T("r")) != 0) { continue; } std::wifstream in(metadata_file); const size_t kMaxLineLength = 2048; wchar_t line[kMaxLineLength]; // Skip first line (contains "21" for no apparent reason) in.getline(line, kMaxLineLength); // Skip if file is empty if (wcsnlen(line, 1) == 0) { in.close(); continue; } // Find hash for artist wchar_t artist_hash[kHashLength]; bool artist_hash_found = false; for (; wcsnlen(line, kMaxLineLength) > 0; in.getline(line, kMaxLineLength)) { if (wcsncmp(artist.c_str(), &line[kHashLength + kDelimiterLength], artist.size()) == 0) { artist_hash_found = true; wcsncpy(artist_hash, line, kHashLength); break; } } if (!artist_hash_found) { in.close(); continue; // Try next file } // Skip rest of artist section for (in.getline(line, kMaxLineLength); wcsnlen(line, kMaxLineLength) > 0; in.getline(line, kMaxLineLength)) {} in.getline(line, kMaxLineLength); // Skip section separator std::wifstream::pos_type album_section_position = in.tellg(); // Skip albums section -- move to next empty line for (; wcsnlen(line, kMaxLineLength) > 0; in.getline(line, kMaxLineLength)) { } // Parse songs section. Each song is formatted like // hash 32 bytes // track // artists ; split with 0x2 // long hash // length // ... int length = 0; bool track_found = false; wchar_t album_hash[kHashLength]; for (in.getline(line, kMaxLineLength); wcsnlen(line, kMaxLineLength) > 0; in.getline(line, kMaxLineLength)) { if (wcsncmp(track.c_str(), &line[kHashLength + kDelimiterLength], track.size()) == 0) { // Skip hash, separator, track, separator. wchar_t *p = &line[kHashLength + kDelimiterLength + track.size() + kDelimiterLength]; // Match any of the artists bool artist_match_found = wcsncmp(artist_hash, p, kHashLength) == 0; for (p += kHashLength; *p == 0x2; p += kHashLength + kDelimiterLength) { if (!artist_match_found && // Don't compare if artist has been found wcsncmp(artist_hash, &p[1], kHashLength) == 0) { artist_match_found = true; } } if (!artist_match_found) { continue; } p += kDelimiterLength + kLongHashLength + kDelimiterLength; // Read track length length = _wtoi(p); track_found = true; // Skip length p = wcschr(p, kDelimiterChar); p += kDelimiterLength; // Skip track number p = wcschr(p, kDelimiterChar); p += kDelimiterLength; // Get album hash wcsncpy(album_hash, p, kHashLength); break; } } if (!track_found || length <= 0) { in.close(); continue; } // Get album in.seekg(album_section_position); // Seek back to the album section std::wstring album; for (in.getline(line, kMaxLineLength); wcsnlen(line, kMaxLineLength) > 0; in.getline(line, kMaxLineLength)) { if (wcsncmp(album_hash, line, kHashLength) == 0) { size_t album_length = wcscspn(&line[kHashLength + kDelimiterLength], kDelimiter); album.assign(line, kHashLength + kDelimiterLength, album_length); break; } } in.close(); return current_request_id_ = scrob_submitter_.Start( ToUtf8(artist), ToUtf8(track), ToUtf8(album), "", length, scrobble_directory_); } // No meta-data found; fall back on a five minute track length // TODO(liesen): does this violate any AudioScrobbler rules? return current_request_id_ = scrob_submitter_.Start( ToUtf8(artist), ToUtf8(track), "", "", 5 * 60, // five minutes -- more than most songs scrobble_directory_); }
CUnicodeString CUnicodeString::SpanExcluding(LPCWSTR lpszCharSet) { ASSERT(IsValidString(lpszCharSet)); return Left(wcscspn(m_Buffer, lpszCharSet)); }
wchar_t *wcspbrk(const wchar_t *s, const wchar_t *b) { s += wcscspn(s, b); return *s ? (wchar_t *)s : NULL; }
int scilab_sscanf(wchar_t* _wcsFormat, wchar_t* _wcsData, int _iIterrator, int _iNiter, std::vector<types::InternalType*> *_pITOut) { int i = 0; int j = 0; int nbrOfDigit = 0; int dims = 2; int dimsArray[2] = {_iNiter, 1}; BOOL bStar = FALSE; BOOL bUnsigned = FALSE; BOOL bNegatif = FALSE; BOOL bIgnoredChars = TRUE; int base = 0; wchar_t wcsLLH = L' '; wchar_t* wcsData = NULL; int sizeOfData = (int)wcslen(_wcsData); int iCountDataRead = 0; wcsData = (wchar_t*)MALLOC((sizeOfData + 1) * sizeof(wchar_t)); memcpy(wcsData, _wcsData, sizeOfData * sizeof(wchar_t)); wcsData[sizeOfData] = '\0'; while (i < (int)wcslen(_wcsFormat)) { while (bIgnoredChars && i < (int)wcslen(_wcsFormat)) // %da%s => 'a' is an ignored char. { if (wcsData != NULL && wcsData[0] != L'\0' && _wcsFormat[i] == wcsData[0]) { if (_wcsFormat[i] != L' ') { i++; wcsData++; } else { while (wcsData[0] == L' ') { wcsData++; } while (_wcsFormat[i] == L' ') { i++; } } } else if ((wcsData == NULL || wcsData[0] == L'\0') && i < (int)wcslen(_wcsFormat) && iCountDataRead == 0 && _pITOut->size() == 0) { iCountDataRead = -1; } else { if (_wcsFormat[i] == L' ') { do { i++; } while (i < (int)wcslen(_wcsFormat) && _wcsFormat[i] == L' '); } if (_wcsFormat[i] != L'%') { wcsData = NULL; while (i < (int)wcslen(_wcsFormat) && _wcsFormat[i] != L'%') { i++; } } break; } } if (i == (int)wcslen(_wcsFormat)) { break; } if (iswdigit(_wcsFormat[i])) { nbrOfDigit = wcstol(&_wcsFormat[i], NULL, 10); while (iswdigit(_wcsFormat[i])) { i++; } } else switch (_wcsFormat[i]) { case L' ' : case L'\n': case L'\t': i++; break; case L'%' : i++; bIgnoredChars = FALSE; break; case L'*' : bStar = TRUE; i++; break; case L'h' : case L'l' : case L'L' : wcsLLH = _wcsFormat[i]; i++; break; case L'c' : { if (wcsData != NULL && wcsData[0] != L'\0') // If the end of data has not been reached we can get datas. { wchar_t wcSingleData[2]; wcSingleData[0] = wcsData[0]; wcSingleData[1] = 0; if (!bStar) // If this format is not ignored put the datas found. { if (_iIterrator == 0) // Create and initialize the container only the first time. { types::String* pS = new types::String(dims, dimsArray); for (int k = 0 ; k < pS->getSize(); k++) { pS->set(k, L""); } _pITOut->push_back(pS); } (*_pITOut)[j]->getAs<types::String>()->set(_iIterrator, wcSingleData); iCountDataRead++; } wcsData++; } else { if (_iIterrator == 0 && !bStar && _iNiter == 1) { _pITOut->push_back(types::Double::Empty()); } else { return -10; } } if (!bStar) { j++; } i++; bIgnoredChars = TRUE; bStar = FALSE; } break; case L's' : { if (wcsData != NULL && wcsData[0] != L'\0') { wchar_t* wcsSingleData = NULL; wchar_t* wcsRes = NULL; wchar_t seps[] = L" \t\n"; int sizeOfCurrentData = (int)wcslen(wcsData); wchar_t* wcsTemp = (wchar_t*)MALLOC((sizeOfCurrentData + 1) * sizeof(wchar_t)); memcpy(wcsTemp, wcsData, sizeOfCurrentData * sizeof(wchar_t)); wcsTemp[sizeOfCurrentData] = L'\0'; wcsRes = os_wcstok(wcsTemp, seps, &wcsTemp); // the seps[] found is replaced by the '\0' char. if (wcsTemp == NULL || wcsTemp[0] == L'\0') { wcsData = NULL; } else { wcsData += (wcslen(wcsData) - wcslen(wcsTemp) - 1); // set the pointer on the seps[] and not on the next char. } if (nbrOfDigit) // Get only the numbers of digit indicated in the format. (ex: %2d) { wcsSingleData = (wchar_t*)MALLOC(sizeof(wchar_t) * (nbrOfDigit + 1)); memcpy(wcsSingleData, wcsRes, sizeof(wchar_t) * nbrOfDigit); wcsSingleData[nbrOfDigit] = L'\0'; nbrOfDigit = 0; } else // Get all data find. { wcsSingleData = wcsRes; } if (!bStar) { if (_iIterrator == 0) { types::String* pS = new types::String(dims, dimsArray); for (int k = 0 ; k < pS->getSize(); k++) { pS->set(k, L""); } _pITOut->push_back(pS); } (*_pITOut)[j]->getAs<types::String>()->set(_iIterrator, wcsSingleData); iCountDataRead++; } if (nbrOfDigit) { FREE(wcsSingleData); } } else { if (_iIterrator == 0 && !bStar && _iNiter == 1) { _pITOut->push_back(types::Double::Empty()); } else { return -10; } } if (!bStar) { j++; } i++; bIgnoredChars = TRUE; bStar = FALSE; } break; case L'[' : { if (wcsData != NULL && wcsData[0] != L'\0') { wchar_t* wcsInside = NULL; wchar_t* wcsCpyFormat = NULL; unsigned int iPos = 0; wchar_t* wcsSingleData = NULL; wchar_t* wcsRes = NULL; wchar_t* wscToFind = NULL; BOOL bInv = FALSE; i++; wcsCpyFormat = (wchar_t*)MALLOC((wcslen(_wcsFormat) - i + 1) * sizeof(wchar_t)); memcpy(wcsCpyFormat, &_wcsFormat[i], (wcslen(_wcsFormat) - i) * sizeof(wchar_t)); wcsCpyFormat[wcslen(_wcsFormat) - i] = L'\0'; wcsInside = os_wcstok(wcsCpyFormat, L"]", &wcsCpyFormat); i += (int)wcslen(wcsInside) + 1; // +1 => ] wscToFind = findChars(wcsInside, &bInv); if (wscToFind == NULL) { // MALLOC error return -10; } if (bInv) { iPos = (int)wcscspn(wcsData, wscToFind); } else { iPos = (int)wcsspn(wcsData, wscToFind); } if (iPos == 0) { // The string begins with a character which is not in wscToFind if (_iIterrator == 0 && !bStar && _iNiter == 1) { _pITOut->push_back(types::Double::Empty()); } else { return -10; } } else { wcsRes = (wchar_t*)MALLOC((iPos + 1) * sizeof(wchar_t)); memcpy(wcsRes, wcsData, iPos * sizeof(wchar_t)); wcsRes[iPos] = '\0'; FREE(wcsInside); if (nbrOfDigit) { wcsSingleData = (wchar_t*)MALLOC(sizeof(wchar_t) * (nbrOfDigit + 1)); memcpy(wcsSingleData, wcsRes, sizeof(wchar_t) * nbrOfDigit); wcsSingleData[nbrOfDigit] = L'\0'; wcsData += nbrOfDigit; } else { wcsSingleData = wcsRes; wcsData += iPos; } } if (!bStar) { if (_iIterrator == 0) { types::String* pS = new types::String(dims, dimsArray); for (int k = 0 ; k < pS->getSize(); k++) { pS->set(k, L""); } _pITOut->push_back(pS); } if (wcsSingleData != NULL) { (*_pITOut)[j]->getAs<types::String>()->set(_iIterrator, wcsSingleData); iCountDataRead++; } } if (nbrOfDigit) { FREE(wcsSingleData); } } else { if (_iIterrator == 0 && !bStar && _iNiter == 1) { _pITOut->push_back(types::Double::Empty()); } else { return -10; } } if (!bStar) { j++; } bIgnoredChars = TRUE; nbrOfDigit = 0; bStar = FALSE; } break; case L'x' : case L'X' : base += 6; // 6 + 2 + 8 = 16 // Compute the base of data to get. case L'u' : if (base == 0) { bUnsigned = TRUE; // unsigned int } case L'i' : case L'd' : base += 2; // 2 + 8 = 10 case L'o' : base += 8; // 8 = 8 :D { if (wcsData != NULL && wcsData[0] != L'\0') { long int iSingleData = 0; while (wcsData[0] == L' ') { wcsData++; } if (nbrOfDigit) { wchar_t* number = NULL; if (wcslen(wcsData) < nbrOfDigit) { nbrOfDigit = (int)wcslen(wcsData); } number = (wchar_t*)MALLOC((nbrOfDigit + 1) * sizeof(wchar_t)); memcpy(number, wcsData, nbrOfDigit * sizeof(wchar_t)); number[nbrOfDigit] = L'\0'; iSingleData = wcstoul(number, &number, base); if ((iSingleData == 0) && (number[0] == wcsData[0])) { if (_iIterrator == 0 && !bStar && _iNiter == 1) { wcsData = NULL; _pITOut->push_back(types::Double::Empty()); bStar = TRUE; } else { return -10; } } if (number == NULL) { wcsData += nbrOfDigit; } else { wcsData += (nbrOfDigit - wcslen(number)); } nbrOfDigit = 0; } else { wchar_t temp = wcsData[0]; iSingleData = wcstoul(wcsData, &wcsData, base); if ((iSingleData == 0) && (temp == wcsData[0])) { if (_iIterrator == 0 && !bStar && _iNiter == 1) { wcsData = NULL; _pITOut->push_back(types::Double::Empty()); bStar = TRUE; } else { return -10; } } } if (!bStar) { if (_iIterrator == 0) { switch (wcsLLH) { case L'h' : { if (bUnsigned) { types::UInt16* pUInt16 = new types::UInt16(dims, dimsArray); for (int k = 0; k < pUInt16->getSize(); k++) { pUInt16->set(k, 0); } _pITOut->push_back(pUInt16); } else { types::Int16* pInt16 = new types::Int16(dims, dimsArray); for (int k = 0; k < pInt16->getSize(); k++) { pInt16->set(k, 0); } _pITOut->push_back(pInt16); } } break; case L'l' : case L'L' : { if (bUnsigned) { types::UInt64* pUInt64 = new types::UInt64(dims, dimsArray); for (int k = 0; k < pUInt64->getSize(); k++) { pUInt64->set(k, 0); } _pITOut->push_back(pUInt64); } else { types::Int64* pInt64 = new types::Int64(dims, dimsArray); for (int k = 0; k < pInt64->getSize(); k++) { pInt64->set(k, 0); } _pITOut->push_back(pInt64); } } break; default : { if (bUnsigned) { types::UInt32* pUInt32 = new types::UInt32(dims, dimsArray); for (int k = 0; k < pUInt32->getSize(); k++) { pUInt32->set(k, 0); } _pITOut->push_back(pUInt32); } else { types::Int32* pInt32 = new types::Int32(dims, dimsArray); for (int k = 0; k < pInt32->getSize(); k++) { pInt32->set(k, 0); } _pITOut->push_back(pInt32); } } } } switch (wcsLLH) { case L'h' : if (bUnsigned) { (*_pITOut)[j]->getAs<types::UInt16>()->set(_iIterrator, static_cast<unsigned short int>(iSingleData)); iCountDataRead++; } else { (*_pITOut)[j]->getAs<types::Int16>()->set(_iIterrator, static_cast<short int>(iSingleData)); iCountDataRead++; } break; case L'l' : case L'L' : if (bUnsigned) { (*_pITOut)[j]->getAs<types::UInt64>()->set(_iIterrator, iSingleData); iCountDataRead++; } else { (*_pITOut)[j]->getAs<types::Int64>()->set(_iIterrator, static_cast<long int>(iSingleData)); iCountDataRead++; } break; default : if (bUnsigned) { (*_pITOut)[j]->getAs<types::UInt32>()->set(_iIterrator, static_cast<unsigned int>(iSingleData)); iCountDataRead++; } else { (*_pITOut)[j]->getAs<types::Int32>()->set(_iIterrator, static_cast<int>(iSingleData)); iCountDataRead++; } } } } else { if (_iIterrator == 0 && !bStar && _iNiter == 1) { _pITOut->push_back(types::Double::Empty()); } else { return -10; } } if (!bStar) { j++; } wcsLLH = L' '; bIgnoredChars = TRUE; bUnsigned = FALSE; bNegatif = FALSE; bStar = FALSE; base = 0; i++; } break; case L'e' : case L'E' : case L'g' : case L'G' : case L'f' : { if (wcsData != NULL && wcsData[0] != L'\0') { double dSingleData = 0; BOOL bSigne = FALSE; while (wcsData[0] == L' ') { wcsData++; } if (nbrOfDigit) { int iSizeRead = 0; wchar_t* number = NULL; wchar_t* next = NULL; if (wcslen(wcsData) < nbrOfDigit) { nbrOfDigit = (int)wcslen(wcsData); } number = (wchar_t*)MALLOC((nbrOfDigit + 1) * sizeof(wchar_t)); memcpy(number, wcsData, nbrOfDigit * sizeof(wchar_t)); number[nbrOfDigit] = L'\0'; dSingleData = wcstod(number, &next); if (next) { iSizeRead = nbrOfDigit - (int)wcslen(next); } else { iSizeRead = nbrOfDigit; } if ((dSingleData == 0) && (number[0] == next[0])) { if (_iIterrator == 0 && !bStar && _iNiter == 1) { wcsData = NULL; _pITOut->push_back(types::Double::Empty()); bStar = TRUE; } else { return -10; } } wcsData += iSizeRead; FREE(number); nbrOfDigit = 0; } else { int iLenData = (int)wcslen(wcsData); dSingleData = wcstod(wcsData, &wcsData); if ((dSingleData == 0) && (iLenData == wcslen(wcsData))) { if (_iIterrator == 0 && !bStar && _iNiter == 1) { wcsData = NULL; _pITOut->push_back(types::Double::Empty()); bStar = TRUE; } else { return -10; } } } if (!bStar) { if (_iIterrator == 0) { types::Double* pD = new types::Double(dims, dimsArray); for (int k = 0 ; k < pD->getSize(); k++) { pD->set(k, 0); } _pITOut->push_back(pD); } (*_pITOut)[j]->getAs<types::Double>()->set(_iIterrator, dSingleData); iCountDataRead++; } } else { if (_iIterrator == 0 && !bStar && _iNiter == 1) { _pITOut->push_back(types::Double::Empty()); } else { return -10; } } if (!bStar) { j++; } i++; bIgnoredChars = TRUE; bStar = FALSE; } break; case L'n' : { double dSingleData = -1; if (_iIterrator == 0 && !bStar) { types::Double* pD = new types::Double(dims, dimsArray); for (int k = 0 ; k < pD->getSize(); k++) { pD->set(k, 0); } _pITOut->push_back(pD); } if (wcsData == NULL || wcsData[0] == L'\0') { dSingleData = (double)sizeOfData; } else { dSingleData = (double)sizeOfData - (double)wcslen(wcsData); } if (!bStar) { (*_pITOut)[j]->getAs<types::Double>()->set(_iIterrator, dSingleData); j++; } i++; bIgnoredChars = TRUE; bStar = FALSE; } break; default : printf("format read : %c\n", _wcsFormat[i]); return -10; } } return iCountDataRead; }
int main() { mbstate_t mb = {0}; size_t s = 0; tm tm = {0}; wint_t w = 0; ::FILE* fp = 0; __darwin_va_list va; char* ns = 0; wchar_t* ws = 0; static_assert((std::is_same<decltype(fwprintf(fp, L"")), int>::value), ""); static_assert((std::is_same<decltype(fwscanf(fp, L"")), int>::value), ""); static_assert((std::is_same<decltype(swprintf(ws, s, L"")), int>::value), ""); static_assert((std::is_same<decltype(swscanf(L"", L"")), int>::value), ""); static_assert((std::is_same<decltype(vfwprintf(fp, L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vfwscanf(fp, L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vswprintf(ws, s, L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vswscanf(L"", L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vwprintf(L"", va)), int>::value), ""); static_assert((std::is_same<decltype(vwscanf(L"", va)), int>::value), ""); static_assert((std::is_same<decltype(wprintf(L"")), int>::value), ""); static_assert((std::is_same<decltype(wscanf(L"")), int>::value), ""); static_assert((std::is_same<decltype(fgetwc(fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(fgetws(ws, 0, fp)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(fputwc(L' ', fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(fputws(L"", fp)), int>::value), ""); static_assert((std::is_same<decltype(fwide(fp, 0)), int>::value), ""); static_assert((std::is_same<decltype(getwc(fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(getwchar()), wint_t>::value), ""); static_assert((std::is_same<decltype(putwc(L' ', fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(putwchar(L' ')), wint_t>::value), ""); static_assert((std::is_same<decltype(ungetwc(L' ', fp)), wint_t>::value), ""); static_assert((std::is_same<decltype(wcstod(L"", (wchar_t**)0)), double>::value), ""); static_assert((std::is_same<decltype(wcstof(L"", (wchar_t**)0)), float>::value), ""); static_assert((std::is_same<decltype(wcstold(L"", (wchar_t**)0)), long double>::value), ""); static_assert((std::is_same<decltype(wcstol(L"", (wchar_t**)0, 0)), long>::value), ""); static_assert((std::is_same<decltype(wcstoll(L"", (wchar_t**)0, 0)), long long>::value), ""); static_assert((std::is_same<decltype(wcstoul(L"", (wchar_t**)0, 0)), unsigned long>::value), ""); static_assert((std::is_same<decltype(wcstoull(L"", (wchar_t**)0, 0)), unsigned long long>::value), ""); static_assert((std::is_same<decltype(wcscpy(ws, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsncpy(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcscat(ws, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsncat(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcscmp(L"", L"")), int>::value), ""); static_assert((std::is_same<decltype(wcscoll(L"", L"")), int>::value), ""); static_assert((std::is_same<decltype(wcsncmp(L"", L"", s)), int>::value), ""); static_assert((std::is_same<decltype(wcsxfrm(ws, L"", s)), size_t>::value), ""); static_assert((std::is_same<decltype(wcschr((wchar_t*)0, L' ')), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcscspn(L"", L"")), size_t>::value), ""); static_assert((std::is_same<decltype(wcslen(L"")), size_t>::value), ""); static_assert((std::is_same<decltype(wcspbrk((wchar_t*)0, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsrchr((wchar_t*)0, L' ')), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsspn(L"", L"")), size_t>::value), ""); static_assert((std::is_same<decltype(wcsstr((wchar_t*)0, L"")), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcstok(ws, L"", (wchar_t**)0)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemchr((wchar_t*)0, L' ', s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemcmp(L"", L"", s)), int>::value), ""); static_assert((std::is_same<decltype(wmemcpy(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemmove(ws, L"", s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wmemset(ws, L' ', s)), wchar_t*>::value), ""); static_assert((std::is_same<decltype(wcsftime(ws, s, L"", &tm)), size_t>::value), ""); static_assert((std::is_same<decltype(btowc(0)), wint_t>::value), ""); static_assert((std::is_same<decltype(wctob(w)), int>::value), ""); static_assert((std::is_same<decltype(mbsinit(&mb)), int>::value), ""); static_assert((std::is_same<decltype(mbrlen("", s, &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(mbrtowc(ws, "", s, &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(wcrtomb(ns, L' ', &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(mbsrtowcs(ws, (const char**)0, s, &mb)), size_t>::value), ""); static_assert((std::is_same<decltype(wcsrtombs(ns, (const wchar_t**)0, s, &mb)), size_t>::value), ""); }
/* Implementation based on [1]. [1] http://www.kernel.org/doc/man-pages/online/pages/man3/getopt.3.html */ int getopt_long(int argc, wchar_t* const argv[], const wchar_t* optstring, const struct option* longopts, int* longindex) { const struct option* o = longopts; const struct option* match = NULL; int num_matches = 0; size_t argument_name_length = 0; const wchar_t* current_argument = NULL; int retval = -1; optarg = NULL; optopt = 0; if (optind >= argc) return -1; if (wcslen(argv[optind]) < 3 || wcsncmp(argv[optind], L"--", 2) != 0) return getopt(argc, argv, optstring); /* It's an option; starts with -- and is longer than two chars. */ current_argument = argv[optind] + 2; argument_name_length = wcscspn(current_argument, L"="); for (; o->name; ++o) { if (wcsncmp(o->name, current_argument, argument_name_length) == 0) { match = o; ++num_matches; /* if it's an exact match, i.e. there was no '=' in it, this is the one */ if (wcscmp(o->name, current_argument) == 0) break; } } if (num_matches == 1) { /* If longindex is not NULL, it points to a variable which is set to the index of the long option relative to longopts. */ if (longindex) *longindex = (match - longopts); /* If flag is NULL, then getopt_long() shall return val. Otherwise, getopt_long() returns 0, and flag shall point to a variable which shall be set to val if the option is found, but left unchanged if the option is not found. */ if (match->flag) *(match->flag) = match->val; retval = match->flag ? 0 : match->val; if (match->has_arg != no_argument) { optarg = wcschr(argv[optind], '='); if (optarg != NULL) ++optarg; if (match->has_arg == required_argument) { /* Only scan the next argv for required arguments. Behavior is not specified, but has been observed with Ubuntu and Mac OSX. */ if (optarg == NULL && ++optind < argc) { optarg = argv[optind]; } if (optarg == NULL) retval = ':'; } } else if (wcschr(argv[optind], '=')) { /* An argument was provided to a non-argument option. I haven't seen this specified explicitly, but both GNU and BSD-based implementations show this behavior. */ retval = '?'; } } else { /* Unknown option or ambiguous match. */ retval = '?'; } ++optind; return retval; }
/// /// Find the operands for the instruction for x86 and x64 /// void Findx86_x64Operands( INSTRUCTION *pInstruction, const INSTRUCTION_INFO& objInstructionInfo, PCWSTR *ppwzRegisters ) { // Set the implicit operands const OPERAND *pOperands = (const OPERAND *) objInstructionInfo.arrImplicitSourceRegisters; while( (pOperands != NULL) && pOperands->pwzOperand != NULL ) { pInstruction->setSourceRegisters.insert( *pOperands ); pOperands++; } pOperands = (const OPERAND *) objInstructionInfo.arrImplicitDestinationRegisters; while( (pOperands != NULL) && pOperands->pwzOperand != NULL ) { pInstruction->setDestinationRegisters.insert( *pOperands ); pOperands++; } pOperands = (const OPERAND *) objInstructionInfo.arrImplicitDestinationPointerRegisters; while( (pOperands != NULL) && pOperands->pwzOperand != NULL ) { pInstruction->setDestinationPointerRegisters.insert( *pOperands ); pOperands++; } pOperands = (const OPERAND *) objInstructionInfo.arrImplicitPassedOrReturnedRegisters; while( (pOperands != NULL) && pOperands->pwzOperand != NULL ) { pInstruction->setPassedOrReturnedRegisters.insert( *pOperands ); pOperands++; } if( objInstructionInfo.eOperandClassification == NO_OPERANDS ) { return; } // Set our search rules. Note that we have some special case code to handle EBP and ESP references, because we // want to be able to track those. To do that, we end up with special monitoring flags and an extra backwards looking // operand pointer. bool fInSource = !HAS_DEST_OPERANDS( objInstructionInfo.eOperandClassification ) || HAS_OPERAND_ORDER_REVERSED( objInstructionInfo.eOperandClassification ); bool fInIndirectReference = false; bool fInMonitoredPointerReference = false; PCWSTR pwzMonitoredPointerOperand = NULL; PCWSTR pwzOperand = pInstruction->pwzArguments; PCWSTR pwzNextOperand = NULL; size_t cchOperand; WCHAR chDelimiter; while( FindNextOperand( pwzOperand, L"[], :+-*", &pwzNextOperand, &cchOperand, &chDelimiter ) ) { // Prepare for the next iteration PCWSTR pwzCurrentOperand = pwzOperand; pwzOperand = pwzNextOperand; // Cache state information for this iteration bool fWasInIndirectReference = fInIndirectReference; bool fWasInSource = fInSource; // Check the delimiter we found, because it can change things switch( chDelimiter ) { case ',': { if( HAS_OPERAND_ORDER_REVERSED( objInstructionInfo.eOperandClassification ) ) { fInSource = !HAS_DEST_OPERANDS( objInstructionInfo.eOperandClassification ); } else { fInSource = HAS_SOURCE_OPERANDS( objInstructionInfo.eOperandClassification ); } } break; case '[': fInIndirectReference = true; break; case ']': fInIndirectReference = false; if( fInMonitoredPointerReference ) { OPERAND objOperand; objOperand.pwzOperand = pwzMonitoredPointerOperand; objOperand.cchOperand = (pwzCurrentOperand - pwzMonitoredPointerOperand) + cchOperand; if( fWasInSource ) { pInstruction->setSourceRegisters.insert( objOperand ); } else { // If the destination operand is flagged as being unaffected by the instruction, don't add it // to the destination register set if( !HAS_DEST_OPERAND_AS_UNAFFECTED( objInstructionInfo.eOperandClassification ) ) { pInstruction->setDestinationRegisters.insert( objOperand ); } // If the destination is flagged as being an implied source register, we add it to the // implied source registers as well if( HAS_DEST_OPERAND_AS_IMPLIED_SOURCE( objInstructionInfo.eOperandClassification ) ) { pInstruction->setSourceRegisters.insert( objOperand ); } } // We additionally tag registers that were explicitly defined, rather than implicitly defined pInstruction->setExplicitRegisters.insert( objOperand ); // And we tag compound registers because we want to be able to invalidate them // if the indexing registers are changed if( wcscspn( objOperand.pwzOperand, L", :+-*" ) < objOperand.cchOperand ) { pInstruction->setCompoundRegisters.insert( objOperand ); } fInMonitoredPointerReference = false; pwzMonitoredPointerOperand = NULL; // And we're done, since we've added the pointer reference as a logical register continue; } break; case ':': continue; } // Continue if we don't have any actual operand if( cchOperand == 0 ) { continue; } // Otherwise, we have to check the operand found to see if we are going to add it to the list if( IsStringInSet( pwzCurrentOperand, cchOperand, X64_X86_EXCLUDED_OPERANDS ) ) { fInMonitoredPointerReference = false; pwzMonitoredPointerOperand = NULL; continue; } /// Skip the numbers if( iswdigit( *pwzCurrentOperand ) ) { continue; } // Skip items in parentheses if( *pwzCurrentOperand == '(' ) { fInMonitoredPointerReference = false; pwzMonitoredPointerOperand = NULL; continue; } // Skip anything that isn't a register if( !IsStringInSet( pwzCurrentOperand, cchOperand, ppwzRegisters ) ) { continue; } // Check to see if this is a monitored register (for local variable references) if( fInIndirectReference && (pwzCurrentOperand[cchOperand-1] == 'p') && (pwzMonitoredPointerOperand == NULL) && ((chDelimiter == '+') || (chDelimiter == '-')) ) { fInMonitoredPointerReference = true; pwzMonitoredPointerOperand = pwzCurrentOperand; } else { fInMonitoredPointerReference = false; pwzMonitoredPointerOperand = NULL; } // Add the register OPERAND objOperand; objOperand.pwzOperand = pwzCurrentOperand; objOperand.cchOperand = cchOperand; if( fWasInSource ) { pInstruction->setSourceRegisters.insert( objOperand ); } else { // If the destination operand is flagged as being unaffected by the instruction, don't add it // to the destination register set if( !HAS_DEST_OPERAND_AS_UNAFFECTED( objInstructionInfo.eOperandClassification ) ) { if( fWasInIndirectReference || !HAS_DEST_REGISTERS( objInstructionInfo.eOperandClassification) ) { pInstruction->setDestinationPointerRegisters.insert( objOperand ); } else { pInstruction->setDestinationRegisters.insert( objOperand ); } } // If the destination is flagged as being an implied source register, we add it to the // implied source registers as well if( HAS_DEST_OPERAND_AS_IMPLIED_SOURCE( objInstructionInfo.eOperandClassification ) ) { pInstruction->setSourceRegisters.insert( objOperand ); } } // We additionally tag registers that were explicitly defined, rather than implicitly defined pInstruction->setExplicitRegisters.insert( objOperand ); } }
/* allocate and fill the file_search_data */ file_search_data* create_file_search_data(rsh_tchar** paths, size_t count, int max_depth) { size_t i; file_search_data* data = (file_search_data*)rsh_malloc(sizeof(file_search_data)); memset(data, 0, sizeof(file_search_data)); rsh_blocks_vector_init(&data->root_files); data->max_depth = max_depth; #ifdef _WIN32 /* expand wildcards and fill the root_files */ for (i = 0; i < count; i++) { int added = 0; size_t length, index; wchar_t* path = paths[i]; wchar_t* p = wcschr(path, L'\0') - 1; /* strip trailing '\','/' symbols (if not preceded by ':') */ for (; p > path && IS_PATH_SEPARATOR_W(*p) && p[-1] != L':'; p--) *p = 0; /* Expand a wildcard in the current file path and store results into data->root_files. * If a wildcard is not found then just the file path is stored. * NB, only wildcards in the last filename of the path are expanded. */ length = p - path + 1; index = wcscspn(path, L"*?"); if (index < length && wcscspn(path + index, L"/\\") >= (length - index)) { /* a wildcard is found without a directory separator after it */ wchar_t* parent; WIN32_FIND_DATAW d; HANDLE handle; /* find a directory separator before the file name */ for (; index > 0 && !IS_PATH_SEPARATOR(path[index]); index--); parent = (IS_PATH_SEPARATOR(path[index]) ? path : 0); handle = FindFirstFileW(path, &d); if (INVALID_HANDLE_VALUE != handle) { do { file_t file; int failed; if (IS_CURRENT_OR_PARENT_DIRW(d.cFileName)) continue; memset(&file, 0, sizeof(file)); file.wpath = make_pathw(parent, index + 1, d.cFileName); if (!file.wpath) continue; /* skip directories if not in recursive mode */ if (data->max_depth == 0 && (d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) continue; /* convert file name */ file.path = wchar_to_cstr(file.wpath, WIN_DEFAULT_ENCODING, &failed); if (!failed) { failed = (file_statw(&file) < 0); } /* quietly skip unconvertible file names */ if (!file.path || failed) { if (failed) { data->errors_count++; } free(file.path); free(file.wpath); continue; } /* fill the file information */ file.mode |= FILE_IFROOT; add_root_file(data, &file); added++; } while (FindNextFileW(handle, &d)); FindClose(handle); } else { /* report error on the specified wildcard */ char * cpath = wchar_to_cstr(path, WIN_DEFAULT_ENCODING, NULL); set_errno_from_last_file_error(); log_file_error(cpath); free(cpath); data->errors_count++; } } else { int failed; file_t file; memset(&file, 0, sizeof(file)); /* if filepath is a dash string "-" */ if ((path[0] == L'-' && path[1] == L'\0')) { file.mode = FILE_IFSTDIN; file.path = rsh_strdup("(stdin)"); } else { file.path = wchar_to_cstr(path, WIN_DEFAULT_ENCODING, &failed); if (failed) { log_error(_("Can't convert the path to local encoding: %s\n"), file.path); free(file.path); data->errors_count++; continue; } file.wpath = path; if (file_statw(&file) < 0) { log_file_error(file.path); free(file.path); data->errors_count++; continue; } } /* mark the file as obtained from the command line */ file.mode |= FILE_IFROOT; file.wpath = rsh_wcsdup(path); add_root_file(data, &file); } } /* for */ #else /* copy file paths */ for (i = 0; i < count; i++) { file_t file; file_init(&file, paths[i], 0); if (IS_DASH_STR(file.path)) { file.mode = FILE_IFSTDIN; } else if (file_stat2(&file, USE_LSTAT) < 0) { log_file_error(file.path); file_cleanup(&file); data->errors_count++; continue; } file.mode |= FILE_IFROOT; add_root_file(data, &file); } #endif return data; }
CCOMStringW CCOMStringW::SpanExcluding(const WCHAR* lpszCharSet) { ATLASSERT(lpszCharSet != NULL); ATLASSERT(::IsBadStringPtrW(lpszCharSet, -1) == 0); return Left(wcscspn(m_pszString, lpszCharSet)); }
static int wrap(wchar_t *prefix, wchar_t *suffix, int indent_len, wchar_t *str) { int len, n, col; int maxlen, tmpcol; wchar_t *p, *pw, *ppw; static const wchar_t eol[] = {L'\r', L'\n', L'\0'}; /* * Display the initial stuff followed by a colon. */ if ((len = wscol(suffix))) n = fprintf(stderr, gettext("%*ws: %ws: "), indent_len - len - 2, prefix, suffix); else n = fprintf(stderr, gettext("%*ws: "), indent_len, prefix); if (n <= 0) return (-1); maxlen = LINE_LEN - indent_len - 1; /* Check for bogus indent_len */ if (maxlen < 1) { return (-1); } /* * Loop once for each line of the string to display. */ for (p = str; *p; ) { /* * Display the next "len" bytes of the string, where * "len" is the smallest of: * * - LINE_LEN * - # bytes before control character * - # bytes left in string * */ len = wcscspn(p, eol); /* calc how many columns the string will take */ col = wcswidth(p, len); if (col > maxlen) { /* * How many characters fit into our desired line length */ pw = p; tmpcol = 0; while (*pw) { if (iswprint(*pw)) tmpcol += wcwidth(*pw); if (tmpcol > maxlen) break; else pw++; } /* * At this point, pw may point to: * A null character: EOL found (should never happen, though) * The character that just overruns the maxlen. */ if (!*pw) { /* * Found a EOL. * This should never happen. */ len = pw - p; goto printline; } ppw = pw; /* * Don't split words * * Bugid 4202307 - liblpoam in lp internal library doesn't * handle multibyte character. */ while (pw > p) { if (iswspace(*pw) || (wdbindf(*(pw - 1), *pw, 1) < 5)) { break; } else { pw--; } } if (pw != p) { len = pw - p; } else { /* * Failed to find the best place to fold. * So, prints as much characters as maxlen allows */ len = ppw - p; } } printline: for (n = 0; n < len; n++, p++) { if (iswprint(*p)) { if (fputwc(*p, stderr) == WEOF) { return (-1); } } } /* * If we displayed up to a control character, * put out the control character now; otherwise, * put out a newline unless we've put out all * the text. */ if (*p == L'\r' || *p == L'\n') { while (*p == L'\r' || *p == L'\n') { if (fputwc(*p, stderr) == WEOF) return (-1); p++; } } else if (*p) { if (fputwc(L'\n', stderr) == WEOF) return (-1); } while (iswspace(*p)) p++; /* * If the loop won't end this time (because we * have more stuff to display) put out leading * blanks to align the next line with the previous * lines. */ if (*p) { for (n = 0; n < indent_len + 2; n++) (void) fputwc(L' ', stderr); } } return (1); }