git.oblomov.eu Git - wine/blob - 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 static double strtod_helper(const char *str, char **end, MSVCRT__locale_t locale, int *err)
 284 {
 285     MSVCRT_pthreadlocinfo locinfo;
 286     unsigned __int64 d=0, hlp;
 287     unsigned fpcontrol;
 288     int exp=0, sign=1;
 289     const char *p;
 290     double ret;
 291     long double lret=1, expcnt = 10;
 292     BOOL found_digit = FALSE, negexp;
 293
 294     if(err)
 295         *err = 0;
 296     else
 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         if(err)
 397             *err = MSVCRT_ERANGE;
 398         else
 399             *MSVCRT__errno() = MSVCRT_ERANGE;
 400     }
 401
 402     if(end)
 403         *end = (char*)p;
 404
 405     return ret;
 406 }
 407
 408 /*********************************************************************
 409  *              strtod_l  (MSVCRT.@)
 410  */
 411 double CDECL MSVCRT_strtod_l(const char *str, char **end, MSVCRT__locale_t locale)
 412 {
 413     return strtod_helper(str, end, locale, NULL);
 414 }
 415
 416 /*********************************************************************
 417  *              strtod  (MSVCRT.@)
 418  */
 419 double CDECL MSVCRT_strtod( const char *str, char **end )
 420 {
 421     return MSVCRT_strtod_l( str, end, NULL );
 422 }
 423
 424 /*********************************************************************
 425  *              atof  (MSVCRT.@)
 426  */
 427 double CDECL MSVCRT_atof( const char *str )
 428 {
 429     return MSVCRT_strtod_l(str, NULL, NULL);
 430 }
 431
 432 /*********************************************************************
 433  *              _atof_l  (MSVCRT.@)
 434  */
 435 double CDECL MSVCRT__atof_l( const char *str, MSVCRT__locale_t locale)
 436 {
 437     return MSVCRT_strtod_l(str, NULL, locale);
 438 }
 439
 440 /*********************************************************************
 441  *              _atoflt_l  (MSVCRT.@)
 442  */
 443 int CDECL MSVCRT__atoflt_l( MSVCRT__CRT_FLOAT *value, char *str, MSVCRT__locale_t locale)
 444 {
 445     double d;
 446     int err;
 447
 448     d = strtod_helper(str, NULL, locale, &err);
 449     value->f = d;
 450     if(isinf(value->f))
 451         return MSVCRT__OVERFLOW;
 452     if((d!=0 || err) && value->f>-MSVCRT_FLT_MIN && value->f<MSVCRT_FLT_MIN)
 453         return MSVCRT__UNDERFLOW;
 454     return 0;
 455 }
 456
 457 /*********************************************************************
 458  *              _atodbl_l  (MSVCRT.@)
 459  */
 460 int CDECL MSVCRT__atodbl_l(MSVCRT__CRT_DOUBLE *value, char *str, MSVCRT__locale_t locale)
 461 {
 462     int err;
 463
 464     value->x = strtod_helper(str, NULL, locale, &err);
 465     if(isinf(value->x))
 466         return MSVCRT__OVERFLOW;
 467     if((value->x!=0 || err) && value->x>-MSVCRT_DBL_MIN && value->x<MSVCRT_DBL_MIN)
 468         return MSVCRT__UNDERFLOW;
 469     return 0;
 470 }
 471
 472 /*********************************************************************
 473  *              _atodbl  (MSVCRT.@)
 474  */
 475 int CDECL MSVCRT__atodbl(MSVCRT__CRT_DOUBLE *value, char *str)
 476 {
 477     return MSVCRT__atodbl_l(value, str, NULL);
 478 }
 479
 480 /*********************************************************************
 481  *              _strcoll_l (MSVCRT.@)
 482  */
 483 int CDECL MSVCRT_strcoll_l( const char* str1, const char* str2, MSVCRT__locale_t locale )
 484 {
 485     MSVCRT_pthreadlocinfo locinfo;
 486
 487     if(!locale)
 488         locinfo = get_locinfo();
 489     else
 490         locinfo = locale->locinfo;
 491
 492     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], 0, str1, -1, str2, -1)-CSTR_EQUAL;
 493 }
 494
 495 /*********************************************************************
 496  *              strcoll (MSVCRT.@)
 497  */
 498 int CDECL MSVCRT_strcoll( const char* str1, const char* str2 )
 499 {
 500     return MSVCRT_strcoll_l(str1, str2, NULL);
 501 }
 502
 503 /*********************************************************************
 504  *              _stricoll_l (MSVCRT.@)
 505  */
 506 int CDECL MSVCRT__stricoll_l( const char* str1, const char* str2, MSVCRT__locale_t locale )
 507 {
 508     MSVCRT_pthreadlocinfo locinfo;
 509
 510     if(!locale)
 511         locinfo = get_locinfo();
 512     else
 513         locinfo = locale->locinfo;
 514
 515     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], NORM_IGNORECASE,
 516             str1, -1, str2, -1)-CSTR_EQUAL;
 517 }
 518
 519 /*********************************************************************
 520  *              _stricoll (MSVCRT.@)
 521  */
 522 int CDECL MSVCRT__stricoll( const char* str1, const char* str2 )
 523 {
 524     return MSVCRT__stricoll_l(str1, str2, NULL);
 525 }
 526
 527 /*********************************************************************
 528  *              _strncoll_l (MSVCRT.@)
 529  */
 530 int CDECL MSVCRT_strncoll_l( const char* str1, const char* str2, MSVCRT_size_t count, MSVCRT__locale_t locale )
 531 {
 532     MSVCRT_pthreadlocinfo locinfo;
 533
 534     if(!locale)
 535         locinfo = get_locinfo();
 536     else
 537         locinfo = locale->locinfo;
 538
 539     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], 0, str1, count, str2, count)-CSTR_EQUAL;
 540 }
 541
 542 /*********************************************************************
 543  *              strncoll (MSVCRT.@)
 544  */
 545 int CDECL MSVCRT_strncoll( const char* str1, const char* str2, MSVCRT_size_t count )
 546 {
 547     return MSVCRT_strncoll_l(str1, str2, count, NULL);
 548 }
 549
 550 /*********************************************************************
 551  *              _strnicoll_l (MSVCRT.@)
 552  */
 553 int CDECL MSVCRT__strnicoll_l( const char* str1, const char* str2, MSVCRT_size_t count, MSVCRT__locale_t locale )
 554 {
 555     MSVCRT_pthreadlocinfo locinfo;
 556
 557     if(!locale)
 558         locinfo = get_locinfo();
 559     else
 560         locinfo = locale->locinfo;
 561
 562     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], NORM_IGNORECASE,
 563             str1, count, str2, count)-CSTR_EQUAL;
 564 }
 565
 566 /*********************************************************************
 567  *              _strnicoll (MSVCRT.@)
 568  */
 569 int CDECL MSVCRT__strnicoll( const char* str1, const char* str2, MSVCRT_size_t count )
 570 {
 571     return MSVCRT__strnicoll_l(str1, str2, count, NULL);
 572 }
 573
 574 /*********************************************************************
 575  *      strcpy_s (MSVCRT.@)
 576  */
 577 int CDECL MSVCRT_strcpy_s( char* dst, MSVCRT_size_t elem, const char* src )
 578 {
 579     MSVCRT_size_t i;
 580     if(!elem) return MSVCRT_EINVAL;
 581     if(!dst) return MSVCRT_EINVAL;
 582     if(!src)
 583     {
 584         dst[0] = '\0';
 585         return MSVCRT_EINVAL;
 586     }
 587
 588     for(i = 0; i < elem; i++)
 589     {
 590         if((dst[i] = src[i]) == '\0') return 0;
 591     }
 592     dst[0] = '\0';
 593     return MSVCRT_ERANGE;
 594 }
 595
 596 /*********************************************************************
 597  *      strcat_s (MSVCRT.@)
 598  */
 599 int CDECL MSVCRT_strcat_s( char* dst, MSVCRT_size_t elem, const char* src )
 600 {
 601     MSVCRT_size_t i, j;
 602     if(!dst) return MSVCRT_EINVAL;
 603     if(elem == 0) return MSVCRT_EINVAL;
 604     if(!src)
 605     {
 606         dst[0] = '\0';
 607         return MSVCRT_EINVAL;
 608     }
 609
 610     for(i = 0; i < elem; i++)
 611     {
 612         if(dst[i] == '\0')
 613         {
 614             for(j = 0; (j + i) < elem; j++)
 615             {
 616                 if((dst[j + i] = src[j]) == '\0') return 0;
 617             }
 618         }
 619     }
 620     /* Set the first element to 0, not the first element after the skipped part */
 621     dst[0] = '\0';
 622     return MSVCRT_ERANGE;
 623 }
 624
 625 /*********************************************************************
 626  *      strncat_s (MSVCRT.@)
 627  */
 628 int CDECL MSVCRT_strncat_s( char* dst, MSVCRT_size_t elem, const char* src, MSVCRT_size_t count )
 629 {
 630     MSVCRT_size_t i, j;
 631
 632     if (!MSVCRT_CHECK_PMT(dst != 0)) return MSVCRT_EINVAL;
 633     if (!MSVCRT_CHECK_PMT(elem != 0)) return MSVCRT_EINVAL;
 634     if (!MSVCRT_CHECK_PMT(src != 0))
 635     {
 636         dst[0] = '\0';
 637         return MSVCRT_EINVAL;
 638     }
 639
 640     for(i = 0; i < elem; i++)
 641     {
 642         if(dst[i] == '\0')
 643         {
 644             for(j = 0; (j + i) < elem; j++)
 645             {
 646                 if(count == MSVCRT__TRUNCATE && j + i == elem - 1)
 647                 {
 648                     dst[j + i] = '\0';
 649                     return MSVCRT_STRUNCATE;
 650                 }
 651                 if(j == count || (dst[j + i] = src[j]) == '\0')
 652                 {
 653                     dst[j + i] = '\0';
 654                     return 0;
 655                 }
 656             }
 657         }
 658     }
 659     /* Set the first element to 0, not the first element after the skipped part */
 660     dst[0] = '\0';
 661     return MSVCRT_ERANGE;
 662 }
 663
 664 /*********************************************************************
 665  *              strxfrm (MSVCRT.@)
 666  */
 667 MSVCRT_size_t CDECL MSVCRT_strxfrm( char *dest, const char *src, MSVCRT_size_t len )
 668 {
 669     /* FIXME: handle Windows locale */
 670     return strxfrm( dest, src, len );
 671 }
 672
 673 /********************************************************************
 674  *              _atoldbl (MSVCRT.@)
 675  */
 676 int CDECL MSVCRT__atoldbl(MSVCRT__LDOUBLE *value, const char *str)
 677 {
 678   /* FIXME needs error checking for huge/small values */
 679 #ifdef HAVE_STRTOLD
 680   long double ld;
 681   TRACE("str %s value %p\n",str,value);
 682   ld = strtold(str,0);
 683   memcpy(value, &ld, 10);
 684 #else
 685   FIXME("stub, str %s value %p\n",str,value);
 686 #endif
 687   return 0;
 688 }
 689
 690 /********************************************************************
 691  *              __STRINGTOLD (MSVCRT.@)
 692  */
 693 int CDECL __STRINGTOLD( MSVCRT__LDOUBLE *value, char **endptr, const char *str, int flags )
 694 {
 695 #ifdef HAVE_STRTOLD
 696     long double ld;
 697     FIXME("%p %p %s %x partial stub\n", value, endptr, str, flags );
 698     ld = strtold(str,0);
 699     memcpy(value, &ld, 10);
 700 #else
 701     FIXME("%p %p %s %x stub\n", value, endptr, str, flags );
 702 #endif
 703     return 0;
 704 }
 705
 706 /******************************************************************
 707  *              strtol (MSVCRT.@)
 708  */
 709 MSVCRT_long CDECL MSVCRT_strtol(const char* nptr, char** end, int base)
 710 {
 711     /* wrapper to forward libc error code to msvcrt's error codes */
 712     long ret;
 713
 714     errno = 0;
 715     ret = strtol(nptr, end, base);
 716     switch (errno)
 717     {
 718     case ERANGE:        *MSVCRT__errno() = MSVCRT_ERANGE;       break;
 719     case EINVAL:        *MSVCRT__errno() = MSVCRT_EINVAL;       break;
 720     default:
 721         /* cope with the fact that we may use 64bit long integers on libc
 722          * while msvcrt always uses 32bit long integers
 723          */
 724         if (ret > MSVCRT_LONG_MAX)
 725         {
 726             ret = MSVCRT_LONG_MAX;
 727             *MSVCRT__errno() = MSVCRT_ERANGE;
 728         }
 729         else if (ret < -MSVCRT_LONG_MAX - 1)
 730         {
 731             ret = -MSVCRT_LONG_MAX - 1;
 732             *MSVCRT__errno() = MSVCRT_ERANGE;
 733         }
 734         break;
 735     }
 736
 737     return ret;
 738 }
 739
 740 /******************************************************************
 741  *              strtoul (MSVCRT.@)
 742  */
 743 MSVCRT_ulong CDECL MSVCRT_strtoul(const char* nptr, char** end, int base)
 744 {
 745     /* wrapper to forward libc error code to msvcrt's error codes */
 746     unsigned long ret;
 747
 748     errno = 0;
 749     ret = strtoul(nptr, end, base);
 750     switch (errno)
 751     {
 752     case ERANGE:        *MSVCRT__errno() = MSVCRT_ERANGE;       break;
 753     case EINVAL:        *MSVCRT__errno() = MSVCRT_EINVAL;       break;
 754     default:
 755         /* cope with the fact that we may use 64bit long integers on libc
 756          * while msvcrt always uses 32bit long integers
 757          */
 758         if (ret > MSVCRT_ULONG_MAX)
 759         {
 760             ret = MSVCRT_ULONG_MAX;
 761             *MSVCRT__errno() = MSVCRT_ERANGE;
 762         }
 763         break;
 764     }
 765
 766     return ret;
 767 }
 768
 769 /******************************************************************
 770  *              strnlen (MSVCRT.@)
 771  */
 772 MSVCRT_size_t CDECL MSVCRT_strnlen(const char *s, MSVCRT_size_t maxlen)
 773 {
 774     MSVCRT_size_t i;
 775
 776     for(i=0; i<maxlen; i++)
 777         if(!s[i]) break;
 778
 779     return i;
 780 }
 781
 782 /*********************************************************************
 783  *  _strtoi64_l (MSVCRT.@)
 784  *
 785  * FIXME: locale parameter is ignored
 786  */
 787 __int64 CDECL MSVCRT_strtoi64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
 788 {
 789     BOOL negative = FALSE;
 790     __int64 ret = 0;
 791
 792     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
 793
 794     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
 795     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
 796     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
 797
 798     while(isspace(*nptr)) nptr++;
 799
 800     if(*nptr == '-') {
 801         negative = TRUE;
 802         nptr++;
 803     } else if(*nptr == '+')
 804         nptr++;
 805
 806     if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') {
 807         base = 16;
 808         nptr += 2;
 809     }
 810
 811     if(base == 0) {
 812         if(*nptr=='0')
 813             base = 8;
 814         else
 815             base = 10;
 816     }
 817
 818     while(*nptr) {
 819         char cur = tolower(*nptr);
 820         int v;
 821
 822         if(isdigit(cur)) {
 823             if(cur >= '0'+base)
 824                 break;
 825             v = cur-'0';
 826         } else {
 827             if(cur<'a' || cur>='a'+base-10)
 828                 break;
 829             v = cur-'a'+10;
 830         }
 831
 832         if(negative)
 833             v = -v;
 834
 835         nptr++;
 836
 837         if(!negative && (ret>MSVCRT_I64_MAX/base || ret*base>MSVCRT_I64_MAX-v)) {
 838             ret = MSVCRT_I64_MAX;
 839             *MSVCRT__errno() = MSVCRT_ERANGE;
 840         } else if(negative && (ret<MSVCRT_I64_MIN/base || ret*base<MSVCRT_I64_MIN-v)) {
 841             ret = MSVCRT_I64_MIN;
 842             *MSVCRT__errno() = MSVCRT_ERANGE;
 843         } else
 844             ret = ret*base + v;
 845     }
 846
 847     if(endptr)
 848         *endptr = (char*)nptr;
 849
 850     return ret;
 851 }
 852
 853 /*********************************************************************
 854  *  _strtoi64 (MSVCRT.@)
 855  */
 856 __int64 CDECL MSVCRT_strtoi64(const char *nptr, char **endptr, int base)
 857 {
 858     return MSVCRT_strtoi64_l(nptr, endptr, base, NULL);
 859 }
 860
 861 /*********************************************************************
 862  *  _atoi_l (MSVCRT.@)
 863  */
 864 int MSVCRT__atoi_l(const char *str, MSVCRT__locale_t locale)
 865 {
 866     __int64 ret = MSVCRT_strtoi64_l(str, NULL, 10, locale);
 867
 868     if(ret > INT_MAX) {
 869         ret = INT_MAX;
 870         *MSVCRT__errno() = MSVCRT_ERANGE;
 871     } else if(ret < INT_MIN) {
 872         ret = INT_MIN;
 873         *MSVCRT__errno() = MSVCRT_ERANGE;
 874     }
 875     return ret;
 876 }
 877
 878 /*********************************************************************
 879  *  _strtoui64_l (MSVCRT.@)
 880  *
 881  * FIXME: locale parameter is ignored
 882  */
 883 unsigned __int64 CDECL MSVCRT_strtoui64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
 884 {
 885     BOOL negative = FALSE;
 886     unsigned __int64 ret = 0;
 887
 888     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
 889
 890     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
 891     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
 892     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
 893
 894     while(isspace(*nptr)) nptr++;
 895
 896     if(*nptr == '-') {
 897         negative = TRUE;
 898         nptr++;
 899     } else if(*nptr == '+')
 900         nptr++;
 901
 902     if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') {
 903         base = 16;
 904         nptr += 2;
 905     }
 906
 907     if(base == 0) {
 908         if(*nptr=='0')
 909             base = 8;
 910         else
 911             base = 10;
 912     }
 913
 914     while(*nptr) {
 915         char cur = tolower(*nptr);
 916         int v;
 917
 918         if(isdigit(cur)) {
 919             if(cur >= '0'+base)
 920                 break;
 921             v = *nptr-'0';
 922         } else {
 923             if(cur<'a' || cur>='a'+base-10)
 924                 break;
 925             v = cur-'a'+10;
 926         }
 927
 928         nptr++;
 929
 930         if(ret>MSVCRT_UI64_MAX/base || ret*base>MSVCRT_UI64_MAX-v) {
 931             ret = MSVCRT_UI64_MAX;
 932             *MSVCRT__errno() = MSVCRT_ERANGE;
 933         } else
 934             ret = ret*base + v;
 935     }
 936
 937     if(endptr)
 938         *endptr = (char*)nptr;
 939
 940     return negative ? -ret : ret;
 941 }
 942
 943 /*********************************************************************
 944  *  _strtoui64 (MSVCRT.@)
 945  */
 946 unsigned __int64 CDECL MSVCRT_strtoui64(const char *nptr, char **endptr, int base)
 947 {
 948     return MSVCRT_strtoui64_l(nptr, endptr, base, NULL);
 949 }
 950
 951 /*********************************************************************
 952  *  _ltoa_s (MSVCRT.@)
 953  */
 954 int CDECL _ltoa_s(MSVCRT_long value, char *str, MSVCRT_size_t size, int radix)
 955 {
 956     MSVCRT_ulong val;
 957     unsigned int digit;
 958     int is_negative;
 959     char buffer[33], *pos;
 960     size_t len;
 961
 962     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
 963     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
 964     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
 965     {
 966         str[0] = '\0';
 967         return MSVCRT_EINVAL;
 968     }
 969
 970     if (value < 0 && radix == 10)
 971     {
 972         is_negative = 1;
 973         val = -value;
 974     }
 975     else
 976     {
 977         is_negative = 0;
 978         val = value;
 979     }
 980
 981     pos = buffer + 32;
 982     *pos = '\0';
 983
 984     do
 985     {
 986         digit = val % radix;
 987         val /= radix;
 988
 989         if (digit < 10)
 990             *--pos = '0' + digit;
 991         else
 992             *--pos = 'a' + digit - 10;
 993     }
 994     while (val != 0);
 995
 996     if (is_negative)
 997         *--pos = '-';
 998
 999     len = buffer + 33 - pos;
1000     if (len > size)
1001     {
1002         size_t i;
1003         char *p = str;
1004
1005         /* Copy the temporary buffer backwards up to the available number of
1006          * characters. Don't copy the negative sign if present. */
1007
1008         if (is_negative)
1009         {
1010             p++;
1011             size--;
1012         }
1013
1014         for (pos = buffer + 31, i = 0; i < size; i++)
1015             *p++ = *pos--;
1016
1017         str[0] = '\0';
1018         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1019         return MSVCRT_ERANGE;
1020     }
1021
1022     memcpy(str, pos, len);
1023     return 0;
1024 }
1025
1026 /*********************************************************************
1027  *  _ltow_s (MSVCRT.@)
1028  */
1029 int CDECL _ltow_s(MSVCRT_long value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1030 {
1031     MSVCRT_ulong val;
1032     unsigned int digit;
1033     int is_negative;
1034     MSVCRT_wchar_t buffer[33], *pos;
1035     size_t len;
1036
1037     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1038     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1039     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1040     {
1041         str[0] = '\0';
1042         return MSVCRT_EINVAL;
1043     }
1044
1045     if (value < 0 && radix == 10)
1046     {
1047         is_negative = 1;
1048         val = -value;
1049     }
1050     else
1051     {
1052         is_negative = 0;
1053         val = value;
1054     }
1055
1056     pos = buffer + 32;
1057     *pos = '\0';
1058
1059     do
1060     {
1061         digit = val % radix;
1062         val /= radix;
1063
1064         if (digit < 10)
1065             *--pos = '0' + digit;
1066         else
1067             *--pos = 'a' + digit - 10;
1068     }
1069     while (val != 0);
1070
1071     if (is_negative)
1072         *--pos = '-';
1073
1074     len = buffer + 33 - pos;
1075     if (len > size)
1076     {
1077         size_t i;
1078         MSVCRT_wchar_t *p = str;
1079
1080         /* Copy the temporary buffer backwards up to the available number of
1081          * characters. Don't copy the negative sign if present. */
1082
1083         if (is_negative)
1084         {
1085             p++;
1086             size--;
1087         }
1088
1089         for (pos = buffer + 31, i = 0; i < size; i++)
1090             *p++ = *pos--;
1091
1092         str[0] = '\0';
1093         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1094         return MSVCRT_ERANGE;
1095     }
1096
1097     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1098     return 0;
1099 }
1100
1101 /*********************************************************************
1102  *  _itoa_s (MSVCRT.@)
1103  */
1104 int CDECL _itoa_s(int value, char *str, MSVCRT_size_t size, int radix)
1105 {
1106     return _ltoa_s(value, str, size, radix);
1107 }
1108
1109 /*********************************************************************
1110  *  _itow_s (MSVCRT.@)
1111  */
1112 int CDECL _itow_s(int value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1113 {
1114     return _ltow_s(value, str, size, radix);
1115 }
1116
1117 /*********************************************************************
1118  *  _ui64toa_s (MSVCRT.@)
1119  */
1120 int CDECL MSVCRT__ui64toa_s(unsigned __int64 value, char *str,
1121         MSVCRT_size_t size, int radix)
1122 {
1123     char buffer[65], *pos;
1124     int digit;
1125
1126     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1127     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1128     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1129     {
1130         str[0] = '\0';
1131         return MSVCRT_EINVAL;
1132     }
1133
1134     pos = buffer+64;
1135     *pos = '\0';
1136
1137     do {
1138         digit = value%radix;
1139         value /= radix;
1140
1141         if(digit < 10)
1142             *--pos = '0'+digit;
1143         else
1144             *--pos = 'a'+digit-10;
1145     }while(value != 0);
1146
1147     if(buffer-pos+65 > size) {
1148         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
1149         return MSVCRT_EINVAL;
1150     }
1151
1152     memcpy(str, pos, buffer-pos+65);
1153     return 0;
1154 }
1155
1156 /*********************************************************************
1157  *      _ui64tow_s  (MSVCRT.@)
1158  */
1159 int CDECL MSVCRT__ui64tow_s( unsigned __int64 value, MSVCRT_wchar_t *str,
1160                              MSVCRT_size_t size, int radix )
1161 {
1162     MSVCRT_wchar_t 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 = value / radix;
1179         if (digit < 10)
1180             *--pos = '0' + digit;
1181         else
1182             *--pos = 'a' + digit - 10;
1183     } while (value != 0);
1184
1185     if(buffer-pos+65 > size) {
1186         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
1187         return MSVCRT_EINVAL;
1188     }
1189
1190     memcpy(str, pos, buffer-pos+65);
1191     return 0;
1192 }
1193
1194 /*********************************************************************
1195  *  _ultoa_s (MSVCRT.@)
1196  */
1197 int CDECL _ultoa_s(MSVCRT_ulong value, char *str, MSVCRT_size_t size, int radix)
1198 {
1199     MSVCRT_ulong digit;
1200     char buffer[33], *pos;
1201     size_t len;
1202
1203     if (!str || !size || radix < 2 || radix > 36)
1204     {
1205         if (str && size)
1206             str[0] = '\0';
1207
1208         *MSVCRT__errno() = MSVCRT_EINVAL;
1209         return MSVCRT_EINVAL;
1210     }
1211
1212     pos = buffer + 32;
1213     *pos = '\0';
1214
1215     do
1216     {
1217         digit = value % radix;
1218         value /= radix;
1219
1220         if (digit < 10)
1221             *--pos = '0' + digit;
1222         else
1223             *--pos = 'a' + digit - 10;
1224     }
1225     while (value != 0);
1226
1227     len = buffer + 33 - pos;
1228     if (len > size)
1229     {
1230         size_t i;
1231         char *p = str;
1232
1233         /* Copy the temporary buffer backwards up to the available number of
1234          * characters. */
1235
1236         for (pos = buffer + 31, i = 0; i < size; i++)
1237             *p++ = *pos--;
1238
1239         str[0] = '\0';
1240         *MSVCRT__errno() = MSVCRT_ERANGE;
1241         return MSVCRT_ERANGE;
1242     }
1243
1244     memcpy(str, pos, len);
1245     return 0;
1246 }
1247
1248 /*********************************************************************
1249  *  _ultow_s (MSVCRT.@)
1250  */
1251 int CDECL _ultow_s(MSVCRT_ulong value, WCHAR *str, MSVCRT_size_t size, int radix)
1252 {
1253     MSVCRT_ulong digit;
1254     WCHAR buffer[33], *pos;
1255     size_t len;
1256
1257     if (!str || !size || radix < 2 || radix > 36)
1258     {
1259         if (str && size)
1260             str[0] = '\0';
1261
1262         *MSVCRT__errno() = MSVCRT_EINVAL;
1263         return MSVCRT_EINVAL;
1264     }
1265
1266     pos = buffer + 32;
1267     *pos = '\0';
1268
1269     do
1270     {
1271         digit = value % radix;
1272         value /= radix;
1273
1274         if (digit < 10)
1275             *--pos = '0' + digit;
1276         else
1277             *--pos = 'a' + digit - 10;
1278     }
1279     while (value != 0);
1280
1281     len = buffer + 33 - pos;
1282     if (len > size)
1283     {
1284         size_t i;
1285         WCHAR *p = str;
1286
1287         /* Copy the temporary buffer backwards up to the available number of
1288          * characters. */
1289
1290         for (pos = buffer + 31, i = 0; i < size; i++)
1291             *p++ = *pos--;
1292
1293         str[0] = '\0';
1294         *MSVCRT__errno() = MSVCRT_ERANGE;
1295         return MSVCRT_ERANGE;
1296     }
1297
1298     memcpy(str, pos, len * sizeof(WCHAR));
1299     return 0;
1300 }
1301
1302 /*********************************************************************
1303  *  _i64toa_s (MSVCRT.@)
1304  */
1305 int CDECL _i64toa_s(__int64 value, char *str, MSVCRT_size_t size, int radix)
1306 {
1307     unsigned __int64 val;
1308     unsigned int digit;
1309     int is_negative;
1310     char buffer[65], *pos;
1311     size_t len;
1312
1313     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1314     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1315     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1316     {
1317         str[0] = '\0';
1318         return MSVCRT_EINVAL;
1319     }
1320
1321     if (value < 0 && radix == 10)
1322     {
1323         is_negative = 1;
1324         val = -value;
1325     }
1326     else
1327     {
1328         is_negative = 0;
1329         val = value;
1330     }
1331
1332     pos = buffer + 64;
1333     *pos = '\0';
1334
1335     do
1336     {
1337         digit = val % radix;
1338         val /= radix;
1339
1340         if (digit < 10)
1341             *--pos = '0' + digit;
1342         else
1343             *--pos = 'a' + digit - 10;
1344     }
1345     while (val != 0);
1346
1347     if (is_negative)
1348         *--pos = '-';
1349
1350     len = buffer + 65 - pos;
1351     if (len > size)
1352     {
1353         size_t i;
1354         char *p = str;
1355
1356         /* Copy the temporary buffer backwards up to the available number of
1357          * characters. Don't copy the negative sign if present. */
1358
1359         if (is_negative)
1360         {
1361             p++;
1362             size--;
1363         }
1364
1365         for (pos = buffer + 63, i = 0; i < size; i++)
1366             *p++ = *pos--;
1367
1368         str[0] = '\0';
1369         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1370         return MSVCRT_ERANGE;
1371     }
1372
1373     memcpy(str, pos, len);
1374     return 0;
1375 }
1376
1377 /*********************************************************************
1378  *  _i64tow_s (MSVCRT.@)
1379  */
1380 int CDECL _i64tow_s(__int64 value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1381 {
1382     unsigned __int64 val;
1383     unsigned int digit;
1384     int is_negative;
1385     MSVCRT_wchar_t buffer[65], *pos;
1386     size_t len;
1387
1388     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1389     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1390     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1391     {
1392         str[0] = '\0';
1393         return MSVCRT_EINVAL;
1394     }
1395
1396     if (value < 0 && radix == 10)
1397     {
1398         is_negative = 1;
1399         val = -value;
1400     }
1401     else
1402     {
1403         is_negative = 0;
1404         val = value;
1405     }
1406
1407     pos = buffer + 64;
1408     *pos = '\0';
1409
1410     do
1411     {
1412         digit = val % radix;
1413         val /= radix;
1414
1415         if (digit < 10)
1416             *--pos = '0' + digit;
1417         else
1418             *--pos = 'a' + digit - 10;
1419     }
1420     while (val != 0);
1421
1422     if (is_negative)
1423         *--pos = '-';
1424
1425     len = buffer + 65 - pos;
1426     if (len > size)
1427     {
1428         size_t i;
1429         MSVCRT_wchar_t *p = str;
1430
1431         /* Copy the temporary buffer backwards up to the available number of
1432          * characters. Don't copy the negative sign if present. */
1433
1434         if (is_negative)
1435         {
1436             p++;
1437             size--;
1438         }
1439
1440         for (pos = buffer + 63, i = 0; i < size; i++)
1441             *p++ = *pos--;
1442
1443         str[0] = '\0';
1444         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1445         return MSVCRT_ERANGE;
1446     }
1447
1448     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1449     return 0;
1450 }
1451
1452 #define I10_OUTPUT_MAX_PREC 21
1453 /* Internal structure used by $I10_OUTPUT */
1454 struct _I10_OUTPUT_DATA {
1455     short pos;
1456     char sign;
1457     BYTE len;
1458     char str[I10_OUTPUT_MAX_PREC+1]; /* add space for '\0' */
1459 };
1460
1461 /*********************************************************************
1462  *              $I10_OUTPUT (MSVCRT.@)
1463  * ld80 - long double (Intel 80 bit FP in 12 bytes) to be printed to data
1464  * prec - precision of part, we're interested in
1465  * flag - 0 for first prec digits, 1 for fractional part
1466  * data - data to be populated
1467  *
1468  * return value
1469  *      0 if given double is NaN or INF
1470  *      1 otherwise
1471  *
1472  * FIXME
1473  *      Native sets last byte of data->str to '0' or '9', I don't know what
1474  *      it means. Current implementation sets it always to '0'.
1475  */
1476 int CDECL MSVCRT_I10_OUTPUT(MSVCRT__LDOUBLE ld80, int prec, int flag, struct _I10_OUTPUT_DATA *data)
1477 {
1478     static const char inf_str[] = "1#INF";
1479     static const char nan_str[] = "1#QNAN";
1480
1481     /* MS' long double type wants 12 bytes for Intel's 80 bit FP format.
1482      * Some UNIX have sizeof(long double) == 16, yet only 80 bit are used.
1483      * Assume long double uses 80 bit FP, never seen 128 bit FP. */
1484     long double ld = 0;
1485     double d;
1486     char format[8];
1487     char buf[I10_OUTPUT_MAX_PREC+9]; /* 9 = strlen("0.e+0000") + '\0' */
1488     char *p;
1489
1490     memcpy(&ld, &ld80, 10);
1491     d = ld;
1492     TRACE("(%lf %d %x %p)\n", d, prec, flag, data);
1493
1494     if(d<0) {
1495         data->sign = '-';
1496         d = -d;
1497     } else
1498         data->sign = ' ';
1499
1500     if(isinf(d)) {
1501         data->pos = 1;
1502         data->len = 5;
1503         memcpy(data->str, inf_str, sizeof(inf_str));
1504
1505         return 0;
1506     }
1507
1508     if(isnan(d)) {
1509         data->pos = 1;
1510         data->len = 6;
1511         memcpy(data->str, nan_str, sizeof(nan_str));
1512
1513         return 0;
1514     }
1515
1516     if(flag&1) {
1517         int exp = 1+floor(log10(d));
1518
1519         prec += exp;
1520         if(exp < 0)
1521             prec--;
1522     }
1523     prec--;
1524
1525     if(prec+1 > I10_OUTPUT_MAX_PREC)
1526         prec = I10_OUTPUT_MAX_PREC-1;
1527     else if(prec < 0) {
1528         d = 0.0;
1529         prec = 0;
1530     }
1531
1532     sprintf(format, "%%.%dle", prec);
1533     sprintf(buf, format, d);
1534
1535     buf[1] = buf[0];
1536     data->pos = atoi(buf+prec+3);
1537     if(buf[1] != '0')
1538         data->pos++;
1539
1540     for(p = buf+prec+1; p>buf+1 && *p=='0'; p--);
1541     data->len = p-buf;
1542
1543     memcpy(data->str, buf+1, data->len);
1544     data->str[data->len] = '\0';
1545
1546     if(buf[1]!='0' && prec-data->len+1>0)
1547         memcpy(data->str+data->len+1, buf+data->len+1, prec-data->len+1);
1548
1549     return 1;
1550 }
1551 #undef I10_OUTPUT_MAX_PREC
1552
1553 /*********************************************************************
1554  *                  memcpy   (NTDLL.@)
1555  */
1556 void * __cdecl MSVCRT_memcpy( void *dst, const void *src, size_t n )
1557 {
1558     return memmove( dst, src, n );
1559 }