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 #include <assert.h>
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <math.h>
  28 #include <limits.h>
  29 #include <locale.h>
  30 #include <errno.h>
  31 #include "msvcrt.h"
  32 #include "bnum.h"
  33 #include "winnls.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  37
  38 /*********************************************************************
  39  *              _mbsdup (MSVCRT.@)
  40  *              _strdup (MSVCRT.@)
  41  */
  42 char* CDECL MSVCRT__strdup(const char* str)
  43 {
  44     if(str)
  45     {
  46       char * ret = MSVCRT_malloc(strlen(str)+1);
  47       if (ret) strcpy( ret, str );
  48       return ret;
  49     }
  50     else return 0;
  51 }
  52
  53 /*********************************************************************
  54  *              _strlwr_s_l (MSVCRT.@)
  55  */
  56 int CDECL MSVCRT__strlwr_s_l(char *str, MSVCRT_size_t len, MSVCRT__locale_t locale)
  57 {
  58     MSVCRT_pthreadlocinfo locinfo;
  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     if(!locale)
  81         locinfo = get_locinfo();
  82     else
  83         locinfo = locale->locinfo;
  84
  85     if(!locinfo->lc_handle[MSVCRT_LC_CTYPE])
  86     {
  87         while (*str)
  88         {
  89             if (*str >= 'A' && *str <= 'Z')
  90                 *str -= 'A' - 'a';
  91             str++;
  92         }
  93     }
  94     else
  95     {
  96         while (*str)
  97         {
  98             *str = MSVCRT__tolower_l((unsigned char)*str, locale);
  99             str++;
 100         }
 101     }
 102
 103     return 0;
 104 }
 105
 106 /*********************************************************************
 107  *              _strlwr_s (MSVCRT.@)
 108  */
 109 int CDECL MSVCRT__strlwr_s(char *str, MSVCRT_size_t len)
 110 {
 111     return MSVCRT__strlwr_s_l(str, len, NULL);
 112 }
 113
 114 /*********************************************************************
 115  *              _strlwr_l (MSVCRT.@)
 116  */
 117 char* CDECL _strlwr_l(char *str, MSVCRT__locale_t locale)
 118 {
 119     MSVCRT__strlwr_s_l(str, -1, locale);
 120     return str;
 121 }
 122
 123 /*********************************************************************
 124  *              _strlwr (MSVCRT.@)
 125  */
 126 char* CDECL MSVCRT__strlwr(char *str)
 127 {
 128     MSVCRT__strlwr_s_l(str, -1, NULL);
 129     return str;
 130 }
 131
 132 /*********************************************************************
 133  *              _strupr_s_l (MSVCRT.@)
 134  */
 135 int CDECL MSVCRT__strupr_s_l(char *str, MSVCRT_size_t len, MSVCRT__locale_t locale)
 136 {
 137     MSVCRT_pthreadlocinfo locinfo;
 138     char *ptr = str;
 139
 140     if (!str || !len)
 141     {
 142         *MSVCRT__errno() = MSVCRT_EINVAL;
 143         return MSVCRT_EINVAL;
 144     }
 145
 146     while (len && *ptr)
 147     {
 148         len--;
 149         ptr++;
 150     }
 151
 152     if (!len)
 153     {
 154         str[0] = '\0';
 155         *MSVCRT__errno() = MSVCRT_EINVAL;
 156         return MSVCRT_EINVAL;
 157     }
 158
 159     if(!locale)
 160         locinfo = get_locinfo();
 161     else
 162         locinfo = locale->locinfo;
 163
 164     if(!locinfo->lc_handle[MSVCRT_LC_CTYPE])
 165     {
 166         while (*str)
 167         {
 168             if (*str >= 'a' && *str <= 'z')
 169                 *str -= 'a' - 'A';
 170             str++;
 171         }
 172     }
 173     else
 174     {
 175         while (*str)
 176         {
 177             *str = MSVCRT__toupper_l((unsigned char)*str, locale);
 178             str++;
 179         }
 180     }
 181
 182     return 0;
 183 }
 184
 185 /*********************************************************************
 186  *              _strupr_s (MSVCRT.@)
 187  */
 188 int CDECL MSVCRT__strupr_s(char *str, MSVCRT_size_t len)
 189 {
 190     return MSVCRT__strupr_s_l(str, len, NULL);
 191 }
 192
 193 /*********************************************************************
 194  *              _strupr_l (MSVCRT.@)
 195  */
 196 char* CDECL MSVCRT__strupr_l(char *str, MSVCRT__locale_t locale)
 197 {
 198     MSVCRT__strupr_s_l(str, -1, locale);
 199     return str;
 200 }
 201
 202 /*********************************************************************
 203  *              _strupr (MSVCRT.@)
 204  */
 205 char* CDECL MSVCRT__strupr(char *str)
 206 {
 207     MSVCRT__strupr_s_l(str, -1, NULL);
 208     return str;
 209 }
 210
 211 /*********************************************************************
 212  *              _strnset_s (MSVCRT.@)
 213  */
 214 int CDECL MSVCRT__strnset_s(char *str, MSVCRT_size_t size, int c, MSVCRT_size_t count)
 215 {
 216     MSVCRT_size_t i;
 217
 218     if(!str && !size && !count) return 0;
 219     if(!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
 220     if(!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
 221
 222     for(i=0; i<size-1 && i<count; i++) {
 223         if(!str[i]) return 0;
 224         str[i] = c;
 225     }
 226     for(; i<size; i++)
 227         if(!str[i]) return 0;
 228
 229     str[0] = 0;
 230     MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
 231     *MSVCRT__errno() = MSVCRT_EINVAL;
 232     return MSVCRT_EINVAL;
 233 }
 234
 235 /*********************************************************************
 236  *              _strnset (MSVCRT.@)
 237  */
 238 char* CDECL MSVCRT__strnset(char* str, int value, MSVCRT_size_t len)
 239 {
 240   if (len > 0 && str)
 241     while (*str && len--)
 242       *str++ = value;
 243   return str;
 244 }
 245
 246 /*********************************************************************
 247  *              _strrev (MSVCRT.@)
 248  */
 249 char* CDECL MSVCRT__strrev(char* str)
 250 {
 251   char * p1;
 252   char * p2;
 253
 254   if (str && *str)
 255     for (p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2)
 256     {
 257       *p1 ^= *p2;
 258       *p2 ^= *p1;
 259       *p1 ^= *p2;
 260     }
 261
 262   return str;
 263 }
 264
 265 /*********************************************************************
 266  *              _strset (MSVCRT.@)
 267  */
 268 char* CDECL _strset(char* str, int value)
 269 {
 270   char *ptr = str;
 271   while (*ptr)
 272     *ptr++ = value;
 273
 274   return str;
 275 }
 276
 277 /*********************************************************************
 278  *              strtok  (MSVCRT.@)
 279  */
 280 char * CDECL MSVCRT_strtok( char *str, const char *delim )
 281 {
 282     thread_data_t *data = msvcrt_get_thread_data();
 283     char *ret;
 284
 285     if (!str)
 286         if (!(str = data->strtok_next)) return NULL;
 287
 288     while (*str && strchr( delim, *str )) str++;
 289     if (!*str) return NULL;
 290     ret = str++;
 291     while (*str && !strchr( delim, *str )) str++;
 292     if (*str) *str++ = 0;
 293     data->strtok_next = str;
 294     return ret;
 295 }
 296
 297 /*********************************************************************
 298  *              strtok_s  (MSVCRT.@)
 299  */
 300 char * CDECL MSVCRT_strtok_s(char *str, const char *delim, char **ctx)
 301 {
 302     if (!MSVCRT_CHECK_PMT(delim != NULL)) return NULL;
 303     if (!MSVCRT_CHECK_PMT(ctx != NULL)) return NULL;
 304     if (!MSVCRT_CHECK_PMT(str != NULL || *ctx != NULL)) return NULL;
 305
 306     if(!str)
 307         str = *ctx;
 308
 309     while(*str && strchr(delim, *str))
 310         str++;
 311     if(!*str)
 312     {
 313         *ctx = str;
 314         return NULL;
 315     }
 316
 317     *ctx = str+1;
 318     while(**ctx && !strchr(delim, **ctx))
 319         (*ctx)++;
 320     if(**ctx)
 321         *(*ctx)++ = 0;
 322
 323     return str;
 324 }
 325
 326 /*********************************************************************
 327  *              _swab (MSVCRT.@)
 328  */
 329 void CDECL MSVCRT__swab(char* src, char* dst, int len)
 330 {
 331   if (len > 1)
 332   {
 333     len = (unsigned)len >> 1;
 334
 335     while (len--) {
 336       char s0 = src[0];
 337       char s1 = src[1];
 338       *dst++ = s1;
 339       *dst++ = s0;
 340       src = src + 2;
 341     }
 342   }
 343 }
 344
 345 static struct fpnum fpnum(int sign, int exp, ULONGLONG m, enum fpmod mod)
 346 {
 347     struct fpnum ret;
 348
 349     ret.sign = sign;
 350     ret.exp = exp;
 351     ret.m = m;
 352     ret.mod = mod;
 353     return ret;
 354 }
 355
 356 int fpnum_double(struct fpnum *fp, double *d)
 357 {
 358     ULONGLONG bits = 0;
 359
 360     if (fp->mod == FP_VAL_INFINITY)
 361     {
 362         *d = fp->sign * INFINITY;
 363         return 0;
 364     }
 365
 366     if (fp->mod == FP_VAL_NAN)
 367     {
 368         bits = ~0;
 369         if (fp->sign == 1)
 370             bits &= ~((ULONGLONG)1 << (MANT_BITS + EXP_BITS - 1));
 371         *d = *(double*)&bits;
 372         return 0;
 373     }
 374
 375     TRACE("%c %s *2^%d (round %d)\n", fp->sign == -1 ? '-' : '+',
 376             wine_dbgstr_longlong(fp->m), fp->exp, fp->mod);
 377     if (!fp->m)
 378     {
 379         *d = fp->sign * 0.0;
 380         return 0;
 381     }
 382
 383     /* make sure that we don't overflow modifying exponent */
 384     if (fp->exp > 1<<EXP_BITS)
 385     {
 386         *d = fp->sign * INFINITY;
 387         return MSVCRT_ERANGE;
 388     }
 389     if (fp->exp < -(1<<EXP_BITS))
 390     {
 391         *d = fp->sign * 0.0;
 392         return MSVCRT_ERANGE;
 393     }
 394     fp->exp += MANT_BITS - 1;
 395
 396     /* normalize mantissa */
 397     while(fp->m < (ULONGLONG)1 << (MANT_BITS-1))
 398     {
 399         fp->m <<= 1;
 400         fp->exp--;
 401     }
 402     while(fp->m >= (ULONGLONG)1 << MANT_BITS)
 403     {
 404         if (fp->m & 1 || fp->mod != FP_ROUND_ZERO)
 405         {
 406             if (!(fp->m & 1)) fp->mod = FP_ROUND_DOWN;
 407             else if(fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
 408             else fp->mod = FP_ROUND_UP;
 409         }
 410         fp->m >>= 1;
 411         fp->exp++;
 412     }
 413     fp->exp += (1 << (EXP_BITS-1)) - 1;
 414
 415     /* handle subnormals */
 416     if (fp->exp <= 0)
 417     {
 418         if (fp->m & 1 && fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
 419         else if (fp->m & 1) fp->mod = FP_ROUND_UP;
 420         else if (fp->mod != FP_ROUND_ZERO) fp->mod = FP_ROUND_DOWN;
 421         fp->m >>= 1;
 422     }
 423     while(fp->m && fp->exp<0)
 424     {
 425         if (fp->m & 1 && fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
 426         else if (fp->m & 1) fp->mod = FP_ROUND_UP;
 427         else if (fp->mod != FP_ROUND_ZERO) fp->mod = FP_ROUND_DOWN;
 428         fp->m >>= 1;
 429         fp->exp++;
 430     }
 431
 432     /* round mantissa */
 433     if (fp->mod == FP_ROUND_UP || (fp->mod == FP_ROUND_EVEN && fp->m & 1))
 434     {
 435         fp->m++;
 436
 437         /* handle subnormal that falls into regular range due to rounding */
 438         if (fp->m == (ULONGLONG)1 << (MANT_BITS - 1))
 439         {
 440             fp->exp++;
 441         }
 442         else if (fp->m >= (ULONGLONG)1 << MANT_BITS)
 443         {
 444             fp->exp++;
 445             fp->m >>= 1;
 446         }
 447     }
 448
 449     if (fp->exp >= (1<<EXP_BITS)-1)
 450     {
 451         *d = fp->sign * INFINITY;
 452         return MSVCRT_ERANGE;
 453     }
 454     if (!fp->m || fp->exp < 0)
 455     {
 456         *d = fp->sign * 0.0;
 457         return MSVCRT_ERANGE;
 458     }
 459
 460     if (fp->sign == -1)
 461         bits |= (ULONGLONG)1 << (MANT_BITS + EXP_BITS - 1);
 462     bits |= (ULONGLONG)fp->exp << (MANT_BITS - 1);
 463     bits |= fp->m & (((ULONGLONG)1 << (MANT_BITS - 1)) - 1);
 464
 465     TRACE("returning %s\n", wine_dbgstr_longlong(bits));
 466     *d = *(double*)&bits;
 467     return 0;
 468 }
 469
 470 #define LDBL_EXP_BITS 15
 471 #define LDBL_MANT_BITS 64
 472 int fpnum_ldouble(struct fpnum *fp, MSVCRT__LDOUBLE *d)
 473 {
 474     if (fp->mod == FP_VAL_INFINITY)
 475     {
 476         d->x80[0] = 0;
 477         d->x80[1] = 0x80000000;
 478         d->x80[2] = (1 << LDBL_EXP_BITS) - 1;
 479         if (fp->sign == -1)
 480             d->x80[2] |= 1 << LDBL_EXP_BITS;
 481         return 0;
 482     }
 483
 484     if (fp->mod == FP_VAL_NAN)
 485     {
 486         d->x80[0] = ~0;
 487         d->x80[1] = ~0;
 488         d->x80[2] = (1 << LDBL_EXP_BITS) - 1;
 489         if (fp->sign == -1)
 490             d->x80[2] |= 1 << LDBL_EXP_BITS;
 491         return 0;
 492     }
 493
 494     TRACE("%c %s *2^%d (round %d)\n", fp->sign == -1 ? '-' : '+',
 495             wine_dbgstr_longlong(fp->m), fp->exp, fp->mod);
 496     if (!fp->m)
 497     {
 498         d->x80[0] = 0;
 499         d->x80[1] = 0;
 500         d->x80[2] = 0;
 501         if (fp->sign == -1)
 502             d->x80[2] |= 1 << LDBL_EXP_BITS;
 503         return 0;
 504     }
 505
 506     /* make sure that we don't overflow modifying exponent */
 507     if (fp->exp > 1<<LDBL_EXP_BITS)
 508     {
 509         d->x80[0] = 0;
 510         d->x80[1] = 0x80000000;
 511         d->x80[2] = (1 << LDBL_EXP_BITS) - 1;
 512         if (fp->sign == -1)
 513             d->x80[2] |= 1 << LDBL_EXP_BITS;
 514         return MSVCRT_ERANGE;
 515     }
 516     if (fp->exp < -(1<<LDBL_EXP_BITS))
 517     {
 518         d->x80[0] = 0;
 519         d->x80[1] = 0;
 520         d->x80[2] = 0;
 521         if (fp->sign == -1)
 522             d->x80[2] |= 1 << LDBL_EXP_BITS;
 523         return MSVCRT_ERANGE;
 524     }
 525     fp->exp += LDBL_MANT_BITS - 1;
 526
 527     /* normalize mantissa */
 528     while(fp->m < (ULONGLONG)1 << (LDBL_MANT_BITS-1))
 529     {
 530         fp->m <<= 1;
 531         fp->exp--;
 532     }
 533     fp->exp += (1 << (LDBL_EXP_BITS-1)) - 1;
 534
 535     /* handle subnormals */
 536     if (fp->exp <= 0)
 537     {
 538         if (fp->m & 1 && fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
 539         else if (fp->m & 1) fp->mod = FP_ROUND_UP;
 540         else if (fp->mod != FP_ROUND_ZERO) fp->mod = FP_ROUND_DOWN;
 541         fp->m >>= 1;
 542     }
 543     while(fp->m && fp->exp<0)
 544     {
 545         if (fp->m & 1 && fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
 546         else if (fp->m & 1) fp->mod = FP_ROUND_UP;
 547         else if (fp->mod != FP_ROUND_ZERO) fp->mod = FP_ROUND_DOWN;
 548         fp->m >>= 1;
 549         fp->exp++;
 550     }
 551
 552     /* round mantissa */
 553     if (fp->mod == FP_ROUND_UP || (fp->mod == FP_ROUND_EVEN && fp->m & 1))
 554     {
 555         if (fp->m == MSVCRT_UI64_MAX)
 556         {
 557             fp->m = (ULONGLONG)1 << (LDBL_MANT_BITS - 1);
 558             fp->exp++;
 559         }
 560         else
 561         {
 562             fp->m++;
 563
 564             /* handle subnormal that falls into regular range due to rounding */
 565             if ((fp->m ^ (fp->m - 1)) & ((ULONGLONG)1 << (LDBL_MANT_BITS - 1))) fp->exp++;
 566         }
 567     }
 568
 569     if (fp->exp >= (1<<LDBL_EXP_BITS)-1)
 570     {
 571         d->x80[0] = 0;
 572         d->x80[1] = 0x80000000;
 573         d->x80[2] = (1 << LDBL_EXP_BITS) - 1;
 574         if (fp->sign == -1)
 575             d->x80[2] |= 1 << LDBL_EXP_BITS;
 576         return MSVCRT_ERANGE;
 577     }
 578     if (!fp->m || fp->exp < 0)
 579     {
 580         d->x80[0] = 0;
 581         d->x80[1] = 0;
 582         d->x80[2] = 0;
 583         if (fp->sign == -1)
 584             d->x80[2] |= 1 << LDBL_EXP_BITS;
 585         return MSVCRT_ERANGE;
 586     }
 587
 588     d->x80[0] = fp->m;
 589     d->x80[1] = fp->m >> 32;
 590     d->x80[2] = fp->exp;
 591     if (fp->sign == -1)
 592         d->x80[2] |= 1 << LDBL_EXP_BITS;
 593     return 0;
 594 }
 595
 596 #if _MSVCR_VER >= 140
 597
 598 static inline int hex2int(char c)
 599 {
 600     if (c >= '0' && c <= '9')
 601         return c - '0';
 602     else if (c >= 'a' && c <= 'f')
 603         return c - 'a' + 10;
 604     else if (c >= 'A' && c <= 'F')
 605         return c - 'A' + 10;
 606     return -1;
 607 }
 608
 609 static struct fpnum fpnum_parse16(MSVCRT_wchar_t get(void *ctx), void unget(void *ctx),
 610         void *ctx, int sign, MSVCRT_pthreadlocinfo locinfo)
 611 {
 612     BOOL found_digit = FALSE, found_dp = FALSE;
 613     enum fpmod round = FP_ROUND_ZERO;
 614     MSVCRT_wchar_t nch;
 615     ULONGLONG m = 0;
 616     int val, exp = 0;
 617
 618     nch = get(ctx);
 619     while(m < MSVCRT_UI64_MAX/16)
 620     {
 621         val = hex2int(nch);
 622         if (val == -1) break;
 623         found_digit = TRUE;
 624         nch = get(ctx);
 625
 626         m = m*16 + val;
 627     }
 628     while(1)
 629     {
 630         val = hex2int(nch);
 631         if (val == -1) break;
 632         nch = get(ctx);
 633         exp += 4;
 634
 635         if (val || round != FP_ROUND_ZERO)
 636         {
 637             if (val < 8) round = FP_ROUND_DOWN;
 638             else if (val == 8 && round == FP_ROUND_ZERO) round = FP_ROUND_EVEN;
 639             else round = FP_ROUND_UP;
 640         }
 641     }
 642
 643     if(nch == *locinfo->lconv->decimal_point)
 644     {
 645         found_dp = TRUE;
 646         nch = get(ctx);
 647     }
 648     else if (!found_digit)
 649     {
 650         if(nch!=MSVCRT_WEOF) unget(ctx);
 651         unget(ctx);
 652         return fpnum(0, 0, 0, 0);
 653     }
 654
 655     while(m <= MSVCRT_UI64_MAX/16)
 656     {
 657         val = hex2int(nch);
 658         if (val == -1) break;
 659         found_digit = TRUE;
 660         nch = get(ctx);
 661
 662         m = m*16 + val;
 663         exp -= 4;
 664     }
 665     while(1)
 666     {
 667         val = hex2int(nch);
 668         if (val == -1) break;
 669         nch = get(ctx);
 670
 671         if (val || round != FP_ROUND_ZERO)
 672         {
 673             if (val < 8) round = FP_ROUND_DOWN;
 674             else if (val == 8 && round == FP_ROUND_ZERO) round = FP_ROUND_EVEN;
 675             else round = FP_ROUND_UP;
 676         }
 677     }
 678
 679     if (!found_digit)
 680     {
 681         if (nch != MSVCRT_WEOF) unget(ctx);
 682         if (found_dp) unget(ctx);
 683         unget(ctx);
 684         return fpnum(0, 0, 0, 0);
 685     }
 686
 687     if(nch=='p' || nch=='P') {
 688         BOOL found_sign = FALSE;
 689         int e=0, s=1;
 690
 691         nch = get(ctx);
 692         if(nch == '-') {
 693             found_sign = TRUE;
 694             s = -1;
 695             nch = get(ctx);
 696         } else if(nch == '+') {
 697             found_sign = TRUE;
 698             nch = get(ctx);
 699         }
 700         if(nch>='0' && nch<='9') {
 701             while(nch>='0' && nch<='9') {
 702                 if(e>INT_MAX/10 || e*10>INT_MAX-nch+'0')
 703                     e = INT_MAX;
 704                 else
 705                     e = e*10+nch-'0';
 706                 nch = get(ctx);
 707             }
 708             if((nch!=MSVCRT_WEOF) && (nch < '0' || nch > '9')) unget(ctx);
 709             e *= s;
 710
 711             if(e<0 && exp<INT_MIN-e) exp = INT_MIN;
 712             else if(e>0 && exp>INT_MAX-e) exp = INT_MAX;
 713             else exp += e;
 714         } else {
 715             if(nch != MSVCRT_WEOF) unget(ctx);
 716             if(found_sign) unget(ctx);
 717             unget(ctx);
 718         }
 719     }
 720
 721     return fpnum(sign, exp, m, round);
 722 }
 723 #endif
 724
 725 /* Converts first 3 limbs to ULONGLONG */
 726 /* Return FALSE on overflow */
 727 static inline BOOL bnum_to_mant(struct bnum *b, ULONGLONG *m)
 728 {
 729     if(MSVCRT_UI64_MAX / LIMB_MAX / LIMB_MAX < b->data[bnum_idx(b, b->e-1)]) return FALSE;
 730     *m = (ULONGLONG)b->data[bnum_idx(b, b->e-1)] * LIMB_MAX * LIMB_MAX;
 731     if(b->b == b->e-1) return TRUE;
 732     if(MSVCRT_UI64_MAX - *m < (ULONGLONG)b->data[bnum_idx(b, b->e-2)] * LIMB_MAX) return FALSE;
 733     *m += (ULONGLONG)b->data[bnum_idx(b, b->e-2)] * LIMB_MAX;
 734     if(b->b == b->e-2) return TRUE;
 735     if(MSVCRT_UI64_MAX - *m < b->data[bnum_idx(b, b->e-3)]) return FALSE;
 736     *m += b->data[bnum_idx(b, b->e-3)];
 737     return TRUE;
 738 }
 739
 740 static struct fpnum fpnum_parse_bnum(MSVCRT_wchar_t (*get)(void *ctx), void (*unget)(void *ctx),
 741         void *ctx, MSVCRT_pthreadlocinfo locinfo, BOOL ldouble, struct bnum *b)
 742 {
 743 #if _MSVCR_VER >= 140
 744     MSVCRT_wchar_t _infinity[] = { 'i', 'n', 'f', 'i', 'n', 'i', 't', 'y', 0 };
 745     MSVCRT_wchar_t _nan[] = { 'n', 'a', 'n', 0 };
 746     MSVCRT_wchar_t *str_match = NULL;
 747     int matched=0;
 748 #endif
 749     BOOL found_digit = FALSE, found_dp = FALSE, found_sign = FALSE;
 750     int e2 = 0, dp=0, sign=1, off, limb_digits = 0, i;
 751     enum fpmod round = FP_ROUND_ZERO;
 752     MSVCRT_wchar_t nch;
 753     ULONGLONG m;
 754
 755     nch = get(ctx);
 756     if(nch == '-') {
 757         found_sign = TRUE;
 758         sign = -1;
 759         nch = get(ctx);
 760     } else if(nch == '+') {
 761         found_sign = TRUE;
 762         nch = get(ctx);
 763     }
 764
 765 #if _MSVCR_VER >= 140
 766     if(nch == _infinity[0] || nch == MSVCRT__toupper(_infinity[0]))
 767         str_match = _infinity;
 768     if(nch == _nan[0] || nch == MSVCRT__toupper(_nan[0]))
 769         str_match = _nan;
 770     while(str_match && nch != MSVCRT_WEOF &&
 771             (nch == str_match[matched] || nch == MSVCRT__toupper(str_match[matched]))) {
 772         nch = get(ctx);
 773         matched++;
 774     }
 775     if(str_match) {
 776         int keep = 0;
 777         if(matched >= 8) keep = 8;
 778         else if(matched >= 3) keep = 3;
 779         if(nch != MSVCRT_WEOF) unget(ctx);
 780         for (; matched > keep; matched--) {
 781             unget(ctx);
 782         }
 783         if(keep) {
 784             if (str_match == _infinity)
 785                 return fpnum(sign, 0, 0, FP_VAL_INFINITY);
 786             if (str_match == _nan)
 787                 return fpnum(sign, 0, 0, FP_VAL_NAN);
 788         } else if(found_sign) {
 789             unget(ctx);
 790         }
 791
 792         return fpnum(0, 0, 0, 0);
 793     }
 794
 795     if(nch == '0') {
 796         found_digit = TRUE;
 797         nch = get(ctx);
 798         if(nch == 'x' || nch == 'X')
 799             return fpnum_parse16(get, unget, ctx, sign, locinfo);
 800     }
 801 #endif
 802
 803     while(nch == '0') {
 804         found_digit = TRUE;
 805         nch = get(ctx);
 806     }
 807
 808     b->b = 0;
 809     b->e = 1;
 810     b->data[0] = 0;
 811     while(nch>='0' && nch<='9') {
 812         found_digit = TRUE;
 813         if(limb_digits == LIMB_DIGITS) {
 814             if(bnum_idx(b, b->b-1) == bnum_idx(b, b->e)) break;
 815             else {
 816                 b->b--;
 817                 b->data[bnum_idx(b, b->b)] = 0;
 818                 limb_digits = 0;
 819             }
 820         }
 821
 822         b->data[bnum_idx(b, b->b)] = b->data[bnum_idx(b, b->b)] * 10 + nch - '0';
 823         limb_digits++;
 824         nch = get(ctx);
 825         dp++;
 826     }
 827     while(nch>='0' && nch<='9') {
 828         if(nch != '0') b->data[bnum_idx(b, b->b)] |= 1;
 829         nch = get(ctx);
 830         dp++;
 831     }
 832
 833     if(nch == *locinfo->lconv->decimal_point) {
 834         found_dp = TRUE;
 835         nch = get(ctx);
 836     }
 837
 838     /* skip leading '0' */
 839     if(nch=='0' && !limb_digits && !b->b) {
 840         found_digit = TRUE;
 841         while(nch == '0') {
 842             nch = get(ctx);
 843             dp--;
 844         }
 845     }
 846
 847     while(nch>='0' && nch<='9') {
 848         found_digit = TRUE;
 849         if(limb_digits == LIMB_DIGITS) {
 850             if(bnum_idx(b, b->b-1) == bnum_idx(b, b->e)) break;
 851             else {
 852                 b->b--;
 853                 b->data[bnum_idx(b, b->b)] = 0;
 854                 limb_digits = 0;
 855             }
 856         }
 857
 858         b->data[bnum_idx(b, b->b)] = b->data[bnum_idx(b, b->b)] * 10 + nch - '0';
 859         limb_digits++;
 860         nch = get(ctx);
 861     }
 862     while(nch>='0' && nch<='9') {
 863         if(nch != '0') b->data[bnum_idx(b, b->b)] |= 1;
 864         nch = get(ctx);
 865     }
 866
 867     if(!found_digit) {
 868         if(nch != MSVCRT_WEOF) unget(ctx);
 869         if(found_dp) unget(ctx);
 870         if(found_sign) unget(ctx);
 871         return fpnum(0, 0, 0, 0);
 872     }
 873
 874     if(nch=='e' || nch=='E' || nch=='d' || nch=='D') {
 875         int e=0, s=1;
 876
 877         nch = get(ctx);
 878         if(nch == '-') {
 879             found_sign = TRUE;
 880             s = -1;
 881             nch = get(ctx);
 882         } else if(nch == '+') {
 883             found_sign = TRUE;
 884             nch = get(ctx);
 885         } else {
 886             found_sign = FALSE;
 887         }
 888
 889         if(nch>='0' && nch<='9') {
 890             while(nch>='0' && nch<='9') {
 891                 if(e>INT_MAX/10 || e*10>INT_MAX-nch+'0')
 892                     e = INT_MAX;
 893                 else
 894                     e = e*10+nch-'0';
 895                 nch = get(ctx);
 896             }
 897             if(nch != MSVCRT_WEOF) unget(ctx);
 898             e *= s;
 899
 900             if(e<0 && dp<INT_MIN-e) dp = INT_MIN;
 901             else if(e>0 && dp>INT_MAX-e) dp = INT_MAX;
 902             else dp += e;
 903         } else {
 904             if(nch != MSVCRT_WEOF) unget(ctx);
 905             if(found_sign) unget(ctx);
 906             unget(ctx);
 907         }
 908     } else if(nch != MSVCRT_WEOF) {
 909         unget(ctx);
 910     }
 911
 912     if(!b->data[bnum_idx(b, b->e-1)])
 913         return fpnum(sign, 0, 0, 0);
 914
 915     /* Fill last limb with 0 if needed */
 916     if(b->b+1 != b->e) {
 917         for(; limb_digits != LIMB_DIGITS; limb_digits++)
 918             b->data[bnum_idx(b, b->b)] *= 10;
 919     }
 920     for(; bnum_idx(b, b->b) < bnum_idx(b, b->e); b->b++) {
 921         if(b->data[bnum_idx(b, b->b)]) break;
 922     }
 923
 924     /* move decimal point to limb boundary */
 925     if(limb_digits==dp && b->b==b->e-1)
 926         return fpnum(sign, 0, b->data[bnum_idx(b, b->e-1)], FP_ROUND_ZERO);
 927     off = (dp - limb_digits) % LIMB_DIGITS;
 928     if(off < 0) off += LIMB_DIGITS;
 929     if(off) bnum_mult(b, p10s[off]);
 930
 931     if(dp-1 > (ldouble ? DBL80_MAX_10_EXP : MSVCRT_DBL_MAX_10_EXP))
 932         return fpnum(sign, INT_MAX, 1, FP_ROUND_ZERO);
 933     /* Count part of exponent stored in denormalized mantissa. */
 934     /* Increase exponent range to handle subnormals. */
 935     if(dp-1 < (ldouble ? DBL80_MIN_10_EXP : MSVCRT_DBL_MIN_10_EXP-MSVCRT_DBL_DIG-18))
 936         return fpnum(sign, INT_MIN, 1, FP_ROUND_ZERO);
 937
 938     while(dp > 3*LIMB_DIGITS) {
 939         if(bnum_rshift(b, 9)) dp -= LIMB_DIGITS;
 940         e2 += 9;
 941     }
 942     while(dp <= 2*LIMB_DIGITS) {
 943         if(bnum_lshift(b, 29)) dp += LIMB_DIGITS;
 944         e2 -= 29;
 945     }
 946     /* Make sure most significant mantissa bit will be set */
 947     while(b->data[bnum_idx(b, b->e-1)] <= 9) {
 948         bnum_lshift(b, 1);
 949         e2--;
 950     }
 951     while(!bnum_to_mant(b, &m)) {
 952         bnum_rshift(b, 1);
 953         e2++;
 954     }
 955
 956     if(b->e-4 >= b->b && b->data[bnum_idx(b, b->e-4)]) {
 957         if(b->data[bnum_idx(b, b->e-4)] > LIMB_MAX/2) round = FP_ROUND_UP;
 958         else if(b->data[bnum_idx(b, b->e-4)] == LIMB_MAX/2) round = FP_ROUND_EVEN;
 959         else round = FP_ROUND_DOWN;
 960     }
 961     if(round == FP_ROUND_ZERO || round == FP_ROUND_EVEN) {
 962         for(i=b->e-5; i>=b->b; i--) {
 963             if(!b->data[bnum_idx(b, b->b)]) continue;
 964             if(round == FP_ROUND_EVEN) round = FP_ROUND_UP;
 965             else round = FP_ROUND_DOWN;
 966         }
 967     }
 968
 969     return fpnum(sign, e2, m, round);
 970 }
 971
 972 struct fpnum fpnum_parse(MSVCRT_wchar_t (*get)(void *ctx), void (*unget)(void *ctx),
 973        void *ctx, MSVCRT_pthreadlocinfo locinfo, BOOL ldouble)
 974 {
 975     if(!ldouble) {
 976         BYTE bnum_data[FIELD_OFFSET(struct bnum, data[BNUM_PREC64])];
 977         struct bnum *b = (struct bnum*)bnum_data;
 978
 979         b->size = BNUM_PREC64;
 980         return fpnum_parse_bnum(get, unget, ctx, locinfo, ldouble, b);
 981     } else {
 982         BYTE bnum_data[FIELD_OFFSET(struct bnum, data[BNUM_PREC80])];
 983         struct bnum *b = (struct bnum*)bnum_data;
 984
 985         b->size = BNUM_PREC80;
 986         return fpnum_parse_bnum(get, unget, ctx, locinfo, ldouble, b);
 987     }
 988 }
 989
 990 static MSVCRT_wchar_t strtod_str_get(void *ctx)
 991 {
 992     const char **p = ctx;
 993     if (!**p) return MSVCRT_WEOF;
 994     return *(*p)++;
 995 }
 996
 997 static void strtod_str_unget(void *ctx)
 998 {
 999     const char **p = ctx;
1000     (*p)--;
1001 }
1002
1003 static inline double strtod_helper(const char *str, char **end, MSVCRT__locale_t locale, int *perr)
1004 {
1005     MSVCRT_pthreadlocinfo locinfo;
1006     const char *beg, *p;
1007     struct fpnum fp;
1008     double ret;
1009     int err;
1010
1011     if (perr) *perr = 0;
1012 #if _MSVCR_VER == 0
1013     else *MSVCRT__errno() = 0;
1014 #endif
1015
1016     if (!MSVCRT_CHECK_PMT(str != NULL)) {
1017         if (end) *end = NULL;
1018         return 0;
1019     }
1020
1021     if (!locale)
1022         locinfo = get_locinfo();
1023     else
1024         locinfo = locale->locinfo;
1025
1026     p = str;
1027     while(MSVCRT__isspace_l((unsigned char)*p, locale))
1028         p++;
1029     beg = p;
1030
1031     fp = fpnum_parse(strtod_str_get, strtod_str_unget, &p, locinfo, FALSE);
1032     if (end) *end = (p == beg ? (char*)str : (char*)p);
1033
1034     err = fpnum_double(&fp, &ret);
1035     if (perr) *perr = err;
1036     else if(err) *MSVCRT__errno() = err;
1037     return ret;
1038 }
1039
1040 /*********************************************************************
1041  *              strtod_l  (MSVCRT.@)
1042  */
1043 double CDECL MSVCRT_strtod_l(const char *str, char **end, MSVCRT__locale_t locale)
1044 {
1045     return strtod_helper(str, end, locale, NULL);
1046 }
1047
1048 /*********************************************************************
1049  *              strtod  (MSVCRT.@)
1050  */
1051 double CDECL MSVCRT_strtod( const char *str, char **end )
1052 {
1053     return MSVCRT_strtod_l( str, end, NULL );
1054 }
1055
1056 #if _MSVCR_VER>=120
1057
1058 /*********************************************************************
1059  *              strtof_l  (MSVCR120.@)
1060  */
1061 float CDECL MSVCRT__strtof_l( const char *str, char **end, MSVCRT__locale_t locale )
1062 {
1063     return MSVCRT_strtod_l(str, end, locale);
1064 }
1065
1066 /*********************************************************************
1067  *              strtof  (MSVCR120.@)
1068  */
1069 float CDECL MSVCRT_strtof( const char *str, char **end )
1070 {
1071     return MSVCRT__strtof_l(str, end, NULL);
1072 }
1073
1074 #endif /* _MSVCR_VER>=120 */
1075
1076 /*********************************************************************
1077  *              atof  (MSVCRT.@)
1078  */
1079 double CDECL MSVCRT_atof( const char *str )
1080 {
1081     return MSVCRT_strtod_l(str, NULL, NULL);
1082 }
1083
1084 /*********************************************************************
1085  *              _atof_l  (MSVCRT.@)
1086  */
1087 double CDECL MSVCRT__atof_l( const char *str, MSVCRT__locale_t locale)
1088 {
1089     return MSVCRT_strtod_l(str, NULL, locale);
1090 }
1091
1092 /*********************************************************************
1093  *              _atoflt_l  (MSVCRT.@)
1094  */
1095 int CDECL MSVCRT__atoflt_l( MSVCRT__CRT_FLOAT *value, char *str, MSVCRT__locale_t locale)
1096 {
1097     double d;
1098     int err;
1099
1100     d = strtod_helper(str, NULL, locale, &err);
1101     value->f = d;
1102     if(isinf(value->f))
1103         return MSVCRT__OVERFLOW;
1104     if((d!=0 || err) && value->f>-MSVCRT_FLT_MIN && value->f<MSVCRT_FLT_MIN)
1105         return MSVCRT__UNDERFLOW;
1106     return 0;
1107 }
1108
1109 /*********************************************************************
1110  * _atoflt  (MSVCR100.@)
1111  */
1112 int CDECL MSVCRT__atoflt(MSVCRT__CRT_FLOAT *value, char *str)
1113 {
1114     return MSVCRT__atoflt_l(value, str, NULL);
1115 }
1116
1117 /*********************************************************************
1118  *              _atodbl_l  (MSVCRT.@)
1119  */
1120 int CDECL MSVCRT__atodbl_l(MSVCRT__CRT_DOUBLE *value, char *str, MSVCRT__locale_t locale)
1121 {
1122     int err;
1123
1124     value->x = strtod_helper(str, NULL, locale, &err);
1125     if(isinf(value->x))
1126         return MSVCRT__OVERFLOW;
1127     if((value->x!=0 || err) && value->x>-MSVCRT_DBL_MIN && value->x<MSVCRT_DBL_MIN)
1128         return MSVCRT__UNDERFLOW;
1129     return 0;
1130 }
1131
1132 /*********************************************************************
1133  *              _atodbl  (MSVCRT.@)
1134  */
1135 int CDECL MSVCRT__atodbl(MSVCRT__CRT_DOUBLE *value, char *str)
1136 {
1137     return MSVCRT__atodbl_l(value, str, NULL);
1138 }
1139
1140 /*********************************************************************
1141  *              _strcoll_l (MSVCRT.@)
1142  */
1143 int CDECL MSVCRT_strcoll_l( const char* str1, const char* str2, MSVCRT__locale_t locale )
1144 {
1145     MSVCRT_pthreadlocinfo locinfo;
1146
1147     if(!locale)
1148         locinfo = get_locinfo();
1149     else
1150         locinfo = locale->locinfo;
1151
1152     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE])
1153         return strcmp(str1, str2);
1154     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], 0, str1, -1, str2, -1)-CSTR_EQUAL;
1155 }
1156
1157 /*********************************************************************
1158  *              strcoll (MSVCRT.@)
1159  */
1160 int CDECL MSVCRT_strcoll( const char* str1, const char* str2 )
1161 {
1162     return MSVCRT_strcoll_l(str1, str2, NULL);
1163 }
1164
1165 /*********************************************************************
1166  *              _stricoll_l (MSVCRT.@)
1167  */
1168 int CDECL MSVCRT__stricoll_l( const char* str1, const char* str2, MSVCRT__locale_t locale )
1169 {
1170     MSVCRT_pthreadlocinfo locinfo;
1171
1172     if(!locale)
1173         locinfo = get_locinfo();
1174     else
1175         locinfo = locale->locinfo;
1176
1177     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE])
1178         return MSVCRT__stricmp(str1, str2);
1179     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], NORM_IGNORECASE,
1180             str1, -1, str2, -1)-CSTR_EQUAL;
1181 }
1182
1183 /*********************************************************************
1184  *              _stricoll (MSVCRT.@)
1185  */
1186 int CDECL MSVCRT__stricoll( const char* str1, const char* str2 )
1187 {
1188     return MSVCRT__stricoll_l(str1, str2, NULL);
1189 }
1190
1191 /*********************************************************************
1192  *              _strncoll_l (MSVCRT.@)
1193  */
1194 int CDECL MSVCRT__strncoll_l( const char* str1, const char* str2, MSVCRT_size_t count, MSVCRT__locale_t locale )
1195 {
1196     MSVCRT_pthreadlocinfo locinfo;
1197
1198     if(!locale)
1199         locinfo = get_locinfo();
1200     else
1201         locinfo = locale->locinfo;
1202
1203     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE])
1204         return MSVCRT_strncmp(str1, str2, count);
1205     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], 0,
1206               str1, MSVCRT_strnlen(str1, count),
1207               str2, MSVCRT_strnlen(str2, count))-CSTR_EQUAL;
1208 }
1209
1210 /*********************************************************************
1211  *              _strncoll (MSVCRT.@)
1212  */
1213 int CDECL MSVCRT__strncoll( const char* str1, const char* str2, MSVCRT_size_t count )
1214 {
1215     return MSVCRT__strncoll_l(str1, str2, count, NULL);
1216 }
1217
1218 /*********************************************************************
1219  *              _strnicoll_l (MSVCRT.@)
1220  */
1221 int CDECL MSVCRT__strnicoll_l( const char* str1, const char* str2, MSVCRT_size_t count, MSVCRT__locale_t locale )
1222 {
1223     MSVCRT_pthreadlocinfo locinfo;
1224
1225     if(!locale)
1226         locinfo = get_locinfo();
1227     else
1228         locinfo = locale->locinfo;
1229
1230     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE])
1231         return MSVCRT__strnicmp(str1, str2, count);
1232     return CompareStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE], NORM_IGNORECASE,
1233             str1, MSVCRT_strnlen(str1, count),
1234             str2, MSVCRT_strnlen(str2, count))-CSTR_EQUAL;
1235 }
1236
1237 /*********************************************************************
1238  *              _strnicoll (MSVCRT.@)
1239  */
1240 int CDECL MSVCRT__strnicoll( const char* str1, const char* str2, MSVCRT_size_t count )
1241 {
1242     return MSVCRT__strnicoll_l(str1, str2, count, NULL);
1243 }
1244
1245 /*********************************************************************
1246  *                  strncpy (MSVCRT.@)
1247  */
1248 char* __cdecl MSVCRT_strncpy(char *dst, const char *src, MSVCRT_size_t len)
1249 {
1250     MSVCRT_size_t i;
1251
1252     for(i=0; i<len; i++)
1253         if((dst[i] = src[i]) == '\0') break;
1254
1255     while (i < len) dst[i++] = 0;
1256
1257     return dst;
1258 }
1259
1260 /*********************************************************************
1261  *      strcpy (MSVCRT.@)
1262  */
1263 char* CDECL strcpy(char *dst, const char *src)
1264 {
1265     char *ret = dst;
1266     while ((*dst++ = *src++));
1267     return ret;
1268 }
1269
1270 /*********************************************************************
1271  *      strcpy_s (MSVCRT.@)
1272  */
1273 int CDECL MSVCRT_strcpy_s( char* dst, MSVCRT_size_t elem, const char* src )
1274 {
1275     MSVCRT_size_t i;
1276     if(!elem) return MSVCRT_EINVAL;
1277     if(!dst) return MSVCRT_EINVAL;
1278     if(!src)
1279     {
1280         dst[0] = '\0';
1281         return MSVCRT_EINVAL;
1282     }
1283
1284     for(i = 0; i < elem; i++)
1285     {
1286         if((dst[i] = src[i]) == '\0') return 0;
1287     }
1288     dst[0] = '\0';
1289     return MSVCRT_ERANGE;
1290 }
1291
1292 /*********************************************************************
1293  *      strcat_s (MSVCRT.@)
1294  */
1295 int CDECL MSVCRT_strcat_s( char* dst, MSVCRT_size_t elem, const char* src )
1296 {
1297     MSVCRT_size_t i, j;
1298     if(!dst) return MSVCRT_EINVAL;
1299     if(elem == 0) return MSVCRT_EINVAL;
1300     if(!src)
1301     {
1302         dst[0] = '\0';
1303         return MSVCRT_EINVAL;
1304     }
1305
1306     for(i = 0; i < elem; i++)
1307     {
1308         if(dst[i] == '\0')
1309         {
1310             for(j = 0; (j + i) < elem; j++)
1311             {
1312                 if((dst[j + i] = src[j]) == '\0') return 0;
1313             }
1314         }
1315     }
1316     /* Set the first element to 0, not the first element after the skipped part */
1317     dst[0] = '\0';
1318     return MSVCRT_ERANGE;
1319 }
1320
1321 /*********************************************************************
1322  *      strcat (MSVCRT.@)
1323  */
1324 char* __cdecl strcat( char *dst, const char *src )
1325 {
1326     char *d = dst;
1327     while (*d) d++;
1328     while ((*d++ = *src++));
1329     return dst;
1330 }
1331
1332 /*********************************************************************
1333  *      strncat_s (MSVCRT.@)
1334  */
1335 int CDECL MSVCRT_strncat_s( char* dst, MSVCRT_size_t elem, const char* src, MSVCRT_size_t count )
1336 {
1337     MSVCRT_size_t i, j;
1338
1339     if (!MSVCRT_CHECK_PMT(dst != 0)) return MSVCRT_EINVAL;
1340     if (!MSVCRT_CHECK_PMT(elem != 0)) return MSVCRT_EINVAL;
1341     if (!MSVCRT_CHECK_PMT(src != 0))
1342     {
1343         dst[0] = '\0';
1344         return MSVCRT_EINVAL;
1345     }
1346
1347     for(i = 0; i < elem; i++)
1348     {
1349         if(dst[i] == '\0')
1350         {
1351             for(j = 0; (j + i) < elem; j++)
1352             {
1353                 if(count == MSVCRT__TRUNCATE && j + i == elem - 1)
1354                 {
1355                     dst[j + i] = '\0';
1356                     return MSVCRT_STRUNCATE;
1357                 }
1358                 if(j == count || (dst[j + i] = src[j]) == '\0')
1359                 {
1360                     dst[j + i] = '\0';
1361                     return 0;
1362                 }
1363             }
1364         }
1365     }
1366     /* Set the first element to 0, not the first element after the skipped part */
1367     dst[0] = '\0';
1368     return MSVCRT_ERANGE;
1369 }
1370
1371 /*********************************************************************
1372  *      strncat (MSVCRT.@)
1373  */
1374 char* __cdecl MSVCRT_strncat(char *dst, const char *src, MSVCRT_size_t len)
1375 {
1376     char *d = dst;
1377     while (*d) d++;
1378     for ( ; len && *src; d++, src++, len--) *d = *src;
1379     *d = 0;
1380     return dst;
1381 }
1382
1383 /*********************************************************************
1384  *              _strxfrm_l (MSVCRT.@)
1385  */
1386 MSVCRT_size_t CDECL MSVCRT__strxfrm_l( char *dest, const char *src,
1387         MSVCRT_size_t len, MSVCRT__locale_t locale )
1388 {
1389     MSVCRT_pthreadlocinfo locinfo;
1390     int ret;
1391
1392     if(!MSVCRT_CHECK_PMT(src)) return INT_MAX;
1393     if(!MSVCRT_CHECK_PMT(dest || !len)) return INT_MAX;
1394
1395     if(len > INT_MAX) {
1396         FIXME("len > INT_MAX not supported\n");
1397         len = INT_MAX;
1398     }
1399
1400     if(!locale)
1401         locinfo = get_locinfo();
1402     else
1403         locinfo = locale->locinfo;
1404
1405     if(!locinfo->lc_handle[MSVCRT_LC_COLLATE]) {
1406         MSVCRT_strncpy(dest, src, len);
1407         return strlen(src);
1408     }
1409
1410     ret = LCMapStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE],
1411             LCMAP_SORTKEY, src, -1, NULL, 0);
1412     if(!ret) {
1413         if(len) dest[0] = 0;
1414         *MSVCRT__errno() = MSVCRT_EILSEQ;
1415         return INT_MAX;
1416     }
1417     if(!len) return ret-1;
1418
1419     if(ret > len) {
1420         dest[0] = 0;
1421         *MSVCRT__errno() = MSVCRT_ERANGE;
1422         return ret-1;
1423     }
1424
1425     return LCMapStringA(locinfo->lc_handle[MSVCRT_LC_COLLATE],
1426             LCMAP_SORTKEY, src, -1, dest, len) - 1;
1427 }
1428
1429 /*********************************************************************
1430  *              strxfrm (MSVCRT.@)
1431  */
1432 MSVCRT_size_t CDECL MSVCRT_strxfrm( char *dest, const char *src, MSVCRT_size_t len )
1433 {
1434     return MSVCRT__strxfrm_l(dest, src, len, NULL);
1435 }
1436
1437 /********************************************************************
1438  *              __STRINGTOLD_L (MSVCR80.@)
1439  */
1440 int CDECL __STRINGTOLD_L( MSVCRT__LDOUBLE *value, char **endptr,
1441         const char *str, int flags, MSVCRT__locale_t locale )
1442 {
1443     MSVCRT_pthreadlocinfo locinfo;
1444     const char *beg, *p;
1445     int err, ret = 0;
1446     struct fpnum fp;
1447
1448     if (flags) FIXME("flags not supported: %x\n", flags);
1449
1450     if (!locale)
1451         locinfo = get_locinfo();
1452     else
1453         locinfo = locale->locinfo;
1454
1455     p = str;
1456     while (MSVCRT__isspace_l((unsigned char)*p, locale))
1457         p++;
1458     beg = p;
1459
1460     fp = fpnum_parse(strtod_str_get, strtod_str_unget, &p, locinfo, TRUE);
1461     if (endptr) *endptr = (p == beg ? (char*)str : (char*)p);
1462     if (p == beg) ret = 4;
1463
1464     err = fpnum_ldouble(&fp, value);
1465     if (err) ret = (value->x80[2] & 0x7fff ? 2 : 1);
1466     return ret;
1467 }
1468
1469 /********************************************************************
1470  *              __STRINGTOLD (MSVCRT.@)
1471  */
1472 int CDECL __STRINGTOLD( MSVCRT__LDOUBLE *value, char **endptr, const char *str, int flags )
1473 {
1474     return __STRINGTOLD_L( value, endptr, str, flags, NULL );
1475 }
1476
1477 /********************************************************************
1478  *              _atoldbl_l (MSVCRT.@)
1479  */
1480 int CDECL MSVCRT__atoldbl_l( MSVCRT__LDOUBLE *value, const char *str, MSVCRT__locale_t locale )
1481 {
1482     char *endptr;
1483     switch(__STRINGTOLD_L( value, &endptr, str, 0, locale ))
1484     {
1485     case 1: return MSVCRT__UNDERFLOW;
1486     case 2: return MSVCRT__OVERFLOW;
1487     default: return 0;
1488     }
1489 }
1490
1491 /********************************************************************
1492  *              _atoldbl (MSVCRT.@)
1493  */
1494 int CDECL MSVCRT__atoldbl(MSVCRT__LDOUBLE *value, const char *str)
1495 {
1496     return MSVCRT__atoldbl_l( value, str, NULL );
1497 }
1498
1499 /*********************************************************************
1500  *              strlen (MSVCRT.@)
1501  */
1502 size_t __cdecl strlen(const char *str)
1503 {
1504     const char *s = str;
1505     while (*s) s++;
1506     return s - str;
1507 }
1508
1509 /******************************************************************
1510  *              strnlen (MSVCRT.@)
1511  */
1512 MSVCRT_size_t CDECL MSVCRT_strnlen(const char *s, MSVCRT_size_t maxlen)
1513 {
1514     MSVCRT_size_t i;
1515
1516     for(i=0; i<maxlen; i++)
1517         if(!s[i]) break;
1518
1519     return i;
1520 }
1521
1522 /*********************************************************************
1523  *  _strtoi64_l (MSVCRT.@)
1524  *
1525  * FIXME: locale parameter is ignored
1526  */
1527 __int64 CDECL MSVCRT_strtoi64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
1528 {
1529     const char *p = nptr;
1530     BOOL negative = FALSE;
1531     BOOL got_digit = FALSE;
1532     __int64 ret = 0;
1533
1534     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
1535
1536     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
1537     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
1538     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
1539
1540     while(MSVCRT__isspace_l((unsigned char)*nptr, locale)) nptr++;
1541
1542     if(*nptr == '-') {
1543         negative = TRUE;
1544         nptr++;
1545     } else if(*nptr == '+')
1546         nptr++;
1547
1548     if((base==0 || base==16) && *nptr=='0' && MSVCRT__tolower_l(*(nptr+1), locale)=='x') {
1549         base = 16;
1550         nptr += 2;
1551     }
1552
1553     if(base == 0) {
1554         if(*nptr=='0')
1555             base = 8;
1556         else
1557             base = 10;
1558     }
1559
1560     while(*nptr) {
1561         char cur = MSVCRT__tolower_l(*nptr, locale);
1562         int v;
1563
1564         if(cur>='0' && cur<='9') {
1565             if(cur >= '0'+base)
1566                 break;
1567             v = cur-'0';
1568         } else {
1569             if(cur<'a' || cur>='a'+base-10)
1570                 break;
1571             v = cur-'a'+10;
1572         }
1573         got_digit = TRUE;
1574
1575         if(negative)
1576             v = -v;
1577
1578         nptr++;
1579
1580         if(!negative && (ret>MSVCRT_I64_MAX/base || ret*base>MSVCRT_I64_MAX-v)) {
1581             ret = MSVCRT_I64_MAX;
1582             *MSVCRT__errno() = MSVCRT_ERANGE;
1583         } else if(negative && (ret<MSVCRT_I64_MIN/base || ret*base<MSVCRT_I64_MIN-v)) {
1584             ret = MSVCRT_I64_MIN;
1585             *MSVCRT__errno() = MSVCRT_ERANGE;
1586         } else
1587             ret = ret*base + v;
1588     }
1589
1590     if(endptr)
1591         *endptr = (char*)(got_digit ? nptr : p);
1592
1593     return ret;
1594 }
1595
1596 /*********************************************************************
1597  *  _strtoi64 (MSVCRT.@)
1598  */
1599 __int64 CDECL MSVCRT_strtoi64(const char *nptr, char **endptr, int base)
1600 {
1601     return MSVCRT_strtoi64_l(nptr, endptr, base, NULL);
1602 }
1603
1604 /*********************************************************************
1605  *  _atoi_l (MSVCRT.@)
1606  */
1607 int __cdecl MSVCRT__atoi_l(const char *str, MSVCRT__locale_t locale)
1608 {
1609     __int64 ret = MSVCRT_strtoi64_l(str, NULL, 10, locale);
1610
1611     if(ret > INT_MAX) {
1612         ret = INT_MAX;
1613         *MSVCRT__errno() = MSVCRT_ERANGE;
1614     } else if(ret < INT_MIN) {
1615         ret = INT_MIN;
1616         *MSVCRT__errno() = MSVCRT_ERANGE;
1617     }
1618     return ret;
1619 }
1620
1621 /*********************************************************************
1622  *  atoi (MSVCRT.@)
1623  */
1624 #if _MSVCR_VER == 0
1625 int __cdecl MSVCRT_atoi(const char *str)
1626 {
1627     BOOL minus = FALSE;
1628     int ret = 0;
1629
1630     if(!str)
1631         return 0;
1632
1633     while(MSVCRT__isspace_l((unsigned char)*str, NULL)) str++;
1634
1635     if(*str == '+') {
1636         str++;
1637     }else if(*str == '-') {
1638         minus = TRUE;
1639         str++;
1640     }
1641
1642     while(*str>='0' && *str<='9') {
1643         ret = ret*10+*str-'0';
1644         str++;
1645     }
1646
1647     return minus ? -ret : ret;
1648 }
1649 #else
1650 int CDECL MSVCRT_atoi(const char *str)
1651 {
1652     return MSVCRT__atoi_l(str, NULL);
1653 }
1654 #endif
1655
1656 /******************************************************************
1657  *      _atoi64_l (MSVCRT.@)
1658  */
1659 __int64 CDECL MSVCRT__atoi64_l(const char *str, MSVCRT__locale_t locale)
1660 {
1661     return MSVCRT_strtoi64_l(str, NULL, 10, locale);
1662 }
1663
1664 /******************************************************************
1665  *      _atoi64 (MSVCRT.@)
1666  */
1667 __int64 CDECL MSVCRT__atoi64(const char *str)
1668 {
1669     return MSVCRT_strtoi64_l(str, NULL, 10, NULL);
1670 }
1671
1672 /******************************************************************
1673  *      _atol_l (MSVCRT.@)
1674  */
1675 MSVCRT_long CDECL MSVCRT__atol_l(const char *str, MSVCRT__locale_t locale)
1676 {
1677     __int64 ret = MSVCRT_strtoi64_l(str, NULL, 10, locale);
1678
1679     if(ret > MSVCRT_LONG_MAX) {
1680         ret = MSVCRT_LONG_MAX;
1681         *MSVCRT__errno() = MSVCRT_ERANGE;
1682     } else if(ret < MSVCRT_LONG_MIN) {
1683         ret = MSVCRT_LONG_MIN;
1684         *MSVCRT__errno() = MSVCRT_ERANGE;
1685     }
1686     return ret;
1687 }
1688
1689 /******************************************************************
1690  *      atol (MSVCRT.@)
1691  */
1692 MSVCRT_long CDECL MSVCRT_atol(const char *str)
1693 {
1694 #if _MSVCR_VER == 0
1695     return MSVCRT_atoi(str);
1696 #else
1697     return MSVCRT__atol_l(str, NULL);
1698 #endif
1699 }
1700
1701 #if _MSVCR_VER>=120
1702
1703 /******************************************************************
1704  *      _atoll_l (MSVCR120.@)
1705  */
1706 MSVCRT_longlong CDECL MSVCRT__atoll_l(const char* str, MSVCRT__locale_t locale)
1707 {
1708     return MSVCRT_strtoi64_l(str, NULL, 10, locale);
1709 }
1710
1711 /******************************************************************
1712  *      atoll (MSVCR120.@)
1713  */
1714 MSVCRT_longlong CDECL MSVCRT_atoll(const char* str)
1715 {
1716     return MSVCRT__atoll_l(str, NULL);
1717 }
1718
1719 #endif /* if _MSVCR_VER>=120 */
1720
1721 /******************************************************************
1722  *              _strtol_l (MSVCRT.@)
1723  */
1724 MSVCRT_long CDECL MSVCRT__strtol_l(const char* nptr,
1725         char** end, int base, MSVCRT__locale_t locale)
1726 {
1727     __int64 ret = MSVCRT_strtoi64_l(nptr, end, base, locale);
1728
1729     if(ret > MSVCRT_LONG_MAX) {
1730         ret = MSVCRT_LONG_MAX;
1731         *MSVCRT__errno() = MSVCRT_ERANGE;
1732     } else if(ret < MSVCRT_LONG_MIN) {
1733         ret = MSVCRT_LONG_MIN;
1734         *MSVCRT__errno() = MSVCRT_ERANGE;
1735     }
1736
1737     return ret;
1738 }
1739
1740 /******************************************************************
1741  *              strtol (MSVCRT.@)
1742  */
1743 MSVCRT_long CDECL MSVCRT_strtol(const char* nptr, char** end, int base)
1744 {
1745     return MSVCRT__strtol_l(nptr, end, base, NULL);
1746 }
1747
1748 /******************************************************************
1749  *              _strtoul_l (MSVCRT.@)
1750  */
1751 MSVCRT_ulong CDECL MSVCRT_strtoul_l(const char* nptr, char** end, int base, MSVCRT__locale_t locale)
1752 {
1753     __int64 ret = MSVCRT_strtoi64_l(nptr, end, base, locale);
1754
1755     if(ret > MSVCRT_ULONG_MAX) {
1756         ret = MSVCRT_ULONG_MAX;
1757         *MSVCRT__errno() = MSVCRT_ERANGE;
1758     }else if(ret < -(__int64)MSVCRT_ULONG_MAX) {
1759         ret = 1;
1760         *MSVCRT__errno() = MSVCRT_ERANGE;
1761     }
1762
1763     return ret;
1764 }
1765
1766 /******************************************************************
1767  *              strtoul (MSVCRT.@)
1768  */
1769 MSVCRT_ulong CDECL MSVCRT_strtoul(const char* nptr, char** end, int base)
1770 {
1771     return MSVCRT_strtoul_l(nptr, end, base, NULL);
1772 }
1773
1774 /*********************************************************************
1775  *  _strtoui64_l (MSVCRT.@)
1776  *
1777  * FIXME: locale parameter is ignored
1778  */
1779 unsigned __int64 CDECL MSVCRT_strtoui64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
1780 {
1781     const char *p = nptr;
1782     BOOL negative = FALSE;
1783     BOOL got_digit = FALSE;
1784     unsigned __int64 ret = 0;
1785
1786     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
1787
1788     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
1789     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
1790     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
1791
1792     while(MSVCRT__isspace_l((unsigned char)*nptr, locale)) nptr++;
1793
1794     if(*nptr == '-') {
1795         negative = TRUE;
1796         nptr++;
1797     } else if(*nptr == '+')
1798         nptr++;
1799
1800     if((base==0 || base==16) && *nptr=='0' && MSVCRT__tolower_l(*(nptr+1), locale)=='x') {
1801         base = 16;
1802         nptr += 2;
1803     }
1804
1805     if(base == 0) {
1806         if(*nptr=='0')
1807             base = 8;
1808         else
1809             base = 10;
1810     }
1811
1812     while(*nptr) {
1813         char cur = MSVCRT__tolower_l(*nptr, locale);
1814         int v;
1815
1816         if(cur>='0' && cur<='9') {
1817             if(cur >= '0'+base)
1818                 break;
1819             v = *nptr-'0';
1820         } else {
1821             if(cur<'a' || cur>='a'+base-10)
1822                 break;
1823             v = cur-'a'+10;
1824         }
1825         got_digit = TRUE;
1826
1827         nptr++;
1828
1829         if(ret>MSVCRT_UI64_MAX/base || ret*base>MSVCRT_UI64_MAX-v) {
1830             ret = MSVCRT_UI64_MAX;
1831             *MSVCRT__errno() = MSVCRT_ERANGE;
1832         } else
1833             ret = ret*base + v;
1834     }
1835
1836     if(endptr)
1837         *endptr = (char*)(got_digit ? nptr : p);
1838
1839     return negative ? -ret : ret;
1840 }
1841
1842 /*********************************************************************
1843  *  _strtoui64 (MSVCRT.@)
1844  */
1845 unsigned __int64 CDECL MSVCRT_strtoui64(const char *nptr, char **endptr, int base)
1846 {
1847     return MSVCRT_strtoui64_l(nptr, endptr, base, NULL);
1848 }
1849
1850 static int ltoa_helper(MSVCRT_long value, char *str, MSVCRT_size_t size, int radix)
1851 {
1852     MSVCRT_ulong val;
1853     unsigned int digit;
1854     BOOL is_negative;
1855     char buffer[33], *pos;
1856     size_t len;
1857
1858     if (value < 0 && radix == 10)
1859     {
1860         is_negative = TRUE;
1861         val = -value;
1862     }
1863     else
1864     {
1865         is_negative = FALSE;
1866         val = value;
1867     }
1868
1869     pos = buffer + 32;
1870     *pos = '\0';
1871
1872     do
1873     {
1874         digit = val % radix;
1875         val /= radix;
1876
1877         if (digit < 10)
1878             *--pos = '0' + digit;
1879         else
1880             *--pos = 'a' + digit - 10;
1881     }
1882     while (val != 0);
1883
1884     if (is_negative)
1885         *--pos = '-';
1886
1887     len = buffer + 33 - pos;
1888     if (len > size)
1889     {
1890         size_t i;
1891         char *p = str;
1892
1893         /* Copy the temporary buffer backwards up to the available number of
1894          * characters. Don't copy the negative sign if present. */
1895
1896         if (is_negative)
1897         {
1898             p++;
1899             size--;
1900         }
1901
1902         for (pos = buffer + 31, i = 0; i < size; i++)
1903             *p++ = *pos--;
1904
1905         str[0] = '\0';
1906         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1907         return MSVCRT_ERANGE;
1908     }
1909
1910     memcpy(str, pos, len);
1911     return 0;
1912 }
1913
1914 /*********************************************************************
1915  *  _ltoa_s (MSVCRT.@)
1916  */
1917 int CDECL MSVCRT__ltoa_s(MSVCRT_long value, char *str, MSVCRT_size_t size, int radix)
1918 {
1919     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1920     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1921     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1922     {
1923         str[0] = '\0';
1924         return MSVCRT_EINVAL;
1925     }
1926
1927     return ltoa_helper(value, str, size, radix);
1928 }
1929
1930 /*********************************************************************
1931  *  _ltow_s (MSVCRT.@)
1932  */
1933 int CDECL MSVCRT__ltow_s(MSVCRT_long value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1934 {
1935     MSVCRT_ulong val;
1936     unsigned int digit;
1937     BOOL is_negative;
1938     MSVCRT_wchar_t buffer[33], *pos;
1939     size_t len;
1940
1941     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
1942     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
1943     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1944     {
1945         str[0] = '\0';
1946         return MSVCRT_EINVAL;
1947     }
1948
1949     if (value < 0 && radix == 10)
1950     {
1951         is_negative = TRUE;
1952         val = -value;
1953     }
1954     else
1955     {
1956         is_negative = FALSE;
1957         val = value;
1958     }
1959
1960     pos = buffer + 32;
1961     *pos = '\0';
1962
1963     do
1964     {
1965         digit = val % radix;
1966         val /= radix;
1967
1968         if (digit < 10)
1969             *--pos = '0' + digit;
1970         else
1971             *--pos = 'a' + digit - 10;
1972     }
1973     while (val != 0);
1974
1975     if (is_negative)
1976         *--pos = '-';
1977
1978     len = buffer + 33 - pos;
1979     if (len > size)
1980     {
1981         size_t i;
1982         MSVCRT_wchar_t *p = str;
1983
1984         /* Copy the temporary buffer backwards up to the available number of
1985          * characters. Don't copy the negative sign if present. */
1986
1987         if (is_negative)
1988         {
1989             p++;
1990             size--;
1991         }
1992
1993         for (pos = buffer + 31, i = 0; i < size; i++)
1994             *p++ = *pos--;
1995
1996         str[0] = '\0';
1997         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
1998         return MSVCRT_ERANGE;
1999     }
2000
2001     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
2002     return 0;
2003 }
2004
2005 /*********************************************************************
2006  *  _itoa_s (MSVCRT.@)
2007  */
2008 int CDECL MSVCRT__itoa_s(int value, char *str, MSVCRT_size_t size, int radix)
2009 {
2010     return MSVCRT__ltoa_s(value, str, size, radix);
2011 }
2012
2013 /*********************************************************************
2014  *  _itoa (MSVCRT.@)
2015  */
2016 char* CDECL MSVCRT__itoa(int value, char *str, int radix)
2017 {
2018     return ltoa_helper(value, str, MSVCRT_SIZE_MAX, radix) ? NULL : str;
2019 }
2020
2021 /*********************************************************************
2022  *  _itow_s (MSVCRT.@)
2023  */
2024 int CDECL MSVCRT__itow_s(int value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
2025 {
2026     return MSVCRT__ltow_s(value, str, size, radix);
2027 }
2028
2029 /*********************************************************************
2030  *  _ui64toa_s (MSVCRT.@)
2031  */
2032 int CDECL MSVCRT__ui64toa_s(unsigned __int64 value, char *str,
2033         MSVCRT_size_t size, int radix)
2034 {
2035     char buffer[65], *pos;
2036     int digit;
2037
2038     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
2039     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
2040     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
2041     {
2042         str[0] = '\0';
2043         return MSVCRT_EINVAL;
2044     }
2045
2046     pos = buffer+64;
2047     *pos = '\0';
2048
2049     do {
2050         digit = value%radix;
2051         value /= radix;
2052
2053         if(digit < 10)
2054             *--pos = '0'+digit;
2055         else
2056             *--pos = 'a'+digit-10;
2057     }while(value != 0);
2058
2059     if(buffer-pos+65 > size) {
2060         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
2061         return MSVCRT_EINVAL;
2062     }
2063
2064     memcpy(str, pos, buffer-pos+65);
2065     return 0;
2066 }
2067
2068 /*********************************************************************
2069  *      _ui64tow_s  (MSVCRT.@)
2070  */
2071 int CDECL MSVCRT__ui64tow_s( unsigned __int64 value, MSVCRT_wchar_t *str,
2072                              MSVCRT_size_t size, int radix )
2073 {
2074     MSVCRT_wchar_t buffer[65], *pos;
2075     int digit;
2076
2077     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
2078     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
2079     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
2080     {
2081         str[0] = '\0';
2082         return MSVCRT_EINVAL;
2083     }
2084
2085     pos = &buffer[64];
2086     *pos = '\0';
2087
2088     do {
2089         digit = value % radix;
2090         value = value / radix;
2091         if (digit < 10)
2092             *--pos = '0' + digit;
2093         else
2094             *--pos = 'a' + digit - 10;
2095     } while (value != 0);
2096
2097     if(buffer-pos+65 > size) {
2098         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_EINVAL);
2099         return MSVCRT_EINVAL;
2100     }
2101
2102     memcpy(str, pos, (buffer-pos+65)*sizeof(MSVCRT_wchar_t));
2103     return 0;
2104 }
2105
2106 /*********************************************************************
2107  *  _ultoa_s (MSVCRT.@)
2108  */
2109 int CDECL MSVCRT__ultoa_s(MSVCRT_ulong value, char *str, MSVCRT_size_t size, int radix)
2110 {
2111     MSVCRT_ulong digit;
2112     char buffer[33], *pos;
2113     size_t len;
2114
2115     if (!str || !size || radix < 2 || radix > 36)
2116     {
2117         if (str && size)
2118             str[0] = '\0';
2119
2120         *MSVCRT__errno() = MSVCRT_EINVAL;
2121         return MSVCRT_EINVAL;
2122     }
2123
2124     pos = buffer + 32;
2125     *pos = '\0';
2126
2127     do
2128     {
2129         digit = value % radix;
2130         value /= radix;
2131
2132         if (digit < 10)
2133             *--pos = '0' + digit;
2134         else
2135             *--pos = 'a' + digit - 10;
2136     }
2137     while (value != 0);
2138
2139     len = buffer + 33 - pos;
2140     if (len > size)
2141     {
2142         size_t i;
2143         char *p = str;
2144
2145         /* Copy the temporary buffer backwards up to the available number of
2146          * characters. */
2147
2148         for (pos = buffer + 31, i = 0; i < size; i++)
2149             *p++ = *pos--;
2150
2151         str[0] = '\0';
2152         *MSVCRT__errno() = MSVCRT_ERANGE;
2153         return MSVCRT_ERANGE;
2154     }
2155
2156     memcpy(str, pos, len);
2157     return 0;
2158 }
2159
2160 /*********************************************************************
2161  *  _ultow_s (MSVCRT.@)
2162  */
2163 int CDECL MSVCRT__ultow_s(MSVCRT_ulong value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
2164 {
2165     MSVCRT_ulong digit;
2166     WCHAR buffer[33], *pos;
2167     size_t len;
2168
2169     if (!str || !size || radix < 2 || radix > 36)
2170     {
2171         if (str && size)
2172             str[0] = '\0';
2173
2174         *MSVCRT__errno() = MSVCRT_EINVAL;
2175         return MSVCRT_EINVAL;
2176     }
2177
2178     pos = buffer + 32;
2179     *pos = '\0';
2180
2181     do
2182     {
2183         digit = value % radix;
2184         value /= radix;
2185
2186         if (digit < 10)
2187             *--pos = '0' + digit;
2188         else
2189             *--pos = 'a' + digit - 10;
2190     }
2191     while (value != 0);
2192
2193     len = buffer + 33 - pos;
2194     if (len > size)
2195     {
2196         size_t i;
2197         WCHAR *p = str;
2198
2199         /* Copy the temporary buffer backwards up to the available number of
2200          * characters. */
2201
2202         for (pos = buffer + 31, i = 0; i < size; i++)
2203             *p++ = *pos--;
2204
2205         str[0] = '\0';
2206         *MSVCRT__errno() = MSVCRT_ERANGE;
2207         return MSVCRT_ERANGE;
2208     }
2209
2210     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
2211     return 0;
2212 }
2213
2214 /*********************************************************************
2215  *  _i64toa_s (MSVCRT.@)
2216  */
2217 int CDECL MSVCRT__i64toa_s(__int64 value, char *str, MSVCRT_size_t size, int radix)
2218 {
2219     unsigned __int64 val;
2220     unsigned int digit;
2221     BOOL is_negative;
2222     char buffer[65], *pos;
2223     size_t len;
2224
2225     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
2226     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
2227     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
2228     {
2229         str[0] = '\0';
2230         return MSVCRT_EINVAL;
2231     }
2232
2233     if (value < 0 && radix == 10)
2234     {
2235         is_negative = TRUE;
2236         val = -value;
2237     }
2238     else
2239     {
2240         is_negative = FALSE;
2241         val = value;
2242     }
2243
2244     pos = buffer + 64;
2245     *pos = '\0';
2246
2247     do
2248     {
2249         digit = val % radix;
2250         val /= radix;
2251
2252         if (digit < 10)
2253             *--pos = '0' + digit;
2254         else
2255             *--pos = 'a' + digit - 10;
2256     }
2257     while (val != 0);
2258
2259     if (is_negative)
2260         *--pos = '-';
2261
2262     len = buffer + 65 - pos;
2263     if (len > size)
2264     {
2265         size_t i;
2266         char *p = str;
2267
2268         /* Copy the temporary buffer backwards up to the available number of
2269          * characters. Don't copy the negative sign if present. */
2270
2271         if (is_negative)
2272         {
2273             p++;
2274             size--;
2275         }
2276
2277         for (pos = buffer + 63, i = 0; i < size; i++)
2278             *p++ = *pos--;
2279
2280         str[0] = '\0';
2281         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
2282         return MSVCRT_ERANGE;
2283     }
2284
2285     memcpy(str, pos, len);
2286     return 0;
2287 }
2288
2289 /*********************************************************************
2290  *  _i64tow_s (MSVCRT.@)
2291  */
2292 int CDECL MSVCRT__i64tow_s(__int64 value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
2293 {
2294     unsigned __int64 val;
2295     unsigned int digit;
2296     BOOL is_negative;
2297     MSVCRT_wchar_t buffer[65], *pos;
2298     size_t len;
2299
2300     if (!MSVCRT_CHECK_PMT(str != NULL)) return MSVCRT_EINVAL;
2301     if (!MSVCRT_CHECK_PMT(size > 0)) return MSVCRT_EINVAL;
2302     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
2303     {
2304         str[0] = '\0';
2305         return MSVCRT_EINVAL;
2306     }
2307
2308     if (value < 0 && radix == 10)
2309     {
2310         is_negative = TRUE;
2311         val = -value;
2312     }
2313     else
2314     {
2315         is_negative = FALSE;
2316         val = value;
2317     }
2318
2319     pos = buffer + 64;
2320     *pos = '\0';
2321
2322     do
2323     {
2324         digit = val % radix;
2325         val /= radix;
2326
2327         if (digit < 10)
2328             *--pos = '0' + digit;
2329         else
2330             *--pos = 'a' + digit - 10;
2331     }
2332     while (val != 0);
2333
2334     if (is_negative)
2335         *--pos = '-';
2336
2337     len = buffer + 65 - pos;
2338     if (len > size)
2339     {
2340         size_t i;
2341         MSVCRT_wchar_t *p = str;
2342
2343         /* Copy the temporary buffer backwards up to the available number of
2344          * characters. Don't copy the negative sign if present. */
2345
2346         if (is_negative)
2347         {
2348             p++;
2349             size--;
2350         }
2351
2352         for (pos = buffer + 63, i = 0; i < size; i++)
2353             *p++ = *pos--;
2354
2355         str[0] = '\0';
2356         MSVCRT_INVALID_PMT("str[size] is too small", MSVCRT_ERANGE);
2357         return MSVCRT_ERANGE;
2358     }
2359
2360     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
2361     return 0;
2362 }
2363
2364 #define I10_OUTPUT_MAX_PREC 21
2365 /* Internal structure used by $I10_OUTPUT */
2366 struct _I10_OUTPUT_DATA {
2367     short pos;
2368     char sign;
2369     BYTE len;
2370     char str[I10_OUTPUT_MAX_PREC+1]; /* add space for '\0' */
2371 };
2372
2373 /*********************************************************************
2374  *              $I10_OUTPUT (MSVCRT.@)
2375  * ld80 - long double (Intel 80 bit FP in 12 bytes) to be printed to data
2376  * prec - precision of part, we're interested in
2377  * flag - 0 for first prec digits, 1 for fractional part
2378  * data - data to be populated
2379  *
2380  * return value
2381  *      0 if given double is NaN or INF
2382  *      1 otherwise
2383  *
2384  * FIXME
2385  *      Native sets last byte of data->str to '0' or '9', I don't know what
2386  *      it means. Current implementation sets it always to '0'.
2387  */
2388 int CDECL MSVCRT_I10_OUTPUT(MSVCRT__LDOUBLE ld80, int prec, int flag, struct _I10_OUTPUT_DATA *data)
2389 {
2390     struct fpnum num;
2391     double d;
2392     char format[8];
2393     char buf[I10_OUTPUT_MAX_PREC+9]; /* 9 = strlen("0.e+0000") + '\0' */
2394     char *p;
2395
2396     if ((ld80.x80[2] & 0x7fff) == 0x7fff)
2397     {
2398         if (ld80.x80[0] == 0 && ld80.x80[1] == 0x80000000)
2399             strcpy( data->str, "1#INF" );
2400         else
2401             strcpy( data->str, (ld80.x80[1] & 0x40000000) ? "1#QNAN" : "1#SNAN" );
2402         data->pos = 1;
2403         data->sign = (ld80.x80[2] & 0x8000) ? '-' : ' ';
2404         data->len = strlen(data->str);
2405         return 0;
2406     }
2407
2408     num.sign = (ld80.x80[2] & 0x8000) ? -1 : 1;
2409     num.exp  = (ld80.x80[2] & 0x7fff) - 0x3fff - 63;
2410     num.m    = ld80.x80[0] | ((ULONGLONG)ld80.x80[1] << 32);
2411     num.mod  = FP_ROUND_EVEN;
2412     fpnum_double( &num, &d );
2413     TRACE("(%lf %d %x %p)\n", d, prec, flag, data);
2414
2415     if(d<0) {
2416         data->sign = '-';
2417         d = -d;
2418     } else
2419         data->sign = ' ';
2420
2421     if(flag&1) {
2422         int exp = 1 + MSVCRT_floor(MSVCRT_log10(d));
2423
2424         prec += exp;
2425         if(exp < 0)
2426             prec--;
2427     }
2428     prec--;
2429
2430     if(prec+1 > I10_OUTPUT_MAX_PREC)
2431         prec = I10_OUTPUT_MAX_PREC-1;
2432     else if(prec < 0) {
2433         d = 0.0;
2434         prec = 0;
2435     }
2436
2437     MSVCRT_sprintf(format, "%%.%dle", prec);
2438     MSVCRT_sprintf(buf, format, d);
2439
2440     buf[1] = buf[0];
2441     data->pos = MSVCRT_atoi(buf+prec+3);
2442     if(buf[1] != '0')
2443         data->pos++;
2444
2445     for(p = buf+prec+1; p>buf+1 && *p=='0'; p--);
2446     data->len = p-buf;
2447
2448     memcpy(data->str, buf+1, data->len);
2449     data->str[data->len] = '\0';
2450
2451     if(buf[1]!='0' && prec-data->len+1>0)
2452         memcpy(data->str+data->len+1, buf+data->len+1, prec-data->len+1);
2453
2454     return 1;
2455 }
2456 #undef I10_OUTPUT_MAX_PREC
2457
2458 /*********************************************************************
2459  *                  memcmp (MSVCRT.@)
2460  */
2461 int __cdecl memcmp(const void *ptr1, const void *ptr2, size_t n)
2462 {
2463     const unsigned char *p1, *p2;
2464
2465     for (p1 = ptr1, p2 = ptr2; n; n--, p1++, p2++)
2466     {
2467         if (*p1 < *p2) return -1;
2468         if (*p1 > *p2) return 1;
2469     }
2470     return 0;
2471 }
2472
2473 /*********************************************************************
2474  *                  memmove (MSVCRT.@)
2475  */
2476 #ifdef WORDS_BIGENDIAN
2477 # define MERGE(w1, sh1, w2, sh2) ((w1 << sh1) | (w2 >> sh2))
2478 #else
2479 # define MERGE(w1, sh1, w2, sh2) ((w1 >> sh1) | (w2 << sh2))
2480 #endif
2481 void * __cdecl memmove(void *dst, const void *src, size_t n)
2482 {
2483     unsigned char *d = dst;
2484     const unsigned char *s = src;
2485     int sh1;
2486
2487     if (!n) return dst;
2488
2489     if ((MSVCRT_size_t)dst - (MSVCRT_size_t)src >= n)
2490     {
2491         for (; (MSVCRT_size_t)d % sizeof(MSVCRT_size_t) && n; n--) *d++ = *s++;
2492
2493         sh1 = 8 * ((MSVCRT_size_t)s % sizeof(MSVCRT_size_t));
2494         if (!sh1)
2495         {
2496             while (n >= sizeof(MSVCRT_size_t))
2497             {
2498                 *(MSVCRT_size_t*)d = *(MSVCRT_size_t*)s;
2499                 s += sizeof(MSVCRT_size_t);
2500                 d += sizeof(MSVCRT_size_t);
2501                 n -= sizeof(MSVCRT_size_t);
2502             }
2503         }
2504         else if (n >= 2 * sizeof(MSVCRT_size_t))
2505         {
2506             int sh2 = 8 * sizeof(MSVCRT_size_t) - sh1;
2507             MSVCRT_size_t x, y;
2508
2509             s -= sh1 / 8;
2510             x = *(MSVCRT_size_t*)s;
2511             do
2512             {
2513                 s += sizeof(MSVCRT_size_t);
2514                 y = *(MSVCRT_size_t*)s;
2515                 *(MSVCRT_size_t*)d = MERGE(x, sh1, y, sh2);
2516                 d += sizeof(MSVCRT_size_t);
2517
2518                 s += sizeof(MSVCRT_size_t);
2519                 x = *(MSVCRT_size_t*)s;
2520                 *(MSVCRT_size_t*)d = MERGE(y, sh1, x, sh2);
2521                 d += sizeof(MSVCRT_size_t);
2522
2523                 n -= 2 * sizeof(MSVCRT_size_t);
2524             } while (n >= 2 * sizeof(MSVCRT_size_t));
2525             s += sh1 / 8;
2526         }
2527         while (n--) *d++ = *s++;
2528         return dst;
2529     }
2530     else
2531     {
2532         d += n;
2533         s += n;
2534
2535         for (; (MSVCRT_size_t)d % sizeof(MSVCRT_size_t) && n; n--) *--d = *--s;
2536
2537         sh1 = 8 * ((MSVCRT_size_t)s % sizeof(MSVCRT_size_t));
2538         if (!sh1)
2539         {
2540             while (n >= sizeof(MSVCRT_size_t))
2541             {
2542                 s -= sizeof(MSVCRT_size_t);
2543                 d -= sizeof(MSVCRT_size_t);
2544                 *(MSVCRT_size_t*)d = *(MSVCRT_size_t*)s;
2545                 n -= sizeof(MSVCRT_size_t);
2546             }
2547         }
2548         else if (n >= 2 * sizeof(MSVCRT_size_t))
2549         {
2550             int sh2 = 8 * sizeof(MSVCRT_size_t) - sh1;
2551             MSVCRT_size_t x, y;
2552
2553             s -= sh1 / 8;
2554             x = *(MSVCRT_size_t*)s;
2555             do
2556             {
2557                 s -= sizeof(MSVCRT_size_t);
2558                 y = *(MSVCRT_size_t*)s;
2559                 d -= sizeof(MSVCRT_size_t);
2560                 *(MSVCRT_size_t*)d = MERGE(y, sh1, x, sh2);
2561
2562                 s -= sizeof(MSVCRT_size_t);
2563                 x = *(MSVCRT_size_t*)s;
2564                 d -= sizeof(MSVCRT_size_t);
2565                 *(MSVCRT_size_t*)d = MERGE(x, sh1, y, sh2);
2566
2567                 n -= 2 * sizeof(MSVCRT_size_t);
2568             } while (n >= 2 * sizeof(MSVCRT_size_t));
2569             s += sh1 / 8;
2570         }
2571         while (n--) *--d = *--s;
2572     }
2573     return dst;
2574 }
2575 #undef MERGE
2576
2577 /*********************************************************************
2578  *                  memcpy   (MSVCRT.@)
2579  */
2580 void * __cdecl memcpy(void *dst, const void *src, size_t n)
2581 {
2582     return memmove(dst, src, n);
2583 }
2584
2585 /*********************************************************************
2586  *                  memset (MSVCRT.@)
2587  */
2588 void* __cdecl memset(void *dst, int c, size_t n)
2589 {
2590     volatile unsigned char *d = dst;  /* avoid gcc optimizations */
2591     while (n--) *d++ = c;
2592     return dst;
2593 }
2594
2595 /*********************************************************************
2596  *                  strchr (MSVCRT.@)
2597  */
2598 char* __cdecl strchr(const char *str, int c)
2599 {
2600     do
2601     {
2602         if (*str == (char)c) return (char*)str;
2603     } while (*str++);
2604     return NULL;
2605 }
2606
2607 /*********************************************************************
2608  *                  strrchr (MSVCRT.@)
2609  */
2610 char* __cdecl MSVCRT_strrchr(const char *str, int c)
2611 {
2612     char *ret = NULL;
2613     do { if (*str == (char)c) ret = (char*)str; } while (*str++);
2614     return ret;
2615 }
2616
2617 /*********************************************************************
2618  *                  memchr   (MSVCRT.@)
2619  */
2620 void* __cdecl MSVCRT_memchr(const void *ptr, int c, MSVCRT_size_t n)
2621 {
2622     const unsigned char *p = ptr;
2623
2624     for (p = ptr; n; n--, p++) if (*p == c) return (void *)(ULONG_PTR)p;
2625     return NULL;
2626 }
2627
2628 /*********************************************************************
2629  *                  strcmp (MSVCRT.@)
2630  */
2631 int __cdecl strcmp(const char *str1, const char *str2)
2632 {
2633     while (*str1 && *str1 == *str2) { str1++; str2++; }
2634     if ((unsigned char)*str1 > (unsigned char)*str2) return 1;
2635     if ((unsigned char)*str1 < (unsigned char)*str2) return -1;
2636     return 0;
2637 }
2638
2639 /*********************************************************************
2640  *                  strncmp   (MSVCRT.@)
2641  */
2642 int __cdecl MSVCRT_strncmp(const char *str1, const char *str2, MSVCRT_size_t len)
2643 {
2644     if (!len) return 0;
2645     while (--len && *str1 && *str1 == *str2) { str1++; str2++; }
2646     return (unsigned char)*str1 - (unsigned char)*str2;
2647 }
2648
2649 /*********************************************************************
2650  *                  _strnicmp_l   (MSVCRT.@)
2651  */
2652 int __cdecl MSVCRT__strnicmp_l(const char *s1, const char *s2,
2653         MSVCRT_size_t count, MSVCRT__locale_t locale)
2654 {
2655     MSVCRT_pthreadlocinfo locinfo;
2656     int c1, c2;
2657
2658     if(s1==NULL || s2==NULL)
2659         return MSVCRT__NLSCMPERROR;
2660
2661     if(!count)
2662         return 0;
2663
2664     if(!locale)
2665         locinfo = get_locinfo();
2666     else
2667         locinfo = locale->locinfo;
2668
2669     if(!locinfo->lc_handle[MSVCRT_LC_CTYPE])
2670     {
2671         do {
2672             if ((c1 = *s1++) >= 'A' && c1 <= 'Z')
2673                 c1 -= 'A' - 'a';
2674             if ((c2 = *s2++) >= 'A' && c2 <= 'Z')
2675                 c2 -= 'A' - 'a';
2676         }while(--count && c1 && c1==c2);
2677
2678         return c1-c2;
2679     }
2680
2681     do {
2682         c1 = MSVCRT__tolower_l((unsigned char)*s1++, locale);
2683         c2 = MSVCRT__tolower_l((unsigned char)*s2++, locale);
2684     }while(--count && c1 && c1==c2);
2685
2686     return c1-c2;
2687 }
2688
2689 /*********************************************************************
2690  *                  _stricmp_l   (MSVCRT.@)
2691  */
2692 int __cdecl MSVCRT__stricmp_l(const char *s1, const char *s2, MSVCRT__locale_t locale)
2693 {
2694     return MSVCRT__strnicmp_l(s1, s2, -1, locale);
2695 }
2696
2697 /*********************************************************************
2698  *                  _strnicmp   (MSVCRT.@)
2699  */
2700 int __cdecl MSVCRT__strnicmp(const char *s1, const char *s2, MSVCRT_size_t count)
2701 {
2702     return MSVCRT__strnicmp_l(s1, s2, count, NULL);
2703 }
2704
2705 /*********************************************************************
2706  *                  _stricmp   (MSVCRT.@)
2707  */
2708 int __cdecl MSVCRT__stricmp(const char *s1, const char *s2)
2709 {
2710     return MSVCRT__strnicmp_l(s1, s2, -1, NULL);
2711 }
2712
2713 /*********************************************************************
2714  *                  strstr   (MSVCRT.@)
2715  */
2716 char* __cdecl MSVCRT_strstr(const char *haystack, const char *needle)
2717 {
2718     MSVCRT_size_t i, j, len, needle_len, lps_len;
2719     BYTE lps[256];
2720
2721     needle_len = strlen(needle);
2722     if (!needle_len) return (char*)haystack;
2723     lps_len = needle_len > ARRAY_SIZE(lps) ? ARRAY_SIZE(lps) : needle_len;
2724
2725     lps[0] = 0;
2726     len = 0;
2727     i = 1;
2728     while (i < lps_len)
2729     {
2730         if (needle[i] == needle[len]) lps[i++] = ++len;
2731         else if (len) len = lps[len-1];
2732         else lps[i++] = 0;
2733     }
2734
2735     i = j = 0;
2736     while (haystack[i])
2737     {
2738         while (j < lps_len && haystack[i] && haystack[i] == needle[j])
2739         {
2740             i++;
2741             j++;
2742         }
2743
2744         if (j == needle_len) return (char*)haystack + i - j;
2745         else if (j)
2746         {
2747             if (j == ARRAY_SIZE(lps) && !MSVCRT_strncmp(haystack + i, needle + j, needle_len - j))
2748                 return (char*)haystack + i - j;
2749             j = lps[j-1];
2750         }
2751         else if (haystack[i]) i++;
2752     }
2753     return NULL;
2754 }
2755
2756 /*********************************************************************
2757  *                  _memicmp_l   (MSVCRT.@)
2758  */
2759 int __cdecl MSVCRT__memicmp_l(const char *s1, const char *s2, MSVCRT_size_t len, MSVCRT__locale_t locale)
2760 {
2761     int ret = 0;
2762
2763 #if _MSVCR_VER == 0 || _MSVCR_VER >= 80
2764     if (!s1 || !s2)
2765     {
2766         if (len)
2767             MSVCRT_INVALID_PMT(NULL, EINVAL);
2768         return len ? MSVCRT__NLSCMPERROR : 0;
2769     }
2770 #endif
2771
2772     while (len--)
2773     {
2774         if ((ret = MSVCRT__tolower_l(*s1, locale) - MSVCRT__tolower_l(*s2, locale)))
2775             break;
2776         s1++;
2777         s2++;
2778     }
2779     return ret;
2780 }
2781
2782 /*********************************************************************
2783  *                  _memicmp   (MSVCRT.@)
2784  */
2785 int __cdecl MSVCRT__memicmp(const char *s1, const char *s2, MSVCRT_size_t len)
2786 {
2787     return MSVCRT__memicmp_l(s1, s2, len, NULL);
2788 }
2789
2790 /*********************************************************************
2791  *                  strcspn   (MSVCRT.@)
2792  */
2793 MSVCRT_size_t __cdecl MSVCRT_strcspn(const char *str, const char *reject)
2794 {
2795     BOOL rejects[256];
2796     const char *p;
2797
2798     memset(rejects, 0, sizeof(rejects));
2799
2800     p = reject;
2801     while(*p)
2802     {
2803         rejects[(unsigned char)*p] = TRUE;
2804         p++;
2805     }
2806
2807     p = str;
2808     while(*p && !rejects[(unsigned char)*p]) p++;
2809     return p - str;
2810 }
2811
2812 /*********************************************************************
2813  *                  strpbrk   (MSVCRT.@)
2814  */
2815 char* __cdecl MSVCRT_strpbrk(const char *str, const char *accept)
2816 {
2817     for (; *str; str++) if (strchr( accept, *str )) return (char*)str;
2818     return NULL;
2819 }
2820
2821 /*********************************************************************
2822  *                  __strncnt   (MSVCRT.@)
2823  */
2824 MSVCRT_size_t __cdecl MSVCRT___strncnt(const char *str, MSVCRT_size_t size)
2825 {
2826     MSVCRT_size_t ret = 0;
2827
2828 #if _MSVCR_VER >= 140
2829     while (*str++ && size--)
2830 #else
2831     while (size-- && *str++)
2832 #endif
2833     {
2834         ret++;
2835     }
2836
2837     return ret;
2838 }
2839
2840
2841 #ifdef _CRTDLL
2842 /*********************************************************************
2843  *              _strdec (CRTDLL.@)
2844  */
2845 char * CDECL _strdec(const char *str1, const char *str2)
2846 {
2847     return (char *)(str2 - 1);
2848 }
2849
2850 /*********************************************************************
2851  *              _strinc (CRTDLL.@)
2852  */
2853 char * CDECL _strinc(const char *str)
2854 {
2855     return (char *)(str + 1);
2856 }
2857
2858 /*********************************************************************
2859  *              _strnextc (CRTDLL.@)
2860  */
2861 unsigned int CDECL _strnextc(const char *str)
2862 {
2863     return (unsigned char)str[0];
2864 }
2865
2866 /*********************************************************************
2867  *              _strninc (CRTDLL.@)
2868  */
2869 char * CDECL _strninc(const char *str, size_t len)
2870 {
2871     return (char *)(str + len);
2872 }
2873
2874 /*********************************************************************
2875  *              _strspnp (CRTDLL.@)
2876  */
2877 char * CDECL _strspnp( const char *str1, const char *str2)
2878 {
2879     str1 += strspn( str1, str2 );
2880     return *str1 ? (char*)str1 : NULL;
2881 }
2882 #endif