wined3d: Link directly to opengl32.
[wine] / dlls / msvcrt / string.c
1 /*
2  * MSVCRT string functions
3  *
4  * Copyright 1996,1998 Marcus Meissner
5  * Copyright 1996 Jukka Iivonen
6  * Copyright 1997,2000 Uwe Bonnes
7  * Copyright 2000 Jon Griffiths
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23
24 #define _ISOC99_SOURCE
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <math.h>
31 #include <limits.h>
32 #include <errno.h>
33 #include "msvcrt.h"
34 #include "winnls.h"
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
38
39 /*********************************************************************
40  *              _mbsdup (MSVCRT.@)
41  *              _strdup (MSVCRT.@)
42  */
43 char* CDECL MSVCRT__strdup(const char* str)
44 {
45     if(str)
46     {
47       char * ret = MSVCRT_malloc(strlen(str)+1);
48       if (ret) strcpy( ret, str );
49       return ret;
50     }
51     else return 0;
52 }
53
54 /*********************************************************************
55  *              _strlwr_s_l (MSVCRT.@)
56  */
57 int CDECL _strlwr_s_l(char *str, MSVCRT_size_t len, MSVCRT__locale_t locale)
58 {
59     char *ptr = str;
60
61     if (!str || !len)
62     {
63         *MSVCRT__errno() = MSVCRT_EINVAL;
64         return MSVCRT_EINVAL;
65     }
66
67     while (len && *ptr)
68     {
69         len--;
70         ptr++;
71     }
72
73     if (!len)
74     {
75         str[0] = '\0';
76         *MSVCRT__errno() = MSVCRT_EINVAL;
77         return MSVCRT_EINVAL;
78     }
79
80     while (*str)
81     {
82         *str = MSVCRT__tolower_l((unsigned char)*str, locale);
83         str++;
84     }
85
86     return 0;
87 }
88
89 /*********************************************************************
90  *              _strlwr_s (MSVCRT.@)
91  */
92 int CDECL _strlwr_s(char *str, MSVCRT_size_t len)
93 {
94     return _strlwr_s_l(str, len, NULL);
95 }
96
97 /*********************************************************************
98  *              _strlwr_l (MSVCRT.@)
99  */
100 char* CDECL _strlwr_l(char *str, MSVCRT__locale_t locale)
101 {
102     _strlwr_s_l(str, -1, locale);
103     return str;
104 }
105
106 /*********************************************************************
107  *              _strlwr (MSVCRT.@)
108  */
109 char* CDECL MSVCRT__strlwr(char *str)
110 {
111     _strlwr_s_l(str, -1, NULL);
112     return str;
113 }
114
115 /*********************************************************************
116  *              _strupr_s_l (MSVCRT.@)
117  */
118 int CDECL _strupr_s_l(char *str, MSVCRT_size_t len, MSVCRT__locale_t locale)
119 {
120     char *ptr = str;
121
122     if (!str || !len)
123     {
124         *MSVCRT__errno() = MSVCRT_EINVAL;
125         return MSVCRT_EINVAL;
126     }
127
128     while (len && *ptr)
129     {
130         len--;
131         ptr++;
132     }
133
134     if (!len)
135     {
136         str[0] = '\0';
137         *MSVCRT__errno() = MSVCRT_EINVAL;
138         return MSVCRT_EINVAL;
139     }
140
141     while (*str)
142     {
143         *str = MSVCRT__toupper_l((unsigned char)*str, locale);
144         str++;
145     }
146
147     return 0;
148 }
149
150 /*********************************************************************
151  *              _strupr_s (MSVCRT.@)
152  */
153 int CDECL _strupr_s(char *str, MSVCRT_size_t len)
154 {
155     return _strupr_s_l(str, len, NULL);
156 }
157
158 /*********************************************************************
159  *              _strupr_l (MSVCRT.@)
160  */
161 char* CDECL MSVCRT__strupr_l(char *str, MSVCRT__locale_t locale)
162 {
163     _strupr_s_l(str, -1, locale);
164     return str;
165 }
166
167 /*********************************************************************
168  *              _strupr (MSVCRT.@)
169  */
170 char* CDECL MSVCRT__strupr(char *str)
171 {
172     _strupr_s_l(str, -1, NULL);
173     return str;
174 }
175
176 /*********************************************************************
177  *              _strnset (MSVCRT.@)
178  */
179 char* CDECL MSVCRT__strnset(char* str, int value, MSVCRT_size_t len)
180 {
181   if (len > 0 && str)
182     while (*str && len--)
183       *str++ = value;
184   return str;
185 }
186
187 /*********************************************************************
188  *              _strrev (MSVCRT.@)
189  */
190 char* CDECL MSVCRT__strrev(char* str)
191 {
192   char * p1;
193   char * p2;
194
195   if (str && *str)
196     for (p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2)
197     {
198       *p1 ^= *p2;
199       *p2 ^= *p1;
200       *p1 ^= *p2;
201     }
202
203   return str;
204 }
205
206 /*********************************************************************
207  *              _strset (MSVCRT.@)
208  */
209 char* CDECL _strset(char* str, int value)
210 {
211   char *ptr = str;
212   while (*ptr)
213     *ptr++ = value;
214
215   return str;
216 }
217
218 /*********************************************************************
219  *              strtok  (MSVCRT.@)
220  */
221 char * CDECL MSVCRT_strtok( char *str, const char *delim )
222 {
223     thread_data_t *data = msvcrt_get_thread_data();
224     char *ret;
225
226     if (!str)
227         if (!(str = data->strtok_next)) return NULL;
228
229     while (*str && strchr( delim, *str )) str++;
230     if (!*str) return NULL;
231     ret = str++;
232     while (*str && !strchr( delim, *str )) str++;
233     if (*str) *str++ = 0;
234     data->strtok_next = str;
235     return ret;
236 }
237
238 /*********************************************************************
239  *              strtok_s  (MSVCRT.@)
240  */
241 char * CDECL MSVCRT_strtok_s(char *str, const char *delim, char **ctx)
242 {
243     if (!MSVCRT_CHECK_PMT(delim != NULL)) return NULL;
244     if (!MSVCRT_CHECK_PMT(ctx != NULL)) return NULL;
245     if (!MSVCRT_CHECK_PMT(str != NULL || *ctx != NULL)) return NULL;
246
247     if(!str)
248         str = *ctx;
249
250     while(*str && strchr(delim, *str))
251         str++;
252     if(!*str)
253         return NULL;
254
255     *ctx = str+1;
256     while(**ctx && !strchr(delim, **ctx))
257         (*ctx)++;
258     if(**ctx)
259         *(*ctx)++ = 0;
260
261     return str;
262 }
263
264 /*********************************************************************
265  *              _swab (MSVCRT.@)
266  */
267 void CDECL MSVCRT__swab(char* src, char* dst, int len)
268 {
269   if (len > 1)
270   {
271     len = (unsigned)len >> 1;
272
273     while (len--) {
274       char s0 = src[0];
275       char s1 = src[1];
276       *dst++ = s1;
277       *dst++ = s0;
278       src = src + 2;
279     }
280   }
281 }
282
283 /*********************************************************************
284  *              strtod_l  (MSVCRT.@)
285  */
286 double CDECL MSVCRT_strtod_l( const char *str, char **end, MSVCRT__locale_t locale)
287 {
288     MSVCRT_pthreadlocinfo locinfo;
289     unsigned __int64 d=0, hlp;
290     unsigned fpcontrol;
291     int exp=0, sign=1;
292     const char *p;
293     double ret;
294     long double lret=1, expcnt = 10;
295     BOOL found_digit = FALSE, negexp;
296
297     if (!MSVCRT_CHECK_PMT(str != NULL)) return 0;
298
299     if(!locale)
300         locinfo = get_locinfo();
301     else
302         locinfo = locale->locinfo;
303
304     /* FIXME: use *_l functions */
305     p = str;
306     while(isspace(*p))
307         p++;
308
309     if(*p == '-') {
310         sign = -1;
311         p++;
312     } else  if(*p == '+')
313         p++;
314
315     while(isdigit(*p)) {
316         found_digit = TRUE;
317         hlp = d*10+*(p++)-'0';
318         if(d>MSVCRT_UI64_MAX/10 || hlp<d) {
319             exp++;
320             break;
321         } else
322             d = hlp;
323     }
324     while(isdigit(*p)) {
325         exp++;
326         p++;
327     }
328
329     if(*p == *locinfo->lconv->decimal_point)
330         p++;
331
332     while(isdigit(*p)) {
333         found_digit = TRUE;
334         hlp = d*10+*(p++)-'0';
335         if(d>MSVCRT_UI64_MAX/10 || hlp<d)
336             break;
337
338         d = hlp;
339         exp--;
340     }
341     while(isdigit(*p))
342         p++;
343
344     if(!found_digit) {
345         if(end)
346             *end = (char*)str;
347         return 0.0;
348     }
349
350     if(*p=='e' || *p=='E' || *p=='d' || *p=='D') {
351         int e=0, s=1;
352
353         p++;
354         if(*p == '-') {
355             s = -1;
356             p++;
357         } else if(*p == '+')
358             p++;
359
360         if(isdigit(*p)) {
361             while(isdigit(*p)) {
362                 if(e>INT_MAX/10 || (e=e*10+*p-'0')<0)
363                     e = INT_MAX;
364                 p++;
365             }
366             e *= s;
367
368             if(exp<0 && e<0 && exp+e>=0) exp = INT_MIN;
369             else if(exp>0 && e>0 && exp+e<0) exp = INT_MAX;
370             else exp += e;
371         } else {
372             if(*p=='-' || *p=='+')
373                 p--;
374             p--;
375         }
376     }
377
378     fpcontrol = _control87(0, 0);
379     _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE
380             |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff);
381
382     negexp = (exp < 0);
383     if(negexp)
384         exp = -exp;
385     while(exp) {
386         if(exp & 1)
387             lret *= expcnt;
388         exp /= 2;
389         expcnt = expcnt*expcnt;
390     }
391     ret = (long double)sign * (negexp ? d/lret : d*lret);
392
393     _control87(fpcontrol, 0xffffffff);
394
395     if((d && ret==0.0) || isinf(ret))
396         *MSVCRT__errno() = MSVCRT_ERANGE;
397
398     if(end)
399         *end = (char*)p;
400
401     return ret;
402 }
403
404 /*********************************************************************
405  *              strtod  (MSVCRT.@)
406  */
407 double CDECL MSVCRT_strtod( const char *str, char **end )
408 {
409     return MSVCRT_strtod_l( str, end, NULL );
410 }
411
412 /*********************************************************************
413  *              atof  (MSVCRT.@)
414  */
415 double CDECL MSVCRT_atof( const char *str )
416 {
417     return MSVCRT_strtod_l(str, NULL, NULL);
418 }
419
420 /*********************************************************************
421  *              _atof_l  (MSVCRT.@)
422  */
423 double CDECL MSVCRT__atof_l( const char *str, MSVCRT__locale_t locale)
424 {
425     return MSVCRT_strtod_l(str, NULL, locale);
426 }
427
428 /*********************************************************************
429  *              _atoflt_l  (MSVCRT.@)
430  */
431 int CDECL MSVCRT__atoflt_l( MSVCRT__CRT_FLOAT *value, char *str, MSVCRT__locale_t locale)
432 {
433     MSVCRT_pthreadlocinfo locinfo;
434     unsigned __int64 d=0, hlp;
435     unsigned fpcontrol;
436     int exp=0, sign=1;
437     const char *p;
438     int ret=0;
439     BOOL found_digit = FALSE;
440
441     if(!locale)
442         locinfo = get_locinfo();
443     else
444         locinfo = locale->locinfo;
445
446     /* FIXME: use *_l functions */
447     p = str;
448     while(isspace(*p))
449         p++;
450
451     if(*p == '-') {
452         sign = -1;
453         p++;
454     } else if(*p == '+')
455         p++;
456
457     while(isdigit(*p)) {
458         found_digit = TRUE;
459         hlp = d*10+*(p++)-'0';
460         if(d>MSVCRT_UI64_MAX/10 || hlp<d) {
461             exp++;
462             break;
463         } else
464             d = hlp;
465     }
466     while(isdigit(*p)) {
467         exp++;
468         p++;
469     }
470
471     if(*p == *locinfo->lconv->decimal_point)
472         p++;
473
474     while(isdigit(*p)) {
475         found_digit = TRUE;
476         hlp = d*10+*(p++)-'0';
477         if(d>MSVCRT_UI64_MAX/10 || hlp<d)
478             break;
479
480         d = hlp;
481         exp--;
482     }
483     while(isdigit(*p))
484         p++;
485
486     if(!found_digit) {
487         value->f = 0.0;
488         return 0;
489     }
490
491     if(*p=='e' || *p=='E' || *p=='d' || *p=='D') {
492         int e=0, s=1;
493
494         p++;
495         if(*p == '-') {
496             s = -1;
497             p++;
498         } else if(*p == '+')
499             p++;
500
501         if(isdigit(*p)) {
502             while(isdigit(*p)) {
503                 if(e>INT_MAX/10 || (e=e*10+*p-'0')<0)
504                     e = INT_MAX;
505                 p++;
506             }
507             e *= s;
508
509             if(exp<0 && e<0 && exp+e>=0) exp = INT_MIN;
510             else if(exp>0 && e>0 && exp+e<0) exp = INT_MAX;
511             else exp += e;
512         } else {
513             if(*p=='-' || *p=='+')
514                 p--;
515             p--;
516         }
517     }
518
519     fpcontrol = _control87(0, 0);
520     _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE
521             |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff);
522
523     if(exp>0)
524         value->f = (double)sign*d*pow(10, exp);
525     else
526         value->f = (double)sign*d/pow(10, -exp);
527
528     _control87(fpcontrol, 0xffffffff);
529
530     if((d && value->f>-MSVCRT_FLT_MIN && value->f<MSVCRT_FLT_MIN) || isinf(value->f))
531         ret = exp > 0 ? MSVCRT__OVERFLOW : MSVCRT__UNDERFLOW;
532
533     return ret;
534 }
535
536 /*********************************************************************
537  *              _strcoll_l (MSVCRT.@)
538  */
539 int CDECL MSVCRT_strcoll_l( const char* str1, const char* str2, MSVCRT__locale_t locale )
540 {
541     MSVCRT_pthreadlocinfo locinfo;
542
543     if(!locale)
544         locinfo = get_locinfo();
545     else
546         locinfo = locale->locinfo;
547
548     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_CTYPE], 0, str1, -1, str2, -1)-CSTR_EQUAL;
549 }
550
551 /*********************************************************************
552  *              strcoll (MSVCRT.@)
553  */
554 int CDECL MSVCRT_strcoll( const char* str1, const char* str2 )
555 {
556     return MSVCRT_strcoll_l(str1, str2, NULL);
557 }
558
559 /*********************************************************************
560  *              _stricoll_l (MSVCRT.@)
561  */
562 int CDECL MSVCRT__stricoll_l( const char* str1, const char* str2, MSVCRT__locale_t locale )
563 {
564     MSVCRT_pthreadlocinfo locinfo;
565
566     if(!locale)
567         locinfo = get_locinfo();
568     else
569         locinfo = locale->locinfo;
570
571     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_CTYPE], NORM_IGNORECASE,
572             str1, -1, str2, -1)-CSTR_EQUAL;
573 }
574
575 /*********************************************************************
576  *              _stricoll (MSVCRT.@)
577  */
578 int CDECL MSVCRT__stricoll( const char* str1, const char* str2 )
579 {
580     return MSVCRT__stricoll_l(str1, str2, NULL);
581 }
582
583 /*********************************************************************
584  *              _strncoll_l (MSVCRT.@)
585  */
586 int CDECL MSVCRT_strncoll_l( const char* str1, const char* str2, MSVCRT_size_t count, MSVCRT__locale_t locale )
587 {
588     MSVCRT_pthreadlocinfo locinfo;
589
590     if(!locale)
591         locinfo = get_locinfo();
592     else
593         locinfo = locale->locinfo;
594
595     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_CTYPE], 0, str1, count, str2, count)-CSTR_EQUAL;
596 }
597
598 /*********************************************************************
599  *              strncoll (MSVCRT.@)
600  */
601 int CDECL MSVCRT_strncoll( const char* str1, const char* str2, MSVCRT_size_t count )
602 {
603     return MSVCRT_strncoll_l(str1, str2, count, NULL);
604 }
605
606 /*********************************************************************
607  *              _strnicoll_l (MSVCRT.@)
608  */
609 int CDECL MSVCRT__strnicoll_l( const char* str1, const char* str2, MSVCRT_size_t count, MSVCRT__locale_t locale )
610 {
611     MSVCRT_pthreadlocinfo locinfo;
612
613     if(!locale)
614         locinfo = get_locinfo();
615     else
616         locinfo = locale->locinfo;
617
618     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_CTYPE], NORM_IGNORECASE,
619             str1, count, str2, count)-CSTR_EQUAL;
620 }
621
622 /*********************************************************************
623  *              _strnicoll (MSVCRT.@)
624  */
625 int CDECL MSVCRT__strnicoll( const char* str1, const char* str2, MSVCRT_size_t count )
626 {
627     return MSVCRT__strnicoll_l(str1, str2, count, NULL);
628 }
629
630 /*********************************************************************
631  *      strcpy_s (MSVCRT.@)
632  */
633 int CDECL MSVCRT_strcpy_s( char* dst, MSVCRT_size_t elem, const char* src )
634 {
635     MSVCRT_size_t i;
636     if(!elem) return MSVCRT_EINVAL;
637     if(!dst) return MSVCRT_EINVAL;
638     if(!src)
639     {
640         dst[0] = '\0';
641         return MSVCRT_EINVAL;
642     }
643
644     for(i = 0; i < elem; i++)
645     {
646         if((dst[i] = src[i]) == '\0') return 0;
647     }
648     dst[0] = '\0';
649     return MSVCRT_ERANGE;
650 }
651
652 /*********************************************************************
653  *      strcat_s (MSVCRT.@)
654  */
655 int CDECL MSVCRT_strcat_s( char* dst, MSVCRT_size_t elem, const char* src )
656 {
657     MSVCRT_size_t i, j;
658     if(!dst) return MSVCRT_EINVAL;
659     if(elem == 0) return MSVCRT_EINVAL;
660     if(!src)
661     {
662         dst[0] = '\0';
663         return MSVCRT_EINVAL;
664     }
665
666     for(i = 0; i < elem; i++)
667     {
668         if(dst[i] == '\0')
669         {
670             for(j = 0; (j + i) < elem; j++)
671             {
672                 if((dst[j + i] = src[j]) == '\0') return 0;
673             }
674         }
675     }
676     /* Set the first element to 0, not the first element after the skipped part */
677     dst[0] = '\0';
678     return MSVCRT_ERANGE;
679 }
680
681 /*********************************************************************
682  *      strncat_s (MSVCRT.@)
683  */
684 int CDECL MSVCRT_strncat_s( char* dst, MSVCRT_size_t elem, const char* src, MSVCRT_size_t count )
685 {
686     MSVCRT_size_t i, j;
687
688     if (!MSVCRT_CHECK_PMT(dst != 0)) return MSVCRT_EINVAL;
689     if (!MSVCRT_CHECK_PMT(elem != 0)) return MSVCRT_EINVAL;
690     if (!MSVCRT_CHECK_PMT(src != 0))
691     {
692         dst[0] = '\0';
693         return MSVCRT_EINVAL;
694     }
695
696     for(i = 0; i < elem; i++)
697     {
698         if(dst[i] == '\0')
699         {
700             for(j = 0; (j + i) < elem; j++)
701             {
702                 if(count == MSVCRT__TRUNCATE && j + i == elem - 1)
703                 {
704                     dst[j + i] = '\0';
705                     return MSVCRT_STRUNCATE;
706                 }
707                 if(j == count || (dst[j + i] = src[j]) == '\0')
708                 {
709                     dst[j + i] = '\0';
710                     return 0;
711                 }
712             }
713         }
714     }
715     /* Set the first element to 0, not the first element after the skipped part */
716     dst[0] = '\0';
717     return MSVCRT_ERANGE;
718 }
719
720 /*********************************************************************
721  *              strxfrm (MSVCRT.@)
722  */
723 MSVCRT_size_t CDECL MSVCRT_strxfrm( char *dest, const char *src, MSVCRT_size_t len )
724 {
725     /* FIXME: handle Windows locale */
726     return strxfrm( dest, src, len );
727 }
728
729 /********************************************************************
730  *              _atoldbl (MSVCRT.@)
731  */
732 int CDECL MSVCRT__atoldbl(MSVCRT__LDOUBLE *value, const char *str)
733 {
734   /* FIXME needs error checking for huge/small values */
735 #ifdef HAVE_STRTOLD
736   long double ld;
737   TRACE("str %s value %p\n",str,value);
738   ld = strtold(str,0);
739   memcpy(value, &ld, 10);
740 #else
741   FIXME("stub, str %s value %p\n",str,value);
742 #endif
743   return 0;
744 }
745
746 /********************************************************************
747  *              __STRINGTOLD (MSVCRT.@)
748  */
749 int CDECL __STRINGTOLD( MSVCRT__LDOUBLE *value, char **endptr, const char *str, int flags )
750 {
751 #ifdef HAVE_STRTOLD
752     long double ld;
753     FIXME("%p %p %s %x partial stub\n", value, endptr, str, flags );
754     ld = strtold(str,0);
755     memcpy(value, &ld, 10);
756 #else
757     FIXME("%p %p %s %x stub\n", value, endptr, str, flags );
758 #endif
759     return 0;
760 }
761
762 /******************************************************************
763  *              strtol (MSVCRT.@)
764  */
765 MSVCRT_long CDECL MSVCRT_strtol(const char* nptr, char** end, int base)
766 {
767     /* wrapper to forward libc error code to msvcrt's error codes */
768     long ret;
769
770     errno = 0;
771     ret = strtol(nptr, end, base);
772     switch (errno)
773     {
774     case ERANGE:        *MSVCRT__errno() = MSVCRT_ERANGE;       break;
775     case EINVAL:        *MSVCRT__errno() = MSVCRT_EINVAL;       break;
776     default:
777         /* cope with the fact that we may use 64bit long integers on libc
778          * while msvcrt always uses 32bit long integers
779          */
780         if (ret > MSVCRT_LONG_MAX)
781         {
782             ret = MSVCRT_LONG_MAX;
783             *MSVCRT__errno() = MSVCRT_ERANGE;
784         }
785         else if (ret < -MSVCRT_LONG_MAX - 1)
786         {
787             ret = -MSVCRT_LONG_MAX - 1;
788             *MSVCRT__errno() = MSVCRT_ERANGE;
789         }
790         break;
791     }
792
793     return ret;
794 }
795
796 /******************************************************************
797  *              strtoul (MSVCRT.@)
798  */
799 MSVCRT_ulong CDECL MSVCRT_strtoul(const char* nptr, char** end, int base)
800 {
801     /* wrapper to forward libc error code to msvcrt's error codes */
802     unsigned long ret;
803
804     errno = 0;
805     ret = strtoul(nptr, end, base);
806     switch (errno)
807     {
808     case ERANGE:        *MSVCRT__errno() = MSVCRT_ERANGE;       break;
809     case EINVAL:        *MSVCRT__errno() = MSVCRT_EINVAL;       break;
810     default:
811         /* cope with the fact that we may use 64bit long integers on libc
812          * while msvcrt always uses 32bit long integers
813          */
814         if (ret > MSVCRT_ULONG_MAX)
815         {
816             ret = MSVCRT_ULONG_MAX;
817             *MSVCRT__errno() = MSVCRT_ERANGE;
818         }
819         break;
820     }
821
822     return ret;
823 }
824
825 /******************************************************************
826  *              strnlen (MSVCRT.@)
827  */
828 MSVCRT_size_t CDECL MSVCRT_strnlen(const char *s, MSVCRT_size_t maxlen)
829 {
830     MSVCRT_size_t i;
831
832     for(i=0; i<maxlen; i++)
833         if(!s[i]) break;
834
835     return i;
836 }
837
838 /*********************************************************************
839  *  _strtoi64_l (MSVCRT.@)
840  *
841  * FIXME: locale parameter is ignored
842  */
843 __int64 CDECL MSVCRT_strtoi64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
844 {
845     BOOL negative = FALSE;
846     __int64 ret = 0;
847
848     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
849
850     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
851     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
852     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
853
854     while(isspace(*nptr)) nptr++;
855
856     if(*nptr == '-') {
857         negative = TRUE;
858         nptr++;
859     } else if(*nptr == '+')
860         nptr++;
861
862     if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') {
863         base = 16;
864         nptr += 2;
865     }
866
867     if(base == 0) {
868         if(*nptr=='0')
869             base = 8;
870         else
871             base = 10;
872     }
873
874     while(*nptr) {
875         char cur = tolower(*nptr);
876         int v;
877
878         if(isdigit(cur)) {
879             if(cur >= '0'+base)
880                 break;
881             v = cur-'0';
882         } else {
883             if(cur<'a' || cur>='a'+base-10)
884                 break;
885             v = cur-'a'+10;
886         }
887
888         if(negative)
889             v = -v;
890
891         nptr++;
892
893         if(!negative && (ret>MSVCRT_I64_MAX/base || ret*base>MSVCRT_I64_MAX-v)) {
894             ret = MSVCRT_I64_MAX;
895             *MSVCRT__errno() = MSVCRT_ERANGE;
896         } else if(negative && (ret<MSVCRT_I64_MIN/base || ret*base<MSVCRT_I64_MIN-v)) {
897             ret = MSVCRT_I64_MIN;
898             *MSVCRT__errno() = MSVCRT_ERANGE;
899         } else
900             ret = ret*base + v;
901     }
902
903     if(endptr)
904         *endptr = (char*)nptr;
905
906     return ret;
907 }
908
909 /*********************************************************************
910  *  _strtoi64 (MSVCRT.@)
911  */
912 __int64 CDECL MSVCRT_strtoi64(const char *nptr, char **endptr, int base)
913 {
914     return MSVCRT_strtoi64_l(nptr, endptr, base, NULL);
915 }
916
917 /*********************************************************************
918  *  _strtoui64_l (MSVCRT.@)
919  *
920  * FIXME: locale parameter is ignored
921  */
922 unsigned __int64 CDECL MSVCRT_strtoui64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
923 {
924     BOOL negative = FALSE;
925     unsigned __int64 ret = 0;
926
927     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
928
929     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
930     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
931     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
932
933     while(isspace(*nptr)) nptr++;
934
935     if(*nptr == '-') {
936         negative = TRUE;
937         nptr++;
938     } else if(*nptr == '+')
939         nptr++;
940
941     if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') {
942         base = 16;
943         nptr += 2;
944     }
945
946     if(base == 0) {
947         if(*nptr=='0')
948             base = 8;
949         else
950             base = 10;
951     }
952
953     while(*nptr) {
954         char cur = tolower(*nptr);
955         int v;
956
957         if(isdigit(cur)) {
958             if(cur >= '0'+base)
959                 break;
960             v = *nptr-'0';
961         } else {
962             if(cur<'a' || cur>='a'+base-10)
963                 break;
964             v = cur-'a'+10;
965         }
966
967         nptr++;
968
969         if(ret>MSVCRT_UI64_MAX/base || ret*base>MSVCRT_UI64_MAX-v) {
970             ret = MSVCRT_UI64_MAX;
971             *MSVCRT__errno() = MSVCRT_ERANGE;
972         } else
973             ret = ret*base + v;
974     }
975
976     if(endptr)
977         *endptr = (char*)nptr;
978
979     return negative ? -ret : ret;
980 }
981
982 /*********************************************************************
983  *  _strtoui64 (MSVCRT.@)
984  */
985 unsigned __int64 CDECL MSVCRT_strtoui64(const char *nptr, char **endptr, int base)
986 {
987     return MSVCRT_strtoui64_l(nptr, endptr, base, NULL);
988 }
989
990 /*********************************************************************
991  *  _ltoa_s (MSVCRT.@)
992  */
993 int CDECL _ltoa_s(MSVCRT_long value, char *str, MSVCRT_size_t size, int radix)
994 {
995     MSVCRT_ulong val;
996     unsigned int digit;
997     int is_negative;
998     char buffer[33], *pos;
999     size_t len;
1000
1001     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1002     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1003     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1004     {
1005         str[0] = '\0';
1006         return MSVCRT_EINVAL;
1007     }
1008
1009     if (value < 0 && radix == 10)
1010     {
1011         is_negative = 1;
1012         val = -value;
1013     }
1014     else
1015     {
1016         is_negative = 0;
1017         val = value;
1018     }
1019
1020     pos = buffer + 32;
1021     *pos = '\0';
1022
1023     do
1024     {
1025         digit = val % radix;
1026         val /= radix;
1027
1028         if (digit < 10)
1029             *--pos = '0' + digit;
1030         else
1031             *--pos = 'a' + digit - 10;
1032     }
1033     while (val != 0);
1034
1035     if (is_negative)
1036         *--pos = '-';
1037
1038     len = buffer + 33 - pos;
1039     if (len > size)
1040     {
1041         size_t i;
1042         char *p = str;
1043
1044         /* Copy the temporary buffer backwards up to the available number of
1045          * characters. Don't copy the negative sign if present. */
1046
1047         if (is_negative)
1048         {
1049             p++;
1050             size--;
1051         }
1052
1053         for (pos = buffer + 31, i = 0; i < size; i++)
1054             *p++ = *pos--;
1055
1056         str[0] = '\0';
1057         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1058         return MSVCRT_ERANGE;
1059     }
1060
1061     memcpy(str, pos, len);
1062     return 0;
1063 }
1064
1065 /*********************************************************************
1066  *  _ltow_s (MSVCRT.@)
1067  */
1068 int CDECL _ltow_s(MSVCRT_long value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1069 {
1070     MSVCRT_ulong val;
1071     unsigned int digit;
1072     int is_negative;
1073     MSVCRT_wchar_t buffer[33], *pos;
1074     size_t len;
1075
1076     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1077     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1078     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1079     {
1080         str[0] = '\0';
1081         return MSVCRT_EINVAL;
1082     }
1083
1084     if (value < 0 && radix == 10)
1085     {
1086         is_negative = 1;
1087         val = -value;
1088     }
1089     else
1090     {
1091         is_negative = 0;
1092         val = value;
1093     }
1094
1095     pos = buffer + 32;
1096     *pos = '\0';
1097
1098     do
1099     {
1100         digit = val % radix;
1101         val /= radix;
1102
1103         if (digit < 10)
1104             *--pos = '0' + digit;
1105         else
1106             *--pos = 'a' + digit - 10;
1107     }
1108     while (val != 0);
1109
1110     if (is_negative)
1111         *--pos = '-';
1112
1113     len = buffer + 33 - pos;
1114     if (len > size)
1115     {
1116         size_t i;
1117         MSVCRT_wchar_t *p = str;
1118
1119         /* Copy the temporary buffer backwards up to the available number of
1120          * characters. Don't copy the negative sign if present. */
1121
1122         if (is_negative)
1123         {
1124             p++;
1125             size--;
1126         }
1127
1128         for (pos = buffer + 31, i = 0; i < size; i++)
1129             *p++ = *pos--;
1130
1131         str[0] = '\0';
1132         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1133         return MSVCRT_ERANGE;
1134     }
1135
1136     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1137     return 0;
1138 }
1139
1140 /*********************************************************************
1141  *  _itoa_s (MSVCRT.@)
1142  */
1143 int CDECL _itoa_s(int value, char *str, MSVCRT_size_t size, int radix)
1144 {
1145     return _ltoa_s(value, str, size, radix);
1146 }
1147
1148 /*********************************************************************
1149  *  _itow_s (MSVCRT.@)
1150  */
1151 int CDECL _itow_s(int value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1152 {
1153     return _ltow_s(value, str, size, radix);
1154 }
1155
1156 /*********************************************************************
1157  *  _ui64toa_s (MSVCRT.@)
1158  */
1159 int CDECL MSVCRT__ui64toa_s(unsigned __int64 value, char *str,
1160         MSVCRT_size_t size, int radix)
1161 {
1162     char buffer[65], *pos;
1163     int digit;
1164
1165     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1166     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1167     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1168     {
1169         str[0] = '\0';
1170         return MSVCRT_EINVAL;
1171     }
1172
1173     pos = buffer+64;
1174     *pos = '\0';
1175
1176     do {
1177         digit = value%radix;
1178         value /= radix;
1179
1180         if(digit < 10)
1181             *--pos = '0'+digit;
1182         else
1183             *--pos = 'a'+digit-10;
1184     }while(value != 0);
1185
1186     if(buffer-pos+65 > size) {
1187         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
1188         return MSVCRT_EINVAL;
1189     }
1190
1191     memcpy(str, pos, buffer-pos+65);
1192     return 0;
1193 }
1194
1195 /*********************************************************************
1196  *      _ui64tow_s  (MSVCRT.@)
1197  */
1198 int CDECL MSVCRT__ui64tow_s( unsigned __int64 value, MSVCRT_wchar_t *str,
1199                              MSVCRT_size_t size, int radix )
1200 {
1201     MSVCRT_wchar_t buffer[65], *pos;
1202     int digit;
1203
1204     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1205     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1206     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1207     {
1208         str[0] = '\0';
1209         return MSVCRT_EINVAL;
1210     }
1211
1212     pos = &buffer[64];
1213     *pos = '\0';
1214
1215     do {
1216         digit = value % radix;
1217         value = value / radix;
1218         if (digit < 10)
1219             *--pos = '0' + digit;
1220         else
1221             *--pos = 'a' + digit - 10;
1222     } while (value != 0);
1223
1224     if(buffer-pos+65 > size) {
1225         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
1226         return MSVCRT_EINVAL;
1227     }
1228
1229     memcpy(str, pos, buffer-pos+65);
1230     return 0;
1231 }
1232
1233 /*********************************************************************
1234  *  _ultoa_s (MSVCRT.@)
1235  */
1236 int CDECL _ultoa_s(MSVCRT_ulong value, char *str, MSVCRT_size_t size, int radix)
1237 {
1238     MSVCRT_ulong digit;
1239     char buffer[33], *pos;
1240     size_t len;
1241
1242     if (!str || !size || radix < 2 || radix > 36)
1243     {
1244         if (str && size)
1245             str[0] = '\0';
1246
1247         *MSVCRT__errno() = MSVCRT_EINVAL;
1248         return MSVCRT_EINVAL;
1249     }
1250
1251     pos = buffer + 32;
1252     *pos = '\0';
1253
1254     do
1255     {
1256         digit = value % radix;
1257         value /= radix;
1258
1259         if (digit < 10)
1260             *--pos = '0' + digit;
1261         else
1262             *--pos = 'a' + digit - 10;
1263     }
1264     while (value != 0);
1265
1266     len = buffer + 33 - pos;
1267     if (len > size)
1268     {
1269         size_t i;
1270         char *p = str;
1271
1272         /* Copy the temporary buffer backwards up to the available number of
1273          * characters. */
1274
1275         for (pos = buffer + 31, i = 0; i < size; i++)
1276             *p++ = *pos--;
1277
1278         str[0] = '\0';
1279         *MSVCRT__errno() = MSVCRT_ERANGE;
1280         return MSVCRT_ERANGE;
1281     }
1282
1283     memcpy(str, pos, len);
1284     return 0;
1285 }
1286
1287 /*********************************************************************
1288  *  _ultow_s (MSVCRT.@)
1289  */
1290 int CDECL _ultow_s(MSVCRT_ulong value, WCHAR *str, MSVCRT_size_t size, int radix)
1291 {
1292     MSVCRT_ulong digit;
1293     WCHAR buffer[33], *pos;
1294     size_t len;
1295
1296     if (!str || !size || radix < 2 || radix > 36)
1297     {
1298         if (str && size)
1299             str[0] = '\0';
1300
1301         *MSVCRT__errno() = MSVCRT_EINVAL;
1302         return MSVCRT_EINVAL;
1303     }
1304
1305     pos = buffer + 32;
1306     *pos = '\0';
1307
1308     do
1309     {
1310         digit = value % radix;
1311         value /= radix;
1312
1313         if (digit < 10)
1314             *--pos = '0' + digit;
1315         else
1316             *--pos = 'a' + digit - 10;
1317     }
1318     while (value != 0);
1319
1320     len = buffer + 33 - pos;
1321     if (len > size)
1322     {
1323         size_t i;
1324         WCHAR *p = str;
1325
1326         /* Copy the temporary buffer backwards up to the available number of
1327          * characters. */
1328
1329         for (pos = buffer + 31, i = 0; i < size; i++)
1330             *p++ = *pos--;
1331
1332         str[0] = '\0';
1333         *MSVCRT__errno() = MSVCRT_ERANGE;
1334         return MSVCRT_ERANGE;
1335     }
1336
1337     memcpy(str, pos, len * sizeof(WCHAR));
1338     return 0;
1339 }
1340
1341 /*********************************************************************
1342  *  _i64toa_s (MSVCRT.@)
1343  */
1344 int CDECL _i64toa_s(__int64 value, char *str, MSVCRT_size_t size, int radix)
1345 {
1346     unsigned __int64 val;
1347     unsigned int digit;
1348     int is_negative;
1349     char buffer[65], *pos;
1350     size_t len;
1351
1352     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1353     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1354     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1355     {
1356         str[0] = '\0';
1357         return MSVCRT_EINVAL;
1358     }
1359
1360     if (value < 0 && radix == 10)
1361     {
1362         is_negative = 1;
1363         val = -value;
1364     }
1365     else
1366     {
1367         is_negative = 0;
1368         val = value;
1369     }
1370
1371     pos = buffer + 64;
1372     *pos = '\0';
1373
1374     do
1375     {
1376         digit = val % radix;
1377         val /= radix;
1378
1379         if (digit < 10)
1380             *--pos = '0' + digit;
1381         else
1382             *--pos = 'a' + digit - 10;
1383     }
1384     while (val != 0);
1385
1386     if (is_negative)
1387         *--pos = '-';
1388
1389     len = buffer + 65 - pos;
1390     if (len > size)
1391     {
1392         size_t i;
1393         char *p = str;
1394
1395         /* Copy the temporary buffer backwards up to the available number of
1396          * characters. Don't copy the negative sign if present. */
1397
1398         if (is_negative)
1399         {
1400             p++;
1401             size--;
1402         }
1403
1404         for (pos = buffer + 63, i = 0; i < size; i++)
1405             *p++ = *pos--;
1406
1407         str[0] = '\0';
1408         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1409         return MSVCRT_ERANGE;
1410     }
1411
1412     memcpy(str, pos, len);
1413     return 0;
1414 }
1415
1416 /*********************************************************************
1417  *  _i64tow_s (MSVCRT.@)
1418  */
1419 int CDECL _i64tow_s(__int64 value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1420 {
1421     unsigned __int64 val;
1422     unsigned int digit;
1423     int is_negative;
1424     MSVCRT_wchar_t buffer[65], *pos;
1425     size_t len;
1426
1427     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1428     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1429     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1430     {
1431         str[0] = '\0';
1432         return MSVCRT_EINVAL;
1433     }
1434
1435     if (value < 0 && radix == 10)
1436     {
1437         is_negative = 1;
1438         val = -value;
1439     }
1440     else
1441     {
1442         is_negative = 0;
1443         val = value;
1444     }
1445
1446     pos = buffer + 64;
1447     *pos = '\0';
1448
1449     do
1450     {
1451         digit = val % radix;
1452         val /= radix;
1453
1454         if (digit < 10)
1455             *--pos = '0' + digit;
1456         else
1457             *--pos = 'a' + digit - 10;
1458     }
1459     while (val != 0);
1460
1461     if (is_negative)
1462         *--pos = '-';
1463
1464     len = buffer + 65 - pos;
1465     if (len > size)
1466     {
1467         size_t i;
1468         MSVCRT_wchar_t *p = str;
1469
1470         /* Copy the temporary buffer backwards up to the available number of
1471          * characters. Don't copy the negative sign if present. */
1472
1473         if (is_negative)
1474         {
1475             p++;
1476             size--;
1477         }
1478
1479         for (pos = buffer + 63, i = 0; i < size; i++)
1480             *p++ = *pos--;
1481
1482         str[0] = '\0';
1483         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1484         return MSVCRT_ERANGE;
1485     }
1486
1487     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1488     return 0;
1489 }
1490
1491 #define I10_OUTPUT_MAX_PREC 21
1492 /* Internal structure used by $I10_OUTPUT */
1493 struct _I10_OUTPUT_DATA {
1494     short pos;
1495     char sign;
1496     BYTE len;
1497     char str[I10_OUTPUT_MAX_PREC+1]; /* add space for '\0' */
1498 };
1499
1500 /*********************************************************************
1501  *              $I10_OUTPUT (MSVCRT.@)
1502  * ld80 - long double (Intel 80 bit FP in 12 bytes) to be printed to data
1503  * prec - precision of part, we're interested in
1504  * flag - 0 for first prec digits, 1 for fractional part
1505  * data - data to be populated
1506  *
1507  * return value
1508  *      0 if given double is NaN or INF
1509  *      1 otherwise
1510  *
1511  * FIXME
1512  *      Native sets last byte of data->str to '0' or '9', I don't know what
1513  *      it means. Current implementation sets it always to '0'.
1514  */
1515 int CDECL MSVCRT_I10_OUTPUT(MSVCRT__LDOUBLE ld80, int prec, int flag, struct _I10_OUTPUT_DATA *data)
1516 {
1517     static const char inf_str[] = "1#INF";
1518     static const char nan_str[] = "1#QNAN";
1519
1520     /* MS' long double type wants 12 bytes for Intel's 80 bit FP format.
1521      * Some UNIX have sizeof(long double) == 16, yet only 80 bit are used.
1522      * Assume long double uses 80 bit FP, never seen 128 bit FP. */
1523     long double ld = 0;
1524     double d;
1525     char format[8];
1526     char buf[I10_OUTPUT_MAX_PREC+9]; /* 9 = strlen("0.e+0000") + '\0' */
1527     char *p;
1528
1529     memcpy(&ld, &ld80, 10);
1530     d = ld;
1531     TRACE("(%lf %d %x %p)\n", d, prec, flag, data);
1532
1533     if(d<0) {
1534         data->sign = '-';
1535         d = -d;
1536     } else
1537         data->sign = ' ';
1538
1539     if(isinf(d)) {
1540         data->pos = 1;
1541         data->len = 5;
1542         memcpy(data->str, inf_str, sizeof(inf_str));
1543
1544         return 0;
1545     }
1546
1547     if(isnan(d)) {
1548         data->pos = 1;
1549         data->len = 6;
1550         memcpy(data->str, nan_str, sizeof(nan_str));
1551
1552         return 0;
1553     }
1554
1555     if(flag&1) {
1556         int exp = 1+floor(log10(d));
1557
1558         prec += exp;
1559         if(exp < 0)
1560             prec--;
1561     }
1562     prec--;
1563
1564     if(prec+1 > I10_OUTPUT_MAX_PREC)
1565         prec = I10_OUTPUT_MAX_PREC-1;
1566     else if(prec < 0) {
1567         d = 0.0;
1568         prec = 0;
1569     }
1570
1571     sprintf(format, "%%.%dle", prec);
1572     sprintf(buf, format, d);
1573
1574     buf[1] = buf[0];
1575     data->pos = atoi(buf+prec+3);
1576     if(buf[1] != '0')
1577         data->pos++;
1578
1579     for(p = buf+prec+1; p>buf+1 && *p=='0'; p--);
1580     data->len = p-buf;
1581
1582     memcpy(data->str, buf+1, data->len);
1583     data->str[data->len] = '\0';
1584
1585     if(buf[1]!='0' && prec-data->len+1>0)
1586         memcpy(data->str+data->len+1, buf+data->len+1, prec-data->len+1);
1587
1588     return 1;
1589 }
1590 #undef I10_OUTPUT_MAX_PREC