string.c File Reference

#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <limits.h>
#include <locale.h>
#include <float.h>
#include "msvcrt.h"
#include "bnum.h"
#include "winnls.h"
#include "wine/asm.h"
#include "wine/debug.h"

Include dependency graph for string.c:

Go to the source code of this file.

Classes
struct	_I10_OUTPUT_DATA

Macros
#define	LDBL_EXP_BITS   15
#define	LDBL_MANT_BITS   64
#define	I10_OUTPUT_MAX_PREC   21
#define	MERGE(w1, sh1, w2, sh2)   ((w1 >> sh1) | (w2 << sh2))

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msvcrt)
char *CDECL	_strdup (const char *str)
int CDECL	_strlwr_s_l (char *str, size_t len, _locale_t locale)
int CDECL	_strlwr_s (char *str, size_t len)
char *CDECL	_strlwr_l (char *str, _locale_t locale)
char *CDECL	_strlwr (char *str)
int CDECL	_strupr_s_l (char *str, size_t len, _locale_t locale)
int CDECL	_strupr_s (char *str, size_t len)
char *CDECL	_strupr_l (char *str, _locale_t locale)
char *CDECL	_strupr (char *str)
int CDECL	_strnset_s (char *str, size_t size, int c, size_t count)
char *CDECL	_strnset (char *str, int value, size_t len)
char *CDECL	_strrev (char *str)
char *CDECL	_strset (char *str, int value)
char *CDECL	strtok (char *str, const char *delim)
char *CDECL	strtok_s (char *str, const char *delim, char **ctx)
void CDECL	_swab (char *src, char *dst, int len)
static struct fpnum	fpnum (int sign, int exp, ULONGLONG m, enum fpmod mod)
int	fpnum_double (struct fpnum *fp, double *d)
int	fpnum_ldouble (struct fpnum *fp, MSVCRT__LDOUBLE *d)
static BOOL	bnum_to_mant (struct bnum *b, ULONGLONG *m)
static struct fpnum	fpnum_parse_bnum (wchar_t(*get)(void *ctx), void(*unget)(void *ctx), void *ctx, pthreadlocinfo locinfo, BOOL ldouble, struct bnum *b)
struct fpnum	fpnum_parse (wchar_t(*get)(void *ctx), void(*unget)(void *ctx), void *ctx, pthreadlocinfo locinfo, BOOL ldouble)
static wchar_t	strtod_str_get (void *ctx)
static void	strtod_str_unget (void *ctx)
static double	strtod_helper (const char *str, char **end, _locale_t locale, int *perr)
double CDECL	_strtod_l (const char *str, char **end, _locale_t locale)
double CDECL	strtod (const char *str, char **end)
double CDECL	atof (const char *str)
double CDECL	_atof_l (const char *str, _locale_t locale)
int CDECL	_atoflt_l (_CRT_FLOAT *value, char *str, _locale_t locale)
int CDECL	_atoflt (_CRT_FLOAT *value, char *str)
int CDECL	_atodbl_l (_CRT_DOUBLE *value, char *str, _locale_t locale)
int CDECL	_atodbl (_CRT_DOUBLE *value, char *str)
int CDECL	_strcoll_l (const char *str1, const char *str2, _locale_t locale)
int CDECL	strcoll (const char *str1, const char *str2)
int CDECL	_stricoll_l (const char *str1, const char *str2, _locale_t locale)
int CDECL	_stricoll (const char *str1, const char *str2)
int CDECL	_strncoll_l (const char *str1, const char *str2, size_t count, _locale_t locale)
int CDECL	_strncoll (const char *str1, const char *str2, size_t count)
int CDECL	_strnicoll_l (const char *str1, const char *str2, size_t count, _locale_t locale)
int CDECL	_strnicoll (const char *str1, const char *str2, size_t count)
char *__cdecl	strncpy (char *dst, const char *src, size_t len)
int __cdecl	strncpy_s (char *dst, size_t elem, const char *src, size_t count)
char *CDECL	strcpy (char *dst, const char *src)
int CDECL	strcpy_s (char *dst, size_t elem, const char *src)
int CDECL	strcat_s (char *dst, size_t elem, const char *src)
char *__cdecl	strcat (char *dst, const char *src)
int CDECL	strncat_s (char *dst, size_t elem, const char *src, size_t count)
char *__cdecl	strncat (char *dst, const char *src, size_t len)
size_t CDECL	_strxfrm_l (char *dest, const char *src, size_t len, _locale_t locale)
size_t CDECL	strxfrm (char *dest, const char *src, size_t len)
int CDECL	__STRINGTOLD_L (MSVCRT__LDOUBLE *value, char **endptr, const char *str, int flags, _locale_t locale)
int CDECL	__STRINGTOLD (MSVCRT__LDOUBLE *value, char **endptr, const char *str, int flags)
int CDECL	_atoldbl_l (MSVCRT__LDOUBLE *value, char *str, _locale_t locale)
int CDECL	_atoldbl (_LDOUBLE *value, char *str)
size_t __cdecl	strlen (const char *str)
size_t CDECL	strnlen (const char *s, size_t maxlen)
__int64 CDECL	_strtoi64_l (const char *nptr, char **endptr, int base, _locale_t locale)
__int64 CDECL	_strtoi64 (const char *nptr, char **endptr, int base)
int __cdecl	_atoi_l (const char *str, _locale_t locale)
int __cdecl	atoi (const char *str)
__int64 CDECL	_atoi64_l (const char *str, _locale_t locale)
__int64 CDECL	_atoi64 (const char *str)
__msvcrt_long CDECL	_atol_l (const char *str, _locale_t locale)
__msvcrt_long CDECL	atol (const char *str)
__msvcrt_long CDECL	_strtol_l (const char *nptr, char **end, int base, _locale_t locale)
__msvcrt_long CDECL	strtol (const char *nptr, char **end, int base)
__msvcrt_ulong CDECL	_strtoul_l (const char *nptr, char **end, int base, _locale_t locale)
__msvcrt_ulong CDECL	strtoul (const char *nptr, char **end, int base)
unsigned __int64 CDECL	_strtoui64_l (const char *nptr, char **endptr, int base, _locale_t locale)
unsigned __int64 CDECL	_strtoui64 (const char *nptr, char **endptr, int base)
static int	ltoa_helper (__msvcrt_long value, char *str, size_t size, int radix)
static int	ltow_helper (__msvcrt_long value, wchar_t *str, size_t size, int radix)
int CDECL	_ltoa_s (__msvcrt_long value, char *str, size_t size, int radix)
int CDECL	_ltow_s (__msvcrt_long value, wchar_t *str, size_t size, int radix)
int CDECL	_itoa_s (int value, char *str, size_t size, int radix)
char *CDECL	_itoa (int value, char *str, int radix)
char *CDECL	_ltoa (__msvcrt_long value, char *str, int radix)
int CDECL	_itow_s (int value, wchar_t *str, size_t size, int radix)
wchar_t *CDECL	_itow (int value, wchar_t *str, int radix)
wchar_t *CDECL	_ltow (__msvcrt_long value, wchar_t *str, int radix)
char *CDECL	_ultoa (__msvcrt_ulong value, char *str, int radix)
char *CDECL	_ui64toa (unsigned __int64 value, char *str, int radix)
wchar_t *CDECL	_ultow (__msvcrt_ulong value, wchar_t *str, int radix)
wchar_t *CDECL	_ui64tow (unsigned __int64 value, wchar_t *str, int radix)
char *CDECL	_i64toa (__int64 value, char *str, int radix)
wchar_t *CDECL	_i64tow (__int64 value, wchar_t *str, int radix)
int CDECL	_ui64toa_s (unsigned __int64 value, char *str, size_t size, int radix)
int CDECL	_ui64tow_s (unsigned __int64 value, wchar_t *str, size_t size, int radix)
int CDECL	_ultoa_s (__msvcrt_ulong value, char *str, size_t size, int radix)
int CDECL	_ultow_s (__msvcrt_ulong value, wchar_t *str, size_t size, int radix)
int CDECL	_i64toa_s (__int64 value, char *str, size_t size, int radix)
int CDECL	_i64tow_s (__int64 value, wchar_t *str, size_t size, int radix)
int CDECL	I10_OUTPUT (MSVCRT__LDOUBLE ld80, int prec, int flag, struct _I10_OUTPUT_DATA *data)
static int	memcmp_bytes (const void *ptr1, const void *ptr2, size_t n)
static int	memcmp_blocks (const void *ptr1, const void *ptr2, size_t size)
int __cdecl	memcmp (const void *ptr1, const void *ptr2, size_t n)
void *__cdecl	memmove (void *dst, const void *src, size_t n)
void *__cdecl	memcpy (void *dst, const void *src, size_t n)
void *__cdecl	_memccpy (void *dst, const void *src, int c, size_t n)
static void	memset_aligned_32 (unsigned char *d, uint64_t v, size_t n)
void *__cdecl	memset (void *dst, int c, size_t n)
char *__cdecl	strchr (const char *str, int c)
char *__cdecl	strrchr (const char *str, int c)
void *__cdecl	memchr (const void *ptr, int c, size_t n)
int __cdecl	strcmp (const char *str1, const char *str2)
int __cdecl	strncmp (const char *str1, const char *str2, size_t len)
int __cdecl	_strnicmp_l (const char *s1, const char *s2, size_t count, _locale_t locale)
int __cdecl	_stricmp_l (const char *s1, const char *s2, _locale_t locale)
int __cdecl	_strnicmp (const char *s1, const char *s2, size_t count)
int __cdecl	_stricmp (const char *s1, const char *s2)
char *__cdecl	strstr (const char *haystack, const char *needle)
int __cdecl	_memicmp_l (const void *v1, const void *v2, size_t len, _locale_t locale)
int __cdecl	_memicmp (const void *s1, const void *s2, size_t len)
size_t __cdecl	strcspn (const char *str, const char *reject)
size_t __cdecl	strspn (const char *str, const char *accept)
char *__cdecl	strpbrk (const char *str, const char *accept)
size_t __cdecl	__strncnt (const char *str, size_t size)

Macro Definition Documentation

I10_OUTPUT_MAX_PREC

#define I10_OUTPUT_MAX_PREC   21

Definition at line 2663 of file string.c.

LDBL_EXP_BITS

#define LDBL_EXP_BITS   15

Definition at line 479 of file string.c.

LDBL_MANT_BITS

#define LDBL_MANT_BITS   64

Definition at line 480 of file string.c.

MERGE

#define MERGE	(		w1,
			sh1,
			w2,
			sh2
	)		((w1 >> sh1) | (w2 << sh2))

Definition at line 3086 of file string.c.

Function Documentation

__STRINGTOLD()

int CDECL __STRINGTOLD	(	MSVCRT__LDOUBLE *	value,
		char **	endptr,
		const char *	str,
		int	flags
	)

Definition at line 1562 of file string.c.

{
    return __STRINGTOLD_L( value, endptr, str, flags, NULL );
}

Referenced by test___STRINGTOLD().

__STRINGTOLD_L()

int CDECL __STRINGTOLD_L	(	MSVCRT__LDOUBLE *	value,
		char **	endptr,
		const char *	str,
		int	flags,
		_locale_t	locale
	)

Definition at line 1523 of file string.c.

{
#ifdef __REACTOS__
    WINE_BROKEN_LDOUBLE value[1];
#endif
    pthreadlocinfo locinfo;
    const char *beg, *p;
    int err, ret = 0;
    struct fpnum fp;
 
    if (flags) FIXME("flags not supported: %x\n", flags);
 
    if (!locale)
        locinfo = get_locinfo();
    else
        locinfo = locale->locinfo;
 
    p = str;
    while (_isspace_l((unsigned char)*p, locale))
        p++;
    beg = p;
 
    fp = fpnum_parse(strtod_str_get, strtod_str_unget, &p, locinfo, TRUE);
    if (endptr) *endptr = (p == beg ? (char*)str : (char*)p);
    if (p == beg) ret = 4;
 
    err = fpnum_ldouble(&fp, value);
    if (err) ret = (value->x80[2] & 0x7fff ? 2 : 1);
#ifdef __REACTOS__
    memcpy(value_, value, sizeof(*value_));
#endif
    return ret;
}

Referenced by __STRINGTOLD(), and _atoldbl_l().

__strncnt()

size_t __cdecl __strncnt	(	const char *	str,
		size_t	size
	)

Definition at line 3534 of file string.c.

{
    size_t ret = 0;
 
#if _MSVCR_VER >= 140
    while (*str++ && size--)
#else
    while (size-- && *str++)
#endif
    {
        ret++;
    }
 
    return ret;
}

Referenced by test___strncnt().

_atodbl()

int CDECL _atodbl	(	_CRT_DOUBLE *	value,
		char *	str
	)

Definition at line 1162 of file string.c.

{
    return _atodbl_l(value, str, NULL);
}

Referenced by test__atodbl().

_atodbl_l()

int CDECL _atodbl_l	(	_CRT_DOUBLE *	value,
		char *	str,
		_locale_t	locale
	)

Definition at line 1147 of file string.c.

{
    int err;
 
    value->x = strtod_helper(str, NULL, locale, &err);
    if(isinf(value->x))
        return _OVERFLOW;
    if((value->x!=0 || err) && value->x>-DBL_MIN && value->x<DBL_MIN)
        return _UNDERFLOW;
    return 0;
}

Referenced by _atodbl().

_atof_l()

double CDECL _atof_l	(	const char *	str,
		_locale_t	locale
	)

Definition at line 1114 of file string.c.

{
    return _strtod_l(str, NULL, locale);
}

_atoflt()

int CDECL _atoflt	(	_CRT_FLOAT *	value,
		char *	str
	)

Definition at line 1139 of file string.c.

{
    return _atoflt_l(value, str, NULL);
}

_atoflt_l()

int CDECL _atoflt_l	(	_CRT_FLOAT *	value,
		char *	str,
		_locale_t	locale
	)

Definition at line 1122 of file string.c.

{
    double d;
    int err;
 
    d = strtod_helper(str, NULL, locale, &err);
    value->f = d;
    if(isinf(value->f))
        return _OVERFLOW;
    if((d!=0 || err) && value->f>-FLT_MIN && value->f<FLT_MIN)
        return _UNDERFLOW;
    return 0;
}

Referenced by _atoflt().

_atoi64()

__int64 CDECL _atoi64

(

const char *

str

)

Definition at line 1757 of file string.c.

{
    return _strtoi64_l(str, NULL, 10, NULL);
}

_atoi64_l()

__int64 CDECL _atoi64_l	(	const char *	str,
		_locale_t	locale
	)

Definition at line 1749 of file string.c.

{
    return _strtoi64_l(str, NULL, 10, locale);
}

_atoi_l()

int __cdecl _atoi_l	(	const char *	str,
		_locale_t	locale
	)

Definition at line 1697 of file string.c.

{
    __int64 ret = _strtoi64_l(str, NULL, 10, locale);
 
    if(ret > INT_MAX) {
        ret = INT_MAX;
        *_errno() = ERANGE;
    } else if(ret < INT_MIN) {
        ret = INT_MIN;
        *_errno() = ERANGE;
    }
    return ret;
}

_atol_l()

__msvcrt_long CDECL _atol_l	(	const char *	str,
		_locale_t	locale
	)

Definition at line 1765 of file string.c.

{
    __int64 ret = _strtoi64_l(str, NULL, 10, locale);
 
    if(ret > LONG_MAX) {
        ret = LONG_MAX;
        *_errno() = ERANGE;
    } else if(ret < LONG_MIN) {
        ret = LONG_MIN;
        *_errno() = ERANGE;
    }
    return ret;
}

Referenced by atol().

_atoldbl()

int CDECL _atoldbl	(	_LDOUBLE *	value,
		char *	str
	)

Definition at line 1584 of file string.c.

{
    return _atoldbl_l( (MSVCRT__LDOUBLE*)value, str, NULL );
}

_atoldbl_l()

int CDECL _atoldbl_l	(	MSVCRT__LDOUBLE *	value,
		char *	str,
		_locale_t	locale
	)

Definition at line 1570 of file string.c.

{
    char *endptr;
    switch(__STRINGTOLD_L( value, &endptr, str, 0, locale ))
    {
    case 1: return _UNDERFLOW;
    case 2: return _OVERFLOW;
    default: return 0;
    }
}

Referenced by _atoldbl().

_i64toa()

char *CDECL _i64toa	(	__int64	value,
		char *	str,
		int	radix
	)

Definition at line 2247 of file string.c.

{
    unsigned __int64 val;
    BOOL is_negative;
    char buffer[65], *pos;
 
    if (value < 0 && radix == 10)
    {
        is_negative = TRUE;
        val = -value;
    }
    else
    {
        is_negative = FALSE;
        val = value;
    }
 
    pos = buffer + 64;
    *pos = '\0';
 
    do
    {
        int digit = val % radix;
        val /= radix;
 
        if (digit < 10)
            *--pos = '0' + digit;
        else
            *--pos = 'a' + digit - 10;
    }
    while (val != 0);
 
    if (is_negative)
        *--pos = '-';
 
    memcpy(str, pos, buffer + 65 - pos);
    return str;
}

_i64toa_s()

int CDECL _i64toa_s	(	__int64	value,
		char *	str,
		size_t	size,
		int	radix
	)

Definition at line 2516 of file string.c.

{
    unsigned __int64 val;
    unsigned int digit;
    BOOL is_negative;
    char buffer[65], *pos;
    size_t len;
 
    if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
    {
        str[0] = '\0';
        return EINVAL;
    }
 
    if (value < 0 && radix == 10)
    {
        is_negative = TRUE;
        val = -value;
    }
    else
    {
        is_negative = FALSE;
        val = value;
    }
 
    pos = buffer + 64;
    *pos = '\0';
 
    do
    {
        digit = val % radix;
        val /= radix;
 
        if (digit < 10)
            *--pos = '0' + digit;
        else
            *--pos = 'a' + digit - 10;
    }
    while (val != 0);
 
    if (is_negative)
        *--pos = '-';
 
    len = buffer + 65 - pos;
    if (len > size)
    {
        size_t i;
        char *p = str;
 
        /* Copy the temporary buffer backwards up to the available number of
         * characters. Don't copy the negative sign if present. */
 
        if (is_negative)
        {
            p++;
            size--;
        }
 
        for (pos = buffer + 63, i = 0; i < size; i++)
            *p++ = *pos--;
 
        str[0] = '\0';
        MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
        return ERANGE;
    }
 
    memcpy(str, pos, len);
    return 0;
}

_i64tow()

wchar_t *CDECL _i64tow	(	__int64	value,
		wchar_t *	str,
		int	radix
	)

Definition at line 2289 of file string.c.

{
    unsigned __int64 val;
    BOOL is_negative;
    wchar_t buffer[65], *pos;
 
    if (value < 0 && radix == 10)
    {
        is_negative = TRUE;
        val = -value;
    }
    else
    {
        is_negative = FALSE;
        val = value;
    }
 
    pos = buffer + 64;
    *pos = '\0';
 
    do
    {
        int digit = val % radix;
        val /= radix;
 
        if (digit < 10)
            *--pos = '0' + digit;
        else
            *--pos = 'a' + digit - 10;
    }
    while (val != 0);
 
    if (is_negative)
        *--pos = '-';
 
    memcpy(str, pos, (buffer + 65 - pos) * sizeof(wchar_t));
    return str;
}

_i64tow_s()

int CDECL _i64tow_s	(	__int64	value,
		wchar_t *	str,
		size_t	size,
		int	radix
	)

Definition at line 2591 of file string.c.

{
    unsigned __int64 val;
    unsigned int digit;
    BOOL is_negative;
    wchar_t buffer[65], *pos;
    size_t len;
 
    if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
    {
        str[0] = '\0';
        return EINVAL;
    }
 
    if (value < 0 && radix == 10)
    {
        is_negative = TRUE;
        val = -value;
    }
    else
    {
        is_negative = FALSE;
        val = value;
    }
 
    pos = buffer + 64;
    *pos = '\0';
 
    do
    {
        digit = val % radix;
        val /= radix;
 
        if (digit < 10)
            *--pos = '0' + digit;
        else
            *--pos = 'a' + digit - 10;
    }
    while (val != 0);
 
    if (is_negative)
        *--pos = '-';
 
    len = buffer + 65 - pos;
    if (len > size)
    {
        size_t i;
        wchar_t *p = str;
 
        /* Copy the temporary buffer backwards up to the available number of
         * characters. Don't copy the negative sign if present. */
 
        if (is_negative)
        {
            p++;
            size--;
        }
 
        for (pos = buffer + 63, i = 0; i < size; i++)
            *p++ = *pos--;
 
        str[0] = '\0';
        MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
        return ERANGE;
    }
 
    memcpy(str, pos, len * sizeof(wchar_t));
    return 0;
}

_itoa()

char *CDECL _itoa	(	int	value,
		char *	str,
		int	radix
	)

Definition at line 2111 of file string.c.

{
    return ltoa_helper(value, str, SIZE_MAX, radix) ? NULL : str;
}

_itoa_s()

int CDECL _itoa_s	(	int	value,
		char *	str,
		size_t	size,
		int	radix
	)

Definition at line 2103 of file string.c.

{
    return _ltoa_s(value, str, size, radix);
}

_itow()

wchar_t *CDECL _itow	(	int	value,
		wchar_t *	str,
		int	radix
	)

This file has no copyright assigned and is placed in the Public Domain. This file is part of the Wine project.

Definition at line 2135 of file string.c.

{
    return ltow_helper(value, str, SIZE_MAX, radix) ? NULL : str;
}

_itow_s()

int CDECL _itow_s	(	int	value,
		wchar_t *	str,
		size_t	size,
		int	radix
	)

Definition at line 2127 of file string.c.

{
    return _ltow_s(value, str, size, radix);
}

_ltoa()

char *CDECL _ltoa	(	__msvcrt_long	value,
		char *	str,
		int	radix
	)

Definition at line 2119 of file string.c.

{
    return ltoa_helper(value, str, SIZE_MAX, radix) ? NULL : str;
}

_ltoa_s()

int CDECL _ltoa_s	(	__msvcrt_long	value,
		char *	str,
		size_t	size,
		int	radix
	)

Definition at line 2071 of file string.c.

{
    if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
    {
        str[0] = '\0';
        return EINVAL;
    }
 
    return ltoa_helper(value, str, size, radix);
}

Referenced by _itoa_s().

_ltow()

wchar_t *CDECL _ltow	(	__msvcrt_long	value,
		wchar_t *	str,
		int	radix
	)

Definition at line 2143 of file string.c.

{
    return ltow_helper(value, str, SIZE_MAX, radix) ? NULL : str;
}

_ltow_s()

int CDECL _ltow_s	(	__msvcrt_long	value,
		wchar_t *	str,
		size_t	size,
		int	radix
	)

Definition at line 2087 of file string.c.

{
    if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
    {
        str[0] = '\0';
        return EINVAL;
    }
 
    return ltow_helper(value, str, size, radix);
}

Referenced by _itow_s().

_memccpy()

void *__cdecl _memccpy	(	void *	dst,
		const void *	src,
		int	c,
		size_t	n
	)

Definition at line 3205 of file string.c.

{
    unsigned char *d = dst;
    const unsigned char *s = src;
    while (n--) if ((*d++ = *s++) == (unsigned char)c) return d;
    return NULL;
}

_memicmp()

int __cdecl _memicmp	(	const void *	s1,
		const void *	s2,
		size_t	len
	)

Definition at line 3485 of file string.c.

{
    return _memicmp_l(s1, s2, len, NULL);
}

Referenced by test__memicmp().

_memicmp_l()

int __cdecl _memicmp_l	(	const void *	v1,
		const void *	v2,
		size_t	len,
		_locale_t	locale
	)

Definition at line 3458 of file string.c.

{
    const char *s1 = v1, *s2 = v2;
    int ret = 0;
 
#if _MSVCR_VER == 0 || _MSVCR_VER >= 80
    if (!s1 || !s2)
    {
        if (len)
            MSVCRT_INVALID_PMT(NULL, EINVAL);
        return len ? _NLSCMPERROR : 0;
    }
#endif
 
    while (len--)
    {
        if ((ret = _tolower_l(*s1, locale) - _tolower_l(*s2, locale)))
            break;
        s1++;
        s2++;
    }
    return ret;
}

Referenced by _memicmp(), and test__memicmp_l().

_strcoll_l()

int CDECL _strcoll_l	(	const char *	str1,
		const char *	str2,
		_locale_t	locale
	)

Definition at line 1170 of file string.c.

{
    pthreadlocinfo locinfo;
 
    if(!locale)
        locinfo = get_locinfo();
    else
        locinfo = locale->locinfo;
 
    if(!locinfo->lc_handle[LC_COLLATE])
        return strcmp(str1, str2);
    return CompareStringA(locinfo->lc_handle[LC_COLLATE], SORT_STRINGSORT,
              str1, -1, str2, -1)-CSTR_EQUAL;
}

Referenced by strcoll().

_strdup()

char *CDECL _strdup

(

const char *

str

)

Definition at line 47 of file string.c.

{
    if(str)
    {
      char * ret = malloc(strlen(str)+1);
      if (ret) strcpy( ret, str );
      return ret;
    }
    else return 0;
}

_stricmp()

int __cdecl _stricmp	(	const char *	s1,
		const char *	s2
	)

Definition at line 3407 of file string.c.

{
    return _strnicmp_l(s1, s2, INT_MAX, NULL);
}

_stricmp_l()

int __cdecl _stricmp_l	(	const char *	s1,
		const char *	s2,
		_locale_t	locale
	)

Definition at line 3391 of file string.c.

{
    return _strnicmp_l(s1, s2, INT_MAX, locale);
}

Referenced by _mbsicmp_l().

_stricoll()

int CDECL _stricoll	(	const char *	str1,
		const char *	str2
	)

Definition at line 1214 of file string.c.

{
    return _stricoll_l(str1, str2, NULL);
}

_stricoll_l()

int CDECL _stricoll_l	(	const char *	str1,
		const char *	str2,
		_locale_t	locale
	)

Definition at line 1196 of file string.c.

{
    pthreadlocinfo locinfo;
 
    if(!locale)
        locinfo = get_locinfo();
    else
        locinfo = locale->locinfo;
 
    if(!locinfo->lc_handle[LC_COLLATE])
        return _stricmp(str1, str2);
    return CompareStringA(locinfo->lc_handle[LC_COLLATE], NORM_IGNORECASE,
            str1, -1, str2, -1)-CSTR_EQUAL;
}

Referenced by _stricoll().

_strlwr()

char *CDECL _strlwr

(

char *

str

)

Definition at line 131 of file string.c.

{
    _strlwr_s_l(str, -1, NULL);
    return str;
}

_strlwr_l()

char *CDECL _strlwr_l	(	char *	str,
		_locale_t	locale
	)

Definition at line 122 of file string.c.

{
    _strlwr_s_l(str, -1, locale);
    return str;
}

_strlwr_s()

int CDECL _strlwr_s	(	char *	str,
		size_t	len
	)

Definition at line 114 of file string.c.

{
    return _strlwr_s_l(str, len, NULL);
}

_strlwr_s_l()

int CDECL _strlwr_s_l	(	char *	str,
		size_t	len,
		_locale_t	locale
	)

Definition at line 61 of file string.c.

{
    pthreadlocinfo locinfo;
    char *ptr = str;
 
    if (!str || !len)
    {
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    while (len && *ptr)
    {
        len--;
        ptr++;
    }
 
    if (!len)
    {
        str[0] = '\0';
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    if(!locale)
        locinfo = get_locinfo();
    else
        locinfo = locale->locinfo;
 
    if(!locinfo->lc_handle[LC_CTYPE])
    {
        while (*str)
        {
            if (*str >= 'A' && *str <= 'Z')
                *str -= 'A' - 'a';
            str++;
        }
    }
    else
    {
        while (*str)
        {
            *str = _tolower_l((unsigned char)*str, locale);
            str++;
        }
    }
 
    return 0;
}

_strncoll()

int CDECL _strncoll	(	const char *	str1,
		const char *	str2,
		size_t	count
	)

Definition at line 1241 of file string.c.

{
    return _strncoll_l(str1, str2, count, NULL);
}

Referenced by test__tcsncoll().

_strncoll_l()

int CDECL _strncoll_l	(	const char *	str1,
		const char *	str2,
		size_t	count,
		_locale_t	locale
	)

Definition at line 1222 of file string.c.

{
    pthreadlocinfo locinfo;
 
    if(!locale)
        locinfo = get_locinfo();
    else
        locinfo = locale->locinfo;
 
    if(!locinfo->lc_handle[LC_COLLATE])
        return strncmp(str1, str2, count);
    return CompareStringA(locinfo->lc_handle[LC_COLLATE], SORT_STRINGSORT,
              str1, strnlen(str1, count),
              str2, strnlen(str2, count))-CSTR_EQUAL;
}

Referenced by _strncoll().

_strnicmp()

int __cdecl _strnicmp	(	const char *	s1,
		const char *	s2,
		size_t	count
	)

Definition at line 3399 of file string.c.

{
    return _strnicmp_l(s1, s2, count, NULL);
}

_strnicmp_l()

int __cdecl _strnicmp_l	(	const char *	s1,
		const char *	s2,
		size_t	count,
		_locale_t	locale
	)

Definition at line 3347 of file string.c.

{
    pthreadlocinfo locinfo;
    int c1, c2;
 
    if(!count)
        return 0;
#if _MSVCR_VER>=80
    if(!MSVCRT_CHECK_PMT(s1 && s2 && count <= INT_MAX))
#else
    /* Old versions of msvcrt.dll didn't have count <= INT_MAX check */
    if(!MSVCRT_CHECK_PMT(s1 && s2))
#endif /* _MSVCR_VER>=140 */
        return _NLSCMPERROR;
 
    if(!locale)
        locinfo = get_locinfo();
    else
        locinfo = locale->locinfo;
 
    if(!locinfo->lc_handle[LC_CTYPE])
    {
        do {
            if ((c1 = *s1++) >= 'A' && c1 <= 'Z')
                c1 -= 'A' - 'a';
            if ((c2 = *s2++) >= 'A' && c2 <= 'Z')
                c2 -= 'A' - 'a';
        }while(--count && c1 && c1==c2);
 
        return (unsigned char)c1 - (unsigned char)c2;
    }
 
    do {
        c1 = _tolower_l((unsigned char)*s1++, locale);
        c2 = _tolower_l((unsigned char)*s2++, locale);
    }while(--count && c1 && c1==c2);
 
    return c1-c2;
}

Referenced by _stricmp(), _stricmp_l(), and _strnicmp().

_strnicoll()

int CDECL _strnicoll	(	const char *	str1,
		const char *	str2,
		size_t	count
	)

Definition at line 1268 of file string.c.

{
    return _strnicoll_l(str1, str2, count, NULL);
}

Referenced by test__tcsnicoll().

_strnicoll_l()

int CDECL _strnicoll_l	(	const char *	str1,
		const char *	str2,
		size_t	count,
		_locale_t	locale
	)

Definition at line 1249 of file string.c.

{
    pthreadlocinfo locinfo;
 
    if(!locale)
        locinfo = get_locinfo();
    else
        locinfo = locale->locinfo;
 
    if(!locinfo->lc_handle[LC_COLLATE])
        return _strnicmp(str1, str2, count);
    return CompareStringA(locinfo->lc_handle[LC_COLLATE], NORM_IGNORECASE,
            str1, strnlen(str1, count),
            str2, strnlen(str2, count))-CSTR_EQUAL;
}

Referenced by _strnicoll().

_strnset()

char *CDECL _strnset	(	char *	str,
		int	value,
		size_t	len
	)

Definition at line 243 of file string.c.

{
  if (len > 0 && str)
    while (*str && len--)
      *str++ = value;
  return str;
}

_strnset_s()

int CDECL _strnset_s	(	char *	str,
		size_t	size,
		int	c,
		size_t	count
	)

Definition at line 219 of file string.c.

{
    size_t i;
 
    if(!str && !size && !count) return 0;
    if(!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
    if(!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
 
    for(i=0; i<size-1 && i<count; i++) {
        if(!str[i]) return 0;
        str[i] = c;
    }
    for(; i<size; i++)
        if(!str[i]) return 0;
 
    str[0] = 0;
    _invalid_parameter(NULL, NULL, NULL, 0, 0);
    *_errno() = EINVAL;
    return EINVAL;
}

_strrev()

char *CDECL _strrev

(

char *

str

)

Definition at line 254 of file string.c.

{
  char * p1;
  char * p2;
 
  if (str && *str)
    for (p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2)
    {
      *p1 ^= *p2;
      *p2 ^= *p1;
      *p1 ^= *p2;
    }
 
  return str;
}

_strset()

char *CDECL _strset	(	char *	str,
		int	value
	)

Definition at line 273 of file string.c.

{
  char *ptr = str;
  while (*ptr)
    *ptr++ = value;
 
  return str;
}

_strtod_l()

double CDECL _strtod_l	(	const char *	str,
		char **	end,
		_locale_t	locale
	)

Definition at line 1064 of file string.c.

{
    return strtod_helper(str, end, locale, NULL);
}

Referenced by _atof_l(), atof(), and strtod().

_strtoi64()

__int64 CDECL _strtoi64	(	const char *	nptr,
		char **	endptr,
		int	base
	)

Definition at line 1689 of file string.c.

{
    return _strtoi64_l(nptr, endptr, base, NULL);
}

_strtoi64_l()

__int64 CDECL _strtoi64_l	(	const char *	nptr,
		char **	endptr,
		int	base,
		_locale_t	locale
	)

Definition at line 1617 of file string.c.

{
    const char *p = nptr;
    BOOL negative = FALSE;
    BOOL got_digit = FALSE;
    __int64 ret = 0;
 
    TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
 
    if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
    if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
    if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
 
    while(_isspace_l((unsigned char)*nptr, locale)) nptr++;
 
    if(*nptr == '-') {
        negative = TRUE;
        nptr++;
    } else if(*nptr == '+')
        nptr++;
 
    if((base==0 || base==16) && *nptr=='0' && _tolower_l(*(nptr+1), locale)=='x') {
        base = 16;
        nptr += 2;
    }
 
    if(base == 0) {
        if(*nptr=='0')
            base = 8;
        else
            base = 10;
    }
 
    while(*nptr) {
        char cur = _tolower_l(*nptr, locale);
        int v;
 
        if(cur>='0' && cur<='9') {
            if(cur >= '0'+base)
                break;
            v = cur-'0';
        } else {
            if(cur<'a' || cur>='a'+base-10)
                break;
            v = cur-'a'+10;
        }
        got_digit = TRUE;
 
        if(negative)
            v = -v;
 
        nptr++;
 
        if(!negative && (ret>I64_MAX/base || ret*base>I64_MAX-v)) {
            ret = I64_MAX;
            *_errno() = ERANGE;
        } else if(negative && (ret<I64_MIN/base || ret*base<I64_MIN-v)) {
            ret = I64_MIN;
            *_errno() = ERANGE;
        } else
            ret = ret*base + v;
    }
 
    if(endptr)
        *endptr = (char*)(got_digit ? nptr : p);
 
    return ret;
}

Referenced by _atoi64(), _atoi64_l(), _atoi_l(), _atol_l(), _strtoi64(), _strtol_l(), and _strtoul_l().

_strtol_l()

__msvcrt_long CDECL _strtol_l	(	const char *	nptr,
		char **	end,
		int	base,
		_locale_t	locale
	)

Definition at line 1814 of file string.c.

{
    __int64 ret = _strtoi64_l(nptr, end, base, locale);
 
    if(ret > LONG_MAX) {
        ret = LONG_MAX;
        *_errno() = ERANGE;
    } else if(ret < LONG_MIN) {
        ret = LONG_MIN;
        *_errno() = ERANGE;
    }
 
    return ret;
}

Referenced by strtol().

_strtoui64()

unsigned __int64 CDECL _strtoui64	(	const char *	nptr,
		char **	endptr,
		int	base
	)

Definition at line 1935 of file string.c.

{
    return _strtoui64_l(nptr, endptr, base, NULL);
}

_strtoui64_l()

unsigned __int64 CDECL _strtoui64_l	(	const char *	nptr,
		char **	endptr,
		int	base,
		_locale_t	locale
	)

Definition at line 1869 of file string.c.

{
    const char *p = nptr;
    BOOL negative = FALSE;
    BOOL got_digit = FALSE;
    unsigned __int64 ret = 0;
 
    TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
 
    if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
    if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
    if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
 
    while(_isspace_l((unsigned char)*nptr, locale)) nptr++;
 
    if(*nptr == '-') {
        negative = TRUE;
        nptr++;
    } else if(*nptr == '+')
        nptr++;
 
    if((base==0 || base==16) && *nptr=='0' && _tolower_l(*(nptr+1), locale)=='x') {
        base = 16;
        nptr += 2;
    }
 
    if(base == 0) {
        if(*nptr=='0')
            base = 8;
        else
            base = 10;
    }
 
    while(*nptr) {
        char cur = _tolower_l(*nptr, locale);
        int v;
 
        if(cur>='0' && cur<='9') {
            if(cur >= '0'+base)
                break;
            v = *nptr-'0';
        } else {
            if(cur<'a' || cur>='a'+base-10)
                break;
            v = cur-'a'+10;
        }
        got_digit = TRUE;
 
        nptr++;
 
        if(ret>UI64_MAX/base || ret*base>UI64_MAX-v) {
            ret = UI64_MAX;
            *_errno() = ERANGE;
        } else
            ret = ret*base + v;
    }
 
    if(endptr)
        *endptr = (char*)(got_digit ? nptr : p);
 
    return negative ? -ret : ret;
}

Referenced by _strtoui64().

_strtoul_l()

__msvcrt_ulong CDECL _strtoul_l	(	const char *	nptr,
		char **	end,
		int	base,
		_locale_t	locale
	)

Definition at line 1841 of file string.c.

{
    __int64 ret = _strtoi64_l(nptr, end, base, locale);
 
    if(ret > ULONG_MAX) {
        ret = ULONG_MAX;
        *_errno() = ERANGE;
    }else if(ret < -(__int64)ULONG_MAX) {
        ret = 1;
        *_errno() = ERANGE;
    }
 
    return ret;
}

Referenced by strtoul().

_strupr()

char *CDECL _strupr

(

char *

str

)

Definition at line 210 of file string.c.

{
    _strupr_s_l(str, -1, NULL);
    return str;
}

_strupr_l()

char *CDECL _strupr_l	(	char *	str,
		_locale_t	locale
	)

Definition at line 201 of file string.c.

{
    _strupr_s_l(str, -1, locale);
    return str;
}

_strupr_s()

int CDECL _strupr_s	(	char *	str,
		size_t	len
	)

Definition at line 193 of file string.c.

{
    return _strupr_s_l(str, len, NULL);
}

_strupr_s_l()

int CDECL _strupr_s_l	(	char *	str,
		size_t	len,
		_locale_t	locale
	)

Definition at line 140 of file string.c.

{
    pthreadlocinfo locinfo;
    char *ptr = str;
 
    if (!str || !len)
    {
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    while (len && *ptr)
    {
        len--;
        ptr++;
    }
 
    if (!len)
    {
        str[0] = '\0';
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    if(!locale)
        locinfo = get_locinfo();
    else
        locinfo = locale->locinfo;
 
    if(!locinfo->lc_handle[LC_CTYPE])
    {
        while (*str)
        {
            if (*str >= 'a' && *str <= 'z')
                *str -= 'a' - 'A';
            str++;
        }
    }
    else
    {
        while (*str)
        {
            *str = _toupper_l((unsigned char)*str, locale);
            str++;
        }
    }
 
    return 0;
}

_strxfrm_l()

size_t CDECL _strxfrm_l	(	char *	dest,
		const char *	src,
		size_t	len,
		_locale_t	locale
	)

Definition at line 1466 of file string.c.

{
    pthreadlocinfo locinfo;
    int ret;
 
    if(!MSVCRT_CHECK_PMT(src)) return INT_MAX;
    if(!MSVCRT_CHECK_PMT(dest || !len)) return INT_MAX;
 
    if(len > INT_MAX) {
        FIXME("len > INT_MAX not supported\n");
        len = INT_MAX;
    }
 
    if(!locale)
        locinfo = get_locinfo();
    else
        locinfo = locale->locinfo;
 
    if(!locinfo->lc_handle[LC_COLLATE]) {
        strncpy(dest, src, len);
        return strlen(src);
    }
 
    ret = LCMapStringA(locinfo->lc_handle[LC_COLLATE],
            LCMAP_SORTKEY, src, -1, NULL, 0);
    if(!ret) {
        if(len) dest[0] = 0;
        *_errno() = EILSEQ;
        return INT_MAX;
    }
    if(!len) return ret-1;
 
    if(ret > len) {
        dest[0] = 0;
        *_errno() = ERANGE;
        return ret-1;
    }
 
    return LCMapStringA(locinfo->lc_handle[LC_COLLATE],
            LCMAP_SORTKEY, src, -1, dest, len) - 1;
}

Referenced by strxfrm().

_swab()

void CDECL _swab	(	char *	src,
		char *	dst,
		int	len
	)

Definition at line 338 of file string.c.

{
  if (len > 1)
  {
    len = (unsigned)len >> 1;
 
    while (len--) {
      char s0 = src[0];
      char s1 = src[1];
      *dst++ = s1;
      *dst++ = s0;
      src = src + 2;
    }
  }
}

Referenced by test_swab().

_ui64toa()

char *CDECL _ui64toa	(	unsigned __int64	value,
		char *	str,
		int	radix
	)

Definition at line 2175 of file string.c.

{
    char buffer[65], *pos;
 
    pos = &buffer[64];
    *pos = '\0';
 
    do {
    int digit = value % radix;
    value /= radix;
 
    if (digit < 10)
        *--pos = '0' + digit;
        else
        *--pos = 'a' + digit - 10;
    } while (value != 0);
 
    memcpy(str, pos, buffer + 65 - pos);
    return str;
}

Referenced by ulltoa().

_ui64toa_s()

int CDECL _ui64toa_s	(	unsigned __int64	value,
		char *	str,
		size_t	size,
		int	radix
	)

Definition at line 2331 of file string.c.

{
    char buffer[65], *pos;
    int digit;
 
    if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
    {
        str[0] = '\0';
        return EINVAL;
    }
 
    pos = buffer+64;
    *pos = '\0';
 
    do {
        digit = value%radix;
        value /= radix;
 
        if(digit < 10)
            *--pos = '0'+digit;
        else
            *--pos = 'a'+digit-10;
    }while(value != 0);
 
    if(buffer-pos+65 > size) {
        MSVCRT_INVALID_PMT("str[size] is too small", EINVAL);
        return EINVAL;
    }
 
    memcpy(str, pos, buffer-pos+65);
    return 0;
}

_ui64tow()

wchar_t *CDECL _ui64tow	(	unsigned __int64	value,
		wchar_t *	str,
		int	radix
	)

Definition at line 2223 of file string.c.

{
    wchar_t buffer[65], *pos;
 
    pos = &buffer[64];
    *pos = '\0';
 
    do {
    int digit = value % radix;
    value /= radix;
 
    if (digit < 10)
        *--pos = '0' + digit;
        else
        *--pos = 'a' + digit - 10;
    } while (value != 0);
 
    memcpy(str, pos, (buffer + 65 - pos) * sizeof(wchar_t));
    return str;
}

Referenced by ulltow().

_ui64tow_s()

int CDECL _ui64tow_s	(	unsigned __int64	value,
		wchar_t *	str,
		size_t	size,
		int	radix
	)

Definition at line 2370 of file string.c.

{
    wchar_t buffer[65], *pos;
    int digit;
 
    if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
    {
        str[0] = '\0';
        return EINVAL;
    }
 
    pos = &buffer[64];
    *pos = '\0';
 
    do {
    digit = value % radix;
    value = value / radix;
    if (digit < 10)
        *--pos = '0' + digit;
    else
        *--pos = 'a' + digit - 10;
    } while (value != 0);
 
    if(buffer-pos+65 > size) {
        MSVCRT_INVALID_PMT("str[size] is too small", EINVAL);
        return EINVAL;
    }
 
    memcpy(str, pos, (buffer-pos+65)*sizeof(wchar_t));
    return 0;
}

_ultoa()

char *CDECL _ultoa	(	__msvcrt_ulong	value,
		char *	str,
		int	radix
	)

Definition at line 2151 of file string.c.

{
    char buffer[33], *pos;
 
    pos = &buffer[32];
    *pos = '\0';
 
    do {
    int digit = value % radix;
    value /= radix;
 
    if (digit < 10)
        *--pos = '0' + digit;
        else
        *--pos = 'a' + digit - 10;
    } while (value != 0);
 
    memcpy(str, pos, buffer + 33 - pos);
    return str;
}

_ultoa_s()

int CDECL _ultoa_s	(	__msvcrt_ulong	value,
		char *	str,
		size_t	size,
		int	radix
	)

Definition at line 2408 of file string.c.

{
    __msvcrt_ulong digit;
    char buffer[33], *pos;
    size_t len;
 
    if (!str || !size || radix < 2 || radix > 36)
    {
        if (str && size)
            str[0] = '\0';
 
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    pos = buffer + 32;
    *pos = '\0';
 
    do
    {
        digit = value % radix;
        value /= radix;
 
        if (digit < 10)
            *--pos = '0' + digit;
        else
            *--pos = 'a' + digit - 10;
    }
    while (value != 0);
 
    len = buffer + 33 - pos;
    if (len > size)
    {
        size_t i;
        char *p = str;
 
        /* Copy the temporary buffer backwards up to the available number of
         * characters. */
 
        for (pos = buffer + 31, i = 0; i < size; i++)
            *p++ = *pos--;
 
        str[0] = '\0';
        *_errno() = ERANGE;
        return ERANGE;
    }
 
    memcpy(str, pos, len);
    return 0;
}

_ultow()

wchar_t *CDECL _ultow	(	__msvcrt_ulong	value,
		wchar_t *	str,
		int	radix
	)

Definition at line 2199 of file string.c.

{
    wchar_t buffer[33], *pos;
 
    pos = &buffer[32];
    *pos = '\0';
 
    do {
    int digit = value % radix;
    value /= radix;
 
    if (digit < 10)
        *--pos = '0' + digit;
        else
        *--pos = 'a' + digit - 10;
    } while (value != 0);
 
    memcpy(str, pos, (buffer + 33 - pos) * sizeof(wchar_t));
    return str;
}

Referenced by AddNewLayout(), BcdDeleteElement(), CliGetPreloadKeyboardLayouts(), RecycleBin5::DeleteFile(), IntLoadPreloadKeyboardLayouts(), OnInitDialog(), PerformancePageRefreshThread(), PrintingThreadProc(), ScmWaitForServiceConnect(), and ShowItemError().

_ultow_s()

int CDECL _ultow_s	(	__msvcrt_ulong	value,
		wchar_t *	str,
		size_t	size,
		int	radix
	)

Definition at line 2462 of file string.c.

{
    __msvcrt_ulong digit;
    WCHAR buffer[33], *pos;
    size_t len;
 
    if (!str || !size || radix < 2 || radix > 36)
    {
        if (str && size)
            str[0] = '\0';
 
        *_errno() = EINVAL;
        return EINVAL;
    }
 
    pos = buffer + 32;
    *pos = '\0';
 
    do
    {
        digit = value % radix;
        value /= radix;
 
        if (digit < 10)
            *--pos = '0' + digit;
        else
            *--pos = 'a' + digit - 10;
    }
    while (value != 0);
 
    len = buffer + 33 - pos;
    if (len > size)
    {
        size_t i;
        WCHAR *p = str;
 
        /* Copy the temporary buffer backwards up to the available number of
         * characters. */
 
        for (pos = buffer + 31, i = 0; i < size; i++)
            *p++ = *pos--;
 
        str[0] = '\0';
        *_errno() = ERANGE;
        return ERANGE;
    }
 
    memcpy(str, pos, len * sizeof(wchar_t));
    return 0;
}

atof()

double CDECL atof

(

const char *

str

)

Definition at line 1106 of file string.c.

{
    return _strtod_l(str, NULL, NULL);
}

atoi()

int __cdecl atoi

(

const char *

str

)

Definition at line 1715 of file string.c.

{
    BOOL minus = FALSE;
    int ret = 0;
 
    if(!str)
        return 0;
 
    while(_isspace_l((unsigned char)*str, NULL)) str++;
 
    if(*str == '+') {
        str++;
    }else if(*str == '-') {
        minus = TRUE;
        str++;
    }
 
    while(*str>='0' && *str<='9') {
        ret = ret*10+*str-'0';
        str++;
    }
 
    return minus ? -ret : ret;
}

atol()

__msvcrt_long CDECL atol

(

const char *

str

)

Definition at line 1782 of file string.c.

{
#if _MSVCR_VER == 0
    return atoi(str);
#else
    return _atol_l(str, NULL);
#endif
}

Referenced by test_atol().

bnum_to_mant()

static BOOL bnum_to_mant ( struct bnum *  b, ULONGLONG *  m  )

inlinestatic

Definition at line 740 of file string.c.

{
    if(UI64_MAX / LIMB_MAX / LIMB_MAX < b->data[bnum_idx(b, b->e-1)]) return FALSE;
    *m = (ULONGLONG)b->data[bnum_idx(b, b->e-1)] * LIMB_MAX * LIMB_MAX;
    if(b->b == b->e-1) return TRUE;
    if(UI64_MAX - *m < (ULONGLONG)b->data[bnum_idx(b, b->e-2)] * LIMB_MAX) return FALSE;
    *m += (ULONGLONG)b->data[bnum_idx(b, b->e-2)] * LIMB_MAX;
    if(b->b == b->e-2) return TRUE;
    if(UI64_MAX - *m < b->data[bnum_idx(b, b->e-3)]) return FALSE;
    *m += b->data[bnum_idx(b, b->e-3)];
    return TRUE;
}

Referenced by fpnum_parse_bnum().

fpnum()

static struct fpnum fpnum ( int  sign, int  exp, ULONGLONG  m, enum fpmod  mod  )

static

Definition at line 354 of file string.c.

{
    struct fpnum ret;
 
    ret.sign = sign;
    ret.exp = exp;
    ret.m = m;
    ret.mod = mod;
    return ret;
}

fpnum_double()

int fpnum_double	(	struct fpnum *	fp,
		double *	d
	)

Definition at line 365 of file string.c.

{
    ULONGLONG bits = 0;
 
    if (fp->mod == FP_VAL_INFINITY)
    {
        *d = fp->sign * INFINITY;
        return 0;
    }
 
    if (fp->mod == FP_VAL_NAN)
    {
        bits = ~0;
        if (fp->sign == 1)
            bits &= ~((ULONGLONG)1 << (MANT_BITS + EXP_BITS - 1));
        *d = *(double*)&bits;
        return 0;
    }
 
    TRACE("%c %#I64x *2^%d (round %d)\n", fp->sign == -1 ? '-' : '+',
            fp->m, fp->exp, fp->mod);
    if (!fp->m)
    {
        *d = fp->sign * 0.0;
        return 0;
    }
 
    /* make sure that we don't overflow modifying exponent */
    if (fp->exp > 1<<EXP_BITS)
    {
        *d = fp->sign * INFINITY;
        return ERANGE;
    }
    if (fp->exp < -(1<<EXP_BITS))
    {
        *d = fp->sign * 0.0;
        return ERANGE;
    }
    fp->exp += MANT_BITS - 1;
 
    /* normalize mantissa */
    while(fp->m < (ULONGLONG)1 << (MANT_BITS-1))
    {
        fp->m <<= 1;
        fp->exp--;
    }
    while(fp->m >= (ULONGLONG)1 << MANT_BITS)
    {
        if (fp->m & 1 || fp->mod != FP_ROUND_ZERO)
        {
            if (!(fp->m & 1)) fp->mod = FP_ROUND_DOWN;
            else if(fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
            else fp->mod = FP_ROUND_UP;
        }
        fp->m >>= 1;
        fp->exp++;
    }
    fp->exp += (1 << (EXP_BITS-1)) - 1;
 
    /* handle subnormals */
    if (fp->exp <= 0)
    {
        if (fp->m & 1 && fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
        else if (fp->m & 1) fp->mod = FP_ROUND_UP;
        else if (fp->mod != FP_ROUND_ZERO) fp->mod = FP_ROUND_DOWN;
        fp->m >>= 1;
    }
    while(fp->m && fp->exp<0)
    {
        if (fp->m & 1 && fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
        else if (fp->m & 1) fp->mod = FP_ROUND_UP;
        else if (fp->mod != FP_ROUND_ZERO) fp->mod = FP_ROUND_DOWN;
        fp->m >>= 1;
        fp->exp++;
    }
 
    /* round mantissa */
    if (fp->mod == FP_ROUND_UP || (fp->mod == FP_ROUND_EVEN && fp->m & 1))
    {
        fp->m++;
 
        /* handle subnormal that falls into regular range due to rounding */
        if (fp->m == (ULONGLONG)1 << (MANT_BITS - 1))
        {
            fp->exp++;
        }
        else if (fp->m >= (ULONGLONG)1 << MANT_BITS)
        {
            fp->exp++;
            fp->m >>= 1;
        }
    }
 
    if (fp->exp >= (1<<EXP_BITS)-1)
    {
        *d = fp->sign * INFINITY;
        return ERANGE;
    }
    if (!fp->m || fp->exp < 0)
    {
        *d = fp->sign * 0.0;
        return ERANGE;
    }
 
    if (fp->sign == -1)
        bits |= (ULONGLONG)1 << (MANT_BITS + EXP_BITS - 1);
    bits |= (ULONGLONG)fp->exp << (MANT_BITS - 1);
    bits |= fp->m & (((ULONGLONG)1 << (MANT_BITS - 1)) - 1);
 
    TRACE("returning %#I64x\n", bits);
    *d = *(double*)&bits;
    return 0;
}

Referenced by I10_OUTPUT(), and strtod_helper().

fpnum_ldouble()

int fpnum_ldouble	(	struct fpnum *	fp,
		MSVCRT__LDOUBLE *	d
	)

Definition at line 484 of file string.c.

{
    if (fp->mod == FP_VAL_INFINITY)
    {
        d->x80[0] = 0;
        d->x80[1] = 0x80000000;
        d->x80[2] = (1 << LDBL_EXP_BITS) - 1;
        if (fp->sign == -1)
            d->x80[2] |= 1 << LDBL_EXP_BITS;
        return 0;
    }
 
    if (fp->mod == FP_VAL_NAN)
    {
        d->x80[0] = ~0;
        d->x80[1] = ~0;
        d->x80[2] = (1 << LDBL_EXP_BITS) - 1;
        if (fp->sign == -1)
            d->x80[2] |= 1 << LDBL_EXP_BITS;
        return 0;
    }
 
    TRACE("%c %#I64x *2^%d (round %d)\n", fp->sign == -1 ? '-' : '+',
            fp->m, fp->exp, fp->mod);
    if (!fp->m)
    {
        d->x80[0] = 0;
        d->x80[1] = 0;
        d->x80[2] = 0;
        if (fp->sign == -1)
            d->x80[2] |= 1 << LDBL_EXP_BITS;
        return 0;
    }
 
    /* make sure that we don't overflow modifying exponent */
    if (fp->exp > 1<<LDBL_EXP_BITS)
    {
        d->x80[0] = 0;
        d->x80[1] = 0x80000000;
        d->x80[2] = (1 << LDBL_EXP_BITS) - 1;
        if (fp->sign == -1)
            d->x80[2] |= 1 << LDBL_EXP_BITS;
        return ERANGE;
    }
    if (fp->exp < -(1<<LDBL_EXP_BITS))
    {
        d->x80[0] = 0;
        d->x80[1] = 0;
        d->x80[2] = 0;
        if (fp->sign == -1)
            d->x80[2] |= 1 << LDBL_EXP_BITS;
        return ERANGE;
    }
    fp->exp += LDBL_MANT_BITS - 1;
 
    /* normalize mantissa */
    while(fp->m < (ULONGLONG)1 << (LDBL_MANT_BITS-1))
    {
        fp->m <<= 1;
        fp->exp--;
    }
    fp->exp += (1 << (LDBL_EXP_BITS-1)) - 1;
 
    /* handle subnormals */
    if (fp->exp <= 0)
    {
        if (fp->m & 1 && fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
        else if (fp->m & 1) fp->mod = FP_ROUND_UP;
        else if (fp->mod != FP_ROUND_ZERO) fp->mod = FP_ROUND_DOWN;
        fp->m >>= 1;
    }
    while(fp->m && fp->exp<0)
    {
        if (fp->m & 1 && fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
        else if (fp->m & 1) fp->mod = FP_ROUND_UP;
        else if (fp->mod != FP_ROUND_ZERO) fp->mod = FP_ROUND_DOWN;
        fp->m >>= 1;
        fp->exp++;
    }
 
    /* round mantissa */
    if (fp->mod == FP_ROUND_UP || (fp->mod == FP_ROUND_EVEN && fp->m & 1))
    {
        if (fp->m == UI64_MAX)
        {
            fp->m = (ULONGLONG)1 << (LDBL_MANT_BITS - 1);
            fp->exp++;
        }
        else
        {
            fp->m++;
 
            /* handle subnormal that falls into regular range due to rounding */
            if ((fp->m ^ (fp->m - 1)) & ((ULONGLONG)1 << (LDBL_MANT_BITS - 1))) fp->exp++;
        }
    }
 
    if (fp->exp >= (1<<LDBL_EXP_BITS)-1)
    {
        d->x80[0] = 0;
        d->x80[1] = 0x80000000;
        d->x80[2] = (1 << LDBL_EXP_BITS) - 1;
        if (fp->sign == -1)
            d->x80[2] |= 1 << LDBL_EXP_BITS;
        return ERANGE;
    }
    if (!fp->m || fp->exp < 0)
    {
        d->x80[0] = 0;
        d->x80[1] = 0;
        d->x80[2] = 0;
        if (fp->sign == -1)
            d->x80[2] |= 1 << LDBL_EXP_BITS;
        return ERANGE;
    }
 
    d->x80[0] = fp->m;
    d->x80[1] = fp->m >> 32;
    d->x80[2] = fp->exp;
    if (fp->sign == -1)
        d->x80[2] |= 1 << LDBL_EXP_BITS;
    return 0;
}

Referenced by __STRINGTOLD_L().

fpnum_parse()

struct fpnum fpnum_parse	(	wchar_t(*)(void *ctx)	get,
		void(*)(void *ctx)	unget,
		void *	ctx,
		pthreadlocinfo	locinfo,
		BOOL	ldouble
	)

Definition at line 985 of file string.c.

{
    if(!ldouble) {
#ifdef _MSC_VER
        BYTE bnum_data[FIELD_OFFSET(struct bnum, data) + BNUM_PREC64 * sizeof(DWORD)];
#else
        BYTE bnum_data[FIELD_OFFSET(struct bnum, data[BNUM_PREC64])];
#endif
        struct bnum *b = (struct bnum*)bnum_data;
 
        b->size = BNUM_PREC64;
        return fpnum_parse_bnum(get, unget, ctx, locinfo, ldouble, b);
    } else {
#ifdef _MSC_VER
        BYTE bnum_data[FIELD_OFFSET(struct bnum, data) + BNUM_PREC80 * sizeof(DWORD)];
#else
        BYTE bnum_data[FIELD_OFFSET(struct bnum, data[BNUM_PREC80])];
#endif
        struct bnum *b = (struct bnum*)bnum_data;
 
        b->size = BNUM_PREC80;
        return fpnum_parse_bnum(get, unget, ctx, locinfo, ldouble, b);
    }
}

Referenced by __STRINGTOLD_L(), and strtod_helper().

fpnum_parse_bnum()

static struct fpnum fpnum_parse_bnum ( wchar_t(*)(void *ctx)  get, void(*)(void *ctx)  unget, void *  ctx, pthreadlocinfo  locinfo, BOOL  ldouble, struct bnum *  b  )

static

Definition at line 753 of file string.c.

{
#if _MSVCR_VER >= 140
    const wchar_t _infinity[] = L"infinity";
    const wchar_t _nan[] = L"nan";
    const wchar_t *str_match = NULL;
    int matched=0;
#endif
    BOOL found_digit = FALSE, found_dp = FALSE, found_sign = FALSE;
    int e2 = 0, dp=0, sign=1, off, limb_digits = 0, i;
    enum fpmod round = FP_ROUND_ZERO;
    wchar_t nch;
    ULONGLONG m;
 
    nch = get(ctx);
    if(nch == '-') {
        found_sign = TRUE;
        sign = -1;
        nch = get(ctx);
    } else if(nch == '+') {
        found_sign = TRUE;
        nch = get(ctx);
    }
 
#if _MSVCR_VER >= 140
    if(nch == _infinity[0] || nch == _toupper(_infinity[0]))
        str_match = _infinity;
    if(nch == _nan[0] || nch == _toupper(_nan[0]))
        str_match = _nan;
    while(str_match && nch != WEOF &&
            (nch == str_match[matched] || nch == _toupper(str_match[matched]))) {
        nch = get(ctx);
        matched++;
    }
    if(str_match) {
        int keep = 0;
        if(matched >= 8) keep = 8;
        else if(matched >= 3) keep = 3;
        if(nch != WEOF) unget(ctx);
        for (; matched > keep; matched--) {
            unget(ctx);
        }
        if(keep) {
            if (str_match == _infinity)
                return fpnum(sign, 0, 0, FP_VAL_INFINITY);
            if (str_match == _nan)
                return fpnum(sign, 0, 0, FP_VAL_NAN);
        } else if(found_sign) {
            unget(ctx);
        }
 
        return fpnum(0, 0, 0, 0);
    }
 
    if(nch == '0') {
        found_digit = TRUE;
        nch = get(ctx);
        if(nch == 'x' || nch == 'X')
            return fpnum_parse16(get, unget, ctx, sign, locinfo);
    }
#endif
 
    while(nch == '0') {
        found_digit = TRUE;
        nch = get(ctx);
    }
 
    b->b = 0;
    b->e = 1;
    b->data[0] = 0;
    while(nch>='0' && nch<='9') {
        found_digit = TRUE;
        if(limb_digits == LIMB_DIGITS) {
            if(bnum_idx(b, b->b-1) == bnum_idx(b, b->e)) break;
            else {
                b->b--;
                b->data[bnum_idx(b, b->b)] = 0;
                limb_digits = 0;
            }
        }
 
        b->data[bnum_idx(b, b->b)] = b->data[bnum_idx(b, b->b)] * 10 + nch - '0';
        limb_digits++;
        nch = get(ctx);
        dp++;
    }
    while(nch>='0' && nch<='9') {
        if(nch != '0') b->data[bnum_idx(b, b->b)] |= 1;
        nch = get(ctx);
        dp++;
    }
 
    if(nch == *locinfo->lconv->decimal_point) {
        found_dp = TRUE;
        nch = get(ctx);
    }
 
    /* skip leading '0' */
    if(nch=='0' && !limb_digits && !b->b) {
        found_digit = TRUE;
        while(nch == '0') {
            nch = get(ctx);
            dp--;
        }
    }
 
    while(nch>='0' && nch<='9') {
        found_digit = TRUE;
        if(limb_digits == LIMB_DIGITS) {
            if(bnum_idx(b, b->b-1) == bnum_idx(b, b->e)) break;
            else {
                b->b--;
                b->data[bnum_idx(b, b->b)] = 0;
                limb_digits = 0;
            }
        }
 
        b->data[bnum_idx(b, b->b)] = b->data[bnum_idx(b, b->b)] * 10 + nch - '0';
        limb_digits++;
        nch = get(ctx);
    }
    while(nch>='0' && nch<='9') {
        if(nch != '0') b->data[bnum_idx(b, b->b)] |= 1;
        nch = get(ctx);
    }
 
    if(!found_digit) {
        if(nch != WEOF) unget(ctx);
        if(found_dp) unget(ctx);
        if(found_sign) unget(ctx);
        return fpnum(0, 0, 0, 0);
    }
 
    if(nch=='e' || nch=='E' || nch=='d' || nch=='D') {
        int e=0, s=1;
 
        nch = get(ctx);
        if(nch == '-') {
            found_sign = TRUE;
            s = -1;
            nch = get(ctx);
        } else if(nch == '+') {
            found_sign = TRUE;
            nch = get(ctx);
        } else {
            found_sign = FALSE;
        }
 
        if(nch>='0' && nch<='9') {
            while(nch>='0' && nch<='9') {
                if(e>INT_MAX/10 || e*10>INT_MAX-nch+'0')
                    e = INT_MAX;
                else
                    e = e*10+nch-'0';
                nch = get(ctx);
            }
            if(nch != WEOF) unget(ctx);
            e *= s;
 
            if(e<0 && dp<INT_MIN-e) dp = INT_MIN;
            else if(e>0 && dp>INT_MAX-e) dp = INT_MAX;
            else dp += e;
        } else {
            if(nch != WEOF) unget(ctx);
            if(found_sign) unget(ctx);
            unget(ctx);
        }
    } else if(nch != WEOF) {
        unget(ctx);
    }
 
    if(!b->data[bnum_idx(b, b->e-1)])
        return fpnum(sign, 0, 0, 0);
 
    /* Fill last limb with 0 if needed */
    if(b->b+1 != b->e) {
        for(; limb_digits != LIMB_DIGITS; limb_digits++)
            b->data[bnum_idx(b, b->b)] *= 10;
    }
    for(; bnum_idx(b, b->b) < bnum_idx(b, b->e); b->b++) {
        if(b->data[bnum_idx(b, b->b)]) break;
    }
 
    /* move decimal point to limb boundary */
    if(limb_digits==dp && b->b==b->e-1)
        return fpnum(sign, 0, b->data[bnum_idx(b, b->e-1)], FP_ROUND_ZERO);
    off = (dp - limb_digits) % LIMB_DIGITS;
    if(off < 0) off += LIMB_DIGITS;
    if(off) bnum_mult(b, p10s[off]);
 
    if(dp-1 > (ldouble ? DBL80_MAX_10_EXP : DBL_MAX_10_EXP))
        return fpnum(sign, INT_MAX, 1, FP_ROUND_ZERO);
    /* Count part of exponent stored in denormalized mantissa. */
    /* Increase exponent range to handle subnormals. */
    if(dp-1 < (ldouble ? DBL80_MIN_10_EXP : DBL_MIN_10_EXP-DBL_DIG-18))
        return fpnum(sign, INT_MIN, 1, FP_ROUND_ZERO);
 
    while(dp > 3*LIMB_DIGITS) {
        if(bnum_rshift(b, 9)) dp -= LIMB_DIGITS;
        e2 += 9;
    }
    while(dp <= 2*LIMB_DIGITS) {
        if(bnum_lshift(b, 29)) dp += LIMB_DIGITS;
        e2 -= 29;
    }
    /* Make sure most significant mantissa bit will be set */
    while(b->data[bnum_idx(b, b->e-1)] <= 9) {
        bnum_lshift(b, 1);
        e2--;
    }
    while(!bnum_to_mant(b, &m)) {
        bnum_rshift(b, 1);
        e2++;
    }
 
    if(b->e-4 >= b->b && b->data[bnum_idx(b, b->e-4)]) {
        if(b->data[bnum_idx(b, b->e-4)] > LIMB_MAX/2) round = FP_ROUND_UP;
        else if(b->data[bnum_idx(b, b->e-4)] == LIMB_MAX/2) round = FP_ROUND_EVEN;
        else round = FP_ROUND_DOWN;
    }
    if(round == FP_ROUND_ZERO || round == FP_ROUND_EVEN) {
        for(i=b->e-5; i>=b->b; i--) {
            if(!b->data[bnum_idx(b, b->b)]) continue;
            if(round == FP_ROUND_EVEN) round = FP_ROUND_UP;
            else round = FP_ROUND_DOWN;
        }
    }
 
    return fpnum(sign, e2, m, round);
}

Referenced by fpnum_parse().

I10_OUTPUT()

int CDECL I10_OUTPUT	(	MSVCRT__LDOUBLE	ld80,
		int	prec,
		int	flag,
		struct _I10_OUTPUT_DATA *	data
	)

Definition at line 2690 of file string.c.

{
#ifdef __REACTOS__
    WINE_BROKEN_LDOUBLE ld80 = { 0 };
    memcpy(&ld80, &ld80_, sizeof(ld80_));
#endif
    struct fpnum num;
    double d;
    char format[8];
    char buf[I10_OUTPUT_MAX_PREC+9]; /* 9 = strlen("0.e+0000") + '\0' */
    char *p;
 
    if ((ld80.x80[2] & 0x7fff) == 0x7fff)
    {
        if (ld80.x80[0] == 0 && ld80.x80[1] == 0x80000000)
            strcpy( data->str, "1#INF" );
        else
            strcpy( data->str, (ld80.x80[1] & 0x40000000) ? "1#QNAN" : "1#SNAN" );
        data->pos = 1;
        data->sign = (ld80.x80[2] & 0x8000) ? '-' : ' ';
        data->len = strlen(data->str);
        return 0;
    }
 
    num.sign = (ld80.x80[2] & 0x8000) ? -1 : 1;
    num.exp  = (ld80.x80[2] & 0x7fff) - 0x3fff - 63;
    num.m    = ld80.x80[0] | ((ULONGLONG)ld80.x80[1] << 32);
    num.mod  = FP_ROUND_EVEN;
    fpnum_double( &num, &d );
    TRACE("(%lf %d %x %p)\n", d, prec, flag, data);
 
    if(d<0) {
        data->sign = '-';
        d = -d;
    } else
        data->sign = ' ';
 
    if(flag&1) {
        int exp = 1 + floor(log10(d));
 
        prec += exp;
        if(exp < 0)
            prec--;
    }
    prec--;
 
    if(prec+1 > I10_OUTPUT_MAX_PREC)
        prec = I10_OUTPUT_MAX_PREC-1;
    else if(prec < 0) {
        d = 0.0;
        prec = 0;
    }
 
    sprintf(format, "%%.%dle", prec);
    sprintf(buf, format, d);
 
    buf[1] = buf[0];
    data->pos = atoi(buf+prec+3);
    if(buf[1] != '0')
        data->pos++;
 
    for(p = buf+prec+1; p>buf+1 && *p=='0'; p--);
    data->len = p-buf;
 
    memcpy(data->str, buf+1, data->len);
    data->str[data->len] = '\0';
 
    if(buf[1]!='0' && prec-data->len+1>0)
        memcpy(data->str+data->len+1, buf+data->len+1, prec-data->len+1);
 
    return 1;
}

ltoa_helper()

static int ltoa_helper ( __msvcrt_long  value, char *  str, size_t  size, int  radix  )

static

Definition at line 1940 of file string.c.

{
    __msvcrt_ulong val;
    unsigned int digit;
    BOOL is_negative;
    char buffer[33], *pos;
    size_t len;
 
    if (value < 0 && radix == 10)
    {
        is_negative = TRUE;
        val = -value;
    }
    else
    {
        is_negative = FALSE;
        val = value;
    }
 
    pos = buffer + 32;
    *pos = '\0';
 
    do
    {
        digit = val % radix;
        val /= radix;
 
        if (digit < 10)
            *--pos = '0' + digit;
        else
            *--pos = 'a' + digit - 10;
    }
    while (val != 0);
 
    if (is_negative)
        *--pos = '-';
 
    len = buffer + 33 - pos;
    if (len > size)
    {
        size_t i;
        char *p = str;
 
        /* Copy the temporary buffer backwards up to the available number of
         * characters. Don't copy the negative sign if present. */
 
        if (is_negative)
        {
            p++;
            size--;
        }
 
        for (pos = buffer + 31, i = 0; i < size; i++)
            *p++ = *pos--;
 
        str[0] = '\0';
        MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
        return ERANGE;
    }
 
    memcpy(str, pos, len);
    return 0;
}

Referenced by _itoa(), _ltoa(), and _ltoa_s().

ltow_helper()

static int ltow_helper ( __msvcrt_long  value, wchar_t *  str, size_t  size, int  radix  )

static

Definition at line 2004 of file string.c.

{
    __msvcrt_ulong val;
    unsigned int digit;
    BOOL is_negative;
    wchar_t buffer[33], *pos;
    size_t len;
 
    if (value < 0 && radix == 10)
    {
        is_negative = TRUE;
        val = -value;
    }
    else
    {
        is_negative = FALSE;
        val = value;
    }
 
    pos = buffer + 32;
    *pos = '\0';
 
    do
    {
        digit = val % radix;
        val /= radix;
 
        if (digit < 10)
            *--pos = '0' + digit;
        else
            *--pos = 'a' + digit - 10;
    }
    while (val != 0);
 
    if (is_negative)
        *--pos = '-';
 
    len = buffer + 33 - pos;
    if (len > size)
    {
        size_t i;
        wchar_t *p = str;
 
        /* Copy the temporary buffer backwards up to the available number of
         * characters. Don't copy the negative sign if present. */
 
        if (is_negative)
        {
            p++;
            size--;
        }
 
        for (pos = buffer + 31, i = 0; i < size; i++)
            *p++ = *pos--;
 
        str[0] = '\0';
        MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
        return ERANGE;
    }
 
    memcpy(str, pos, len * sizeof(wchar_t));
    return 0;
}

Referenced by _itow(), _ltow(), and _ltow_s().

memchr()

void *__cdecl memchr	(	const void *	ptr,
		int	c,
		size_t	n
	)

Definition at line 3308 of file string.c.

{
    const unsigned char *p = ptr;
 
    for (p = ptr; n; n--, p++) if (*p == (unsigned char)c) return (void *)(ULONG_PTR)p;
    return NULL;
}

memcmp()

int __cdecl memcmp	(	const void *	ptr1,
		const void *	ptr2,
		size_t	n
	)

Definition at line 2802 of file string.c.

{
    const unsigned char *p1 = ptr1, *p2 = ptr2;
    size_t align;
    int result;
 
    if (n < sizeof(uint64_t))
        return memcmp_bytes(p1, p2, n);
 
    align = -(size_t)p1 & (sizeof(uint64_t) - 1);
 
    if ((result = memcmp_bytes(p1, p2, align)))
        return result;
 
    p1 += align;
    p2 += align;
    n  -= align;
 
    return memcmp_blocks(p1, p2, n);
}

memcmp_blocks()

static int memcmp_blocks ( const void *  ptr1, const void *  ptr2, size_t  size  )

inlinestatic

Definition at line 2777 of file string.c.

{
    typedef uint64_t DECLSPEC_ALIGN(1) unaligned_ui64;
 
    const uint64_t *p1 = ptr1;
    const unaligned_ui64 *p2 = ptr2;
    size_t remainder = size & (sizeof(uint64_t) - 1);
    size_t block_count = size / sizeof(uint64_t);
 
    while (block_count)
    {
        if (*p1 != *p2)
            return memcmp_bytes(p1, p2, sizeof(uint64_t));
 
        p1++;
        p2++;
        block_count--;
    }
 
    return memcmp_bytes(p1, p2, remainder);
}

Referenced by memcmp().

memcmp_bytes()

static int memcmp_bytes ( const void *  ptr1, const void *  ptr2, size_t  n  )

inlinestatic

Definition at line 2765 of file string.c.

{
    const unsigned char *p1, *p2;
 
    for (p1 = ptr1, p2 = ptr2; n; n--, p1++, p2++)
    {
        if (*p1 != *p2)
            return *p1 > *p2 ? 1 : -1;
    }
    return 0;
}

Referenced by memcmp(), and memcmp_blocks().

memcpy()

void *__cdecl memcpy	(	void *	dst,
		const void *	src,
		size_t	n
	)

Definition at line 3197 of file string.c.

{
    return memmove(dst, src, n);
}

memmove()

void *__cdecl memmove	(	void *	dst,
		const void *	src,
		size_t	n
	)

Definition at line 3088 of file string.c.

{
#if defined(__x86_64__) && !defined(__arm64ec__)
    return sse2_memmove(dst, src, n);
#else
    unsigned char *d = dst;
    const unsigned char *s = src;
    int sh1;
 
#ifdef __i386__
    if (sse2_supported)
        return sse2_memmove(dst, src, n);
#endif
 
    if (!n) return dst;
 
    if ((size_t)dst - (size_t)src >= n)
    {
        for (; (size_t)d % sizeof(size_t) && n; n--) *d++ = *s++;
 
        sh1 = 8 * ((size_t)s % sizeof(size_t));
        if (!sh1)
        {
            while (n >= sizeof(size_t))
            {
                *(size_t*)d = *(size_t*)s;
                s += sizeof(size_t);
                d += sizeof(size_t);
                n -= sizeof(size_t);
            }
        }
        else if (n >= 2 * sizeof(size_t))
        {
            int sh2 = 8 * sizeof(size_t) - sh1;
            size_t x, y;
 
            s -= sh1 / 8;
            x = *(size_t*)s;
            do
            {
                s += sizeof(size_t);
                y = *(size_t*)s;
                *(size_t*)d = MERGE(x, sh1, y, sh2);
                d += sizeof(size_t);
 
                s += sizeof(size_t);
                x = *(size_t*)s;
                *(size_t*)d = MERGE(y, sh1, x, sh2);
                d += sizeof(size_t);
 
                n -= 2 * sizeof(size_t);
            } while (n >= 2 * sizeof(size_t));
            s += sh1 / 8;
        }
        while (n--) *d++ = *s++;
        return dst;
    }
    else
    {
        d += n;
        s += n;
 
        for (; (size_t)d % sizeof(size_t) && n; n--) *--d = *--s;
 
        sh1 = 8 * ((size_t)s % sizeof(size_t));
        if (!sh1)
        {
            while (n >= sizeof(size_t))
            {
                s -= sizeof(size_t);
                d -= sizeof(size_t);
                *(size_t*)d = *(size_t*)s;
                n -= sizeof(size_t);
            }
        }
        else if (n >= 2 * sizeof(size_t))
        {
            int sh2 = 8 * sizeof(size_t) - sh1;
            size_t x, y;
 
            s -= sh1 / 8;
            x = *(size_t*)s;
            do
            {
                s -= sizeof(size_t);
                y = *(size_t*)s;
                d -= sizeof(size_t);
                *(size_t*)d = MERGE(y, sh1, x, sh2);
 
                s -= sizeof(size_t);
                x = *(size_t*)s;
                d -= sizeof(size_t);
                *(size_t*)d = MERGE(x, sh1, y, sh2);
 
                n -= 2 * sizeof(size_t);
            } while (n >= 2 * sizeof(size_t));
            s += sh1 / 8;
        }
        while (n--) *--d = *--s;
    }
    return dst;
#endif
}

memset()

void *__cdecl memset	(	void *	dst,
		int	c,
		size_t	n
	)

Definition at line 3230 of file string.c.

{
    typedef uint64_t DECLSPEC_ALIGN(1) unaligned_ui64;
    typedef uint32_t DECLSPEC_ALIGN(1) unaligned_ui32;
    typedef uint16_t DECLSPEC_ALIGN(1) unaligned_ui16;
 
    uint64_t v = 0x101010101010101ull * (unsigned char)c;
    unsigned char *d = (unsigned char *)dst;
    size_t a = 0x20 - ((uintptr_t)d & 0x1f);
 
    if (n >= 16)
    {
        *(unaligned_ui64 *)(d + 0) = v;
        *(unaligned_ui64 *)(d + 8) = v;
        *(unaligned_ui64 *)(d + n - 16) = v;
        *(unaligned_ui64 *)(d + n - 8) = v;
        if (n <= 32) return dst;
        *(unaligned_ui64 *)(d + 16) = v;
        *(unaligned_ui64 *)(d + 24) = v;
        *(unaligned_ui64 *)(d + n - 32) = v;
        *(unaligned_ui64 *)(d + n - 24) = v;
        if (n <= 64) return dst;
 
        n = (n - a) & ~0x1f;
        memset_aligned_32(d + a, v, n);
        return dst;
    }
    if (n >= 8)
    {
        *(unaligned_ui64 *)d = v;
        *(unaligned_ui64 *)(d + n - 8) = v;
        return dst;
    }
    if (n >= 4)
    {
        *(unaligned_ui32 *)d = v;
        *(unaligned_ui32 *)(d + n - 4) = v;
        return dst;
    }
    if (n >= 2)
    {
        *(unaligned_ui16 *)d = v;
        *(unaligned_ui16 *)(d + n - 2) = v;
        return dst;
    }
    if (n >= 1)
    {
        *(uint8_t *)d = v;
        return dst;
    }
    return dst;
}

memset_aligned_32()

static void memset_aligned_32 ( unsigned char *  d, uint64_t  v, size_t  n  )

inlinestatic

Definition at line 3214 of file string.c.

{
    unsigned char *end = d + n;
    while (d < end)
    {
        *(uint64_t *)(d + 0) = v;
        *(uint64_t *)(d + 8) = v;
        *(uint64_t *)(d + 16) = v;
        *(uint64_t *)(d + 24) = v;
        d += 32;
    }
}

Referenced by memset().

strcat()

char *__cdecl strcat	(	char *	dst,
		const char *	src
	)

Definition at line 1398 of file string.c.

{
    char *d = dst;
    while (*d) d++;
    while ((*d++ = *src++));
    return dst;
}

strcat_s()

int CDECL strcat_s	(	char *	dst,
		size_t	elem,
		const char *	src
	)

Definition at line 1368 of file string.c.

{
    size_t i, j;
    if (!MSVCRT_CHECK_PMT(dst != 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(elem != 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(src != NULL))
    {
        dst[0] = '\0';
        return EINVAL;
    }
 
    for(i = 0; i < elem; i++)
    {
        if(dst[i] == '\0')
        {
            for(j = 0; (j + i) < elem; j++)
            {
                if((dst[j + i] = src[j]) == '\0') return 0;
            }
        }
    }
    /* Set the first element to 0, not the first element after the skipped part */
    MSVCRT_INVALID_PMT("dst[elem] is too small", ERANGE);
    dst[0] = '\0';
    return ERANGE;
}

strchr()

char *__cdecl strchr	(	const char *	str,
		int	c
	)

Definition at line 3286 of file string.c.

{
    do
    {
        if (*str == (char)c) return (char*)str;
    } while (*str++);
    return NULL;
}

Referenced by strpbrk(), strspn(), strtok(), and strtok_s().

strcmp()

int __cdecl strcmp	(	const char *	str1,
		const char *	str2
	)

Definition at line 3319 of file string.c.

{
    while (*str1 && *str1 == *str2) { str1++; str2++; }
    if ((unsigned char)*str1 > (unsigned char)*str2) return 1;
    if ((unsigned char)*str1 < (unsigned char)*str2) return -1;
    return 0;
}

Referenced by _strcoll_l(), test__itoa_s(), test__snprintf(), test__strlwr_s(), test__strnset_s(), test__strupr(), test__tcscoll(), test__tcsncoll(), test__tcsnicoll(), test__ultoa_s(), test_gcvt(), test_printf_format(), test_qsort(), test_strcmp(), test_strcpy_s(), test_StrDupA(), test_StrFormatByteSize64A(), test_StrFormatKBSizeA(), test_StrFormatKBSizeW(), test_StrFromTimeIntervalA(), test_strncpy(), and test_strxfrm().

strcoll()

int CDECL strcoll	(	const char *	str1,
		const char *	str2
	)

Definition at line 1188 of file string.c.

{
    return _strcoll_l(str1, str2, NULL);
}

strcpy()

char *CDECL strcpy	(	char *	dst,
		const char *	src
	)

Definition at line 1335 of file string.c.

{
    char *ret = dst;
    while ((*dst++ = *src++));
    return ret;
}

strcpy_s()

int CDECL strcpy_s	(	char *	dst,
		size_t	elem,
		const char *	src
	)

Definition at line 1345 of file string.c.

{
    size_t i;
    if (!MSVCRT_CHECK_PMT(dst != 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(elem != 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(src != NULL))
    {
        dst[0] = '\0';
        return EINVAL;
    }
 
    for(i = 0; i < elem; i++)
    {
        if((dst[i] = src[i]) == '\0') return 0;
    }
    MSVCRT_INVALID_PMT("dst[elem] is too small", ERANGE);
    dst[0] = '\0';
    return ERANGE;
}

strcspn()

size_t __cdecl strcspn	(	const char *	str,
		const char *	reject
	)

Definition at line 3493 of file string.c.

{
    BOOL rejects[256];
    const char *p;
 
    memset(rejects, 0, sizeof(rejects));
 
    p = reject;
    while(*p)
    {
        rejects[(unsigned char)*p] = TRUE;
        p++;
    }
 
    p = str;
    while(*p && !rejects[(unsigned char)*p]) p++;
    return p - str;
}

Referenced by __Extract_locale_name(), __ParseLocaleString(), _mbscspn_l(), add_sequence(), CmdLineParse(), ConvertStabs(), get_annotation_by_name(), get_constant_by_name(), get_parameter_by_name(), gl_text(), KdbpCliInterpretInitFile(), KdbpCmdFilter(), KdbpDoCommand(), KdbpPagerInternal(), LoadWindowsCore(), NtLdrGetNextOption(), parse_options(), PcVideoSetDisplayMode(), RpnpParseExpression(), ATL::ChTraitsCRT< char >::StringSpanExcluding(), and test_strcspn().

strlen()

size_t __cdecl strlen

(

const char *

str

)

Definition at line 1592 of file string.c.

{
    const char *s = str;
    while (*s) s++;
    return s - str;
}

strncat()

char *__cdecl strncat	(	char *	dst,
		const char *	src,
		size_t	len
	)

Definition at line 1454 of file string.c.

{
    char *d = dst;
    while (*d) d++;
    for ( ; len && *src; d++, src++, len--) *d = *src;
    *d = 0;
    return dst;
}

strncat_s()

int CDECL strncat_s	(	char *	dst,
		size_t	elem,
		const char *	src,
		size_t	count
	)

Definition at line 1409 of file string.c.

{
    size_t i, j;
 
    if (!MSVCRT_CHECK_PMT(dst != 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(elem != 0)) return EINVAL;
    if (count == 0) return 0;
 
    if (!MSVCRT_CHECK_PMT(src != NULL))
    {
        *dst = 0;
        return EINVAL;
    }
 
    for (i = 0; i < elem; i++) if (!dst[i]) break;
 
    if (i == elem)
    {
        MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n", EINVAL);
        *dst = 0;
        return EINVAL;
    }
 
    for (j = 0; (j + i) < elem; j++)
    {
        if(count == _TRUNCATE && j + i == elem - 1)
        {
            dst[j + i] = '\0';
            return STRUNCATE;
        }
        if(j == count || (dst[j + i] = src[j]) == '\0')
        {
            dst[j + i] = '\0';
            return 0;
        }
    }
 
    MSVCRT_INVALID_PMT("dst[elem] is too small", ERANGE);
    dst[0] = '\0';
    return ERANGE;
}

strncmp()

int __cdecl strncmp	(	const char *	str1,
		const char *	str2,
		size_t	len
	)

Definition at line 3330 of file string.c.

{
    if (!len) return 0;
    while (--len && *str1 && *str1 == *str2) { str1++; str2++; }
 
#if defined(_WIN64) || defined(_UCRT) || _MSVCR_VER == 70 || _MSVCR_VER == 71 || _MSVCR_VER >= 110
    if ((unsigned char)*str1 > (unsigned char)*str2) return 1;
    if ((unsigned char)*str1 < (unsigned char)*str2) return -1;
    return 0;
#else
    return (unsigned char)*str1 - (unsigned char)*str2;
#endif
}

Referenced by _strncoll_l(), strstr(), test_strcmp(), and test_strncpy().

strncpy()

char *__cdecl strncpy	(	char *	dst,
		const char *	src,
		size_t	len
	)

Definition at line 1276 of file string.c.

{
    size_t i;
 
    for(i=0; i<len; i++)
        if((dst[i] = src[i]) == '\0') break;
 
    while (i < len) dst[i++] = 0;
 
    return dst;
}

strncpy_s()

int __cdecl strncpy_s	(	char *	dst,
		size_t	elem,
		const char *	src,
		size_t	count
	)

Definition at line 1291 of file string.c.

{
    char *p = dst;
    BOOL truncate = (count == _TRUNCATE);
 
    TRACE("(%p %Iu %s %Iu)\n", dst, elem, debugstr_a(src), count);
 
    if (!count)
    {
        if (dst && elem) *dst = 0;
        return 0;
    }
 
    if (!MSVCRT_CHECK_PMT(dst != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(elem != 0)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(src != NULL))
    {
        *dst = 0;
        return EINVAL;
    }
 
    while (elem && count && *src)
    {
        *p++ = *src++;
        elem--;
        count--;
    }
    if (!elem && truncate)
    {
        *(p-1) = 0;
        return STRUNCATE;
    }
    else if (!elem)
    {
        *dst = 0;
        return ERANGE;
    }
    *p = 0;
    return 0;
}

strnlen()

size_t CDECL strnlen	(	const char *	s,
		size_t	maxlen
	)

Definition at line 1602 of file string.c.

{
    size_t i;
 
    for(i=0; i<maxlen; i++)
        if(!s[i]) break;
 
    return i;
}

Referenced by _strncoll_l(), and _strnicoll_l().

strpbrk()

char *__cdecl strpbrk	(	const char *	str,
		const char *	accept
	)

Definition at line 3525 of file string.c.

{
    for (; *str; str++) if (strchr( accept, *str )) return (char*)str;
    return NULL;
}

strrchr()

char *__cdecl strrchr	(	const char *	str,
		int	c
	)

Definition at line 3298 of file string.c.

{
    char *ret = NULL;
    do { if (*str == (char)c) ret = (char*)str; } while (*str++);
    return ret;
}

Referenced by __rpc_uaddr2taddr_af(), _mbsrchr_l(), _module_name_from_addr(), appName(), ArcOpen(), AssertFail(), basename(), check_directory(), CLRRuntimeHost_ExecuteInDefaultAppDomain(), ComputeLNames(), ComputeRNames(), ConvertCoffs(), create_full_path(), create_monodata(), CWebServiceLibCurl::CWebServiceLibCurl(), d3dx_include_from_file_open(), DbgHelpAddLineNumber(), DecodeDirectoryURL(), disk_query_directory(), disk_query_information(), doChildren(), download_url(), Extract(), extract_rev_infos(), fdi_notify_extract(), find_or_create_directory(), FsOpenFile(), FTPChdirAndGetCWD(), FTPDecodeURL(), FTPFtw(), FTPFtwL2(), FTPGetCWD(), FTPMkdir2(), FTPPutOneF(), generate_joliet_path_tables(), generate_path_tables(), get_app_key(), get_basename(), get_basename_noext(), get_dirname(), get_events(), get_graft(), get_temp_filename(), getDirectory(), getFilename(), getopt(), if(), init(), init_event(), init_logger_addr(), InitDirComponents(), InitOurDirectory(), InitUserInfo(), insert_boot_cat(), iso9660_check(), iso9660_file_length(), KdpFilterEscapes(), TConfig::keyfile_init(), LdrQueryProcessModuleInformationEx(), load_hook_dll(), LoadAndBootWindows(), LoadReactOSSetup(), main(), mkPath(), MLLoadLibraryA(), MMIO_ParseExtA(), nFTPChdirAndGetCWD(), OnImage(), path_name(), pathcp(), PeLdrpBindImportName(), PRINTDLG_CreateDevNames(), PxeGetFileInformation(), read_rcfile(), reg_unreg_wine_test_class(), RemoteCompletionFunction(), rename_file(), RtlpQueryRemoteProcessModules(), run_script(), save_av0(), searchfileinpath(), SearchPathA(), set_progname(), setup_dsound_options(), ShellCmd(), sort_n_finish(), SpoolGetCmd(), SpoolPutCmd(), START_TEST(), StoreNameInSft(), strip_path(), StrRemoveTrailingSlashes(), test__lcreat(), test_appsearch_inilocator(), test_appsearch_reglocator(), test_CommandLine(), test_CreateScalableFontResource(), test_CryptCATAdminAddRemoveCatalog(), test_dde(), test_debug_children(), test_debug_heap(), test_EnumPrinterDrivers(), test_filenames(), test_find_file(), test_GetMappedFileName(), test_GetModuleBaseName(), test_GetPrivateProfileString(), test_GetSetConsoleInputExeName(), test_internet_features_registry(), test_load_save(), test_LoadImage_working_directory(), test_PlaySound(), test_PrintDlgA(), test_SetupCopyOEMInf(), test_SetupDecompressOrCopyFile(), test_utf8(), u_strrchr(), UDFGetDeviceName(), VerInstallFileA(), Win32DbgPrint(), wined3d_dll_init(), WINHELP_HistoryWndProc(), WINHELP_LookupHelpFile(), WinLdrLoadDeviceDriver(), xHalIoAssignDriveLetters(), and xkeymap_from_locale().

strspn()

size_t __cdecl strspn	(	const char *	str,
		const char *	accept
	)

Definition at line 3515 of file string.c.

{
    const char *ptr;
    for (ptr = str; *ptr; ptr++) if (!strchr( accept, *ptr )) break;
    return ptr - str;
}

strstr()

char *__cdecl strstr	(	const char *	haystack,
		const char *	needle
	)

Definition at line 3415 of file string.c.

{
    size_t i, j, len, needle_len, lps_len;
    BYTE lps[256];
 
    needle_len = strlen(needle);
    if (!needle_len) return (char*)haystack;
    lps_len = needle_len > ARRAY_SIZE(lps) ? ARRAY_SIZE(lps) : needle_len;
 
    lps[0] = 0;
    len = 0;
    i = 1;
    while (i < lps_len)
    {
        if (needle[i] == needle[len]) lps[i++] = ++len;
        else if (len) len = lps[len-1];
        else lps[i++] = 0;
    }
 
    i = j = 0;
    while (haystack[i])
    {
        while (j < lps_len && haystack[i] && haystack[i] == needle[j])
        {
            i++;
            j++;
        }
 
        if (j == needle_len) return (char*)haystack + i - j;
        else if (j)
        {
            if (j == ARRAY_SIZE(lps) && !strncmp(haystack + i, needle + j, needle_len - j))
                return (char*)haystack + i - j;
            j = lps[j-1];
        }
        else if (haystack[i]) i++;
    }
    return NULL;
}

Referenced by test_strstr().

strtod()

double CDECL strtod	(	const char *	str,
		char **	end
	)

Definition at line 1072 of file string.c.

{
    return _strtod_l( str, end, NULL );
}

Referenced by _test_strtod_str(), and test__strtod().

strtod_helper()

static double strtod_helper ( const char *  str, char **  end, _locale_t  locale, int *  perr  )

inlinestatic

Definition at line 1024 of file string.c.

{
    pthreadlocinfo locinfo;
    const char *beg, *p;
    struct fpnum fp;
    double ret;
    int err;
 
    if (perr) *perr = 0;
#if _MSVCR_VER == 0
    else *_errno() = 0;
#endif
 
    if (!MSVCRT_CHECK_PMT(str != NULL)) {
        if (end) *end = NULL;
        return 0;
    }
 
    if (!locale)
        locinfo = get_locinfo();
    else
        locinfo = locale->locinfo;
 
    p = str;
    while(_isspace_l((unsigned char)*p, locale))
        p++;
    beg = p;
 
    fp = fpnum_parse(strtod_str_get, strtod_str_unget, &p, locinfo, FALSE);
    if (end) *end = (p == beg ? (char*)str : (char*)p);
 
    err = fpnum_double(&fp, &ret);
    if (perr) *perr = err;
    else if(err) *_errno() = err;
    return ret;
}

Referenced by _atodbl_l(), _atoflt_l(), and _strtod_l().

strtod_str_get()

static wchar_t strtod_str_get ( void *  ctx )

static

Definition at line 1011 of file string.c.

{
    const char **p = ctx;
    if (!**p) return WEOF;
    return *(*p)++;
}

Referenced by __STRINGTOLD_L(), and strtod_helper().

strtod_str_unget()

static void strtod_str_unget ( void *  ctx )

static

Definition at line 1018 of file string.c.

{
    const char **p = ctx;
    (*p)--;
}

Referenced by __STRINGTOLD_L(), and strtod_helper().

strtok()

char *CDECL strtok	(	char *	str,
		const char *	delim
	)

Definition at line 285 of file string.c.

{
    thread_data_t *data = msvcrt_get_thread_data();
    char *ret;
 
    if (!str)
        if (!(str = data->strtok_next)) return NULL;
 
    while (*str && strchr( delim, *str )) str++;
    if (!*str)
    {
        data->strtok_next = str;
        return NULL;
    }
    ret = str++;
    while (*str && !strchr( delim, *str )) str++;
    if (*str) *str++ = 0;
    data->strtok_next = str;
    return ret;
}

Referenced by test__mbstok(), and test_strtok().

strtok_s()

char *CDECL strtok_s	(	char *	str,
		const char *	delim,
		char **	ctx
	)

Definition at line 309 of file string.c.

{
    if (!MSVCRT_CHECK_PMT(delim != NULL)) return NULL;
    if (!MSVCRT_CHECK_PMT(ctx != NULL)) return NULL;
    if (!MSVCRT_CHECK_PMT(str != NULL || *ctx != NULL)) return NULL;
 
    if(!str)
        str = *ctx;
 
    while(*str && strchr(delim, *str))
        str++;
    if(!*str)
    {
        *ctx = str;
        return NULL;
    }
 
    *ctx = str+1;
    while(**ctx && !strchr(delim, **ctx))
        (*ctx)++;
    if(**ctx)
        *(*ctx)++ = 0;
 
    return str;
}

strtol()

__msvcrt_long CDECL strtol	(	const char *	nptr,
		char **	end,
		int	base
	)

Definition at line 1833 of file string.c.

{
    return _strtol_l(nptr, end, base, NULL);
}

Referenced by test_strtol().

strtoul()

__msvcrt_ulong CDECL strtoul	(	const char *	nptr,
		char **	end,
		int	base
	)

Definition at line 1859 of file string.c.

{
    return _strtoul_l(nptr, end, base, NULL);
}

Referenced by test_strtol().

strxfrm()

size_t CDECL strxfrm	(	char *	dest,
		const char *	src,
		size_t	len
	)

Definition at line 1512 of file string.c.

{
    return _strxfrm_l(dest, src, len, NULL);
}

Referenced by test_strxfrm().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msvcrt

)