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 static 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 (MSVCRT.@)
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 (MSVCRT.@)
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 (MSVCRT.@)
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 (MSVCRT.@)
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 (MSVCRT.@)
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 (MSVCRT.@)
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 (MSVCRT.@)
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 /*********************************************************************
1451 * _vsprintf_p_l (MSVCRT.@)
1453 int CDECL
MSVCRT_vsprintf_p_l(char *buffer
, MSVCRT_size_t length
, const char *format
,
1454 MSVCRT__locale_t locale
, __ms_va_list args
)
1456 static const char nullbyte
= '\0';
1457 printf_arg args_ctx
[MSVCRT__ARGMAX
+1];
1458 struct _str_ctx_a puts_ctx
= {length
, buffer
};
1461 memset(args_ctx
, 0, sizeof(args_ctx
));
1463 ret
= create_positional_ctx_a(args_ctx
, format
, args
);
1465 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
1466 *MSVCRT__errno() = MSVCRT_EINVAL
;
1469 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
, MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER
,
1470 arg_clbk_valist
, NULL
, &args
);
1472 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
,
1473 MSVCRT_PRINTF_POSITIONAL_PARAMS
| MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER
,
1474 arg_clbk_positional
, args_ctx
, NULL
);
1476 puts_clbk_str_a(&puts_ctx
, 1, &nullbyte
);
1480 /*********************************************************************
1481 * _vsprintf_p (MSVCRT.@)
1483 int CDECL
MSVCRT_vsprintf_p(char *buffer
, MSVCRT_size_t length
,
1484 const char *format
, __ms_va_list args
)
1486 return MSVCRT_vsprintf_p_l(buffer
, length
, format
, NULL
, args
);
1489 /*********************************************************************
1490 * _sprintf_p_l (MSVCRT.@)
1492 int CDECL
MSVCRT_sprintf_p_l(char *buffer
, MSVCRT_size_t length
,
1493 const char *format
, MSVCRT__locale_t locale
, ...)
1495 __ms_va_list valist
;
1498 __ms_va_start(valist
, locale
);
1499 r
= MSVCRT_vsprintf_p_l(buffer
, length
, format
, locale
, valist
);
1500 __ms_va_end(valist
);
1505 /*********************************************************************
1506 * __swprintf_l (MSVCRT.@)
1508 int CDECL
MSVCRT___swprintf_l( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*format
,
1509 MSVCRT__locale_t locale
, ...)
1512 __ms_va_list valist
;
1513 __ms_va_start(valist
, locale
);
1514 retval
= MSVCRT_vswprintf_l(str
, format
, locale
, valist
);
1515 __ms_va_end(valist
);
1519 /*********************************************************************
1520 * _sprintf_p (MSVCR100.@)
1522 int CDECL
MSVCRT__sprintf_p(char *buffer
, MSVCRT_size_t length
, const char *format
, ...)
1524 __ms_va_list valist
;
1527 __ms_va_start(valist
, format
);
1528 r
= MSVCRT_vsprintf_p_l(buffer
, length
, format
, NULL
, valist
);
1529 __ms_va_end(valist
);
1534 /*********************************************************************
1535 * _swprintf_p_l (MSVCRT.@)
1537 int CDECL
MSVCRT_swprintf_p_l(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
1538 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, ...)
1540 __ms_va_list valist
;
1543 __ms_va_start(valist
, locale
);
1544 r
= MSVCRT_vswprintf_p_l_opt(buffer
, length
, format
, 0, locale
, valist
);
1545 __ms_va_end(valist
);
1550 /*********************************************************************
1551 * _wcscoll_l (MSVCRT.@)
1553 int CDECL
MSVCRT__wcscoll_l(const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
, MSVCRT__locale_t locale
)
1555 MSVCRT_pthreadlocinfo locinfo
;
1558 locinfo
= get_locinfo();
1560 locinfo
= locale
->locinfo
;
1562 if(!locinfo
->lc_handle
[MSVCRT_LC_COLLATE
])
1563 return strcmpW(str1
, str2
);
1564 return CompareStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
], 0, str1
, -1, str2
, -1)-CSTR_EQUAL
;
1567 /*********************************************************************
1568 * wcscoll (MSVCRT.@)
1570 int CDECL
MSVCRT_wcscoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
)
1572 return MSVCRT__wcscoll_l(str1
, str2
, NULL
);
1575 /*********************************************************************
1576 * wcspbrk (MSVCRT.@)
1578 MSVCRT_wchar_t
* CDECL
MSVCRT_wcspbrk( const MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* accept
)
1580 const MSVCRT_wchar_t
* p
;
1584 for (p
= accept
; *p
; p
++) if (*p
== *str
) return (MSVCRT_wchar_t
*)str
;
1590 /*********************************************************************
1591 * wcstok_s (MSVCRT.@)
1593 MSVCRT_wchar_t
* CDECL
MSVCRT_wcstok_s( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
,
1594 MSVCRT_wchar_t
**next_token
)
1596 MSVCRT_wchar_t
*ret
;
1598 if (!MSVCRT_CHECK_PMT(delim
!= NULL
)) return NULL
;
1599 if (!MSVCRT_CHECK_PMT(next_token
!= NULL
)) return NULL
;
1600 if (!MSVCRT_CHECK_PMT(str
!= NULL
|| *next_token
!= NULL
)) return NULL
;
1602 if (!str
) str
= *next_token
;
1604 while (*str
&& strchrW( delim
, *str
)) str
++;
1605 if (!*str
) return NULL
;
1607 while (*str
&& !strchrW( delim
, *str
)) str
++;
1608 if (*str
) *str
++ = 0;
1613 /*********************************************************************
1616 MSVCRT_wchar_t
* CDECL
MSVCRT_wcstok( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
)
1618 return MSVCRT_wcstok_s(str
, delim
, &msvcrt_get_thread_data()->wcstok_next
);
1621 /*********************************************************************
1622 * _wctomb_s_l (MSVCRT.@)
1624 int CDECL
MSVCRT__wctomb_s_l(int *len
, char *mbchar
, MSVCRT_size_t size
,
1625 MSVCRT_wchar_t wch
, MSVCRT__locale_t locale
)
1627 MSVCRT_pthreadlocinfo locinfo
;
1631 if(!mbchar
&& size
>0) {
1640 if(!MSVCRT_CHECK_PMT(size
<= INT_MAX
))
1641 return MSVCRT_EINVAL
;
1644 locinfo
= get_locinfo();
1646 locinfo
= locale
->locinfo
;
1648 if(!locinfo
->lc_codepage
) {
1650 if(mbchar
&& size
>0)
1651 memset(mbchar
, 0, size
);
1652 *MSVCRT__errno() = MSVCRT_EILSEQ
;
1653 return MSVCRT_EILSEQ
;
1656 if(!MSVCRT_CHECK_PMT_ERR(size
>= 1, MSVCRT_ERANGE
))
1657 return MSVCRT_ERANGE
;
1665 mblen
= WideCharToMultiByte(locinfo
->lc_codepage
, 0, &wch
, 1, mbchar
, size
, NULL
, &error
);
1666 if(!mblen
|| error
) {
1667 if(!mblen
&& GetLastError()==ERROR_INSUFFICIENT_BUFFER
) {
1668 if(mbchar
&& size
>0)
1669 memset(mbchar
, 0, size
);
1671 MSVCRT_INVALID_PMT("insufficient buffer size", MSVCRT_ERANGE
);
1672 return MSVCRT_ERANGE
;
1675 *MSVCRT__errno() = MSVCRT_EILSEQ
;
1676 return MSVCRT_EILSEQ
;
1684 /*********************************************************************
1685 * wctomb_s (MSVCRT.@)
1687 int CDECL
MSVCRT_wctomb_s(int *len
, char *mbchar
, MSVCRT_size_t size
, MSVCRT_wchar_t wch
)
1689 return MSVCRT__wctomb_s_l(len
, mbchar
, size
, wch
, NULL
);
1692 /*********************************************************************
1693 * _wctomb_l (MSVCRT.@)
1695 int CDECL
MSVCRT__wctomb_l(char *dst
, MSVCRT_wchar_t ch
, MSVCRT__locale_t locale
)
1699 MSVCRT__wctomb_s_l(&len
, dst
, dst
? MSVCRT_MB_LEN_MAX
: 0, ch
, locale
);
1703 /*********************************************************************
1706 INT CDECL
MSVCRT_wctomb( char *dst
, MSVCRT_wchar_t ch
)
1708 return MSVCRT__wctomb_l(dst
, ch
, NULL
);
1711 /*********************************************************************
1714 INT CDECL
MSVCRT_wctob( MSVCRT_wint_t wchar
)
1718 UINT codepage
= get_locinfo()->lc_codepage
;
1722 return (signed char)wchar
;
1725 } else if(WideCharToMultiByte( codepage
, 0, &wchar
, 1, &out
, 1, NULL
, &error
) && !error
)
1730 /*********************************************************************
1731 * wcrtomb (MSVCRT.@)
1733 MSVCRT_size_t CDECL
MSVCRT_wcrtomb( char *dst
, MSVCRT_wchar_t ch
, MSVCRT_mbstate_t
*s
)
1737 return MSVCRT_wctomb(dst
, ch
);
1740 /*********************************************************************
1741 * iswalnum (MSVCRT.@)
1743 INT CDECL
MSVCRT_iswalnum( MSVCRT_wchar_t wc
)
1745 return isalnumW( wc
);
1748 /*********************************************************************
1749 * iswalpha (MSVCRT.@)
1751 INT CDECL
MSVCRT_iswalpha( MSVCRT_wchar_t wc
)
1753 return isalphaW( wc
);
1756 /*********************************************************************
1757 * iswalpha_l (MSVCRT.@)
1759 INT CDECL
MSVCRT__iswalpha_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1761 return isalphaW( wc
);
1764 /*********************************************************************
1765 * iswcntrl (MSVCRT.@)
1767 INT CDECL
MSVCRT_iswcntrl( MSVCRT_wchar_t wc
)
1769 return iscntrlW( wc
);
1772 /*********************************************************************
1773 * iswdigit (MSVCRT.@)
1775 INT CDECL
MSVCRT_iswdigit( MSVCRT_wchar_t wc
)
1777 return isdigitW( wc
);
1780 /*********************************************************************
1781 * _iswdigit_l (MSVCRT.@)
1783 INT CDECL
MSVCRT__iswdigit_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1785 return isdigitW( wc
);
1788 /*********************************************************************
1789 * iswgraph (MSVCRT.@)
1791 INT CDECL
MSVCRT_iswgraph( MSVCRT_wchar_t wc
)
1793 return isgraphW( wc
);
1796 /*********************************************************************
1797 * iswlower (MSVCRT.@)
1799 INT CDECL
MSVCRT_iswlower( MSVCRT_wchar_t wc
)
1801 return islowerW( wc
);
1804 /*********************************************************************
1805 * iswprint (MSVCRT.@)
1807 INT CDECL
MSVCRT_iswprint( MSVCRT_wchar_t wc
)
1809 return isprintW( wc
);
1812 /*********************************************************************
1813 * _iswpunct_l (MSVCRT.@)
1815 INT CDECL
MSVCRT__iswpunct_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1817 return ispunctW( wc
);
1820 /*********************************************************************
1821 * iswpunct (MSVCRT.@)
1823 INT CDECL
MSVCRT_iswpunct( MSVCRT_wchar_t wc
)
1825 return ispunctW( wc
);
1828 /*********************************************************************
1829 * _iswspace_l (MSVCRT.@)
1831 INT CDECL
MSVCRT__iswspace_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1833 return isspaceW( wc
);
1836 /*********************************************************************
1837 * iswspace (MSVCRT.@)
1839 INT CDECL
MSVCRT_iswspace( MSVCRT_wchar_t wc
)
1841 return isspaceW( wc
);
1844 /*********************************************************************
1845 * iswupper (MSVCRT.@)
1847 INT CDECL
MSVCRT_iswupper( MSVCRT_wchar_t wc
)
1849 return isupperW( wc
);
1852 /*********************************************************************
1853 * iswxdigit (MSVCRT.@)
1855 INT CDECL
MSVCRT_iswxdigit( MSVCRT_wchar_t wc
)
1857 return isxdigitW( wc
);
1860 /*********************************************************************
1861 * wcscpy_s (MSVCRT.@)
1863 INT CDECL
MSVCRT_wcscpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
)
1865 MSVCRT_size_t size
= 0;
1867 if(!MSVCRT_CHECK_PMT(wcDest
)) return MSVCRT_EINVAL
;
1868 if(!MSVCRT_CHECK_PMT(numElement
)) return MSVCRT_EINVAL
;
1872 if(!MSVCRT_CHECK_PMT(wcSrc
)) return MSVCRT_EINVAL
;
1874 size
= strlenW(wcSrc
) + 1;
1876 if(!MSVCRT_CHECK_PMT_ERR(size
<= numElement
, MSVCRT_ERANGE
))
1877 return MSVCRT_ERANGE
;
1879 memcpy( wcDest
, wcSrc
, size
*sizeof(WCHAR
) );
1884 /******************************************************************
1885 * wcsncpy (MSVCRT.@)
1887 MSVCRT_wchar_t
* __cdecl
MSVCRT_wcsncpy( MSVCRT_wchar_t
* s1
,
1888 const MSVCRT_wchar_t
*s2
, MSVCRT_size_t n
)
1893 if(!(s1
[i
] = s2
[i
])) break;
1899 /******************************************************************
1900 * wcsncpy_s (MSVCRT.@)
1902 INT CDECL
MSVCRT_wcsncpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
,
1903 MSVCRT_size_t count
)
1906 BOOL truncate
= (count
== MSVCRT__TRUNCATE
);
1908 if(!wcDest
&& !numElement
&& !count
)
1911 if (!wcDest
|| !numElement
)
1912 return MSVCRT_EINVAL
;
1917 return count
? MSVCRT_EINVAL
: 0;
1920 while (numElement
&& count
&& *wcSrc
)
1926 if (!numElement
&& truncate
)
1929 return MSVCRT_STRUNCATE
;
1931 else if (!numElement
)
1934 return MSVCRT_ERANGE
;
1941 /******************************************************************
1942 * wcscat_s (MSVCRT.@)
1945 INT CDECL
MSVCRT_wcscat_s(MSVCRT_wchar_t
* dst
, MSVCRT_size_t elem
, const MSVCRT_wchar_t
* src
)
1947 MSVCRT_wchar_t
* ptr
= dst
;
1949 if (!dst
|| elem
== 0) return MSVCRT_EINVAL
;
1953 return MSVCRT_EINVAL
;
1956 /* seek to end of dst string (or elem if no end of string is found */
1957 while (ptr
< dst
+ elem
&& *ptr
!= '\0') ptr
++;
1958 while (ptr
< dst
+ elem
)
1960 if ((*ptr
++ = *src
++) == '\0') return 0;
1962 /* not enough space */
1964 return MSVCRT_ERANGE
;
1967 /*********************************************************************
1968 * wcsncat_s (MSVCRT.@)
1971 INT CDECL
MSVCRT_wcsncat_s(MSVCRT_wchar_t
*dst
, MSVCRT_size_t elem
,
1972 const MSVCRT_wchar_t
*src
, MSVCRT_size_t count
)
1974 MSVCRT_size_t srclen
;
1975 MSVCRT_wchar_t dststart
;
1978 if (!MSVCRT_CHECK_PMT(dst
!= NULL
)) return MSVCRT_EINVAL
;
1979 if (!MSVCRT_CHECK_PMT(elem
> 0)) return MSVCRT_EINVAL
;
1980 if (!MSVCRT_CHECK_PMT(src
!= NULL
|| count
== 0)) return MSVCRT_EINVAL
;
1985 for (dststart
= 0; dststart
< elem
; dststart
++)
1987 if (dst
[dststart
] == '\0')
1990 if (dststart
== elem
)
1992 MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n", MSVCRT_EINVAL
);
1993 return MSVCRT_EINVAL
;
1996 if (count
== MSVCRT__TRUNCATE
)
1998 srclen
= strlenW(src
);
1999 if (srclen
>= (elem
- dststart
))
2001 srclen
= elem
- dststart
- 1;
2002 ret
= MSVCRT_STRUNCATE
;
2006 srclen
= min(strlenW(src
), count
);
2007 if (srclen
< (elem
- dststart
))
2009 memcpy(&dst
[dststart
], src
, srclen
*sizeof(MSVCRT_wchar_t
));
2010 dst
[dststart
+srclen
] = '\0';
2013 MSVCRT_INVALID_PMT("dst[elem] is too small", MSVCRT_ERANGE
);
2015 return MSVCRT_ERANGE
;
2018 /*********************************************************************
2019 * _wcstoi64_l (MSVCRT.@)
2021 * FIXME: locale parameter is ignored
2023 __int64 CDECL
MSVCRT__wcstoi64_l(const MSVCRT_wchar_t
*nptr
,
2024 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
2026 BOOL negative
= FALSE
;
2029 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
2031 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
)) return 0;
2032 if (!MSVCRT_CHECK_PMT(base
== 0 || base
>= 2)) return 0;
2033 if (!MSVCRT_CHECK_PMT(base
<= 36)) return 0;
2035 while(isspaceW(*nptr
)) nptr
++;
2040 } else if(*nptr
== '+')
2043 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
2056 MSVCRT_wchar_t cur
= tolowerW(*nptr
);
2059 if(cur
>='0' && cur
<='9') {
2064 if(cur
<'a' || cur
>='a'+base
-10)
2074 if(!negative
&& (ret
>MSVCRT_I64_MAX
/base
|| ret
*base
>MSVCRT_I64_MAX
-v
)) {
2075 ret
= MSVCRT_I64_MAX
;
2076 *MSVCRT__errno() = MSVCRT_ERANGE
;
2077 } else if(negative
&& (ret
<MSVCRT_I64_MIN
/base
|| ret
*base
<MSVCRT_I64_MIN
-v
)) {
2078 ret
= MSVCRT_I64_MIN
;
2079 *MSVCRT__errno() = MSVCRT_ERANGE
;
2085 *endptr
= (MSVCRT_wchar_t
*)nptr
;
2090 /*********************************************************************
2091 * _wcstoi64 (MSVCRT.@)
2093 __int64 CDECL
MSVCRT__wcstoi64(const MSVCRT_wchar_t
*nptr
,
2094 MSVCRT_wchar_t
**endptr
, int base
)
2096 return MSVCRT__wcstoi64_l(nptr
, endptr
, base
, NULL
);
2099 /*********************************************************************
2100 * _wcstol_l (MSVCRT.@)
2102 MSVCRT_long CDECL
MSVCRT__wcstol_l(const MSVCRT_wchar_t
*s
,
2103 MSVCRT_wchar_t
**end
, int base
, MSVCRT__locale_t locale
)
2105 __int64 ret
= MSVCRT__wcstoi64_l(s
, end
, base
, locale
);
2107 if(ret
> MSVCRT_LONG_MAX
) {
2108 ret
= MSVCRT_LONG_MAX
;
2109 *MSVCRT__errno() = MSVCRT_ERANGE
;
2110 }else if(ret
< MSVCRT_LONG_MIN
) {
2111 ret
= MSVCRT_LONG_MIN
;
2112 *MSVCRT__errno() = MSVCRT_ERANGE
;
2117 /*********************************************************************
2118 * _wtoi_l (MSVCRT.@)
2120 int __cdecl
MSVCRT__wtoi_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
2122 __int64 ret
= MSVCRT__wcstoi64_l(str
, NULL
, 10, locale
);
2126 *MSVCRT__errno() = MSVCRT_ERANGE
;
2127 } else if(ret
< INT_MIN
) {
2129 *MSVCRT__errno() = MSVCRT_ERANGE
;
2134 /*********************************************************************
2137 int __cdecl
MSVCRT__wtoi(const MSVCRT_wchar_t
*str
)
2139 return MSVCRT__wtoi_l(str
, NULL
);
2142 /*********************************************************************
2143 * _wtol_l (MSVCRT.@)
2145 MSVCRT_long __cdecl
MSVCRT__wtol_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
2147 __int64 ret
= MSVCRT__wcstoi64_l(str
, NULL
, 10, locale
);
2149 if(ret
> MSVCRT_LONG_MAX
) {
2150 ret
= MSVCRT_LONG_MAX
;
2151 *MSVCRT__errno() = MSVCRT_ERANGE
;
2152 } else if(ret
< MSVCRT_LONG_MIN
) {
2153 ret
= MSVCRT_LONG_MIN
;
2154 *MSVCRT__errno() = MSVCRT_ERANGE
;
2159 /*********************************************************************
2162 MSVCRT_long __cdecl
MSVCRT__wtol(const MSVCRT_wchar_t
*str
)
2164 return MSVCRT__wtol_l(str
, NULL
);
2167 /*********************************************************************
2168 * _wtoll_l (MSVCR120.@)
2170 MSVCRT_longlong __cdecl
MSVCRT__wtoll_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
2172 return MSVCRT__wcstoi64_l(str
, NULL
, 10, locale
);
2175 /*********************************************************************
2176 * _wtoll (MSVCR120.@)
2178 MSVCRT_longlong __cdecl
MSVCRT__wtoll(const MSVCRT_wchar_t
*str
)
2180 return MSVCRT__wtoll_l(str
, NULL
);
2183 /*********************************************************************
2184 * _wcstoui64_l (MSVCRT.@)
2186 * FIXME: locale parameter is ignored
2188 unsigned __int64 CDECL
MSVCRT__wcstoui64_l(const MSVCRT_wchar_t
*nptr
,
2189 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
2191 BOOL negative
= FALSE
;
2192 unsigned __int64 ret
= 0;
2194 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
2196 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
)) return 0;
2197 if (!MSVCRT_CHECK_PMT(base
== 0 || base
>= 2)) return 0;
2198 if (!MSVCRT_CHECK_PMT(base
<= 36)) return 0;
2200 while(isspaceW(*nptr
)) nptr
++;
2205 } else if(*nptr
== '+')
2208 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
2221 MSVCRT_wchar_t cur
= tolowerW(*nptr
);
2224 if(cur
>='0' && cur
<='9') {
2229 if(cur
<'a' || cur
>='a'+base
-10)
2236 if(ret
>MSVCRT_UI64_MAX
/base
|| ret
*base
>MSVCRT_UI64_MAX
-v
) {
2237 ret
= MSVCRT_UI64_MAX
;
2238 *MSVCRT__errno() = MSVCRT_ERANGE
;
2244 *endptr
= (MSVCRT_wchar_t
*)nptr
;
2246 return negative
? -ret
: ret
;
2249 /*********************************************************************
2250 * _wcstoui64 (MSVCRT.@)
2252 unsigned __int64 CDECL
MSVCRT__wcstoui64(const MSVCRT_wchar_t
*nptr
,
2253 MSVCRT_wchar_t
**endptr
, int base
)
2255 return MSVCRT__wcstoui64_l(nptr
, endptr
, base
, NULL
);
2258 /*********************************************************************
2259 * _wcstoul_l (MSVCRT.@)
2261 MSVCRT_ulong __cdecl
MSVCRT__wcstoul_l(const MSVCRT_wchar_t
*s
,
2262 MSVCRT_wchar_t
**end
, int base
, MSVCRT__locale_t locale
)
2264 __int64 ret
= MSVCRT__wcstoui64_l(s
, end
, base
, locale
);
2266 if(ret
> MSVCRT_ULONG_MAX
) {
2267 ret
= MSVCRT_ULONG_MAX
;
2268 *MSVCRT__errno() = MSVCRT_ERANGE
;
2273 /*********************************************************************
2274 * wcstoul (MSVCRT.@)
2276 MSVCRT_ulong __cdecl
MSVCRT_wcstoul(const MSVCRT_wchar_t
*s
, MSVCRT_wchar_t
**end
, int base
)
2278 return MSVCRT__wcstoul_l(s
, end
, base
, NULL
);
2281 /******************************************************************
2282 * wcsnlen (MSVCRT.@)
2284 MSVCRT_size_t CDECL
MSVCRT_wcsnlen(const MSVCRT_wchar_t
*s
, MSVCRT_size_t maxlen
)
2288 for (i
= 0; i
< maxlen
; i
++)
2293 /*********************************************************************
2294 * _towupper_l (MSVCRT.@)
2296 int CDECL
MSVCRT__towupper_l(MSVCRT_wint_t c
, MSVCRT__locale_t locale
)
2301 /*********************************************************************
2302 * towupper (MSVCRT.@)
2304 int CDECL
MSVCRT_towupper(MSVCRT_wint_t c
)
2306 return MSVCRT__towupper_l(c
, NULL
);
2309 /*********************************************************************
2310 * _towlower_l (MSVCRT.@)
2312 int CDECL
MSVCRT__towlower_l(MSVCRT_wint_t c
, MSVCRT__locale_t locale
)
2317 /*********************************************************************
2318 * towlower (MSVCRT.@)
2320 int CDECL
MSVCRT_towlower(MSVCRT_wint_t c
)
2322 return MSVCRT__towlower_l(c
, NULL
);
2325 /*********************************************************************
2328 MSVCRT_wchar_t
* CDECL
MSVCRT_wcschr(const MSVCRT_wchar_t
*str
, MSVCRT_wchar_t ch
)
2330 return strchrW(str
, ch
);
2333 /***********************************************************************
2336 int CDECL
MSVCRT_wcslen(const MSVCRT_wchar_t
*str
)
2338 return strlenW(str
);
2341 /*********************************************************************
2344 MSVCRT_wchar_t
* CDECL
MSVCRT_wcsstr(const MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*sub
)
2346 return strstrW(str
, sub
);
2349 /*********************************************************************
2350 * _wtoi64_l (MSVCRT.@)
2352 __int64 CDECL
MSVCRT__wtoi64_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
2354 ULONGLONG RunningTotal
= 0;
2355 BOOL bMinus
= FALSE
;
2357 while (isspaceW(*str
)) {
2363 } else if (*str
== '-') {
2368 while (*str
>= '0' && *str
<= '9') {
2369 RunningTotal
= RunningTotal
* 10 + *str
- '0';
2373 return bMinus
? -RunningTotal
: RunningTotal
;
2376 /*********************************************************************
2377 * _wtoi64 (MSVCRT.@)
2379 __int64 CDECL
MSVCRT__wtoi64(const MSVCRT_wchar_t
*str
)
2381 return MSVCRT__wtoi64_l(str
, NULL
);
2384 /*********************************************************************
2385 * wcsncmp (MSVCRT.@)
2387 int CDECL
MSVCRT_wcsncmp(const MSVCRT_wchar_t
*str1
, const MSVCRT_wchar_t
*str2
, int n
)
2389 return strncmpW(str1
, str2
, n
);
2392 /*********************************************************************
2393 * _wcsxfrm_l (MSVCRT.@)
2395 MSVCRT_size_t CDECL
MSVCRT__wcsxfrm_l(MSVCRT_wchar_t
*dest
, const MSVCRT_wchar_t
*src
,
2396 MSVCRT_size_t len
, MSVCRT__locale_t locale
)
2398 MSVCRT_pthreadlocinfo locinfo
;
2401 if(!MSVCRT_CHECK_PMT(src
)) return INT_MAX
;
2402 if(!MSVCRT_CHECK_PMT(dest
|| !len
)) return INT_MAX
;
2405 FIXME("len > INT_MAX not supported\n");
2410 locinfo
= get_locinfo();
2412 locinfo
= locale
->locinfo
;
2414 if(!locinfo
->lc_handle
[MSVCRT_LC_COLLATE
]) {
2415 MSVCRT_wcsncpy(dest
, src
, len
);
2416 return strlenW(src
);
2419 ret
= LCMapStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
],
2420 LCMAP_SORTKEY
, src
, -1, NULL
, 0);
2422 if(len
) dest
[0] = 0;
2423 *MSVCRT__errno() = MSVCRT_EILSEQ
;
2426 if(!len
) return ret
-1;
2430 *MSVCRT__errno() = MSVCRT_ERANGE
;
2434 ret
= LCMapStringW(locinfo
->lc_handle
[MSVCRT_LC_COLLATE
],
2435 LCMAP_SORTKEY
, src
, -1, dest
, len
) - 1;
2436 for(i
=ret
; i
>=0; i
--)
2437 dest
[i
] = ((unsigned char*)dest
)[i
];
2441 /*********************************************************************
2442 * wcsxfrm (MSVCRT.@)
2444 MSVCRT_size_t CDECL
MSVCRT_wcsxfrm(MSVCRT_wchar_t
*dest
,
2445 const MSVCRT_wchar_t
*src
, MSVCRT_size_t len
)
2447 return MSVCRT__wcsxfrm_l(dest
, src
, len
, NULL
);