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 /* _get_printf_count_output - not exported in native msvcrt */
44 int CDECL
MSVCRT__get_printf_count_output( void )
46 return n_format_enabled
? 1 : 0;
49 /* _set_printf_count_output - not exported in native msvcrt */
50 int CDECL
MSVCRT__set_printf_count_output( int enable
)
52 BOOL old
= n_format_enabled
;
53 n_format_enabled
= (enable
? TRUE
: FALSE
);
57 /*********************************************************************
60 MSVCRT_wchar_t
* CDECL
MSVCRT__wcsdup( const MSVCRT_wchar_t
* str
)
62 MSVCRT_wchar_t
* ret
= NULL
;
65 int size
= (strlenW(str
) + 1) * sizeof(MSVCRT_wchar_t
);
66 ret
= MSVCRT_malloc( size
);
67 if (ret
) memcpy( ret
, str
, size
);
72 /*********************************************************************
73 * _wcsicoll (MSVCRT.@)
75 INT CDECL
MSVCRT__wcsicoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
)
77 /* FIXME: handle collates */
78 return strcmpiW( str1
, str2
);
81 /*********************************************************************
82 * _wcsnicoll (MSVCRT.@)
84 INT CDECL
MSVCRT__wcsnicoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
, MSVCRT_size_t count
)
86 /* FIXME: handle collates */
87 return strncmpiW( str1
, str2
, count
);
90 /*********************************************************************
93 MSVCRT_wchar_t
* CDECL
MSVCRT__wcsnset( MSVCRT_wchar_t
* str
, MSVCRT_wchar_t c
, MSVCRT_size_t n
)
95 MSVCRT_wchar_t
* ret
= str
;
96 while ((n
-- > 0) && *str
) *str
++ = c
;
100 /*********************************************************************
103 MSVCRT_wchar_t
* CDECL
MSVCRT__wcsrev( MSVCRT_wchar_t
* str
)
105 MSVCRT_wchar_t
* ret
= str
;
106 MSVCRT_wchar_t
* end
= str
+ strlenW(str
) - 1;
109 MSVCRT_wchar_t t
= *end
;
116 /*********************************************************************
119 MSVCRT_wchar_t
* CDECL
MSVCRT__wcsset( MSVCRT_wchar_t
* str
, MSVCRT_wchar_t c
)
121 MSVCRT_wchar_t
* ret
= str
;
122 while (*str
) *str
++ = c
;
126 /******************************************************************
127 * _wcsupr_s_l (MSVCRT.@)
129 int CDECL
MSVCRT__wcsupr_s_l( MSVCRT_wchar_t
* str
, MSVCRT_size_t n
,
130 MSVCRT__locale_t locale
)
132 MSVCRT_wchar_t
* ptr
= str
;
136 if (str
) *str
= '\0';
137 *MSVCRT__errno() = MSVCRT_EINVAL
;
138 return MSVCRT_EINVAL
;
144 /* FIXME: add locale support */
145 *ptr
= toupperW(*ptr
);
149 /* MSDN claims that the function should return and set errno to
150 * ERANGE, which doesn't seem to be true based on the tests. */
152 *MSVCRT__errno() = MSVCRT_EINVAL
;
153 return MSVCRT_EINVAL
;
156 /******************************************************************
157 * _wcsupr_s (MSVCRT.@)
160 INT CDECL
MSVCRT__wcsupr_s( MSVCRT_wchar_t
* str
, MSVCRT_size_t n
)
162 return MSVCRT__wcsupr_s_l( str
, n
, NULL
);
165 /******************************************************************
166 * _wcslwr_s (MSVCRT.@)
168 int CDECL
MSVCRT__wcslwr_s( MSVCRT_wchar_t
* str
, MSVCRT_size_t n
)
170 MSVCRT_wchar_t
* ptr
= str
;
174 if (str
) *str
= '\0';
175 *MSVCRT__errno() = MSVCRT_EINVAL
;
176 return MSVCRT_EINVAL
;
182 *ptr
= tolowerW(*ptr
);
186 /* MSDN claims that the function should return and set errno to
187 * ERANGE, which doesn't seem to be true based on the tests. */
189 *MSVCRT__errno() = MSVCRT_EINVAL
;
190 return MSVCRT_EINVAL
;
193 /*********************************************************************
194 * _wcstod_l - not exported in native msvcrt
196 double CDECL
MSVCRT__wcstod_l(const MSVCRT_wchar_t
* str
, MSVCRT_wchar_t
** end
,
197 MSVCRT__locale_t locale
)
199 MSVCRT_pthreadlocinfo locinfo
;
200 unsigned __int64 d
=0, hlp
;
203 const MSVCRT_wchar_t
*p
;
205 BOOL found_digit
= FALSE
;
207 if (!MSVCRT_CHECK_PMT(str
!= NULL
)) {
208 *MSVCRT__errno() = MSVCRT_EINVAL
;
213 locinfo
= get_locinfo();
215 locinfo
= locale
->locinfo
;
227 while(isdigitW(*p
)) {
229 hlp
= d
*10+*(p
++)-'0';
230 if(d
>MSVCRT_UI64_MAX
/10 || hlp
<d
) {
236 while(isdigitW(*p
)) {
240 if(*p
== *locinfo
->lconv
->decimal_point
)
243 while(isdigitW(*p
)) {
245 hlp
= d
*10+*(p
++)-'0';
246 if(d
>MSVCRT_UI64_MAX
/10 || hlp
<d
)
257 *end
= (MSVCRT_wchar_t
*)str
;
261 if(*p
=='e' || *p
=='E' || *p
=='d' || *p
=='D') {
272 while(isdigitW(*p
)) {
273 if(e
>INT_MAX
/10 || (e
=e
*10+*p
-'0')<0)
279 if(exp
<0 && e
<0 && exp
+e
>=0) exp
= INT_MIN
;
280 else if(exp
>0 && e
>0 && exp
+e
<0) exp
= INT_MAX
;
283 if(*p
=='-' || *p
=='+')
289 fpcontrol
= _control87(0, 0);
290 _control87(MSVCRT__EM_DENORMAL
|MSVCRT__EM_INVALID
|MSVCRT__EM_ZERODIVIDE
291 |MSVCRT__EM_OVERFLOW
|MSVCRT__EM_UNDERFLOW
|MSVCRT__EM_INEXACT
, 0xffffffff);
294 ret
= (double)sign
*d
*pow(10, exp
);
296 ret
= (double)sign
*d
/pow(10, -exp
);
298 _control87(fpcontrol
, 0xffffffff);
300 if((d
&& ret
==0.0) || isinf(ret
))
301 *MSVCRT__errno() = MSVCRT_ERANGE
;
304 *end
= (MSVCRT_wchar_t
*)p
;
309 /*********************************************************************
310 * wcsrtombs_l (INTERNAL)
312 static MSVCRT_size_t CDECL
MSVCRT_wcsrtombs_l(char *mbstr
, const MSVCRT_wchar_t
**wcstr
,
313 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
315 MSVCRT_pthreadlocinfo locinfo
;
316 MSVCRT_size_t tmp
= 0;
320 locinfo
= get_locinfo();
322 locinfo
= locale
->locinfo
;
325 tmp
= WideCharToMultiByte(locinfo
->lc_codepage
, WC_NO_BEST_FIT_CHARS
,
326 *wcstr
, -1, NULL
, 0, NULL
, &used_default
)-1;
334 MSVCRT_size_t i
, size
;
336 size
= WideCharToMultiByte(locinfo
->lc_codepage
, WC_NO_BEST_FIT_CHARS
,
337 *wcstr
, 1, buf
, 3, NULL
, &used_default
);
343 for(i
=0; i
<size
; i
++)
344 mbstr
[tmp
++] = buf
[i
];
355 /*********************************************************************
356 * _wcstombs_l (MSVCRT.@)
358 MSVCRT_size_t CDECL
MSVCRT__wcstombs_l(char *mbstr
, const MSVCRT_wchar_t
*wcstr
,
359 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
361 return MSVCRT_wcsrtombs_l(mbstr
, &wcstr
, count
, locale
);
364 /*********************************************************************
365 * wcstombs (MSVCRT.@)
367 MSVCRT_size_t CDECL
MSVCRT_wcstombs(char *mbstr
, const MSVCRT_wchar_t
*wcstr
,
370 return MSVCRT_wcsrtombs_l(mbstr
, &wcstr
, count
, NULL
);
373 /*********************************************************************
374 * wcsrtombs (MSVCRT.@)
376 MSVCRT_size_t CDECL
MSVCRT_wcsrtombs(char *mbstr
, const MSVCRT_wchar_t
**wcstr
,
377 MSVCRT_size_t count
, MSVCRT_mbstate_t
*mbstate
)
382 return MSVCRT_wcsrtombs_l(mbstr
, wcstr
, count
, NULL
);
385 /*********************************************************************
386 * MSVCRT_wcsrtombs_s_l (INTERNAL)
388 static int MSVCRT_wcsrtombs_s_l(MSVCRT_size_t
*ret
, char *mbstr
,
389 MSVCRT_size_t size
, const MSVCRT_wchar_t
**wcstr
,
390 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
394 if(!mbstr
&& !size
&& wcstr
) {
395 conv
= MSVCRT_wcsrtombs_l(NULL
, wcstr
, 0, locale
);
401 if (!MSVCRT_CHECK_PMT(wcstr
!= NULL
) || !MSVCRT_CHECK_PMT(*wcstr
!= NULL
)
402 || !MSVCRT_CHECK_PMT(mbstr
!= NULL
)) {
405 *MSVCRT__errno() = MSVCRT_EINVAL
;
406 return MSVCRT_EINVAL
;
409 if(count
==MSVCRT__TRUNCATE
|| size
<count
)
414 conv
= MSVCRT_wcsrtombs_l(mbstr
, wcstr
, conv
, locale
);
416 mbstr
[conv
++] = '\0';
417 else if(conv
==size
&& (count
==MSVCRT__TRUNCATE
|| mbstr
[conv
-1]=='\0'))
418 mbstr
[conv
-1] = '\0';
420 MSVCRT_INVALID_PMT("mbstr[size] is too small");
423 *MSVCRT__errno() = MSVCRT_ERANGE
;
424 return MSVCRT_ERANGE
;
432 /*********************************************************************
433 * _wcstombs_s_l (MSVCRT.@)
435 int CDECL
MSVCRT__wcstombs_s_l(MSVCRT_size_t
*ret
, char *mbstr
,
436 MSVCRT_size_t size
, const MSVCRT_wchar_t
*wcstr
,
437 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
439 return MSVCRT_wcsrtombs_s_l(ret
, mbstr
, size
, &wcstr
,count
, locale
);
442 /*********************************************************************
443 * wcstombs_s (MSVCRT.@)
445 int CDECL
MSVCRT_wcstombs_s(MSVCRT_size_t
*ret
, char *mbstr
,
446 MSVCRT_size_t size
, const MSVCRT_wchar_t
*wcstr
, MSVCRT_size_t count
)
448 return MSVCRT_wcsrtombs_s_l(ret
, mbstr
, size
, &wcstr
, count
, NULL
);
451 /*********************************************************************
452 * wcsrtombs_s (MSVCRT.@)
454 int CDECL
MSVCRT_wcsrtombs_s(MSVCRT_size_t
*ret
, char *mbstr
, MSVCRT_size_t size
,
455 const MSVCRT_wchar_t
**wcstr
, MSVCRT_size_t count
, MSVCRT_mbstate_t
*mbstate
)
460 return MSVCRT_wcsrtombs_s_l(ret
, mbstr
, size
, wcstr
, count
, NULL
);
463 /*********************************************************************
466 double CDECL
MSVCRT_wcstod(const MSVCRT_wchar_t
* lpszStr
, MSVCRT_wchar_t
** end
)
468 return MSVCRT__wcstod_l(lpszStr
, end
, NULL
);
471 /*********************************************************************
474 double CDECL
MSVCRT__wtof(const MSVCRT_wchar_t
*str
)
476 return MSVCRT__wcstod_l(str
, NULL
, NULL
);
479 /*********************************************************************
482 double CDECL
MSVCRT__wtof_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
484 return MSVCRT__wcstod_l(str
, NULL
, locale
);
487 /*********************************************************************
488 * arg_clbk_valist (INTERNAL)
490 printf_arg
arg_clbk_valist(void *ctx
, int arg_pos
, int type
, __ms_va_list
*valist
)
495 ret
.get_longlong
= va_arg(*valist
, LONGLONG
);
496 else if(type
== VT_INT
)
497 ret
.get_int
= va_arg(*valist
, int);
498 else if(type
== VT_R8
)
499 ret
.get_double
= va_arg(*valist
, double);
500 else if(type
== VT_PTR
)
501 ret
.get_ptr
= va_arg(*valist
, void*);
503 ERR("Incorrect type\n");
510 /*********************************************************************
511 * arg_clbk_positional (INTERNAL)
513 static printf_arg
arg_clbk_positional(void *ctx
, int pos
, int type
, __ms_va_list
*valist
)
515 printf_arg
*args
= ctx
;
519 /*********************************************************************
520 * _vsnprintf (MSVCRT.@)
522 int CDECL
MSVCRT_vsnprintf( char *str
, MSVCRT_size_t len
,
523 const char *format
, __ms_va_list valist
)
525 static const char nullbyte
= '\0';
526 struct _str_ctx_a ctx
= {len
, str
};
529 ret
= pf_printf_a(puts_clbk_str_a
, &ctx
, format
, NULL
, FALSE
, FALSE
,
530 arg_clbk_valist
, NULL
, &valist
);
531 puts_clbk_str_a(&ctx
, 1, &nullbyte
);
535 /*********************************************************************
536 * _vsnprintf_l (MSVCRT.@)
538 int CDECL
MSVCRT_vsnprintf_l( char *str
, MSVCRT_size_t len
, const char *format
,
539 MSVCRT__locale_t locale
, __ms_va_list valist
)
541 static const char nullbyte
= '\0';
542 struct _str_ctx_a ctx
= {len
, str
};
545 ret
= pf_printf_a(puts_clbk_str_a
, &ctx
, format
, locale
, FALSE
, FALSE
,
546 arg_clbk_valist
, NULL
, &valist
);
547 puts_clbk_str_a(&ctx
, 1, &nullbyte
);
551 /*********************************************************************
552 * _vsnprintf_s_l (MSVCRT.@)
554 int CDECL
MSVCRT_vsnprintf_s_l( char *str
, MSVCRT_size_t sizeOfBuffer
,
555 MSVCRT_size_t count
, const char *format
,
556 MSVCRT__locale_t locale
, __ms_va_list valist
)
558 static const char nullbyte
= '\0';
559 struct _str_ctx_a ctx
;
562 if(sizeOfBuffer
<count
+1 || count
==-1)
569 ret
= pf_printf_a(puts_clbk_str_a
, &ctx
, format
, locale
, FALSE
, TRUE
,
570 arg_clbk_valist
, NULL
, &valist
);
571 puts_clbk_str_a(&ctx
, 1, &nullbyte
);
573 if(ret
<0 || ret
==len
) {
574 if(count
!=MSVCRT__TRUNCATE
&& count
>sizeOfBuffer
) {
575 MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small");
576 *MSVCRT__errno() = MSVCRT_ERANGE
;
577 memset(str
, 0, sizeOfBuffer
);
587 /*********************************************************************
588 * _vsnprintf_s (MSVCRT.@)
590 int CDECL
MSVCRT_vsnprintf_s( char *str
, MSVCRT_size_t sizeOfBuffer
,
591 MSVCRT_size_t count
, const char *format
, __ms_va_list valist
)
593 return MSVCRT_vsnprintf_s_l(str
,sizeOfBuffer
, count
, format
, NULL
, valist
);
596 /*********************************************************************
597 * vsprintf (MSVCRT.@)
599 int CDECL
MSVCRT_vsprintf( char *str
, const char *format
, __ms_va_list valist
)
601 return MSVCRT_vsnprintf(str
, INT_MAX
, format
, valist
);
604 /*********************************************************************
605 * vsprintf_s (MSVCRT.@)
607 int CDECL
MSVCRT_vsprintf_s( char *str
, MSVCRT_size_t num
, const char *format
, __ms_va_list valist
)
609 return MSVCRT_vsnprintf(str
, num
, format
, valist
);
612 /*********************************************************************
613 * _vscprintf (MSVCRT.@)
615 int CDECL
MSVCRT__vscprintf( const char *format
, __ms_va_list valist
)
617 return MSVCRT_vsnprintf( NULL
, INT_MAX
, format
, valist
);
620 /*********************************************************************
621 * _snprintf (MSVCRT.@)
623 int CDECL
MSVCRT__snprintf(char *str
, unsigned int len
, const char *format
, ...)
627 __ms_va_start(valist
, format
);
628 retval
= MSVCRT_vsnprintf(str
, len
, format
, valist
);
633 /*********************************************************************
634 * _snprintf_s (MSVCRT.@)
636 int CDECL
MSVCRT__snprintf_s(char *str
, unsigned int len
, unsigned int count
,
637 const char *format
, ...)
641 __ms_va_start(valist
, format
);
642 retval
= MSVCRT_vsnprintf_s_l(str
, len
, count
, format
, NULL
, valist
);
647 /*********************************************************************
648 * _scprintf (MSVCRT.@)
650 int CDECL
MSVCRT__scprintf(const char *format
, ...)
654 __ms_va_start(valist
, format
);
655 retval
= MSVCRT__vscprintf(format
, valist
);
660 /*********************************************************************
661 * _vsnwprintf (MSVCRT.@)
663 int CDECL
MSVCRT_vsnwprintf(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
664 const MSVCRT_wchar_t
*format
, __ms_va_list valist
)
666 static const MSVCRT_wchar_t nullbyte
= '\0';
667 struct _str_ctx_w ctx
= {len
, str
};
670 ret
= pf_printf_w(puts_clbk_str_w
, &ctx
, format
, NULL
, FALSE
, FALSE
,
671 arg_clbk_valist
, NULL
, &valist
);
672 puts_clbk_str_w(&ctx
, 1, &nullbyte
);
676 /*********************************************************************
677 * _vsnwprintf_l (MSVCRT.@)
679 int CDECL
MSVCRT_vsnwprintf_l(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
680 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
,
683 static const MSVCRT_wchar_t nullbyte
= '\0';
684 struct _str_ctx_w ctx
= {len
, str
};
687 ret
= pf_printf_w(puts_clbk_str_w
, &ctx
, format
, locale
, FALSE
, FALSE
,
688 arg_clbk_valist
, NULL
, &valist
);
689 puts_clbk_str_w(&ctx
, 1, &nullbyte
);
693 /*********************************************************************
694 * _vsnwprintf_s_l (MSVCRT.@)
696 int CDECL
MSVCRT_vsnwprintf_s_l( MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
697 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
,
698 MSVCRT__locale_t locale
, __ms_va_list valist
)
700 static const MSVCRT_wchar_t nullbyte
= '\0';
701 struct _str_ctx_w ctx
;
705 if(count
!=-1 && len
>count
+1)
710 ret
= pf_printf_w(puts_clbk_str_w
, &ctx
, format
, locale
, FALSE
, TRUE
,
711 arg_clbk_valist
, NULL
, &valist
);
712 puts_clbk_str_w(&ctx
, 1, &nullbyte
);
714 if(ret
<0 || ret
==len
) {
715 if(count
!=MSVCRT__TRUNCATE
&& count
>sizeOfBuffer
) {
716 MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small");
717 *MSVCRT__errno() = MSVCRT_ERANGE
;
718 memset(str
, 0, sizeOfBuffer
*sizeof(MSVCRT_wchar_t
));
728 /*********************************************************************
729 * _vsnwprintf_s (MSVCRT.@)
731 int CDECL
MSVCRT_vsnwprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
732 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
, __ms_va_list valist
)
734 return MSVCRT_vsnwprintf_s_l(str
, sizeOfBuffer
, count
,
735 format
, NULL
, valist
);
738 /*********************************************************************
739 * _snwprintf (MSVCRT.@)
741 int CDECL
MSVCRT__snwprintf( MSVCRT_wchar_t
*str
, unsigned int len
, const MSVCRT_wchar_t
*format
, ...)
745 __ms_va_start(valist
, format
);
746 retval
= MSVCRT_vsnwprintf(str
, len
, format
, valist
);
751 /*********************************************************************
752 * _snwprintf_s (MSVCRT.@)
754 int CDECL
MSVCRT__snwprintf_s( MSVCRT_wchar_t
*str
, unsigned int len
, unsigned int count
,
755 const MSVCRT_wchar_t
*format
, ...)
759 __ms_va_start(valist
, format
);
760 retval
= MSVCRT_vsnwprintf_s_l(str
, len
, count
, format
, NULL
, valist
);
765 /*********************************************************************
768 int CDECL
MSVCRT_sprintf( char *str
, const char *format
, ... )
773 __ms_va_start( ap
, format
);
774 r
= MSVCRT_vsnprintf( str
, INT_MAX
, format
, ap
);
779 /*********************************************************************
780 * sprintf_s (MSVCRT.@)
782 int CDECL
MSVCRT_sprintf_s( char *str
, MSVCRT_size_t num
, const char *format
, ... )
787 __ms_va_start( ap
, format
);
788 r
= MSVCRT_vsnprintf( str
, num
, format
, ap
);
793 /*********************************************************************
794 * _scwprintf (MSVCRT.@)
796 int CDECL
MSVCRT__scwprintf( const MSVCRT_wchar_t
*format
, ... )
801 __ms_va_start( ap
, format
);
802 r
= MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, ap
);
807 /*********************************************************************
808 * swprintf (MSVCRT.@)
810 int CDECL
MSVCRT_swprintf( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*format
, ... )
815 __ms_va_start( ap
, format
);
816 r
= MSVCRT_vsnwprintf( str
, INT_MAX
, format
, ap
);
821 /*********************************************************************
822 * swprintf_s (MSVCRT.@)
824 int CDECL
MSVCRT_swprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t numberOfElements
,
825 const MSVCRT_wchar_t
*format
, ... )
830 __ms_va_start(ap
, format
);
831 r
= MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, ap
);
837 /*********************************************************************
838 * _vswprintf (MSVCRT.@)
840 int CDECL
MSVCRT_vswprintf( MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* format
, __ms_va_list args
)
842 return MSVCRT_vsnwprintf( str
, INT_MAX
, format
, args
);
845 /*********************************************************************
846 * _vswprintf (MSVCRT.@)
848 int CDECL
MSVCRT_vswprintf_l( MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* format
,
849 MSVCRT__locale_t locale
, __ms_va_list args
)
851 return MSVCRT_vsnwprintf_l( str
, INT_MAX
, format
, locale
, args
);
854 /*********************************************************************
855 * _vscwprintf (MSVCRT.@)
857 int CDECL
MSVCRT__vscwprintf( const MSVCRT_wchar_t
*format
, __ms_va_list args
)
859 return MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, args
);
862 /*********************************************************************
863 * vswprintf_s (MSVCRT.@)
865 int CDECL
MSVCRT_vswprintf_s(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
866 const MSVCRT_wchar_t
* format
, __ms_va_list args
)
868 return MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, args
);
871 /*********************************************************************
872 * _vswprintf_s_l (MSVCRT.@)
874 int CDECL
MSVCRT_vswprintf_s_l(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
875 const MSVCRT_wchar_t
* format
, MSVCRT__locale_t locale
, __ms_va_list args
)
877 return MSVCRT_vsnwprintf_s_l(str
, numberOfElements
, INT_MAX
,
878 format
, locale
, args
);
881 /*********************************************************************
882 * _vsprintf_p_l (MSVCRT.@)
884 int CDECL
MSVCRT_vsprintf_p_l(char *buffer
, MSVCRT_size_t length
, const char *format
,
885 MSVCRT__locale_t locale
, __ms_va_list args
)
887 static const char nullbyte
= '\0';
888 printf_arg args_ctx
[MSVCRT__ARGMAX
+1];
889 struct _str_ctx_a puts_ctx
= {length
, buffer
};
892 memset(args_ctx
, 0, sizeof(args_ctx
));
894 ret
= create_positional_ctx_a(args_ctx
, format
, args
);
896 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
897 *MSVCRT__errno() = MSVCRT_EINVAL
;
900 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
, FALSE
, TRUE
,
901 arg_clbk_valist
, NULL
, &args
);
903 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
, TRUE
, TRUE
,
904 arg_clbk_positional
, args_ctx
, NULL
);
906 puts_clbk_str_a(&puts_ctx
, 1, &nullbyte
);
910 /*********************************************************************
911 * _vsprintf_p (MSVCRT.@)
913 int CDECL
MSVCRT_vsprintf_p(char *buffer
, MSVCRT_size_t length
,
914 const char *format
, __ms_va_list args
)
916 return MSVCRT_vsprintf_p_l(buffer
, length
, format
, NULL
, args
);
919 /*********************************************************************
920 * _sprintf_p_l (MSVCRT.@)
922 int CDECL
MSVCRT_sprintf_p_l(char *buffer
, MSVCRT_size_t length
,
923 const char *format
, MSVCRT__locale_t locale
, ...)
928 __ms_va_start(valist
, locale
);
929 r
= MSVCRT_vsprintf_p_l(buffer
, length
, format
, locale
, valist
);
935 /*********************************************************************
936 * _vswprintf_p_l (MSVCRT.@)
938 int CDECL
MSVCRT_vswprintf_p_l(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
939 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, __ms_va_list args
)
941 static const MSVCRT_wchar_t nullbyte
= '\0';
942 printf_arg args_ctx
[MSVCRT__ARGMAX
+1];
943 struct _str_ctx_w puts_ctx
= {length
, buffer
};
946 memset(args_ctx
, 0, sizeof(args_ctx
));
948 ret
= create_positional_ctx_w(args_ctx
, format
, args
);
950 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
951 *MSVCRT__errno() = MSVCRT_EINVAL
;
954 ret
= pf_printf_w(puts_clbk_str_w
, &puts_ctx
, format
, locale
, TRUE
, TRUE
,
955 arg_clbk_valist
, NULL
, &args
);
957 ret
= pf_printf_w(puts_clbk_str_w
, &puts_ctx
, format
, locale
, TRUE
, TRUE
,
958 arg_clbk_positional
, args_ctx
, NULL
);
960 puts_clbk_str_w(&puts_ctx
, 1, &nullbyte
);
964 /*********************************************************************
965 * _swprintf_p_l (MSVCRT.@)
967 int CDECL
MSVCRT_swprintf_p_l(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
968 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, ...)
973 __ms_va_start(valist
, locale
);
974 r
= MSVCRT_vswprintf_p_l(buffer
, length
, format
, locale
, valist
);
980 /*********************************************************************
983 int CDECL
MSVCRT_wcscoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
)
985 /* FIXME: handle collates */
986 return strcmpW( str1
, str2
);
989 /*********************************************************************
992 MSVCRT_wchar_t
* CDECL
MSVCRT_wcspbrk( const MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* accept
)
994 const MSVCRT_wchar_t
* p
;
997 for (p
= accept
; *p
; p
++) if (*p
== *str
) return (MSVCRT_wchar_t
*)str
;
1003 /*********************************************************************
1004 * wcstok_s (MSVCRT.@)
1006 MSVCRT_wchar_t
* CDECL
wcstok_s( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
,
1007 MSVCRT_wchar_t
**next_token
)
1009 MSVCRT_wchar_t
*ret
;
1011 if (!MSVCRT_CHECK_PMT(delim
!= NULL
) || !MSVCRT_CHECK_PMT(next_token
!= NULL
) ||
1012 !MSVCRT_CHECK_PMT(str
!= NULL
|| *next_token
!= NULL
))
1014 *MSVCRT__errno() = MSVCRT_EINVAL
;
1017 if (!str
) str
= *next_token
;
1019 while (*str
&& strchrW( delim
, *str
)) str
++;
1020 if (!*str
) return NULL
;
1022 while (*str
&& !strchrW( delim
, *str
)) str
++;
1023 if (*str
) *str
++ = 0;
1028 /*********************************************************************
1031 MSVCRT_wchar_t
* CDECL
MSVCRT_wcstok( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
)
1033 return wcstok_s(str
, delim
, &msvcrt_get_thread_data()->wcstok_next
);
1036 /*********************************************************************
1039 INT CDECL
MSVCRT_wctob( MSVCRT_wint_t wchar
)
1044 if(WideCharToMultiByte( get_locinfo()->lc_codepage
, 0, &wchar
, 1, &out
, 1, NULL
, &error
) && !error
)
1049 /*********************************************************************
1052 INT CDECL
MSVCRT_wctomb( char *dst
, MSVCRT_wchar_t ch
)
1054 return WideCharToMultiByte( get_locinfo()->lc_codepage
, 0, &ch
, 1, dst
, 6, NULL
, NULL
);
1057 /*********************************************************************
1058 * iswalnum (MSVCRT.@)
1060 INT CDECL
MSVCRT_iswalnum( MSVCRT_wchar_t wc
)
1062 return isalnumW( wc
);
1065 /*********************************************************************
1066 * iswalpha (MSVCRT.@)
1068 INT CDECL
MSVCRT_iswalpha( MSVCRT_wchar_t wc
)
1070 return isalphaW( wc
);
1073 /*********************************************************************
1074 * iswalpha_l (MSVCRT.@)
1076 INT CDECL
MSVCRT__iswalpha_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1078 return isalphaW( wc
);
1081 /*********************************************************************
1082 * iswcntrl (MSVCRT.@)
1084 INT CDECL
MSVCRT_iswcntrl( MSVCRT_wchar_t wc
)
1086 return iscntrlW( wc
);
1089 /*********************************************************************
1090 * iswdigit (MSVCRT.@)
1092 INT CDECL
MSVCRT_iswdigit( MSVCRT_wchar_t wc
)
1094 return isdigitW( wc
);
1097 /*********************************************************************
1098 * iswgraph (MSVCRT.@)
1100 INT CDECL
MSVCRT_iswgraph( MSVCRT_wchar_t wc
)
1102 return isgraphW( wc
);
1105 /*********************************************************************
1106 * iswlower (MSVCRT.@)
1108 INT CDECL
MSVCRT_iswlower( MSVCRT_wchar_t wc
)
1110 return islowerW( wc
);
1113 /*********************************************************************
1114 * iswprint (MSVCRT.@)
1116 INT CDECL
MSVCRT_iswprint( MSVCRT_wchar_t wc
)
1118 return isprintW( wc
);
1121 /*********************************************************************
1122 * iswpunct (MSVCRT.@)
1124 INT CDECL
MSVCRT_iswpunct( MSVCRT_wchar_t wc
)
1126 return ispunctW( wc
);
1129 /*********************************************************************
1130 * iswspace (MSVCRT.@)
1132 INT CDECL
MSVCRT_iswspace( MSVCRT_wchar_t wc
)
1134 return isspaceW( wc
);
1137 /*********************************************************************
1138 * iswupper (MSVCRT.@)
1140 INT CDECL
MSVCRT_iswupper( MSVCRT_wchar_t wc
)
1142 return isupperW( wc
);
1145 /*********************************************************************
1146 * iswxdigit (MSVCRT.@)
1148 INT CDECL
MSVCRT_iswxdigit( MSVCRT_wchar_t wc
)
1150 return isxdigitW( wc
);
1153 /*********************************************************************
1154 * wcscpy_s (MSVCRT.@)
1156 INT CDECL
MSVCRT_wcscpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
)
1158 MSVCRT_size_t size
= 0;
1160 if(!wcDest
|| !numElement
)
1161 return MSVCRT_EINVAL
;
1167 return MSVCRT_EINVAL
;
1170 size
= strlenW(wcSrc
) + 1;
1172 if(size
> numElement
)
1174 return MSVCRT_ERANGE
;
1177 memcpy( wcDest
, wcSrc
, size
*sizeof(WCHAR
) );
1182 /******************************************************************
1183 * wcsncpy_s (MSVCRT.@)
1185 INT CDECL
MSVCRT_wcsncpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
,
1186 MSVCRT_size_t count
)
1188 MSVCRT_size_t size
= 0;
1190 if (!wcDest
|| !numElement
)
1191 return MSVCRT_EINVAL
;
1197 return MSVCRT_EINVAL
;
1200 size
= min(strlenW(wcSrc
), count
);
1202 if (size
>= numElement
)
1204 return MSVCRT_ERANGE
;
1207 memcpy( wcDest
, wcSrc
, size
*sizeof(WCHAR
) );
1208 wcDest
[size
] = '\0';
1213 /******************************************************************
1214 * wcscat_s (MSVCRT.@)
1217 INT CDECL
MSVCRT_wcscat_s(MSVCRT_wchar_t
* dst
, MSVCRT_size_t elem
, const MSVCRT_wchar_t
* src
)
1219 MSVCRT_wchar_t
* ptr
= dst
;
1221 if (!dst
|| elem
== 0) return MSVCRT_EINVAL
;
1225 return MSVCRT_EINVAL
;
1228 /* seek to end of dst string (or elem if no end of string is found */
1229 while (ptr
< dst
+ elem
&& *ptr
!= '\0') ptr
++;
1230 while (ptr
< dst
+ elem
)
1232 if ((*ptr
++ = *src
++) == '\0') return 0;
1234 /* not enough space */
1236 return MSVCRT_ERANGE
;
1239 /*********************************************************************
1240 * wcsncat_s (MSVCRT.@)
1243 INT CDECL
MSVCRT_wcsncat_s(MSVCRT_wchar_t
*dst
, MSVCRT_size_t elem
,
1244 const MSVCRT_wchar_t
*src
, MSVCRT_size_t count
)
1246 MSVCRT_size_t srclen
;
1247 MSVCRT_wchar_t dststart
;
1250 if (!MSVCRT_CHECK_PMT(dst
!= NULL
) || !MSVCRT_CHECK_PMT(elem
> 0))
1252 *MSVCRT__errno() = MSVCRT_EINVAL
;
1253 return MSVCRT_EINVAL
;
1255 if (!MSVCRT_CHECK_PMT(src
!= NULL
|| count
== 0))
1256 return MSVCRT_EINVAL
;
1260 for (dststart
= 0; dststart
< elem
; dststart
++)
1262 if (dst
[dststart
] == '\0')
1265 if (dststart
== elem
)
1267 MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n");
1268 return MSVCRT_EINVAL
;
1271 if (count
== MSVCRT__TRUNCATE
)
1273 srclen
= strlenW(src
);
1274 if (srclen
>= (elem
- dststart
))
1276 srclen
= elem
- dststart
- 1;
1277 ret
= MSVCRT_STRUNCATE
;
1281 srclen
= min(strlenW(src
), count
);
1282 if (srclen
< (elem
- dststart
))
1284 memcpy(&dst
[dststart
], src
, srclen
*sizeof(MSVCRT_wchar_t
));
1285 dst
[dststart
+srclen
] = '\0';
1288 MSVCRT_INVALID_PMT("dst[elem] is too small");
1290 return MSVCRT_ERANGE
;
1293 /*********************************************************************
1294 * _wcstoi64_l (MSVCRT.@)
1296 * FIXME: locale parameter is ignored
1298 __int64 CDECL
MSVCRT__wcstoi64_l(const MSVCRT_wchar_t
*nptr
,
1299 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
1301 BOOL negative
= FALSE
;
1304 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
1306 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
) || !MSVCRT_CHECK_PMT(base
== 0 || base
>= 2) ||
1307 !MSVCRT_CHECK_PMT(base
<= 36)) {
1308 *MSVCRT__errno() = MSVCRT_EINVAL
;
1312 while(isspaceW(*nptr
)) nptr
++;
1317 } else if(*nptr
== '+')
1320 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
1333 char cur
= tolowerW(*nptr
);
1341 if(cur
<'a' || cur
>='a'+base
-10)
1351 if(!negative
&& (ret
>MSVCRT_I64_MAX
/base
|| ret
*base
>MSVCRT_I64_MAX
-v
)) {
1352 ret
= MSVCRT_I64_MAX
;
1353 *MSVCRT__errno() = MSVCRT_ERANGE
;
1354 } else if(negative
&& (ret
<MSVCRT_I64_MIN
/base
|| ret
*base
<MSVCRT_I64_MIN
-v
)) {
1355 ret
= MSVCRT_I64_MIN
;
1356 *MSVCRT__errno() = MSVCRT_ERANGE
;
1362 *endptr
= (MSVCRT_wchar_t
*)nptr
;
1367 /*********************************************************************
1368 * _wcstoi64 (MSVCRT.@)
1370 __int64 CDECL
MSVCRT__wcstoi64(const MSVCRT_wchar_t
*nptr
,
1371 MSVCRT_wchar_t
**endptr
, int base
)
1373 return MSVCRT__wcstoi64_l(nptr
, endptr
, base
, NULL
);
1376 /*********************************************************************
1377 * _wcstoui64_l (MSVCRT.@)
1379 * FIXME: locale parameter is ignored
1381 unsigned __int64 CDECL
MSVCRT__wcstoui64_l(const MSVCRT_wchar_t
*nptr
,
1382 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
1384 BOOL negative
= FALSE
;
1385 unsigned __int64 ret
= 0;
1387 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
1389 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
) || !MSVCRT_CHECK_PMT(base
== 0 || base
>= 2) ||
1390 !MSVCRT_CHECK_PMT(base
<= 36)) {
1391 *MSVCRT__errno() = MSVCRT_EINVAL
;
1395 while(isspaceW(*nptr
)) nptr
++;
1400 } else if(*nptr
== '+')
1403 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
1416 char cur
= tolowerW(*nptr
);
1424 if(cur
<'a' || cur
>='a'+base
-10)
1431 if(ret
>MSVCRT_UI64_MAX
/base
|| ret
*base
>MSVCRT_UI64_MAX
-v
) {
1432 ret
= MSVCRT_UI64_MAX
;
1433 *MSVCRT__errno() = MSVCRT_ERANGE
;
1439 *endptr
= (MSVCRT_wchar_t
*)nptr
;
1441 return negative
? -ret
: ret
;
1444 /*********************************************************************
1445 * _wcstoui64 (MSVCRT.@)
1447 unsigned __int64 CDECL
MSVCRT__wcstoui64(const MSVCRT_wchar_t
*nptr
,
1448 MSVCRT_wchar_t
**endptr
, int base
)
1450 return MSVCRT__wcstoui64_l(nptr
, endptr
, base
, NULL
);
1453 /******************************************************************
1454 * wcsnlen (MSVCRT.@)
1456 MSVCRT_size_t CDECL
MSVCRT_wcsnlen(const MSVCRT_wchar_t
*s
, MSVCRT_size_t maxlen
)
1460 for (i
= 0; i
< maxlen
; i
++)
1465 /*********************************************************************
1466 * _towupper_l (MSVCRT.@)
1468 int CDECL
MSVCRT__towupper_l(MSVCRT_wint_t c
, MSVCRT__locale_t locale
)
1473 /*********************************************************************
1474 * _towlower_l (MSVCRT.@)
1476 int CDECL
MSVCRT__towlower_l(MSVCRT_wint_t c
, MSVCRT__locale_t locale
)