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