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"
30 #include "wine/unicode.h"
31 #include "wine/debug.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt
);
36 /*********************************************************************
39 MSVCRT_wchar_t
* CDECL
_wcsdup( const MSVCRT_wchar_t
* str
)
41 MSVCRT_wchar_t
* ret
= NULL
;
44 int size
= (strlenW(str
) + 1) * sizeof(MSVCRT_wchar_t
);
45 ret
= MSVCRT_malloc( size
);
46 if (ret
) memcpy( ret
, str
, size
);
51 /*********************************************************************
52 * _wcsicoll (MSVCRT.@)
54 INT CDECL
_wcsicoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
)
56 /* FIXME: handle collates */
57 return strcmpiW( str1
, str2
);
60 /*********************************************************************
61 * _wcsnicoll (MSVCRT.@)
63 INT CDECL
_wcsnicoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
, MSVCRT_size_t count
)
65 /* FIXME: handle collates */
66 return strncmpiW( str1
, str2
, count
);
69 /*********************************************************************
72 MSVCRT_wchar_t
* CDECL
MSVCRT__wcsnset( MSVCRT_wchar_t
* str
, MSVCRT_wchar_t c
, MSVCRT_size_t n
)
74 MSVCRT_wchar_t
* ret
= str
;
75 while ((n
-- > 0) && *str
) *str
++ = c
;
79 /*********************************************************************
82 MSVCRT_wchar_t
* CDECL
_wcsrev( MSVCRT_wchar_t
* str
)
84 MSVCRT_wchar_t
* ret
= str
;
85 MSVCRT_wchar_t
* end
= str
+ strlenW(str
) - 1;
88 MSVCRT_wchar_t t
= *end
;
95 /*********************************************************************
98 MSVCRT_wchar_t
* CDECL
_wcsset( MSVCRT_wchar_t
* str
, MSVCRT_wchar_t c
)
100 MSVCRT_wchar_t
* ret
= str
;
101 while (*str
) *str
++ = c
;
105 /******************************************************************
106 * _wcsupr_s_l (MSVCRT.@)
108 int CDECL
MSVCRT__wcsupr_s_l( MSVCRT_wchar_t
* str
, MSVCRT_size_t n
,
109 MSVCRT__locale_t locale
)
111 MSVCRT_wchar_t
* ptr
= str
;
115 if (str
) *str
= '\0';
116 *MSVCRT__errno() = MSVCRT_EINVAL
;
117 return MSVCRT_EINVAL
;
123 /* FIXME: add locale support */
124 *ptr
= toupperW(*ptr
);
128 /* MSDN claims that the function should return and set errno to
129 * ERANGE, which doesn't seem to be true based on the tests. */
131 *MSVCRT__errno() = MSVCRT_EINVAL
;
132 return MSVCRT_EINVAL
;
135 /******************************************************************
136 * _wcsupr_s (MSVCRT.@)
139 INT CDECL
MSVCRT__wcsupr_s( MSVCRT_wchar_t
* str
, MSVCRT_size_t n
)
141 return MSVCRT__wcsupr_s_l( str
, n
, NULL
);
144 /******************************************************************
145 * _wcslwr_s (MSVCRT.@)
147 int CDECL
MSVCRT__wcslwr_s( MSVCRT_wchar_t
* str
, MSVCRT_size_t n
)
149 MSVCRT_wchar_t
* ptr
= str
;
153 if (str
) *str
= '\0';
154 *MSVCRT__errno() = MSVCRT_EINVAL
;
155 return MSVCRT_EINVAL
;
161 *ptr
= tolowerW(*ptr
);
165 /* MSDN claims that the function should return and set errno to
166 * ERANGE, which doesn't seem to be true based on the tests. */
168 *MSVCRT__errno() = MSVCRT_EINVAL
;
169 return MSVCRT_EINVAL
;
172 /*********************************************************************
173 * _wcstod_l - not exported in native msvcrt
175 double CDECL
MSVCRT__wcstod_l(const MSVCRT_wchar_t
* str
, MSVCRT_wchar_t
** end
,
176 MSVCRT__locale_t locale
)
178 unsigned __int64 d
=0, hlp
;
181 const MSVCRT_wchar_t
*p
;
183 BOOL found_digit
= FALSE
;
185 if (!MSVCRT_CHECK_PMT(str
!= NULL
)) {
186 *MSVCRT__errno() = MSVCRT_EINVAL
;
191 locale
= get_locale();
203 while(isdigitW(*p
)) {
205 hlp
= d
*10+*(p
++)-'0';
206 if(d
>MSVCRT_UI64_MAX
/10 || hlp
<d
) {
212 while(isdigitW(*p
)) {
216 if(*p
== *locale
->locinfo
->lconv
->decimal_point
)
219 while(isdigitW(*p
)) {
221 hlp
= d
*10+*(p
++)-'0';
222 if(d
>MSVCRT_UI64_MAX
/10 || hlp
<d
)
233 *end
= (MSVCRT_wchar_t
*)str
;
237 if(*p
=='e' || *p
=='E' || *p
=='d' || *p
=='D') {
248 while(isdigitW(*p
)) {
249 if(e
>INT_MAX
/10 || (e
=e
*10+*p
-'0')<0)
255 if(exp
<0 && e
<0 && exp
+e
>=0) exp
= INT_MIN
;
256 else if(exp
>0 && e
>0 && exp
+e
<0) exp
= INT_MAX
;
259 if(*p
=='-' || *p
=='+')
265 fpcontrol
= _control87(0, 0);
266 _control87(MSVCRT__EM_DENORMAL
|MSVCRT__EM_INVALID
|MSVCRT__EM_ZERODIVIDE
267 |MSVCRT__EM_OVERFLOW
|MSVCRT__EM_UNDERFLOW
|MSVCRT__EM_INEXACT
, 0xffffffff);
270 ret
= (double)sign
*d
*pow(10, exp
);
272 ret
= (double)sign
*d
/pow(10, -exp
);
274 _control87(fpcontrol
, 0xffffffff);
276 if((d
&& ret
==0.0) || isinf(ret
))
277 *MSVCRT__errno() = MSVCRT_ERANGE
;
280 *end
= (MSVCRT_wchar_t
*)p
;
285 /*********************************************************************
286 * _wcstombs_l (MSVCRT.@)
288 MSVCRT_size_t CDECL
MSVCRT__wcstombs_l(char *mbstr
, const MSVCRT_wchar_t
*wcstr
,
289 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
291 char default_char
= '\0';
292 MSVCRT_size_t tmp
= 0;
296 locale
= get_locale();
299 return WideCharToMultiByte(locale
->locinfo
->lc_codepage
, WC_NO_BEST_FIT_CHARS
,
300 wcstr
, -1, NULL
, 0, &default_char
, &used_default
)-1;
304 MSVCRT_size_t i
, size
;
306 size
= WideCharToMultiByte(locale
->locinfo
->lc_codepage
, WC_NO_BEST_FIT_CHARS
,
307 wcstr
, 1, buf
, 3, &default_char
, &used_default
);
313 for(i
=0; i
<size
; i
++)
314 mbstr
[tmp
++] = buf
[i
];
323 /*********************************************************************
324 * wcstombs (MSVCRT.@)
326 MSVCRT_size_t CDECL
MSVCRT_wcstombs(char *mbstr
, const MSVCRT_wchar_t
*wcstr
,
329 return MSVCRT__wcstombs_l(mbstr
, wcstr
, count
, NULL
);
332 /*********************************************************************
333 * _wcstombs_s_l (MSVCRT.@)
335 MSVCRT_size_t CDECL
MSVCRT__wcstombs_s_l(MSVCRT_size_t
*ret
, char *mbstr
,
336 MSVCRT_size_t size
, const MSVCRT_wchar_t
*wcstr
,
337 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
341 if(!mbstr
&& !size
) {
342 conv
= MSVCRT__wcstombs_l(NULL
, wcstr
, 0, locale
);
348 if (!MSVCRT_CHECK_PMT(wcstr
!= NULL
) || !MSVCRT_CHECK_PMT(mbstr
!= NULL
)) {
351 *MSVCRT__errno() = MSVCRT_EINVAL
;
352 return MSVCRT_EINVAL
;
355 if(count
==MSVCRT__TRUNCATE
|| size
<count
)
360 conv
= MSVCRT__wcstombs_l(mbstr
, wcstr
, conv
, locale
);
362 mbstr
[conv
++] = '\0';
363 else if(conv
==size
&& (count
==MSVCRT__TRUNCATE
|| mbstr
[conv
-1]=='\0'))
364 mbstr
[conv
-1] = '\0';
366 MSVCRT_INVALID_PMT("mbstr[size] is too small");
369 *MSVCRT__errno() = MSVCRT_ERANGE
;
370 return MSVCRT_ERANGE
;
378 /*********************************************************************
379 * wcstombs_s (MSVCRT.@)
381 MSVCRT_size_t CDECL
MSVCRT_wcstombs_s(MSVCRT_size_t
*ret
, char *mbstr
,
382 MSVCRT_size_t size
, const MSVCRT_wchar_t
*wcstr
, MSVCRT_size_t count
)
384 return MSVCRT__wcstombs_s_l(ret
, mbstr
, size
, wcstr
, count
, NULL
);
387 /*********************************************************************
390 double CDECL
MSVCRT_wcstod(const MSVCRT_wchar_t
* lpszStr
, MSVCRT_wchar_t
** end
)
392 return MSVCRT__wcstod_l(lpszStr
, end
, NULL
);
395 /*********************************************************************
398 double CDECL
MSVCRT__wtof(const MSVCRT_wchar_t
*str
)
400 return MSVCRT__wcstod_l(str
, NULL
, NULL
);
403 /*********************************************************************
406 double CDECL
MSVCRT__wtof_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
408 return MSVCRT__wcstod_l(str
, NULL
, locale
);
411 typedef struct pf_flags_t
413 char Sign
, LeftAlign
, Alternate
, PadZero
;
414 int FieldLength
, Precision
;
415 char IntegerLength
, IntegerDouble
;
420 static inline BOOL
pf_is_auto_grow(pf_output
*out
)
422 return (out
->unicode
) ? !!out
->grow
.W
: !!out
->grow
.A
;
425 static inline int pf_check_auto_grow(pf_output
*out
, unsigned delta
)
427 if (pf_is_auto_grow(out
) && out
->used
+ delta
> out
->len
)
429 out
->len
= max(out
->len
* 2, out
->used
+ delta
);
434 if (out
->buf
.W
!= out
->grow
.W
)
436 if (!(ptr
= MSVCRT_realloc(out
->buf
.W
, out
->len
* sizeof(WCHAR
))))
441 if (!(ptr
= MSVCRT_malloc(out
->len
* sizeof(WCHAR
))))
443 memcpy(ptr
, out
->buf
.W
, out
->used
* sizeof(WCHAR
));
452 if (out
->buf
.A
!= out
->grow
.A
)
454 if (!(ptr
= MSVCRT_realloc(out
->buf
.A
, out
->len
* sizeof(char))))
459 if (!(ptr
= MSVCRT_malloc(out
->len
* sizeof(char))))
461 memcpy(ptr
, out
->buf
.A
, out
->used
* sizeof(char));
471 * writes a string of characters to the output
472 * returns -1 if the string doesn't fit in the output buffer
473 * return the length of the string if all characters were written
475 static inline int pf_output_stringW( pf_output
*out
, LPCWSTR str
, int len
)
480 len
= strlenW( str
);
485 if(pf_check_auto_grow(out
, len
) == -1) return -1;
486 space
= out
->len
- out
->used
;
487 p
= out
->buf
.W
+ out
->used
;
490 if (out
->buf
.W
) memcpy( p
, str
, len
*sizeof(WCHAR
) );
494 if( space
> 0 && out
->buf
.W
)
495 memcpy( p
, str
, space
*sizeof(WCHAR
) );
500 int n
= WideCharToMultiByte( CP_ACP
, 0, str
, len
, NULL
, 0, NULL
, NULL
);
503 if(pf_check_auto_grow(out
, n
) == -1) return -1;
504 space
= out
->len
- out
->used
;
505 p
= out
->buf
.A
+ out
->used
;
508 if (out
->buf
.A
) WideCharToMultiByte( CP_ACP
, 0, str
, len
, p
, n
, NULL
, NULL
);
512 if( space
> 0 && out
->buf
.A
)
513 WideCharToMultiByte( CP_ACP
, 0, str
, len
, p
, space
, NULL
, NULL
);
519 static inline int pf_output_stringA( pf_output
*out
, LPCSTR str
, int len
)
529 if (pf_check_auto_grow(out
, len
) == -1) return -1;
530 p
= out
->buf
.A
+ out
->used
;
531 space
= out
->len
- out
->used
;
534 if (out
->buf
.A
) memcpy( p
, str
, len
);
538 if( space
> 0 && out
->buf
.A
)
539 memcpy( p
, str
, space
);
544 int n
= MultiByteToWideChar( CP_ACP
, 0, str
, len
, NULL
, 0 );
547 if (pf_check_auto_grow(out
, n
) == -1) return -1;
548 p
= out
->buf
.W
+ out
->used
;
549 space
= out
->len
- out
->used
;
552 if (out
->buf
.W
) MultiByteToWideChar( CP_ACP
, 0, str
, len
, p
, n
);
556 if( space
> 0 && out
->buf
.W
)
557 MultiByteToWideChar( CP_ACP
, 0, str
, len
, p
, space
);
563 /* pf_fill: takes care of signs, alignment, zero and field padding */
564 static inline int pf_fill( pf_output
*out
, int len
, pf_flags
*flags
, char left
)
568 if( flags
->Sign
&& !( flags
->Format
== 'd' || flags
->Format
== 'i' ) )
571 if( left
&& flags
->Sign
)
573 flags
->FieldLength
--;
575 r
= pf_output_stringA( out
, &flags
->Sign
, 1 );
578 if( ( !left
&& flags
->LeftAlign
) ||
579 ( left
&& !flags
->LeftAlign
))
581 for( i
=0; (i
<(flags
->FieldLength
-len
)) && (r
>=0); i
++ )
583 if( left
&& flags
->PadZero
)
584 r
= pf_output_stringA( out
, "0", 1 );
586 r
= pf_output_stringA( out
, " ", 1 );
590 if( left
&& flags
->Sign
&& !flags
->PadZero
)
591 r
= pf_output_stringA( out
, &flags
->Sign
, 1 );
596 static inline int pf_output_format_W( pf_output
*out
, LPCWSTR str
,
597 int len
, pf_flags
*flags
)
602 len
= strlenW( str
);
604 if (flags
->Precision
>= 0 && flags
->Precision
< len
)
605 len
= flags
->Precision
;
607 r
= pf_fill( out
, len
, flags
, 1 );
610 r
= pf_output_stringW( out
, str
, len
);
613 r
= pf_fill( out
, len
, flags
, 0 );
618 static inline int pf_output_format_A( pf_output
*out
, LPCSTR str
,
619 int len
, pf_flags
*flags
)
626 if (flags
->Precision
>= 0 && flags
->Precision
< len
)
627 len
= flags
->Precision
;
629 r
= pf_fill( out
, len
, flags
, 1 );
632 r
= pf_output_stringA( out
, str
, len
);
635 r
= pf_fill( out
, len
, flags
, 0 );
640 static int pf_handle_string_format( pf_output
*out
, const void* str
, int len
,
641 pf_flags
*flags
, BOOL capital_letter
)
643 if(str
== NULL
) /* catch NULL pointer */
644 return pf_output_format_A( out
, "(null)", -1, flags
);
646 /* prefixes take priority over %c,%s vs. %C,%S, so we handle them first */
647 if(flags
->WideString
|| flags
->IntegerLength
== 'l')
648 return pf_output_format_W( out
, str
, len
, flags
);
649 if(flags
->IntegerLength
== 'h')
650 return pf_output_format_A( out
, str
, len
, flags
);
652 /* %s,%c -> chars in ansi functions & wchars in unicode
653 * %S,%C -> wchars in ansi functions & chars in unicode */
654 if( capital_letter
== out
->unicode
) /* either both TRUE or both FALSE */
655 return pf_output_format_A( out
, str
, len
, flags
);
657 return pf_output_format_W( out
, str
, len
, flags
);
660 static inline BOOL
pf_is_integer_format( char fmt
)
662 static const char float_fmts
[] = "diouxX";
665 return strchr( float_fmts
, fmt
) ? TRUE
: FALSE
;
668 static inline BOOL
pf_is_double_format( char fmt
)
670 static const char float_fmts
[] = "aeEfgG";
673 return strchr( float_fmts
, fmt
) ? TRUE
: FALSE
;
676 static inline BOOL
pf_is_valid_format( char fmt
)
678 static const char float_fmts
[] = "acCdeEfgGinouxX";
681 return strchr( float_fmts
, fmt
) ? TRUE
: FALSE
;
684 static void pf_rebuild_format_string( char *p
, pf_flags
*flags
)
689 if( flags
->LeftAlign
)
690 *p
++ = flags
->LeftAlign
;
691 if( flags
->Alternate
)
692 *p
++ = flags
->Alternate
;
694 *p
++ = flags
->PadZero
;
695 if( flags
->FieldLength
)
697 sprintf(p
, "%d", flags
->FieldLength
);
700 if( flags
->Precision
>= 0 )
702 sprintf(p
, ".%d", flags
->Precision
);
705 *p
++ = flags
->Format
;
709 /* pf_integer_conv: prints x to buf, including alternate formats and
710 additional precision digits, but not field characters or the sign */
711 static void pf_integer_conv( char *buf
, int buf_len
, pf_flags
*flags
,
718 char number
[40], *tmp
= number
;
720 if( buf_len
> sizeof number
)
721 tmp
= HeapAlloc( GetProcessHeap(), 0, buf_len
);
724 if( flags
->Format
== 'o' )
726 else if( flags
->Format
== 'x' || flags
->Format
== 'X' )
729 if( flags
->Format
== 'X' )
730 digits
= "0123456789ABCDEFX";
732 digits
= "0123456789abcdefx";
734 if( x
< 0 && ( flags
->Format
== 'd' || flags
->Format
== 'i' ) )
740 /* Do conversion (backwards) */
742 if( x
== 0 && flags
->Precision
)
747 j
= (ULONGLONG
) x
% base
;
748 x
= (ULONGLONG
) x
/ base
;
749 tmp
[i
++] = digits
[j
];
751 k
= flags
->Precision
- i
;
754 if( flags
->Alternate
)
758 tmp
[i
++] = digits
[16];
761 else if( base
== 8 && tmp
[i
-1] != '0' )
765 /* Reverse for buf */
771 /* Adjust precision so pf_fill won't truncate the number later */
772 flags
->Precision
= strlen( buf
);
775 HeapFree( GetProcessHeap(), 0, tmp
);
780 /* pf_fixup_exponent: convert a string containing a 2 digit exponent
781 to 3 digits, accounting for padding, in place. Needed to match
782 the native printf's which always use 3 digits. */
783 static void pf_fixup_exponent( char *buf
)
787 while (tmp
[0] && toupper(tmp
[0]) != 'E')
790 if (tmp
[0] && (tmp
[1] == '+' || tmp
[1] == '-') &&
791 isdigit(tmp
[2]) && isdigit(tmp
[3]))
796 return; /* Exponent already 3 digits */
798 /* We have a 2 digit exponent. Prepend '0' to make it 3 */
806 /* We didn't expand into trailing space, so this string isn't left
807 * justified. Terminate the string and strip a ' ' at the start of
808 * the string if there is one (as there may be if the string is
813 memmove(buf
, buf
+ 1, (tmp
- buf
) + 3);
815 /* Otherwise, we expanded into trailing space -> nothing to do */
819 /*********************************************************************
820 * pf_vsnprintf (INTERNAL)
822 * implements both A and W vsnprintf functions
824 int pf_vsnprintf( pf_output
*out
, const WCHAR
*format
,
825 MSVCRT__locale_t locale
, BOOL valid
, __ms_va_list valist
)
828 LPCWSTR q
, p
= format
;
832 locale
= get_locale();
834 TRACE("format is %s\n",debugstr_w(format
));
837 q
= strchrW( p
, '%' );
839 /* there's no % characters left, output the rest of the string */
842 r
= pf_output_stringW(out
, p
, -1);
849 /* there's characters before the %, output them */
852 r
= pf_output_stringW(out
, p
, q
- p
);
858 /* we must be at a % now, skip over it */
862 /* output a single % character */
865 r
= pf_output_stringW(out
, p
++, 1);
871 /* parse the flags */
872 memset( &flags
, 0, sizeof flags
);
875 if( *p
== '+' || *p
== ' ' )
877 if ( flags
.Sign
!= '+' )
881 flags
.LeftAlign
= *p
;
885 flags
.Alternate
= *p
;
891 /* deal with the field width specifier */
892 flags
.FieldLength
= 0;
895 flags
.FieldLength
= va_arg( valist
, int );
896 if (flags
.FieldLength
< 0)
898 flags
.LeftAlign
= '-';
899 flags
.FieldLength
= -flags
.FieldLength
;
903 else while( isdigit(*p
) )
905 flags
.FieldLength
*= 10;
906 flags
.FieldLength
+= *p
++ - '0';
909 /* deal with precision */
910 flags
.Precision
= -1;
917 flags
.Precision
= va_arg( valist
, int );
920 else while( isdigit(*p
) )
922 flags
.Precision
*= 10;
923 flags
.Precision
+= *p
++ - '0';
927 /* deal with integer width modifier */
930 if( *p
== 'l' && *(p
+1) == 'l' )
932 flags
.IntegerDouble
++;
935 else if( *p
== 'h' || *p
== 'l' || *p
== 'L' )
937 flags
.IntegerLength
= *p
;
942 if( *(p
+1) == '6' && *(p
+2) == '4' )
944 flags
.IntegerDouble
++;
947 else if( *(p
+1) == '3' && *(p
+2) == '2' )
949 else if( isdigit(*(p
+1)) || *(p
+1) == 0 )
955 flags
.WideString
= *p
++;
965 if (flags
.Format
== '$')
967 FIXME("Positional parameters are not supported (%s)\n", wine_dbgstr_w(format
));
970 /* output a string */
971 if( flags
.Format
== 's' || flags
.Format
== 'S' )
972 r
= pf_handle_string_format( out
, va_arg(valist
, const void*), -1,
973 &flags
, (flags
.Format
== 'S') );
975 /* output a single character */
976 else if( flags
.Format
== 'c' || flags
.Format
== 'C' )
978 INT ch
= va_arg( valist
, int );
980 r
= pf_handle_string_format( out
, &ch
, 1, &flags
, (flags
.Format
== 'C') );
983 /* output a pointer */
984 else if( flags
.Format
== 'p' )
987 void *ptr
= va_arg( valist
, void * );
990 if( flags
.Alternate
)
991 sprintf(pointer
, "0X%0*lX", 2 * (int)sizeof(ptr
), (ULONG_PTR
)ptr
);
993 sprintf(pointer
, "%0*lX", 2 * (int)sizeof(ptr
), (ULONG_PTR
)ptr
);
994 r
= pf_output_format_A( out
, pointer
, -1, &flags
);
998 else if( flags
.Format
== 'n' )
1000 int *x
= va_arg(valist
, int *);
1004 /* deal with 64-bit integers */
1005 else if( pf_is_integer_format( flags
.Format
) && flags
.IntegerDouble
)
1007 char number
[40], *x
= number
;
1009 /* Estimate largest possible required buffer size:
1010 * Chooses the larger of the field or precision
1011 * Includes extra bytes: 1 byte for null, 1 byte for sign,
1012 4 bytes for exponent, 2 bytes for alternate formats, 1 byte
1013 for a decimal, and 1 byte for an additional float digit. */
1014 int x_len
= ((flags
.FieldLength
> flags
.Precision
) ?
1015 flags
.FieldLength
: flags
.Precision
) + 10;
1017 if( x_len
>= sizeof number
)
1018 x
= HeapAlloc( GetProcessHeap(), 0, x_len
);
1020 pf_integer_conv( x
, x_len
, &flags
, va_arg(valist
, LONGLONG
) );
1022 r
= pf_output_format_A( out
, x
, -1, &flags
);
1024 HeapFree( GetProcessHeap(), 0, x
);
1027 /* deal with integers and floats using libc's printf */
1028 else if( pf_is_valid_format( flags
.Format
) )
1030 char fmt
[20], number
[40], *x
= number
, *decimal_point
;
1032 /* Estimate largest possible required buffer size:
1033 * Chooses the larger of the field or precision
1034 * Includes extra bytes: 1 byte for null, 1 byte for sign,
1035 4 bytes for exponent, 2 bytes for alternate formats, 1 byte
1036 for a decimal, and 1 byte for an additional float digit. */
1037 int x_len
= ((flags
.FieldLength
> flags
.Precision
) ?
1038 flags
.FieldLength
: flags
.Precision
) + 10;
1040 if( x_len
>= sizeof number
)
1041 x
= HeapAlloc( GetProcessHeap(), 0, x_len
);
1043 pf_rebuild_format_string( fmt
, &flags
);
1045 if( pf_is_double_format( flags
.Format
) )
1047 sprintf( x
, fmt
, va_arg(valist
, double) );
1048 if (toupper(flags
.Format
) == 'E' || toupper(flags
.Format
) == 'G')
1049 pf_fixup_exponent( x
);
1052 sprintf( x
, fmt
, va_arg(valist
, int) );
1054 decimal_point
= strchr(x
, '.');
1056 *decimal_point
= *locale
->locinfo
->lconv
->decimal_point
;
1058 r
= pf_output_stringA( out
, x
, -1 );
1060 HeapFree( GetProcessHeap(), 0, x
);
1068 MSVCRT__invalid_parameter( NULL
, NULL
, NULL
, 0, 0 );
1069 *MSVCRT__errno() = MSVCRT_EINVAL
;
1081 /* check we reached the end, and null terminate the string */
1083 pf_output_stringW( out
, p
, 1 );
1085 return out
->used
- 1;
1088 /*********************************************************************
1089 * vsnprintf_internal (INTERNAL)
1091 static inline int vsnprintf_internal( char *str
, MSVCRT_size_t len
, const char *format
,
1092 MSVCRT__locale_t locale
, BOOL valid
, __ms_va_list valist
)
1095 LPWSTR formatW
= NULL
;
1099 out
.unicode
= FALSE
;
1105 sz
= MultiByteToWideChar( CP_ACP
, 0, format
, -1, NULL
, 0 );
1106 formatW
= HeapAlloc( GetProcessHeap(), 0, sz
*sizeof(WCHAR
) );
1107 MultiByteToWideChar( CP_ACP
, 0, format
, -1, formatW
, sz
);
1109 r
= pf_vsnprintf( &out
, formatW
, locale
, valid
, valist
);
1111 HeapFree( GetProcessHeap(), 0, formatW
);
1116 /*********************************************************************
1117 * _vsnprintf (MSVCRT.@)
1119 int CDECL
MSVCRT_vsnprintf( char *str
, MSVCRT_size_t len
,
1120 const char *format
, __ms_va_list valist
)
1122 return vsnprintf_internal(str
, len
, format
, NULL
, FALSE
, valist
);
1125 /*********************************************************************
1126 * _vsnprintf_l (MSVCRT.@)
1128 int CDECL
MSVCRT_vsnprintf_l( char *str
, MSVCRT_size_t len
, const char *format
,
1129 MSVCRT__locale_t locale
, __ms_va_list valist
)
1131 return vsnprintf_internal(str
, len
, format
, locale
, FALSE
, valist
);
1134 /*********************************************************************
1135 * _vsnprintf_s_l (MSVCRT.@)
1137 int CDECL
MSVCRT_vsnprintf_s_l( char *str
, MSVCRT_size_t sizeOfBuffer
,
1138 MSVCRT_size_t count
, const char *format
,
1139 MSVCRT__locale_t locale
, __ms_va_list valist
)
1143 if(sizeOfBuffer
<count
+1 || count
==-1)
1148 ret
= vsnprintf_internal(str
, len
, format
, locale
, TRUE
, valist
);
1150 if(ret
<0 || ret
==len
) {
1151 if(count
!=MSVCRT__TRUNCATE
&& count
>sizeOfBuffer
) {
1152 MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small");
1153 *MSVCRT__errno() = MSVCRT_ERANGE
;
1154 memset(str
, 0, sizeOfBuffer
);
1164 /*********************************************************************
1165 * _vsnprintf_s (MSVCRT.@)
1167 int CDECL
MSVCRT_vsnprintf_s( char *str
, MSVCRT_size_t sizeOfBuffer
,
1168 MSVCRT_size_t count
, const char *format
, __ms_va_list valist
)
1170 return MSVCRT_vsnprintf_s_l(str
,sizeOfBuffer
, count
, format
, NULL
, valist
);
1173 /*********************************************************************
1174 * vsprintf (MSVCRT.@)
1176 int CDECL
MSVCRT_vsprintf( char *str
, const char *format
, __ms_va_list valist
)
1178 return MSVCRT_vsnprintf(str
, INT_MAX
, format
, valist
);
1181 /*********************************************************************
1182 * vsprintf_s (MSVCRT.@)
1184 int CDECL
MSVCRT_vsprintf_s( char *str
, MSVCRT_size_t num
, const char *format
, __ms_va_list valist
)
1186 return MSVCRT_vsnprintf(str
, num
, format
, valist
);
1189 /*********************************************************************
1190 * _vscprintf (MSVCRT.@)
1192 int CDECL
_vscprintf( const char *format
, __ms_va_list valist
)
1194 return MSVCRT_vsnprintf( NULL
, INT_MAX
, format
, valist
);
1197 /*********************************************************************
1198 * _snprintf (MSVCRT.@)
1200 int CDECL
MSVCRT__snprintf(char *str
, unsigned int len
, const char *format
, ...)
1203 __ms_va_list valist
;
1204 __ms_va_start(valist
, format
);
1205 retval
= MSVCRT_vsnprintf(str
, len
, format
, valist
);
1206 __ms_va_end(valist
);
1210 /*********************************************************************
1211 * _snprintf_s (MSVCRT.@)
1213 int CDECL
MSVCRT__snprintf_s(char *str
, unsigned int len
, unsigned int count
,
1214 const char *format
, ...)
1217 __ms_va_list valist
;
1218 __ms_va_start(valist
, format
);
1219 retval
= MSVCRT_vsnprintf_s_l(str
, len
, count
, format
, NULL
, valist
);
1220 __ms_va_end(valist
);
1224 /*********************************************************************
1225 * _scprintf (MSVCRT.@)
1227 int CDECL
MSVCRT__scprintf(const char *format
, ...)
1230 __ms_va_list valist
;
1231 __ms_va_start(valist
, format
);
1232 retval
= _vscprintf(format
, valist
);
1233 __ms_va_end(valist
);
1237 /*********************************************************************
1238 * vsnwprintf_internal (INTERNAL)
1240 static inline int vsnwprintf_internal(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
1241 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, BOOL valid
,
1242 __ms_va_list valist
)
1252 return pf_vsnprintf( &out
, format
, locale
, valid
, valist
);
1255 /*********************************************************************
1256 * _vsnwprintf (MSVCRT.@)
1258 int CDECL
MSVCRT_vsnwprintf(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
1259 const MSVCRT_wchar_t
*format
, __ms_va_list valist
)
1261 return vsnwprintf_internal(str
, len
, format
, NULL
, FALSE
, valist
);
1264 /*********************************************************************
1265 * _vsnwprintf_l (MSVCRT.@)
1267 int CDECL
MSVCRT_vsnwprintf_l(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
1268 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
,
1269 __ms_va_list valist
)
1271 return vsnwprintf_internal(str
, len
, format
, locale
, FALSE
, valist
);
1274 /*********************************************************************
1275 * _vsnwprintf_s_l (MSVCRT.@)
1277 int CDECL
MSVCRT_vsnwprintf_s_l( MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
1278 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
,
1279 MSVCRT__locale_t locale
, __ms_va_list valist
)
1284 if(count
!=-1 && len
>count
+1)
1287 ret
= vsnwprintf_internal(str
, len
, format
, locale
, TRUE
, valist
);
1289 if(ret
<0 || ret
==len
) {
1290 if(count
!=MSVCRT__TRUNCATE
&& count
>sizeOfBuffer
) {
1291 MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small");
1292 *MSVCRT__errno() = MSVCRT_ERANGE
;
1293 memset(str
, 0, sizeOfBuffer
*sizeof(MSVCRT_wchar_t
));
1303 /*********************************************************************
1304 * _vsnwprintf_s (MSVCRT.@)
1306 int CDECL
MSVCRT_vsnwprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
1307 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
, __ms_va_list valist
)
1309 return MSVCRT_vsnwprintf_s_l(str
, sizeOfBuffer
, count
,
1310 format
, NULL
, valist
);
1313 /*********************************************************************
1314 * _snwprintf (MSVCRT.@)
1316 int CDECL
MSVCRT__snwprintf( MSVCRT_wchar_t
*str
, unsigned int len
, const MSVCRT_wchar_t
*format
, ...)
1319 __ms_va_list valist
;
1320 __ms_va_start(valist
, format
);
1321 retval
= MSVCRT_vsnwprintf(str
, len
, format
, valist
);
1322 __ms_va_end(valist
);
1326 /*********************************************************************
1327 * _snwprintf_s (MSVCRT.@)
1329 int CDECL
MSVCRT__snwprintf_s( MSVCRT_wchar_t
*str
, unsigned int len
, unsigned int count
,
1330 const MSVCRT_wchar_t
*format
, ...)
1333 __ms_va_list valist
;
1334 __ms_va_start(valist
, format
);
1335 retval
= MSVCRT_vsnwprintf_s_l(str
, len
, count
, format
, NULL
, valist
);
1336 __ms_va_end(valist
);
1340 /*********************************************************************
1341 * sprintf (MSVCRT.@)
1343 int CDECL
MSVCRT_sprintf( char *str
, const char *format
, ... )
1348 __ms_va_start( ap
, format
);
1349 r
= MSVCRT_vsnprintf( str
, INT_MAX
, format
, ap
);
1354 /*********************************************************************
1355 * sprintf_s (MSVCRT.@)
1357 int CDECL
MSVCRT_sprintf_s( char *str
, MSVCRT_size_t num
, const char *format
, ... )
1362 __ms_va_start( ap
, format
);
1363 r
= MSVCRT_vsnprintf( str
, num
, format
, ap
);
1368 /*********************************************************************
1369 * _scwprintf (MSVCRT.@)
1371 int CDECL
MSVCRT__scwprintf( const MSVCRT_wchar_t
*format
, ... )
1376 __ms_va_start( ap
, format
);
1377 r
= MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, ap
);
1382 /*********************************************************************
1383 * swprintf (MSVCRT.@)
1385 int CDECL
MSVCRT_swprintf( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*format
, ... )
1390 __ms_va_start( ap
, format
);
1391 r
= MSVCRT_vsnwprintf( str
, INT_MAX
, format
, ap
);
1396 /*********************************************************************
1397 * swprintf_s (MSVCRT.@)
1399 int CDECL
MSVCRT_swprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t numberOfElements
,
1400 const MSVCRT_wchar_t
*format
, ... )
1405 __ms_va_start(ap
, format
);
1406 r
= MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, ap
);
1412 /*********************************************************************
1413 * vswprintf (MSVCRT.@)
1415 int CDECL
MSVCRT_vswprintf( MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* format
, __ms_va_list args
)
1417 return MSVCRT_vsnwprintf( str
, INT_MAX
, format
, args
);
1420 /*********************************************************************
1421 * _vscwprintf (MSVCRT.@)
1423 int CDECL
_vscwprintf( const MSVCRT_wchar_t
*format
, __ms_va_list args
)
1425 return MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, args
);
1428 /*********************************************************************
1429 * vswprintf_s (MSVCRT.@)
1431 int CDECL
MSVCRT_vswprintf_s(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
1432 const MSVCRT_wchar_t
* format
, __ms_va_list args
)
1434 return MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, args
);
1437 /*********************************************************************
1438 * _vswprintf_s_l (MSVCRT.@)
1440 int CDECL
MSVCRT_vswprintf_s_l(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
1441 const MSVCRT_wchar_t
* format
, MSVCRT__locale_t locale
, __ms_va_list args
)
1443 return MSVCRT_vsnwprintf_s_l(str
, numberOfElements
, INT_MAX
,
1444 format
, locale
, args
);
1447 /*********************************************************************
1448 * wcscoll (MSVCRT.@)
1450 int CDECL
MSVCRT_wcscoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
)
1452 /* FIXME: handle collates */
1453 return strcmpW( str1
, str2
);
1456 /*********************************************************************
1457 * wcspbrk (MSVCRT.@)
1459 MSVCRT_wchar_t
* CDECL
MSVCRT_wcspbrk( const MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* accept
)
1461 const MSVCRT_wchar_t
* p
;
1464 for (p
= accept
; *p
; p
++) if (*p
== *str
) return (MSVCRT_wchar_t
*)str
;
1470 /*********************************************************************
1471 * wcstok_s (MSVCRT.@)
1473 MSVCRT_wchar_t
* CDECL
wcstok_s( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
,
1474 MSVCRT_wchar_t
**next_token
)
1476 MSVCRT_wchar_t
*ret
;
1478 if (!MSVCRT_CHECK_PMT(delim
!= NULL
) || !MSVCRT_CHECK_PMT(next_token
!= NULL
) ||
1479 !MSVCRT_CHECK_PMT(str
!= NULL
|| *next_token
!= NULL
))
1481 *MSVCRT__errno() = MSVCRT_EINVAL
;
1484 if (!str
) str
= *next_token
;
1486 while (*str
&& strchrW( delim
, *str
)) str
++;
1487 if (!*str
) return NULL
;
1489 while (*str
&& !strchrW( delim
, *str
)) str
++;
1490 if (*str
) *str
++ = 0;
1495 /*********************************************************************
1498 MSVCRT_wchar_t
* CDECL
MSVCRT_wcstok( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
)
1500 return wcstok_s(str
, delim
, &msvcrt_get_thread_data()->wcstok_next
);
1503 /*********************************************************************
1506 INT CDECL
MSVCRT_wctomb( char *dst
, MSVCRT_wchar_t ch
)
1508 return WideCharToMultiByte( CP_ACP
, 0, &ch
, 1, dst
, 6, NULL
, NULL
);
1511 /*********************************************************************
1512 * iswalnum (MSVCRT.@)
1514 INT CDECL
MSVCRT_iswalnum( MSVCRT_wchar_t wc
)
1516 return isalnumW( wc
);
1519 /*********************************************************************
1520 * iswalpha (MSVCRT.@)
1522 INT CDECL
MSVCRT_iswalpha( MSVCRT_wchar_t wc
)
1524 return isalphaW( wc
);
1527 /*********************************************************************
1528 * iswalpha_l (MSVCRT.@)
1530 INT CDECL
MSVCRT__iswalpha_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1532 return isalphaW( wc
);
1535 /*********************************************************************
1536 * iswcntrl (MSVCRT.@)
1538 INT CDECL
MSVCRT_iswcntrl( MSVCRT_wchar_t wc
)
1540 return iscntrlW( wc
);
1543 /*********************************************************************
1544 * iswdigit (MSVCRT.@)
1546 INT CDECL
MSVCRT_iswdigit( MSVCRT_wchar_t wc
)
1548 return isdigitW( wc
);
1551 /*********************************************************************
1552 * iswgraph (MSVCRT.@)
1554 INT CDECL
MSVCRT_iswgraph( MSVCRT_wchar_t wc
)
1556 return isgraphW( wc
);
1559 /*********************************************************************
1560 * iswlower (MSVCRT.@)
1562 INT CDECL
MSVCRT_iswlower( MSVCRT_wchar_t wc
)
1564 return islowerW( wc
);
1567 /*********************************************************************
1568 * iswprint (MSVCRT.@)
1570 INT CDECL
MSVCRT_iswprint( MSVCRT_wchar_t wc
)
1572 return isprintW( wc
);
1575 /*********************************************************************
1576 * iswpunct (MSVCRT.@)
1578 INT CDECL
MSVCRT_iswpunct( MSVCRT_wchar_t wc
)
1580 return ispunctW( wc
);
1583 /*********************************************************************
1584 * iswspace (MSVCRT.@)
1586 INT CDECL
MSVCRT_iswspace( MSVCRT_wchar_t wc
)
1588 return isspaceW( wc
);
1591 /*********************************************************************
1592 * iswupper (MSVCRT.@)
1594 INT CDECL
MSVCRT_iswupper( MSVCRT_wchar_t wc
)
1596 return isupperW( wc
);
1599 /*********************************************************************
1600 * iswxdigit (MSVCRT.@)
1602 INT CDECL
MSVCRT_iswxdigit( MSVCRT_wchar_t wc
)
1604 return isxdigitW( wc
);
1607 /*********************************************************************
1608 * wcscpy_s (MSVCRT.@)
1610 INT CDECL
MSVCRT_wcscpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
)
1612 MSVCRT_size_t size
= 0;
1614 if(!wcDest
|| !numElement
)
1615 return MSVCRT_EINVAL
;
1621 return MSVCRT_EINVAL
;
1624 size
= strlenW(wcSrc
) + 1;
1626 if(size
> numElement
)
1628 return MSVCRT_ERANGE
;
1631 memcpy( wcDest
, wcSrc
, size
*sizeof(WCHAR
) );
1636 /******************************************************************
1637 * wcsncpy_s (MSVCRT.@)
1639 INT CDECL
MSVCRT_wcsncpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
,
1640 MSVCRT_size_t count
)
1642 MSVCRT_size_t size
= 0;
1644 if (!wcDest
|| !numElement
)
1645 return MSVCRT_EINVAL
;
1651 return MSVCRT_EINVAL
;
1654 size
= min(strlenW(wcSrc
), count
);
1656 if (size
>= numElement
)
1658 return MSVCRT_ERANGE
;
1661 memcpy( wcDest
, wcSrc
, size
*sizeof(WCHAR
) );
1662 wcDest
[size
] = '\0';
1667 /******************************************************************
1668 * wcscat_s (MSVCRT.@)
1671 INT CDECL
MSVCRT_wcscat_s(MSVCRT_wchar_t
* dst
, MSVCRT_size_t elem
, const MSVCRT_wchar_t
* src
)
1673 MSVCRT_wchar_t
* ptr
= dst
;
1675 if (!dst
|| elem
== 0) return MSVCRT_EINVAL
;
1679 return MSVCRT_EINVAL
;
1682 /* seek to end of dst string (or elem if no end of string is found */
1683 while (ptr
< dst
+ elem
&& *ptr
!= '\0') ptr
++;
1684 while (ptr
< dst
+ elem
)
1686 if ((*ptr
++ = *src
++) == '\0') return 0;
1688 /* not enough space */
1690 return MSVCRT_ERANGE
;
1693 /*********************************************************************
1694 * wcsncat_s (MSVCRT.@)
1697 INT CDECL
MSVCRT_wcsncat_s(MSVCRT_wchar_t
*dst
, MSVCRT_size_t elem
,
1698 const MSVCRT_wchar_t
*src
, MSVCRT_size_t count
)
1700 MSVCRT_size_t srclen
;
1701 MSVCRT_wchar_t dststart
;
1704 if (!MSVCRT_CHECK_PMT(dst
!= NULL
) || !MSVCRT_CHECK_PMT(elem
> 0))
1706 *MSVCRT__errno() = MSVCRT_EINVAL
;
1707 return MSVCRT_EINVAL
;
1709 if (!MSVCRT_CHECK_PMT(src
!= NULL
|| count
== 0))
1710 return MSVCRT_EINVAL
;
1714 for (dststart
= 0; dststart
< elem
; dststart
++)
1716 if (dst
[dststart
] == '\0')
1719 if (dststart
== elem
)
1721 MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n");
1722 return MSVCRT_EINVAL
;
1725 if (count
== MSVCRT__TRUNCATE
)
1727 srclen
= strlenW(src
);
1728 if (srclen
>= (elem
- dststart
))
1730 srclen
= elem
- dststart
- 1;
1731 ret
= MSVCRT_STRUNCATE
;
1735 srclen
= min(strlenW(src
), count
);
1736 if (srclen
< (elem
- dststart
))
1738 memcpy(&dst
[dststart
], src
, srclen
*sizeof(MSVCRT_wchar_t
));
1739 dst
[dststart
+srclen
] = '\0';
1742 MSVCRT_INVALID_PMT("dst[elem] is too small");
1744 return MSVCRT_ERANGE
;
1747 /*********************************************************************
1748 * _wcstoi64_l (MSVCRT.@)
1750 * FIXME: locale parameter is ignored
1752 __int64 CDECL
MSVCRT__wcstoi64_l(const MSVCRT_wchar_t
*nptr
,
1753 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
1755 BOOL negative
= FALSE
;
1758 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
1760 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
) || !MSVCRT_CHECK_PMT(base
== 0 || base
>= 2) ||
1761 !MSVCRT_CHECK_PMT(base
<= 36)) {
1762 *MSVCRT__errno() = MSVCRT_EINVAL
;
1766 while(isspaceW(*nptr
)) nptr
++;
1771 } else if(*nptr
== '+')
1774 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
1787 char cur
= tolowerW(*nptr
);
1795 if(cur
<'a' || cur
>='a'+base
-10)
1805 if(!negative
&& (ret
>MSVCRT_I64_MAX
/base
|| ret
*base
>MSVCRT_I64_MAX
-v
)) {
1806 ret
= MSVCRT_I64_MAX
;
1807 *MSVCRT__errno() = MSVCRT_ERANGE
;
1808 } else if(negative
&& (ret
<MSVCRT_I64_MIN
/base
|| ret
*base
<MSVCRT_I64_MIN
-v
)) {
1809 ret
= MSVCRT_I64_MIN
;
1810 *MSVCRT__errno() = MSVCRT_ERANGE
;
1816 *endptr
= (MSVCRT_wchar_t
*)nptr
;
1821 /*********************************************************************
1822 * _wcstoi64 (MSVCRT.@)
1824 __int64 CDECL
MSVCRT__wcstoi64(const MSVCRT_wchar_t
*nptr
,
1825 MSVCRT_wchar_t
**endptr
, int base
)
1827 return MSVCRT__wcstoi64_l(nptr
, endptr
, base
, NULL
);
1830 /*********************************************************************
1831 * _wcstoui64_l (MSVCRT.@)
1833 * FIXME: locale parameter is ignored
1835 unsigned __int64 CDECL
MSVCRT__wcstoui64_l(const MSVCRT_wchar_t
*nptr
,
1836 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
1838 BOOL negative
= FALSE
;
1839 unsigned __int64 ret
= 0;
1841 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
1843 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
) || !MSVCRT_CHECK_PMT(base
== 0 || base
>= 2) ||
1844 !MSVCRT_CHECK_PMT(base
<= 36)) {
1845 *MSVCRT__errno() = MSVCRT_EINVAL
;
1849 while(isspaceW(*nptr
)) nptr
++;
1854 } else if(*nptr
== '+')
1857 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
1870 char cur
= tolowerW(*nptr
);
1878 if(cur
<'a' || cur
>='a'+base
-10)
1885 if(ret
>MSVCRT_UI64_MAX
/base
|| ret
*base
>MSVCRT_UI64_MAX
-v
) {
1886 ret
= MSVCRT_UI64_MAX
;
1887 *MSVCRT__errno() = MSVCRT_ERANGE
;
1893 *endptr
= (MSVCRT_wchar_t
*)nptr
;
1895 return negative
? -ret
: ret
;
1898 /*********************************************************************
1899 * _wcstoui64 (MSVCRT.@)
1901 unsigned __int64 CDECL
MSVCRT__wcstoui64(const MSVCRT_wchar_t
*nptr
,
1902 MSVCRT_wchar_t
**endptr
, int base
)
1904 return MSVCRT__wcstoui64_l(nptr
, endptr
, base
, NULL
);
1907 /******************************************************************
1908 * wcsnlen (MSVCRT.@)
1910 MSVCRT_size_t CDECL
MSVCRT_wcsnlen(const MSVCRT_wchar_t
*s
, MSVCRT_size_t maxlen
)
1914 for (i
= 0; i
< maxlen
; i
++)