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(*p
>='0' && *p
<='9') {
379 hlp
= d
*10+*(p
++)-'0';
380 if(d
>MSVCRT_UI64_MAX
/10 || hlp
<d
) {
386 while(*p
>='0' && *p
<='9') {
390 if(*p
== *locinfo
->lconv
->decimal_point
)
393 while(*p
>='0' && *p
<='9') {
395 hlp
= d
*10+*(p
++)-'0';
396 if(d
>MSVCRT_UI64_MAX
/10 || hlp
<d
)
402 while(*p
>='0' && *p
<='9')
407 *end
= (MSVCRT_wchar_t
*)str
;
411 if(*p
=='e' || *p
=='E' || *p
=='d' || *p
=='D') {
421 if(*p
>='0' && *p
<='9') {
422 while(*p
>='0' && *p
<='9') {
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
;
480 if(!locinfo
->lc_codepage
) {
484 return strlenW(*wcstr
);
486 for(i
=0; i
<count
; i
++) {
487 if((*wcstr
)[i
] > 255) {
488 *MSVCRT__errno() = MSVCRT_EILSEQ
;
492 mbstr
[i
] = (*wcstr
)[i
];
493 if(!(*wcstr
)[i
]) break;
499 tmp
= WideCharToMultiByte(locinfo
->lc_codepage
, WC_NO_BEST_FIT_CHARS
,
500 *wcstr
, -1, NULL
, 0, NULL
, &used_default
)-1;
501 if(!tmp
|| used_default
) {
502 *MSVCRT__errno() = MSVCRT_EILSEQ
;
510 MSVCRT_size_t i
, size
;
512 size
= WideCharToMultiByte(locinfo
->lc_codepage
, WC_NO_BEST_FIT_CHARS
,
513 *wcstr
, 1, buf
, 3, NULL
, &used_default
);
514 if(!size
|| used_default
) {
515 *MSVCRT__errno() = MSVCRT_EILSEQ
;
521 for(i
=0; i
<size
; i
++)
522 mbstr
[tmp
++] = buf
[i
];
533 /*********************************************************************
534 * _wcstombs_l (MSVCRT.@)
536 MSVCRT_size_t CDECL
MSVCRT__wcstombs_l(char *mbstr
, const MSVCRT_wchar_t
*wcstr
,
537 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
539 return MSVCRT_wcsrtombs_l(mbstr
, &wcstr
, count
, locale
);
542 /*********************************************************************
543 * wcstombs (MSVCRT.@)
545 MSVCRT_size_t CDECL
MSVCRT_wcstombs(char *mbstr
, const MSVCRT_wchar_t
*wcstr
,
548 return MSVCRT_wcsrtombs_l(mbstr
, &wcstr
, count
, NULL
);
551 /*********************************************************************
552 * wcsrtombs (MSVCRT.@)
554 MSVCRT_size_t CDECL
MSVCRT_wcsrtombs(char *mbstr
, const MSVCRT_wchar_t
**wcstr
,
555 MSVCRT_size_t count
, MSVCRT_mbstate_t
*mbstate
)
560 return MSVCRT_wcsrtombs_l(mbstr
, wcstr
, count
, NULL
);
563 /*********************************************************************
564 * MSVCRT_wcsrtombs_s_l (INTERNAL)
566 static int MSVCRT_wcsrtombs_s_l(MSVCRT_size_t
*ret
, char *mbstr
,
567 MSVCRT_size_t size
, const MSVCRT_wchar_t
**wcstr
,
568 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
572 if(!mbstr
&& !size
&& wcstr
) {
573 conv
= MSVCRT_wcsrtombs_l(NULL
, wcstr
, 0, locale
);
575 return *MSVCRT__errno();
581 if (!MSVCRT_CHECK_PMT(mbstr
!= NULL
)) return MSVCRT_EINVAL
;
582 if (size
) mbstr
[0] = '\0';
583 if (!MSVCRT_CHECK_PMT(wcstr
!= NULL
)) return MSVCRT_EINVAL
;
584 if (!MSVCRT_CHECK_PMT(*wcstr
!= NULL
)) return MSVCRT_EINVAL
;
586 if(count
==MSVCRT__TRUNCATE
|| size
<count
)
591 conv
= MSVCRT_wcsrtombs_l(mbstr
, wcstr
, conv
, locale
);
595 return *MSVCRT__errno();
596 }else if(conv
< size
)
597 mbstr
[conv
++] = '\0';
598 else if(conv
==size
&& (count
==MSVCRT__TRUNCATE
|| mbstr
[conv
-1]=='\0'))
599 mbstr
[conv
-1] = '\0';
601 MSVCRT_INVALID_PMT("mbstr[size] is too small", MSVCRT_ERANGE
);
604 return MSVCRT_ERANGE
;
612 /*********************************************************************
613 * _wcstombs_s_l (MSVCRT.@)
615 int CDECL
MSVCRT__wcstombs_s_l(MSVCRT_size_t
*ret
, char *mbstr
,
616 MSVCRT_size_t size
, const MSVCRT_wchar_t
*wcstr
,
617 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
619 return MSVCRT_wcsrtombs_s_l(ret
, mbstr
, size
, &wcstr
,count
, locale
);
622 /*********************************************************************
623 * wcstombs_s (MSVCRT.@)
625 int CDECL
MSVCRT_wcstombs_s(MSVCRT_size_t
*ret
, char *mbstr
,
626 MSVCRT_size_t size
, const MSVCRT_wchar_t
*wcstr
, MSVCRT_size_t count
)
628 return MSVCRT_wcsrtombs_s_l(ret
, mbstr
, size
, &wcstr
, count
, NULL
);
631 /*********************************************************************
632 * wcsrtombs_s (MSVCRT.@)
634 int CDECL
MSVCRT_wcsrtombs_s(MSVCRT_size_t
*ret
, char *mbstr
, MSVCRT_size_t size
,
635 const MSVCRT_wchar_t
**wcstr
, MSVCRT_size_t count
, MSVCRT_mbstate_t
*mbstate
)
640 return MSVCRT_wcsrtombs_s_l(ret
, mbstr
, size
, wcstr
, count
, NULL
);
643 /*********************************************************************
646 double CDECL
MSVCRT_wcstod(const MSVCRT_wchar_t
* lpszStr
, MSVCRT_wchar_t
** end
)
648 return MSVCRT__wcstod_l(lpszStr
, end
, NULL
);
651 /*********************************************************************
654 double CDECL
MSVCRT__wtof(const MSVCRT_wchar_t
*str
)
656 return MSVCRT__wcstod_l(str
, NULL
, NULL
);
659 /*********************************************************************
662 double CDECL
MSVCRT__wtof_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
664 return MSVCRT__wcstod_l(str
, NULL
, locale
);
667 /*********************************************************************
668 * _wcstof_l (MSVCR120.@)
670 float CDECL
MSVCRT__wcstof_l( const MSVCRT_wchar_t
*str
, MSVCRT_wchar_t
**end
, MSVCRT__locale_t locale
)
672 return MSVCRT__wcstod_l(str
, end
, locale
);
675 /*********************************************************************
676 * wcstof (MSVCR120.@)
678 float CDECL
MSVCRT_wcstof( const MSVCRT_wchar_t
*str
, MSVCRT_wchar_t
**end
)
680 return MSVCRT__wcstof_l(str
, end
, NULL
);
683 /*********************************************************************
684 * arg_clbk_valist (INTERNAL)
686 printf_arg
arg_clbk_valist(void *ctx
, int arg_pos
, int type
, __ms_va_list
*valist
)
691 ret
.get_longlong
= va_arg(*valist
, LONGLONG
);
692 else if(type
== VT_INT
)
693 ret
.get_int
= va_arg(*valist
, int);
694 else if(type
== VT_R8
)
695 ret
.get_double
= va_arg(*valist
, double);
696 else if(type
== VT_PTR
)
697 ret
.get_ptr
= va_arg(*valist
, void*);
699 ERR("Incorrect type\n");
706 /*********************************************************************
707 * arg_clbk_positional (INTERNAL)
709 printf_arg
arg_clbk_positional(void *ctx
, int pos
, int type
, __ms_va_list
*valist
)
711 printf_arg
*args
= ctx
;
715 /*********************************************************************
716 * _vsnprintf (MSVCRT.@)
718 int CDECL
MSVCRT_vsnprintf( char *str
, MSVCRT_size_t len
,
719 const char *format
, __ms_va_list valist
)
721 static const char nullbyte
= '\0';
722 struct _str_ctx_a ctx
= {len
, str
};
725 ret
= pf_printf_a(puts_clbk_str_a
, &ctx
, format
, NULL
, 0,
726 arg_clbk_valist
, NULL
, &valist
);
727 puts_clbk_str_a(&ctx
, 1, &nullbyte
);
731 static int puts_clbk_str_c99_a(void *ctx
, int len
, const char *str
)
733 struct _str_ctx_a
*out
= ctx
;
739 memcpy(out
->buf
, str
, out
->len
);
740 out
->buf
+= out
->len
;
745 memcpy(out
->buf
, str
, len
);
751 /*********************************************************************
752 * __stdio_common_vsprintf (UCRTBASE.@)
754 int CDECL
MSVCRT__stdio_common_vsprintf( unsigned __int64 options
, char *str
, MSVCRT_size_t len
, const char *format
,
755 MSVCRT__locale_t locale
, __ms_va_list valist
)
757 static const char nullbyte
= '\0';
758 struct _str_ctx_a ctx
= {len
, str
};
761 if (options
& ~UCRTBASE_PRINTF_MASK
)
762 FIXME("options %s not handled\n", wine_dbgstr_longlong(options
));
763 ret
= pf_printf_a(puts_clbk_str_c99_a
,
764 &ctx
, format
, locale
, options
& UCRTBASE_PRINTF_MASK
, arg_clbk_valist
, NULL
, &valist
);
765 puts_clbk_str_a(&ctx
, 1, &nullbyte
);
767 if(options
& UCRTBASE_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION
)
768 return ret
>len
? -1 : ret
;
770 if(len
) str
[len
-1] = 0;
771 return (options
& UCRTBASE_PRINTF_STANDARD_SNPRINTF_BEHAVIOUR
) ? ret
: -2;
776 /*********************************************************************
777 * _vsnprintf_l (MSVCRT.@)
779 int CDECL
MSVCRT_vsnprintf_l( char *str
, MSVCRT_size_t len
, const char *format
,
780 MSVCRT__locale_t locale
, __ms_va_list valist
)
782 static const char nullbyte
= '\0';
783 struct _str_ctx_a ctx
= {len
, str
};
786 ret
= pf_printf_a(puts_clbk_str_a
, &ctx
, format
, locale
, 0,
787 arg_clbk_valist
, NULL
, &valist
);
788 puts_clbk_str_a(&ctx
, 1, &nullbyte
);
792 /*********************************************************************
793 * _vsprintf_l (MSVCRT.@)
795 int CDECL
MSVCRT_vsprintf_l( char *str
, const char *format
,
796 MSVCRT__locale_t locale
, __ms_va_list valist
)
798 return MSVCRT_vsnprintf_l(str
, INT_MAX
, format
, locale
, valist
);
801 /*********************************************************************
802 * _sprintf_l (MSVCRT.@)
804 int CDECL
MSVCRT_sprintf_l(char *str
, const char *format
,
805 MSVCRT__locale_t locale
, ...)
809 __ms_va_start(valist
, locale
);
810 retval
= MSVCRT_vsnprintf_l(str
, INT_MAX
, format
, locale
, valist
);
815 static int CDECL
MSVCRT_vsnprintf_s_l_opt( char *str
, MSVCRT_size_t sizeOfBuffer
,
816 MSVCRT_size_t count
, const char *format
, DWORD options
,
817 MSVCRT__locale_t locale
, __ms_va_list valist
)
819 static const char nullbyte
= '\0';
820 struct _str_ctx_a ctx
;
823 if(sizeOfBuffer
<count
+1 || count
==-1)
830 ret
= pf_printf_a(puts_clbk_str_a
, &ctx
, format
, locale
, MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER
| options
,
831 arg_clbk_valist
, NULL
, &valist
);
832 puts_clbk_str_a(&ctx
, 1, &nullbyte
);
834 if(ret
<0 || ret
==len
) {
835 if(count
!=MSVCRT__TRUNCATE
&& count
>sizeOfBuffer
) {
836 MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", MSVCRT_ERANGE
);
837 memset(str
, 0, sizeOfBuffer
);
847 static int MSVCRT_vsnwprintf_s_l_opt( MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
848 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
, DWORD options
,
849 MSVCRT__locale_t locale
, __ms_va_list valist
)
851 static const MSVCRT_wchar_t nullbyte
= '\0';
852 struct _str_ctx_w ctx
;
856 if(count
!=-1 && len
>count
+1)
861 ret
= pf_printf_w(puts_clbk_str_w
, &ctx
, format
, locale
, MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER
| options
,
862 arg_clbk_valist
, NULL
, &valist
);
863 puts_clbk_str_w(&ctx
, 1, &nullbyte
);
865 if(ret
<0 || ret
==len
) {
866 if(count
!=MSVCRT__TRUNCATE
&& count
>sizeOfBuffer
) {
867 MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small", MSVCRT_ERANGE
);
868 memset(str
, 0, sizeOfBuffer
*sizeof(MSVCRT_wchar_t
));
878 /*********************************************************************
879 * _vsnprintf_s_l (MSVCRT.@)
881 int CDECL
MSVCRT_vsnprintf_s_l( char *str
, MSVCRT_size_t sizeOfBuffer
,
882 MSVCRT_size_t count
, const char *format
,
883 MSVCRT__locale_t locale
, __ms_va_list valist
)
885 return MSVCRT_vsnprintf_s_l_opt(str
, sizeOfBuffer
, count
, format
, 0, locale
, valist
);
888 /*********************************************************************
889 * _vsprintf_s_l (MSVCRT.@)
891 int CDECL
MSVCRT_vsprintf_s_l( char *str
, MSVCRT_size_t count
, const char *format
,
892 MSVCRT__locale_t locale
, __ms_va_list valist
)
894 return MSVCRT_vsnprintf_s_l(str
, INT_MAX
, count
, format
, locale
, valist
);
897 /*********************************************************************
898 * _sprintf_s_l (MSVCRT.@)
900 int CDECL
MSVCRT_sprintf_s_l( char *str
, MSVCRT_size_t count
, const char *format
,
901 MSVCRT__locale_t locale
, ...)
905 __ms_va_start(valist
, locale
);
906 retval
= MSVCRT_vsnprintf_s_l(str
, INT_MAX
, count
, format
, locale
, valist
);
911 /*********************************************************************
912 * _vsnprintf_s (MSVCRT.@)
914 int CDECL
MSVCRT_vsnprintf_s( char *str
, MSVCRT_size_t sizeOfBuffer
,
915 MSVCRT_size_t count
, const char *format
, __ms_va_list valist
)
917 return MSVCRT_vsnprintf_s_l(str
,sizeOfBuffer
, count
, format
, NULL
, valist
);
920 /*********************************************************************
921 * __stdio_common_vsnprintf_s (UCRTBASE.@)
923 int CDECL
MSVCRT__stdio_common_vsnprintf_s( unsigned __int64 options
,
924 char *str
, MSVCRT_size_t sizeOfBuffer
, MSVCRT_size_t count
,
925 const char *format
, MSVCRT__locale_t locale
, __ms_va_list valist
)
927 if (options
& ~UCRTBASE_PRINTF_MASK
)
928 FIXME("options %s not handled\n", wine_dbgstr_longlong(options
));
929 return MSVCRT_vsnprintf_s_l_opt(str
, sizeOfBuffer
, count
, format
, options
& UCRTBASE_PRINTF_MASK
, locale
, valist
);
932 /*********************************************************************
933 * __stdio_common_vsnwprintf_s (UCRTBASE.@)
935 int CDECL
MSVCRT__stdio_common_vsnwprintf_s( unsigned __int64 options
,
936 MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
, MSVCRT_size_t count
,
937 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, __ms_va_list valist
)
939 if (options
& ~UCRTBASE_PRINTF_MASK
)
940 FIXME("options %s not handled\n", wine_dbgstr_longlong(options
));
941 return MSVCRT_vsnwprintf_s_l_opt(str
, sizeOfBuffer
, count
, format
, options
& UCRTBASE_PRINTF_MASK
, locale
, valist
);
944 /*********************************************************************
945 * __stdio_common_vswprintf_s (UCRTBASE.@)
947 int CDECL
MSVCRT__stdio_common_vswprintf_s( unsigned __int64 options
,
948 MSVCRT_wchar_t
*str
, MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
,
949 MSVCRT__locale_t locale
, __ms_va_list valist
)
951 return MSVCRT__stdio_common_vsnwprintf_s(options
, str
, INT_MAX
, count
, format
, locale
, valist
);
954 /*********************************************************************
955 * __stdio_common_vsprintf_s (UCRTBASE.@)
957 int CDECL
MSVCRT__stdio_common_vsprintf_s( unsigned __int64 options
,
958 char *str
, MSVCRT_size_t count
, const char *format
,
959 MSVCRT__locale_t locale
, __ms_va_list valist
)
961 if (options
& ~UCRTBASE_PRINTF_MASK
)
962 FIXME("options %s not handled\n", wine_dbgstr_longlong(options
));
963 return MSVCRT_vsnprintf_s_l_opt(str
, INT_MAX
, count
, format
, options
& UCRTBASE_PRINTF_MASK
, locale
, valist
);
966 /*********************************************************************
967 * vsprintf (MSVCRT.@)
969 int CDECL
MSVCRT_vsprintf( char *str
, const char *format
, __ms_va_list valist
)
971 return MSVCRT_vsnprintf(str
, INT_MAX
, format
, valist
);
974 /*********************************************************************
975 * vsprintf_s (MSVCRT.@)
977 int CDECL
MSVCRT_vsprintf_s( char *str
, MSVCRT_size_t num
, const char *format
, __ms_va_list valist
)
979 return MSVCRT_vsnprintf(str
, num
, format
, valist
);
982 /*********************************************************************
983 * _vscprintf (MSVCRT.@)
985 int CDECL
MSVCRT__vscprintf( const char *format
, __ms_va_list valist
)
987 return MSVCRT_vsnprintf( NULL
, INT_MAX
, format
, valist
);
990 /*********************************************************************
991 * _vscprintf_p_l (MSVCRT.@)
993 int CDECL
MSVCRT__vscprintf_p_l(const char *format
,
994 MSVCRT__locale_t locale
, __ms_va_list args
)
996 printf_arg args_ctx
[MSVCRT__ARGMAX
+1];
997 struct _str_ctx_a puts_ctx
= {INT_MAX
, NULL
};
1000 memset(args_ctx
, 0, sizeof(args_ctx
));
1002 ret
= create_positional_ctx_a(args_ctx
, format
, args
);
1004 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
1005 *MSVCRT__errno() = MSVCRT_EINVAL
;
1007 } else if(ret
== 0) {
1008 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
,
1009 MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER
,
1010 arg_clbk_valist
, NULL
, &args
);
1012 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
,
1013 MSVCRT_PRINTF_POSITIONAL_PARAMS
| MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER
,
1014 arg_clbk_positional
, args_ctx
, NULL
);
1020 /*********************************************************************
1021 * _vscprintf_p (MSVCR80.@)
1023 int CDECL
MSVCRT__vscprintf_p(const char *format
, __ms_va_list argptr
)
1025 return MSVCRT__vscprintf_p_l(format
, NULL
, argptr
);
1028 /*********************************************************************
1029 * _snprintf (MSVCRT.@)
1031 int CDECL
MSVCRT__snprintf(char *str
, unsigned int len
, const char *format
, ...)
1034 __ms_va_list valist
;
1035 __ms_va_start(valist
, format
);
1036 retval
= MSVCRT_vsnprintf(str
, len
, format
, valist
);
1037 __ms_va_end(valist
);
1041 /*********************************************************************
1042 * _snprintf_l (MSVCRT.@)
1044 int CDECL
MSVCRT__snprintf_l(char *str
, unsigned int count
, MSVCRT__locale_t locale
,
1045 const char *format
, ...)
1048 __ms_va_list valist
;
1049 __ms_va_start(valist
, format
);
1050 retval
= MSVCRT_vsnprintf_l(str
, count
, format
, locale
, valist
);
1051 __ms_va_end(valist
);
1055 /*********************************************************************
1056 * _snprintf_s (MSVCRT.@)
1058 int CDECL
MSVCRT__snprintf_s(char *str
, unsigned int len
, unsigned int count
,
1059 const char *format
, ...)
1062 __ms_va_list valist
;
1063 __ms_va_start(valist
, format
);
1064 retval
= MSVCRT_vsnprintf_s_l(str
, len
, count
, format
, NULL
, valist
);
1065 __ms_va_end(valist
);
1069 /*********************************************************************
1070 * _scprintf (MSVCRT.@)
1072 int CDECL
MSVCRT__scprintf(const char *format
, ...)
1075 __ms_va_list valist
;
1076 __ms_va_start(valist
, format
);
1077 retval
= MSVCRT__vscprintf(format
, valist
);
1078 __ms_va_end(valist
);
1082 /*********************************************************************
1083 * _vsnwprintf (MSVCRT.@)
1085 int CDECL
MSVCRT_vsnwprintf(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
1086 const MSVCRT_wchar_t
*format
, __ms_va_list valist
)
1088 static const MSVCRT_wchar_t nullbyte
= '\0';
1089 struct _str_ctx_w ctx
= {len
, str
};
1092 ret
= pf_printf_w(puts_clbk_str_w
, &ctx
, format
, NULL
, 0,
1093 arg_clbk_valist
, NULL
, &valist
);
1094 puts_clbk_str_w(&ctx
, 1, &nullbyte
);
1098 /*********************************************************************
1099 * _vsnwprintf_l (MSVCRT.@)
1101 int CDECL
MSVCRT_vsnwprintf_l(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
1102 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
,
1103 __ms_va_list valist
)
1105 static const MSVCRT_wchar_t nullbyte
= '\0';
1106 struct _str_ctx_w ctx
= {len
, str
};
1109 ret
= pf_printf_w(puts_clbk_str_w
, &ctx
, format
, locale
, 0,
1110 arg_clbk_valist
, NULL
, &valist
);
1111 puts_clbk_str_w(&ctx
, 1, &nullbyte
);
1115 static int MSVCRT_vswprintf_p_l_opt(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
1116 const MSVCRT_wchar_t
*format
, DWORD options
, MSVCRT__locale_t locale
, __ms_va_list args
)
1118 static const MSVCRT_wchar_t nullbyte
= '\0';
1119 printf_arg args_ctx
[MSVCRT__ARGMAX
+1];
1120 struct _str_ctx_w puts_ctx
= {length
, buffer
};
1123 memset(args_ctx
, 0, sizeof(args_ctx
));
1125 ret
= create_positional_ctx_w(args_ctx
, format
, args
);
1127 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
1128 *MSVCRT__errno() = MSVCRT_EINVAL
;
1131 ret
= pf_printf_w(puts_clbk_str_w
, &puts_ctx
, format
, locale
, MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER
| options
,
1132 arg_clbk_valist
, NULL
, &args
);
1134 ret
= pf_printf_w(puts_clbk_str_w
, &puts_ctx
, format
, locale
,
1135 MSVCRT_PRINTF_POSITIONAL_PARAMS
| MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER
| options
,
1136 arg_clbk_positional
, args_ctx
, NULL
);
1138 puts_clbk_str_w(&puts_ctx
, 1, &nullbyte
);
1142 /*********************************************************************
1143 * _vswprintf_p_l (MSVCRT.@)
1145 int CDECL
MSVCRT_vswprintf_p_l(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
1146 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, __ms_va_list args
)
1148 return MSVCRT_vswprintf_p_l_opt(buffer
, length
, format
, 0, locale
, args
);
1151 /*********************************************************************
1152 * _vswprintf_p (MSVCR100.@)
1154 int CDECL
MSVCRT__vswprintf_p(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
1155 const MSVCRT_wchar_t
*format
, __ms_va_list args
)
1157 return MSVCRT_vswprintf_p_l_opt(buffer
, length
, format
, 0, NULL
, args
);
1161 /*********************************************************************
1162 * __stdio_common_vswprintf_p (UCRTBASE.@)
1164 int CDECL
MSVCRT__stdio_common_vswprintf_p( unsigned __int64 options
,
1165 MSVCRT_wchar_t
*str
, MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
,
1166 MSVCRT__locale_t locale
, __ms_va_list valist
)
1168 if (options
& ~UCRTBASE_PRINTF_MASK
)
1169 FIXME("options %s not handled\n", wine_dbgstr_longlong(options
));
1170 return MSVCRT_vswprintf_p_l_opt(str
, count
, format
, options
& UCRTBASE_PRINTF_MASK
, locale
, valist
);
1173 /*********************************************************************
1174 * _vsnwprintf_s_l (MSVCRT.@)
1176 int CDECL
MSVCRT_vsnwprintf_s_l( MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
1177 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
,
1178 MSVCRT__locale_t locale
, __ms_va_list valist
)
1180 return MSVCRT_vsnwprintf_s_l_opt(str
, sizeOfBuffer
, count
, format
, 0, locale
, valist
);
1183 /*********************************************************************
1184 * _vsnwprintf_s (MSVCRT.@)
1186 int CDECL
MSVCRT_vsnwprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
1187 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
, __ms_va_list valist
)
1189 return MSVCRT_vsnwprintf_s_l(str
, sizeOfBuffer
, count
,
1190 format
, NULL
, valist
);
1193 /*********************************************************************
1194 * _snwprintf (MSVCRT.@)
1196 int CDECL
MSVCRT__snwprintf( MSVCRT_wchar_t
*str
, unsigned int len
, const MSVCRT_wchar_t
*format
, ...)
1199 __ms_va_list valist
;
1200 __ms_va_start(valist
, format
);
1201 retval
= MSVCRT_vsnwprintf(str
, len
, format
, valist
);
1202 __ms_va_end(valist
);
1206 /*********************************************************************
1207 * _snwprintf_l (MSVCRT.@)
1209 int CDECL
MSVCRT__snwprintf_l( MSVCRT_wchar_t
*str
, unsigned int len
, const MSVCRT_wchar_t
*format
,
1210 MSVCRT__locale_t locale
, ...)
1213 __ms_va_list valist
;
1214 __ms_va_start(valist
, locale
);
1215 retval
= MSVCRT_vsnwprintf_l(str
, len
, format
, locale
, valist
);
1216 __ms_va_end(valist
);
1220 /*********************************************************************
1221 * _snwprintf_s (MSVCRT.@)
1223 int CDECL
MSVCRT__snwprintf_s( MSVCRT_wchar_t
*str
, unsigned int len
, unsigned int count
,
1224 const MSVCRT_wchar_t
*format
, ...)
1227 __ms_va_list valist
;
1228 __ms_va_start(valist
, format
);
1229 retval
= MSVCRT_vsnwprintf_s_l(str
, len
, count
, format
, NULL
, valist
);
1230 __ms_va_end(valist
);
1234 /*********************************************************************
1235 * _snwprintf_s_l (MSVCRT.@)
1237 int CDECL
MSVCRT__snwprintf_s_l( MSVCRT_wchar_t
*str
, unsigned int len
, unsigned int count
,
1238 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, ... )
1241 __ms_va_list valist
;
1242 __ms_va_start(valist
, locale
);
1243 retval
= MSVCRT_vsnwprintf_s_l(str
, len
, count
, format
, locale
, valist
);
1244 __ms_va_end(valist
);
1248 static int puts_clbk_str_c99_w(void *ctx
, int len
, const MSVCRT_wchar_t
*str
)
1250 struct _str_ctx_w
*out
= ctx
;
1255 if(out
->len
< len
) {
1256 memcpy(out
->buf
, str
, out
->len
*sizeof(MSVCRT_wchar_t
));
1257 out
->buf
+= out
->len
;
1262 memcpy(out
->buf
, str
, len
*sizeof(MSVCRT_wchar_t
));
1268 /*********************************************************************
1269 * __stdio_common_vswprintf (UCRTBASE.@)
1271 int CDECL
MSVCRT__stdio_common_vswprintf( unsigned __int64 options
,
1272 MSVCRT_wchar_t
*str
, MSVCRT_size_t len
, const MSVCRT_wchar_t
*format
,
1273 MSVCRT__locale_t locale
, __ms_va_list valist
)
1275 static const MSVCRT_wchar_t nullbyte
= '\0';
1276 struct _str_ctx_w ctx
= {len
, str
};
1279 if (options
& ~UCRTBASE_PRINTF_MASK
)
1280 FIXME("options %s not handled\n", wine_dbgstr_longlong(options
));
1281 ret
= pf_printf_w(puts_clbk_str_c99_w
,
1282 &ctx
, format
, locale
, options
& UCRTBASE_PRINTF_MASK
, arg_clbk_valist
, NULL
, &valist
);
1283 puts_clbk_str_w(&ctx
, 1, &nullbyte
);
1285 if(options
& UCRTBASE_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION
)
1286 return ret
>len
? -1 : ret
;
1288 if(len
) str
[len
-1] = 0;
1289 return (options
& UCRTBASE_PRINTF_STANDARD_SNPRINTF_BEHAVIOUR
) ? ret
: -2;
1294 /*********************************************************************
1295 * sprintf (MSVCRT.@)
1297 int CDECL
MSVCRT_sprintf( char *str
, const char *format
, ... )
1302 __ms_va_start( ap
, format
);
1303 r
= MSVCRT_vsnprintf( str
, INT_MAX
, format
, ap
);
1308 /*********************************************************************
1309 * sprintf_s (MSVCRT.@)
1311 int CDECL
MSVCRT_sprintf_s( char *str
, MSVCRT_size_t num
, const char *format
, ... )
1316 __ms_va_start( ap
, format
);
1317 r
= MSVCRT_vsnprintf( str
, num
, format
, ap
);
1322 /*********************************************************************
1323 * _scwprintf (MSVCRT.@)
1325 int CDECL
MSVCRT__scwprintf( const MSVCRT_wchar_t
*format
, ... )
1330 __ms_va_start( ap
, format
);
1331 r
= MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, ap
);
1336 /*********************************************************************
1337 * swprintf (MSVCRT.@)
1339 int CDECL
MSVCRT_swprintf( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*format
, ... )
1344 __ms_va_start( ap
, format
);
1345 r
= MSVCRT_vsnwprintf( str
, INT_MAX
, format
, ap
);
1350 /*********************************************************************
1351 * swprintf_s (MSVCRT.@)
1353 int CDECL
MSVCRT_swprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t numberOfElements
,
1354 const MSVCRT_wchar_t
*format
, ... )
1359 __ms_va_start(ap
, format
);
1360 r
= MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, ap
);
1366 /*********************************************************************
1367 * _swprintf_s_l (MSVCRT.@)
1369 int CDECL
MSVCRT__swprintf_s_l(MSVCRT_wchar_t
*str
, MSVCRT_size_t numberOfElements
,
1370 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, ... )
1375 __ms_va_start(ap
, locale
);
1376 r
= MSVCRT_vsnwprintf_s_l(str
, numberOfElements
, INT_MAX
, format
, locale
, ap
);
1382 /*********************************************************************
1383 * _vswprintf (MSVCRT.@)
1385 int CDECL
MSVCRT_vswprintf( MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* format
, __ms_va_list args
)
1387 return MSVCRT_vsnwprintf( str
, INT_MAX
, format
, args
);
1390 /*********************************************************************
1391 * _vswprintf (MSVCRT.@)
1393 int CDECL
MSVCRT_vswprintf_l( MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* format
,
1394 MSVCRT__locale_t locale
, __ms_va_list args
)
1396 return MSVCRT_vsnwprintf_l( str
, INT_MAX
, format
, locale
, args
);
1399 /*********************************************************************
1400 * _vscwprintf (MSVCRT.@)
1402 int CDECL
MSVCRT__vscwprintf( const MSVCRT_wchar_t
*format
, __ms_va_list args
)
1404 return MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, args
);
1407 /*********************************************************************
1408 * _vscwprintf_l (MSVCRT.@)
1410 int CDECL
MSVCRT__vscwprintf_l( const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, __ms_va_list args
)
1412 return MSVCRT_vsnwprintf_l( NULL
, INT_MAX
, format
, locale
, args
);
1415 /*********************************************************************
1416 * _vscwprintf_p_l (MSVCRT.@)
1418 int CDECL
MSVCRT__vscwprintf_p_l( const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, __ms_va_list args
)
1420 return MSVCRT_vswprintf_p_l_opt( NULL
, INT_MAX
, format
, 0, locale
, args
);
1423 /*********************************************************************
1424 * _vscwprintf_p (MSVCR100.@)
1426 int CDECL
MSVCRT__vscwprintf_p(const MSVCRT_wchar_t
*format
, __ms_va_list args
)
1428 return MSVCRT_vswprintf_p_l_opt(NULL
, INT_MAX
, format
, 0, NULL
, args
);
1431 /*********************************************************************
1432 * vswprintf_s (MSVCRT.@)
1434 int CDECL
MSVCRT_vswprintf_s(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
1435 const MSVCRT_wchar_t
* format
, __ms_va_list args
)
1437 return MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, args
);
1440 /*********************************************************************
1441 * _vswprintf_s_l (MSVCRT.@)
1443 int CDECL
MSVCRT_vswprintf_s_l(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
1444 const MSVCRT_wchar_t
* format
, MSVCRT__locale_t locale
, __ms_va_list args
)
1446 return MSVCRT_vsnwprintf_s_l(str
, numberOfElements
, INT_MAX
,
1447 format
, locale
, args
);
1450 static int MSVCRT_vsprintf_p_l_opt(char *buffer
, MSVCRT_size_t length
, const char *format
,
1451 DWORD options
, MSVCRT__locale_t locale
, __ms_va_list args
)
1453 static const char nullbyte
= '\0';
1454 printf_arg args_ctx
[MSVCRT__ARGMAX
+1];
1455 struct _str_ctx_a puts_ctx
= {length
, buffer
};
1458 memset(args_ctx
, 0, sizeof(args_ctx
));
1460 ret
= create_positional_ctx_a(args_ctx
, format
, args
);
1462 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
1463 *MSVCRT__errno() = MSVCRT_EINVAL
;
1466 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
,
1467 MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER
| options
, arg_clbk_valist
, NULL
, &args
);
1469 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
,
1470 MSVCRT_PRINTF_POSITIONAL_PARAMS
| MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER
| options
,
1471 arg_clbk_positional
, args_ctx
, NULL
);
1473 puts_clbk_str_a(&puts_ctx
, 1, &nullbyte
);
1477 /*********************************************************************
1478 * _vsprintf_p_l (MSVCRT.@)
1480 int CDECL
MSVCRT_vsprintf_p_l(char *buffer
, MSVCRT_size_t length
, const char *format
,
1481 MSVCRT__locale_t locale
, __ms_va_list args
)
1483 return MSVCRT_vsprintf_p_l_opt(buffer
, length
, format
, 0, locale
, args
);
1486 /*********************************************************************
1487 * _vsprintf_p (MSVCRT.@)
1489 int CDECL
MSVCRT_vsprintf_p(char *buffer
, MSVCRT_size_t length
,
1490 const char *format
, __ms_va_list args
)
1492 return MSVCRT_vsprintf_p_l(buffer
, length
, format
, NULL
, args
);
1495 /*********************************************************************
1496 * __stdio_common_vsprintf_p (UCRTBASE.@)
1498 int CDECL
MSVCRT__stdio_common_vsprintf_p(unsigned __int64 options
, char *buffer
, MSVCRT_size_t length
,
1499 const char *format
, MSVCRT__locale_t locale
, __ms_va_list args
)
1501 if (options
& ~UCRTBASE_PRINTF_MASK
)
1502 FIXME("options %s not handled\n", wine_dbgstr_longlong(options
));
1503 return MSVCRT_vsprintf_p_l_opt(buffer
, length
, format
, options
& UCRTBASE_PRINTF_MASK
, locale
, args
);
1506 /*********************************************************************
1507 * _sprintf_p_l (MSVCRT.@)
1509 int CDECL
MSVCRT_sprintf_p_l(char *buffer
, MSVCRT_size_t length
,
1510 const char *format
, MSVCRT__locale_t locale
, ...)
1512 __ms_va_list valist
;
1515 __ms_va_start(valist
, locale
);
1516 r
= MSVCRT_vsprintf_p_l(buffer
, length
, format
, locale
, valist
);
1517 __ms_va_end(valist
);
1522 /*********************************************************************
1523 * __swprintf_l (MSVCRT.@)
1525 int CDECL
MSVCRT___swprintf_l( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*format
,
1526 MSVCRT__locale_t locale
, ...)
1529 __ms_va_list valist
;
1530 __ms_va_start(valist
, locale
);
1531 retval
= MSVCRT_vswprintf_l(str
, format
, locale
, valist
);
1532 __ms_va_end(valist
);
1536 /*********************************************************************
1537 * _sprintf_p (MSVCR100.@)
1539 int CDECL
MSVCRT__sprintf_p(char *buffer
, MSVCRT_size_t length
, const char *format
, ...)
1541 __ms_va_list valist
;
1544 __ms_va_start(valist
, format
);
1545 r
= MSVCRT_vsprintf_p_l(buffer
, length
, format
, NULL
, valist
);
1546 __ms_va_end(valist
);
1551 /*********************************************************************
1552 * _swprintf_p_l (MSVCRT.@)
1554 int CDECL
MSVCRT_swprintf_p_l(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
1555 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, ...)
1557 __ms_va_list valist
;
1560 __ms_va_start(valist
, locale
);
1561 r
= MSVCRT_vswprintf_p_l_opt(buffer
, length
, format
, 0, locale
, valist
);
1562 __ms_va_end(valist
);
1567 /*********************************************************************
1568 * _wcscoll_l (MSVCRT.@)
1570 int CDECL
MSVCRT__wcscoll_l(const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
, MSVCRT__locale_t locale
)
1572 MSVCRT_pthreadlocinfo locinfo
;
1575 locinfo
= get_locinfo();
1577 locinfo
= locale
->locinfo
;
1579 if(!locinfo
->lc_handle
[MSVCRT_LC_COLLATE
])
1580 return strcmpW(str1
, str2
);
1581 return CompareStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
], 0, str1
, -1, str2
, -1)-CSTR_EQUAL
;
1584 /*********************************************************************
1585 * wcscoll (MSVCRT.@)
1587 int CDECL
MSVCRT_wcscoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
)
1589 return MSVCRT__wcscoll_l(str1
, str2
, NULL
);
1592 /*********************************************************************
1593 * wcspbrk (MSVCRT.@)
1595 MSVCRT_wchar_t
* CDECL
MSVCRT_wcspbrk( const MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* accept
)
1597 const MSVCRT_wchar_t
* p
;
1601 for (p
= accept
; *p
; p
++) if (*p
== *str
) return (MSVCRT_wchar_t
*)str
;
1607 /*********************************************************************
1608 * wcstok_s (MSVCRT.@)
1610 MSVCRT_wchar_t
* CDECL
MSVCRT_wcstok_s( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
,
1611 MSVCRT_wchar_t
**next_token
)
1613 MSVCRT_wchar_t
*ret
;
1615 if (!MSVCRT_CHECK_PMT(delim
!= NULL
)) return NULL
;
1616 if (!MSVCRT_CHECK_PMT(next_token
!= NULL
)) return NULL
;
1617 if (!MSVCRT_CHECK_PMT(str
!= NULL
|| *next_token
!= NULL
)) return NULL
;
1619 if (!str
) str
= *next_token
;
1621 while (*str
&& strchrW( delim
, *str
)) str
++;
1622 if (!*str
) return NULL
;
1624 while (*str
&& !strchrW( delim
, *str
)) str
++;
1625 if (*str
) *str
++ = 0;
1630 /*********************************************************************
1633 MSVCRT_wchar_t
* CDECL
MSVCRT_wcstok( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
)
1635 return MSVCRT_wcstok_s(str
, delim
, &msvcrt_get_thread_data()->wcstok_next
);
1638 /*********************************************************************
1639 * _wctomb_s_l (MSVCRT.@)
1641 int CDECL
MSVCRT__wctomb_s_l(int *len
, char *mbchar
, MSVCRT_size_t size
,
1642 MSVCRT_wchar_t wch
, MSVCRT__locale_t locale
)
1644 MSVCRT_pthreadlocinfo locinfo
;
1648 if(!mbchar
&& size
>0) {
1657 if(!MSVCRT_CHECK_PMT(size
<= INT_MAX
))
1658 return MSVCRT_EINVAL
;
1661 locinfo
= get_locinfo();
1663 locinfo
= locale
->locinfo
;
1665 if(!locinfo
->lc_codepage
) {
1667 if(mbchar
&& size
>0)
1668 memset(mbchar
, 0, size
);
1669 *MSVCRT__errno() = MSVCRT_EILSEQ
;
1670 return MSVCRT_EILSEQ
;
1673 if(!MSVCRT_CHECK_PMT_ERR(size
>= 1, MSVCRT_ERANGE
))
1674 return MSVCRT_ERANGE
;
1682 mblen
= WideCharToMultiByte(locinfo
->lc_codepage
, 0, &wch
, 1, mbchar
, size
, NULL
, &error
);
1683 if(!mblen
|| error
) {
1684 if(!mblen
&& GetLastError()==ERROR_INSUFFICIENT_BUFFER
) {
1685 if(mbchar
&& size
>0)
1686 memset(mbchar
, 0, size
);
1688 MSVCRT_INVALID_PMT("insufficient buffer size", MSVCRT_ERANGE
);
1689 return MSVCRT_ERANGE
;
1692 *MSVCRT__errno() = MSVCRT_EILSEQ
;
1693 return MSVCRT_EILSEQ
;
1701 /*********************************************************************
1702 * wctomb_s (MSVCRT.@)
1704 int CDECL
MSVCRT_wctomb_s(int *len
, char *mbchar
, MSVCRT_size_t size
, MSVCRT_wchar_t wch
)
1706 return MSVCRT__wctomb_s_l(len
, mbchar
, size
, wch
, NULL
);
1709 /*********************************************************************
1710 * _wctomb_l (MSVCRT.@)
1712 int CDECL
MSVCRT__wctomb_l(char *dst
, MSVCRT_wchar_t ch
, MSVCRT__locale_t locale
)
1716 MSVCRT__wctomb_s_l(&len
, dst
, dst
? MSVCRT_MB_LEN_MAX
: 0, ch
, locale
);
1720 /*********************************************************************
1723 INT CDECL
MSVCRT_wctomb( char *dst
, MSVCRT_wchar_t ch
)
1725 return MSVCRT__wctomb_l(dst
, ch
, NULL
);
1728 /*********************************************************************
1731 INT CDECL
MSVCRT_wctob( MSVCRT_wint_t wchar
)
1735 UINT codepage
= get_locinfo()->lc_codepage
;
1739 return (signed char)wchar
;
1742 } else if(WideCharToMultiByte( codepage
, 0, &wchar
, 1, &out
, 1, NULL
, &error
) && !error
)
1747 /*********************************************************************
1748 * wcrtomb (MSVCRT.@)
1750 MSVCRT_size_t CDECL
MSVCRT_wcrtomb( char *dst
, MSVCRT_wchar_t ch
, MSVCRT_mbstate_t
*s
)
1754 return MSVCRT_wctomb(dst
, ch
);
1757 /*********************************************************************
1758 * iswalnum (MSVCRT.@)
1760 INT CDECL
MSVCRT_iswalnum( MSVCRT_wchar_t wc
)
1762 return isalnumW( wc
);
1765 /*********************************************************************
1766 * iswalpha (MSVCRT.@)
1768 INT CDECL
MSVCRT_iswalpha( MSVCRT_wchar_t wc
)
1770 return isalphaW( wc
);
1773 /*********************************************************************
1774 * iswalpha_l (MSVCRT.@)
1776 INT CDECL
MSVCRT__iswalpha_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1778 return isalphaW( wc
);
1781 /*********************************************************************
1782 * iswcntrl (MSVCRT.@)
1784 INT CDECL
MSVCRT_iswcntrl( MSVCRT_wchar_t wc
)
1786 return iscntrlW( wc
);
1789 /*********************************************************************
1790 * iswdigit (MSVCRT.@)
1792 INT CDECL
MSVCRT_iswdigit( MSVCRT_wchar_t wc
)
1794 return isdigitW( wc
);
1797 /*********************************************************************
1798 * _iswdigit_l (MSVCRT.@)
1800 INT CDECL
MSVCRT__iswdigit_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1802 return isdigitW( wc
);
1805 /*********************************************************************
1806 * iswgraph (MSVCRT.@)
1808 INT CDECL
MSVCRT_iswgraph( MSVCRT_wchar_t wc
)
1810 return isgraphW( wc
);
1813 /*********************************************************************
1814 * iswlower (MSVCRT.@)
1816 INT CDECL
MSVCRT_iswlower( MSVCRT_wchar_t wc
)
1818 return islowerW( wc
);
1821 /*********************************************************************
1822 * iswprint (MSVCRT.@)
1824 INT CDECL
MSVCRT_iswprint( MSVCRT_wchar_t wc
)
1826 return isprintW( wc
);
1829 /*********************************************************************
1830 * _iswpunct_l (MSVCRT.@)
1832 INT CDECL
MSVCRT__iswpunct_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1834 return ispunctW( wc
);
1837 /*********************************************************************
1838 * iswpunct (MSVCRT.@)
1840 INT CDECL
MSVCRT_iswpunct( MSVCRT_wchar_t wc
)
1842 return ispunctW( wc
);
1845 /*********************************************************************
1846 * _iswspace_l (MSVCRT.@)
1848 INT CDECL
MSVCRT__iswspace_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1850 return isspaceW( wc
);
1853 /*********************************************************************
1854 * iswspace (MSVCRT.@)
1856 INT CDECL
MSVCRT_iswspace( MSVCRT_wchar_t wc
)
1858 return isspaceW( wc
);
1861 /*********************************************************************
1862 * iswupper (MSVCRT.@)
1864 INT CDECL
MSVCRT_iswupper( MSVCRT_wchar_t wc
)
1866 return isupperW( wc
);
1869 /*********************************************************************
1870 * iswxdigit (MSVCRT.@)
1872 INT CDECL
MSVCRT_iswxdigit( MSVCRT_wchar_t wc
)
1874 return isxdigitW( wc
);
1877 /*********************************************************************
1878 * _iswctype_l (MSVCRT.@)
1880 INT CDECL
MSVCRT__iswctype_l( MSVCRT_wchar_t wc
, MSVCRT_wctype_t type
, MSVCRT__locale_t locale
)
1882 return (get_char_typeW(wc
) & 0xffff) & type
;
1885 /*********************************************************************
1886 * _iswblank_l (MSVCRT.@)
1888 INT CDECL
MSVCRT__iswblank_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1890 return wc
== '\t' || MSVCRT__iswctype_l( wc
, MSVCRT__BLANK
, locale
);
1893 /*********************************************************************
1894 * iswblank (MSVCRT.@)
1896 INT CDECL
MSVCRT_iswblank( MSVCRT_wchar_t wc
)
1898 return wc
== '\t' || MSVCRT__iswctype_l( wc
, MSVCRT__BLANK
, NULL
);
1901 /*********************************************************************
1902 * wcscpy_s (MSVCRT.@)
1904 INT CDECL
MSVCRT_wcscpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
)
1906 MSVCRT_size_t size
= 0;
1908 if(!MSVCRT_CHECK_PMT(wcDest
)) return MSVCRT_EINVAL
;
1909 if(!MSVCRT_CHECK_PMT(numElement
)) return MSVCRT_EINVAL
;
1913 if(!MSVCRT_CHECK_PMT(wcSrc
)) return MSVCRT_EINVAL
;
1915 size
= strlenW(wcSrc
) + 1;
1917 if(!MSVCRT_CHECK_PMT_ERR(size
<= numElement
, MSVCRT_ERANGE
))
1918 return MSVCRT_ERANGE
;
1920 memcpy( wcDest
, wcSrc
, size
*sizeof(WCHAR
) );
1925 /******************************************************************
1926 * wcsncpy (MSVCRT.@)
1928 MSVCRT_wchar_t
* __cdecl
MSVCRT_wcsncpy( MSVCRT_wchar_t
* s1
,
1929 const MSVCRT_wchar_t
*s2
, MSVCRT_size_t n
)
1934 if(!(s1
[i
] = s2
[i
])) break;
1940 /******************************************************************
1941 * wcsncpy_s (MSVCRT.@)
1943 INT CDECL
MSVCRT_wcsncpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
,
1944 MSVCRT_size_t count
)
1947 BOOL truncate
= (count
== MSVCRT__TRUNCATE
);
1949 if(!wcDest
&& !numElement
&& !count
)
1952 if (!wcDest
|| !numElement
)
1953 return MSVCRT_EINVAL
;
1958 return count
? MSVCRT_EINVAL
: 0;
1961 while (numElement
&& count
&& *wcSrc
)
1967 if (!numElement
&& truncate
)
1970 return MSVCRT_STRUNCATE
;
1972 else if (!numElement
)
1975 return MSVCRT_ERANGE
;
1982 /******************************************************************
1983 * wcscat_s (MSVCRT.@)
1986 INT CDECL
MSVCRT_wcscat_s(MSVCRT_wchar_t
* dst
, MSVCRT_size_t elem
, const MSVCRT_wchar_t
* src
)
1988 MSVCRT_wchar_t
* ptr
= dst
;
1990 if (!dst
|| elem
== 0) return MSVCRT_EINVAL
;
1994 return MSVCRT_EINVAL
;
1997 /* seek to end of dst string (or elem if no end of string is found */
1998 while (ptr
< dst
+ elem
&& *ptr
!= '\0') ptr
++;
1999 while (ptr
< dst
+ elem
)
2001 if ((*ptr
++ = *src
++) == '\0') return 0;
2003 /* not enough space */
2005 return MSVCRT_ERANGE
;
2008 /*********************************************************************
2009 * wcsncat_s (MSVCRT.@)
2012 INT CDECL
MSVCRT_wcsncat_s(MSVCRT_wchar_t
*dst
, MSVCRT_size_t elem
,
2013 const MSVCRT_wchar_t
*src
, MSVCRT_size_t count
)
2015 MSVCRT_size_t srclen
;
2016 MSVCRT_wchar_t dststart
;
2019 if (!MSVCRT_CHECK_PMT(dst
!= NULL
)) return MSVCRT_EINVAL
;
2020 if (!MSVCRT_CHECK_PMT(elem
> 0)) return MSVCRT_EINVAL
;
2021 if (!MSVCRT_CHECK_PMT(src
!= NULL
|| count
== 0)) return MSVCRT_EINVAL
;
2026 for (dststart
= 0; dststart
< elem
; dststart
++)
2028 if (dst
[dststart
] == '\0')
2031 if (dststart
== elem
)
2033 MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n", MSVCRT_EINVAL
);
2034 return MSVCRT_EINVAL
;
2037 if (count
== MSVCRT__TRUNCATE
)
2039 srclen
= strlenW(src
);
2040 if (srclen
>= (elem
- dststart
))
2042 srclen
= elem
- dststart
- 1;
2043 ret
= MSVCRT_STRUNCATE
;
2047 srclen
= min(strlenW(src
), count
);
2048 if (srclen
< (elem
- dststart
))
2050 memcpy(&dst
[dststart
], src
, srclen
*sizeof(MSVCRT_wchar_t
));
2051 dst
[dststart
+srclen
] = '\0';
2054 MSVCRT_INVALID_PMT("dst[elem] is too small", MSVCRT_ERANGE
);
2056 return MSVCRT_ERANGE
;
2059 /*********************************************************************
2060 * wctoint (INTERNAL)
2062 static int wctoint(WCHAR c
, int base
)
2065 if ('0' <= c
&& c
<= '9')
2067 else if ('A' <= c
&& c
<= 'Z')
2069 else if ('a' <= c
&& c
<= 'z')
2072 /* NOTE: wine_fold_string(MAP_FOLDDIGITS) supports too many things. */
2073 /* Unicode points that contain digits 0-9; keep this sorted! */
2074 static const WCHAR zeros
[] = {
2075 0x660, 0x6f0, 0x966, 0x9e6, 0xa66, 0xae6, 0xb66, 0xc66, 0xce6,
2076 0xd66, 0xe50, 0xed0, 0xf20, 0x1040, 0x17e0, 0x1810, 0xff10
2079 for (i
= 0; i
< sizeof(zeros
)/sizeof(zeros
[0]) && c
>= zeros
[i
]; ++i
) {
2080 if (zeros
[i
] <= c
&& c
<= zeros
[i
] + 9) {
2086 return v
< base
? v
: -1;
2089 /*********************************************************************
2090 * _wcstoi64_l (MSVCRT.@)
2092 * FIXME: locale parameter is ignored
2094 __int64 CDECL
MSVCRT__wcstoi64_l(const MSVCRT_wchar_t
*nptr
,
2095 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
2097 BOOL negative
= FALSE
, empty
= TRUE
;
2100 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
2102 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
)) return 0;
2103 if (!MSVCRT_CHECK_PMT(base
== 0 || base
>= 2)) return 0;
2104 if (!MSVCRT_CHECK_PMT(base
<= 36)) return 0;
2107 *endptr
= (MSVCRT_wchar_t
*)nptr
;
2109 while(isspaceW(*nptr
)) nptr
++;
2114 } else if(*nptr
== '+')
2117 if((base
==0 || base
==16) && wctoint(*nptr
, 1)==0 && tolowerW(*(nptr
+1))=='x') {
2123 if(wctoint(*nptr
, 1)==0)
2130 int v
= wctoint(*nptr
, base
);
2140 if(!negative
&& (ret
>MSVCRT_I64_MAX
/base
|| ret
*base
>MSVCRT_I64_MAX
-v
)) {
2141 ret
= MSVCRT_I64_MAX
;
2142 *MSVCRT__errno() = MSVCRT_ERANGE
;
2143 } else if(negative
&& (ret
<MSVCRT_I64_MIN
/base
|| ret
*base
<MSVCRT_I64_MIN
-v
)) {
2144 ret
= MSVCRT_I64_MIN
;
2145 *MSVCRT__errno() = MSVCRT_ERANGE
;
2150 if(endptr
&& !empty
)
2151 *endptr
= (MSVCRT_wchar_t
*)nptr
;
2156 /*********************************************************************
2157 * _wcstoi64 (MSVCRT.@)
2159 __int64 CDECL
MSVCRT__wcstoi64(const MSVCRT_wchar_t
*nptr
,
2160 MSVCRT_wchar_t
**endptr
, int base
)
2162 return MSVCRT__wcstoi64_l(nptr
, endptr
, base
, NULL
);
2165 /*********************************************************************
2166 * _wcstol_l (MSVCRT.@)
2168 MSVCRT_long CDECL
MSVCRT__wcstol_l(const MSVCRT_wchar_t
*s
,
2169 MSVCRT_wchar_t
**end
, int base
, MSVCRT__locale_t locale
)
2171 __int64 ret
= MSVCRT__wcstoi64_l(s
, end
, base
, locale
);
2173 if(ret
> MSVCRT_LONG_MAX
) {
2174 ret
= MSVCRT_LONG_MAX
;
2175 *MSVCRT__errno() = MSVCRT_ERANGE
;
2176 }else if(ret
< MSVCRT_LONG_MIN
) {
2177 ret
= MSVCRT_LONG_MIN
;
2178 *MSVCRT__errno() = MSVCRT_ERANGE
;
2183 /*********************************************************************
2184 * _wtoi_l (MSVCRT.@)
2186 int __cdecl
MSVCRT__wtoi_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
2188 __int64 ret
= MSVCRT__wcstoi64_l(str
, NULL
, 10, locale
);
2192 *MSVCRT__errno() = MSVCRT_ERANGE
;
2193 } else if(ret
< INT_MIN
) {
2195 *MSVCRT__errno() = MSVCRT_ERANGE
;
2200 /*********************************************************************
2203 int __cdecl
MSVCRT__wtoi(const MSVCRT_wchar_t
*str
)
2205 return MSVCRT__wtoi_l(str
, NULL
);
2208 /*********************************************************************
2209 * _wtol_l (MSVCRT.@)
2211 MSVCRT_long __cdecl
MSVCRT__wtol_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
2213 __int64 ret
= MSVCRT__wcstoi64_l(str
, NULL
, 10, locale
);
2215 if(ret
> MSVCRT_LONG_MAX
) {
2216 ret
= MSVCRT_LONG_MAX
;
2217 *MSVCRT__errno() = MSVCRT_ERANGE
;
2218 } else if(ret
< MSVCRT_LONG_MIN
) {
2219 ret
= MSVCRT_LONG_MIN
;
2220 *MSVCRT__errno() = MSVCRT_ERANGE
;
2225 /*********************************************************************
2228 MSVCRT_long __cdecl
MSVCRT__wtol(const MSVCRT_wchar_t
*str
)
2230 return MSVCRT__wtol_l(str
, NULL
);
2233 /*********************************************************************
2234 * _wtoll_l (MSVCR120.@)
2236 MSVCRT_longlong __cdecl
MSVCRT__wtoll_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
2238 return MSVCRT__wcstoi64_l(str
, NULL
, 10, locale
);
2241 /*********************************************************************
2242 * _wtoll (MSVCR120.@)
2244 MSVCRT_longlong __cdecl
MSVCRT__wtoll(const MSVCRT_wchar_t
*str
)
2246 return MSVCRT__wtoll_l(str
, NULL
);
2249 /*********************************************************************
2250 * _wcstoui64_l (MSVCRT.@)
2252 * FIXME: locale parameter is ignored
2254 unsigned __int64 CDECL
MSVCRT__wcstoui64_l(const MSVCRT_wchar_t
*nptr
,
2255 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
2257 BOOL negative
= FALSE
, empty
= TRUE
;
2258 unsigned __int64 ret
= 0;
2260 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
2262 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
)) return 0;
2263 if (!MSVCRT_CHECK_PMT(base
== 0 || base
>= 2)) return 0;
2264 if (!MSVCRT_CHECK_PMT(base
<= 36)) return 0;
2267 *endptr
= (MSVCRT_wchar_t
*)nptr
;
2269 while(isspaceW(*nptr
)) nptr
++;
2274 } else if(*nptr
== '+')
2277 if((base
==0 || base
==16) && wctoint(*nptr
, 1)==0 && tolowerW(*(nptr
+1))=='x') {
2283 if(wctoint(*nptr
, 1)==0)
2290 int v
= wctoint(*nptr
, base
);
2297 if(ret
>MSVCRT_UI64_MAX
/base
|| ret
*base
>MSVCRT_UI64_MAX
-v
) {
2298 ret
= MSVCRT_UI64_MAX
;
2299 *MSVCRT__errno() = MSVCRT_ERANGE
;
2304 if(endptr
&& !empty
)
2305 *endptr
= (MSVCRT_wchar_t
*)nptr
;
2307 return negative
? -ret
: ret
;
2310 /*********************************************************************
2311 * _wcstoui64 (MSVCRT.@)
2313 unsigned __int64 CDECL
MSVCRT__wcstoui64(const MSVCRT_wchar_t
*nptr
,
2314 MSVCRT_wchar_t
**endptr
, int base
)
2316 return MSVCRT__wcstoui64_l(nptr
, endptr
, base
, NULL
);
2319 /*********************************************************************
2320 * _wcstoul_l (MSVCRT.@)
2322 MSVCRT_ulong __cdecl
MSVCRT__wcstoul_l(const MSVCRT_wchar_t
*s
,
2323 MSVCRT_wchar_t
**end
, int base
, MSVCRT__locale_t locale
)
2325 __int64 ret
= MSVCRT__wcstoui64_l(s
, end
, base
, locale
);
2327 if(ret
> MSVCRT_ULONG_MAX
) {
2328 ret
= MSVCRT_ULONG_MAX
;
2329 *MSVCRT__errno() = MSVCRT_ERANGE
;
2334 /*********************************************************************
2335 * wcstoul (MSVCRT.@)
2337 MSVCRT_ulong __cdecl
MSVCRT_wcstoul(const MSVCRT_wchar_t
*s
, MSVCRT_wchar_t
**end
, int base
)
2339 return MSVCRT__wcstoul_l(s
, end
, base
, NULL
);
2342 /******************************************************************
2343 * wcsnlen (MSVCRT.@)
2345 MSVCRT_size_t CDECL
MSVCRT_wcsnlen(const MSVCRT_wchar_t
*s
, MSVCRT_size_t maxlen
)
2349 for (i
= 0; i
< maxlen
; i
++)
2354 /*********************************************************************
2355 * _towupper_l (MSVCRT.@)
2357 int CDECL
MSVCRT__towupper_l(MSVCRT_wint_t c
, MSVCRT__locale_t locale
)
2362 /*********************************************************************
2363 * towupper (MSVCRT.@)
2365 int CDECL
MSVCRT_towupper(MSVCRT_wint_t c
)
2367 return MSVCRT__towupper_l(c
, NULL
);
2370 /*********************************************************************
2371 * _towlower_l (MSVCRT.@)
2373 int CDECL
MSVCRT__towlower_l(MSVCRT_wint_t c
, MSVCRT__locale_t locale
)
2378 /*********************************************************************
2379 * towlower (MSVCRT.@)
2381 int CDECL
MSVCRT_towlower(MSVCRT_wint_t c
)
2383 return MSVCRT__towlower_l(c
, NULL
);
2386 /*********************************************************************
2389 MSVCRT_wchar_t
* CDECL
MSVCRT_wcschr(const MSVCRT_wchar_t
*str
, MSVCRT_wchar_t ch
)
2391 return strchrW(str
, ch
);
2394 /***********************************************************************
2397 int CDECL
MSVCRT_wcslen(const MSVCRT_wchar_t
*str
)
2399 return strlenW(str
);
2402 /*********************************************************************
2405 MSVCRT_wchar_t
* CDECL
MSVCRT_wcsstr(const MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*sub
)
2407 return strstrW(str
, sub
);
2410 /*********************************************************************
2411 * _wtoi64_l (MSVCRT.@)
2413 __int64 CDECL
MSVCRT__wtoi64_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
2415 ULONGLONG RunningTotal
= 0;
2416 BOOL bMinus
= FALSE
;
2418 while (isspaceW(*str
)) {
2424 } else if (*str
== '-') {
2429 while (*str
>= '0' && *str
<= '9') {
2430 RunningTotal
= RunningTotal
* 10 + *str
- '0';
2434 return bMinus
? -RunningTotal
: RunningTotal
;
2437 /*********************************************************************
2438 * _wtoi64 (MSVCRT.@)
2440 __int64 CDECL
MSVCRT__wtoi64(const MSVCRT_wchar_t
*str
)
2442 return MSVCRT__wtoi64_l(str
, NULL
);
2445 /*********************************************************************
2446 * wcsncmp (MSVCRT.@)
2448 int CDECL
MSVCRT_wcsncmp(const MSVCRT_wchar_t
*str1
, const MSVCRT_wchar_t
*str2
, int n
)
2450 return strncmpW(str1
, str2
, n
);
2453 /*********************************************************************
2454 * _wcsxfrm_l (MSVCRT.@)
2456 MSVCRT_size_t CDECL
MSVCRT__wcsxfrm_l(MSVCRT_wchar_t
*dest
, const MSVCRT_wchar_t
*src
,
2457 MSVCRT_size_t len
, MSVCRT__locale_t locale
)
2459 MSVCRT_pthreadlocinfo locinfo
;
2462 if(!MSVCRT_CHECK_PMT(src
)) return INT_MAX
;
2463 if(!MSVCRT_CHECK_PMT(dest
|| !len
)) return INT_MAX
;
2466 FIXME("len > INT_MAX not supported\n");
2471 locinfo
= get_locinfo();
2473 locinfo
= locale
->locinfo
;
2475 if(!locinfo
->lc_handle
[MSVCRT_LC_COLLATE
]) {
2476 MSVCRT_wcsncpy(dest
, src
, len
);
2477 return strlenW(src
);
2480 ret
= LCMapStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
],
2481 LCMAP_SORTKEY
, src
, -1, NULL
, 0);
2483 if(len
) dest
[0] = 0;
2484 *MSVCRT__errno() = MSVCRT_EILSEQ
;
2487 if(!len
) return ret
-1;
2491 *MSVCRT__errno() = MSVCRT_ERANGE
;
2495 ret
= LCMapStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
],
2496 LCMAP_SORTKEY
, src
, -1, dest
, len
) - 1;
2497 for(i
=ret
; i
>=0; i
--)
2498 dest
[i
] = ((unsigned char*)dest
)[i
];
2502 /*********************************************************************
2503 * wcsxfrm (MSVCRT.@)
2505 MSVCRT_size_t CDECL
MSVCRT_wcsxfrm(MSVCRT_wchar_t
*dest
,
2506 const MSVCRT_wchar_t
*src
, MSVCRT_size_t len
)
2508 return MSVCRT__wcsxfrm_l(dest
, src
, len
, NULL
);