2 * msvcrt.dll wide-char functions
4 * Copyright 1999 Alexandre Julliard
5 * Copyright 2000 Jon Griffiths
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
31 #include "wine/unicode.h"
32 #include "wine/debug.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt
);
36 static BOOL n_format_enabled
= TRUE
;
43 /*********************************************************************
44 * _get_printf_count_output (MSVCR80.@)
46 int CDECL
MSVCRT__get_printf_count_output( void )
48 return n_format_enabled
? 1 : 0;
51 /*********************************************************************
52 * _set_printf_count_output (MSVCR80.@)
54 int CDECL
MSVCRT__set_printf_count_output( int enable
)
56 BOOL old
= n_format_enabled
;
57 n_format_enabled
= enable
!= 0;
61 /*********************************************************************
64 MSVCRT_wchar_t
* CDECL
MSVCRT__wcsdup( const MSVCRT_wchar_t
* str
)
66 MSVCRT_wchar_t
* ret
= NULL
;
69 int size
= (strlenW(str
) + 1) * sizeof(MSVCRT_wchar_t
);
70 ret
= MSVCRT_malloc( size
);
71 if (ret
) memcpy( ret
, str
, size
);
76 INT CDECL
MSVCRT__wcsicmp_l(const MSVCRT_wchar_t
*str1
, const MSVCRT_wchar_t
*str2
, MSVCRT__locale_t locale
)
78 if(!MSVCRT_CHECK_PMT(str1
!= NULL
) || !MSVCRT_CHECK_PMT(str2
!= NULL
))
79 return MSVCRT__NLSCMPERROR
;
81 return strcmpiW(str1
, str2
);
84 /*********************************************************************
87 INT CDECL
MSVCRT__wcsicmp( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
)
89 return strcmpiW( str1
, str2
);
92 /*********************************************************************
93 * _wcsnicmp_l (MSVCRT.@)
95 INT CDECL
MSVCRT__wcsnicmp_l(const MSVCRT_wchar_t
*str1
, const MSVCRT_wchar_t
*str2
, INT n
, MSVCRT__locale_t locale
)
97 return strncmpiW(str1
, str2
, n
);
100 /*********************************************************************
101 * _wcsnicmp (MSVCRT.@)
103 INT CDECL
MSVCRT__wcsnicmp(const MSVCRT_wchar_t
*str1
, const MSVCRT_wchar_t
*str2
, INT n
)
105 return MSVCRT__wcsnicmp_l(str1
, str2
, n
, NULL
);
108 /*********************************************************************
109 * _wcsicoll_l (MSVCRT.@)
111 int CDECL
MSVCRT__wcsicoll_l(const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
, MSVCRT__locale_t locale
)
113 MSVCRT_pthreadlocinfo locinfo
;
116 locinfo
= get_locinfo();
118 locinfo
= locale
->locinfo
;
120 if(!locinfo
->lc_handle
[MSVCRT_LC_COLLATE
])
121 return strcmpiW(str1
, str2
);
122 return CompareStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
], NORM_IGNORECASE
,
123 str1
, -1, str2
, -1)-CSTR_EQUAL
;
126 /*********************************************************************
127 * _wcsicoll (MSVCRT.@)
129 INT CDECL
MSVCRT__wcsicoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
)
131 return MSVCRT__wcsicoll_l(str1
, str2
, NULL
);
134 /*********************************************************************
135 * _wcsnicoll_l (MSVCRT.@)
137 int CDECL
MSVCRT__wcsnicoll_l(const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
,
138 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
140 MSVCRT_pthreadlocinfo locinfo
;
143 locinfo
= get_locinfo();
145 locinfo
= locale
->locinfo
;
147 if(!locinfo
->lc_handle
[MSVCRT_LC_COLLATE
])
148 return strncmpiW(str1
, str2
, count
);
149 return CompareStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
], NORM_IGNORECASE
,
150 str1
, count
, str2
, count
)-CSTR_EQUAL
;
153 /*********************************************************************
154 * _wcsnicoll (MSVCRT.@)
156 INT CDECL
MSVCRT__wcsnicoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
, MSVCRT_size_t count
)
158 return MSVCRT__wcsnicoll_l(str1
, str2
, count
, NULL
);
161 /*********************************************************************
162 * _wcsnset (MSVCRT.@)
164 MSVCRT_wchar_t
* CDECL
MSVCRT__wcsnset( MSVCRT_wchar_t
* str
, MSVCRT_wchar_t c
, MSVCRT_size_t n
)
166 MSVCRT_wchar_t
* ret
= str
;
167 while ((n
-- > 0) && *str
) *str
++ = c
;
171 /*********************************************************************
174 MSVCRT_wchar_t
* CDECL
MSVCRT__wcsrev( MSVCRT_wchar_t
* str
)
176 MSVCRT_wchar_t
* ret
= str
;
177 MSVCRT_wchar_t
* end
= str
+ strlenW(str
) - 1;
180 MSVCRT_wchar_t t
= *end
;
187 /*********************************************************************
188 * _wcsset_s (MSVCRT.@)
190 int CDECL
MSVCRT__wcsset_s( MSVCRT_wchar_t
*str
, MSVCRT_size_t n
, MSVCRT_wchar_t c
)
192 MSVCRT_wchar_t
*p
= str
;
194 if(!MSVCRT_CHECK_PMT(str
!= NULL
)) return MSVCRT_EINVAL
;
195 if(!MSVCRT_CHECK_PMT(n
)) return MSVCRT_EINVAL
;
197 while(*p
&& --n
) *p
++ = c
;
200 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
201 *MSVCRT__errno() = MSVCRT_EINVAL
;
202 return MSVCRT_EINVAL
;
207 /*********************************************************************
210 MSVCRT_wchar_t
* CDECL
MSVCRT__wcsset( MSVCRT_wchar_t
* str
, MSVCRT_wchar_t c
)
212 MSVCRT_wchar_t
* ret
= str
;
213 while (*str
) *str
++ = c
;
217 /******************************************************************
218 * _wcsupr_s_l (MSVCRT.@)
220 int CDECL
MSVCRT__wcsupr_s_l( MSVCRT_wchar_t
* str
, MSVCRT_size_t n
,
221 MSVCRT__locale_t locale
)
223 MSVCRT_wchar_t
* ptr
= str
;
227 if (str
) *str
= '\0';
228 *MSVCRT__errno() = MSVCRT_EINVAL
;
229 return MSVCRT_EINVAL
;
235 /* FIXME: add locale support */
236 *ptr
= toupperW(*ptr
);
240 /* MSDN claims that the function should return and set errno to
241 * ERANGE, which doesn't seem to be true based on the tests. */
243 *MSVCRT__errno() = MSVCRT_EINVAL
;
244 return MSVCRT_EINVAL
;
247 /******************************************************************
248 * _wcsupr_s (MSVCRT.@)
251 INT CDECL
MSVCRT__wcsupr_s( MSVCRT_wchar_t
* str
, MSVCRT_size_t n
)
253 return MSVCRT__wcsupr_s_l( str
, n
, NULL
);
256 /******************************************************************
257 * _wcsupr_l (MSVCRT.@)
259 MSVCRT_wchar_t
* CDECL
MSVCRT__wcsupr_l( MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
261 MSVCRT__wcsupr_s_l( str
, -1, locale
);
265 /******************************************************************
266 * _wcslwr_s_l (MSVCRT.@)
268 int CDECL
MSVCRT__wcslwr_s_l( MSVCRT_wchar_t
* str
, MSVCRT_size_t n
, MSVCRT__locale_t locale
)
270 MSVCRT_wchar_t
* ptr
= str
;
274 if (str
) *str
= '\0';
275 *MSVCRT__errno() = MSVCRT_EINVAL
;
276 return MSVCRT_EINVAL
;
282 *ptr
= tolowerW(*ptr
);
286 /* MSDN claims that the function should return and set errno to
287 * ERANGE, which doesn't seem to be true based on the tests. */
289 *MSVCRT__errno() = MSVCRT_EINVAL
;
290 return MSVCRT_EINVAL
;
293 /******************************************************************
294 * _wcslwr_s (MSVCRT.@)
296 int CDECL
MSVCRT__wcslwr_s( MSVCRT_wchar_t
* str
, MSVCRT_size_t n
)
298 return MSVCRT__wcslwr_s_l(str
, n
, NULL
);
301 /******************************************************************
302 * _wcslwr_l (MSVCRT.@)
304 MSVCRT_wchar_t
* CDECL
MSVCRT__wcslwr_l( MSVCRT_wchar_t
* str
, MSVCRT__locale_t locale
)
306 MSVCRT__wcslwr_s_l(str
, -1, locale
);
310 /******************************************************************
313 MSVCRT_wchar_t
* CDECL
MSVCRT__wcslwr( MSVCRT_wchar_t
* str
)
315 MSVCRT__wcslwr_s_l(str
, -1, NULL
);
319 /*********************************************************************
320 * _wcsncoll_l (MSVCRT.@)
322 int CDECL
MSVCRT__wcsncoll_l(const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
,
323 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
325 MSVCRT_pthreadlocinfo locinfo
;
328 locinfo
= get_locinfo();
330 locinfo
= locale
->locinfo
;
332 if(!locinfo
->lc_handle
[MSVCRT_LC_COLLATE
])
333 return strncmpW(str1
, str2
, count
);
334 return CompareStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
], 0, str1
, count
, str2
, count
)-CSTR_EQUAL
;
337 /*********************************************************************
338 * _wcsncoll (MSVCRT.@)
340 int CDECL
MSVCRT__wcsncoll(const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
, MSVCRT_size_t count
)
342 return MSVCRT__wcsncoll_l(str1
, str2
, count
, NULL
);
345 /*********************************************************************
346 * _wcstod_l (MSVCRT.@)
348 double CDECL
MSVCRT__wcstod_l(const MSVCRT_wchar_t
* str
, MSVCRT_wchar_t
** end
,
349 MSVCRT__locale_t locale
)
351 MSVCRT_pthreadlocinfo locinfo
;
352 unsigned __int64 d
=0, hlp
;
355 const MSVCRT_wchar_t
*p
;
357 long double lret
=1, expcnt
= 10;
358 BOOL found_digit
= FALSE
, negexp
;
360 if (!MSVCRT_CHECK_PMT(str
!= NULL
)) return 0;
363 locinfo
= get_locinfo();
365 locinfo
= locale
->locinfo
;
377 while(isdigitW(*p
)) {
379 hlp
= d
*10+*(p
++)-'0';
380 if(d
>MSVCRT_UI64_MAX
/10 || hlp
<d
) {
386 while(isdigitW(*p
)) {
390 if(*p
== *locinfo
->lconv
->decimal_point
)
393 while(isdigitW(*p
)) {
395 hlp
= d
*10+*(p
++)-'0';
396 if(d
>MSVCRT_UI64_MAX
/10 || hlp
<d
)
407 *end
= (MSVCRT_wchar_t
*)str
;
411 if(*p
=='e' || *p
=='E' || *p
=='d' || *p
=='D') {
422 while(isdigitW(*p
)) {
423 if(e
>INT_MAX
/10 || (e
=e
*10+*p
-'0')<0)
429 if(exp
<0 && e
<0 && exp
+e
>=0) exp
= INT_MIN
;
430 else if(exp
>0 && e
>0 && exp
+e
<0) exp
= INT_MAX
;
433 if(*p
=='-' || *p
=='+')
439 fpcontrol
= _control87(0, 0);
440 _control87(MSVCRT__EM_DENORMAL
|MSVCRT__EM_INVALID
|MSVCRT__EM_ZERODIVIDE
441 |MSVCRT__EM_OVERFLOW
|MSVCRT__EM_UNDERFLOW
|MSVCRT__EM_INEXACT
, 0xffffffff);
450 expcnt
= expcnt
*expcnt
;
452 ret
= (long double)sign
* (negexp
? d
/lret
: d
*lret
);
454 _control87(fpcontrol
, 0xffffffff);
456 if((d
&& ret
==0.0) || isinf(ret
))
457 *MSVCRT__errno() = MSVCRT_ERANGE
;
460 *end
= (MSVCRT_wchar_t
*)p
;
465 /*********************************************************************
466 * wcsrtombs_l (INTERNAL)
468 static MSVCRT_size_t
MSVCRT_wcsrtombs_l(char *mbstr
, const MSVCRT_wchar_t
**wcstr
,
469 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
471 MSVCRT_pthreadlocinfo locinfo
;
472 MSVCRT_size_t tmp
= 0;
476 locinfo
= get_locinfo();
478 locinfo
= locale
->locinfo
;
481 tmp
= WideCharToMultiByte(locinfo
->lc_codepage
, WC_NO_BEST_FIT_CHARS
,
482 *wcstr
, -1, NULL
, 0, NULL
, &used_default
)-1;
483 if(!tmp
|| used_default
) {
484 *MSVCRT__errno() = MSVCRT_EILSEQ
;
492 MSVCRT_size_t i
, size
;
494 size
= WideCharToMultiByte(locinfo
->lc_codepage
, WC_NO_BEST_FIT_CHARS
,
495 *wcstr
, 1, buf
, 3, NULL
, &used_default
);
496 if(!size
|| used_default
) {
497 *MSVCRT__errno() = MSVCRT_EILSEQ
;
503 for(i
=0; i
<size
; i
++)
504 mbstr
[tmp
++] = buf
[i
];
515 /*********************************************************************
516 * _wcstombs_l (MSVCRT.@)
518 MSVCRT_size_t CDECL
MSVCRT__wcstombs_l(char *mbstr
, const MSVCRT_wchar_t
*wcstr
,
519 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
521 return MSVCRT_wcsrtombs_l(mbstr
, &wcstr
, count
, locale
);
524 /*********************************************************************
525 * wcstombs (MSVCRT.@)
527 MSVCRT_size_t CDECL
MSVCRT_wcstombs(char *mbstr
, const MSVCRT_wchar_t
*wcstr
,
530 return MSVCRT_wcsrtombs_l(mbstr
, &wcstr
, count
, NULL
);
533 /*********************************************************************
534 * wcsrtombs (MSVCRT.@)
536 MSVCRT_size_t CDECL
MSVCRT_wcsrtombs(char *mbstr
, const MSVCRT_wchar_t
**wcstr
,
537 MSVCRT_size_t count
, MSVCRT_mbstate_t
*mbstate
)
542 return MSVCRT_wcsrtombs_l(mbstr
, wcstr
, count
, NULL
);
545 /*********************************************************************
546 * MSVCRT_wcsrtombs_s_l (INTERNAL)
548 static int MSVCRT_wcsrtombs_s_l(MSVCRT_size_t
*ret
, char *mbstr
,
549 MSVCRT_size_t size
, const MSVCRT_wchar_t
**wcstr
,
550 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
554 if(!mbstr
&& !size
&& wcstr
) {
555 conv
= MSVCRT_wcsrtombs_l(NULL
, wcstr
, 0, locale
);
557 return *MSVCRT__errno();
563 if (!MSVCRT_CHECK_PMT(mbstr
!= NULL
)) return MSVCRT_EINVAL
;
564 if (size
) mbstr
[0] = '\0';
565 if (!MSVCRT_CHECK_PMT(wcstr
!= NULL
)) return MSVCRT_EINVAL
;
566 if (!MSVCRT_CHECK_PMT(*wcstr
!= NULL
)) return MSVCRT_EINVAL
;
568 if(count
==MSVCRT__TRUNCATE
|| size
<count
)
573 conv
= MSVCRT_wcsrtombs_l(mbstr
, wcstr
, conv
, locale
);
577 return *MSVCRT__errno();
578 }else if(conv
< size
)
579 mbstr
[conv
++] = '\0';
580 else if(conv
==size
&& (count
==MSVCRT__TRUNCATE
|| mbstr
[conv
-1]=='\0'))
581 mbstr
[conv
-1] = '\0';
583 MSVCRT_INVALID_PMT("mbstr[size] is too small", MSVCRT_ERANGE
);
586 return MSVCRT_ERANGE
;
594 /*********************************************************************
595 * _wcstombs_s_l (MSVCRT.@)
597 int CDECL
MSVCRT__wcstombs_s_l(MSVCRT_size_t
*ret
, char *mbstr
,
598 MSVCRT_size_t size
, const MSVCRT_wchar_t
*wcstr
,
599 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
601 return MSVCRT_wcsrtombs_s_l(ret
, mbstr
, size
, &wcstr
,count
, locale
);
604 /*********************************************************************
605 * wcstombs_s (MSVCRT.@)
607 int CDECL
MSVCRT_wcstombs_s(MSVCRT_size_t
*ret
, char *mbstr
,
608 MSVCRT_size_t size
, const MSVCRT_wchar_t
*wcstr
, MSVCRT_size_t count
)
610 return MSVCRT_wcsrtombs_s_l(ret
, mbstr
, size
, &wcstr
, count
, NULL
);
613 /*********************************************************************
614 * wcsrtombs_s (MSVCRT.@)
616 int CDECL
MSVCRT_wcsrtombs_s(MSVCRT_size_t
*ret
, char *mbstr
, MSVCRT_size_t size
,
617 const MSVCRT_wchar_t
**wcstr
, MSVCRT_size_t count
, MSVCRT_mbstate_t
*mbstate
)
622 return MSVCRT_wcsrtombs_s_l(ret
, mbstr
, size
, wcstr
, count
, NULL
);
625 /*********************************************************************
628 double CDECL
MSVCRT_wcstod(const MSVCRT_wchar_t
* lpszStr
, MSVCRT_wchar_t
** end
)
630 return MSVCRT__wcstod_l(lpszStr
, end
, NULL
);
633 /*********************************************************************
636 double CDECL
MSVCRT__wtof(const MSVCRT_wchar_t
*str
)
638 return MSVCRT__wcstod_l(str
, NULL
, NULL
);
641 /*********************************************************************
644 double CDECL
MSVCRT__wtof_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
646 return MSVCRT__wcstod_l(str
, NULL
, locale
);
649 /*********************************************************************
650 * arg_clbk_valist (INTERNAL)
652 printf_arg
arg_clbk_valist(void *ctx
, int arg_pos
, int type
, __ms_va_list
*valist
)
657 ret
.get_longlong
= va_arg(*valist
, LONGLONG
);
658 else if(type
== VT_INT
)
659 ret
.get_int
= va_arg(*valist
, int);
660 else if(type
== VT_R8
)
661 ret
.get_double
= va_arg(*valist
, double);
662 else if(type
== VT_PTR
)
663 ret
.get_ptr
= va_arg(*valist
, void*);
665 ERR("Incorrect type\n");
672 /*********************************************************************
673 * arg_clbk_positional (INTERNAL)
675 static printf_arg
arg_clbk_positional(void *ctx
, int pos
, int type
, __ms_va_list
*valist
)
677 printf_arg
*args
= ctx
;
681 /*********************************************************************
682 * _vsnprintf (MSVCRT.@)
684 int CDECL
MSVCRT_vsnprintf( char *str
, MSVCRT_size_t len
,
685 const char *format
, __ms_va_list valist
)
687 static const char nullbyte
= '\0';
688 struct _str_ctx_a ctx
= {len
, str
};
691 ret
= pf_printf_a(puts_clbk_str_a
, &ctx
, format
, NULL
, FALSE
, FALSE
,
692 arg_clbk_valist
, NULL
, &valist
);
693 puts_clbk_str_a(&ctx
, 1, &nullbyte
);
697 /*********************************************************************
698 * _vsnprintf_l (MSVCRT.@)
700 int CDECL
MSVCRT_vsnprintf_l( char *str
, MSVCRT_size_t len
, const char *format
,
701 MSVCRT__locale_t locale
, __ms_va_list valist
)
703 static const char nullbyte
= '\0';
704 struct _str_ctx_a ctx
= {len
, str
};
707 ret
= pf_printf_a(puts_clbk_str_a
, &ctx
, format
, locale
, FALSE
, FALSE
,
708 arg_clbk_valist
, NULL
, &valist
);
709 puts_clbk_str_a(&ctx
, 1, &nullbyte
);
713 /*********************************************************************
714 * _vsprintf_l (MSVCRT.@)
716 int CDECL
MSVCRT_vsprintf_l( char *str
, const char *format
,
717 MSVCRT__locale_t locale
, __ms_va_list valist
)
719 return MSVCRT_vsnprintf_l(str
, INT_MAX
, format
, locale
, valist
);
722 /*********************************************************************
723 * _sprintf_l (MSVCRT.@)
725 int CDECL
MSVCRT_sprintf_l(char *str
, const char *format
,
726 MSVCRT__locale_t locale
, ...)
730 __ms_va_start(valist
, locale
);
731 retval
= MSVCRT_vsnprintf_l(str
, INT_MAX
, format
, locale
, valist
);
736 /*********************************************************************
737 * _vsnprintf_s_l (MSVCRT.@)
739 int CDECL
MSVCRT_vsnprintf_s_l( char *str
, MSVCRT_size_t sizeOfBuffer
,
740 MSVCRT_size_t count
, const char *format
,
741 MSVCRT__locale_t locale
, __ms_va_list valist
)
743 static const char nullbyte
= '\0';
744 struct _str_ctx_a ctx
;
747 if(sizeOfBuffer
<count
+1 || count
==-1)
754 ret
= pf_printf_a(puts_clbk_str_a
, &ctx
, format
, locale
, FALSE
, TRUE
,
755 arg_clbk_valist
, NULL
, &valist
);
756 puts_clbk_str_a(&ctx
, 1, &nullbyte
);
758 if(ret
<0 || ret
==len
) {
759 if(count
!=MSVCRT__TRUNCATE
&& count
>sizeOfBuffer
) {
760 MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", MSVCRT_ERANGE
);
761 memset(str
, 0, sizeOfBuffer
);
771 /*********************************************************************
772 * _vsprintf_s_l (MSVCRT.@)
774 int CDECL
MSVCRT_vsprintf_s_l( char *str
, MSVCRT_size_t count
, const char *format
,
775 MSVCRT__locale_t locale
, __ms_va_list valist
)
777 return MSVCRT_vsnprintf_s_l(str
, INT_MAX
, count
, format
, locale
, valist
);
780 /*********************************************************************
781 * _sprintf_s_l (MSVCRT.@)
783 int CDECL
MSVCRT_sprintf_s_l( char *str
, MSVCRT_size_t count
, const char *format
,
784 MSVCRT__locale_t locale
, ...)
788 __ms_va_start(valist
, locale
);
789 retval
= MSVCRT_vsnprintf_s_l(str
, INT_MAX
, count
, format
, locale
, valist
);
794 /*********************************************************************
795 * _vsnprintf_s (MSVCRT.@)
797 int CDECL
MSVCRT_vsnprintf_s( char *str
, MSVCRT_size_t sizeOfBuffer
,
798 MSVCRT_size_t count
, const char *format
, __ms_va_list valist
)
800 return MSVCRT_vsnprintf_s_l(str
,sizeOfBuffer
, count
, format
, NULL
, valist
);
803 /*********************************************************************
804 * vsprintf (MSVCRT.@)
806 int CDECL
MSVCRT_vsprintf( char *str
, const char *format
, __ms_va_list valist
)
808 return MSVCRT_vsnprintf(str
, INT_MAX
, format
, valist
);
811 /*********************************************************************
812 * vsprintf_s (MSVCRT.@)
814 int CDECL
MSVCRT_vsprintf_s( char *str
, MSVCRT_size_t num
, const char *format
, __ms_va_list valist
)
816 return MSVCRT_vsnprintf(str
, num
, format
, valist
);
819 /*********************************************************************
820 * _vscprintf (MSVCRT.@)
822 int CDECL
MSVCRT__vscprintf( const char *format
, __ms_va_list valist
)
824 return MSVCRT_vsnprintf( NULL
, INT_MAX
, format
, valist
);
827 /*********************************************************************
828 * _vscprintf_p_l (MSVCRT.@)
830 int CDECL
MSVCRT__vscprintf_p_l(const char *format
,
831 MSVCRT__locale_t locale
, __ms_va_list args
)
833 printf_arg args_ctx
[MSVCRT__ARGMAX
+1];
834 struct _str_ctx_a puts_ctx
= {INT_MAX
, NULL
};
837 memset(args_ctx
, 0, sizeof(args_ctx
));
839 ret
= create_positional_ctx_a(args_ctx
, format
, args
);
841 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
842 *MSVCRT__errno() = MSVCRT_EINVAL
;
844 } else if(ret
== 0) {
845 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
, FALSE
, TRUE
,
846 arg_clbk_valist
, NULL
, &args
);
848 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
, TRUE
, TRUE
,
849 arg_clbk_positional
, args_ctx
, NULL
);
855 /*********************************************************************
856 * _vscprintf_p (MSVCR80.@)
858 int CDECL
MSVCRT__vscprintf_p(const char *format
, __ms_va_list argptr
)
860 return MSVCRT__vscprintf_p_l(format
, NULL
, argptr
);
863 /*********************************************************************
864 * _snprintf (MSVCRT.@)
866 int CDECL
MSVCRT__snprintf(char *str
, unsigned int len
, const char *format
, ...)
870 __ms_va_start(valist
, format
);
871 retval
= MSVCRT_vsnprintf(str
, len
, format
, valist
);
876 /*********************************************************************
877 * _snprintf_l (MSVCRT.@)
879 int CDECL
MSVCRT__snprintf_l(char *str
, unsigned int count
, MSVCRT__locale_t locale
,
880 const char *format
, ...)
884 __ms_va_start(valist
, format
);
885 retval
= MSVCRT_vsnprintf_l(str
, count
, format
, locale
, valist
);
890 /*********************************************************************
891 * _snprintf_s (MSVCRT.@)
893 int CDECL
MSVCRT__snprintf_s(char *str
, unsigned int len
, unsigned int count
,
894 const char *format
, ...)
898 __ms_va_start(valist
, format
);
899 retval
= MSVCRT_vsnprintf_s_l(str
, len
, count
, format
, NULL
, valist
);
904 /*********************************************************************
905 * _scprintf (MSVCRT.@)
907 int CDECL
MSVCRT__scprintf(const char *format
, ...)
911 __ms_va_start(valist
, format
);
912 retval
= MSVCRT__vscprintf(format
, valist
);
917 /*********************************************************************
918 * _vsnwprintf (MSVCRT.@)
920 int CDECL
MSVCRT_vsnwprintf(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
921 const MSVCRT_wchar_t
*format
, __ms_va_list valist
)
923 static const MSVCRT_wchar_t nullbyte
= '\0';
924 struct _str_ctx_w ctx
= {len
, str
};
927 ret
= pf_printf_w(puts_clbk_str_w
, &ctx
, format
, NULL
, FALSE
, FALSE
,
928 arg_clbk_valist
, NULL
, &valist
);
929 puts_clbk_str_w(&ctx
, 1, &nullbyte
);
933 /*********************************************************************
934 * _vsnwprintf_l (MSVCRT.@)
936 int CDECL
MSVCRT_vsnwprintf_l(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
937 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
,
940 static const MSVCRT_wchar_t nullbyte
= '\0';
941 struct _str_ctx_w ctx
= {len
, str
};
944 ret
= pf_printf_w(puts_clbk_str_w
, &ctx
, format
, locale
, FALSE
, FALSE
,
945 arg_clbk_valist
, NULL
, &valist
);
946 puts_clbk_str_w(&ctx
, 1, &nullbyte
);
950 /*********************************************************************
951 * _vswprintf_p_l (MSVCRT.@)
953 int CDECL
MSVCRT_vswprintf_p_l(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
954 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, __ms_va_list args
)
956 static const MSVCRT_wchar_t nullbyte
= '\0';
957 printf_arg args_ctx
[MSVCRT__ARGMAX
+1];
958 struct _str_ctx_w puts_ctx
= {length
, buffer
};
961 memset(args_ctx
, 0, sizeof(args_ctx
));
963 ret
= create_positional_ctx_w(args_ctx
, format
, args
);
965 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
966 *MSVCRT__errno() = MSVCRT_EINVAL
;
969 ret
= pf_printf_w(puts_clbk_str_w
, &puts_ctx
, format
, locale
, FALSE
, TRUE
,
970 arg_clbk_valist
, NULL
, &args
);
972 ret
= pf_printf_w(puts_clbk_str_w
, &puts_ctx
, format
, locale
, TRUE
, TRUE
,
973 arg_clbk_positional
, args_ctx
, NULL
);
975 puts_clbk_str_w(&puts_ctx
, 1, &nullbyte
);
979 /*********************************************************************
980 * _vswprintf_p (MSVCR100.@)
982 int CDECL
MSVCRT__vswprintf_p(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
983 const MSVCRT_wchar_t
*format
, __ms_va_list args
)
985 return MSVCRT_vswprintf_p_l(buffer
, length
, format
, NULL
, args
);
988 /*********************************************************************
989 * _vsnwprintf_s_l (MSVCRT.@)
991 int CDECL
MSVCRT_vsnwprintf_s_l( MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
992 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
,
993 MSVCRT__locale_t locale
, __ms_va_list valist
)
995 static const MSVCRT_wchar_t nullbyte
= '\0';
996 struct _str_ctx_w ctx
;
1000 if(count
!=-1 && len
>count
+1)
1005 ret
= pf_printf_w(puts_clbk_str_w
, &ctx
, format
, locale
, FALSE
, TRUE
,
1006 arg_clbk_valist
, NULL
, &valist
);
1007 puts_clbk_str_w(&ctx
, 1, &nullbyte
);
1009 if(ret
<0 || ret
==len
) {
1010 if(count
!=MSVCRT__TRUNCATE
&& count
>sizeOfBuffer
) {
1011 MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", MSVCRT_ERANGE
);
1012 memset(str
, 0, sizeOfBuffer
*sizeof(MSVCRT_wchar_t
));
1022 /*********************************************************************
1023 * _vsnwprintf_s (MSVCRT.@)
1025 int CDECL
MSVCRT_vsnwprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
1026 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
, __ms_va_list valist
)
1028 return MSVCRT_vsnwprintf_s_l(str
, sizeOfBuffer
, count
,
1029 format
, NULL
, valist
);
1032 /*********************************************************************
1033 * _snwprintf (MSVCRT.@)
1035 int CDECL
MSVCRT__snwprintf( MSVCRT_wchar_t
*str
, unsigned int len
, const MSVCRT_wchar_t
*format
, ...)
1038 __ms_va_list valist
;
1039 __ms_va_start(valist
, format
);
1040 retval
= MSVCRT_vsnwprintf(str
, len
, format
, valist
);
1041 __ms_va_end(valist
);
1045 /*********************************************************************
1046 * _snwprintf_l (MSVCRT.@)
1048 int CDECL
MSVCRT__snwprintf_l( MSVCRT_wchar_t
*str
, unsigned int len
, const MSVCRT_wchar_t
*format
,
1049 MSVCRT__locale_t locale
, ...)
1052 __ms_va_list valist
;
1053 __ms_va_start(valist
, locale
);
1054 retval
= MSVCRT_vsnwprintf_l(str
, len
, format
, locale
, valist
);
1055 __ms_va_end(valist
);
1059 /*********************************************************************
1060 * _snwprintf_s (MSVCRT.@)
1062 int CDECL
MSVCRT__snwprintf_s( MSVCRT_wchar_t
*str
, unsigned int len
, unsigned int count
,
1063 const MSVCRT_wchar_t
*format
, ...)
1066 __ms_va_list valist
;
1067 __ms_va_start(valist
, format
);
1068 retval
= MSVCRT_vsnwprintf_s_l(str
, len
, count
, format
, NULL
, valist
);
1069 __ms_va_end(valist
);
1073 /*********************************************************************
1074 * _snwprintf_s_l (MSVCRT.@)
1076 int CDECL
MSVCRT__snwprintf_s_l( MSVCRT_wchar_t
*str
, unsigned int len
, unsigned int count
,
1077 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, ... )
1080 __ms_va_list valist
;
1081 __ms_va_start(valist
, locale
);
1082 retval
= MSVCRT_vsnwprintf_s_l(str
, len
, count
, format
, locale
, valist
);
1083 __ms_va_end(valist
);
1087 /*********************************************************************
1088 * sprintf (MSVCRT.@)
1090 int CDECL
MSVCRT_sprintf( char *str
, const char *format
, ... )
1095 __ms_va_start( ap
, format
);
1096 r
= MSVCRT_vsnprintf( str
, INT_MAX
, format
, ap
);
1101 /*********************************************************************
1102 * sprintf_s (MSVCRT.@)
1104 int CDECL
MSVCRT_sprintf_s( char *str
, MSVCRT_size_t num
, const char *format
, ... )
1109 __ms_va_start( ap
, format
);
1110 r
= MSVCRT_vsnprintf( str
, num
, format
, ap
);
1115 /*********************************************************************
1116 * _scwprintf (MSVCRT.@)
1118 int CDECL
MSVCRT__scwprintf( const MSVCRT_wchar_t
*format
, ... )
1123 __ms_va_start( ap
, format
);
1124 r
= MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, ap
);
1129 /*********************************************************************
1130 * swprintf (MSVCRT.@)
1132 int CDECL
MSVCRT_swprintf( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*format
, ... )
1137 __ms_va_start( ap
, format
);
1138 r
= MSVCRT_vsnwprintf( str
, INT_MAX
, format
, ap
);
1143 /*********************************************************************
1144 * swprintf_s (MSVCRT.@)
1146 int CDECL
MSVCRT_swprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t numberOfElements
,
1147 const MSVCRT_wchar_t
*format
, ... )
1152 __ms_va_start(ap
, format
);
1153 r
= MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, ap
);
1159 /*********************************************************************
1160 * _swprintf_s_l (MSVCRT.@)
1162 int CDECL
MSVCRT__swprintf_s_l(MSVCRT_wchar_t
*str
, MSVCRT_size_t numberOfElements
,
1163 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, ... )
1168 __ms_va_start(ap
, locale
);
1169 r
= MSVCRT_vsnwprintf_s_l(str
, numberOfElements
, INT_MAX
, format
, locale
, ap
);
1175 /*********************************************************************
1176 * _vswprintf (MSVCRT.@)
1178 int CDECL
MSVCRT_vswprintf( MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* format
, __ms_va_list args
)
1180 return MSVCRT_vsnwprintf( str
, INT_MAX
, format
, args
);
1183 /*********************************************************************
1184 * _vswprintf (MSVCRT.@)
1186 int CDECL
MSVCRT_vswprintf_l( MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* format
,
1187 MSVCRT__locale_t locale
, __ms_va_list args
)
1189 return MSVCRT_vsnwprintf_l( str
, INT_MAX
, format
, locale
, args
);
1192 /*********************************************************************
1193 * _vscwprintf (MSVCRT.@)
1195 int CDECL
MSVCRT__vscwprintf( const MSVCRT_wchar_t
*format
, __ms_va_list args
)
1197 return MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, args
);
1200 /*********************************************************************
1201 * _vscwprintf_l (MSVCRT.@)
1203 int CDECL
MSVCRT__vscwprintf_l( const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, __ms_va_list args
)
1205 return MSVCRT_vsnwprintf_l( NULL
, INT_MAX
, format
, locale
, args
);
1208 /*********************************************************************
1209 * _vscwprintf_p_l (MSVCRT.@)
1211 int CDECL
MSVCRT__vscwprintf_p_l( const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, __ms_va_list args
)
1213 return MSVCRT_vswprintf_p_l( NULL
, INT_MAX
, format
, locale
, args
);
1216 /*********************************************************************
1217 * _vscwprintf_p (MSVCR100.@)
1219 int CDECL
MSVCRT__vscwprintf_p(const MSVCRT_wchar_t
*format
, __ms_va_list args
)
1221 return MSVCRT_vswprintf_p_l(NULL
, INT_MAX
, format
, NULL
, args
);
1224 /*********************************************************************
1225 * vswprintf_s (MSVCRT.@)
1227 int CDECL
MSVCRT_vswprintf_s(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
1228 const MSVCRT_wchar_t
* format
, __ms_va_list args
)
1230 return MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, args
);
1233 /*********************************************************************
1234 * _vswprintf_s_l (MSVCRT.@)
1236 int CDECL
MSVCRT_vswprintf_s_l(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
1237 const MSVCRT_wchar_t
* format
, MSVCRT__locale_t locale
, __ms_va_list args
)
1239 return MSVCRT_vsnwprintf_s_l(str
, numberOfElements
, INT_MAX
,
1240 format
, locale
, args
);
1243 /*********************************************************************
1244 * _vsprintf_p_l (MSVCRT.@)
1246 int CDECL
MSVCRT_vsprintf_p_l(char *buffer
, MSVCRT_size_t length
, const char *format
,
1247 MSVCRT__locale_t locale
, __ms_va_list args
)
1249 static const char nullbyte
= '\0';
1250 printf_arg args_ctx
[MSVCRT__ARGMAX
+1];
1251 struct _str_ctx_a puts_ctx
= {length
, buffer
};
1254 memset(args_ctx
, 0, sizeof(args_ctx
));
1256 ret
= create_positional_ctx_a(args_ctx
, format
, args
);
1258 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
1259 *MSVCRT__errno() = MSVCRT_EINVAL
;
1262 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
, FALSE
, TRUE
,
1263 arg_clbk_valist
, NULL
, &args
);
1265 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
, TRUE
, TRUE
,
1266 arg_clbk_positional
, args_ctx
, NULL
);
1268 puts_clbk_str_a(&puts_ctx
, 1, &nullbyte
);
1272 /*********************************************************************
1273 * _vsprintf_p (MSVCRT.@)
1275 int CDECL
MSVCRT_vsprintf_p(char *buffer
, MSVCRT_size_t length
,
1276 const char *format
, __ms_va_list args
)
1278 return MSVCRT_vsprintf_p_l(buffer
, length
, format
, NULL
, args
);
1281 /*********************************************************************
1282 * _sprintf_p_l (MSVCRT.@)
1284 int CDECL
MSVCRT_sprintf_p_l(char *buffer
, MSVCRT_size_t length
,
1285 const char *format
, MSVCRT__locale_t locale
, ...)
1287 __ms_va_list valist
;
1290 __ms_va_start(valist
, locale
);
1291 r
= MSVCRT_vsprintf_p_l(buffer
, length
, format
, locale
, valist
);
1292 __ms_va_end(valist
);
1297 /*********************************************************************
1298 * __swprintf_l (MSVCRT.@)
1300 int CDECL
MSVCRT___swprintf_l( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*format
,
1301 MSVCRT__locale_t locale
, ...)
1304 __ms_va_list valist
;
1305 __ms_va_start(valist
, locale
);
1306 retval
= MSVCRT_vswprintf_l(str
, format
, locale
, valist
);
1307 __ms_va_end(valist
);
1311 /*********************************************************************
1312 * _sprintf_p (MSVCR100.@)
1314 int CDECL
MSVCRT__sprintf_p(char *buffer
, MSVCRT_size_t length
, const char *format
, ...)
1316 __ms_va_list valist
;
1319 __ms_va_start(valist
, format
);
1320 r
= MSVCRT_vsprintf_p_l(buffer
, length
, format
, NULL
, valist
);
1321 __ms_va_end(valist
);
1326 /*********************************************************************
1327 * _swprintf_p_l (MSVCRT.@)
1329 int CDECL
MSVCRT_swprintf_p_l(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
1330 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, ...)
1332 __ms_va_list valist
;
1335 __ms_va_start(valist
, locale
);
1336 r
= MSVCRT_vswprintf_p_l(buffer
, length
, format
, locale
, valist
);
1337 __ms_va_end(valist
);
1342 /*********************************************************************
1343 * _wcscoll_l (MSVCRT.@)
1345 int CDECL
MSVCRT__wcscoll_l(const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
, MSVCRT__locale_t locale
)
1347 MSVCRT_pthreadlocinfo locinfo
;
1350 locinfo
= get_locinfo();
1352 locinfo
= locale
->locinfo
;
1354 if(!locinfo
->lc_handle
[MSVCRT_LC_COLLATE
])
1355 return strcmpW(str1
, str2
);
1356 return CompareStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
], 0, str1
, -1, str2
, -1)-CSTR_EQUAL
;
1359 /*********************************************************************
1360 * wcscoll (MSVCRT.@)
1362 int CDECL
MSVCRT_wcscoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
)
1364 return MSVCRT__wcscoll_l(str1
, str2
, NULL
);
1367 /*********************************************************************
1368 * wcspbrk (MSVCRT.@)
1370 MSVCRT_wchar_t
* CDECL
MSVCRT_wcspbrk( const MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* accept
)
1372 const MSVCRT_wchar_t
* p
;
1376 for (p
= accept
; *p
; p
++) if (*p
== *str
) return (MSVCRT_wchar_t
*)str
;
1382 /*********************************************************************
1383 * wcstok_s (MSVCRT.@)
1385 MSVCRT_wchar_t
* CDECL
MSVCRT_wcstok_s( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
,
1386 MSVCRT_wchar_t
**next_token
)
1388 MSVCRT_wchar_t
*ret
;
1390 if (!MSVCRT_CHECK_PMT(delim
!= NULL
)) return NULL
;
1391 if (!MSVCRT_CHECK_PMT(next_token
!= NULL
)) return NULL
;
1392 if (!MSVCRT_CHECK_PMT(str
!= NULL
|| *next_token
!= NULL
)) return NULL
;
1394 if (!str
) str
= *next_token
;
1396 while (*str
&& strchrW( delim
, *str
)) str
++;
1397 if (!*str
) return NULL
;
1399 while (*str
&& !strchrW( delim
, *str
)) str
++;
1400 if (*str
) *str
++ = 0;
1405 /*********************************************************************
1408 MSVCRT_wchar_t
* CDECL
MSVCRT_wcstok( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
)
1410 return MSVCRT_wcstok_s(str
, delim
, &msvcrt_get_thread_data()->wcstok_next
);
1413 /*********************************************************************
1414 * _wctomb_s_l (MSVCRT.@)
1416 int CDECL
MSVCRT__wctomb_s_l(int *len
, char *mbchar
, MSVCRT_size_t size
,
1417 MSVCRT_wchar_t wch
, MSVCRT__locale_t locale
)
1419 MSVCRT_pthreadlocinfo locinfo
;
1423 if(!mbchar
&& size
>0) {
1432 if(!MSVCRT_CHECK_PMT(size
<= INT_MAX
))
1433 return MSVCRT_EINVAL
;
1436 locinfo
= get_locinfo();
1438 locinfo
= locale
->locinfo
;
1440 if(!locinfo
->lc_codepage
) {
1442 if(mbchar
&& size
>0)
1443 memset(mbchar
, 0, size
);
1444 *MSVCRT__errno() = MSVCRT_EILSEQ
;
1445 return MSVCRT_EILSEQ
;
1448 if(!MSVCRT_CHECK_PMT_ERR(size
>= 1, MSVCRT_ERANGE
))
1449 return MSVCRT_ERANGE
;
1457 mblen
= WideCharToMultiByte(locinfo
->lc_codepage
, 0, &wch
, 1, mbchar
, size
, NULL
, &error
);
1458 if(!mblen
|| error
) {
1459 if(!mblen
&& GetLastError()==ERROR_INSUFFICIENT_BUFFER
) {
1460 if(mbchar
&& size
>0)
1461 memset(mbchar
, 0, size
);
1463 MSVCRT_INVALID_PMT("insufficient buffer size", MSVCRT_ERANGE
);
1464 return MSVCRT_ERANGE
;
1467 *MSVCRT__errno() = MSVCRT_EILSEQ
;
1468 return MSVCRT_EILSEQ
;
1476 /*********************************************************************
1477 * wctomb_s (MSVCRT.@)
1479 int CDECL
MSVCRT_wctomb_s(int *len
, char *mbchar
, MSVCRT_size_t size
, MSVCRT_wchar_t wch
)
1481 return MSVCRT__wctomb_s_l(len
, mbchar
, size
, wch
, NULL
);
1484 /*********************************************************************
1485 * _wctomb_l (MSVCRT.@)
1487 int CDECL
MSVCRT__wctomb_l(char *dst
, MSVCRT_wchar_t ch
, MSVCRT__locale_t locale
)
1491 MSVCRT__wctomb_s_l(&len
, dst
, dst
? MSVCRT_MB_LEN_MAX
: 0, ch
, locale
);
1495 /*********************************************************************
1498 INT CDECL
MSVCRT_wctomb( char *dst
, MSVCRT_wchar_t ch
)
1500 return MSVCRT__wctomb_l(dst
, ch
, NULL
);
1503 /*********************************************************************
1506 INT CDECL
MSVCRT_wctob( MSVCRT_wint_t wchar
)
1510 UINT codepage
= get_locinfo()->lc_codepage
;
1514 return (signed char)wchar
;
1517 } else if(WideCharToMultiByte( codepage
, 0, &wchar
, 1, &out
, 1, NULL
, &error
) && !error
)
1522 /*********************************************************************
1523 * wcrtomb (MSVCRT.@)
1525 MSVCRT_size_t CDECL
MSVCRT_wcrtomb( char *dst
, MSVCRT_wchar_t ch
, MSVCRT_mbstate_t
*s
)
1529 return MSVCRT_wctomb(dst
, ch
);
1532 /*********************************************************************
1533 * iswalnum (MSVCRT.@)
1535 INT CDECL
MSVCRT_iswalnum( MSVCRT_wchar_t wc
)
1537 return isalnumW( wc
);
1540 /*********************************************************************
1541 * iswalpha (MSVCRT.@)
1543 INT CDECL
MSVCRT_iswalpha( MSVCRT_wchar_t wc
)
1545 return isalphaW( wc
);
1548 /*********************************************************************
1549 * iswalpha_l (MSVCRT.@)
1551 INT CDECL
MSVCRT__iswalpha_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1553 return isalphaW( wc
);
1556 /*********************************************************************
1557 * iswcntrl (MSVCRT.@)
1559 INT CDECL
MSVCRT_iswcntrl( MSVCRT_wchar_t wc
)
1561 return iscntrlW( wc
);
1564 /*********************************************************************
1565 * iswdigit (MSVCRT.@)
1567 INT CDECL
MSVCRT_iswdigit( MSVCRT_wchar_t wc
)
1569 return isdigitW( wc
);
1572 /*********************************************************************
1573 * _iswdigit_l (MSVCRT.@)
1575 INT CDECL
MSVCRT__iswdigit_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1577 return isdigitW( wc
);
1580 /*********************************************************************
1581 * iswgraph (MSVCRT.@)
1583 INT CDECL
MSVCRT_iswgraph( MSVCRT_wchar_t wc
)
1585 return isgraphW( wc
);
1588 /*********************************************************************
1589 * iswlower (MSVCRT.@)
1591 INT CDECL
MSVCRT_iswlower( MSVCRT_wchar_t wc
)
1593 return islowerW( wc
);
1596 /*********************************************************************
1597 * iswprint (MSVCRT.@)
1599 INT CDECL
MSVCRT_iswprint( MSVCRT_wchar_t wc
)
1601 return isprintW( wc
);
1604 /*********************************************************************
1605 * _iswpunct_l (MSVCRT.@)
1607 INT CDECL
MSVCRT__iswpunct_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1609 return ispunctW( wc
);
1612 /*********************************************************************
1613 * iswpunct (MSVCRT.@)
1615 INT CDECL
MSVCRT_iswpunct( MSVCRT_wchar_t wc
)
1617 return ispunctW( wc
);
1620 /*********************************************************************
1621 * _iswspace_l (MSVCRT.@)
1623 INT CDECL
MSVCRT__iswspace_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1625 return isspaceW( wc
);
1628 /*********************************************************************
1629 * iswspace (MSVCRT.@)
1631 INT CDECL
MSVCRT_iswspace( MSVCRT_wchar_t wc
)
1633 return isspaceW( wc
);
1636 /*********************************************************************
1637 * iswupper (MSVCRT.@)
1639 INT CDECL
MSVCRT_iswupper( MSVCRT_wchar_t wc
)
1641 return isupperW( wc
);
1644 /*********************************************************************
1645 * iswxdigit (MSVCRT.@)
1647 INT CDECL
MSVCRT_iswxdigit( MSVCRT_wchar_t wc
)
1649 return isxdigitW( wc
);
1652 /*********************************************************************
1653 * wcscpy_s (MSVCRT.@)
1655 INT CDECL
MSVCRT_wcscpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
)
1657 MSVCRT_size_t size
= 0;
1659 if(!MSVCRT_CHECK_PMT(wcDest
)) return MSVCRT_EINVAL
;
1660 if(!MSVCRT_CHECK_PMT(numElement
)) return MSVCRT_EINVAL
;
1664 if(!MSVCRT_CHECK_PMT(wcSrc
)) return MSVCRT_EINVAL
;
1666 size
= strlenW(wcSrc
) + 1;
1668 if(!MSVCRT_CHECK_PMT_ERR(size
<= numElement
, MSVCRT_ERANGE
))
1669 return MSVCRT_ERANGE
;
1671 memcpy( wcDest
, wcSrc
, size
*sizeof(WCHAR
) );
1676 /******************************************************************
1677 * wcsncpy (MSVCRT.@)
1679 MSVCRT_wchar_t
* __cdecl
MSVCRT_wcsncpy( MSVCRT_wchar_t
* s1
,
1680 const MSVCRT_wchar_t
*s2
, MSVCRT_size_t n
)
1685 if(!(s1
[i
] = s2
[i
])) break;
1691 /******************************************************************
1692 * wcsncpy_s (MSVCRT.@)
1694 INT CDECL
MSVCRT_wcsncpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
,
1695 MSVCRT_size_t count
)
1698 BOOL truncate
= (count
== MSVCRT__TRUNCATE
);
1700 if(!wcDest
&& !numElement
&& !count
)
1703 if (!wcDest
|| !numElement
)
1704 return MSVCRT_EINVAL
;
1709 return count
? MSVCRT_EINVAL
: 0;
1712 while (numElement
&& count
&& *wcSrc
)
1718 if (!numElement
&& truncate
)
1721 return MSVCRT_STRUNCATE
;
1723 else if (!numElement
)
1726 return MSVCRT_ERANGE
;
1733 /******************************************************************
1734 * wcscat_s (MSVCRT.@)
1737 INT CDECL
MSVCRT_wcscat_s(MSVCRT_wchar_t
* dst
, MSVCRT_size_t elem
, const MSVCRT_wchar_t
* src
)
1739 MSVCRT_wchar_t
* ptr
= dst
;
1741 if (!dst
|| elem
== 0) return MSVCRT_EINVAL
;
1745 return MSVCRT_EINVAL
;
1748 /* seek to end of dst string (or elem if no end of string is found */
1749 while (ptr
< dst
+ elem
&& *ptr
!= '\0') ptr
++;
1750 while (ptr
< dst
+ elem
)
1752 if ((*ptr
++ = *src
++) == '\0') return 0;
1754 /* not enough space */
1756 return MSVCRT_ERANGE
;
1759 /*********************************************************************
1760 * wcsncat_s (MSVCRT.@)
1763 INT CDECL
MSVCRT_wcsncat_s(MSVCRT_wchar_t
*dst
, MSVCRT_size_t elem
,
1764 const MSVCRT_wchar_t
*src
, MSVCRT_size_t count
)
1766 MSVCRT_size_t srclen
;
1767 MSVCRT_wchar_t dststart
;
1770 if (!MSVCRT_CHECK_PMT(dst
!= NULL
)) return MSVCRT_EINVAL
;
1771 if (!MSVCRT_CHECK_PMT(elem
> 0)) return MSVCRT_EINVAL
;
1772 if (!MSVCRT_CHECK_PMT(src
!= NULL
|| count
== 0)) return MSVCRT_EINVAL
;
1777 for (dststart
= 0; dststart
< elem
; dststart
++)
1779 if (dst
[dststart
] == '\0')
1782 if (dststart
== elem
)
1784 MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n", MSVCRT_EINVAL
);
1785 return MSVCRT_EINVAL
;
1788 if (count
== MSVCRT__TRUNCATE
)
1790 srclen
= strlenW(src
);
1791 if (srclen
>= (elem
- dststart
))
1793 srclen
= elem
- dststart
- 1;
1794 ret
= MSVCRT_STRUNCATE
;
1798 srclen
= min(strlenW(src
), count
);
1799 if (srclen
< (elem
- dststart
))
1801 memcpy(&dst
[dststart
], src
, srclen
*sizeof(MSVCRT_wchar_t
));
1802 dst
[dststart
+srclen
] = '\0';
1805 MSVCRT_INVALID_PMT("dst[elem] is too small", MSVCRT_ERANGE
);
1807 return MSVCRT_ERANGE
;
1810 /*********************************************************************
1811 * _wcstoi64_l (MSVCRT.@)
1813 * FIXME: locale parameter is ignored
1815 __int64 CDECL
MSVCRT__wcstoi64_l(const MSVCRT_wchar_t
*nptr
,
1816 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
1818 BOOL negative
= FALSE
;
1821 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
1823 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
)) return 0;
1824 if (!MSVCRT_CHECK_PMT(base
== 0 || base
>= 2)) return 0;
1825 if (!MSVCRT_CHECK_PMT(base
<= 36)) return 0;
1827 while(isspaceW(*nptr
)) nptr
++;
1832 } else if(*nptr
== '+')
1835 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
1848 MSVCRT_wchar_t cur
= tolowerW(*nptr
);
1856 if(cur
<'a' || cur
>='a'+base
-10)
1866 if(!negative
&& (ret
>MSVCRT_I64_MAX
/base
|| ret
*base
>MSVCRT_I64_MAX
-v
)) {
1867 ret
= MSVCRT_I64_MAX
;
1868 *MSVCRT__errno() = MSVCRT_ERANGE
;
1869 } else if(negative
&& (ret
<MSVCRT_I64_MIN
/base
|| ret
*base
<MSVCRT_I64_MIN
-v
)) {
1870 ret
= MSVCRT_I64_MIN
;
1871 *MSVCRT__errno() = MSVCRT_ERANGE
;
1877 *endptr
= (MSVCRT_wchar_t
*)nptr
;
1882 /*********************************************************************
1883 * _wcstoi64 (MSVCRT.@)
1885 __int64 CDECL
MSVCRT__wcstoi64(const MSVCRT_wchar_t
*nptr
,
1886 MSVCRT_wchar_t
**endptr
, int base
)
1888 return MSVCRT__wcstoi64_l(nptr
, endptr
, base
, NULL
);
1891 /*********************************************************************
1892 * _wcstol_l (MSVCRT.@)
1894 MSVCRT_long CDECL
MSVCRT__wcstol_l(const MSVCRT_wchar_t
*s
,
1895 MSVCRT_wchar_t
**end
, int base
, MSVCRT__locale_t locale
)
1897 __int64 ret
= MSVCRT__wcstoi64_l(s
, end
, base
, locale
);
1899 if(ret
> MSVCRT_LONG_MAX
) {
1900 ret
= MSVCRT_LONG_MAX
;
1901 *MSVCRT__errno() = MSVCRT_ERANGE
;
1902 }else if(ret
< MSVCRT_LONG_MIN
) {
1903 ret
= MSVCRT_LONG_MIN
;
1904 *MSVCRT__errno() = MSVCRT_ERANGE
;
1909 /*********************************************************************
1910 * _wtoi_l (MSVCRT.@)
1912 int __cdecl
MSVCRT__wtoi_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
1914 __int64 ret
= MSVCRT__wcstoi64_l(str
, NULL
, 10, locale
);
1918 *MSVCRT__errno() = MSVCRT_ERANGE
;
1919 } else if(ret
< INT_MIN
) {
1921 *MSVCRT__errno() = MSVCRT_ERANGE
;
1926 /*********************************************************************
1929 int __cdecl
MSVCRT__wtoi(const MSVCRT_wchar_t
*str
)
1931 return MSVCRT__wtoi_l(str
, NULL
);
1934 /*********************************************************************
1935 * _wtol_l (MSVCRT.@)
1937 MSVCRT_long __cdecl
MSVCRT__wtol_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
1939 __int64 ret
= MSVCRT__wcstoi64_l(str
, NULL
, 10, locale
);
1941 if(ret
> MSVCRT_LONG_MAX
) {
1942 ret
= MSVCRT_LONG_MAX
;
1943 *MSVCRT__errno() = MSVCRT_ERANGE
;
1944 } else if(ret
< MSVCRT_LONG_MIN
) {
1945 ret
= MSVCRT_LONG_MIN
;
1946 *MSVCRT__errno() = MSVCRT_ERANGE
;
1951 /*********************************************************************
1954 MSVCRT_long __cdecl
MSVCRT__wtol(const MSVCRT_wchar_t
*str
)
1956 return MSVCRT__wtol_l(str
, NULL
);
1959 /*********************************************************************
1960 * _wcstoui64_l (MSVCRT.@)
1962 * FIXME: locale parameter is ignored
1964 unsigned __int64 CDECL
MSVCRT__wcstoui64_l(const MSVCRT_wchar_t
*nptr
,
1965 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
1967 BOOL negative
= FALSE
;
1968 unsigned __int64 ret
= 0;
1970 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
1972 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
)) return 0;
1973 if (!MSVCRT_CHECK_PMT(base
== 0 || base
>= 2)) return 0;
1974 if (!MSVCRT_CHECK_PMT(base
<= 36)) return 0;
1976 while(isspaceW(*nptr
)) nptr
++;
1981 } else if(*nptr
== '+')
1984 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
1997 MSVCRT_wchar_t cur
= tolowerW(*nptr
);
2005 if(cur
<'a' || cur
>='a'+base
-10)
2012 if(ret
>MSVCRT_UI64_MAX
/base
|| ret
*base
>MSVCRT_UI64_MAX
-v
) {
2013 ret
= MSVCRT_UI64_MAX
;
2014 *MSVCRT__errno() = MSVCRT_ERANGE
;
2020 *endptr
= (MSVCRT_wchar_t
*)nptr
;
2022 return negative
? -ret
: ret
;
2025 /*********************************************************************
2026 * _wcstoui64 (MSVCRT.@)
2028 unsigned __int64 CDECL
MSVCRT__wcstoui64(const MSVCRT_wchar_t
*nptr
,
2029 MSVCRT_wchar_t
**endptr
, int base
)
2031 return MSVCRT__wcstoui64_l(nptr
, endptr
, base
, NULL
);
2034 /*********************************************************************
2035 * _wcstoul_l (MSVCRT.@)
2037 MSVCRT_ulong __cdecl
MSVCRT__wcstoul_l(const MSVCRT_wchar_t
*s
,
2038 MSVCRT_wchar_t
**end
, int base
, MSVCRT__locale_t locale
)
2040 __int64 ret
= MSVCRT__wcstoui64_l(s
, end
, base
, locale
);
2042 if(ret
> MSVCRT_ULONG_MAX
) {
2043 ret
= MSVCRT_ULONG_MAX
;
2044 *MSVCRT__errno() = MSVCRT_ERANGE
;
2049 /*********************************************************************
2050 * wcstoul (MSVCRT.@)
2052 MSVCRT_ulong __cdecl
MSVCRT_wcstoul(const MSVCRT_wchar_t
*s
, MSVCRT_wchar_t
**end
, int base
)
2054 return MSVCRT__wcstoul_l(s
, end
, base
, NULL
);
2057 /******************************************************************
2058 * wcsnlen (MSVCRT.@)
2060 MSVCRT_size_t CDECL
MSVCRT_wcsnlen(const MSVCRT_wchar_t
*s
, MSVCRT_size_t maxlen
)
2064 for (i
= 0; i
< maxlen
; i
++)
2069 /*********************************************************************
2070 * _towupper_l (MSVCRT.@)
2072 int CDECL
MSVCRT__towupper_l(MSVCRT_wint_t c
, MSVCRT__locale_t locale
)
2077 /*********************************************************************
2078 * towupper (MSVCRT.@)
2080 int CDECL
MSVCRT_towupper(MSVCRT_wint_t c
)
2082 return MSVCRT__towupper_l(c
, NULL
);
2085 /*********************************************************************
2086 * _towlower_l (MSVCRT.@)
2088 int CDECL
MSVCRT__towlower_l(MSVCRT_wint_t c
, MSVCRT__locale_t locale
)
2093 /*********************************************************************
2094 * towlower (MSVCRT.@)
2096 int CDECL
MSVCRT_towlower(MSVCRT_wint_t c
)
2098 return MSVCRT__towlower_l(c
, NULL
);
2101 /*********************************************************************
2104 MSVCRT_wchar_t
* CDECL
MSVCRT_wcschr(const MSVCRT_wchar_t
*str
, MSVCRT_wchar_t ch
)
2106 return strchrW(str
, ch
);
2109 /***********************************************************************
2112 int CDECL
MSVCRT_wcslen(const MSVCRT_wchar_t
*str
)
2114 return strlenW(str
);
2117 /*********************************************************************
2120 MSVCRT_wchar_t
* CDECL
MSVCRT_wcsstr(const MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*sub
)
2122 return strstrW(str
, sub
);
2125 /*********************************************************************
2126 * _wtoi64_l (MSVCRT.@)
2128 __int64 CDECL
MSVCRT__wtoi64_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
2130 ULONGLONG RunningTotal
= 0;
2131 BOOL bMinus
= FALSE
;
2133 while (isspaceW(*str
)) {
2139 } else if (*str
== '-') {
2144 while (*str
>= '0' && *str
<= '9') {
2145 RunningTotal
= RunningTotal
* 10 + *str
- '0';
2149 return bMinus
? -RunningTotal
: RunningTotal
;
2152 /*********************************************************************
2153 * _wtoi64 (MSVCRT.@)
2155 __int64 CDECL
MSVCRT__wtoi64(const MSVCRT_wchar_t
*str
)
2157 return MSVCRT__wtoi64_l(str
, NULL
);
2160 /*********************************************************************
2161 * wcsncmp (MSVCRT.@)
2163 int CDECL
MSVCRT_wcsncmp(const MSVCRT_wchar_t
*str1
, const MSVCRT_wchar_t
*str2
, int n
)
2165 return strncmpW(str1
, str2
, n
);
2168 /*********************************************************************
2169 * _wcsxfrm_l (MSVCRT.@)
2171 MSVCRT_size_t CDECL
MSVCRT__wcsxfrm_l(MSVCRT_wchar_t
*dest
, const MSVCRT_wchar_t
*src
,
2172 MSVCRT_size_t len
, MSVCRT__locale_t locale
)
2174 MSVCRT_pthreadlocinfo locinfo
;
2177 if(!MSVCRT_CHECK_PMT(src
)) return INT_MAX
;
2178 if(!MSVCRT_CHECK_PMT(dest
|| !len
)) return INT_MAX
;
2181 FIXME("len > INT_MAX not supported\n");
2186 locinfo
= get_locinfo();
2188 locinfo
= locale
->locinfo
;
2190 if(!locinfo
->lc_handle
[MSVCRT_LC_COLLATE
]) {
2191 MSVCRT_wcsncpy(dest
, src
, len
);
2192 return strlenW(src
);
2195 ret
= LCMapStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
],
2196 LCMAP_SORTKEY
, src
, -1, NULL
, 0);
2198 if(len
) dest
[0] = 0;
2199 *MSVCRT__errno() = MSVCRT_EILSEQ
;
2202 if(!len
) return ret
-1;
2206 *MSVCRT__errno() = MSVCRT_ERANGE
;
2210 ret
= LCMapStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
],
2211 LCMAP_SORTKEY
, src
, -1, dest
, len
) - 1;
2212 for(i
=ret
; i
>=0; i
--)
2213 dest
[i
] = ((unsigned char*)dest
)[i
];
2217 /*********************************************************************
2218 * wcsxfrm (MSVCRT.@)
2220 MSVCRT_size_t CDECL
MSVCRT_wcsxfrm(MSVCRT_wchar_t
*dest
,
2221 const MSVCRT_wchar_t
*src
, MSVCRT_size_t len
)
2223 return MSVCRT__wcsxfrm_l(dest
, src
, len
, NULL
);