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 /*********************************************************************
63 MSVCRT_wchar_t
* CDECL
MSVCRT__wcsnset( MSVCRT_wchar_t
* str
, MSVCRT_wchar_t c
, MSVCRT_size_t n
)
65 MSVCRT_wchar_t
* ret
= str
;
66 while ((n
-- > 0) && *str
) *str
++ = c
;
70 /*********************************************************************
73 MSVCRT_wchar_t
* CDECL
_wcsrev( MSVCRT_wchar_t
* str
)
75 MSVCRT_wchar_t
* ret
= str
;
76 MSVCRT_wchar_t
* end
= str
+ strlenW(str
) - 1;
79 MSVCRT_wchar_t t
= *end
;
86 /*********************************************************************
89 MSVCRT_wchar_t
* CDECL
_wcsset( MSVCRT_wchar_t
* str
, MSVCRT_wchar_t c
)
91 MSVCRT_wchar_t
* ret
= str
;
92 while (*str
) *str
++ = c
;
96 /******************************************************************
97 * _wcsupr_s (MSVCRT.@)
100 INT CDECL
MSVCRT__wcsupr_s( MSVCRT_wchar_t
* str
, MSVCRT_size_t n
)
102 MSVCRT_wchar_t
* ptr
= str
;
106 if (str
) *str
= '\0';
107 *MSVCRT__errno() = MSVCRT_EINVAL
;
108 return MSVCRT_EINVAL
;
114 *ptr
= toupperW(*ptr
);
118 /* MSDN claims that the function should return and set errno to
119 * ERANGE, which doesn't seem to be true based on the tests. */
121 *MSVCRT__errno() = MSVCRT_EINVAL
;
122 return MSVCRT_EINVAL
;
125 /*********************************************************************
126 * _wcstod_l - not exported in native msvcrt
128 double CDECL
MSVCRT__wcstod_l(const MSVCRT_wchar_t
* str
, MSVCRT_wchar_t
** end
,
129 MSVCRT__locale_t locale
)
131 unsigned __int64 d
=0, hlp
;
134 const MSVCRT_wchar_t
*p
;
136 BOOL found_digit
= FALSE
;
138 if (!MSVCRT_CHECK_PMT(str
!= NULL
)) {
139 *MSVCRT__errno() = MSVCRT_EINVAL
;
144 locale
= get_locale();
156 while(isdigitW(*p
)) {
158 hlp
= d
*10+*(p
++)-'0';
159 if(d
>MSVCRT_UI64_MAX
/10 || hlp
<d
) {
165 while(isdigitW(*p
)) {
169 if(*p
== *locale
->locinfo
->lconv
->decimal_point
)
172 while(isdigitW(*p
)) {
174 hlp
= d
*10+*(p
++)-'0';
175 if(d
>MSVCRT_UI64_MAX
/10 || hlp
<d
)
186 *end
= (MSVCRT_wchar_t
*)str
;
190 if(*p
=='e' || *p
=='E' || *p
=='d' || *p
=='D') {
201 while(isdigitW(*p
)) {
202 if(e
>INT_MAX
/10 || (e
=e
*10+*p
-'0')<0)
208 if(exp
<0 && e
<0 && exp
+e
>=0) exp
= INT_MIN
;
209 else if(exp
>0 && e
>0 && exp
+e
<0) exp
= INT_MAX
;
212 if(*p
=='-' || *p
=='+')
218 fpcontrol
= _control87(0, 0);
219 _control87(MSVCRT__EM_DENORMAL
|MSVCRT__EM_INVALID
|MSVCRT__EM_ZERODIVIDE
220 |MSVCRT__EM_OVERFLOW
|MSVCRT__EM_UNDERFLOW
|MSVCRT__EM_INEXACT
, 0xffffffff);
223 ret
= (double)sign
*d
*pow(10, exp
);
225 ret
= (double)sign
*d
/pow(10, -exp
);
227 _control87(fpcontrol
, 0xffffffff);
229 if((d
&& ret
==0.0) || isinf(ret
))
230 *MSVCRT__errno() = MSVCRT_ERANGE
;
233 *end
= (MSVCRT_wchar_t
*)p
;
238 /*********************************************************************
239 * _wcstombs_l (MSVCRT.@)
241 MSVCRT_size_t CDECL
MSVCRT__wcstombs_l(char *mbstr
, const MSVCRT_wchar_t
*wcstr
,
242 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
244 char default_char
= '\0';
245 MSVCRT_size_t tmp
= 0;
249 locale
= get_locale();
252 return WideCharToMultiByte(locale
->locinfo
->lc_codepage
, WC_NO_BEST_FIT_CHARS
,
253 wcstr
, -1, NULL
, 0, &default_char
, &used_default
)-1;
257 MSVCRT_size_t i
, size
;
259 size
= WideCharToMultiByte(locale
->locinfo
->lc_codepage
, WC_NO_BEST_FIT_CHARS
,
260 wcstr
, 1, buf
, 3, &default_char
, &used_default
);
266 for(i
=0; i
<size
; i
++)
267 mbstr
[tmp
++] = buf
[i
];
276 /*********************************************************************
277 * wcstombs (MSVCRT.@)
279 MSVCRT_size_t CDECL
MSVCRT_wcstombs(char *mbstr
, const MSVCRT_wchar_t
*wcstr
,
282 return MSVCRT__wcstombs_l(mbstr
, wcstr
, count
, NULL
);
285 /*********************************************************************
286 * _wcstombs_s_l (MSVCRT.@)
288 MSVCRT_size_t CDECL
MSVCRT__wcstombs_s_l(MSVCRT_size_t
*ret
, char *mbstr
,
289 MSVCRT_size_t size
, const MSVCRT_wchar_t
*wcstr
,
290 MSVCRT_size_t count
, MSVCRT__locale_t locale
)
294 if(!mbstr
&& !size
) {
295 conv
= MSVCRT__wcstombs_l(NULL
, wcstr
, 0, locale
);
301 if (!MSVCRT_CHECK_PMT(wcstr
!= NULL
) || !MSVCRT_CHECK_PMT(mbstr
!= NULL
)) {
304 *MSVCRT__errno() = MSVCRT_EINVAL
;
305 return MSVCRT_EINVAL
;
308 if(count
==MSVCRT__TRUNCATE
|| size
<count
)
313 conv
= MSVCRT__wcstombs_l(mbstr
, wcstr
, conv
, locale
);
315 mbstr
[conv
++] = '\0';
316 else if(conv
==size
&& (count
==MSVCRT__TRUNCATE
|| mbstr
[conv
-1]=='\0'))
317 mbstr
[conv
-1] = '\0';
319 MSVCRT_INVALID_PMT("mbstr[size] is too small");
322 *MSVCRT__errno() = MSVCRT_ERANGE
;
323 return MSVCRT_ERANGE
;
331 /*********************************************************************
332 * wcstombs_s (MSVCRT.@)
334 MSVCRT_size_t CDECL
MSVCRT_wcstombs_s(MSVCRT_size_t
*ret
, char *mbstr
,
335 MSVCRT_size_t size
, const MSVCRT_wchar_t
*wcstr
, MSVCRT_size_t count
)
337 return MSVCRT__wcstombs_s_l(ret
, mbstr
, size
, wcstr
, count
, NULL
);
340 /*********************************************************************
343 double CDECL
MSVCRT_wcstod(const MSVCRT_wchar_t
* lpszStr
, MSVCRT_wchar_t
** end
)
345 return MSVCRT__wcstod_l(lpszStr
, end
, NULL
);
348 /*********************************************************************
351 double CDECL
MSVCRT__wtof(const MSVCRT_wchar_t
*str
)
353 return MSVCRT__wcstod_l(str
, NULL
, NULL
);
356 /*********************************************************************
359 double CDECL
MSVCRT__wtof_l(const MSVCRT_wchar_t
*str
, MSVCRT__locale_t locale
)
361 return MSVCRT__wcstod_l(str
, NULL
, locale
);
364 typedef struct pf_flags_t
366 char Sign
, LeftAlign
, Alternate
, PadZero
;
367 int FieldLength
, Precision
;
368 char IntegerLength
, IntegerDouble
;
373 static inline BOOL
pf_is_auto_grow(pf_output
*out
)
375 return (out
->unicode
) ? !!out
->grow
.W
: !!out
->grow
.A
;
378 static inline int pf_check_auto_grow(pf_output
*out
, unsigned delta
)
380 if (pf_is_auto_grow(out
) && out
->used
+ delta
> out
->len
)
382 out
->len
= max(out
->len
* 2, out
->used
+ delta
);
385 if (out
->buf
.W
!= out
->grow
.W
)
386 out
->buf
.W
= MSVCRT_realloc(out
->buf
.W
, out
->len
* sizeof(WCHAR
));
388 out
->buf
.W
= MSVCRT_malloc(out
->len
* sizeof(WCHAR
));
389 if (!out
->buf
.W
) return -1;
393 if (out
->buf
.A
!= out
->grow
.A
)
394 out
->buf
.A
= MSVCRT_realloc(out
->buf
.A
, out
->len
* sizeof(char));
396 out
->buf
.A
= MSVCRT_malloc(out
->len
* sizeof(char));
397 if (!out
->buf
.A
) return -1;
404 * writes a string of characters to the output
405 * returns -1 if the string doesn't fit in the output buffer
406 * return the length of the string if all characters were written
408 static inline int pf_output_stringW( pf_output
*out
, LPCWSTR str
, int len
)
413 len
= strlenW( str
);
418 if(pf_check_auto_grow(out
, len
) == -1) return -1;
419 space
= out
->len
- out
->used
;
420 p
= out
->buf
.W
+ out
->used
;
423 if (out
->buf
.W
) memcpy( p
, str
, len
*sizeof(WCHAR
) );
427 if( space
> 0 && out
->buf
.W
)
428 memcpy( p
, str
, space
*sizeof(WCHAR
) );
433 int n
= WideCharToMultiByte( CP_ACP
, 0, str
, len
, NULL
, 0, NULL
, NULL
);
436 if(pf_check_auto_grow(out
, n
) == -1) return -1;
437 space
= out
->len
- out
->used
;
438 p
= out
->buf
.A
+ out
->used
;
441 if (out
->buf
.A
) WideCharToMultiByte( CP_ACP
, 0, str
, len
, p
, n
, NULL
, NULL
);
445 if( space
> 0 && out
->buf
.A
)
446 WideCharToMultiByte( CP_ACP
, 0, str
, len
, p
, space
, NULL
, NULL
);
452 static inline int pf_output_stringA( pf_output
*out
, LPCSTR str
, int len
)
462 if (pf_check_auto_grow(out
, len
) == -1) return -1;
463 p
= out
->buf
.A
+ out
->used
;
464 space
= out
->len
- out
->used
;
467 if (out
->buf
.A
) memcpy( p
, str
, len
);
471 if( space
> 0 && out
->buf
.A
)
472 memcpy( p
, str
, space
);
477 int n
= MultiByteToWideChar( CP_ACP
, 0, str
, len
, NULL
, 0 );
480 if (pf_check_auto_grow(out
, n
) == -1) return -1;
481 p
= out
->buf
.W
+ out
->used
;
482 space
= out
->len
- out
->used
;
485 if (out
->buf
.W
) MultiByteToWideChar( CP_ACP
, 0, str
, len
, p
, n
);
489 if( space
> 0 && out
->buf
.W
)
490 MultiByteToWideChar( CP_ACP
, 0, str
, len
, p
, space
);
496 /* pf_fill: takes care of signs, alignment, zero and field padding */
497 static inline int pf_fill( pf_output
*out
, int len
, pf_flags
*flags
, char left
)
501 if( flags
->Sign
&& !( flags
->Format
== 'd' || flags
->Format
== 'i' ) )
504 if( left
&& flags
->Sign
)
506 flags
->FieldLength
--;
508 r
= pf_output_stringA( out
, &flags
->Sign
, 1 );
511 if( ( !left
&& flags
->LeftAlign
) ||
512 ( left
&& !flags
->LeftAlign
))
514 for( i
=0; (i
<(flags
->FieldLength
-len
)) && (r
>=0); i
++ )
516 if( left
&& flags
->PadZero
)
517 r
= pf_output_stringA( out
, "0", 1 );
519 r
= pf_output_stringA( out
, " ", 1 );
523 if( left
&& flags
->Sign
&& !flags
->PadZero
)
524 r
= pf_output_stringA( out
, &flags
->Sign
, 1 );
529 static inline int pf_output_format_W( pf_output
*out
, LPCWSTR str
,
530 int len
, pf_flags
*flags
)
535 len
= strlenW( str
);
537 if (flags
->Precision
>= 0 && flags
->Precision
< len
)
538 len
= flags
->Precision
;
540 r
= pf_fill( out
, len
, flags
, 1 );
543 r
= pf_output_stringW( out
, str
, len
);
546 r
= pf_fill( out
, len
, flags
, 0 );
551 static inline int pf_output_format_A( pf_output
*out
, LPCSTR str
,
552 int len
, pf_flags
*flags
)
559 if (flags
->Precision
>= 0 && flags
->Precision
< len
)
560 len
= flags
->Precision
;
562 r
= pf_fill( out
, len
, flags
, 1 );
565 r
= pf_output_stringA( out
, str
, len
);
568 r
= pf_fill( out
, len
, flags
, 0 );
573 static int pf_handle_string_format( pf_output
*out
, const void* str
, int len
,
574 pf_flags
*flags
, BOOL capital_letter
)
576 if(str
== NULL
) /* catch NULL pointer */
577 return pf_output_format_A( out
, "(null)", -1, flags
);
579 /* prefixes take priority over %c,%s vs. %C,%S, so we handle them first */
580 if(flags
->WideString
|| flags
->IntegerLength
== 'l')
581 return pf_output_format_W( out
, str
, len
, flags
);
582 if(flags
->IntegerLength
== 'h')
583 return pf_output_format_A( out
, str
, len
, flags
);
585 /* %s,%c -> chars in ansi functions & wchars in unicode
586 * %S,%C -> wchars in ansi functions & chars in unicode */
587 if( capital_letter
== out
->unicode
) /* either both TRUE or both FALSE */
588 return pf_output_format_A( out
, str
, len
, flags
);
590 return pf_output_format_W( out
, str
, len
, flags
);
593 static inline BOOL
pf_is_integer_format( char fmt
)
595 static const char float_fmts
[] = "diouxX";
598 return strchr( float_fmts
, fmt
) ? TRUE
: FALSE
;
601 static inline BOOL
pf_is_double_format( char fmt
)
603 static const char float_fmts
[] = "aeEfgG";
606 return strchr( float_fmts
, fmt
) ? TRUE
: FALSE
;
609 static inline BOOL
pf_is_valid_format( char fmt
)
611 static const char float_fmts
[] = "acCdeEfgGinouxX";
614 return strchr( float_fmts
, fmt
) ? TRUE
: FALSE
;
617 static void pf_rebuild_format_string( char *p
, pf_flags
*flags
)
622 if( flags
->LeftAlign
)
623 *p
++ = flags
->LeftAlign
;
624 if( flags
->Alternate
)
625 *p
++ = flags
->Alternate
;
627 *p
++ = flags
->PadZero
;
628 if( flags
->FieldLength
)
630 sprintf(p
, "%d", flags
->FieldLength
);
633 if( flags
->Precision
>= 0 )
635 sprintf(p
, ".%d", flags
->Precision
);
638 *p
++ = flags
->Format
;
642 /* pf_integer_conv: prints x to buf, including alternate formats and
643 additional precision digits, but not field characters or the sign */
644 static void pf_integer_conv( char *buf
, int buf_len
, pf_flags
*flags
,
651 char number
[40], *tmp
= number
;
653 if( buf_len
> sizeof number
)
654 tmp
= HeapAlloc( GetProcessHeap(), 0, buf_len
);
657 if( flags
->Format
== 'o' )
659 else if( flags
->Format
== 'x' || flags
->Format
== 'X' )
662 if( flags
->Format
== 'X' )
663 digits
= "0123456789ABCDEFX";
665 digits
= "0123456789abcdefx";
667 if( x
< 0 && ( flags
->Format
== 'd' || flags
->Format
== 'i' ) )
673 /* Do conversion (backwards) */
675 if( x
== 0 && flags
->Precision
)
680 j
= (ULONGLONG
) x
% base
;
681 x
= (ULONGLONG
) x
/ base
;
682 tmp
[i
++] = digits
[j
];
684 k
= flags
->Precision
- i
;
687 if( flags
->Alternate
)
691 tmp
[i
++] = digits
[16];
694 else if( base
== 8 && tmp
[i
-1] != '0' )
698 /* Reverse for buf */
704 /* Adjust precision so pf_fill won't truncate the number later */
705 flags
->Precision
= strlen( buf
);
708 HeapFree( GetProcessHeap(), 0, tmp
);
713 /* pf_fixup_exponent: convert a string containing a 2 digit exponent
714 to 3 digits, accounting for padding, in place. Needed to match
715 the native printf's which always use 3 digits. */
716 static void pf_fixup_exponent( char *buf
)
720 while (tmp
[0] && toupper(tmp
[0]) != 'E')
723 if (tmp
[0] && (tmp
[1] == '+' || tmp
[1] == '-') &&
724 isdigit(tmp
[2]) && isdigit(tmp
[3]))
729 return; /* Exponent already 3 digits */
731 /* We have a 2 digit exponent. Prepend '0' to make it 3 */
739 /* We didn't expand into trailing space, so this string isn't left
740 * justified. Terminate the string and strip a ' ' at the start of
741 * the string if there is one (as there may be if the string is
746 memmove(buf
, buf
+ 1, (tmp
- buf
) + 3);
748 /* Otherwise, we expanded into trailing space -> nothing to do */
752 /*********************************************************************
753 * pf_vsnprintf (INTERNAL)
755 * implements both A and W vsnprintf functions
757 int pf_vsnprintf( pf_output
*out
, const WCHAR
*format
,
758 MSVCRT__locale_t locale
, BOOL valid
, __ms_va_list valist
)
761 LPCWSTR q
, p
= format
;
765 locale
= get_locale();
767 TRACE("format is %s\n",debugstr_w(format
));
770 q
= strchrW( p
, '%' );
772 /* there's no % characters left, output the rest of the string */
775 r
= pf_output_stringW(out
, p
, -1);
782 /* there's characters before the %, output them */
785 r
= pf_output_stringW(out
, p
, q
- p
);
791 /* we must be at a % now, skip over it */
795 /* output a single % character */
798 r
= pf_output_stringW(out
, p
++, 1);
804 /* parse the flags */
805 memset( &flags
, 0, sizeof flags
);
808 if( *p
== '+' || *p
== ' ' )
810 if ( flags
.Sign
!= '+' )
814 flags
.LeftAlign
= *p
;
818 flags
.Alternate
= *p
;
824 /* deal with the field width specifier */
825 flags
.FieldLength
= 0;
828 flags
.FieldLength
= va_arg( valist
, int );
829 if (flags
.FieldLength
< 0)
831 flags
.LeftAlign
= '-';
832 flags
.FieldLength
= -flags
.FieldLength
;
836 else while( isdigit(*p
) )
838 flags
.FieldLength
*= 10;
839 flags
.FieldLength
+= *p
++ - '0';
842 /* deal with precision */
843 flags
.Precision
= -1;
850 flags
.Precision
= va_arg( valist
, int );
853 else while( isdigit(*p
) )
855 flags
.Precision
*= 10;
856 flags
.Precision
+= *p
++ - '0';
860 /* deal with integer width modifier */
863 if( *p
== 'l' && *(p
+1) == 'l' )
865 flags
.IntegerDouble
++;
868 else if( *p
== 'h' || *p
== 'l' || *p
== 'L' )
870 flags
.IntegerLength
= *p
;
875 if( *(p
+1) == '6' && *(p
+2) == '4' )
877 flags
.IntegerDouble
++;
880 else if( *(p
+1) == '3' && *(p
+2) == '2' )
882 else if( isdigit(*(p
+1)) || *(p
+1) == 0 )
888 flags
.WideString
= *p
++;
898 if (flags
.Format
== '$')
900 FIXME("Positional parameters are not supported (%s)\n", wine_dbgstr_w(format
));
903 /* output a string */
904 if( flags
.Format
== 's' || flags
.Format
== 'S' )
905 r
= pf_handle_string_format( out
, va_arg(valist
, const void*), -1,
906 &flags
, (flags
.Format
== 'S') );
908 /* output a single character */
909 else if( flags
.Format
== 'c' || flags
.Format
== 'C' )
911 INT ch
= va_arg( valist
, int );
913 r
= pf_handle_string_format( out
, &ch
, 1, &flags
, (flags
.Format
== 'C') );
916 /* output a pointer */
917 else if( flags
.Format
== 'p' )
920 void *ptr
= va_arg( valist
, void * );
923 if( flags
.Alternate
)
924 sprintf(pointer
, "0X%0*lX", 2 * (int)sizeof(ptr
), (ULONG_PTR
)ptr
);
926 sprintf(pointer
, "%0*lX", 2 * (int)sizeof(ptr
), (ULONG_PTR
)ptr
);
927 r
= pf_output_format_A( out
, pointer
, -1, &flags
);
931 else if( flags
.Format
== 'n' )
933 int *x
= va_arg(valist
, int *);
937 /* deal with 64-bit integers */
938 else if( pf_is_integer_format( flags
.Format
) && flags
.IntegerDouble
)
940 char number
[40], *x
= number
;
942 /* Estimate largest possible required buffer size:
943 * Chooses the larger of the field or precision
944 * Includes extra bytes: 1 byte for null, 1 byte for sign,
945 4 bytes for exponent, 2 bytes for alternate formats, 1 byte
946 for a decimal, and 1 byte for an additional float digit. */
947 int x_len
= ((flags
.FieldLength
> flags
.Precision
) ?
948 flags
.FieldLength
: flags
.Precision
) + 10;
950 if( x_len
>= sizeof number
)
951 x
= HeapAlloc( GetProcessHeap(), 0, x_len
);
953 pf_integer_conv( x
, x_len
, &flags
, va_arg(valist
, LONGLONG
) );
955 r
= pf_output_format_A( out
, x
, -1, &flags
);
957 HeapFree( GetProcessHeap(), 0, x
);
960 /* deal with integers and floats using libc's printf */
961 else if( pf_is_valid_format( flags
.Format
) )
963 char fmt
[20], number
[40], *x
= number
, *decimal_point
;
965 /* Estimate largest possible required buffer size:
966 * Chooses the larger of the field or precision
967 * Includes extra bytes: 1 byte for null, 1 byte for sign,
968 4 bytes for exponent, 2 bytes for alternate formats, 1 byte
969 for a decimal, and 1 byte for an additional float digit. */
970 int x_len
= ((flags
.FieldLength
> flags
.Precision
) ?
971 flags
.FieldLength
: flags
.Precision
) + 10;
973 if( x_len
>= sizeof number
)
974 x
= HeapAlloc( GetProcessHeap(), 0, x_len
);
976 pf_rebuild_format_string( fmt
, &flags
);
978 if( pf_is_double_format( flags
.Format
) )
980 sprintf( x
, fmt
, va_arg(valist
, double) );
981 if (toupper(flags
.Format
) == 'E' || toupper(flags
.Format
) == 'G')
982 pf_fixup_exponent( x
);
985 sprintf( x
, fmt
, va_arg(valist
, int) );
987 decimal_point
= strchr(x
, '.');
989 *decimal_point
= *locale
->locinfo
->lconv
->decimal_point
;
991 r
= pf_output_stringA( out
, x
, -1 );
993 HeapFree( GetProcessHeap(), 0, x
);
1001 MSVCRT__invalid_parameter( NULL
, NULL
, NULL
, 0, 0 );
1002 *MSVCRT__errno() = MSVCRT_EINVAL
;
1014 /* check we reached the end, and null terminate the string */
1016 pf_output_stringW( out
, p
, 1 );
1018 return out
->used
- 1;
1021 /*********************************************************************
1022 * vsnprintf_internal (INTERNAL)
1024 static inline int vsnprintf_internal( char *str
, MSVCRT_size_t len
, const char *format
,
1025 MSVCRT__locale_t locale
, BOOL valid
, __ms_va_list valist
)
1028 LPWSTR formatW
= NULL
;
1032 out
.unicode
= FALSE
;
1038 sz
= MultiByteToWideChar( CP_ACP
, 0, format
, -1, NULL
, 0 );
1039 formatW
= HeapAlloc( GetProcessHeap(), 0, sz
*sizeof(WCHAR
) );
1040 MultiByteToWideChar( CP_ACP
, 0, format
, -1, formatW
, sz
);
1042 r
= pf_vsnprintf( &out
, formatW
, locale
, valid
, valist
);
1044 HeapFree( GetProcessHeap(), 0, formatW
);
1049 /*********************************************************************
1050 * _vsnprintf (MSVCRT.@)
1052 int CDECL
MSVCRT_vsnprintf( char *str
, MSVCRT_size_t len
,
1053 const char *format
, __ms_va_list valist
)
1055 return vsnprintf_internal(str
, len
, format
, NULL
, FALSE
, valist
);
1058 /*********************************************************************
1059 * _vsnprintf_l (MSVCRT.@)
1061 int CDECL
MSVCRT_vsnprintf_l( char *str
, MSVCRT_size_t len
, const char *format
,
1062 MSVCRT__locale_t locale
, __ms_va_list valist
)
1064 return vsnprintf_internal(str
, len
, format
, locale
, FALSE
, valist
);
1067 /*********************************************************************
1068 * _vsnprintf_s_l (MSVCRT.@)
1070 int CDECL
MSVCRT_vsnprintf_s_l( char *str
, MSVCRT_size_t sizeOfBuffer
,
1071 MSVCRT_size_t count
, const char *format
,
1072 MSVCRT__locale_t locale
, __ms_va_list valist
)
1076 if(sizeOfBuffer
<count
+1 || count
==-1)
1081 ret
= vsnprintf_internal(str
, len
, format
, locale
, TRUE
, valist
);
1083 if(ret
<0 || ret
==len
) {
1084 if(count
!=MSVCRT__TRUNCATE
&& count
>sizeOfBuffer
) {
1085 MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small");
1086 *MSVCRT__errno() = MSVCRT_ERANGE
;
1087 memset(str
, 0, sizeOfBuffer
);
1097 /*********************************************************************
1098 * _vsnprintf_s (MSVCRT.@)
1100 int CDECL
MSVCRT_vsnprintf_s( char *str
, MSVCRT_size_t sizeOfBuffer
,
1101 MSVCRT_size_t count
, const char *format
, __ms_va_list valist
)
1103 return MSVCRT_vsnprintf_s_l(str
,sizeOfBuffer
, count
, format
, NULL
, valist
);
1106 /*********************************************************************
1107 * vsprintf (MSVCRT.@)
1109 int CDECL
MSVCRT_vsprintf( char *str
, const char *format
, __ms_va_list valist
)
1111 return MSVCRT_vsnprintf(str
, INT_MAX
, format
, valist
);
1114 /*********************************************************************
1115 * vsprintf_s (MSVCRT.@)
1117 int CDECL
MSVCRT_vsprintf_s( char *str
, MSVCRT_size_t num
, const char *format
, __ms_va_list valist
)
1119 return MSVCRT_vsnprintf(str
, num
, format
, valist
);
1122 /*********************************************************************
1123 * _vscprintf (MSVCRT.@)
1125 int CDECL
_vscprintf( const char *format
, __ms_va_list valist
)
1127 return MSVCRT_vsnprintf( NULL
, INT_MAX
, format
, valist
);
1130 /*********************************************************************
1131 * _snprintf (MSVCRT.@)
1133 int CDECL
MSVCRT__snprintf(char *str
, unsigned int len
, const char *format
, ...)
1136 __ms_va_list valist
;
1137 __ms_va_start(valist
, format
);
1138 retval
= MSVCRT_vsnprintf(str
, len
, format
, valist
);
1139 __ms_va_end(valist
);
1143 /*********************************************************************
1144 * _snprintf_s (MSVCRT.@)
1146 int CDECL
MSVCRT__snprintf_s(char *str
, unsigned int len
, unsigned int count
,
1147 const char *format
, ...)
1150 __ms_va_list valist
;
1151 __ms_va_start(valist
, format
);
1152 retval
= MSVCRT_vsnprintf_s_l(str
, len
, count
, format
, NULL
, valist
);
1153 __ms_va_end(valist
);
1157 /*********************************************************************
1158 * _scprintf (MSVCRT.@)
1160 int CDECL
MSVCRT__scprintf(const char *format
, ...)
1163 __ms_va_list valist
;
1164 __ms_va_start(valist
, format
);
1165 retval
= _vscprintf(format
, valist
);
1166 __ms_va_end(valist
);
1170 /*********************************************************************
1171 * vsnwprintf_internal (INTERNAL)
1173 static inline int vsnwprintf_internal(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
1174 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
, BOOL valid
,
1175 __ms_va_list valist
)
1185 return pf_vsnprintf( &out
, format
, locale
, valid
, valist
);
1188 /*********************************************************************
1189 * _vsnwprintf (MSVCRT.@)
1191 int CDECL
MSVCRT_vsnwprintf(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
1192 const MSVCRT_wchar_t
*format
, __ms_va_list valist
)
1194 return vsnwprintf_internal(str
, len
, format
, NULL
, FALSE
, valist
);
1197 /*********************************************************************
1198 * _vsnwprintf_l (MSVCRT.@)
1200 int CDECL
MSVCRT_vsnwprintf_l(MSVCRT_wchar_t
*str
, MSVCRT_size_t len
,
1201 const MSVCRT_wchar_t
*format
, MSVCRT__locale_t locale
,
1202 __ms_va_list valist
)
1204 return vsnwprintf_internal(str
, len
, format
, locale
, FALSE
, valist
);
1207 /*********************************************************************
1208 * _vsnwprintf_s_l (MSVCRT.@)
1210 int CDECL
MSVCRT_vsnwprintf_s_l( MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
1211 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
,
1212 MSVCRT__locale_t locale
, __ms_va_list valist
)
1217 if(count
!=-1 && len
>count
+1)
1220 ret
= vsnwprintf_internal(str
, len
, format
, locale
, TRUE
, valist
);
1222 if(ret
<0 || ret
==len
) {
1223 if(count
!=MSVCRT__TRUNCATE
&& count
>sizeOfBuffer
) {
1224 MSVCRT_INVALID_PMT("str[sizeOfBuffer] is too small");
1225 *MSVCRT__errno() = MSVCRT_ERANGE
;
1226 memset(str
, 0, sizeOfBuffer
*sizeof(MSVCRT_wchar_t
));
1236 /*********************************************************************
1237 * _vsnwprintf_s (MSVCRT.@)
1239 int CDECL
MSVCRT_vsnwprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t sizeOfBuffer
,
1240 MSVCRT_size_t count
, const MSVCRT_wchar_t
*format
, __ms_va_list valist
)
1242 return MSVCRT_vsnwprintf_s_l(str
, sizeOfBuffer
, count
,
1243 format
, NULL
, valist
);
1246 /*********************************************************************
1247 * _snwprintf (MSVCRT.@)
1249 int CDECL
MSVCRT__snwprintf( MSVCRT_wchar_t
*str
, unsigned int len
, const MSVCRT_wchar_t
*format
, ...)
1252 __ms_va_list valist
;
1253 __ms_va_start(valist
, format
);
1254 retval
= MSVCRT_vsnwprintf(str
, len
, format
, valist
);
1255 __ms_va_end(valist
);
1259 /*********************************************************************
1260 * _snwprintf_s (MSVCRT.@)
1262 int CDECL
MSVCRT__snwprintf_s( MSVCRT_wchar_t
*str
, unsigned int len
, unsigned int count
,
1263 const MSVCRT_wchar_t
*format
, ...)
1266 __ms_va_list valist
;
1267 __ms_va_start(valist
, format
);
1268 retval
= MSVCRT_vsnwprintf_s_l(str
, len
, count
, format
, NULL
, valist
);
1269 __ms_va_end(valist
);
1273 /*********************************************************************
1274 * sprintf (MSVCRT.@)
1276 int CDECL
MSVCRT_sprintf( char *str
, const char *format
, ... )
1281 __ms_va_start( ap
, format
);
1282 r
= MSVCRT_vsnprintf( str
, INT_MAX
, format
, ap
);
1287 /*********************************************************************
1288 * sprintf_s (MSVCRT.@)
1290 int CDECL
MSVCRT_sprintf_s( char *str
, MSVCRT_size_t num
, const char *format
, ... )
1295 __ms_va_start( ap
, format
);
1296 r
= MSVCRT_vsnprintf( str
, num
, format
, ap
);
1301 /*********************************************************************
1302 * _scwprintf (MSVCRT.@)
1304 int CDECL
MSVCRT__scwprintf( const MSVCRT_wchar_t
*format
, ... )
1309 __ms_va_start( ap
, format
);
1310 r
= MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, ap
);
1315 /*********************************************************************
1316 * swprintf (MSVCRT.@)
1318 int CDECL
MSVCRT_swprintf( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*format
, ... )
1323 __ms_va_start( ap
, format
);
1324 r
= MSVCRT_vsnwprintf( str
, INT_MAX
, format
, ap
);
1329 /*********************************************************************
1330 * swprintf_s (MSVCRT.@)
1332 int CDECL
MSVCRT_swprintf_s(MSVCRT_wchar_t
*str
, MSVCRT_size_t numberOfElements
,
1333 const MSVCRT_wchar_t
*format
, ... )
1338 __ms_va_start(ap
, format
);
1339 r
= MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, ap
);
1345 /*********************************************************************
1346 * vswprintf (MSVCRT.@)
1348 int CDECL
MSVCRT_vswprintf( MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* format
, __ms_va_list args
)
1350 return MSVCRT_vsnwprintf( str
, INT_MAX
, format
, args
);
1353 /*********************************************************************
1354 * _vscwprintf (MSVCRT.@)
1356 int CDECL
_vscwprintf( const MSVCRT_wchar_t
*format
, __ms_va_list args
)
1358 return MSVCRT_vsnwprintf( NULL
, INT_MAX
, format
, args
);
1361 /*********************************************************************
1362 * vswprintf_s (MSVCRT.@)
1364 int CDECL
MSVCRT_vswprintf_s(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
1365 const MSVCRT_wchar_t
* format
, __ms_va_list args
)
1367 return MSVCRT_vsnwprintf_s(str
, numberOfElements
, INT_MAX
, format
, args
);
1370 /*********************************************************************
1371 * _vswprintf_s_l (MSVCRT.@)
1373 int CDECL
MSVCRT_vswprintf_s_l(MSVCRT_wchar_t
* str
, MSVCRT_size_t numberOfElements
,
1374 const MSVCRT_wchar_t
* format
, MSVCRT__locale_t locale
, __ms_va_list args
)
1376 return MSVCRT_vsnwprintf_s_l(str
, numberOfElements
, INT_MAX
,
1377 format
, locale
, args
);
1380 /*********************************************************************
1381 * wcscoll (MSVCRT.@)
1383 int CDECL
MSVCRT_wcscoll( const MSVCRT_wchar_t
* str1
, const MSVCRT_wchar_t
* str2
)
1385 /* FIXME: handle collates */
1386 return strcmpW( str1
, str2
);
1389 /*********************************************************************
1390 * wcspbrk (MSVCRT.@)
1392 MSVCRT_wchar_t
* CDECL
MSVCRT_wcspbrk( const MSVCRT_wchar_t
* str
, const MSVCRT_wchar_t
* accept
)
1394 const MSVCRT_wchar_t
* p
;
1397 for (p
= accept
; *p
; p
++) if (*p
== *str
) return (MSVCRT_wchar_t
*)str
;
1403 /*********************************************************************
1404 * wcstok_s (MSVCRT.@)
1406 MSVCRT_wchar_t
* CDECL
wcstok_s( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
,
1407 MSVCRT_wchar_t
**next_token
)
1409 MSVCRT_wchar_t
*ret
;
1411 if (!MSVCRT_CHECK_PMT(delim
!= NULL
) || !MSVCRT_CHECK_PMT(next_token
!= NULL
) ||
1412 !MSVCRT_CHECK_PMT(str
!= NULL
|| *next_token
!= NULL
))
1414 *MSVCRT__errno() = MSVCRT_EINVAL
;
1417 if (!str
) str
= *next_token
;
1419 while (*str
&& strchrW( delim
, *str
)) str
++;
1420 if (!*str
) return NULL
;
1422 while (*str
&& !strchrW( delim
, *str
)) str
++;
1423 if (*str
) *str
++ = 0;
1428 /*********************************************************************
1431 MSVCRT_wchar_t
* CDECL
MSVCRT_wcstok( MSVCRT_wchar_t
*str
, const MSVCRT_wchar_t
*delim
)
1433 return wcstok_s(str
, delim
, &msvcrt_get_thread_data()->wcstok_next
);
1436 /*********************************************************************
1439 INT CDECL
MSVCRT_wctomb( char *dst
, MSVCRT_wchar_t ch
)
1441 return WideCharToMultiByte( CP_ACP
, 0, &ch
, 1, dst
, 6, NULL
, NULL
);
1444 /*********************************************************************
1445 * iswalnum (MSVCRT.@)
1447 INT CDECL
MSVCRT_iswalnum( MSVCRT_wchar_t wc
)
1449 return isalnumW( wc
);
1452 /*********************************************************************
1453 * iswalpha (MSVCRT.@)
1455 INT CDECL
MSVCRT_iswalpha( MSVCRT_wchar_t wc
)
1457 return isalphaW( wc
);
1460 /*********************************************************************
1461 * iswalpha_l (MSVCRT.@)
1463 INT CDECL
MSVCRT__iswalpha_l( MSVCRT_wchar_t wc
, MSVCRT__locale_t locale
)
1465 return isalphaW( wc
);
1468 /*********************************************************************
1469 * iswcntrl (MSVCRT.@)
1471 INT CDECL
MSVCRT_iswcntrl( MSVCRT_wchar_t wc
)
1473 return iscntrlW( wc
);
1476 /*********************************************************************
1477 * iswdigit (MSVCRT.@)
1479 INT CDECL
MSVCRT_iswdigit( MSVCRT_wchar_t wc
)
1481 return isdigitW( wc
);
1484 /*********************************************************************
1485 * iswgraph (MSVCRT.@)
1487 INT CDECL
MSVCRT_iswgraph( MSVCRT_wchar_t wc
)
1489 return isgraphW( wc
);
1492 /*********************************************************************
1493 * iswlower (MSVCRT.@)
1495 INT CDECL
MSVCRT_iswlower( MSVCRT_wchar_t wc
)
1497 return islowerW( wc
);
1500 /*********************************************************************
1501 * iswprint (MSVCRT.@)
1503 INT CDECL
MSVCRT_iswprint( MSVCRT_wchar_t wc
)
1505 return isprintW( wc
);
1508 /*********************************************************************
1509 * iswpunct (MSVCRT.@)
1511 INT CDECL
MSVCRT_iswpunct( MSVCRT_wchar_t wc
)
1513 return ispunctW( wc
);
1516 /*********************************************************************
1517 * iswspace (MSVCRT.@)
1519 INT CDECL
MSVCRT_iswspace( MSVCRT_wchar_t wc
)
1521 return isspaceW( wc
);
1524 /*********************************************************************
1525 * iswupper (MSVCRT.@)
1527 INT CDECL
MSVCRT_iswupper( MSVCRT_wchar_t wc
)
1529 return isupperW( wc
);
1532 /*********************************************************************
1533 * iswxdigit (MSVCRT.@)
1535 INT CDECL
MSVCRT_iswxdigit( MSVCRT_wchar_t wc
)
1537 return isxdigitW( wc
);
1540 /*********************************************************************
1541 * wcscpy_s (MSVCRT.@)
1543 INT CDECL
MSVCRT_wcscpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
)
1545 MSVCRT_size_t size
= 0;
1547 if(!wcDest
|| !numElement
)
1548 return MSVCRT_EINVAL
;
1554 return MSVCRT_EINVAL
;
1557 size
= strlenW(wcSrc
) + 1;
1559 if(size
> numElement
)
1561 return MSVCRT_ERANGE
;
1564 memcpy( wcDest
, wcSrc
, size
*sizeof(WCHAR
) );
1569 /******************************************************************
1570 * wcsncpy_s (MSVCRT.@)
1572 INT CDECL
MSVCRT_wcsncpy_s( MSVCRT_wchar_t
* wcDest
, MSVCRT_size_t numElement
, const MSVCRT_wchar_t
*wcSrc
,
1573 MSVCRT_size_t count
)
1575 MSVCRT_size_t size
= 0;
1577 if (!wcDest
|| !numElement
)
1578 return MSVCRT_EINVAL
;
1584 return MSVCRT_EINVAL
;
1587 size
= min(strlenW(wcSrc
), count
);
1589 if (size
>= numElement
)
1591 return MSVCRT_ERANGE
;
1594 memcpy( wcDest
, wcSrc
, size
*sizeof(WCHAR
) );
1595 wcDest
[size
] = '\0';
1600 /******************************************************************
1601 * wcscat_s (MSVCRT.@)
1604 INT CDECL
MSVCRT_wcscat_s(MSVCRT_wchar_t
* dst
, MSVCRT_size_t elem
, const MSVCRT_wchar_t
* src
)
1606 MSVCRT_wchar_t
* ptr
= dst
;
1608 if (!dst
|| elem
== 0) return MSVCRT_EINVAL
;
1612 return MSVCRT_EINVAL
;
1615 /* seek to end of dst string (or elem if no end of string is found */
1616 while (ptr
< dst
+ elem
&& *ptr
!= '\0') ptr
++;
1617 while (ptr
< dst
+ elem
)
1619 if ((*ptr
++ = *src
++) == '\0') return 0;
1621 /* not enough space */
1623 return MSVCRT_ERANGE
;
1626 /*********************************************************************
1627 * wcsncat_s (MSVCRT.@)
1630 INT CDECL
MSVCRT_wcsncat_s(MSVCRT_wchar_t
*dst
, MSVCRT_size_t elem
,
1631 const MSVCRT_wchar_t
*src
, MSVCRT_size_t count
)
1633 MSVCRT_size_t srclen
;
1634 MSVCRT_wchar_t dststart
;
1637 if (!MSVCRT_CHECK_PMT(dst
!= NULL
) || !MSVCRT_CHECK_PMT(elem
> 0))
1639 *MSVCRT__errno() = MSVCRT_EINVAL
;
1640 return MSVCRT_EINVAL
;
1642 if (!MSVCRT_CHECK_PMT(src
!= NULL
|| count
== 0))
1643 return MSVCRT_EINVAL
;
1647 for (dststart
= 0; dststart
< elem
; dststart
++)
1649 if (dst
[dststart
] == '\0')
1652 if (dststart
== elem
)
1654 MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n");
1655 return MSVCRT_EINVAL
;
1658 if (count
== MSVCRT__TRUNCATE
)
1660 srclen
= strlenW(src
);
1661 if (srclen
>= (elem
- dststart
))
1663 srclen
= elem
- dststart
- 1;
1664 ret
= MSVCRT_STRUNCATE
;
1668 srclen
= min(strlenW(src
), count
);
1669 if (srclen
< (elem
- dststart
))
1671 memcpy(&dst
[dststart
], src
, srclen
*sizeof(MSVCRT_wchar_t
));
1675 MSVCRT_INVALID_PMT("dst[elem] is too small");
1677 return MSVCRT_ERANGE
;
1680 /*********************************************************************
1681 * _wcstoi64_l (MSVCRT.@)
1683 * FIXME: locale parameter is ignored
1685 __int64 CDECL
MSVCRT__wcstoi64_l(const MSVCRT_wchar_t
*nptr
,
1686 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
1688 BOOL negative
= FALSE
;
1691 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
1693 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
) || !MSVCRT_CHECK_PMT(base
== 0 || base
>= 2) ||
1694 !MSVCRT_CHECK_PMT(base
<= 36)) {
1695 *MSVCRT__errno() = MSVCRT_EINVAL
;
1699 while(isspaceW(*nptr
)) nptr
++;
1704 } else if(*nptr
== '+')
1707 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
1720 char cur
= tolowerW(*nptr
);
1728 if(cur
<'a' || cur
>='a'+base
-10)
1738 if(!negative
&& (ret
>MSVCRT_I64_MAX
/base
|| ret
*base
>MSVCRT_I64_MAX
-v
)) {
1739 ret
= MSVCRT_I64_MAX
;
1740 *MSVCRT__errno() = MSVCRT_ERANGE
;
1741 } else if(negative
&& (ret
<MSVCRT_I64_MIN
/base
|| ret
*base
<MSVCRT_I64_MIN
-v
)) {
1742 ret
= MSVCRT_I64_MIN
;
1743 *MSVCRT__errno() = MSVCRT_ERANGE
;
1749 *endptr
= (MSVCRT_wchar_t
*)nptr
;
1754 /*********************************************************************
1755 * _wcstoi64 (MSVCRT.@)
1757 __int64 CDECL
MSVCRT__wcstoi64(const MSVCRT_wchar_t
*nptr
,
1758 MSVCRT_wchar_t
**endptr
, int base
)
1760 return MSVCRT__wcstoi64_l(nptr
, endptr
, base
, NULL
);
1763 /*********************************************************************
1764 * _wcstoui64_l (MSVCRT.@)
1766 * FIXME: locale parameter is ignored
1768 unsigned __int64 CDECL
MSVCRT__wcstoui64_l(const MSVCRT_wchar_t
*nptr
,
1769 MSVCRT_wchar_t
**endptr
, int base
, MSVCRT__locale_t locale
)
1771 BOOL negative
= FALSE
;
1772 unsigned __int64 ret
= 0;
1774 TRACE("(%s %p %d %p)\n", debugstr_w(nptr
), endptr
, base
, locale
);
1776 if (!MSVCRT_CHECK_PMT(nptr
!= NULL
) || !MSVCRT_CHECK_PMT(base
== 0 || base
>= 2) ||
1777 !MSVCRT_CHECK_PMT(base
<= 36)) {
1778 *MSVCRT__errno() = MSVCRT_EINVAL
;
1782 while(isspaceW(*nptr
)) nptr
++;
1787 } else if(*nptr
== '+')
1790 if((base
==0 || base
==16) && *nptr
=='0' && tolowerW(*(nptr
+1))=='x') {
1803 char cur
= tolowerW(*nptr
);
1811 if(cur
<'a' || cur
>='a'+base
-10)
1818 if(ret
>MSVCRT_UI64_MAX
/base
|| ret
*base
>MSVCRT_UI64_MAX
-v
) {
1819 ret
= MSVCRT_UI64_MAX
;
1820 *MSVCRT__errno() = MSVCRT_ERANGE
;
1826 *endptr
= (MSVCRT_wchar_t
*)nptr
;
1828 return negative
? -ret
: ret
;
1831 /*********************************************************************
1832 * _wcstoui64 (MSVCRT.@)
1834 unsigned __int64 CDECL
MSVCRT__wcstoui64(const MSVCRT_wchar_t
*nptr
,
1835 MSVCRT_wchar_t
**endptr
, int base
)
1837 return MSVCRT__wcstoui64_l(nptr
, endptr
, base
, NULL
);
1840 /******************************************************************
1841 * wcsnlen (MSVCRT.@)
1843 MSVCRT_size_t CDECL
MSVCRT_wcsnlen(const MSVCRT_wchar_t
*s
, MSVCRT_size_t maxlen
)
1847 for (i
= 0; i
< maxlen
; i
++)