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 /*********************************************************************
 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  *  _atoi_l (MSVCRT.@)
 919  */
 920 int MSVCRT__atoi_l(const char *str, MSVCRT__locale_t locale)
 921 {
 922     __int64 ret = MSVCRT_strtoi64_l(str, NULL, 10, locale);
 923
 924     if(ret > INT_MAX) {
 925         ret = INT_MAX;
 926         *MSVCRT__errno() = MSVCRT_ERANGE;
 927     } else if(ret < INT_MIN) {
 928         ret = INT_MIN;
 929         *MSVCRT__errno() = MSVCRT_ERANGE;
 930     }
 931     return ret;
 932 }
 933
 934 /*********************************************************************
 935  *  _strtoui64_l (MSVCRT.@)
 936  *
 937  * FIXME: locale parameter is ignored
 938  */
 939 unsigned __int64 CDECL MSVCRT_strtoui64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
 940 {
 941     BOOL negative = FALSE;
 942     unsigned __int64 ret = 0;
 943
 944     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
 945
 946     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
 947     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
 948     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
 949
 950     while(isspace(*nptr)) nptr++;
 951
 952     if(*nptr == '-') {
 953         negative = TRUE;
 954         nptr++;
 955     } else if(*nptr == '+')
 956         nptr++;
 957
 958     if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') {
 959         base = 16;
 960         nptr += 2;
 961     }
 962
 963     if(base == 0) {
 964         if(*nptr=='0')
 965             base = 8;
 966         else
 967             base = 10;
 968     }
 969
 970     while(*nptr) {
 971         char cur = tolower(*nptr);
 972         int v;
 973
 974         if(isdigit(cur)) {
 975             if(cur >= '0'+base)
 976                 break;
 977             v = *nptr-'0';
 978         } else {
 979             if(cur<'a' || cur>='a'+base-10)
 980                 break;
 981             v = cur-'a'+10;
 982         }
 983
 984         nptr++;
 985
 986         if(ret>MSVCRT_UI64_MAX/base || ret*base>MSVCRT_UI64_MAX-v) {
 987             ret = MSVCRT_UI64_MAX;
 988             *MSVCRT__errno() = MSVCRT_ERANGE;
 989         } else
 990             ret = ret*base + v;
 991     }
 992
 993     if(endptr)
 994         *endptr = (char*)nptr;
 995
 996     return negative ? -ret : ret;
 997 }
 998
 999 /*********************************************************************
1000  *  _strtoui64 (MSVCRT.@)
1001  */
1002 unsigned __int64 CDECL MSVCRT_strtoui64(const char *nptr, char **endptr, int base)
1003 {
1004     return MSVCRT_strtoui64_l(nptr, endptr, base, NULL);
1005 }
1006
1007 /*********************************************************************
1008  *  _ltoa_s (MSVCRT.@)
1009  */
1010 int CDECL _ltoa_s(MSVCRT_long value, char *str, MSVCRT_size_t size, int radix)
1011 {
1012     MSVCRT_ulong val;
1013     unsigned int digit;
1014     int is_negative;
1015     char buffer[33], *pos;
1016     size_t len;
1017
1018     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1019     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1020     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1021     {
1022         str[0] = '\0';
1023         return MSVCRT_EINVAL;
1024     }
1025
1026     if (value < 0 && radix == 10)
1027     {
1028         is_negative = 1;
1029         val = -value;
1030     }
1031     else
1032     {
1033         is_negative = 0;
1034         val = value;
1035     }
1036
1037     pos = buffer + 32;
1038     *pos = '\0';
1039
1040     do
1041     {
1042         digit = val % radix;
1043         val /= radix;
1044
1045         if (digit < 10)
1046             *--pos = '0' + digit;
1047         else
1048             *--pos = 'a' + digit - 10;
1049     }
1050     while (val != 0);
1051
1052     if (is_negative)
1053         *--pos = '-';
1054
1055     len = buffer + 33 - pos;
1056     if (len > size)
1057     {
1058         size_t i;
1059         char *p = str;
1060
1061         /* Copy the temporary buffer backwards up to the available number of
1062          * characters. Don't copy the negative sign if present. */
1063
1064         if (is_negative)
1065         {
1066             p++;
1067             size--;
1068         }
1069
1070         for (pos = buffer + 31, i = 0; i < size; i++)
1071             *p++ = *pos--;
1072
1073         str[0] = '\0';
1074         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1075         return MSVCRT_ERANGE;
1076     }
1077
1078     memcpy(str, pos, len);
1079     return 0;
1080 }
1081
1082 /*********************************************************************
1083  *  _ltow_s (MSVCRT.@)
1084  */
1085 int CDECL _ltow_s(MSVCRT_long value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1086 {
1087     MSVCRT_ulong val;
1088     unsigned int digit;
1089     int is_negative;
1090     MSVCRT_wchar_t buffer[33], *pos;
1091     size_t len;
1092
1093     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1094     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1095     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1096     {
1097         str[0] = '\0';
1098         return MSVCRT_EINVAL;
1099     }
1100
1101     if (value < 0 && radix == 10)
1102     {
1103         is_negative = 1;
1104         val = -value;
1105     }
1106     else
1107     {
1108         is_negative = 0;
1109         val = value;
1110     }
1111
1112     pos = buffer + 32;
1113     *pos = '\0';
1114
1115     do
1116     {
1117         digit = val % radix;
1118         val /= radix;
1119
1120         if (digit < 10)
1121             *--pos = '0' + digit;
1122         else
1123             *--pos = 'a' + digit - 10;
1124     }
1125     while (val != 0);
1126
1127     if (is_negative)
1128         *--pos = '-';
1129
1130     len = buffer + 33 - pos;
1131     if (len > size)
1132     {
1133         size_t i;
1134         MSVCRT_wchar_t *p = str;
1135
1136         /* Copy the temporary buffer backwards up to the available number of
1137          * characters. Don't copy the negative sign if present. */
1138
1139         if (is_negative)
1140         {
1141             p++;
1142             size--;
1143         }
1144
1145         for (pos = buffer + 31, i = 0; i < size; i++)
1146             *p++ = *pos--;
1147
1148         str[0] = '\0';
1149         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1150         return MSVCRT_ERANGE;
1151     }
1152
1153     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1154     return 0;
1155 }
1156
1157 /*********************************************************************
1158  *  _itoa_s (MSVCRT.@)
1159  */
1160 int CDECL _itoa_s(int value, char *str, MSVCRT_size_t size, int radix)
1161 {
1162     return _ltoa_s(value, str, size, radix);
1163 }
1164
1165 /*********************************************************************
1166  *  _itow_s (MSVCRT.@)
1167  */
1168 int CDECL _itow_s(int value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1169 {
1170     return _ltow_s(value, str, size, radix);
1171 }
1172
1173 /*********************************************************************
1174  *  _ui64toa_s (MSVCRT.@)
1175  */
1176 int CDECL MSVCRT__ui64toa_s(unsigned __int64 value, char *str,
1177         MSVCRT_size_t size, int radix)
1178 {
1179     char buffer[65], *pos;
1180     int digit;
1181
1182     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1183     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1184     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1185     {
1186         str[0] = '\0';
1187         return MSVCRT_EINVAL;
1188     }
1189
1190     pos = buffer+64;
1191     *pos = '\0';
1192
1193     do {
1194         digit = value%radix;
1195         value /= radix;
1196
1197         if(digit < 10)
1198             *--pos = '0'+digit;
1199         else
1200             *--pos = 'a'+digit-10;
1201     }while(value != 0);
1202
1203     if(buffer-pos+65 > size) {
1204         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
1205         return MSVCRT_EINVAL;
1206     }
1207
1208     memcpy(str, pos, buffer-pos+65);
1209     return 0;
1210 }
1211
1212 /*********************************************************************
1213  *      _ui64tow_s  (MSVCRT.@)
1214  */
1215 int CDECL MSVCRT__ui64tow_s( unsigned __int64 value, MSVCRT_wchar_t *str,
1216                              MSVCRT_size_t size, int radix )
1217 {
1218     MSVCRT_wchar_t buffer[65], *pos;
1219     int digit;
1220
1221     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1222     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1223     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1224     {
1225         str[0] = '\0';
1226         return MSVCRT_EINVAL;
1227     }
1228
1229     pos = &buffer[64];
1230     *pos = '\0';
1231
1232     do {
1233         digit = value % radix;
1234         value = value / radix;
1235         if (digit < 10)
1236             *--pos = '0' + digit;
1237         else
1238             *--pos = 'a' + digit - 10;
1239     } while (value != 0);
1240
1241     if(buffer-pos+65 > size) {
1242         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
1243         return MSVCRT_EINVAL;
1244     }
1245
1246     memcpy(str, pos, buffer-pos+65);
1247     return 0;
1248 }
1249
1250 /*********************************************************************
1251  *  _ultoa_s (MSVCRT.@)
1252  */
1253 int CDECL _ultoa_s(MSVCRT_ulong value, char *str, MSVCRT_size_t size, int radix)
1254 {
1255     MSVCRT_ulong digit;
1256     char buffer[33], *pos;
1257     size_t len;
1258
1259     if (!str || !size || radix < 2 || radix > 36)
1260     {
1261         if (str && size)
1262             str[0] = '\0';
1263
1264         *MSVCRT__errno() = MSVCRT_EINVAL;
1265         return MSVCRT_EINVAL;
1266     }
1267
1268     pos = buffer + 32;
1269     *pos = '\0';
1270
1271     do
1272     {
1273         digit = value % radix;
1274         value /= radix;
1275
1276         if (digit < 10)
1277             *--pos = '0' + digit;
1278         else
1279             *--pos = 'a' + digit - 10;
1280     }
1281     while (value != 0);
1282
1283     len = buffer + 33 - pos;
1284     if (len > size)
1285     {
1286         size_t i;
1287         char *p = str;
1288
1289         /* Copy the temporary buffer backwards up to the available number of
1290          * characters. */
1291
1292         for (pos = buffer + 31, i = 0; i < size; i++)
1293             *p++ = *pos--;
1294
1295         str[0] = '\0';
1296         *MSVCRT__errno() = MSVCRT_ERANGE;
1297         return MSVCRT_ERANGE;
1298     }
1299
1300     memcpy(str, pos, len);
1301     return 0;
1302 }
1303
1304 /*********************************************************************
1305  *  _ultow_s (MSVCRT.@)
1306  */
1307 int CDECL _ultow_s(MSVCRT_ulong value, WCHAR *str, MSVCRT_size_t size, int radix)
1308 {
1309     MSVCRT_ulong digit;
1310     WCHAR buffer[33], *pos;
1311     size_t len;
1312
1313     if (!str || !size || radix < 2 || radix > 36)
1314     {
1315         if (str && size)
1316             str[0] = '\0';
1317
1318         *MSVCRT__errno() = MSVCRT_EINVAL;
1319         return MSVCRT_EINVAL;
1320     }
1321
1322     pos = buffer + 32;
1323     *pos = '\0';
1324
1325     do
1326     {
1327         digit = value % radix;
1328         value /= radix;
1329
1330         if (digit < 10)
1331             *--pos = '0' + digit;
1332         else
1333             *--pos = 'a' + digit - 10;
1334     }
1335     while (value != 0);
1336
1337     len = buffer + 33 - pos;
1338     if (len > size)
1339     {
1340         size_t i;
1341         WCHAR *p = str;
1342
1343         /* Copy the temporary buffer backwards up to the available number of
1344          * characters. */
1345
1346         for (pos = buffer + 31, i = 0; i < size; i++)
1347             *p++ = *pos--;
1348
1349         str[0] = '\0';
1350         *MSVCRT__errno() = MSVCRT_ERANGE;
1351         return MSVCRT_ERANGE;
1352     }
1353
1354     memcpy(str, pos, len * sizeof(WCHAR));
1355     return 0;
1356 }
1357
1358 /*********************************************************************
1359  *  _i64toa_s (MSVCRT.@)
1360  */
1361 int CDECL _i64toa_s(__int64 value, char *str, MSVCRT_size_t size, int radix)
1362 {
1363     unsigned __int64 val;
1364     unsigned int digit;
1365     int is_negative;
1366     char buffer[65], *pos;
1367     size_t len;
1368
1369     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1370     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1371     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1372     {
1373         str[0] = '\0';
1374         return MSVCRT_EINVAL;
1375     }
1376
1377     if (value < 0 && radix == 10)
1378     {
1379         is_negative = 1;
1380         val = -value;
1381     }
1382     else
1383     {
1384         is_negative = 0;
1385         val = value;
1386     }
1387
1388     pos = buffer + 64;
1389     *pos = '\0';
1390
1391     do
1392     {
1393         digit = val % radix;
1394         val /= radix;
1395
1396         if (digit < 10)
1397             *--pos = '0' + digit;
1398         else
1399             *--pos = 'a' + digit - 10;
1400     }
1401     while (val != 0);
1402
1403     if (is_negative)
1404         *--pos = '-';
1405
1406     len = buffer + 65 - pos;
1407     if (len > size)
1408     {
1409         size_t i;
1410         char *p = str;
1411
1412         /* Copy the temporary buffer backwards up to the available number of
1413          * characters. Don't copy the negative sign if present. */
1414
1415         if (is_negative)
1416         {
1417             p++;
1418             size--;
1419         }
1420
1421         for (pos = buffer + 63, i = 0; i < size; i++)
1422             *p++ = *pos--;
1423
1424         str[0] = '\0';
1425         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1426         return MSVCRT_ERANGE;
1427     }
1428
1429     memcpy(str, pos, len);
1430     return 0;
1431 }
1432
1433 /*********************************************************************
1434  *  _i64tow_s (MSVCRT.@)
1435  */
1436 int CDECL _i64tow_s(__int64 value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1437 {
1438     unsigned __int64 val;
1439     unsigned int digit;
1440     int is_negative;
1441     MSVCRT_wchar_t buffer[65], *pos;
1442     size_t len;
1443
1444     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1445     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1446     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1447     {
1448         str[0] = '\0';
1449         return MSVCRT_EINVAL;
1450     }
1451
1452     if (value < 0 && radix == 10)
1453     {
1454         is_negative = 1;
1455         val = -value;
1456     }
1457     else
1458     {
1459         is_negative = 0;
1460         val = value;
1461     }
1462
1463     pos = buffer + 64;
1464     *pos = '\0';
1465
1466     do
1467     {
1468         digit = val % radix;
1469         val /= radix;
1470
1471         if (digit < 10)
1472             *--pos = '0' + digit;
1473         else
1474             *--pos = 'a' + digit - 10;
1475     }
1476     while (val != 0);
1477
1478     if (is_negative)
1479         *--pos = '-';
1480
1481     len = buffer + 65 - pos;
1482     if (len > size)
1483     {
1484         size_t i;
1485         MSVCRT_wchar_t *p = str;
1486
1487         /* Copy the temporary buffer backwards up to the available number of
1488          * characters. Don't copy the negative sign if present. */
1489
1490         if (is_negative)
1491         {
1492             p++;
1493             size--;
1494         }
1495
1496         for (pos = buffer + 63, i = 0; i < size; i++)
1497             *p++ = *pos--;
1498
1499         str[0] = '\0';
1500         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1501         return MSVCRT_ERANGE;
1502     }
1503
1504     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1505     return 0;
1506 }
1507
1508 #define I10_OUTPUT_MAX_PREC 21
1509 /* Internal structure used by $I10_OUTPUT */
1510 struct _I10_OUTPUT_DATA {
1511     short pos;
1512     char sign;
1513     BYTE len;
1514     char str[I10_OUTPUT_MAX_PREC+1]; /* add space for '\0' */
1515 };
1516
1517 /*********************************************************************
1518  *              $I10_OUTPUT (MSVCRT.@)
1519  * ld80 - long double (Intel 80 bit FP in 12 bytes) to be printed to data
1520  * prec - precision of part, we're interested in
1521  * flag - 0 for first prec digits, 1 for fractional part
1522  * data - data to be populated
1523  *
1524  * return value
1525  *      0 if given double is NaN or INF
1526  *      1 otherwise
1527  *
1528  * FIXME
1529  *      Native sets last byte of data->str to '0' or '9', I don't know what
1530  *      it means. Current implementation sets it always to '0'.
1531  */
1532 int CDECL MSVCRT_I10_OUTPUT(MSVCRT__LDOUBLE ld80, int prec, int flag, struct _I10_OUTPUT_DATA *data)
1533 {
1534     static const char inf_str[] = "1#INF";
1535     static const char nan_str[] = "1#QNAN";
1536
1537     /* MS' long double type wants 12 bytes for Intel's 80 bit FP format.
1538      * Some UNIX have sizeof(long double) == 16, yet only 80 bit are used.
1539      * Assume long double uses 80 bit FP, never seen 128 bit FP. */
1540     long double ld = 0;
1541     double d;
1542     char format[8];
1543     char buf[I10_OUTPUT_MAX_PREC+9]; /* 9 = strlen("0.e+0000") + '\0' */
1544     char *p;
1545
1546     memcpy(&ld, &ld80, 10);
1547     d = ld;
1548     TRACE("(%lf %d %x %p)\n", d, prec, flag, data);
1549
1550     if(d<0) {
1551         data->sign = '-';
1552         d = -d;
1553     } else
1554         data->sign = ' ';
1555
1556     if(isinf(d)) {
1557         data->pos = 1;
1558         data->len = 5;
1559         memcpy(data->str, inf_str, sizeof(inf_str));
1560
1561         return 0;
1562     }
1563
1564     if(isnan(d)) {
1565         data->pos = 1;
1566         data->len = 6;
1567         memcpy(data->str, nan_str, sizeof(nan_str));
1568
1569         return 0;
1570     }
1571
1572     if(flag&1) {
1573         int exp = 1+floor(log10(d));
1574
1575         prec += exp;
1576         if(exp < 0)
1577             prec--;
1578     }
1579     prec--;
1580
1581     if(prec+1 > I10_OUTPUT_MAX_PREC)
1582         prec = I10_OUTPUT_MAX_PREC-1;
1583     else if(prec < 0) {
1584         d = 0.0;
1585         prec = 0;
1586     }
1587
1588     sprintf(format, "%%.%dle", prec);
1589     sprintf(buf, format, d);
1590
1591     buf[1] = buf[0];
1592     data->pos = atoi(buf+prec+3);
1593     if(buf[1] != '0')
1594         data->pos++;
1595
1596     for(p = buf+prec+1; p>buf+1 && *p=='0'; p--);
1597     data->len = p-buf;
1598
1599     memcpy(data->str, buf+1, data->len);
1600     data->str[data->len] = '\0';
1601
1602     if(buf[1]!='0' && prec-data->len+1>0)
1603         memcpy(data->str+data->len+1, buf+data->len+1, prec-data->len+1);
1604
1605     return 1;
1606 }
1607 #undef I10_OUTPUT_MAX_PREC