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  *                  strncpy (MSVCRT.@)
 576  */
 577 char* __cdecl MSVCRT_strncpy(char *dst, const char *src, MSVCRT_size_t len)
 578 {
 579     MSVCRT_size_t i;
 580
 581     for(i=0; i<len; i++)
 582         if((dst[i] = src[i]) == '\0') break;
 583
 584     while (i < len) dst[i++] = 0;
 585
 586     return dst;
 587 }
 588
 589 /*********************************************************************
 590  *      strcpy_s (MSVCRT.@)
 591  */
 592 int CDECL MSVCRT_strcpy_s( char* dst, MSVCRT_size_t elem, const char* src )
 593 {
 594     MSVCRT_size_t i;
 595     if(!elem) return MSVCRT_EINVAL;
 596     if(!dst) return MSVCRT_EINVAL;
 597     if(!src)
 598     {
 599         dst[0] = '\0';
 600         return MSVCRT_EINVAL;
 601     }
 602
 603     for(i = 0; i < elem; i++)
 604     {
 605         if((dst[i] = src[i]) == '\0') return 0;
 606     }
 607     dst[0] = '\0';
 608     return MSVCRT_ERANGE;
 609 }
 610
 611 /*********************************************************************
 612  *      strcat_s (MSVCRT.@)
 613  */
 614 int CDECL MSVCRT_strcat_s( char* dst, MSVCRT_size_t elem, const char* src )
 615 {
 616     MSVCRT_size_t i, j;
 617     if(!dst) return MSVCRT_EINVAL;
 618     if(elem == 0) return MSVCRT_EINVAL;
 619     if(!src)
 620     {
 621         dst[0] = '\0';
 622         return MSVCRT_EINVAL;
 623     }
 624
 625     for(i = 0; i < elem; i++)
 626     {
 627         if(dst[i] == '\0')
 628         {
 629             for(j = 0; (j + i) < elem; j++)
 630             {
 631                 if((dst[j + i] = src[j]) == '\0') return 0;
 632             }
 633         }
 634     }
 635     /* Set the first element to 0, not the first element after the skipped part */
 636     dst[0] = '\0';
 637     return MSVCRT_ERANGE;
 638 }
 639
 640 /*********************************************************************
 641  *      strncat_s (MSVCRT.@)
 642  */
 643 int CDECL MSVCRT_strncat_s( char* dst, MSVCRT_size_t elem, const char* src, MSVCRT_size_t count )
 644 {
 645     MSVCRT_size_t i, j;
 646
 647     if (!MSVCRT_CHECK_PMT(dst != 0)) return MSVCRT_EINVAL;
 648     if (!MSVCRT_CHECK_PMT(elem != 0)) return MSVCRT_EINVAL;
 649     if (!MSVCRT_CHECK_PMT(src != 0))
 650     {
 651         dst[0] = '\0';
 652         return MSVCRT_EINVAL;
 653     }
 654
 655     for(i = 0; i < elem; i++)
 656     {
 657         if(dst[i] == '\0')
 658         {
 659             for(j = 0; (j + i) < elem; j++)
 660             {
 661                 if(count == MSVCRT__TRUNCATE && j + i == elem - 1)
 662                 {
 663                     dst[j + i] = '\0';
 664                     return MSVCRT_STRUNCATE;
 665                 }
 666                 if(j == count || (dst[j + i] = src[j]) == '\0')
 667                 {
 668                     dst[j + i] = '\0';
 669                     return 0;
 670                 }
 671             }
 672         }
 673     }
 674     /* Set the first element to 0, not the first element after the skipped part */
 675     dst[0] = '\0';
 676     return MSVCRT_ERANGE;
 677 }
 678
 679 /*********************************************************************
 680  *      strncat (MSVCRT.@)
 681  */
 682 char* __cdecl MSVCRT_strncat(char *dst, const char *src, MSVCRT_size_t len)
 683 {
 684     return strncat(dst, src, len);
 685 }
 686
 687 /*********************************************************************
 688  *              strxfrm (MSVCRT.@)
 689  */
 690 MSVCRT_size_t CDECL MSVCRT_strxfrm( char *dest, const char *src, MSVCRT_size_t len )
 691 {
 692     /* FIXME: handle Windows locale */
 693     return strxfrm( dest, src, len );
 694 }
 695
 696 /********************************************************************
 697  *              _atoldbl (MSVCRT.@)
 698  */
 699 int CDECL MSVCRT__atoldbl(MSVCRT__LDOUBLE *value, const char *str)
 700 {
 701   /* FIXME needs error checking for huge/small values */
 702 #ifdef HAVE_STRTOLD
 703   long double ld;
 704   TRACE("str %s value %p\n",str,value);
 705   ld = strtold(str,0);
 706   memcpy(value, &ld, 10);
 707 #else
 708   FIXME("stub, str %s value %p\n",str,value);
 709 #endif
 710   return 0;
 711 }
 712
 713 /********************************************************************
 714  *              __STRINGTOLD (MSVCRT.@)
 715  */
 716 int CDECL __STRINGTOLD( MSVCRT__LDOUBLE *value, char **endptr, const char *str, int flags )
 717 {
 718 #ifdef HAVE_STRTOLD
 719     long double ld;
 720     FIXME("%p %p %s %x partial stub\n", value, endptr, str, flags );
 721     ld = strtold(str,0);
 722     memcpy(value, &ld, 10);
 723 #else
 724     FIXME("%p %p %s %x stub\n", value, endptr, str, flags );
 725 #endif
 726     return 0;
 727 }
 728
 729 /******************************************************************
 730  *              strtol (MSVCRT.@)
 731  */
 732 MSVCRT_long CDECL MSVCRT_strtol(const char* nptr, char** end, int base)
 733 {
 734     /* wrapper to forward libc error code to msvcrt's error codes */
 735     long ret;
 736
 737     errno = 0;
 738     ret = strtol(nptr, end, base);
 739     switch (errno)
 740     {
 741     case ERANGE:        *MSVCRT__errno() = MSVCRT_ERANGE;       break;
 742     case EINVAL:        *MSVCRT__errno() = MSVCRT_EINVAL;       break;
 743     default:
 744         /* cope with the fact that we may use 64bit long integers on libc
 745          * while msvcrt always uses 32bit long integers
 746          */
 747         if (ret > MSVCRT_LONG_MAX)
 748         {
 749             ret = MSVCRT_LONG_MAX;
 750             *MSVCRT__errno() = MSVCRT_ERANGE;
 751         }
 752         else if (ret < -MSVCRT_LONG_MAX - 1)
 753         {
 754             ret = -MSVCRT_LONG_MAX - 1;
 755             *MSVCRT__errno() = MSVCRT_ERANGE;
 756         }
 757         break;
 758     }
 759
 760     return ret;
 761 }
 762
 763 /******************************************************************
 764  *              strtoul (MSVCRT.@)
 765  */
 766 MSVCRT_ulong CDECL MSVCRT_strtoul(const char* nptr, char** end, int base)
 767 {
 768     /* wrapper to forward libc error code to msvcrt's error codes */
 769     unsigned long ret;
 770
 771     errno = 0;
 772     ret = strtoul(nptr, end, base);
 773     switch (errno)
 774     {
 775     case ERANGE:        *MSVCRT__errno() = MSVCRT_ERANGE;       break;
 776     case EINVAL:        *MSVCRT__errno() = MSVCRT_EINVAL;       break;
 777     default:
 778         /* cope with the fact that we may use 64bit long integers on libc
 779          * while msvcrt always uses 32bit long integers
 780          */
 781         if (ret > MSVCRT_ULONG_MAX)
 782         {
 783             ret = MSVCRT_ULONG_MAX;
 784             *MSVCRT__errno() = MSVCRT_ERANGE;
 785         }
 786         break;
 787     }
 788
 789     return ret;
 790 }
 791
 792 /*********************************************************************
 793  *              strlen (MSVCRT.@)
 794  */
 795 MSVCRT_size_t __cdecl MSVCRT_strlen(const char *str)
 796 {
 797     return strlen(str);
 798 }
 799
 800 /******************************************************************
 801  *              strnlen (MSVCRT.@)
 802  */
 803 MSVCRT_size_t CDECL MSVCRT_strnlen(const char *s, MSVCRT_size_t maxlen)
 804 {
 805     MSVCRT_size_t i;
 806
 807     for(i=0; i<maxlen; i++)
 808         if(!s[i]) break;
 809
 810     return i;
 811 }
 812
 813 /*********************************************************************
 814  *  _strtoi64_l (MSVCRT.@)
 815  *
 816  * FIXME: locale parameter is ignored
 817  */
 818 __int64 CDECL MSVCRT_strtoi64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
 819 {
 820     BOOL negative = FALSE;
 821     __int64 ret = 0;
 822
 823     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
 824
 825     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
 826     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
 827     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
 828
 829     while(isspace(*nptr)) nptr++;
 830
 831     if(*nptr == '-') {
 832         negative = TRUE;
 833         nptr++;
 834     } else if(*nptr == '+')
 835         nptr++;
 836
 837     if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') {
 838         base = 16;
 839         nptr += 2;
 840     }
 841
 842     if(base == 0) {
 843         if(*nptr=='0')
 844             base = 8;
 845         else
 846             base = 10;
 847     }
 848
 849     while(*nptr) {
 850         char cur = tolower(*nptr);
 851         int v;
 852
 853         if(isdigit(cur)) {
 854             if(cur >= '0'+base)
 855                 break;
 856             v = cur-'0';
 857         } else {
 858             if(cur<'a' || cur>='a'+base-10)
 859                 break;
 860             v = cur-'a'+10;
 861         }
 862
 863         if(negative)
 864             v = -v;
 865
 866         nptr++;
 867
 868         if(!negative && (ret>MSVCRT_I64_MAX/base || ret*base>MSVCRT_I64_MAX-v)) {
 869             ret = MSVCRT_I64_MAX;
 870             *MSVCRT__errno() = MSVCRT_ERANGE;
 871         } else if(negative && (ret<MSVCRT_I64_MIN/base || ret*base<MSVCRT_I64_MIN-v)) {
 872             ret = MSVCRT_I64_MIN;
 873             *MSVCRT__errno() = MSVCRT_ERANGE;
 874         } else
 875             ret = ret*base + v;
 876     }
 877
 878     if(endptr)
 879         *endptr = (char*)nptr;
 880
 881     return ret;
 882 }
 883
 884 /*********************************************************************
 885  *  _strtoi64 (MSVCRT.@)
 886  */
 887 __int64 CDECL MSVCRT_strtoi64(const char *nptr, char **endptr, int base)
 888 {
 889     return MSVCRT_strtoi64_l(nptr, endptr, base, NULL);
 890 }
 891
 892 /*********************************************************************
 893  *  _atoi_l (MSVCRT.@)
 894  */
 895 int __cdecl MSVCRT__atoi_l(const char *str, MSVCRT__locale_t locale)
 896 {
 897     __int64 ret = MSVCRT_strtoi64_l(str, NULL, 10, locale);
 898
 899     if(ret > INT_MAX) {
 900         ret = INT_MAX;
 901         *MSVCRT__errno() = MSVCRT_ERANGE;
 902     } else if(ret < INT_MIN) {
 903         ret = INT_MIN;
 904         *MSVCRT__errno() = MSVCRT_ERANGE;
 905     }
 906     return ret;
 907 }
 908
 909 /*********************************************************************
 910  *  atoi (MSVCRT.@)
 911  */
 912 int __cdecl MSVCRT_atoi(const char *str)
 913 {
 914     BOOL minus = FALSE;
 915     int ret = 0;
 916
 917     if(!str)
 918         return 0;
 919
 920     while(isspace(*str)) str++;
 921
 922     if(*str == '+') {
 923         str++;
 924     }else if(*str == '-') {
 925         minus = TRUE;
 926         str++;
 927     }
 928
 929     while(*str>='0' && *str<='9') {
 930         ret = ret*10+*str-'0';
 931         str++;
 932     }
 933
 934     return minus ? -ret : ret;
 935 }
 936
 937 /*********************************************************************
 938  *  _strtoui64_l (MSVCRT.@)
 939  *
 940  * FIXME: locale parameter is ignored
 941  */
 942 unsigned __int64 CDECL MSVCRT_strtoui64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
 943 {
 944     BOOL negative = FALSE;
 945     unsigned __int64 ret = 0;
 946
 947     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
 948
 949     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
 950     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
 951     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
 952
 953     while(isspace(*nptr)) nptr++;
 954
 955     if(*nptr == '-') {
 956         negative = TRUE;
 957         nptr++;
 958     } else if(*nptr == '+')
 959         nptr++;
 960
 961     if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') {
 962         base = 16;
 963         nptr += 2;
 964     }
 965
 966     if(base == 0) {
 967         if(*nptr=='0')
 968             base = 8;
 969         else
 970             base = 10;
 971     }
 972
 973     while(*nptr) {
 974         char cur = tolower(*nptr);
 975         int v;
 976
 977         if(isdigit(cur)) {
 978             if(cur >= '0'+base)
 979                 break;
 980             v = *nptr-'0';
 981         } else {
 982             if(cur<'a' || cur>='a'+base-10)
 983                 break;
 984             v = cur-'a'+10;
 985         }
 986
 987         nptr++;
 988
 989         if(ret>MSVCRT_UI64_MAX/base || ret*base>MSVCRT_UI64_MAX-v) {
 990             ret = MSVCRT_UI64_MAX;
 991             *MSVCRT__errno() = MSVCRT_ERANGE;
 992         } else
 993             ret = ret*base + v;
 994     }
 995
 996     if(endptr)
 997         *endptr = (char*)nptr;
 998
 999     return negative ? -ret : ret;
1000 }
1001
1002 /*********************************************************************
1003  *  _strtoui64 (MSVCRT.@)
1004  */
1005 unsigned __int64 CDECL MSVCRT_strtoui64(const char *nptr, char **endptr, int base)
1006 {
1007     return MSVCRT_strtoui64_l(nptr, endptr, base, NULL);
1008 }
1009
1010 /*********************************************************************
1011  *  _ltoa_s (MSVCRT.@)
1012  */
1013 int CDECL _ltoa_s(MSVCRT_long value, char *str, MSVCRT_size_t size, int radix)
1014 {
1015     MSVCRT_ulong val;
1016     unsigned int digit;
1017     int is_negative;
1018     char buffer[33], *pos;
1019     size_t len;
1020
1021     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1022     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1023     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1024     {
1025         str[0] = '\0';
1026         return MSVCRT_EINVAL;
1027     }
1028
1029     if (value < 0 && radix == 10)
1030     {
1031         is_negative = 1;
1032         val = -value;
1033     }
1034     else
1035     {
1036         is_negative = 0;
1037         val = value;
1038     }
1039
1040     pos = buffer + 32;
1041     *pos = '\0';
1042
1043     do
1044     {
1045         digit = val % radix;
1046         val /= radix;
1047
1048         if (digit < 10)
1049             *--pos = '0' + digit;
1050         else
1051             *--pos = 'a' + digit - 10;
1052     }
1053     while (val != 0);
1054
1055     if (is_negative)
1056         *--pos = '-';
1057
1058     len = buffer + 33 - pos;
1059     if (len > size)
1060     {
1061         size_t i;
1062         char *p = str;
1063
1064         /* Copy the temporary buffer backwards up to the available number of
1065          * characters. Don't copy the negative sign if present. */
1066
1067         if (is_negative)
1068         {
1069             p++;
1070             size--;
1071         }
1072
1073         for (pos = buffer + 31, i = 0; i < size; i++)
1074             *p++ = *pos--;
1075
1076         str[0] = '\0';
1077         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1078         return MSVCRT_ERANGE;
1079     }
1080
1081     memcpy(str, pos, len);
1082     return 0;
1083 }
1084
1085 /*********************************************************************
1086  *  _ltow_s (MSVCRT.@)
1087  */
1088 int CDECL _ltow_s(MSVCRT_long value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1089 {
1090     MSVCRT_ulong val;
1091     unsigned int digit;
1092     int is_negative;
1093     MSVCRT_wchar_t buffer[33], *pos;
1094     size_t len;
1095
1096     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1097     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1098     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1099     {
1100         str[0] = '\0';
1101         return MSVCRT_EINVAL;
1102     }
1103
1104     if (value < 0 && radix == 10)
1105     {
1106         is_negative = 1;
1107         val = -value;
1108     }
1109     else
1110     {
1111         is_negative = 0;
1112         val = value;
1113     }
1114
1115     pos = buffer + 32;
1116     *pos = '\0';
1117
1118     do
1119     {
1120         digit = val % radix;
1121         val /= radix;
1122
1123         if (digit < 10)
1124             *--pos = '0' + digit;
1125         else
1126             *--pos = 'a' + digit - 10;
1127     }
1128     while (val != 0);
1129
1130     if (is_negative)
1131         *--pos = '-';
1132
1133     len = buffer + 33 - pos;
1134     if (len > size)
1135     {
1136         size_t i;
1137         MSVCRT_wchar_t *p = str;
1138
1139         /* Copy the temporary buffer backwards up to the available number of
1140          * characters. Don't copy the negative sign if present. */
1141
1142         if (is_negative)
1143         {
1144             p++;
1145             size--;
1146         }
1147
1148         for (pos = buffer + 31, i = 0; i < size; i++)
1149             *p++ = *pos--;
1150
1151         str[0] = '\0';
1152         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1153         return MSVCRT_ERANGE;
1154     }
1155
1156     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1157     return 0;
1158 }
1159
1160 /*********************************************************************
1161  *  _itoa_s (MSVCRT.@)
1162  */
1163 int CDECL _itoa_s(int value, char *str, MSVCRT_size_t size, int radix)
1164 {
1165     return _ltoa_s(value, str, size, radix);
1166 }
1167
1168 /*********************************************************************
1169  *  _itow_s (MSVCRT.@)
1170  */
1171 int CDECL _itow_s(int value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1172 {
1173     return _ltow_s(value, str, size, radix);
1174 }
1175
1176 /*********************************************************************
1177  *  _ui64toa_s (MSVCRT.@)
1178  */
1179 int CDECL MSVCRT__ui64toa_s(unsigned __int64 value, char *str,
1180         MSVCRT_size_t size, int radix)
1181 {
1182     char buffer[65], *pos;
1183     int digit;
1184
1185     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1186     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1187     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1188     {
1189         str[0] = '\0';
1190         return MSVCRT_EINVAL;
1191     }
1192
1193     pos = buffer+64;
1194     *pos = '\0';
1195
1196     do {
1197         digit = value%radix;
1198         value /= radix;
1199
1200         if(digit < 10)
1201             *--pos = '0'+digit;
1202         else
1203             *--pos = 'a'+digit-10;
1204     }while(value != 0);
1205
1206     if(buffer-pos+65 > size) {
1207         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
1208         return MSVCRT_EINVAL;
1209     }
1210
1211     memcpy(str, pos, buffer-pos+65);
1212     return 0;
1213 }
1214
1215 /*********************************************************************
1216  *      _ui64tow_s  (MSVCRT.@)
1217  */
1218 int CDECL MSVCRT__ui64tow_s( unsigned __int64 value, MSVCRT_wchar_t *str,
1219                              MSVCRT_size_t size, int radix )
1220 {
1221     MSVCRT_wchar_t buffer[65], *pos;
1222     int digit;
1223
1224     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1225     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1226     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1227     {
1228         str[0] = '\0';
1229         return MSVCRT_EINVAL;
1230     }
1231
1232     pos = &buffer[64];
1233     *pos = '\0';
1234
1235     do {
1236         digit = value % radix;
1237         value = value / radix;
1238         if (digit < 10)
1239             *--pos = '0' + digit;
1240         else
1241             *--pos = 'a' + digit - 10;
1242     } while (value != 0);
1243
1244     if(buffer-pos+65 > size) {
1245         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
1246         return MSVCRT_EINVAL;
1247     }
1248
1249     memcpy(str, pos, (buffer-pos+65)*sizeof(MSVCRT_wchar_t));
1250     return 0;
1251 }
1252
1253 /*********************************************************************
1254  *  _ultoa_s (MSVCRT.@)
1255  */
1256 int CDECL _ultoa_s(MSVCRT_ulong value, char *str, MSVCRT_size_t size, int radix)
1257 {
1258     MSVCRT_ulong digit;
1259     char buffer[33], *pos;
1260     size_t len;
1261
1262     if (!str || !size || radix < 2 || radix > 36)
1263     {
1264         if (str && size)
1265             str[0] = '\0';
1266
1267         *MSVCRT__errno() = MSVCRT_EINVAL;
1268         return MSVCRT_EINVAL;
1269     }
1270
1271     pos = buffer + 32;
1272     *pos = '\0';
1273
1274     do
1275     {
1276         digit = value % radix;
1277         value /= radix;
1278
1279         if (digit < 10)
1280             *--pos = '0' + digit;
1281         else
1282             *--pos = 'a' + digit - 10;
1283     }
1284     while (value != 0);
1285
1286     len = buffer + 33 - pos;
1287     if (len > size)
1288     {
1289         size_t i;
1290         char *p = str;
1291
1292         /* Copy the temporary buffer backwards up to the available number of
1293          * characters. */
1294
1295         for (pos = buffer + 31, i = 0; i < size; i++)
1296             *p++ = *pos--;
1297
1298         str[0] = '\0';
1299         *MSVCRT__errno() = MSVCRT_ERANGE;
1300         return MSVCRT_ERANGE;
1301     }
1302
1303     memcpy(str, pos, len);
1304     return 0;
1305 }
1306
1307 /*********************************************************************
1308  *  _ultow_s (MSVCRT.@)
1309  */
1310 int CDECL _ultow_s(MSVCRT_ulong value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1311 {
1312     MSVCRT_ulong digit;
1313     WCHAR buffer[33], *pos;
1314     size_t len;
1315
1316     if (!str || !size || radix < 2 || radix > 36)
1317     {
1318         if (str && size)
1319             str[0] = '\0';
1320
1321         *MSVCRT__errno() = MSVCRT_EINVAL;
1322         return MSVCRT_EINVAL;
1323     }
1324
1325     pos = buffer + 32;
1326     *pos = '\0';
1327
1328     do
1329     {
1330         digit = value % radix;
1331         value /= radix;
1332
1333         if (digit < 10)
1334             *--pos = '0' + digit;
1335         else
1336             *--pos = 'a' + digit - 10;
1337     }
1338     while (value != 0);
1339
1340     len = buffer + 33 - pos;
1341     if (len > size)
1342     {
1343         size_t i;
1344         WCHAR *p = str;
1345
1346         /* Copy the temporary buffer backwards up to the available number of
1347          * characters. */
1348
1349         for (pos = buffer + 31, i = 0; i < size; i++)
1350             *p++ = *pos--;
1351
1352         str[0] = '\0';
1353         *MSVCRT__errno() = MSVCRT_ERANGE;
1354         return MSVCRT_ERANGE;
1355     }
1356
1357     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1358     return 0;
1359 }
1360
1361 /*********************************************************************
1362  *  _i64toa_s (MSVCRT.@)
1363  */
1364 int CDECL _i64toa_s(__int64 value, char *str, MSVCRT_size_t size, int radix)
1365 {
1366     unsigned __int64 val;
1367     unsigned int digit;
1368     int is_negative;
1369     char buffer[65], *pos;
1370     size_t len;
1371
1372     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1373     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1374     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1375     {
1376         str[0] = '\0';
1377         return MSVCRT_EINVAL;
1378     }
1379
1380     if (value < 0 && radix == 10)
1381     {
1382         is_negative = 1;
1383         val = -value;
1384     }
1385     else
1386     {
1387         is_negative = 0;
1388         val = value;
1389     }
1390
1391     pos = buffer + 64;
1392     *pos = '\0';
1393
1394     do
1395     {
1396         digit = val % radix;
1397         val /= radix;
1398
1399         if (digit < 10)
1400             *--pos = '0' + digit;
1401         else
1402             *--pos = 'a' + digit - 10;
1403     }
1404     while (val != 0);
1405
1406     if (is_negative)
1407         *--pos = '-';
1408
1409     len = buffer + 65 - pos;
1410     if (len > size)
1411     {
1412         size_t i;
1413         char *p = str;
1414
1415         /* Copy the temporary buffer backwards up to the available number of
1416          * characters. Don't copy the negative sign if present. */
1417
1418         if (is_negative)
1419         {
1420             p++;
1421             size--;
1422         }
1423
1424         for (pos = buffer + 63, i = 0; i < size; i++)
1425             *p++ = *pos--;
1426
1427         str[0] = '\0';
1428         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1429         return MSVCRT_ERANGE;
1430     }
1431
1432     memcpy(str, pos, len);
1433     return 0;
1434 }
1435
1436 /*********************************************************************
1437  *  _i64tow_s (MSVCRT.@)
1438  */
1439 int CDECL _i64tow_s(__int64 value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1440 {
1441     unsigned __int64 val;
1442     unsigned int digit;
1443     int is_negative;
1444     MSVCRT_wchar_t buffer[65], *pos;
1445     size_t len;
1446
1447     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1448     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1449     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1450     {
1451         str[0] = '\0';
1452         return MSVCRT_EINVAL;
1453     }
1454
1455     if (value < 0 && radix == 10)
1456     {
1457         is_negative = 1;
1458         val = -value;
1459     }
1460     else
1461     {
1462         is_negative = 0;
1463         val = value;
1464     }
1465
1466     pos = buffer + 64;
1467     *pos = '\0';
1468
1469     do
1470     {
1471         digit = val % radix;
1472         val /= radix;
1473
1474         if (digit < 10)
1475             *--pos = '0' + digit;
1476         else
1477             *--pos = 'a' + digit - 10;
1478     }
1479     while (val != 0);
1480
1481     if (is_negative)
1482         *--pos = '-';
1483
1484     len = buffer + 65 - pos;
1485     if (len > size)
1486     {
1487         size_t i;
1488         MSVCRT_wchar_t *p = str;
1489
1490         /* Copy the temporary buffer backwards up to the available number of
1491          * characters. Don't copy the negative sign if present. */
1492
1493         if (is_negative)
1494         {
1495             p++;
1496             size--;
1497         }
1498
1499         for (pos = buffer + 63, i = 0; i < size; i++)
1500             *p++ = *pos--;
1501
1502         str[0] = '\0';
1503         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1504         return MSVCRT_ERANGE;
1505     }
1506
1507     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1508     return 0;
1509 }
1510
1511 #define I10_OUTPUT_MAX_PREC 21
1512 /* Internal structure used by $I10_OUTPUT */
1513 struct _I10_OUTPUT_DATA {
1514     short pos;
1515     char sign;
1516     BYTE len;
1517     char str[I10_OUTPUT_MAX_PREC+1]; /* add space for '\0' */
1518 };
1519
1520 /*********************************************************************
1521  *              $I10_OUTPUT (MSVCRT.@)
1522  * ld80 - long double (Intel 80 bit FP in 12 bytes) to be printed to data
1523  * prec - precision of part, we're interested in
1524  * flag - 0 for first prec digits, 1 for fractional part
1525  * data - data to be populated
1526  *
1527  * return value
1528  *      0 if given double is NaN or INF
1529  *      1 otherwise
1530  *
1531  * FIXME
1532  *      Native sets last byte of data->str to '0' or '9', I don't know what
1533  *      it means. Current implementation sets it always to '0'.
1534  */
1535 int CDECL MSVCRT_I10_OUTPUT(MSVCRT__LDOUBLE ld80, int prec, int flag, struct _I10_OUTPUT_DATA *data)
1536 {
1537     static const char inf_str[] = "1#INF";
1538     static const char nan_str[] = "1#QNAN";
1539
1540     /* MS' long double type wants 12 bytes for Intel's 80 bit FP format.
1541      * Some UNIX have sizeof(long double) == 16, yet only 80 bit are used.
1542      * Assume long double uses 80 bit FP, never seen 128 bit FP. */
1543     long double ld = 0;
1544     double d;
1545     char format[8];
1546     char buf[I10_OUTPUT_MAX_PREC+9]; /* 9 = strlen("0.e+0000") + '\0' */
1547     char *p;
1548
1549     memcpy(&ld, &ld80, 10);
1550     d = ld;
1551     TRACE("(%lf %d %x %p)\n", d, prec, flag, data);
1552
1553     if(d<0) {
1554         data->sign = '-';
1555         d = -d;
1556     } else
1557         data->sign = ' ';
1558
1559     if(isinf(d)) {
1560         data->pos = 1;
1561         data->len = 5;
1562         memcpy(data->str, inf_str, sizeof(inf_str));
1563
1564         return 0;
1565     }
1566
1567     if(isnan(d)) {
1568         data->pos = 1;
1569         data->len = 6;
1570         memcpy(data->str, nan_str, sizeof(nan_str));
1571
1572         return 0;
1573     }
1574
1575     if(flag&1) {
1576         int exp = 1+floor(log10(d));
1577
1578         prec += exp;
1579         if(exp < 0)
1580             prec--;
1581     }
1582     prec--;
1583
1584     if(prec+1 > I10_OUTPUT_MAX_PREC)
1585         prec = I10_OUTPUT_MAX_PREC-1;
1586     else if(prec < 0) {
1587         d = 0.0;
1588         prec = 0;
1589     }
1590
1591     sprintf(format, "%%.%dle", prec);
1592     sprintf(buf, format, d);
1593
1594     buf[1] = buf[0];
1595     data->pos = atoi(buf+prec+3);
1596     if(buf[1] != '0')
1597         data->pos++;
1598
1599     for(p = buf+prec+1; p>buf+1 && *p=='0'; p--);
1600     data->len = p-buf;
1601
1602     memcpy(data->str, buf+1, data->len);
1603     data->str[data->len] = '\0';
1604
1605     if(buf[1]!='0' && prec-data->len+1>0)
1606         memcpy(data->str+data->len+1, buf+data->len+1, prec-data->len+1);
1607
1608     return 1;
1609 }
1610 #undef I10_OUTPUT_MAX_PREC
1611
1612 /*********************************************************************
1613  *                  memcmp (MSVCRT.@)
1614  */
1615 int __cdecl MSVCRT_memcmp(const void *ptr1, const void *ptr2, MSVCRT_size_t n)
1616 {
1617     return memcmp(ptr1, ptr2, n);
1618 }
1619
1620 /*********************************************************************
1621  *                  memcpy   (MSVCRT.@)
1622  */
1623 void * __cdecl MSVCRT_memcpy(void *dst, const void *src, MSVCRT_size_t n)
1624 {
1625     return memmove(dst, src, n);
1626 }
1627
1628 /*********************************************************************
1629  *                  memmove (MSVCRT.@)
1630  */
1631 void * __cdecl MSVCRT_memmove(void *dst, const void *src, MSVCRT_size_t n)
1632 {
1633     return memmove(dst, src, n);
1634 }
1635
1636 /*********************************************************************
1637  *                  memset (MSVCRT.@)
1638  */
1639 void* __cdecl MSVCRT_memset(void *dst, int c, MSVCRT_size_t n)
1640 {
1641     return memset(dst, c, n);
1642 }
1643
1644 /*********************************************************************
1645  *                  strchr (MSVCRT.@)
1646  */
1647 char* __cdecl MSVCRT_strchr(const char *str, int c)
1648 {
1649     return strchr(str, c);
1650 }
1651
1652 /*********************************************************************
1653  *                  strrchr (MSVCRT.@)
1654  */
1655 char* __cdecl MSVCRT_strrchr(const char *str, int c)
1656 {
1657     return strrchr(str, c);
1658 }
1659
1660 /*********************************************************************
1661  *                  memchr   (MSVCRT.@)
1662  */
1663 void* __cdecl MSVCRT_memchr(const void *ptr, int c, MSVCRT_size_t n)
1664 {
1665     return memchr(ptr, c, n);
1666 }
1667
1668 /*********************************************************************
1669  *                  strcmp (MSVCRT.@)
1670  */
1671 int __cdecl MSVCRT_strcmp(const char *str1, const char *str2)
1672 {
1673     return strcmp(str1, str2);
1674 }
1675
1676 /*********************************************************************
1677  *                  strncmp   (MSVCRT.@)
1678  */
1679 int __cdecl MSVCRT_strncmp(const char *str1, const char *str2, MSVCRT_size_t len)
1680 {
1681     return strncmp(str1, str2, len);
1682 }
1683
1684 /*********************************************************************
1685  *                  _strnicmp_l   (MSVCRT.@)
1686  */
1687 int __cdecl MSVCRT__strnicmp_l(const char *s1, const char *s2,
1688         MSVCRT_size_t count, MSVCRT__locale_t locale)
1689 {
1690     MSVCRT_pthreadlocinfo locinfo;
1691     char c1, c2;
1692
1693     if(s1==NULL || s2==NULL)
1694         return MSVCRT__NLSCMPERROR;
1695
1696     if(!count)
1697         return 0;
1698
1699     if(!locale)
1700         locinfo = get_locinfo();
1701     else
1702         locinfo = locale->locinfo;
1703
1704     if(!locinfo->lc_handle[MSVCRT_LC_CTYPE])
1705         return strncasecmp(s1, s2, count);
1706
1707     do {
1708         c1 = MSVCRT__tolower_l(*s1++, locale);
1709         c2 = MSVCRT__tolower_l(*s2++, locale);
1710     }while(--count && c1 && c1==c2);
1711
1712     return c1-c2;
1713 }
1714
1715 /*********************************************************************
1716  *                  _stricmp_l   (MSVCRT.@)
1717  */
1718 int __cdecl MSVCRT__stricmp_l(const char *s1, const char *s2, MSVCRT__locale_t locale)
1719 {
1720     return MSVCRT__strnicmp_l(s1, s2, -1, locale);
1721 }
1722
1723 /*********************************************************************
1724  *                  _strnicmp   (MSVCRT.@)
1725  */
1726 int __cdecl MSVCRT__strnicmp(const char *s1, const char *s2, MSVCRT_size_t count)
1727 {
1728     return MSVCRT__strnicmp_l(s1, s2, count, NULL);
1729 }
1730
1731 /*********************************************************************
1732  *                  _stricmp   (MSVCRT.@)
1733  */
1734 int __cdecl MSVCRT__stricmp(const char *s1, const char *s2)
1735 {
1736     return MSVCRT__strnicmp_l(s1, s2, -1, NULL);
1737 }
1738
1739 /*********************************************************************
1740  *                  strstr   (MSVCRT.@)
1741  */
1742 char* __cdecl MSVCRT_strstr(const char *haystack, const char *needle)
1743 {
1744     return strstr(haystack, needle);
1745 }