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