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_s (MSVCRT.@)
 178  */
 179 int CDECL MSVCRT__strnset_s(char *str, MSVCRT_size_t size, int c, MSVCRT_size_t count)
 180 {
 181     MSVCRT_size_t i;
 182
 183     if(!str && !size && !count) return 0;
 184     if(!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
 185     if(!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
 186
 187     for(i=0; i<size-1 && i<count; i++) {
 188         if(!str[i]) return 0;
 189         str[i] = c;
 190     }
 191     for(; i<size; i++)
 192         if(!str[i]) return 0;
 193
 194     str[0] = 0;
 195     MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
 196     *MSVCRT__errno() = MSVCRT_EINVAL;
 197     return MSVCRT_EINVAL;
 198 }
 199
 200 /*********************************************************************
 201  *              _strnset (MSVCRT.@)
 202  */
 203 char* CDECL MSVCRT__strnset(char* str, int value, MSVCRT_size_t len)
 204 {
 205   if (len > 0 && str)
 206     while (*str && len--)
 207       *str++ = value;
 208   return str;
 209 }
 210
 211 /*********************************************************************
 212  *              _strrev (MSVCRT.@)
 213  */
 214 char* CDECL MSVCRT__strrev(char* str)
 215 {
 216   char * p1;
 217   char * p2;
 218
 219   if (str && *str)
 220     for (p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2)
 221     {
 222       *p1 ^= *p2;
 223       *p2 ^= *p1;
 224       *p1 ^= *p2;
 225     }
 226
 227   return str;
 228 }
 229
 230 /*********************************************************************
 231  *              _strset (MSVCRT.@)
 232  */
 233 char* CDECL _strset(char* str, int value)
 234 {
 235   char *ptr = str;
 236   while (*ptr)
 237     *ptr++ = value;
 238
 239   return str;
 240 }
 241
 242 /*********************************************************************
 243  *              strtok  (MSVCRT.@)
 244  */
 245 char * CDECL MSVCRT_strtok( char *str, const char *delim )
 246 {
 247     thread_data_t *data = msvcrt_get_thread_data();
 248     char *ret;
 249
 250     if (!str)
 251         if (!(str = data->strtok_next)) return NULL;
 252
 253     while (*str && strchr( delim, *str )) str++;
 254     if (!*str) return NULL;
 255     ret = str++;
 256     while (*str && !strchr( delim, *str )) str++;
 257     if (*str) *str++ = 0;
 258     data->strtok_next = str;
 259     return ret;
 260 }
 261
 262 /*********************************************************************
 263  *              strtok_s  (MSVCRT.@)
 264  */
 265 char * CDECL MSVCRT_strtok_s(char *str, const char *delim, char **ctx)
 266 {
 267     if (!MSVCRT_CHECK_PMT(delim != NULL)) return NULL;
 268     if (!MSVCRT_CHECK_PMT(ctx != NULL)) return NULL;
 269     if (!MSVCRT_CHECK_PMT(str != NULL || *ctx != NULL)) return NULL;
 270
 271     if(!str)
 272         str = *ctx;
 273
 274     while(*str && strchr(delim, *str))
 275         str++;
 276     if(!*str)
 277         return NULL;
 278
 279     *ctx = str+1;
 280     while(**ctx && !strchr(delim, **ctx))
 281         (*ctx)++;
 282     if(**ctx)
 283         *(*ctx)++ = 0;
 284
 285     return str;
 286 }
 287
 288 /*********************************************************************
 289  *              _swab (MSVCRT.@)
 290  */
 291 void CDECL MSVCRT__swab(char* src, char* dst, int len)
 292 {
 293   if (len > 1)
 294   {
 295     len = (unsigned)len >> 1;
 296
 297     while (len--) {
 298       char s0 = src[0];
 299       char s1 = src[1];
 300       *dst++ = s1;
 301       *dst++ = s0;
 302       src = src + 2;
 303     }
 304   }
 305 }
 306
 307 static double strtod_helper(const char *str, char **end, MSVCRT__locale_t locale, int *err)
 308 {
 309     MSVCRT_pthreadlocinfo locinfo;
 310     unsigned __int64 d=0, hlp;
 311     unsigned fpcontrol;
 312     int exp=0, sign=1;
 313     const char *p;
 314     double ret;
 315     long double lret=1, expcnt = 10;
 316     BOOL found_digit = FALSE, negexp;
 317
 318     if(err)
 319         *err = 0;
 320     else
 321         if(!MSVCRT_CHECK_PMT(str != NULL)) return 0;
 322
 323     if(!locale)
 324         locinfo = get_locinfo();
 325     else
 326         locinfo = locale->locinfo;
 327
 328     /* FIXME: use *_l functions */
 329     p = str;
 330     while(isspace(*p))
 331         p++;
 332
 333     if(*p == '-') {
 334         sign = -1;
 335         p++;
 336     } else  if(*p == '+')
 337         p++;
 338
 339     while(isdigit(*p)) {
 340         found_digit = TRUE;
 341         hlp = d*10+*(p++)-'0';
 342         if(d>MSVCRT_UI64_MAX/10 || hlp<d) {
 343             exp++;
 344             break;
 345         } else
 346             d = hlp;
 347     }
 348     while(isdigit(*p)) {
 349         exp++;
 350         p++;
 351     }
 352
 353     if(*p == *locinfo->lconv->decimal_point)
 354         p++;
 355
 356     while(isdigit(*p)) {
 357         found_digit = TRUE;
 358         hlp = d*10+*(p++)-'0';
 359         if(d>MSVCRT_UI64_MAX/10 || hlp<d)
 360             break;
 361
 362         d = hlp;
 363         exp--;
 364     }
 365     while(isdigit(*p))
 366         p++;
 367
 368     if(!found_digit) {
 369         if(end)
 370             *end = (char*)str;
 371         return 0.0;
 372     }
 373
 374     if(*p=='e' || *p=='E' || *p=='d' || *p=='D') {
 375         int e=0, s=1;
 376
 377         p++;
 378         if(*p == '-') {
 379             s = -1;
 380             p++;
 381         } else if(*p == '+')
 382             p++;
 383
 384         if(isdigit(*p)) {
 385             while(isdigit(*p)) {
 386                 if(e>INT_MAX/10 || (e=e*10+*p-'0')<0)
 387                     e = INT_MAX;
 388                 p++;
 389             }
 390             e *= s;
 391
 392             if(exp<0 && e<0 && exp+e>=0) exp = INT_MIN;
 393             else if(exp>0 && e>0 && exp+e<0) exp = INT_MAX;
 394             else exp += e;
 395         } else {
 396             if(*p=='-' || *p=='+')
 397                 p--;
 398             p--;
 399         }
 400     }
 401
 402     fpcontrol = _control87(0, 0);
 403     _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE
 404             |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff);
 405
 406     negexp = (exp < 0);
 407     if(negexp)
 408         exp = -exp;
 409     while(exp) {
 410         if(exp & 1)
 411             lret *= expcnt;
 412         exp /= 2;
 413         expcnt = expcnt*expcnt;
 414     }
 415     ret = (long double)sign * (negexp ? d/lret : d*lret);
 416
 417     _control87(fpcontrol, 0xffffffff);
 418
 419     if((d && ret==0.0) || isinf(ret)) {
 420         if(err)
 421             *err = MSVCRT_ERANGE;
 422         else
 423             *MSVCRT__errno() = MSVCRT_ERANGE;
 424     }
 425
 426     if(end)
 427         *end = (char*)p;
 428
 429     return ret;
 430 }
 431
 432 /*********************************************************************
 433  *              strtod_l  (MSVCRT.@)
 434  */
 435 double CDECL MSVCRT_strtod_l(const char *str, char **end, MSVCRT__locale_t locale)
 436 {
 437     return strtod_helper(str, end, locale, NULL);
 438 }
 439
 440 /*********************************************************************
 441  *              strtod  (MSVCRT.@)
 442  */
 443 double CDECL MSVCRT_strtod( const char *str, char **end )
 444 {
 445     return MSVCRT_strtod_l( str, end, NULL );
 446 }
 447
 448 /*********************************************************************
 449  *              atof  (MSVCRT.@)
 450  */
 451 double CDECL MSVCRT_atof( const char *str )
 452 {
 453     return MSVCRT_strtod_l(str, NULL, NULL);
 454 }
 455
 456 /*********************************************************************
 457  *              _atof_l  (MSVCRT.@)
 458  */
 459 double CDECL MSVCRT__atof_l( const char *str, MSVCRT__locale_t locale)
 460 {
 461     return MSVCRT_strtod_l(str, NULL, locale);
 462 }
 463
 464 /*********************************************************************
 465  *              _atoflt_l  (MSVCRT.@)
 466  */
 467 int CDECL MSVCRT__atoflt_l( MSVCRT__CRT_FLOAT *value, char *str, MSVCRT__locale_t locale)
 468 {
 469     double d;
 470     int err;
 471
 472     d = strtod_helper(str, NULL, locale, &err);
 473     value->f = d;
 474     if(isinf(value->f))
 475         return MSVCRT__OVERFLOW;
 476     if((d!=0 || err) && value->f>-MSVCRT_FLT_MIN && value->f<MSVCRT_FLT_MIN)
 477         return MSVCRT__UNDERFLOW;
 478     return 0;
 479 }
 480
 481 /*********************************************************************
 482  * _atoflt  (MSVCR100.@)
 483  */
 484 int CDECL MSVCRT__atoflt(MSVCRT__CRT_FLOAT *value, char *str)
 485 {
 486     return MSVCRT__atoflt_l(value, str, NULL);
 487 }
 488
 489 /*********************************************************************
 490  *              _atodbl_l  (MSVCRT.@)
 491  */
 492 int CDECL MSVCRT__atodbl_l(MSVCRT__CRT_DOUBLE *value, char *str, MSVCRT__locale_t locale)
 493 {
 494     int err;
 495
 496     value->x = strtod_helper(str, NULL, locale, &err);
 497     if(isinf(value->x))
 498         return MSVCRT__OVERFLOW;
 499     if((value->x!=0 || err) && value->x>-MSVCRT_DBL_MIN && value->x<MSVCRT_DBL_MIN)
 500         return MSVCRT__UNDERFLOW;
 501     return 0;
 502 }
 503
 504 /*********************************************************************
 505  *              _atodbl  (MSVCRT.@)
 506  */
 507 int CDECL MSVCRT__atodbl(MSVCRT__CRT_DOUBLE *value, char *str)
 508 {
 509     return MSVCRT__atodbl_l(value, str, NULL);
 510 }
 511
 512 /*********************************************************************
 513  *              _strcoll_l (MSVCRT.@)
 514  */
 515 int CDECL MSVCRT_strcoll_l( const char* str1, const char* str2, MSVCRT__locale_t locale )
 516 {
 517     MSVCRT_pthreadlocinfo locinfo;
 518
 519     if(!locale)
 520         locinfo = get_locinfo();
 521     else
 522         locinfo = locale->locinfo;
 523
 524     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE])
 525         return strcmp(str1, str2);
 526     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], 0, str1, -1, str2, -1)-CSTR_EQUAL;
 527 }
 528
 529 /*********************************************************************
 530  *              strcoll (MSVCRT.@)
 531  */
 532 int CDECL MSVCRT_strcoll( const char* str1, const char* str2 )
 533 {
 534     return MSVCRT_strcoll_l(str1, str2, NULL);
 535 }
 536
 537 /*********************************************************************
 538  *              _stricoll_l (MSVCRT.@)
 539  */
 540 int CDECL MSVCRT__stricoll_l( const char* str1, const char* str2, MSVCRT__locale_t locale )
 541 {
 542     MSVCRT_pthreadlocinfo locinfo;
 543
 544     if(!locale)
 545         locinfo = get_locinfo();
 546     else
 547         locinfo = locale->locinfo;
 548
 549     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE])
 550         return strcasecmp(str1, str2);
 551     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], NORM_IGNORECASE,
 552             str1, -1, str2, -1)-CSTR_EQUAL;
 553 }
 554
 555 /*********************************************************************
 556  *              _stricoll (MSVCRT.@)
 557  */
 558 int CDECL MSVCRT__stricoll( const char* str1, const char* str2 )
 559 {
 560     return MSVCRT__stricoll_l(str1, str2, NULL);
 561 }
 562
 563 /*********************************************************************
 564  *              _strncoll_l (MSVCRT.@)
 565  */
 566 int CDECL MSVCRT__strncoll_l( const char* str1, const char* str2, MSVCRT_size_t count, MSVCRT__locale_t locale )
 567 {
 568     MSVCRT_pthreadlocinfo locinfo;
 569
 570     if(!locale)
 571         locinfo = get_locinfo();
 572     else
 573         locinfo = locale->locinfo;
 574
 575     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE])
 576         return strncmp(str1, str2, count);
 577     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], 0, str1, count, str2, count)-CSTR_EQUAL;
 578 }
 579
 580 /*********************************************************************
 581  *              _strncoll (MSVCRT.@)
 582  */
 583 int CDECL MSVCRT__strncoll( const char* str1, const char* str2, MSVCRT_size_t count )
 584 {
 585     return MSVCRT__strncoll_l(str1, str2, count, NULL);
 586 }
 587
 588 /*********************************************************************
 589  *              _strnicoll_l (MSVCRT.@)
 590  */
 591 int CDECL MSVCRT__strnicoll_l( const char* str1, const char* str2, MSVCRT_size_t count, MSVCRT__locale_t locale )
 592 {
 593     MSVCRT_pthreadlocinfo locinfo;
 594
 595     if(!locale)
 596         locinfo = get_locinfo();
 597     else
 598         locinfo = locale->locinfo;
 599
 600     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE])
 601         return strncasecmp(str1, str2, count);
 602     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], NORM_IGNORECASE,
 603             str1, count, str2, count)-CSTR_EQUAL;
 604 }
 605
 606 /*********************************************************************
 607  *              _strnicoll (MSVCRT.@)
 608  */
 609 int CDECL MSVCRT__strnicoll( const char* str1, const char* str2, MSVCRT_size_t count )
 610 {
 611     return MSVCRT__strnicoll_l(str1, str2, count, NULL);
 612 }
 613
 614 /*********************************************************************
 615  *                  strncpy (MSVCRT.@)
 616  */
 617 char* __cdecl MSVCRT_strncpy(char *dst, const char *src, MSVCRT_size_t len)
 618 {
 619     MSVCRT_size_t i;
 620
 621     for(i=0; i<len; i++)
 622         if((dst[i] = src[i]) == '\0') break;
 623
 624     while (i < len) dst[i++] = 0;
 625
 626     return dst;
 627 }
 628
 629 /*********************************************************************
 630  *      strcpy_s (MSVCRT.@)
 631  */
 632 int CDECL MSVCRT_strcpy_s( char* dst, MSVCRT_size_t elem, const char* src )
 633 {
 634     MSVCRT_size_t i;
 635     if(!elem) return MSVCRT_EINVAL;
 636     if(!dst) return MSVCRT_EINVAL;
 637     if(!src)
 638     {
 639         dst[0] = '\0';
 640         return MSVCRT_EINVAL;
 641     }
 642
 643     for(i = 0; i < elem; i++)
 644     {
 645         if((dst[i] = src[i]) == '\0') return 0;
 646     }
 647     dst[0] = '\0';
 648     return MSVCRT_ERANGE;
 649 }
 650
 651 /*********************************************************************
 652  *      strcat_s (MSVCRT.@)
 653  */
 654 int CDECL MSVCRT_strcat_s( char* dst, MSVCRT_size_t elem, const char* src )
 655 {
 656     MSVCRT_size_t i, j;
 657     if(!dst) return MSVCRT_EINVAL;
 658     if(elem == 0) return MSVCRT_EINVAL;
 659     if(!src)
 660     {
 661         dst[0] = '\0';
 662         return MSVCRT_EINVAL;
 663     }
 664
 665     for(i = 0; i < elem; i++)
 666     {
 667         if(dst[i] == '\0')
 668         {
 669             for(j = 0; (j + i) < elem; j++)
 670             {
 671                 if((dst[j + i] = src[j]) == '\0') return 0;
 672             }
 673         }
 674     }
 675     /* Set the first element to 0, not the first element after the skipped part */
 676     dst[0] = '\0';
 677     return MSVCRT_ERANGE;
 678 }
 679
 680 /*********************************************************************
 681  *      strncat_s (MSVCRT.@)
 682  */
 683 int CDECL MSVCRT_strncat_s( char* dst, MSVCRT_size_t elem, const char* src, MSVCRT_size_t count )
 684 {
 685     MSVCRT_size_t i, j;
 686
 687     if (!MSVCRT_CHECK_PMT(dst != 0)) return MSVCRT_EINVAL;
 688     if (!MSVCRT_CHECK_PMT(elem != 0)) return MSVCRT_EINVAL;
 689     if (!MSVCRT_CHECK_PMT(src != 0))
 690     {
 691         dst[0] = '\0';
 692         return MSVCRT_EINVAL;
 693     }
 694
 695     for(i = 0; i < elem; i++)
 696     {
 697         if(dst[i] == '\0')
 698         {
 699             for(j = 0; (j + i) < elem; j++)
 700             {
 701                 if(count == MSVCRT__TRUNCATE && j + i == elem - 1)
 702                 {
 703                     dst[j + i] = '\0';
 704                     return MSVCRT_STRUNCATE;
 705                 }
 706                 if(j == count || (dst[j + i] = src[j]) == '\0')
 707                 {
 708                     dst[j + i] = '\0';
 709                     return 0;
 710                 }
 711             }
 712         }
 713     }
 714     /* Set the first element to 0, not the first element after the skipped part */
 715     dst[0] = '\0';
 716     return MSVCRT_ERANGE;
 717 }
 718
 719 /*********************************************************************
 720  *      strncat (MSVCRT.@)
 721  */
 722 char* __cdecl MSVCRT_strncat(char *dst, const char *src, MSVCRT_size_t len)
 723 {
 724     return strncat(dst, src, len);
 725 }
 726
 727 /*********************************************************************
 728  *              _strxfrm_l (MSVCRT.@)
 729  */
 730 MSVCRT_size_t CDECL MSVCRT__strxfrm_l( char *dest, const char *src,
 731         MSVCRT_size_t len, MSVCRT__locale_t locale )
 732 {
 733     MSVCRT_pthreadlocinfo locinfo;
 734     int ret;
 735
 736     if(!MSVCRT_CHECK_PMT(src)) return INT_MAX;
 737     if(!MSVCRT_CHECK_PMT(dest || !len)) return INT_MAX;
 738
 739     if(len > INT_MAX) {
 740         FIXME("len > INT_MAX not supported\n");
 741         len = INT_MAX;
 742     }
 743
 744     if(!locale)
 745         locinfo = get_locinfo();
 746     else
 747         locinfo = locale->locinfo;
 748
 749     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE]) {
 750         MSVCRT_strncpy(dest, src, len);
 751         return strlen(src);
 752     }
 753
 754     ret = LCMapStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE],
 755             LCMAP_SORTKEY, src, -1, NULL, 0);
 756     if(!ret) {
 757         if(len) dest[0] = 0;
 758         *MSVCRT__errno() = MSVCRT_EILSEQ;
 759         return INT_MAX;
 760     }
 761     if(!len) return ret-1;
 762
 763     if(ret > len) {
 764         dest[0] = 0;
 765         *MSVCRT__errno() = MSVCRT_ERANGE;
 766         return ret-1;
 767     }
 768
 769     return LCMapStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE],
 770             LCMAP_SORTKEY, src, -1, dest, len) - 1;
 771 }
 772
 773 /*********************************************************************
 774  *              strxfrm (MSVCRT.@)
 775  */
 776 MSVCRT_size_t CDECL MSVCRT_strxfrm( char *dest, const char *src, MSVCRT_size_t len )
 777 {
 778     return MSVCRT__strxfrm_l(dest, src, len, NULL);
 779 }
 780
 781 /********************************************************************
 782  *              _atoldbl (MSVCRT.@)
 783  */
 784 int CDECL MSVCRT__atoldbl(MSVCRT__LDOUBLE *value, const char *str)
 785 {
 786   /* FIXME needs error checking for huge/small values */
 787 #ifdef HAVE_STRTOLD
 788   long double ld;
 789   TRACE("str %s value %p\n",str,value);
 790   ld = strtold(str,0);
 791   memcpy(value, &ld, 10);
 792 #else
 793   FIXME("stub, str %s value %p\n",str,value);
 794 #endif
 795   return 0;
 796 }
 797
 798 /********************************************************************
 799  *              __STRINGTOLD (MSVCRT.@)
 800  */
 801 int CDECL __STRINGTOLD( MSVCRT__LDOUBLE *value, char **endptr, const char *str, int flags )
 802 {
 803 #ifdef HAVE_STRTOLD
 804     long double ld;
 805     FIXME("%p %p %s %x partial stub\n", value, endptr, str, flags );
 806     ld = strtold(str,0);
 807     memcpy(value, &ld, 10);
 808 #else
 809     FIXME("%p %p %s %x stub\n", value, endptr, str, flags );
 810 #endif
 811     return 0;
 812 }
 813
 814 /*********************************************************************
 815  *              strlen (MSVCRT.@)
 816  */
 817 MSVCRT_size_t __cdecl MSVCRT_strlen(const char *str)
 818 {
 819     return strlen(str);
 820 }
 821
 822 /******************************************************************
 823  *              strnlen (MSVCRT.@)
 824  */
 825 MSVCRT_size_t CDECL MSVCRT_strnlen(const char *s, MSVCRT_size_t maxlen)
 826 {
 827     MSVCRT_size_t i;
 828
 829     for(i=0; i<maxlen; i++)
 830         if(!s[i]) break;
 831
 832     return i;
 833 }
 834
 835 /*********************************************************************
 836  *  _strtoi64_l (MSVCRT.@)
 837  *
 838  * FIXME: locale parameter is ignored
 839  */
 840 __int64 CDECL MSVCRT_strtoi64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
 841 {
 842     BOOL negative = FALSE;
 843     __int64 ret = 0;
 844
 845     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
 846
 847     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
 848     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
 849     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
 850
 851     while(isspace(*nptr)) nptr++;
 852
 853     if(*nptr == '-') {
 854         negative = TRUE;
 855         nptr++;
 856     } else if(*nptr == '+')
 857         nptr++;
 858
 859     if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') {
 860         base = 16;
 861         nptr += 2;
 862     }
 863
 864     if(base == 0) {
 865         if(*nptr=='0')
 866             base = 8;
 867         else
 868             base = 10;
 869     }
 870
 871     while(*nptr) {
 872         char cur = tolower(*nptr);
 873         int v;
 874
 875         if(isdigit(cur)) {
 876             if(cur >= '0'+base)
 877                 break;
 878             v = cur-'0';
 879         } else {
 880             if(cur<'a' || cur>='a'+base-10)
 881                 break;
 882             v = cur-'a'+10;
 883         }
 884
 885         if(negative)
 886             v = -v;
 887
 888         nptr++;
 889
 890         if(!negative && (ret>MSVCRT_I64_MAX/base || ret*base>MSVCRT_I64_MAX-v)) {
 891             ret = MSVCRT_I64_MAX;
 892             *MSVCRT__errno() = MSVCRT_ERANGE;
 893         } else if(negative && (ret<MSVCRT_I64_MIN/base || ret*base<MSVCRT_I64_MIN-v)) {
 894             ret = MSVCRT_I64_MIN;
 895             *MSVCRT__errno() = MSVCRT_ERANGE;
 896         } else
 897             ret = ret*base + v;
 898     }
 899
 900     if(endptr)
 901         *endptr = (char*)nptr;
 902
 903     return ret;
 904 }
 905
 906 /*********************************************************************
 907  *  _strtoi64 (MSVCRT.@)
 908  */
 909 __int64 CDECL MSVCRT_strtoi64(const char *nptr, char **endptr, int base)
 910 {
 911     return MSVCRT_strtoi64_l(nptr, endptr, base, NULL);
 912 }
 913
 914 /*********************************************************************
 915  *  _atoi_l (MSVCRT.@)
 916  */
 917 int __cdecl MSVCRT__atoi_l(const char *str, MSVCRT__locale_t locale)
 918 {
 919     __int64 ret = MSVCRT_strtoi64_l(str, NULL, 10, locale);
 920
 921     if(ret > INT_MAX) {
 922         ret = INT_MAX;
 923         *MSVCRT__errno() = MSVCRT_ERANGE;
 924     } else if(ret < INT_MIN) {
 925         ret = INT_MIN;
 926         *MSVCRT__errno() = MSVCRT_ERANGE;
 927     }
 928     return ret;
 929 }
 930
 931 /*********************************************************************
 932  *  atoi (MSVCRT.@)
 933  */
 934 #if _MSVCR_VER == 0
 935 int __cdecl MSVCRT_atoi(const char *str)
 936 {
 937     BOOL minus = FALSE;
 938     int ret = 0;
 939
 940     if(!str)
 941         return 0;
 942
 943     while(isspace(*str)) str++;
 944
 945     if(*str == '+') {
 946         str++;
 947     }else if(*str == '-') {
 948         minus = TRUE;
 949         str++;
 950     }
 951
 952     while(*str>='0' && *str<='9') {
 953         ret = ret*10+*str-'0';
 954         str++;
 955     }
 956
 957     return minus ? -ret : ret;
 958 }
 959 #else
 960 int CDECL MSVCRT_atoi(const char *str)
 961 {
 962     return MSVCRT__atoi_l(str, NULL);
 963 }
 964 #endif
 965
 966 /******************************************************************
 967  *              strtol (MSVCRT.@)
 968  */
 969 MSVCRT_long CDECL MSVCRT_strtol(const char* nptr, char** end, int base)
 970 {
 971     __int64 ret = MSVCRT_strtoi64_l(nptr, end, base, NULL);
 972
 973     if(ret > MSVCRT_LONG_MAX) {
 974         ret = MSVCRT_LONG_MAX;
 975         *MSVCRT__errno() = MSVCRT_ERANGE;
 976     } else if(ret < MSVCRT_LONG_MIN) {
 977         ret = MSVCRT_LONG_MIN;
 978         *MSVCRT__errno() = MSVCRT_ERANGE;
 979     }
 980
 981     return ret;
 982 }
 983
 984 /******************************************************************
 985  *              _strtoul_l (MSVCRT.@)
 986  */
 987 MSVCRT_ulong CDECL MSVCRT_strtoul_l(const char* nptr, char** end, int base, MSVCRT__locale_t locale)
 988 {
 989     __int64 ret = MSVCRT_strtoi64_l(nptr, end, base, locale);
 990
 991     if(ret > MSVCRT_ULONG_MAX) {
 992         ret = MSVCRT_ULONG_MAX;
 993         *MSVCRT__errno() = MSVCRT_ERANGE;
 994     }else if(ret < -(__int64)MSVCRT_ULONG_MAX) {
 995         ret = 1;
 996         *MSVCRT__errno() = MSVCRT_ERANGE;
 997     }
 998
 999     return ret;
1000 }
1001
1002 /******************************************************************
1003  *              strtoul (MSVCRT.@)
1004  */
1005 MSVCRT_ulong CDECL MSVCRT_strtoul(const char* nptr, char** end, int base)
1006 {
1007     return MSVCRT_strtoul_l(nptr, end, base, NULL);
1008 }
1009
1010 /*********************************************************************
1011  *  _strtoui64_l (MSVCRT.@)
1012  *
1013  * FIXME: locale parameter is ignored
1014  */
1015 unsigned __int64 CDECL MSVCRT_strtoui64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
1016 {
1017     BOOL negative = FALSE;
1018     unsigned __int64 ret = 0;
1019
1020     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
1021
1022     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
1023     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
1024     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
1025
1026     while(isspace(*nptr)) nptr++;
1027
1028     if(*nptr == '-') {
1029         negative = TRUE;
1030         nptr++;
1031     } else if(*nptr == '+')
1032         nptr++;
1033
1034     if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') {
1035         base = 16;
1036         nptr += 2;
1037     }
1038
1039     if(base == 0) {
1040         if(*nptr=='0')
1041             base = 8;
1042         else
1043             base = 10;
1044     }
1045
1046     while(*nptr) {
1047         char cur = tolower(*nptr);
1048         int v;
1049
1050         if(isdigit(cur)) {
1051             if(cur >= '0'+base)
1052                 break;
1053             v = *nptr-'0';
1054         } else {
1055             if(cur<'a' || cur>='a'+base-10)
1056                 break;
1057             v = cur-'a'+10;
1058         }
1059
1060         nptr++;
1061
1062         if(ret>MSVCRT_UI64_MAX/base || ret*base>MSVCRT_UI64_MAX-v) {
1063             ret = MSVCRT_UI64_MAX;
1064             *MSVCRT__errno() = MSVCRT_ERANGE;
1065         } else
1066             ret = ret*base + v;
1067     }
1068
1069     if(endptr)
1070         *endptr = (char*)nptr;
1071
1072     return negative ? -ret : ret;
1073 }
1074
1075 /*********************************************************************
1076  *  _strtoui64 (MSVCRT.@)
1077  */
1078 unsigned __int64 CDECL MSVCRT_strtoui64(const char *nptr, char **endptr, int base)
1079 {
1080     return MSVCRT_strtoui64_l(nptr, endptr, base, NULL);
1081 }
1082
1083 static int ltoa_helper(MSVCRT_long value, char *str, MSVCRT_size_t size, int radix)
1084 {
1085     MSVCRT_ulong val;
1086     unsigned int digit;
1087     BOOL is_negative;
1088     char buffer[33], *pos;
1089     size_t len;
1090
1091     if (value < 0 && radix == 10)
1092     {
1093         is_negative = TRUE;
1094         val = -value;
1095     }
1096     else
1097     {
1098         is_negative = FALSE;
1099         val = value;
1100     }
1101
1102     pos = buffer + 32;
1103     *pos = '\0';
1104
1105     do
1106     {
1107         digit = val % radix;
1108         val /= radix;
1109
1110         if (digit < 10)
1111             *--pos = '0' + digit;
1112         else
1113             *--pos = 'a' + digit - 10;
1114     }
1115     while (val != 0);
1116
1117     if (is_negative)
1118         *--pos = '-';
1119
1120     len = buffer + 33 - pos;
1121     if (len > size)
1122     {
1123         size_t i;
1124         char *p = str;
1125
1126         /* Copy the temporary buffer backwards up to the available number of
1127          * characters. Don't copy the negative sign if present. */
1128
1129         if (is_negative)
1130         {
1131             p++;
1132             size--;
1133         }
1134
1135         for (pos = buffer + 31, i = 0; i < size; i++)
1136             *p++ = *pos--;
1137
1138         str[0] = '\0';
1139         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1140         return MSVCRT_ERANGE;
1141     }
1142
1143     memcpy(str, pos, len);
1144     return 0;
1145 }
1146
1147 /*********************************************************************
1148  *  _ltoa_s (MSVCRT.@)
1149  */
1150 int CDECL MSVCRT__ltoa_s(MSVCRT_long value, char *str, MSVCRT_size_t size, int radix)
1151 {
1152     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1153     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1154     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1155     {
1156         str[0] = '\0';
1157         return MSVCRT_EINVAL;
1158     }
1159
1160     return ltoa_helper(value, str, size, radix);
1161 }
1162
1163 /*********************************************************************
1164  *  _ltow_s (MSVCRT.@)
1165  */
1166 int CDECL MSVCRT__ltow_s(MSVCRT_long value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1167 {
1168     MSVCRT_ulong val;
1169     unsigned int digit;
1170     BOOL is_negative;
1171     MSVCRT_wchar_t buffer[33], *pos;
1172     size_t len;
1173
1174     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1175     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1176     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1177     {
1178         str[0] = '\0';
1179         return MSVCRT_EINVAL;
1180     }
1181
1182     if (value < 0 && radix == 10)
1183     {
1184         is_negative = TRUE;
1185         val = -value;
1186     }
1187     else
1188     {
1189         is_negative = FALSE;
1190         val = value;
1191     }
1192
1193     pos = buffer + 32;
1194     *pos = '\0';
1195
1196     do
1197     {
1198         digit = val % radix;
1199         val /= radix;
1200
1201         if (digit < 10)
1202             *--pos = '0' + digit;
1203         else
1204             *--pos = 'a' + digit - 10;
1205     }
1206     while (val != 0);
1207
1208     if (is_negative)
1209         *--pos = '-';
1210
1211     len = buffer + 33 - pos;
1212     if (len > size)
1213     {
1214         size_t i;
1215         MSVCRT_wchar_t *p = str;
1216
1217         /* Copy the temporary buffer backwards up to the available number of
1218          * characters. Don't copy the negative sign if present. */
1219
1220         if (is_negative)
1221         {
1222             p++;
1223             size--;
1224         }
1225
1226         for (pos = buffer + 31, i = 0; i < size; i++)
1227             *p++ = *pos--;
1228
1229         str[0] = '\0';
1230         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1231         return MSVCRT_ERANGE;
1232     }
1233
1234     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1235     return 0;
1236 }
1237
1238 /*********************************************************************
1239  *  _itoa_s (MSVCRT.@)
1240  */
1241 int CDECL MSVCRT__itoa_s(int value, char *str, MSVCRT_size_t size, int radix)
1242 {
1243     return MSVCRT__ltoa_s(value, str, size, radix);
1244 }
1245
1246 /*********************************************************************
1247  *  _itoa (MSVCRT.@)
1248  */
1249 char* CDECL MSVCRT__itoa(int value, char *str, int radix)
1250 {
1251     return ltoa_helper(value, str, MSVCRT_SIZE_MAX, radix) ? NULL : str;
1252 }
1253
1254 /*********************************************************************
1255  *  _itow_s (MSVCRT.@)
1256  */
1257 int CDECL MSVCRT__itow_s(int value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1258 {
1259     return MSVCRT__ltow_s(value, str, size, radix);
1260 }
1261
1262 /*********************************************************************
1263  *  _ui64toa_s (MSVCRT.@)
1264  */
1265 int CDECL MSVCRT__ui64toa_s(unsigned __int64 value, char *str,
1266         MSVCRT_size_t size, int radix)
1267 {
1268     char buffer[65], *pos;
1269     int digit;
1270
1271     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1272     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1273     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1274     {
1275         str[0] = '\0';
1276         return MSVCRT_EINVAL;
1277     }
1278
1279     pos = buffer+64;
1280     *pos = '\0';
1281
1282     do {
1283         digit = value%radix;
1284         value /= radix;
1285
1286         if(digit < 10)
1287             *--pos = '0'+digit;
1288         else
1289             *--pos = 'a'+digit-10;
1290     }while(value != 0);
1291
1292     if(buffer-pos+65 > size) {
1293         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
1294         return MSVCRT_EINVAL;
1295     }
1296
1297     memcpy(str, pos, buffer-pos+65);
1298     return 0;
1299 }
1300
1301 /*********************************************************************
1302  *      _ui64tow_s  (MSVCRT.@)
1303  */
1304 int CDECL MSVCRT__ui64tow_s( unsigned __int64 value, MSVCRT_wchar_t *str,
1305                              MSVCRT_size_t size, int radix )
1306 {
1307     MSVCRT_wchar_t buffer[65], *pos;
1308     int digit;
1309
1310     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1311     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1312     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1313     {
1314         str[0] = '\0';
1315         return MSVCRT_EINVAL;
1316     }
1317
1318     pos = &buffer[64];
1319     *pos = '\0';
1320
1321     do {
1322         digit = value % radix;
1323         value = value / radix;
1324         if (digit < 10)
1325             *--pos = '0' + digit;
1326         else
1327             *--pos = 'a' + digit - 10;
1328     } while (value != 0);
1329
1330     if(buffer-pos+65 > size) {
1331         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
1332         return MSVCRT_EINVAL;
1333     }
1334
1335     memcpy(str, pos, (buffer-pos+65)*sizeof(MSVCRT_wchar_t));
1336     return 0;
1337 }
1338
1339 /*********************************************************************
1340  *  _ultoa_s (MSVCRT.@)
1341  */
1342 int CDECL MSVCRT__ultoa_s(MSVCRT_ulong value, char *str, MSVCRT_size_t size, int radix)
1343 {
1344     MSVCRT_ulong digit;
1345     char buffer[33], *pos;
1346     size_t len;
1347
1348     if (!str || !size || radix < 2 || radix > 36)
1349     {
1350         if (str && size)
1351             str[0] = '\0';
1352
1353         *MSVCRT__errno() = MSVCRT_EINVAL;
1354         return MSVCRT_EINVAL;
1355     }
1356
1357     pos = buffer + 32;
1358     *pos = '\0';
1359
1360     do
1361     {
1362         digit = value % radix;
1363         value /= radix;
1364
1365         if (digit < 10)
1366             *--pos = '0' + digit;
1367         else
1368             *--pos = 'a' + digit - 10;
1369     }
1370     while (value != 0);
1371
1372     len = buffer + 33 - pos;
1373     if (len > size)
1374     {
1375         size_t i;
1376         char *p = str;
1377
1378         /* Copy the temporary buffer backwards up to the available number of
1379          * characters. */
1380
1381         for (pos = buffer + 31, i = 0; i < size; i++)
1382             *p++ = *pos--;
1383
1384         str[0] = '\0';
1385         *MSVCRT__errno() = MSVCRT_ERANGE;
1386         return MSVCRT_ERANGE;
1387     }
1388
1389     memcpy(str, pos, len);
1390     return 0;
1391 }
1392
1393 /*********************************************************************
1394  *  _ultow_s (MSVCRT.@)
1395  */
1396 int CDECL MSVCRT__ultow_s(MSVCRT_ulong value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1397 {
1398     MSVCRT_ulong digit;
1399     WCHAR buffer[33], *pos;
1400     size_t len;
1401
1402     if (!str || !size || radix < 2 || radix > 36)
1403     {
1404         if (str && size)
1405             str[0] = '\0';
1406
1407         *MSVCRT__errno() = MSVCRT_EINVAL;
1408         return MSVCRT_EINVAL;
1409     }
1410
1411     pos = buffer + 32;
1412     *pos = '\0';
1413
1414     do
1415     {
1416         digit = value % radix;
1417         value /= radix;
1418
1419         if (digit < 10)
1420             *--pos = '0' + digit;
1421         else
1422             *--pos = 'a' + digit - 10;
1423     }
1424     while (value != 0);
1425
1426     len = buffer + 33 - pos;
1427     if (len > size)
1428     {
1429         size_t i;
1430         WCHAR *p = str;
1431
1432         /* Copy the temporary buffer backwards up to the available number of
1433          * characters. */
1434
1435         for (pos = buffer + 31, i = 0; i < size; i++)
1436             *p++ = *pos--;
1437
1438         str[0] = '\0';
1439         *MSVCRT__errno() = MSVCRT_ERANGE;
1440         return MSVCRT_ERANGE;
1441     }
1442
1443     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1444     return 0;
1445 }
1446
1447 /*********************************************************************
1448  *  _i64toa_s (MSVCRT.@)
1449  */
1450 int CDECL MSVCRT__i64toa_s(__int64 value, char *str, MSVCRT_size_t size, int radix)
1451 {
1452     unsigned __int64 val;
1453     unsigned int digit;
1454     BOOL is_negative;
1455     char buffer[65], *pos;
1456     size_t len;
1457
1458     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1459     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1460     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1461     {
1462         str[0] = '\0';
1463         return MSVCRT_EINVAL;
1464     }
1465
1466     if (value < 0 && radix == 10)
1467     {
1468         is_negative = TRUE;
1469         val = -value;
1470     }
1471     else
1472     {
1473         is_negative = FALSE;
1474         val = value;
1475     }
1476
1477     pos = buffer + 64;
1478     *pos = '\0';
1479
1480     do
1481     {
1482         digit = val % radix;
1483         val /= radix;
1484
1485         if (digit < 10)
1486             *--pos = '0' + digit;
1487         else
1488             *--pos = 'a' + digit - 10;
1489     }
1490     while (val != 0);
1491
1492     if (is_negative)
1493         *--pos = '-';
1494
1495     len = buffer + 65 - pos;
1496     if (len > size)
1497     {
1498         size_t i;
1499         char *p = str;
1500
1501         /* Copy the temporary buffer backwards up to the available number of
1502          * characters. Don't copy the negative sign if present. */
1503
1504         if (is_negative)
1505         {
1506             p++;
1507             size--;
1508         }
1509
1510         for (pos = buffer + 63, i = 0; i < size; i++)
1511             *p++ = *pos--;
1512
1513         str[0] = '\0';
1514         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1515         return MSVCRT_ERANGE;
1516     }
1517
1518     memcpy(str, pos, len);
1519     return 0;
1520 }
1521
1522 /*********************************************************************
1523  *  _i64tow_s (MSVCRT.@)
1524  */
1525 int CDECL MSVCRT__i64tow_s(__int64 value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1526 {
1527     unsigned __int64 val;
1528     unsigned int digit;
1529     BOOL is_negative;
1530     MSVCRT_wchar_t buffer[65], *pos;
1531     size_t len;
1532
1533     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1534     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1535     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1536     {
1537         str[0] = '\0';
1538         return MSVCRT_EINVAL;
1539     }
1540
1541     if (value < 0 && radix == 10)
1542     {
1543         is_negative = TRUE;
1544         val = -value;
1545     }
1546     else
1547     {
1548         is_negative = FALSE;
1549         val = value;
1550     }
1551
1552     pos = buffer + 64;
1553     *pos = '\0';
1554
1555     do
1556     {
1557         digit = val % radix;
1558         val /= radix;
1559
1560         if (digit < 10)
1561             *--pos = '0' + digit;
1562         else
1563             *--pos = 'a' + digit - 10;
1564     }
1565     while (val != 0);
1566
1567     if (is_negative)
1568         *--pos = '-';
1569
1570     len = buffer + 65 - pos;
1571     if (len > size)
1572     {
1573         size_t i;
1574         MSVCRT_wchar_t *p = str;
1575
1576         /* Copy the temporary buffer backwards up to the available number of
1577          * characters. Don't copy the negative sign if present. */
1578
1579         if (is_negative)
1580         {
1581             p++;
1582             size--;
1583         }
1584
1585         for (pos = buffer + 63, i = 0; i < size; i++)
1586             *p++ = *pos--;
1587
1588         str[0] = '\0';
1589         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1590         return MSVCRT_ERANGE;
1591     }
1592
1593     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1594     return 0;
1595 }
1596
1597 #define I10_OUTPUT_MAX_PREC 21
1598 /* Internal structure used by $I10_OUTPUT */
1599 struct _I10_OUTPUT_DATA {
1600     short pos;
1601     char sign;
1602     BYTE len;
1603     char str[I10_OUTPUT_MAX_PREC+1]; /* add space for '\0' */
1604 };
1605
1606 /*********************************************************************
1607  *              $I10_OUTPUT (MSVCRT.@)
1608  * ld80 - long double (Intel 80 bit FP in 12 bytes) to be printed to data
1609  * prec - precision of part, we're interested in
1610  * flag - 0 for first prec digits, 1 for fractional part
1611  * data - data to be populated
1612  *
1613  * return value
1614  *      0 if given double is NaN or INF
1615  *      1 otherwise
1616  *
1617  * FIXME
1618  *      Native sets last byte of data->str to '0' or '9', I don't know what
1619  *      it means. Current implementation sets it always to '0'.
1620  */
1621 int CDECL MSVCRT_I10_OUTPUT(MSVCRT__LDOUBLE ld80, int prec, int flag, struct _I10_OUTPUT_DATA *data)
1622 {
1623     static const char inf_str[] = "1#INF";
1624     static const char nan_str[] = "1#QNAN";
1625
1626     /* MS' long double type wants 12 bytes for Intel's 80 bit FP format.
1627      * Some UNIX have sizeof(long double) == 16, yet only 80 bit are used.
1628      * Assume long double uses 80 bit FP, never seen 128 bit FP. */
1629     long double ld = 0;
1630     double d;
1631     char format[8];
1632     char buf[I10_OUTPUT_MAX_PREC+9]; /* 9 = strlen("0.e+0000") + '\0' */
1633     char *p;
1634
1635     memcpy(&ld, &ld80, 10);
1636     d = ld;
1637     TRACE("(%lf %d %x %p)\n", d, prec, flag, data);
1638
1639     if(d<0) {
1640         data->sign = '-';
1641         d = -d;
1642     } else
1643         data->sign = ' ';
1644
1645     if(isinf(d)) {
1646         data->pos = 1;
1647         data->len = 5;
1648         memcpy(data->str, inf_str, sizeof(inf_str));
1649
1650         return 0;
1651     }
1652
1653     if(isnan(d)) {
1654         data->pos = 1;
1655         data->len = 6;
1656         memcpy(data->str, nan_str, sizeof(nan_str));
1657
1658         return 0;
1659     }
1660
1661     if(flag&1) {
1662         int exp = 1+floor(log10(d));
1663
1664         prec += exp;
1665         if(exp < 0)
1666             prec--;
1667     }
1668     prec--;
1669
1670     if(prec+1 > I10_OUTPUT_MAX_PREC)
1671         prec = I10_OUTPUT_MAX_PREC-1;
1672     else if(prec < 0) {
1673         d = 0.0;
1674         prec = 0;
1675     }
1676
1677     sprintf(format, "%%.%dle", prec);
1678     sprintf(buf, format, d);
1679
1680     buf[1] = buf[0];
1681     data->pos = atoi(buf+prec+3);
1682     if(buf[1] != '0')
1683         data->pos++;
1684
1685     for(p = buf+prec+1; p>buf+1 && *p=='0'; p--);
1686     data->len = p-buf;
1687
1688     memcpy(data->str, buf+1, data->len);
1689     data->str[data->len] = '\0';
1690
1691     if(buf[1]!='0' && prec-data->len+1>0)
1692         memcpy(data->str+data->len+1, buf+data->len+1, prec-data->len+1);
1693
1694     return 1;
1695 }
1696 #undef I10_OUTPUT_MAX_PREC
1697
1698 /*********************************************************************
1699  *                  memcmp (MSVCRT.@)
1700  */
1701 int __cdecl MSVCRT_memcmp(const void *ptr1, const void *ptr2, MSVCRT_size_t n)
1702 {
1703     return memcmp(ptr1, ptr2, n);
1704 }
1705
1706 /*********************************************************************
1707  *                  memcpy   (MSVCRT.@)
1708  */
1709 void * __cdecl MSVCRT_memcpy(void *dst, const void *src, MSVCRT_size_t n)
1710 {
1711     return memmove(dst, src, n);
1712 }
1713
1714 /*********************************************************************
1715  *                  memmove (MSVCRT.@)
1716  */
1717 void * __cdecl MSVCRT_memmove(void *dst, const void *src, MSVCRT_size_t n)
1718 {
1719     return memmove(dst, src, n);
1720 }
1721
1722 /*********************************************************************
1723  *                  memset (MSVCRT.@)
1724  */
1725 void* __cdecl MSVCRT_memset(void *dst, int c, MSVCRT_size_t n)
1726 {
1727     return memset(dst, c, n);
1728 }
1729
1730 /*********************************************************************
1731  *                  strchr (MSVCRT.@)
1732  */
1733 char* __cdecl MSVCRT_strchr(const char *str, int c)
1734 {
1735     return strchr(str, c);
1736 }
1737
1738 /*********************************************************************
1739  *                  strrchr (MSVCRT.@)
1740  */
1741 char* __cdecl MSVCRT_strrchr(const char *str, int c)
1742 {
1743     return strrchr(str, c);
1744 }
1745
1746 /*********************************************************************
1747  *                  memchr   (MSVCRT.@)
1748  */
1749 void* __cdecl MSVCRT_memchr(const void *ptr, int c, MSVCRT_size_t n)
1750 {
1751     return memchr(ptr, c, n);
1752 }
1753
1754 /*********************************************************************
1755  *                  strcmp (MSVCRT.@)
1756  */
1757 int __cdecl MSVCRT_strcmp(const char *str1, const char *str2)
1758 {
1759     return strcmp(str1, str2);
1760 }
1761
1762 /*********************************************************************
1763  *                  strncmp   (MSVCRT.@)
1764  */
1765 int __cdecl MSVCRT_strncmp(const char *str1, const char *str2, MSVCRT_size_t len)
1766 {
1767     return strncmp(str1, str2, len);
1768 }
1769
1770 /*********************************************************************
1771  *                  _strnicmp_l   (MSVCRT.@)
1772  */
1773 int __cdecl MSVCRT__strnicmp_l(const char *s1, const char *s2,
1774         MSVCRT_size_t count, MSVCRT__locale_t locale)
1775 {
1776     MSVCRT_pthreadlocinfo locinfo;
1777     int c1, c2;
1778
1779     if(s1==NULL || s2==NULL)
1780         return MSVCRT__NLSCMPERROR;
1781
1782     if(!count)
1783         return 0;
1784
1785     if(!locale)
1786         locinfo = get_locinfo();
1787     else
1788         locinfo = locale->locinfo;
1789
1790     if(!locinfo->lc_handle[MSVCRT_LC_CTYPE])
1791         return strncasecmp(s1, s2, count);
1792
1793     do {
1794         c1 = MSVCRT__tolower_l(*s1++, locale);
1795         c2 = MSVCRT__tolower_l(*s2++, locale);
1796     }while(--count && c1 && c1==c2);
1797
1798     return c1-c2;
1799 }
1800
1801 /*********************************************************************
1802  *                  _stricmp_l   (MSVCRT.@)
1803  */
1804 int __cdecl MSVCRT__stricmp_l(const char *s1, const char *s2, MSVCRT__locale_t locale)
1805 {
1806     return MSVCRT__strnicmp_l(s1, s2, -1, locale);
1807 }
1808
1809 /*********************************************************************
1810  *                  _strnicmp   (MSVCRT.@)
1811  */
1812 int __cdecl MSVCRT__strnicmp(const char *s1, const char *s2, MSVCRT_size_t count)
1813 {
1814     return MSVCRT__strnicmp_l(s1, s2, count, NULL);
1815 }
1816
1817 /*********************************************************************
1818  *                  _stricmp   (MSVCRT.@)
1819  */
1820 int __cdecl MSVCRT__stricmp(const char *s1, const char *s2)
1821 {
1822     return MSVCRT__strnicmp_l(s1, s2, -1, NULL);
1823 }
1824
1825 /*********************************************************************
1826  *                  strstr   (MSVCRT.@)
1827  */
1828 char* __cdecl MSVCRT_strstr(const char *haystack, const char *needle)
1829 {
1830     return strstr(haystack, needle);
1831 }