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