bool voikko_is_nonword(const wchar_t * word, size_t nchars) {
// If X is a character (possibly other than '.'), then the following
// patterns (URLs and email addresses) will be considered non-words:
// X*//X*.X+
// X*@X+.X+
// www.X+.X+
if (nchars < 4) return false;
const wchar_t * i = wmemchr(word, L'/', nchars - 3);
if (i && i[1] == L'/' && wmemchr(i + 1, L'.', nchars - (i - word) - 2)) {
return true;
}
i = wmemchr(word, L'@', nchars - 3);
if (i && i[1] != L'.' && wmemchr(i + 1, L'.', nchars - (i - word) - 2)) {
return true;
}
if (nchars < 7) {
return false;
}
if ((wcsncmp(L"www.", word, 4) == 0) &&
word[4] != L'.' &&
wmemchr(word + 5, L'.', nchars - 5)) {
return true;
}
return false;
}
int main( void )
{
TESTCASE( wmemchr( wabcde, L'c', 5 ) == &wabcde[2] );
TESTCASE( wmemchr( wabcde, L'a', 1 ) == &wabcde[0] );
TESTCASE( wmemchr( wabcde, L'a', 0 ) == NULL );
TESTCASE( wmemchr( wabcde, L'\0', 5 ) == NULL );
TESTCASE( wmemchr( wabcde, L'\0', 6 ) == &wabcde[5] );
return TEST_RESULTS;
}
static __inline int
inccl(const struct ccl *ccl, wint_t wi)
{
if (ccl->compl) {
return (wmemchr(ccl->start, wi, ccl->end - ccl->start)
== NULL);
} else {
return (wmemchr(ccl->start, wi, ccl->end - ccl->start) != NULL);
}
}
static int
processLine (char *line, void *data) {
const char *string = line;
size_t length = strlen(string);
const char *byte = string;
size_t count = length + 1;
wchar_t characters[count];
wchar_t *character = characters;
convertUtf8ToWchars(&byte, &character, count);
length = character - characters;
character = characters;
while (1) {
const wchar_t *end = wmemchr(character, FF, length);
if (!end) break;
count = end - character;
if (!processCharacters(character, count, *end, data)) return 0;
count += 1;
character += count;
length -= count;
}
if (!processCharacters(character, length, '\n', data)) return 0;
if (opt_forceOutput)
if (!flushOutputStream(data))
return 0;
return 1;
}
int
brlDotNumberToIndex (wchar_t number, int *index) {
const wchar_t *character = wmemchr(brlDotNumbers, number, ARRAY_COUNT(brlDotNumbers));
if (!character) return 0;
*index = character - brlDotNumbers;
return 1;
}
getcchar(const cchar_t *wcval,
wchar_t *wch,
attr_t *attrs,
short *color_pair,
void *opts)
{
wchar_t *wp;
int len;
int code = ERR;
TR(TRACE_CCALLS, (T_CALLED("getcchar(%p,%p,%p,%p,%p)"),
wcval, wch, attrs, color_pair, opts));
if (opts == NULL) {
len = (wp = wmemchr(wcval->chars, L'\0', CCHARW_MAX))
? wp - wcval->chars
: CCHARW_MAX;
if (wch == NULL) {
code = len;
} else if (attrs == 0 || color_pair == 0) {
code = ERR;
} else if (len >= 0) {
*attrs = AttrOf(*wcval) & A_ATTRIBUTES;
*color_pair = GetPair(*wcval);
wmemcpy(wch, wcval->chars, (unsigned) len);
wch[len] = L'\0';
code = OK;
}
}
TR(TRACE_CCALLS, (T_RETURN("%d"), code));
return (code);
}
OMRawStorage*
OMXMLStorage::openNewDataStream(const wchar_t* uri)
{
TRACE("OMXMLStorage::openNewDataStream");
PRECONDITION("XML document raw storage has filename", _storage->fileName() != 0);
// uri is assumed to be 'stream directory' / 'stream file name' as
// created in getDataStreamEntityValue()
OMDiskRawStorage* storage = 0;
wchar_t* base = getBaseFilePath(_storage->fileName());
// start by creating the directory
wchar_t* workBuffer = new wchar_t[wcslen(uri) + 1];
wcscpy(workBuffer, uri);
wchar_t* sep = wmemchr(workBuffer, L'/', wcslen(uri));
ASSERT("New DataStream uri starts with a directory", sep != 0);
*sep = L'\0';
wchar_t* filepath = new wchar_t[wcslen(workBuffer) + 1];
wcsconvertURItoFilepath(workBuffer, filepath);
wchar_t* fullFilepath = new wchar_t[wcslen(base) + wcslen(filepath) + 1];
wcscpy(fullFilepath, base);
wcscat(fullFilepath, filepath);
wmkdir(fullFilepath);
delete [] workBuffer;
delete [] filepath;
delete [] fullFilepath;
// remove the file and then open new modify
filepath = new wchar_t[wcslen(uri) + 1];
wcsconvertURItoFilepath(uri, filepath);
fullFilepath = new wchar_t[wcslen(base) + wcslen(filepath) + 1];
wcscpy(fullFilepath, base);
wcscat(fullFilepath, filepath);
wremove(fullFilepath);
try
{
storage = OMDiskRawStorage::openNewModify(fullFilepath);
}
catch (...)
{
storage = 0;
}
delete [] filepath;
delete [] fullFilepath;
delete [] base;
return storage;
}
void SuggestionGeneratorSoftHyphens::generate(SuggestionStatus * s) const {
const size_t wlen = s->getWordLength();
const wchar_t * word = s->getWord();
const wchar_t * softHyphen = wmemchr(word, L'\u00AD', wlen);
if (softHyphen) {
wchar_t * buffer = new wchar_t[wlen];
size_t j = 0;
for (size_t i = 0; i < wlen; ++i) {
if (word[i] != L'\u00AD') {
buffer[j++] = word[i];
}
}
buffer[j] = L'\0';
SuggestionGeneratorCaseChange::suggestForBuffer(morAnalyzer, s, buffer, j);
delete[] buffer;
}
}
OMUniqueObjectIdentification
OMXMLStorage::getMetaDefIdFromQSymbol(const wchar_t* qSymbol) const
{
TRACE("OMXMLStorage::getMetaDefIdFromQSymbol");
// if the qSymbol refers to a non-baseline metadef then it
// must be in the qSymbolMap; otherwise it is a baseline qSymbol
OMUniqueObjectIdentification id = _metaDefIdMap.getId(qSymbol);
if (id == nullOMUniqueObjectIdentification)
{
// support qualified baseline symbols
// users __should__ use just the symbol for baseline metadefs
const wchar_t* spc = wmemchr(qSymbol, L' ', wcslen(qSymbol));
ASSERT("Valid QSymbol has space", spc != 0);
id = getBaselineMetaDefId(spc + 1);
}
return id;
}
static int has_invalid_null_termination(const ErlNifBinary *path) {
const WCHAR *null_pos, *end_pos;
null_pos = wmemchr((const WCHAR*)path->data, L'\0', path->size);
end_pos = (const WCHAR*)&path->data[path->size] - 1;
if(null_pos == NULL) {
return 1;
}
/* prim_file:internal_name2native sometimes feeds us data that is "doubly"
* NUL-terminated, so we'll accept any number of trailing NULs so long as
* they aren't interrupted by anything else. */
while(null_pos < end_pos && (*null_pos) == L'\0') {
null_pos++;
}
return null_pos != end_pos;
}
TInt CTestLibcwchar::wmemchr2L( )
{
wchar_t ws1[50]=L"abcdefghij",*retval;
retval = wmemchr(ws1,L'x',50);
INFO_PRINTF2(_L("wmemchr2 return is %d"),retval);
if(retval != NULL)
{
return KErrGeneral;
}
else
{
return KErrNone;
}
}
getcchar(const cchar_t *wcval,
wchar_t *wch,
attr_t *attrs,
short *color_pair,
void *opts)
{
wchar_t *wp;
int len;
int code = ERR;
TR(TRACE_CCALLS, (T_CALLED("getcchar(%p,%p,%p,%p,%p)"),
(const void *) wcval,
(void *) wch,
(void *) attrs,
(void *) color_pair,
opts));
if (opts == NULL) {
len = ((wp = wmemchr(wcval->chars, L'\0', CCHARW_MAX))
? (int) (wp - wcval->chars)
: CCHARW_MAX);
if (wch == NULL) {
/*
* If the value is a null, set the length to 1.
* If the value is not a null, return the length plus 1 for null.
*/
code = (len < CCHARW_MAX) ? (len + 1) : CCHARW_MAX;
} else if (attrs == 0 || color_pair == 0) {
code = ERR;
} else if (len >= 0) {
*attrs = AttrOf(*wcval) & A_ATTRIBUTES;
*color_pair = (short) GetPair(*wcval);
wmemcpy(wch, wcval->chars, (unsigned) len);
wch[len] = L'\0';
code = OK;
}
}
TR(TRACE_CCALLS, (T_RETURN("%d"), code));
return (code);
}
static const lua_WChar *lmemfind (const lua_WChar *s1, size_t l1,
const lua_WChar *s2, size_t l2) {
if (l2 == 0) return s1; /* empty strings are everywhere */
else if (l2 > l1) return NULL; /* avoids a negative `l1' */
else {
const lua_WChar *init; /* to search for a `*s2' inside `s1' */
l2--; /* 1st char will be checked by `memchr' */
l1 = l1-l2; /* `s2' cannot be found after that */
while (l1 > 0 && (init = (const lua_WChar *)wmemchr(s1, *s2, l1)) != NULL) {
init++; /* 1st char is already checked */
if (wmemcmp(init, s2+1, l2) == 0)
return init-1;
else { /* correct `l1' and `s1' to try again */
l1 -= init-s1;
s1 = init;
}
}
return NULL; /* not found */
}
}
TInt CTestLibcwchar::wmemchr1L( )
{
wchar_t ws1[50]=L"abcdefghij",*retval;
retval = wmemchr(ws1,L'c',10);
INFO_PRINTF1(_L("wmemchr1 result is"));
for(int i=0;i<9;i++)
{
INFO_PRINTF3(_L("retval[%d]=%x"),i,retval[i]);
if(retval[i] != ws1[i+2])
{
return KErrGeneral;
}
}
return KErrNone;
}
void test_wmemchr( void )
{
wchar_t* dest;
wint_t result;
wint_t ch = L'r';
wchar_t str[] = L"lazy";
wchar_t string1[60] = L"The quick brown dog jumps over the lazy fox";
wprintf( L"Wmemchr\n" );
wprintf( L"String to be searched:\n\t\t%s\n", string1 );
wprintf( L"\t\t%s\n\t\t%s\n\n", fmt1, fmt2 );
wprintf( L"Search char:\t%c\n", ch );
dest = wmemchr( string1, ch, sizeof( string1 ) );
result = dest - string1 + 1;
if( dest != NULL )
wprintf( L"Result:\t\t%c found at position %d\n\n", ch, result );
else
wprintf( L"Result:\t\t%c not found\n\n" );
return;
}
/***********************************************************************
* WindowsTrimStringStart (combase.@)
*/
HRESULT WINAPI WindowsTrimStringStart(HSTRING str1, HSTRING str2, HSTRING *out)
{
struct hstring_private *priv1 = impl_from_HSTRING(str1);
struct hstring_private *priv2 = impl_from_HSTRING(str2);
UINT32 start;
TRACE("(%p, %p, %p)\n", str1, str2, out);
if (!out || !str2 || !priv2->length)
return E_INVALIDARG;
if (!str1)
{
*out = NULL;
return S_OK;
}
for (start = 0; start < priv1->length; start++)
{
if (!wmemchr(priv2->buffer, priv1->buffer[start], priv2->length))
break;
}
return start ? WindowsCreateString(&priv1->buffer[start], priv1->length - start, out) :
WindowsDuplicateString(str1, out);
}
/***********************************************************************
* WindowsTrimStringEnd (combase.@)
*/
HRESULT WINAPI WindowsTrimStringEnd(HSTRING str1, HSTRING str2, HSTRING *out)
{
struct hstring_private *priv1 = impl_from_HSTRING(str1);
struct hstring_private *priv2 = impl_from_HSTRING(str2);
UINT32 len;
TRACE("(%p, %p, %p)\n", str1, str2, out);
if (!out || !str2 || !priv2->length)
return E_INVALIDARG;
if (!str1)
{
*out = NULL;
return S_OK;
}
for (len = priv1->length; len > 0; len--)
{
if (!wmemchr(priv2->buffer, priv1->buffer[len - 1], priv2->length))
break;
}
return (len < priv1->length) ? WindowsCreateString(priv1->buffer, len, out) :
WindowsDuplicateString(str1, out);
}
static TACommandVerdict wmemchr_cmd(TAThread thread,TAInputStream stream)
{
wchar_t* s;
wchar_t c;
size_t n;
wchar_t* res;
// Prepare
s = readPointer(&stream);
c = readWChar(&stream);
n = readSize(&stream);
// Execute
START_TARGET_OPERATION(thread);
res = wmemchr( s, c, n );
END_TARGET_OPERATION(thread);
// Response
writePointer(thread,res);
sendResponse(thread);
return taDefaultVerdict;
}
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), "");
}
int
cpbLinearCopy (int column, int row) {
int copied = 0;
ScreenDescription screen;
describeScreen(&screen);
{
int rightColumn = screen.cols - 1;
size_t length;
wchar_t *buffer = cpbReadScreen(&length, 0, beginRow, rightColumn, row);
if (buffer) {
if (column < rightColumn) {
wchar_t *start = buffer + length;
while (start != buffer) {
if (*--start == WC_C('\r')) {
start += 1;
break;
}
}
{
int adjustment = (column + 1) - (buffer + length - start);
if (adjustment < 0) length += adjustment;
}
}
if (beginColumn) {
wchar_t *start = wmemchr(buffer, WC_C('\r'), length);
if (!start) start = buffer + length;
if ((start - buffer) > beginColumn) start = buffer + beginColumn;
if (start != buffer) wmemmove(buffer, start, (length -= start - buffer));
}
{
const wchar_t *from = buffer;
const wchar_t *end = from + length;
wchar_t *to = buffer;
int spaces = 0;
int newlines = 0;
while (from != end) {
wchar_t character = *from++;
switch (character) {
case WC_C(' '):
spaces += 1;
continue;
case WC_C('\r'):
newlines += 1;
continue;
default:
break;
}
if (newlines) {
if ((newlines > 1) || (spaces > 0)) spaces = 1;
newlines = 0;
}
while (spaces) {
*to++ = WC_C(' ');
spaces -= 1;
}
*to++ = character;
}
length = to - buffer;
}
if (cpbEndOperation(buffer, length)) copied = 1;
free(buffer);
}
}
return copied;
}
_STD_BEGIN
#define ACSIZE 32 /* holds only prefix, m.s. digits */
int _WGetint(_WSft *px, void *pans)
{ /* get an integer value for _WScanf */
wchar_t ac[ACSIZE], *p;
char seen = 0;
wint_t ch;
static const wchar_t digits[] = {
L'0', L'1', L'2', L'3', L'4', L'5',
L'6', L'7', L'8', L'9', L'a', L'b',
L'c', L'd', L'e', L'f', L'A', L'B',
L'C', L'D', L'E', L'F'};
static const wchar_t flit[] = {
L'd', L'i', L'o', L'u', L'x', L'X',
L'p', L'\0'};
static const char barr[] = {10, 0, 8, 10, 16, 16, 16};
int base =
barr[(const wchar_t *)wcschr(&flit[0], *px->s) - flit];
int dlen;
px->nget = 0 < px->width ? px->width : INT_MAX;
p = ac, ch = WGETN(px);
if (ch == L'+' || ch == L'-')
*p++ = ch, ch = WGETN(px);
if (ch == L'0')
{ /* match possible prefix */
seen = 1;
*p++ = ch, ch = WGETN(px);
if ((ch == L'x' || ch == L'X')
&& (base == 0 || base == 16))
base = 16, *p++ = ch, ch = WGETN(px), seen = 0;
else if (base == 0)
base = 8;
}
dlen = base == 0 || base == 10 ? 10
: base == 8 ? 8 : 16 + 6;
for (; ch == L'0'; seen = 1)
ch = WGETN(px);
if (seen)
*p++ = L'0';
for (; ch != WEOF && wmemchr(&digits[0], ch, dlen);
ch = WGETN(px), seen = 1)
if (p < &ac[ACSIZE - 1])
*p++ = ch;
WUNGETN(px, ch);
if (!seen)
return (p == ac && ch == WEOF ? EOF : 0);
*p = L'\0';
if (px->noconv)
;
else if (*px->s == L'd' || *px->s == L'i')
{ /* deliver a signed integer */
const _Longlong lval = _WStoll(ac, 0, base);
px->stored = 1;
switch (px->qual)
{ /* store in specified integer type */
case L'b':
if (pans != 0)
*(signed char *)pans = (signed char)lval;
else
*va_arg(px->ap, signed char *) = (signed char)lval;
break;
case L'q':
if (pans != 0)
*(_Longlong *)pans = lval;
else
*va_arg(px->ap, _Longlong *) = lval;
break;
case L'j':
if (pans != 0)
*(intmax_t *)pans = lval;
else
*va_arg(px->ap, intmax_t *) = lval;
break;
case L't':
if (pans != 0)
*(ptrdiff_t *)pans = (ptrdiff_t)lval;
else
*va_arg(px->ap, ptrdiff_t *) = (ptrdiff_t)lval;
break;
case L'z':
if (pans != 0)
*(ptrdiff_t *)pans = (ptrdiff_t)lval;
else
*va_arg(px->ap, ptrdiff_t *) = (ptrdiff_t)lval;
break;
case L'h':
if (pans != 0)
*(short *)pans = (short)lval;
else
*va_arg(px->ap, short *) = (short)lval;
break;
case L'l':
if (pans != 0)
*(long *)pans = (long)lval;
else
*va_arg(px->ap, long *) = (long)lval;
break;
default:
if (pans != 0)
*(int *)pans = (int)lval;
else
*va_arg(px->ap, int *) = (int)lval;
}
}
else
{ /* deliver an unsigned integer */
_IO_size_t
_IO_getwline_info (_IO_FILE *fp, wchar_t *buf, _IO_size_t n, wint_t delim,
int extract_delim, wint_t *eof)
{
wchar_t *ptr = buf;
if (eof != NULL)
*eof = 0;
if (__builtin_expect (fp->_mode, 1) == 0)
_IO_fwide (fp, 1);
while (n != 0)
{
_IO_ssize_t len = (fp->_wide_data->_IO_read_end
- fp->_wide_data->_IO_read_ptr);
if (len <= 0)
{
wint_t wc = __wuflow (fp);
if (wc == WEOF)
{
if (eof)
*eof = wc;
break;
}
if (wc == delim)
{
if (extract_delim > 0)
*ptr++ = wc;
else if (extract_delim < 0)
_IO_sputbackc (fp, wc);
if (extract_delim > 0)
++len;
return ptr - buf;
}
*ptr++ = wc;
n--;
}
else
{
wchar_t *t;
if ((_IO_size_t) len >= n)
len = n;
t = wmemchr ((void *) fp->_wide_data->_IO_read_ptr, delim, len);
if (t != NULL)
{
_IO_size_t old_len = ptr - buf;
len = t - fp->_wide_data->_IO_read_ptr;
if (extract_delim >= 0)
{
++t;
if (extract_delim > 0)
++len;
}
wmemcpy ((void *) ptr, (void *) fp->_wide_data->_IO_read_ptr,
len);
fp->_wide_data->_IO_read_ptr = t;
return old_len + len;
}
wmemcpy ((void *) ptr, (void *) fp->_wide_data->_IO_read_ptr, len);
fp->_wide_data->_IO_read_ptr += len;
ptr += len;
n -= len;
}
}
return ptr - buf;
}
wchar_t *wstring_fmt_real(wchar_t *wstring, const wchar_t *fmt, ...) {
va_list args;
va_start(args, fmt);
try wstring = wstring_fmt_real_v(wstring, fmt, args);
va_end(args);
catch throw_proxy();
return wstring;
};
wchar_t *wstring_fmt_real_v(wchar_t *wstring, const wchar_t *fmt, va_list args) {
if (!fmt) throw(exception_type_null, EINVAL, second_arg_is_null, NULL);
scope {
wchar_t *new_wstring = array_new(wchar_t, 1, ARRAY_NULL_TERMINATED);
int wanted_size;
va_list args_copy;
try {
for (va_copy(args_copy, args);
(wanted_size = vswprintf(new_wstring, array_length(new_wstring) + sizeof(wchar_t), fmt, args_copy)) > (ssize_t)array_length(new_wstring);
va_copy(args_copy, args)) {
va_end(args_copy);
array_resize(new_wstring, wanted_size);
};
va_end(args_copy);
if (wanted_size < 0) throw_errno();
array_resize(new_wstring, wanted_size);
};
catch throw_proxy();
wstring_set(wstring, new_wstring);
};
return wstring;
};
wchar_t *wstring_cut_real(wchar_t *wstring, size_t pos, size_t len) {
try {
if (pos + len < pos) throw(exception_type_integer_overflow, ERANGE, integer_overflow, NULL);
if (pos + len >= array_length(wstring)) {
throw(exception_type_index_out_of_bound, EINVAL, index_out_of_bound, NULL);
};
wmemmove(&wstring[pos], &wstring[pos + len], array_length(wstring) - len - pos);
array_resize(wstring, array_length(wstring) - len);
};
catch throw_proxy();
return wstring;
};
size_t wstring_length(wchar_t *wstring) {
size_t ret = 0;
try {
ret = array_length(wstring);
};
catch throw_proxy();
return ret;
};
wchar_t *wstring_new() {
wchar_t *wstring = NULL;
try {
wstring = array_new(wchar_t, 0, ARRAY_NULL_TERMINATED);
};
catch throw_proxy();
return wstring;
};
wchar_t *wstring_push_real(wchar_t *wstring, wchar_t push) {
if (!push) throw(exception_type_null, EINVAL, second_arg_is_null, NULL);
try {
array_push(wstring, push);
};
catch throw_proxy();
return wstring;
};
wchar_t *wstring_clean_real(wchar_t *wstring) {
try {
array_resize(wstring, 0);
};
catch throw_proxy();
return wstring;
};
wchar_t *wstring_set_real(wchar_t *wstring, const wchar_t *set) {
if (!set) throw(exception_type_null, EINVAL, second_arg_is_null, NULL);
try {
array_resize(wstring, wcslen(set));
};
catch throw_proxy();
wcscpy(wstring, set);
return wstring;
};
wchar_t *wstring_cat_real(wchar_t *wstring, const wchar_t *cat) {
if (!cat) throw(exception_type_null, EINVAL, second_arg_is_null, NULL);
try {
array_add(wstring, cat, wcslen(cat));
};
catch throw_proxy();
return wstring;
};
wchar_t *wstring_ncat_real(wchar_t *wstring, const wchar_t *cat, size_t cat_len) {
if (!cat) throw(exception_type_null, EINVAL, second_arg_is_null, NULL);
wchar_t *end_str;
if ((end_str = wmemchr(cat, L'\0', cat_len))) {
cat_len = end_str - cat;
};
try {
array_add(wstring, cat, cat_len);
};
catch throw_proxy();
return wstring;
};
wchar_t *wstring_new_fmt(const wchar_t *fmt, ...) {
va_list va;
wchar_t *ret = NULL;
va_start(va, fmt);
try {
ret = wstring_new_fmt_v(fmt, va);
};
va_end(va);
catch throw_proxy();
return ret;
};
wchar_t *wstring_set_from_string_real(wchar_t *wstring, const char *string) {
if (!string) throw(exception_type_null, EINVAL, second_arg_is_null, NULL);
try {
size_t need_size = mbstowcs(NULL, string, 0);
array_resize(wstring, need_size);
mbstowcs(wstring, string, need_size);
};
catch throw_proxy();
return wstring;
};
wchar_t *wstring_new_set(const wchar_t *set) {
wchar_t *string = NULL;
try {
string = array_new(wchar_t, set ? wcslen(set) : 0, ARRAY_NULL_TERMINATED);
if (set) wcscpy(string, set);
};
catch throw_proxy();
return string;
};
wchar_t *wstring_new_fmt_v(const wchar_t *fmt, va_list va) {
return wstring_fmt_real_v(wstring_new(), fmt, va);
};
DWRITE_TEXT_METRICS TextFormatD2D::GetMetrics(
const WCHAR* str, UINT strLen, bool gdiEmulation, float maxWidth)
{
// GDI+ compatibility: If the last character is a newline, GDI+ measurements seem to ignore it.
bool strippedLastNewLine = false;
if (strLen > 2 && str[strLen - 1] == L'\n')
{
strippedLastNewLine = true;
--strLen;
if (str[strLen - 1] == L'\r')
{
--strLen;
}
}
DWRITE_TEXT_METRICS metrics = {0};
Microsoft::WRL::ComPtr<IDWriteTextLayout> textLayout;
HRESULT hr = CanvasD2D::c_DWFactory->CreateTextLayout(
str,
strLen,
m_TextFormat.Get(),
maxWidth,
10000,
textLayout.GetAddressOf());
if (SUCCEEDED(hr))
{
const float xOffset = m_TextFormat->GetFontSize() / 6.0f;
if (gdiEmulation)
{
Microsoft::WRL::ComPtr<IDWriteTextLayout1> textLayout1;
textLayout.As(&textLayout1);
const float emOffset = xOffset / 24.0f;
const DWRITE_TEXT_RANGE range = {0, strLen};
textLayout1->SetCharacterSpacing(emOffset, emOffset, 0.0f, range);
}
textLayout->GetMetrics(&metrics);
if (metrics.width > 0.0f)
{
if (gdiEmulation)
{
metrics.width += xOffset * 2;
metrics.height += m_ExtraHeight;
// GDI+ compatibility: If the string contains a newline (even if it is the
// stripped last character), GDI+ adds the line gap to the overall height.
if (strippedLastNewLine || wmemchr(str, L'\n', strLen) != nullptr)
{
metrics.height += m_LineGap;
}
}
else
{
// GDI+ compatibility: With accurate metrics, the line gap needs to be subtracted
// from the overall height if the string does not contain newlines.
if (!strippedLastNewLine && wmemchr(str, L'\n', strLen) == nullptr)
{
metrics.height -= m_LineGap;
}
}
}
else
{
// GDI+ compatibility: Get rid of the height that DirectWrite assigns to zero-width
// strings.
metrics.height = 0.0f;
}
}
return metrics;
}
size_t wcsnlen(const wchar_t *s, size_t n)
{
const wchar_t *z = wmemchr(s, 0, n);
if (z) n = z-s;
return n;
}
/**
* `wchar_t` version of `strnlen`.
*
* @param str The string.
* @param maxlen The number of bytes to inspect, at most.
* @return The number of `wchar_t`:s before the
* first NUL character. `maxlen` if no
* NUL character was found.
*
* @since Always.
*/
size_t wcsnlen(const wchar_t* str, size_t maxlen)
{
const wchar_t* end = wmemchr(str, 0, maxlen);
return end == NULL ? maxlen : (size_t)(end - str);
}
gcc_pure gcc_nonnull_all
static inline wchar_t *
StringFind(wchar_t *haystack, wchar_t needle, size_t size)
{
return wmemchr(haystack, needle, size);
}
BOOL ClipboardPaste(void)
{
HGLOBAL hMem = 0;
LPSTR lpMem;
UINT uFormat = CharSet == CS_OEM ? CF_OEMTEXT : CF_TEXT;
LONG lSize;
MODEENUM SaveMode;
BOOL FreeConversionMemory = FALSE;
if (IsViewOnly()) return(FALSE);
/*prepare resources...*/
if (!OpenClipboard(hwndMain)) {
ErrorBox(MB_ICONEXCLAMATION, 302);
return (FALSE);
}
/*first check for binary data containing null bytes...*/
if (UtfEncoding != 16 && (hMem = GetClipboardData(uFormat)) != 0) {
lSize = GlobalSize(hMem);
if ((lpMem = GlobalLock(hMem)) != NULL) {
LPSTR lp;
LONG lRemain;
lp = _fmemchr(lpMem, '\0', (size_t)lSize);
if (lp != NULL && (lp-lpMem+sizeof(BinaryPart)) <= (size_t)lSize
&& lp[1]==BinaryFormat[0]
&& _fmemchr(lp+1, '\0', lSize-(lp+1-lpMem)) != NULL
&& _fmemcmp(lp+1, BinaryFormat, 10) == 0) {
/*insert first part of null containing binary data...*/
SaveMode = Mode;
if (Mode != InsertMode && Mode != ReplaceMode) {
StartUndoSequence();
Mode = InsertMode;
}
if (SelectCount) DeleteSelected(17);
else EnterDeleteForUndo(&CurrPos, 0, 1); /*force new undo elem*/
Mode = SaveMode;
HideEditCaret();
if (*lpMem) InsertBuffer(lpMem, (UINT)(lp-lpMem), 0);
lRemain = strtoul(lp+11, &lp, 10);
if (*lp != ':') lSize = 0;
else {
if (lSize >= (lp - lpMem) + lRemain) lSize = lRemain;
else lSize = 0;
lpMem = lp + 1;
}
if (lSize) InsertBuffer(lpMem, (UINT)lSize, 1);
GetXPos(&CurrCol);
ShowEditCaret();
/*clean up...*/
GlobalUnlock(hMem);
CloseClipboard();
return (TRUE);
}
GlobalUnlock(hMem);
hMem = 0;
}
}
/*then, if running on Windows NT, try to get wide chars...*/
if (!(GetVersion() & 0x80000000U) && CharSet != CS_EBCDIC) {
UINT Cp;
if (UtfEncoding == 8)
Cp = CP_UTF8;
else if (CharSet == CS_ANSI)
Cp = AnsiCodePage;
else Cp = OemCodePage;
if (Cp) {
HGLOBAL hWideCharMem = GetClipboardData(CF_UNICODETEXT);
WCHAR *lpWideCharMem;
if (hWideCharMem) {
lSize = GlobalSize(hWideCharMem);
lpWideCharMem = GlobalLock(hWideCharMem);
if (lpWideCharMem != NULL) {
INT nSizeRequired;
PWCHAR wp;
lSize >>= 1;
wp = wmemchr(lpWideCharMem, '\0', lSize);
if (wp != NULL) lSize = wp - lpWideCharMem;
if (UtfEncoding == 16) {
lSize <<= 1;
if (UtfLsbFirst) {
hMem = hWideCharMem;
lpMem = (LPSTR)lpWideCharMem;
} else {
hMem = GlobalAlloc(GMEM_MOVEABLE, lSize);
if (hMem) {
lpMem = GlobalLock(hMem);
if (lpMem != NULL) {
INT i = 0;
while ((i += 2) <= lSize) {
lpMem[i-2] = *lpWideCharMem >> 8;
lpMem[i-1] = *lpWideCharMem++ & 255;
}
FreeConversionMemory = TRUE;
} else {
GlobalFree(hMem);
hMem = 0;
}
}
}
} else {
BOOL IsWordDiv(int c)
{
return (wmemchr(Opt.WordDiv, c, Opt.WordDivLen)!=NULL);
}
static const char_type*
find(const char_type* __s, size_t __n, const char_type& __a)
{ return (char_type*)wmemchr((wchar_t*)__s, __a, __n); }
