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 * _vswprintf_p_l (MSVCRT.@)
696 int CDECL
MSVCRT_vswprintf_p_l(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
697 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, __ms_va_list args
)
699 static const MSVCRT_wchar_t nullbyte
= '\0';
700 printf_arg args_ctx
[MSVCRT__ARGMAX
+1];
701 struct _str_ctx_w puts_ctx
= {length
, buffer
};
704 memset(args_ctx
, 0, sizeof(args_ctx
));
706 ret
= create_positional_ctx_w(args_ctx
, format
, args
);
708 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
709 *MSVCRT__errno() = MSVCRT_EINVAL
;
712 ret
= pf_printf_w(puts_clbk_str_w
, &puts_ctx
, format
, locale
, TRUE
, TRUE
,
713 arg_clbk_valist
, NULL
, &args
);
715 ret
= pf_printf_w(puts_clbk_str_w
, &puts_ctx
, format
, locale
, TRUE
, TRUE
,
716 arg_clbk_positional
, args_ctx
, NULL
);
718 puts_clbk_str_w(&puts_ctx
, 1, &nullbyte
);
722 /*********************************************************************
723 * _vsnwprintf_s_l (MSVCRT.@)
725 int CDECL
MSVCRT_vsnwprintf_s_l( MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
726 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
,
727 MSVCRT__locale_t locale
, __ms_va_list valist
)
729 static const MSVCRT_wchar_t nullbyte
= '\0';
730 struct _str_ctx_w ctx
;
734 if(count
!=-1 && len
>count
+1)
739 ret
= pf_printf_w(puts_clbk_str_w
, &ctx
, format
, locale
, FALSE
, TRUE
,
740 arg_clbk_valist
, NULL
, &valist
);
741 puts_clbk_str_w(&ctx
, 1, &nullbyte
);
743 if(ret
<0 || ret
==len
) {
744 if(count
!=MSVCRT__TRUNCATE
&& count
>sizeOfBuffer
) {
745 MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small");
746 *MSVCRT__errno() = MSVCRT_ERANGE
;
747 memset(str
, 0, sizeOfBuffer
*sizeof(MSVCRT_wchar_t
));
757 /*********************************************************************
758 * _vsnwprintf_s (MSVCRT.@)
760 int CDECL
MSVCRT_vsnwprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
761 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
, __ms_va_list valist
)
763 return MSVCRT_vsnwprintf_s_l(str
, sizeOfBuffer
, count
,
764 format
, NULL
, valist
);
767 /*********************************************************************
768 * _snwprintf (MSVCRT.@)
770 int CDECL
MSVCRT__snwprintf( MSVCRT_wchar_t
*str
, unsigned int len
, const MSVCRT_wchar_t
*format
, ...)
774 __ms_va_start(valist
, format
);
775 retval
= MSVCRT_vsnwprintf(str
, len
, format
, valist
);
780 /*********************************************************************
781 * _snwprintf_s (MSVCRT.@)
783 int CDECL
MSVCRT__snwprintf_s( MSVCRT_wchar_t
*str
, unsigned int len
, unsigned int count
,
784 const MSVCRT_wchar_t
*format
, ...)
788 __ms_va_start(valist
, format
);
789 retval
= MSVCRT_vsnwprintf_s_l(str
, len
, count
, format
, NULL
, valist
);
794 /*********************************************************************
797 int CDECL
MSVCRT_sprintf( char *str
, const char *format
, ... )
802 __ms_va_start( ap
, format
);
803 r
= MSVCRT_vsnprintf( str
, INT_MAX
, format
, ap
);
808 /*********************************************************************
809 * sprintf_s (MSVCRT.@)
811 int CDECL
MSVCRT_sprintf_s( char *str
, MSVCRT_size_t num
, const char *format
, ... )
816 __ms_va_start( ap
, format
);
817 r
= MSVCRT_vsnprintf( str
, num
, format
, ap
);
822 /*********************************************************************
823 * _scwprintf (MSVCRT.@)
825 int CDECL
MSVCRT__scwprintf( const MSVCRT_wchar_t
*format
, ... )
830 __ms_va_start( ap
, format
);
831 r
= MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, ap
);
836 /*********************************************************************
837 * swprintf (MSVCRT.@)
839 int CDECL
MSVCRT_swprintf( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*format
, ... )
844 __ms_va_start( ap
, format
);
845 r
= MSVCRT_vsnwprintf( str
, INT_MAX
, format
, ap
);
850 /*********************************************************************
851 * swprintf_s (MSVCRT.@)
853 int CDECL
MSVCRT_swprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t numberOfElements
,
854 const MSVCRT_wchar_t
*format
, ... )
859 __ms_va_start(ap
, format
);
860 r
= MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, ap
);
866 /*********************************************************************
867 * _vswprintf (MSVCRT.@)
869 int CDECL
MSVCRT_vswprintf( MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* format
, __ms_va_list args
)
871 return MSVCRT_vsnwprintf( str
, INT_MAX
, format
, args
);
874 /*********************************************************************
875 * _vswprintf (MSVCRT.@)
877 int CDECL
MSVCRT_vswprintf_l( MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* format
,
878 MSVCRT__locale_t locale
, __ms_va_list args
)
880 return MSVCRT_vsnwprintf_l( str
, INT_MAX
, format
, locale
, args
);
883 /*********************************************************************
884 * _vscwprintf (MSVCRT.@)
886 int CDECL
MSVCRT__vscwprintf( const MSVCRT_wchar_t
*format
, __ms_va_list args
)
888 return MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, args
);
891 /*********************************************************************
892 * _vscwprintf_l (MSVCRT.@)
894 int CDECL
MSVCRT__vscwprintf_l( const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, __ms_va_list args
)
896 return MSVCRT_vsnwprintf_l( NULL
, INT_MAX
, format
, locale
, args
);
899 /*********************************************************************
900 * _vscwprintf_p_l (MSVCRT.@)
902 int CDECL
MSVCRT__vscwprintf_p_l( const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, __ms_va_list args
)
904 return MSVCRT_vswprintf_p_l( NULL
, INT_MAX
, format
, locale
, args
);
907 /*********************************************************************
908 * vswprintf_s (MSVCRT.@)
910 int CDECL
MSVCRT_vswprintf_s(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
911 const MSVCRT_wchar_t
* format
, __ms_va_list args
)
913 return MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, args
);
916 /*********************************************************************
917 * _vswprintf_s_l (MSVCRT.@)
919 int CDECL
MSVCRT_vswprintf_s_l(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
920 const MSVCRT_wchar_t
* format
, MSVCRT__locale_t locale
, __ms_va_list args
)
922 return MSVCRT_vsnwprintf_s_l(str
, numberOfElements
, INT_MAX
,
923 format
, locale
, args
);
926 /*********************************************************************
927 * _vsprintf_p_l (MSVCRT.@)
929 int CDECL
MSVCRT_vsprintf_p_l(char *buffer
, MSVCRT_size_t length
, const char *format
,
930 MSVCRT__locale_t locale
, __ms_va_list args
)
932 static const char nullbyte
= '\0';
933 printf_arg args_ctx
[MSVCRT__ARGMAX
+1];
934 struct _str_ctx_a puts_ctx
= {length
, buffer
};
937 memset(args_ctx
, 0, sizeof(args_ctx
));
939 ret
= create_positional_ctx_a(args_ctx
, format
, args
);
941 MSVCRT__invalid_parameter(NULL
, NULL
, NULL
, 0, 0);
942 *MSVCRT__errno() = MSVCRT_EINVAL
;
945 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
, FALSE
, TRUE
,
946 arg_clbk_valist
, NULL
, &args
);
948 ret
= pf_printf_a(puts_clbk_str_a
, &puts_ctx
, format
, locale
, TRUE
, TRUE
,
949 arg_clbk_positional
, args_ctx
, NULL
);
951 puts_clbk_str_a(&puts_ctx
, 1, &nullbyte
);
955 /*********************************************************************
956 * _vsprintf_p (MSVCRT.@)
958 int CDECL
MSVCRT_vsprintf_p(char *buffer
, MSVCRT_size_t length
,
959 const char *format
, __ms_va_list args
)
961 return MSVCRT_vsprintf_p_l(buffer
, length
, format
, NULL
, args
);
964 /*********************************************************************
965 * _sprintf_p_l (MSVCRT.@)
967 int CDECL
MSVCRT_sprintf_p_l(char *buffer
, MSVCRT_size_t length
,
968 const char *format
, MSVCRT__locale_t locale
, ...)
973 __ms_va_start(valist
, locale
);
974 r
= MSVCRT_vsprintf_p_l(buffer
, length
, format
, locale
, valist
);
980 /*********************************************************************
981 * _swprintf_p_l (MSVCRT.@)
983 int CDECL
MSVCRT_swprintf_p_l(MSVCRT_wchar_t
*buffer
, MSVCRT_size_t length
,
984 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, ...)
989 __ms_va_start(valist
, locale
);
990 r
= MSVCRT_vswprintf_p_l(buffer
, length
, format
, locale
, valist
);
996 /*********************************************************************
999 int CDECL
MSVCRT_wcscoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
)
1001 /* FIXME: handle collates */
1002 return strcmpW( str1
, str2
);
1005 /*********************************************************************
1006 * wcspbrk (MSVCRT.@)
1008 MSVCRT_wchar_t
* CDECL
MSVCRT_wcspbrk( const MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* accept
)
1010 const MSVCRT_wchar_t
* p
;
1013 for (p
= accept
; *p
; p
++) if (*p
== *str
) return (MSVCRT_wchar_t
*)str
;
1019 /*********************************************************************
1020 * wcstok_s (MSVCRT.@)
1022 MSVCRT_wchar_t
* CDECL
wcstok_s( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
,
1023 MSVCRT_wchar_t
**next_token
)
1025 MSVCRT_wchar_t
*ret
;
1027 if (!MSVCRT_CHECK_PMT(delim
!= NULL
) || !MSVCRT_CHECK_PMT(next_token
!= NULL
) ||
1028 !MSVCRT_CHECK_PMT(str
!= NULL
|| *next_token
!= NULL
))
1030 *MSVCRT__errno() = MSVCRT_EINVAL
;
1033 if (!str
) str
= *next_token
;
1035 while (*str
&& strchrW( delim
, *str
)) str
++;
1036 if (!*str
) return NULL
;
1038 while (*str
&& !strchrW( delim
, *str
)) str
++;
1039 if (*str
) *str
++ = 0;
1044 /*********************************************************************
1047 MSVCRT_wchar_t
* CDECL
MSVCRT_wcstok( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
)
1049 return wcstok_s(str
, delim
, &msvcrt_get_thread_data()->wcstok_next
);
1052 /*********************************************************************
1055 INT CDECL
MSVCRT_wctob( MSVCRT_wint_t wchar
)
1060 if(WideCharToMultiByte( get_locinfo()->lc_codepage
, 0, &wchar
, 1, &out
, 1, NULL
, &error
) && !error
)
1065 /*********************************************************************
1068 INT CDECL
MSVCRT_wctomb( char *dst
, MSVCRT_wchar_t ch
)
1070 return WideCharToMultiByte( get_locinfo()->lc_codepage
, 0, &ch
, 1, dst
, 6, NULL
, NULL
);
1073 /*********************************************************************
1074 * iswalnum (MSVCRT.@)
1076 INT CDECL
MSVCRT_iswalnum( MSVCRT_wchar_t wc
)
1078 return isalnumW( wc
);
1081 /*********************************************************************
1082 * iswalpha (MSVCRT.@)
1084 INT CDECL
MSVCRT_iswalpha( MSVCRT_wchar_t wc
)
1086 return isalphaW( wc
);
1089 /*********************************************************************
1090 * iswalpha_l (MSVCRT.@)
1092 INT CDECL
MSVCRT__iswalpha_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1094 return isalphaW( wc
);
1097 /*********************************************************************
1098 * iswcntrl (MSVCRT.@)
1100 INT CDECL
MSVCRT_iswcntrl( MSVCRT_wchar_t wc
)
1102 return iscntrlW( wc
);
1105 /*********************************************************************
1106 * iswdigit (MSVCRT.@)
1108 INT CDECL
MSVCRT_iswdigit( MSVCRT_wchar_t wc
)
1110 return isdigitW( wc
);
1113 /*********************************************************************
1114 * iswgraph (MSVCRT.@)
1116 INT CDECL
MSVCRT_iswgraph( MSVCRT_wchar_t wc
)
1118 return isgraphW( wc
);
1121 /*********************************************************************
1122 * iswlower (MSVCRT.@)
1124 INT CDECL
MSVCRT_iswlower( MSVCRT_wchar_t wc
)
1126 return islowerW( wc
);
1129 /*********************************************************************
1130 * iswprint (MSVCRT.@)
1132 INT CDECL
MSVCRT_iswprint( MSVCRT_wchar_t wc
)
1134 return isprintW( wc
);
1137 /*********************************************************************
1138 * iswpunct (MSVCRT.@)
1140 INT CDECL
MSVCRT_iswpunct( MSVCRT_wchar_t wc
)
1142 return ispunctW( wc
);
1145 /*********************************************************************
1146 * iswspace (MSVCRT.@)
1148 INT CDECL
MSVCRT_iswspace( MSVCRT_wchar_t wc
)
1150 return isspaceW( wc
);
1153 /*********************************************************************
1154 * iswupper (MSVCRT.@)
1156 INT CDECL
MSVCRT_iswupper( MSVCRT_wchar_t wc
)
1158 return isupperW( wc
);
1161 /*********************************************************************
1162 * iswxdigit (MSVCRT.@)
1164 INT CDECL
MSVCRT_iswxdigit( MSVCRT_wchar_t wc
)
1166 return isxdigitW( wc
);
1169 /*********************************************************************
1170 * wcscpy_s (MSVCRT.@)
1172 INT CDECL
MSVCRT_wcscpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
)
1174 MSVCRT_size_t size
= 0;
1176 if(!wcDest
|| !numElement
)
1177 return MSVCRT_EINVAL
;
1183 return MSVCRT_EINVAL
;
1186 size
= strlenW(wcSrc
) + 1;
1188 if(size
> numElement
)
1190 return MSVCRT_ERANGE
;
1193 memcpy( wcDest
, wcSrc
, size
*sizeof(WCHAR
) );
1198 /******************************************************************
1199 * wcsncpy_s (MSVCRT.@)
1201 INT CDECL
MSVCRT_wcsncpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
,
1202 MSVCRT_size_t count
)
1204 MSVCRT_size_t size
= 0;
1206 if (!wcDest
|| !numElement
)
1207 return MSVCRT_EINVAL
;
1213 return MSVCRT_EINVAL
;
1216 size
= min(strlenW(wcSrc
), count
);
1218 if (size
>= numElement
)
1220 return MSVCRT_ERANGE
;
1223 memcpy( wcDest
, wcSrc
, size
*sizeof(WCHAR
) );
1224 wcDest
[size
] = '\0';
1229 /******************************************************************
1230 * wcscat_s (MSVCRT.@)
1233 INT CDECL
MSVCRT_wcscat_s(MSVCRT_wchar_t
* dst
, MSVCRT_size_t elem
, const MSVCRT_wchar_t
* src
)
1235 MSVCRT_wchar_t
* ptr
= dst
;
1237 if (!dst
|| elem
== 0) return MSVCRT_EINVAL
;
1241 return MSVCRT_EINVAL
;
1244 /* seek to end of dst string (or elem if no end of string is found */
1245 while (ptr
< dst
+ elem
&& *ptr
!= '\0') ptr
++;
1246 while (ptr
< dst
+ elem
)
1248 if ((*ptr
++ = *src
++) == '\0') return 0;
1250 /* not enough space */
1252 return MSVCRT_ERANGE
;
1255 /*********************************************************************
1256 * wcsncat_s (MSVCRT.@)
1259 INT CDECL
MSVCRT_wcsncat_s(MSVCRT_wchar_t
*dst
, MSVCRT_size_t elem
,
1260 const MSVCRT_wchar_t
*src
, MSVCRT_size_t count
)
1262 MSVCRT_size_t srclen
;
1263 MSVCRT_wchar_t dststart
;
1266 if (!MSVCRT_CHECK_PMT(dst
!= NULL
) || !MSVCRT_CHECK_PMT(elem
> 0))
1268 *MSVCRT__errno() = MSVCRT_EINVAL
;
1269 return MSVCRT_EINVAL
;
1271 if (!MSVCRT_CHECK_PMT(src
!= NULL
|| count
== 0))
1272 return MSVCRT_EINVAL
;
1276 for (dststart
= 0; dststart
< elem
; dststart
++)
1278 if (dst
[dststart
] == '\0')
1281 if (dststart
== elem
)
1283 MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n");
1284 return MSVCRT_EINVAL
;
1287 if (count
== MSVCRT__TRUNCATE
)
1289 srclen
= strlenW(src
);
1290 if (srclen
>= (elem
- dststart
))
1292 srclen
= elem
- dststart
- 1;
1293 ret
= MSVCRT_STRUNCATE
;
1297 srclen
= min(strlenW(src
), count
);
1298 if (srclen
< (elem
- dststart
))
1300 memcpy(&dst
[dststart
], src
, srclen
*sizeof(MSVCRT_wchar_t
));
1301 dst
[dststart
+srclen
] = '\0';
1304 MSVCRT_INVALID_PMT("dst[elem] is too small");
1306 return MSVCRT_ERANGE
;
1309 /*********************************************************************
1310 * _wcstoi64_l (MSVCRT.@)
1312 * FIXME: locale parameter is ignored
1314 __int64 CDECL
MSVCRT__wcstoi64_l(const MSVCRT_wchar_t
*nptr
,
1315 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
1317 BOOL negative
= FALSE
;
1320 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
1322 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
) || !MSVCRT_CHECK_PMT(base
== 0 || base
>= 2) ||
1323 !MSVCRT_CHECK_PMT(base
<= 36)) {
1324 *MSVCRT__errno() = MSVCRT_EINVAL
;
1328 while(isspaceW(*nptr
)) nptr
++;
1333 } else if(*nptr
== '+')
1336 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
1349 char cur
= tolowerW(*nptr
);
1357 if(cur
<'a' || cur
>='a'+base
-10)
1367 if(!negative
&& (ret
>MSVCRT_I64_MAX
/base
|| ret
*base
>MSVCRT_I64_MAX
-v
)) {
1368 ret
= MSVCRT_I64_MAX
;
1369 *MSVCRT__errno() = MSVCRT_ERANGE
;
1370 } else if(negative
&& (ret
<MSVCRT_I64_MIN
/base
|| ret
*base
<MSVCRT_I64_MIN
-v
)) {
1371 ret
= MSVCRT_I64_MIN
;
1372 *MSVCRT__errno() = MSVCRT_ERANGE
;
1378 *endptr
= (MSVCRT_wchar_t
*)nptr
;
1383 /*********************************************************************
1384 * _wcstoi64 (MSVCRT.@)
1386 __int64 CDECL
MSVCRT__wcstoi64(const MSVCRT_wchar_t
*nptr
,
1387 MSVCRT_wchar_t
**endptr
, int base
)
1389 return MSVCRT__wcstoi64_l(nptr
, endptr
, base
, NULL
);
1392 /*********************************************************************
1393 * _wcstoui64_l (MSVCRT.@)
1395 * FIXME: locale parameter is ignored
1397 unsigned __int64 CDECL
MSVCRT__wcstoui64_l(const MSVCRT_wchar_t
*nptr
,
1398 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
1400 BOOL negative
= FALSE
;
1401 unsigned __int64 ret
= 0;
1403 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
1405 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
) || !MSVCRT_CHECK_PMT(base
== 0 || base
>= 2) ||
1406 !MSVCRT_CHECK_PMT(base
<= 36)) {
1407 *MSVCRT__errno() = MSVCRT_EINVAL
;
1411 while(isspaceW(*nptr
)) nptr
++;
1416 } else if(*nptr
== '+')
1419 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
1432 char cur
= tolowerW(*nptr
);
1440 if(cur
<'a' || cur
>='a'+base
-10)
1447 if(ret
>MSVCRT_UI64_MAX
/base
|| ret
*base
>MSVCRT_UI64_MAX
-v
) {
1448 ret
= MSVCRT_UI64_MAX
;
1449 *MSVCRT__errno() = MSVCRT_ERANGE
;
1455 *endptr
= (MSVCRT_wchar_t
*)nptr
;
1457 return negative
? -ret
: ret
;
1460 /*********************************************************************
1461 * _wcstoui64 (MSVCRT.@)
1463 unsigned __int64 CDECL
MSVCRT__wcstoui64(const MSVCRT_wchar_t
*nptr
,
1464 MSVCRT_wchar_t
**endptr
, int base
)
1466 return MSVCRT__wcstoui64_l(nptr
, endptr
, base
, NULL
);
1469 /******************************************************************
1470 * wcsnlen (MSVCRT.@)
1472 MSVCRT_size_t CDECL
MSVCRT_wcsnlen(const MSVCRT_wchar_t
*s
, MSVCRT_size_t maxlen
)
1476 for (i
= 0; i
< maxlen
; i
++)
1481 /*********************************************************************
1482 * _towupper_l (MSVCRT.@)
1484 int CDECL
MSVCRT__towupper_l(MSVCRT_wint_t c
, MSVCRT__locale_t locale
)
1489 /*********************************************************************
1490 * _towlower_l (MSVCRT.@)
1492 int CDECL
MSVCRT__towlower_l(MSVCRT_wint_t c
, MSVCRT__locale_t locale
)