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 %#I64x *2^%d (round %d)\n", fp->sign == -1 ? '-' : '+',
 381             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 %#I64x\n", 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 %#I64x *2^%d (round %d)\n", fp->sign == -1 ? '-' : '+',
 500             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     double ret = _strtod_l(str, end, locale);
1069     if (ret && isfinite(ret)) {
1070         float f = ret;
1071         if (!f || !isfinite(f))
1072             *_errno() = ERANGE;
1073     }
1074     return ret;
1075 }
1076
1077 /*********************************************************************
1078  *              strtof  (MSVCR120.@)
1079  */
1080 float CDECL strtof( const char *str, char **end )
1081 {
1082     return _strtof_l(str, end, NULL);
1083 }
1084
1085 #endif /* _MSVCR_VER>=120 */
1086
1087 /*********************************************************************
1088  *              atof  (MSVCRT.@)
1089  */
1090 double CDECL atof( const char *str )
1091 {
1092     return _strtod_l(str, NULL, NULL);
1093 }
1094
1095 /*********************************************************************
1096  *              _atof_l  (MSVCRT.@)
1097  */
1098 double CDECL _atof_l( const char *str, _locale_t locale)
1099 {
1100     return _strtod_l(str, NULL, locale);
1101 }
1102
1103 /*********************************************************************
1104  *              _atoflt_l  (MSVCRT.@)
1105  */
1106 int CDECL _atoflt_l(_CRT_FLOAT *value, char *str, _locale_t locale)
1107 {
1108     double d;
1109     int err;
1110
1111     d = strtod_helper(str, NULL, locale, &err);
1112     value->f = d;
1113     if(isinf(value->f))
1114         return _OVERFLOW;
1115     if((d!=0 || err) && value->f>-FLT_MIN && value->f<FLT_MIN)
1116         return _UNDERFLOW;
1117     return 0;
1118 }
1119
1120 /*********************************************************************
1121  * _atoflt  (MSVCR100.@)
1122  */
1123 int CDECL _atoflt(_CRT_FLOAT *value, char *str)
1124 {
1125     return _atoflt_l(value, str, NULL);
1126 }
1127
1128 /*********************************************************************
1129  *              _atodbl_l  (MSVCRT.@)
1130  */
1131 int CDECL _atodbl_l(_CRT_DOUBLE *value, char *str, _locale_t locale)
1132 {
1133     int err;
1134
1135     value->x = strtod_helper(str, NULL, locale, &err);
1136     if(isinf(value->x))
1137         return _OVERFLOW;
1138     if((value->x!=0 || err) && value->x>-DBL_MIN && value->x<DBL_MIN)
1139         return _UNDERFLOW;
1140     return 0;
1141 }
1142
1143 /*********************************************************************
1144  *              _atodbl  (MSVCRT.@)
1145  */
1146 int CDECL _atodbl(_CRT_DOUBLE *value, char *str)
1147 {
1148     return _atodbl_l(value, str, NULL);
1149 }
1150
1151 /*********************************************************************
1152  *              _strcoll_l (MSVCRT.@)
1153  */
1154 int CDECL _strcoll_l( const char* str1, const char* str2, _locale_t locale )
1155 {
1156     pthreadlocinfo locinfo;
1157
1158     if(!locale)
1159         locinfo = get_locinfo();
1160     else
1161         locinfo = locale->locinfo;
1162
1163     if(!locinfo->lc_handle[LC_COLLATE])
1164         return strcmp(str1, str2);
1165     return CompareStringA(locinfo->lc_handle[LC_COLLATE], 0, str1, -1, str2, -1)-CSTR_EQUAL;
1166 }
1167
1168 /*********************************************************************
1169  *              strcoll (MSVCRT.@)
1170  */
1171 int CDECL strcoll( const char* str1, const char* str2 )
1172 {
1173     return _strcoll_l(str1, str2, NULL);
1174 }
1175
1176 /*********************************************************************
1177  *              _stricoll_l (MSVCRT.@)
1178  */
1179 int CDECL _stricoll_l( const char* str1, const char* str2, _locale_t locale )
1180 {
1181     pthreadlocinfo locinfo;
1182
1183     if(!locale)
1184         locinfo = get_locinfo();
1185     else
1186         locinfo = locale->locinfo;
1187
1188     if(!locinfo->lc_handle[LC_COLLATE])
1189         return _stricmp(str1, str2);
1190     return CompareStringA(locinfo->lc_handle[LC_COLLATE], NORM_IGNORECASE,
1191             str1, -1, str2, -1)-CSTR_EQUAL;
1192 }
1193
1194 /*********************************************************************
1195  *              _stricoll (MSVCRT.@)
1196  */
1197 int CDECL _stricoll( const char* str1, const char* str2 )
1198 {
1199     return _stricoll_l(str1, str2, NULL);
1200 }
1201
1202 /*********************************************************************
1203  *              _strncoll_l (MSVCRT.@)
1204  */
1205 int CDECL _strncoll_l( const char* str1, const char* str2, size_t count, _locale_t locale )
1206 {
1207     pthreadlocinfo locinfo;
1208
1209     if(!locale)
1210         locinfo = get_locinfo();
1211     else
1212         locinfo = locale->locinfo;
1213
1214     if(!locinfo->lc_handle[LC_COLLATE])
1215         return strncmp(str1, str2, count);
1216     return CompareStringA(locinfo->lc_handle[LC_COLLATE], 0,
1217               str1, strnlen(str1, count),
1218               str2, strnlen(str2, count))-CSTR_EQUAL;
1219 }
1220
1221 /*********************************************************************
1222  *              _strncoll (MSVCRT.@)
1223  */
1224 int CDECL _strncoll( const char* str1, const char* str2, size_t count )
1225 {
1226     return _strncoll_l(str1, str2, count, NULL);
1227 }
1228
1229 /*********************************************************************
1230  *              _strnicoll_l (MSVCRT.@)
1231  */
1232 int CDECL _strnicoll_l( const char* str1, const char* str2, size_t count, _locale_t locale )
1233 {
1234     pthreadlocinfo locinfo;
1235
1236     if(!locale)
1237         locinfo = get_locinfo();
1238     else
1239         locinfo = locale->locinfo;
1240
1241     if(!locinfo->lc_handle[LC_COLLATE])
1242         return _strnicmp(str1, str2, count);
1243     return CompareStringA(locinfo->lc_handle[LC_COLLATE], NORM_IGNORECASE,
1244             str1, strnlen(str1, count),
1245             str2, strnlen(str2, count))-CSTR_EQUAL;
1246 }
1247
1248 /*********************************************************************
1249  *              _strnicoll (MSVCRT.@)
1250  */
1251 int CDECL _strnicoll( const char* str1, const char* str2, size_t count )
1252 {
1253     return _strnicoll_l(str1, str2, count, NULL);
1254 }
1255
1256 /*********************************************************************
1257  *                  strncpy (MSVCRT.@)
1258  */
1259 char* __cdecl strncpy(char *dst, const char *src, size_t len)
1260 {
1261     size_t i;
1262
1263     for(i=0; i<len; i++)
1264         if((dst[i] = src[i]) == '\0') break;
1265
1266     while (i < len) dst[i++] = 0;
1267
1268     return dst;
1269 }
1270
1271 /*********************************************************************
1272  *      strcpy (MSVCRT.@)
1273  */
1274 char* CDECL strcpy(char *dst, const char *src)
1275 {
1276     char *ret = dst;
1277     while ((*dst++ = *src++));
1278     return ret;
1279 }
1280
1281 /*********************************************************************
1282  *      strcpy_s (MSVCRT.@)
1283  */
1284 int CDECL strcpy_s( char* dst, size_t elem, const char* src )
1285 {
1286     size_t i;
1287     if(!elem) return EINVAL;
1288     if(!dst) return EINVAL;
1289     if(!src)
1290     {
1291         dst[0] = '\0';
1292         return EINVAL;
1293     }
1294
1295     for(i = 0; i < elem; i++)
1296     {
1297         if((dst[i] = src[i]) == '\0') return 0;
1298     }
1299     dst[0] = '\0';
1300     return ERANGE;
1301 }
1302
1303 /*********************************************************************
1304  *      strcat_s (MSVCRT.@)
1305  */
1306 int CDECL strcat_s( char* dst, size_t elem, const char* src )
1307 {
1308     size_t i, j;
1309     if(!dst) return EINVAL;
1310     if(elem == 0) return EINVAL;
1311     if(!src)
1312     {
1313         dst[0] = '\0';
1314         return EINVAL;
1315     }
1316
1317     for(i = 0; i < elem; i++)
1318     {
1319         if(dst[i] == '\0')
1320         {
1321             for(j = 0; (j + i) < elem; j++)
1322             {
1323                 if((dst[j + i] = src[j]) == '\0') return 0;
1324             }
1325         }
1326     }
1327     /* Set the first element to 0, not the first element after the skipped part */
1328     dst[0] = '\0';
1329     return ERANGE;
1330 }
1331
1332 /*********************************************************************
1333  *      strcat (MSVCRT.@)
1334  */
1335 char* __cdecl strcat( char *dst, const char *src )
1336 {
1337     char *d = dst;
1338     while (*d) d++;
1339     while ((*d++ = *src++));
1340     return dst;
1341 }
1342
1343 /*********************************************************************
1344  *      strncat_s (MSVCRT.@)
1345  */
1346 int CDECL strncat_s( char* dst, size_t elem, const char* src, size_t count )
1347 {
1348     size_t i, j;
1349
1350     if (!MSVCRT_CHECK_PMT(dst != 0)) return EINVAL;
1351     if (!MSVCRT_CHECK_PMT(elem != 0)) return EINVAL;
1352     if (!MSVCRT_CHECK_PMT(src != 0))
1353     {
1354         dst[0] = '\0';
1355         return EINVAL;
1356     }
1357
1358     for(i = 0; i < elem; i++)
1359     {
1360         if(dst[i] == '\0')
1361         {
1362             for(j = 0; (j + i) < elem; j++)
1363             {
1364                 if(count == _TRUNCATE && j + i == elem - 1)
1365                 {
1366                     dst[j + i] = '\0';
1367                     return STRUNCATE;
1368                 }
1369                 if(j == count || (dst[j + i] = src[j]) == '\0')
1370                 {
1371                     dst[j + i] = '\0';
1372                     return 0;
1373                 }
1374             }
1375         }
1376     }
1377     /* Set the first element to 0, not the first element after the skipped part */
1378     dst[0] = '\0';
1379     return ERANGE;
1380 }
1381
1382 /*********************************************************************
1383  *      strncat (MSVCRT.@)
1384  */
1385 char* __cdecl strncat(char *dst, const char *src, size_t len)
1386 {
1387     char *d = dst;
1388     while (*d) d++;
1389     for ( ; len && *src; d++, src++, len--) *d = *src;
1390     *d = 0;
1391     return dst;
1392 }
1393
1394 /*********************************************************************
1395  *              _strxfrm_l (MSVCRT.@)
1396  */
1397 size_t CDECL _strxfrm_l( char *dest, const char *src,
1398         size_t len, _locale_t locale )
1399 {
1400     pthreadlocinfo locinfo;
1401     int ret;
1402
1403     if(!MSVCRT_CHECK_PMT(src)) return INT_MAX;
1404     if(!MSVCRT_CHECK_PMT(dest || !len)) return INT_MAX;
1405
1406     if(len > INT_MAX) {
1407         FIXME("len > INT_MAX not supported\n");
1408         len = INT_MAX;
1409     }
1410
1411     if(!locale)
1412         locinfo = get_locinfo();
1413     else
1414         locinfo = locale->locinfo;
1415
1416     if(!locinfo->lc_handle[LC_COLLATE]) {
1417         strncpy(dest, src, len);
1418         return strlen(src);
1419     }
1420
1421     ret = LCMapStringA(locinfo->lc_handle[LC_COLLATE],
1422             LCMAP_SORTKEY, src, -1, NULL, 0);
1423     if(!ret) {
1424         if(len) dest[0] = 0;
1425         *_errno() = EILSEQ;
1426         return INT_MAX;
1427     }
1428     if(!len) return ret-1;
1429
1430     if(ret > len) {
1431         dest[0] = 0;
1432         *_errno() = ERANGE;
1433         return ret-1;
1434     }
1435
1436     return LCMapStringA(locinfo->lc_handle[LC_COLLATE],
1437             LCMAP_SORTKEY, src, -1, dest, len) - 1;
1438 }
1439
1440 /*********************************************************************
1441  *              strxfrm (MSVCRT.@)
1442  */
1443 size_t CDECL strxfrm( char *dest, const char *src, size_t len )
1444 {
1445     return _strxfrm_l(dest, src, len, NULL);
1446 }
1447
1448 /********************************************************************
1449  *              __STRINGTOLD_L (MSVCR80.@)
1450  */
1451 int CDECL __STRINGTOLD_L( MSVCRT__LDOUBLE *value, char **endptr,
1452         const char *str, int flags, _locale_t locale )
1453 {
1454     pthreadlocinfo locinfo;
1455     const char *beg, *p;
1456     int err, ret = 0;
1457     struct fpnum fp;
1458
1459     if (flags) FIXME("flags not supported: %x\n", flags);
1460
1461     if (!locale)
1462         locinfo = get_locinfo();
1463     else
1464         locinfo = locale->locinfo;
1465
1466     p = str;
1467     while (_isspace_l((unsigned char)*p, locale))
1468         p++;
1469     beg = p;
1470
1471     fp = fpnum_parse(strtod_str_get, strtod_str_unget, &p, locinfo, TRUE);
1472     if (endptr) *endptr = (p == beg ? (char*)str : (char*)p);
1473     if (p == beg) ret = 4;
1474
1475     err = fpnum_ldouble(&fp, value);
1476     if (err) ret = (value->x80[2] & 0x7fff ? 2 : 1);
1477     return ret;
1478 }
1479
1480 /********************************************************************
1481  *              __STRINGTOLD (MSVCRT.@)
1482  */
1483 int CDECL __STRINGTOLD( MSVCRT__LDOUBLE *value, char **endptr, const char *str, int flags )
1484 {
1485     return __STRINGTOLD_L( value, endptr, str, flags, NULL );
1486 }
1487
1488 /********************************************************************
1489  *              _atoldbl_l (MSVCRT.@)
1490  */
1491 int CDECL _atoldbl_l( MSVCRT__LDOUBLE *value, char *str, _locale_t locale )
1492 {
1493     char *endptr;
1494     switch(__STRINGTOLD_L( value, &endptr, str, 0, locale ))
1495     {
1496     case 1: return _UNDERFLOW;
1497     case 2: return _OVERFLOW;
1498     default: return 0;
1499     }
1500 }
1501
1502 /********************************************************************
1503  *              _atoldbl (MSVCRT.@)
1504  */
1505 int CDECL _atoldbl(_LDOUBLE *value, char *str)
1506 {
1507     return _atoldbl_l( (MSVCRT__LDOUBLE*)value, str, NULL );
1508 }
1509
1510 /*********************************************************************
1511  *              strlen (MSVCRT.@)
1512  */
1513 size_t __cdecl strlen(const char *str)
1514 {
1515     const char *s = str;
1516     while (*s) s++;
1517     return s - str;
1518 }
1519
1520 /******************************************************************
1521  *              strnlen (MSVCRT.@)
1522  */
1523 size_t CDECL strnlen(const char *s, size_t maxlen)
1524 {
1525     size_t i;
1526
1527     for(i=0; i<maxlen; i++)
1528         if(!s[i]) break;
1529
1530     return i;
1531 }
1532
1533 /*********************************************************************
1534  *  _strtoi64_l (MSVCRT.@)
1535  *
1536  * FIXME: locale parameter is ignored
1537  */
1538 __int64 CDECL _strtoi64_l(const char *nptr, char **endptr, int base, _locale_t locale)
1539 {
1540     const char *p = nptr;
1541     BOOL negative = FALSE;
1542     BOOL got_digit = FALSE;
1543     __int64 ret = 0;
1544
1545     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
1546
1547     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
1548     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
1549     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
1550
1551     while(_isspace_l((unsigned char)*nptr, locale)) nptr++;
1552
1553     if(*nptr == '-') {
1554         negative = TRUE;
1555         nptr++;
1556     } else if(*nptr == '+')
1557         nptr++;
1558
1559     if((base==0 || base==16) && *nptr=='0' && _tolower_l(*(nptr+1), locale)=='x') {
1560         base = 16;
1561         nptr += 2;
1562     }
1563
1564     if(base == 0) {
1565         if(*nptr=='0')
1566             base = 8;
1567         else
1568             base = 10;
1569     }
1570
1571     while(*nptr) {
1572         char cur = _tolower_l(*nptr, locale);
1573         int v;
1574
1575         if(cur>='0' && cur<='9') {
1576             if(cur >= '0'+base)
1577                 break;
1578             v = cur-'0';
1579         } else {
1580             if(cur<'a' || cur>='a'+base-10)
1581                 break;
1582             v = cur-'a'+10;
1583         }
1584         got_digit = TRUE;
1585
1586         if(negative)
1587             v = -v;
1588
1589         nptr++;
1590
1591         if(!negative && (ret>I64_MAX/base || ret*base>I64_MAX-v)) {
1592             ret = I64_MAX;
1593             *_errno() = ERANGE;
1594         } else if(negative && (ret<I64_MIN/base || ret*base<I64_MIN-v)) {
1595             ret = I64_MIN;
1596             *_errno() = ERANGE;
1597         } else
1598             ret = ret*base + v;
1599     }
1600
1601     if(endptr)
1602         *endptr = (char*)(got_digit ? nptr : p);
1603
1604     return ret;
1605 }
1606
1607 /*********************************************************************
1608  *  _strtoi64 (MSVCRT.@)
1609  */
1610 __int64 CDECL _strtoi64(const char *nptr, char **endptr, int base)
1611 {
1612     return _strtoi64_l(nptr, endptr, base, NULL);
1613 }
1614
1615 /*********************************************************************
1616  *  _atoi_l (MSVCRT.@)
1617  */
1618 int __cdecl _atoi_l(const char *str, _locale_t locale)
1619 {
1620     __int64 ret = _strtoi64_l(str, NULL, 10, locale);
1621
1622     if(ret > INT_MAX) {
1623         ret = INT_MAX;
1624         *_errno() = ERANGE;
1625     } else if(ret < INT_MIN) {
1626         ret = INT_MIN;
1627         *_errno() = ERANGE;
1628     }
1629     return ret;
1630 }
1631
1632 /*********************************************************************
1633  *  atoi (MSVCRT.@)
1634  */
1635 #if _MSVCR_VER == 0
1636 int __cdecl atoi(const char *str)
1637 {
1638     BOOL minus = FALSE;
1639     int ret = 0;
1640
1641     if(!str)
1642         return 0;
1643
1644     while(_isspace_l((unsigned char)*str, NULL)) str++;
1645
1646     if(*str == '+') {
1647         str++;
1648     }else if(*str == '-') {
1649         minus = TRUE;
1650         str++;
1651     }
1652
1653     while(*str>='0' && *str<='9') {
1654         ret = ret*10+*str-'0';
1655         str++;
1656     }
1657
1658     return minus ? -ret : ret;
1659 }
1660 #else
1661 int CDECL atoi(const char *str)
1662 {
1663     return _atoi_l(str, NULL);
1664 }
1665 #endif
1666
1667 /******************************************************************
1668  *      _atoi64_l (MSVCRT.@)
1669  */
1670 __int64 CDECL _atoi64_l(const char *str, _locale_t locale)
1671 {
1672     return _strtoi64_l(str, NULL, 10, locale);
1673 }
1674
1675 /******************************************************************
1676  *      _atoi64 (MSVCRT.@)
1677  */
1678 __int64 CDECL _atoi64(const char *str)
1679 {
1680     return _strtoi64_l(str, NULL, 10, NULL);
1681 }
1682
1683 /******************************************************************
1684  *      _atol_l (MSVCRT.@)
1685  */
1686 __msvcrt_long CDECL _atol_l(const char *str, _locale_t locale)
1687 {
1688     __int64 ret = _strtoi64_l(str, NULL, 10, locale);
1689
1690     if(ret > LONG_MAX) {
1691         ret = LONG_MAX;
1692         *_errno() = ERANGE;
1693     } else if(ret < LONG_MIN) {
1694         ret = LONG_MIN;
1695         *_errno() = ERANGE;
1696     }
1697     return ret;
1698 }
1699
1700 /******************************************************************
1701  *      atol (MSVCRT.@)
1702  */
1703 __msvcrt_long CDECL atol(const char *str)
1704 {
1705 #if _MSVCR_VER == 0
1706     return atoi(str);
1707 #else
1708     return _atol_l(str, NULL);
1709 #endif
1710 }
1711
1712 #if _MSVCR_VER>=120
1713
1714 /******************************************************************
1715  *      _atoll_l (MSVCR120.@)
1716  */
1717 __int64 CDECL _atoll_l(const char* str, _locale_t locale)
1718 {
1719     return _strtoi64_l(str, NULL, 10, locale);
1720 }
1721
1722 /******************************************************************
1723  *      atoll (MSVCR120.@)
1724  */
1725 __int64 CDECL atoll(const char* str)
1726 {
1727     return _atoll_l(str, NULL);
1728 }
1729
1730 #endif /* _MSVCR_VER>=120 */
1731
1732 /******************************************************************
1733  *              _strtol_l (MSVCRT.@)
1734  */
1735 __msvcrt_long CDECL _strtol_l(const char* nptr,
1736         char** end, int base, _locale_t locale)
1737 {
1738     __int64 ret = _strtoi64_l(nptr, end, base, locale);
1739
1740     if(ret > LONG_MAX) {
1741         ret = LONG_MAX;
1742         *_errno() = ERANGE;
1743     } else if(ret < LONG_MIN) {
1744         ret = LONG_MIN;
1745         *_errno() = ERANGE;
1746     }
1747
1748     return ret;
1749 }
1750
1751 /******************************************************************
1752  *              strtol (MSVCRT.@)
1753  */
1754 __msvcrt_long CDECL strtol(const char* nptr, char** end, int base)
1755 {
1756     return _strtol_l(nptr, end, base, NULL);
1757 }
1758
1759 /******************************************************************
1760  *              _strtoul_l (MSVCRT.@)
1761  */
1762 __msvcrt_ulong CDECL _strtoul_l(const char* nptr, char** end, int base, _locale_t locale)
1763 {
1764     __int64 ret = _strtoi64_l(nptr, end, base, locale);
1765
1766     if(ret > ULONG_MAX) {
1767         ret = ULONG_MAX;
1768         *_errno() = ERANGE;
1769     }else if(ret < -(__int64)ULONG_MAX) {
1770         ret = 1;
1771         *_errno() = ERANGE;
1772     }
1773
1774     return ret;
1775 }
1776
1777 /******************************************************************
1778  *              strtoul (MSVCRT.@)
1779  */
1780 __msvcrt_ulong CDECL strtoul(const char* nptr, char** end, int base)
1781 {
1782     return _strtoul_l(nptr, end, base, NULL);
1783 }
1784
1785 /*********************************************************************
1786  *  _strtoui64_l (MSVCRT.@)
1787  *
1788  * FIXME: locale parameter is ignored
1789  */
1790 unsigned __int64 CDECL _strtoui64_l(const char *nptr, char **endptr, int base, _locale_t locale)
1791 {
1792     const char *p = nptr;
1793     BOOL negative = FALSE;
1794     BOOL got_digit = FALSE;
1795     unsigned __int64 ret = 0;
1796
1797     TRACE("(%s %p %d %p)\n", debugstr_a(nptr), endptr, base, locale);
1798
1799     if (!MSVCRT_CHECK_PMT(nptr != NULL)) return 0;
1800     if (!MSVCRT_CHECK_PMT(base == 0 || base >= 2)) return 0;
1801     if (!MSVCRT_CHECK_PMT(base <= 36)) return 0;
1802
1803     while(_isspace_l((unsigned char)*nptr, locale)) nptr++;
1804
1805     if(*nptr == '-') {
1806         negative = TRUE;
1807         nptr++;
1808     } else if(*nptr == '+')
1809         nptr++;
1810
1811     if((base==0 || base==16) && *nptr=='0' && _tolower_l(*(nptr+1), locale)=='x') {
1812         base = 16;
1813         nptr += 2;
1814     }
1815
1816     if(base == 0) {
1817         if(*nptr=='0')
1818             base = 8;
1819         else
1820             base = 10;
1821     }
1822
1823     while(*nptr) {
1824         char cur = _tolower_l(*nptr, locale);
1825         int v;
1826
1827         if(cur>='0' && cur<='9') {
1828             if(cur >= '0'+base)
1829                 break;
1830             v = *nptr-'0';
1831         } else {
1832             if(cur<'a' || cur>='a'+base-10)
1833                 break;
1834             v = cur-'a'+10;
1835         }
1836         got_digit = TRUE;
1837
1838         nptr++;
1839
1840         if(ret>UI64_MAX/base || ret*base>UI64_MAX-v) {
1841             ret = UI64_MAX;
1842             *_errno() = ERANGE;
1843         } else
1844             ret = ret*base + v;
1845     }
1846
1847     if(endptr)
1848         *endptr = (char*)(got_digit ? nptr : p);
1849
1850     return negative ? -ret : ret;
1851 }
1852
1853 /*********************************************************************
1854  *  _strtoui64 (MSVCRT.@)
1855  */
1856 unsigned __int64 CDECL _strtoui64(const char *nptr, char **endptr, int base)
1857 {
1858     return _strtoui64_l(nptr, endptr, base, NULL);
1859 }
1860
1861 static int ltoa_helper(__msvcrt_long value, char *str, size_t size, int radix)
1862 {
1863     __msvcrt_ulong val;
1864     unsigned int digit;
1865     BOOL is_negative;
1866     char buffer[33], *pos;
1867     size_t len;
1868
1869     if (value < 0 && radix == 10)
1870     {
1871         is_negative = TRUE;
1872         val = -value;
1873     }
1874     else
1875     {
1876         is_negative = FALSE;
1877         val = value;
1878     }
1879
1880     pos = buffer + 32;
1881     *pos = '\0';
1882
1883     do
1884     {
1885         digit = val % radix;
1886         val /= radix;
1887
1888         if (digit < 10)
1889             *--pos = '0' + digit;
1890         else
1891             *--pos = 'a' + digit - 10;
1892     }
1893     while (val != 0);
1894
1895     if (is_negative)
1896         *--pos = '-';
1897
1898     len = buffer + 33 - pos;
1899     if (len > size)
1900     {
1901         size_t i;
1902         char *p = str;
1903
1904         /* Copy the temporary buffer backwards up to the available number of
1905          * characters. Don't copy the negative sign if present. */
1906
1907         if (is_negative)
1908         {
1909             p++;
1910             size--;
1911         }
1912
1913         for (pos = buffer + 31, i = 0; i < size; i++)
1914             *p++ = *pos--;
1915
1916         str[0] = '\0';
1917         MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
1918         return ERANGE;
1919     }
1920
1921     memcpy(str, pos, len);
1922     return 0;
1923 }
1924
1925 static int ltow_helper(__msvcrt_long value, wchar_t *str, size_t size, int radix)
1926 {
1927     __msvcrt_ulong val;
1928     unsigned int digit;
1929     BOOL is_negative;
1930     wchar_t buffer[33], *pos;
1931     size_t len;
1932
1933     if (value < 0 && radix == 10)
1934     {
1935         is_negative = TRUE;
1936         val = -value;
1937     }
1938     else
1939     {
1940         is_negative = FALSE;
1941         val = value;
1942     }
1943
1944     pos = buffer + 32;
1945     *pos = '\0';
1946
1947     do
1948     {
1949         digit = val % radix;
1950         val /= radix;
1951
1952         if (digit < 10)
1953             *--pos = '0' + digit;
1954         else
1955             *--pos = 'a' + digit - 10;
1956     }
1957     while (val != 0);
1958
1959     if (is_negative)
1960         *--pos = '-';
1961
1962     len = buffer + 33 - pos;
1963     if (len > size)
1964     {
1965         size_t i;
1966         wchar_t *p = str;
1967
1968         /* Copy the temporary buffer backwards up to the available number of
1969          * characters. Don't copy the negative sign if present. */
1970
1971         if (is_negative)
1972         {
1973             p++;
1974             size--;
1975         }
1976
1977         for (pos = buffer + 31, i = 0; i < size; i++)
1978             *p++ = *pos--;
1979
1980         str[0] = '\0';
1981         MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
1982         return ERANGE;
1983     }
1984
1985     memcpy(str, pos, len * sizeof(wchar_t));
1986     return 0;
1987 }
1988
1989 /*********************************************************************
1990  *  _ltoa_s (MSVCRT.@)
1991  */
1992 int CDECL _ltoa_s(__msvcrt_long value, char *str, size_t size, int radix)
1993 {
1994     if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
1995     if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
1996     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
1997     {
1998         str[0] = '\0';
1999         return EINVAL;
2000     }
2001
2002     return ltoa_helper(value, str, size, radix);
2003 }
2004
2005 /*********************************************************************
2006  *  _ltow_s (MSVCRT.@)
2007  */
2008 int CDECL _ltow_s(__msvcrt_long value, wchar_t *str, size_t size, int radix)
2009 {
2010     if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
2011     if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
2012     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
2013     {
2014         str[0] = '\0';
2015         return EINVAL;
2016     }
2017
2018     return ltow_helper(value, str, size, radix);
2019 }
2020
2021 /*********************************************************************
2022  *  _itoa_s (MSVCRT.@)
2023  */
2024 int CDECL _itoa_s(int value, char *str, size_t size, int radix)
2025 {
2026     return _ltoa_s(value, str, size, radix);
2027 }
2028
2029 /*********************************************************************
2030  *  _itoa (MSVCRT.@)
2031  */
2032 char* CDECL _itoa(int value, char *str, int radix)
2033 {
2034     return ltoa_helper(value, str, SIZE_MAX, radix) ? NULL : str;
2035 }
2036
2037 /*********************************************************************
2038  *  _ltoa (MSVCRT.@)
2039  */
2040 char* CDECL _ltoa(__msvcrt_long value, char *str, int radix)
2041 {
2042     return ltoa_helper(value, str, SIZE_MAX, radix) ? NULL : str;
2043 }
2044
2045 /*********************************************************************
2046  *  _itow_s (MSVCRT.@)
2047  */
2048 int CDECL _itow_s(int value, wchar_t *str, size_t size, int radix)
2049 {
2050     return _ltow_s(value, str, size, radix);
2051 }
2052
2053 /*********************************************************************
2054  *  _itow (MSVCRT.@)
2055  */
2056 wchar_t* CDECL _itow(int value, wchar_t *str, int radix)
2057 {
2058     return ltow_helper(value, str, SIZE_MAX, radix) ? NULL : str;
2059 }
2060
2061 /*********************************************************************
2062  *  _ltow (MSVCRT.@)
2063  */
2064 wchar_t* CDECL _ltow(__msvcrt_long value, wchar_t *str, int radix)
2065 {
2066     return ltow_helper(value, str, SIZE_MAX, radix) ? NULL : str;
2067 }
2068
2069 /*********************************************************************
2070  *  _ultoa (MSVCRT.@)
2071  */
2072 char* CDECL _ultoa(__msvcrt_ulong value, char *str, int radix)
2073 {
2074     char buffer[33], *pos;
2075
2076     pos = &buffer[32];
2077     *pos = '\0';
2078
2079     do {
2080         int digit = value % radix;
2081         value /= radix;
2082
2083         if (digit < 10)
2084             *--pos = '0' + digit;
2085         else
2086             *--pos = 'a' + digit - 10;
2087     } while (value != 0);
2088
2089     memcpy(str, pos, buffer + 33 - pos);
2090     return str;
2091 }
2092
2093 /*********************************************************************
2094  *  _ui64toa (MSVCRT.@)
2095  */
2096 char* CDECL _ui64toa(unsigned __int64 value, char *str, int radix)
2097 {
2098     char buffer[65], *pos;
2099
2100     pos = &buffer[64];
2101     *pos = '\0';
2102
2103     do {
2104         int digit = value % radix;
2105         value /= radix;
2106
2107         if (digit < 10)
2108             *--pos = '0' + digit;
2109         else
2110             *--pos = 'a' + digit - 10;
2111     } while (value != 0);
2112
2113     memcpy(str, pos, buffer + 65 - pos);
2114     return str;
2115 }
2116
2117 /*********************************************************************
2118  *  _ultow (MSVCRT.@)
2119  */
2120 wchar_t* CDECL _ultow(__msvcrt_ulong value, wchar_t *str, int radix)
2121 {
2122     wchar_t buffer[33], *pos;
2123
2124     pos = &buffer[32];
2125     *pos = '\0';
2126
2127     do {
2128         int digit = value % radix;
2129         value /= radix;
2130
2131         if (digit < 10)
2132             *--pos = '0' + digit;
2133         else
2134             *--pos = 'a' + digit - 10;
2135     } while (value != 0);
2136
2137     memcpy(str, pos, (buffer + 33 - pos) * sizeof(wchar_t));
2138     return str;
2139 }
2140
2141 /*********************************************************************
2142  *  _ui64tow (MSVCRT.@)
2143  */
2144 wchar_t* CDECL _ui64tow(unsigned __int64 value, wchar_t *str, int radix)
2145 {
2146     wchar_t buffer[65], *pos;
2147
2148     pos = &buffer[64];
2149     *pos = '\0';
2150
2151     do {
2152         int digit = value % radix;
2153         value /= radix;
2154
2155         if (digit < 10)
2156             *--pos = '0' + digit;
2157         else
2158             *--pos = 'a' + digit - 10;
2159     } while (value != 0);
2160
2161     memcpy(str, pos, (buffer + 65 - pos) * sizeof(wchar_t));
2162     return str;
2163 }
2164
2165 /*********************************************************************
2166  *  _i64toa (MSVCRT.@)
2167  */
2168 char* CDECL _i64toa(__int64 value, char *str, int radix)
2169 {
2170     unsigned __int64 val;
2171     BOOL is_negative;
2172     char buffer[65], *pos;
2173
2174     if (value < 0 && radix == 10)
2175     {
2176         is_negative = TRUE;
2177         val = -value;
2178     }
2179     else
2180     {
2181         is_negative = FALSE;
2182         val = value;
2183     }
2184
2185     pos = buffer + 64;
2186     *pos = '\0';
2187
2188     do
2189     {
2190         int digit = val % radix;
2191         val /= radix;
2192
2193         if (digit < 10)
2194             *--pos = '0' + digit;
2195         else
2196             *--pos = 'a' + digit - 10;
2197     }
2198     while (val != 0);
2199
2200     if (is_negative)
2201         *--pos = '-';
2202
2203     memcpy(str, pos, buffer + 65 - pos);
2204     return str;
2205 }
2206
2207 /*********************************************************************
2208  *  _i64tow (MSVCRT.@)
2209  */
2210 wchar_t* CDECL _i64tow(__int64 value, wchar_t *str, int radix)
2211 {
2212     unsigned __int64 val;
2213     BOOL is_negative;
2214     wchar_t buffer[65], *pos;
2215
2216     if (value < 0 && radix == 10)
2217     {
2218         is_negative = TRUE;
2219         val = -value;
2220     }
2221     else
2222     {
2223         is_negative = FALSE;
2224         val = value;
2225     }
2226
2227     pos = buffer + 64;
2228     *pos = '\0';
2229
2230     do
2231     {
2232         int digit = val % radix;
2233         val /= radix;
2234
2235         if (digit < 10)
2236             *--pos = '0' + digit;
2237         else
2238             *--pos = 'a' + digit - 10;
2239     }
2240     while (val != 0);
2241
2242     if (is_negative)
2243         *--pos = '-';
2244
2245     memcpy(str, pos, (buffer + 65 - pos) * sizeof(wchar_t));
2246     return str;
2247 }
2248
2249 /*********************************************************************
2250  *  _ui64toa_s (MSVCRT.@)
2251  */
2252 int CDECL _ui64toa_s(unsigned __int64 value, char *str,
2253         size_t size, int radix)
2254 {
2255     char buffer[65], *pos;
2256     int digit;
2257
2258     if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
2259     if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
2260     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
2261     {
2262         str[0] = '\0';
2263         return EINVAL;
2264     }
2265
2266     pos = buffer+64;
2267     *pos = '\0';
2268
2269     do {
2270         digit = value%radix;
2271         value /= radix;
2272
2273         if(digit < 10)
2274             *--pos = '0'+digit;
2275         else
2276             *--pos = 'a'+digit-10;
2277     }while(value != 0);
2278
2279     if(buffer-pos+65 > size) {
2280         MSVCRT_INVALID_PMT("str[size] is too small", EINVAL);
2281         return EINVAL;
2282     }
2283
2284     memcpy(str, pos, buffer-pos+65);
2285     return 0;
2286 }
2287
2288 /*********************************************************************
2289  *      _ui64tow_s  (MSVCRT.@)
2290  */
2291 int CDECL _ui64tow_s( unsigned __int64 value, wchar_t *str,
2292                              size_t size, int radix )
2293 {
2294     wchar_t buffer[65], *pos;
2295     int digit;
2296
2297     if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
2298     if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
2299     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
2300     {
2301         str[0] = '\0';
2302         return EINVAL;
2303     }
2304
2305     pos = &buffer[64];
2306     *pos = '\0';
2307
2308     do {
2309         digit = value % radix;
2310         value = value / radix;
2311         if (digit < 10)
2312             *--pos = '0' + digit;
2313         else
2314             *--pos = 'a' + digit - 10;
2315     } while (value != 0);
2316
2317     if(buffer-pos+65 > size) {
2318         MSVCRT_INVALID_PMT("str[size] is too small", EINVAL);
2319         return EINVAL;
2320     }
2321
2322     memcpy(str, pos, (buffer-pos+65)*sizeof(wchar_t));
2323     return 0;
2324 }
2325
2326 /*********************************************************************
2327  *  _ultoa_s (MSVCRT.@)
2328  */
2329 int CDECL _ultoa_s(__msvcrt_ulong value, char *str, size_t size, int radix)
2330 {
2331     __msvcrt_ulong digit;
2332     char buffer[33], *pos;
2333     size_t len;
2334
2335     if (!str || !size || radix < 2 || radix > 36)
2336     {
2337         if (str && size)
2338             str[0] = '\0';
2339
2340         *_errno() = EINVAL;
2341         return EINVAL;
2342     }
2343
2344     pos = buffer + 32;
2345     *pos = '\0';
2346
2347     do
2348     {
2349         digit = value % radix;
2350         value /= radix;
2351
2352         if (digit < 10)
2353             *--pos = '0' + digit;
2354         else
2355             *--pos = 'a' + digit - 10;
2356     }
2357     while (value != 0);
2358
2359     len = buffer + 33 - pos;
2360     if (len > size)
2361     {
2362         size_t i;
2363         char *p = str;
2364
2365         /* Copy the temporary buffer backwards up to the available number of
2366          * characters. */
2367
2368         for (pos = buffer + 31, i = 0; i < size; i++)
2369             *p++ = *pos--;
2370
2371         str[0] = '\0';
2372         *_errno() = ERANGE;
2373         return ERANGE;
2374     }
2375
2376     memcpy(str, pos, len);
2377     return 0;
2378 }
2379
2380 /*********************************************************************
2381  *  _ultow_s (MSVCRT.@)
2382  */
2383 int CDECL _ultow_s(__msvcrt_ulong value, wchar_t *str, size_t size, int radix)
2384 {
2385     __msvcrt_ulong digit;
2386     WCHAR buffer[33], *pos;
2387     size_t len;
2388
2389     if (!str || !size || radix < 2 || radix > 36)
2390     {
2391         if (str && size)
2392             str[0] = '\0';
2393
2394         *_errno() = EINVAL;
2395         return EINVAL;
2396     }
2397
2398     pos = buffer + 32;
2399     *pos = '\0';
2400
2401     do
2402     {
2403         digit = value % radix;
2404         value /= radix;
2405
2406         if (digit < 10)
2407             *--pos = '0' + digit;
2408         else
2409             *--pos = 'a' + digit - 10;
2410     }
2411     while (value != 0);
2412
2413     len = buffer + 33 - pos;
2414     if (len > size)
2415     {
2416         size_t i;
2417         WCHAR *p = str;
2418
2419         /* Copy the temporary buffer backwards up to the available number of
2420          * characters. */
2421
2422         for (pos = buffer + 31, i = 0; i < size; i++)
2423             *p++ = *pos--;
2424
2425         str[0] = '\0';
2426         *_errno() = ERANGE;
2427         return ERANGE;
2428     }
2429
2430     memcpy(str, pos, len * sizeof(wchar_t));
2431     return 0;
2432 }
2433
2434 /*********************************************************************
2435  *  _i64toa_s (MSVCRT.@)
2436  */
2437 int CDECL _i64toa_s(__int64 value, char *str, size_t size, int radix)
2438 {
2439     unsigned __int64 val;
2440     unsigned int digit;
2441     BOOL is_negative;
2442     char buffer[65], *pos;
2443     size_t len;
2444
2445     if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
2446     if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
2447     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
2448     {
2449         str[0] = '\0';
2450         return EINVAL;
2451     }
2452
2453     if (value < 0 && radix == 10)
2454     {
2455         is_negative = TRUE;
2456         val = -value;
2457     }
2458     else
2459     {
2460         is_negative = FALSE;
2461         val = value;
2462     }
2463
2464     pos = buffer + 64;
2465     *pos = '\0';
2466
2467     do
2468     {
2469         digit = val % radix;
2470         val /= radix;
2471
2472         if (digit < 10)
2473             *--pos = '0' + digit;
2474         else
2475             *--pos = 'a' + digit - 10;
2476     }
2477     while (val != 0);
2478
2479     if (is_negative)
2480         *--pos = '-';
2481
2482     len = buffer + 65 - pos;
2483     if (len > size)
2484     {
2485         size_t i;
2486         char *p = str;
2487
2488         /* Copy the temporary buffer backwards up to the available number of
2489          * characters. Don't copy the negative sign if present. */
2490
2491         if (is_negative)
2492         {
2493             p++;
2494             size--;
2495         }
2496
2497         for (pos = buffer + 63, i = 0; i < size; i++)
2498             *p++ = *pos--;
2499
2500         str[0] = '\0';
2501         MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
2502         return ERANGE;
2503     }
2504
2505     memcpy(str, pos, len);
2506     return 0;
2507 }
2508
2509 /*********************************************************************
2510  *  _i64tow_s (MSVCRT.@)
2511  */
2512 int CDECL _i64tow_s(__int64 value, wchar_t *str, size_t size, int radix)
2513 {
2514     unsigned __int64 val;
2515     unsigned int digit;
2516     BOOL is_negative;
2517     wchar_t buffer[65], *pos;
2518     size_t len;
2519
2520     if (!MSVCRT_CHECK_PMT(str != NULL)) return EINVAL;
2521     if (!MSVCRT_CHECK_PMT(size > 0)) return EINVAL;
2522     if (!MSVCRT_CHECK_PMT(radix >= 2 && radix <= 36))
2523     {
2524         str[0] = '\0';
2525         return EINVAL;
2526     }
2527
2528     if (value < 0 && radix == 10)
2529     {
2530         is_negative = TRUE;
2531         val = -value;
2532     }
2533     else
2534     {
2535         is_negative = FALSE;
2536         val = value;
2537     }
2538
2539     pos = buffer + 64;
2540     *pos = '\0';
2541
2542     do
2543     {
2544         digit = val % radix;
2545         val /= radix;
2546
2547         if (digit < 10)
2548             *--pos = '0' + digit;
2549         else
2550             *--pos = 'a' + digit - 10;
2551     }
2552     while (val != 0);
2553
2554     if (is_negative)
2555         *--pos = '-';
2556
2557     len = buffer + 65 - pos;
2558     if (len > size)
2559     {
2560         size_t i;
2561         wchar_t *p = str;
2562
2563         /* Copy the temporary buffer backwards up to the available number of
2564          * characters. Don't copy the negative sign if present. */
2565
2566         if (is_negative)
2567         {
2568             p++;
2569             size--;
2570         }
2571
2572         for (pos = buffer + 63, i = 0; i < size; i++)
2573             *p++ = *pos--;
2574
2575         str[0] = '\0';
2576         MSVCRT_INVALID_PMT("str[size] is too small", ERANGE);
2577         return ERANGE;
2578     }
2579
2580     memcpy(str, pos, len * sizeof(wchar_t));
2581     return 0;
2582 }
2583
2584 #define I10_OUTPUT_MAX_PREC 21
2585 /* Internal structure used by $I10_OUTPUT */
2586 struct _I10_OUTPUT_DATA {
2587     short pos;
2588     char sign;
2589     BYTE len;
2590     char str[I10_OUTPUT_MAX_PREC+1]; /* add space for '\0' */
2591 };
2592
2593 /*********************************************************************
2594  *              $I10_OUTPUT (MSVCRT.@)
2595  * ld80 - long double (Intel 80 bit FP in 12 bytes) to be printed to data
2596  * prec - precision of part, we're interested in
2597  * flag - 0 for first prec digits, 1 for fractional part
2598  * data - data to be populated
2599  *
2600  * return value
2601  *      0 if given double is NaN or INF
2602  *      1 otherwise
2603  *
2604  * FIXME
2605  *      Native sets last byte of data->str to '0' or '9', I don't know what
2606  *      it means. Current implementation sets it always to '0'.
2607  */
2608 int CDECL I10_OUTPUT(MSVCRT__LDOUBLE ld80, int prec, int flag, struct _I10_OUTPUT_DATA *data)
2609 {
2610     struct fpnum num;
2611     double d;
2612     char format[8];
2613     char buf[I10_OUTPUT_MAX_PREC+9]; /* 9 = strlen("0.e+0000") + '\0' */
2614     char *p;
2615
2616     if ((ld80.x80[2] & 0x7fff) == 0x7fff)
2617     {
2618         if (ld80.x80[0] == 0 && ld80.x80[1] == 0x80000000)
2619             strcpy( data->str, "1#INF" );
2620         else
2621             strcpy( data->str, (ld80.x80[1] & 0x40000000) ? "1#QNAN" : "1#SNAN" );
2622         data->pos = 1;
2623         data->sign = (ld80.x80[2] & 0x8000) ? '-' : ' ';
2624         data->len = strlen(data->str);
2625         return 0;
2626     }
2627
2628     num.sign = (ld80.x80[2] & 0x8000) ? -1 : 1;
2629     num.exp  = (ld80.x80[2] & 0x7fff) - 0x3fff - 63;
2630     num.m    = ld80.x80[0] | ((ULONGLONG)ld80.x80[1] << 32);
2631     num.mod  = FP_ROUND_EVEN;
2632     fpnum_double( &num, &d );
2633     TRACE("(%lf %d %x %p)\n", d, prec, flag, data);
2634
2635     if(d<0) {
2636         data->sign = '-';
2637         d = -d;
2638     } else
2639         data->sign = ' ';
2640
2641     if(flag&1) {
2642         int exp = 1 + floor(log10(d));
2643
2644         prec += exp;
2645         if(exp < 0)
2646             prec--;
2647     }
2648     prec--;
2649
2650     if(prec+1 > I10_OUTPUT_MAX_PREC)
2651         prec = I10_OUTPUT_MAX_PREC-1;
2652     else if(prec < 0) {
2653         d = 0.0;
2654         prec = 0;
2655     }
2656
2657     sprintf(format, "%%.%dle", prec);
2658     sprintf(buf, format, d);
2659
2660     buf[1] = buf[0];
2661     data->pos = atoi(buf+prec+3);
2662     if(buf[1] != '0')
2663         data->pos++;
2664
2665     for(p = buf+prec+1; p>buf+1 && *p=='0'; p--);
2666     data->len = p-buf;
2667
2668     memcpy(data->str, buf+1, data->len);
2669     data->str[data->len] = '\0';
2670
2671     if(buf[1]!='0' && prec-data->len+1>0)
2672         memcpy(data->str+data->len+1, buf+data->len+1, prec-data->len+1);
2673
2674     return 1;
2675 }
2676 #undef I10_OUTPUT_MAX_PREC
2677
2678 /*********************************************************************
2679  *                  memcmp (MSVCRT.@)
2680  */
2681 int __cdecl memcmp(const void *ptr1, const void *ptr2, size_t n)
2682 {
2683     const unsigned char *p1, *p2;
2684
2685     for (p1 = ptr1, p2 = ptr2; n; n--, p1++, p2++)
2686     {
2687         if (*p1 < *p2) return -1;
2688         if (*p1 > *p2) return 1;
2689     }
2690     return 0;
2691 }
2692
2693 #if defined(__i386__) || defined(__x86_64__)
2694
2695 #ifdef __i386__
2696
2697 #define DEST_REG "%edi"
2698 #define SRC_REG "%esi"
2699 #define LEN_REG "%ecx"
2700 #define TMP_REG "%edx"
2701
2702 #define MEMMOVE_INIT \
2703     "pushl " SRC_REG "\n\t" \
2704     __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t") \
2705     "pushl " DEST_REG "\n\t" \
2706     __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t") \
2707     "movl 12(%esp), " DEST_REG "\n\t" \
2708     "movl 16(%esp), " SRC_REG "\n\t" \
2709     "movl 20(%esp), " LEN_REG "\n\t"
2710
2711 #define MEMMOVE_CLEANUP \
2712     "movl 12(%esp), %eax\n\t" \
2713     "popl " DEST_REG "\n\t" \
2714     __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t") \
2715     "popl " SRC_REG "\n\t" \
2716     __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
2717
2718 #else
2719
2720 #define DEST_REG "%rdi"
2721 #define SRC_REG "%rsi"
2722 #define LEN_REG "%r8"
2723 #define TMP_REG "%r9"
2724
2725 #define MEMMOVE_INIT \
2726     "pushq " SRC_REG "\n\t" \
2727     __ASM_CFI(".cfi_adjust_cfa_offset 8\n\t") \
2728     "pushq " DEST_REG "\n\t" \
2729     __ASM_CFI(".cfi_adjust_cfa_offset 8\n\t") \
2730     "movq %rcx, " DEST_REG "\n\t" \
2731     "movq %rdx, " SRC_REG "\n\t"
2732
2733 #define MEMMOVE_CLEANUP \
2734     "movq %rcx, %rax\n\t" \
2735     "popq " DEST_REG "\n\t" \
2736     __ASM_CFI(".cfi_adjust_cfa_offset -8\n\t") \
2737     "popq " SRC_REG "\n\t" \
2738     __ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
2739 #endif
2740
2741 void * __cdecl sse2_memmove(void *dst, const void *src, size_t n);
2742 __ASM_GLOBAL_FUNC( sse2_memmove,
2743         MEMMOVE_INIT
2744         "mov " DEST_REG ", " TMP_REG "\n\t" /* check copying direction */
2745         "sub " SRC_REG ", " TMP_REG "\n\t"
2746         "cmp " LEN_REG ", " TMP_REG "\n\t"
2747         "jb copy_bwd\n\t"
2748         /* copy forwards */
2749         "cmp $4, " LEN_REG "\n\t" /* 4-bytes align */
2750         "jb copy_fwd3\n\t"
2751         "mov " DEST_REG ", " TMP_REG "\n\t"
2752         "shr $1, " TMP_REG "\n\t"
2753         "jnc 1f\n\t"
2754         "movsb\n\t"
2755         "dec " LEN_REG "\n\t"
2756         "inc " TMP_REG "\n\t"
2757         "1:\n\t"
2758         "shr $1, " TMP_REG "\n\t"
2759         "jnc 1f\n\t"
2760         "movsw\n\t"
2761         "sub $2, " LEN_REG "\n\t"
2762         "inc " TMP_REG "\n\t"
2763         "1:\n\t" /* 16-bytes align */
2764         "cmp $16, " LEN_REG "\n\t"
2765         "jb copy_fwd15\n\t"
2766         "shr $1, " TMP_REG "\n\t"
2767         "jnc 1f\n\t"
2768         "movsl\n\t"
2769         "sub $4, " LEN_REG "\n\t"
2770         "inc " TMP_REG "\n\t"
2771         "1:\n\t"
2772         "shr $1, " TMP_REG "\n\t"
2773         "jnc 1f\n\t"
2774         "movsl\n\t"
2775         "movsl\n\t"
2776         "sub $8, " LEN_REG "\n\t"
2777         "1:\n\t"
2778         "cmp $64, " LEN_REG "\n\t"
2779         "jb copy_fwd63\n\t"
2780         "1:\n\t" /* copy 64-bytes blocks in loop, dest 16-bytes aligned */
2781         "movdqu 0x00(" SRC_REG "), %xmm0\n\t"
2782         "movdqu 0x10(" SRC_REG "), %xmm1\n\t"
2783         "movdqu 0x20(" SRC_REG "), %xmm2\n\t"
2784         "movdqu 0x30(" SRC_REG "), %xmm3\n\t"
2785         "movdqa %xmm0, 0x00(" DEST_REG ")\n\t"
2786         "movdqa %xmm1, 0x10(" DEST_REG ")\n\t"
2787         "movdqa %xmm2, 0x20(" DEST_REG ")\n\t"
2788         "movdqa %xmm3, 0x30(" DEST_REG ")\n\t"
2789         "add $64, " SRC_REG "\n\t"
2790         "add $64, " DEST_REG "\n\t"
2791         "sub $64, " LEN_REG "\n\t"
2792         "cmp $64, " LEN_REG "\n\t"
2793         "jae 1b\n\t"
2794         "copy_fwd63:\n\t" /* copy last 63 bytes, dest 16-bytes aligned */
2795         "mov " LEN_REG ", " TMP_REG "\n\t"
2796         "and $15, " LEN_REG "\n\t"
2797         "shr $5, " TMP_REG "\n\t"
2798         "jnc 1f\n\t"
2799         "movdqu 0(" SRC_REG "), %xmm0\n\t"
2800         "movdqa %xmm0, 0(" DEST_REG ")\n\t"
2801         "add $16, " SRC_REG "\n\t"
2802         "add $16, " DEST_REG "\n\t"
2803         "1:\n\t"
2804         "shr $1, " TMP_REG "\n\t"
2805         "jnc copy_fwd15\n\t"
2806         "movdqu 0x00(" SRC_REG "), %xmm0\n\t"
2807         "movdqu 0x10(" SRC_REG "), %xmm1\n\t"
2808         "movdqa %xmm0, 0x00(" DEST_REG ")\n\t"
2809         "movdqa %xmm1, 0x10(" DEST_REG ")\n\t"
2810         "add $32, " SRC_REG "\n\t"
2811         "add $32, " DEST_REG "\n\t"
2812         "copy_fwd15:\n\t" /* copy last 15 bytes, dest 4-bytes aligned */
2813         "mov " LEN_REG ", " TMP_REG "\n\t"
2814         "and $3, " LEN_REG "\n\t"
2815         "shr $3, " TMP_REG "\n\t"
2816         "jnc 1f\n\t"
2817         "movsl\n\t"
2818         "1:\n\t"
2819         "shr $1, " TMP_REG "\n\t"
2820         "jnc copy_fwd3\n\t"
2821         "movsl\n\t"
2822         "movsl\n\t"
2823         "copy_fwd3:\n\t" /* copy last 3 bytes */
2824         "shr $1, " LEN_REG "\n\t"
2825         "jnc 1f\n\t"
2826         "movsb\n\t"
2827         "1:\n\t"
2828         "shr $1, " LEN_REG "\n\t"
2829         "jnc 1f\n\t"
2830         "movsw\n\t"
2831         "1:\n\t"
2832         MEMMOVE_CLEANUP
2833         "ret\n\t"
2834         "copy_bwd:\n\t"
2835         "lea (" DEST_REG ", " LEN_REG "), " DEST_REG "\n\t"
2836         "lea (" SRC_REG ", " LEN_REG "), " SRC_REG "\n\t"
2837         "cmp $4, " LEN_REG "\n\t" /* 4-bytes align */
2838         "jb copy_bwd3\n\t"
2839         "mov " DEST_REG ", " TMP_REG "\n\t"
2840         "shr $1, " TMP_REG "\n\t"
2841         "jnc 1f\n\t"
2842         "dec " SRC_REG "\n\t"
2843         "dec " DEST_REG "\n\t"
2844         "movb (" SRC_REG "), %al\n\t"
2845         "movb %al, (" DEST_REG ")\n\t"
2846         "dec " LEN_REG "\n\t"
2847         "1:\n\t"
2848         "shr $1, " TMP_REG "\n\t"
2849         "jnc 1f\n\t"
2850         "sub $2, " SRC_REG "\n\t"
2851         "sub $2, " DEST_REG "\n\t"
2852         "movw (" SRC_REG "), %ax\n\t"
2853         "movw %ax, (" DEST_REG ")\n\t"
2854         "sub $2, " LEN_REG "\n\t"
2855         "1:\n\t" /* 16-bytes align */
2856         "cmp $16, " LEN_REG "\n\t"
2857         "jb copy_bwd15\n\t"
2858         "shr $1, " TMP_REG "\n\t"
2859         "jnc 1f\n\t"
2860         "sub $4, " SRC_REG "\n\t"
2861         "sub $4, " DEST_REG "\n\t"
2862         "movl (" SRC_REG "), %eax\n\t"
2863         "movl %eax, (" DEST_REG ")\n\t"
2864         "sub $4, " LEN_REG "\n\t"
2865         "1:\n\t"
2866         "shr $1, " TMP_REG "\n\t"
2867         "jnc 1f\n\t"
2868         "sub $8, " SRC_REG "\n\t"
2869         "sub $8, " DEST_REG "\n\t"
2870         "movl 4(" SRC_REG "), %eax\n\t"
2871         "movl %eax, 4(" DEST_REG ")\n\t"
2872         "movl (" SRC_REG "), %eax\n\t"
2873         "movl %eax, (" DEST_REG ")\n\t"
2874         "sub $8, " LEN_REG "\n\t"
2875         "1:\n\t"
2876         "cmp $64, " LEN_REG "\n\t"
2877         "jb copy_bwd63\n\t"
2878         "1:\n\t" /* copy 64-bytes blocks in loop, dest 16-bytes aligned */
2879         "sub $64, " SRC_REG "\n\t"
2880         "sub $64, " DEST_REG "\n\t"
2881         "movdqu 0x00(" SRC_REG "), %xmm0\n\t"
2882         "movdqu 0x10(" SRC_REG "), %xmm1\n\t"
2883         "movdqu 0x20(" SRC_REG "), %xmm2\n\t"
2884         "movdqu 0x30(" SRC_REG "), %xmm3\n\t"
2885         "movdqa %xmm0, 0x00(" DEST_REG ")\n\t"
2886         "movdqa %xmm1, 0x10(" DEST_REG ")\n\t"
2887         "movdqa %xmm2, 0x20(" DEST_REG ")\n\t"
2888         "movdqa %xmm3, 0x30(" DEST_REG ")\n\t"
2889         "sub $64, " LEN_REG "\n\t"
2890         "cmp $64, " LEN_REG "\n\t"
2891         "jae 1b\n\t"
2892         "copy_bwd63:\n\t" /* copy last 63 bytes, dest 16-bytes aligned */
2893         "mov " LEN_REG ", " TMP_REG "\n\t"
2894         "and $15, " LEN_REG "\n\t"
2895         "shr $5, " TMP_REG "\n\t"
2896         "jnc 1f\n\t"
2897         "sub $16, " SRC_REG "\n\t"
2898         "sub $16, " DEST_REG "\n\t"
2899         "movdqu (" SRC_REG "), %xmm0\n\t"
2900         "movdqa %xmm0, (" DEST_REG ")\n\t"
2901         "1:\n\t"
2902         "shr $1, " TMP_REG "\n\t"
2903         "jnc copy_bwd15\n\t"
2904         "sub $32, " SRC_REG "\n\t"
2905         "sub $32, " DEST_REG "\n\t"
2906         "movdqu 0x00(" SRC_REG "), %xmm0\n\t"
2907         "movdqu 0x10(" SRC_REG "), %xmm1\n\t"
2908         "movdqa %xmm0, 0x00(" DEST_REG ")\n\t"
2909         "movdqa %xmm1, 0x10(" DEST_REG ")\n\t"
2910         "copy_bwd15:\n\t" /* copy last 15 bytes, dest 4-bytes aligned */
2911         "mov " LEN_REG ", " TMP_REG "\n\t"
2912         "and $3, " LEN_REG "\n\t"
2913         "shr $3, " TMP_REG "\n\t"
2914         "jnc 1f\n\t"
2915         "sub $4, " SRC_REG "\n\t"
2916         "sub $4, " DEST_REG "\n\t"
2917         "movl (" SRC_REG "), %eax\n\t"
2918         "movl %eax, (" DEST_REG ")\n\t"
2919         "1:\n\t"
2920         "shr $1, " TMP_REG "\n\t"
2921         "jnc copy_bwd3\n\t"
2922         "sub $8, " SRC_REG "\n\t"
2923         "sub $8, " DEST_REG "\n\t"
2924         "movl 4(" SRC_REG "), %eax\n\t"
2925         "movl %eax, 4(" DEST_REG ")\n\t"
2926         "movl (" SRC_REG "), %eax\n\t"
2927         "movl %eax, (" DEST_REG ")\n\t"
2928         "copy_bwd3:\n\t" /* copy last 3 bytes */
2929         "shr $1, " LEN_REG "\n\t"
2930         "jnc 1f\n\t"
2931         "dec " SRC_REG "\n\t"
2932         "dec " DEST_REG "\n\t"
2933         "movb (" SRC_REG "), %al\n\t"
2934         "movb %al, (" DEST_REG ")\n\t"
2935         "1:\n\t"
2936         "shr $1, " LEN_REG "\n\t"
2937         "jnc 1f\n\t"
2938         "movw -2(" SRC_REG "), %ax\n\t"
2939         "movw %ax, -2(" DEST_REG ")\n\t"
2940         "1:\n\t"
2941         MEMMOVE_CLEANUP
2942         "ret" )
2943
2944 #endif
2945
2946 /*********************************************************************
2947  *                  memmove (MSVCRT.@)
2948  */
2949 #ifdef WORDS_BIGENDIAN
2950 # define MERGE(w1, sh1, w2, sh2) ((w1 << sh1) | (w2 >> sh2))
2951 #else
2952 # define MERGE(w1, sh1, w2, sh2) ((w1 >> sh1) | (w2 << sh2))
2953 #endif
2954 void * __cdecl memmove(void *dst, const void *src, size_t n)
2955 {
2956 #ifdef __x86_64__
2957     return sse2_memmove(dst, src, n);
2958 #else
2959     unsigned char *d = dst;
2960     const unsigned char *s = src;
2961     int sh1;
2962
2963 #ifdef __i386__
2964     if (sse2_supported)
2965         return sse2_memmove(dst, src, n);
2966 #endif
2967
2968     if (!n) return dst;
2969
2970     if ((size_t)dst - (size_t)src >= n)
2971     {
2972         for (; (size_t)d % sizeof(size_t) && n; n--) *d++ = *s++;
2973
2974         sh1 = 8 * ((size_t)s % sizeof(size_t));
2975         if (!sh1)
2976         {
2977             while (n >= sizeof(size_t))
2978             {
2979                 *(size_t*)d = *(size_t*)s;
2980                 s += sizeof(size_t);
2981                 d += sizeof(size_t);
2982                 n -= sizeof(size_t);
2983             }
2984         }
2985         else if (n >= 2 * sizeof(size_t))
2986         {
2987             int sh2 = 8 * sizeof(size_t) - sh1;
2988             size_t x, y;
2989
2990             s -= sh1 / 8;
2991             x = *(size_t*)s;
2992             do
2993             {
2994                 s += sizeof(size_t);
2995                 y = *(size_t*)s;
2996                 *(size_t*)d = MERGE(x, sh1, y, sh2);
2997                 d += sizeof(size_t);
2998
2999                 s += sizeof(size_t);
3000                 x = *(size_t*)s;
3001                 *(size_t*)d = MERGE(y, sh1, x, sh2);
3002                 d += sizeof(size_t);
3003
3004                 n -= 2 * sizeof(size_t);
3005             } while (n >= 2 * sizeof(size_t));
3006             s += sh1 / 8;
3007         }
3008         while (n--) *d++ = *s++;
3009         return dst;
3010     }
3011     else
3012     {
3013         d += n;
3014         s += n;
3015
3016         for (; (size_t)d % sizeof(size_t) && n; n--) *--d = *--s;
3017
3018         sh1 = 8 * ((size_t)s % sizeof(size_t));
3019         if (!sh1)
3020         {
3021             while (n >= sizeof(size_t))
3022             {
3023                 s -= sizeof(size_t);
3024                 d -= sizeof(size_t);
3025                 *(size_t*)d = *(size_t*)s;
3026                 n -= sizeof(size_t);
3027             }
3028         }
3029         else if (n >= 2 * sizeof(size_t))
3030         {
3031             int sh2 = 8 * sizeof(size_t) - sh1;
3032             size_t x, y;
3033
3034             s -= sh1 / 8;
3035             x = *(size_t*)s;
3036             do
3037             {
3038                 s -= sizeof(size_t);
3039                 y = *(size_t*)s;
3040                 d -= sizeof(size_t);
3041                 *(size_t*)d = MERGE(y, sh1, x, sh2);
3042
3043                 s -= sizeof(size_t);
3044                 x = *(size_t*)s;
3045                 d -= sizeof(size_t);
3046                 *(size_t*)d = MERGE(x, sh1, y, sh2);
3047
3048                 n -= 2 * sizeof(size_t);
3049             } while (n >= 2 * sizeof(size_t));
3050             s += sh1 / 8;
3051         }
3052         while (n--) *--d = *--s;
3053     }
3054     return dst;
3055 #endif
3056 }
3057 #undef MERGE
3058
3059 /*********************************************************************
3060  *                  memcpy   (MSVCRT.@)
3061  */
3062 void * __cdecl memcpy(void *dst, const void *src, size_t n)
3063 {
3064     return memmove(dst, src, n);
3065 }
3066
3067 /*********************************************************************
3068  *                  _memccpy   (MSVCRT.@)
3069  */
3070 void * __cdecl _memccpy(void *dst, const void *src, int c, size_t n)
3071 {
3072     unsigned char *d = dst;
3073     const unsigned char *s = src;
3074     while (n--) if ((*d++ = *s++) == (unsigned char)c) return d;
3075     return NULL;
3076 }
3077
3078
3079 static inline void memset_aligned_32(unsigned char *d, uint64_t v, size_t n)
3080 {
3081     unsigned char *end = d + n;
3082     while (d < end)
3083     {
3084         *(uint64_t *)(d + 0) = v;
3085         *(uint64_t *)(d + 8) = v;
3086         *(uint64_t *)(d + 16) = v;
3087         *(uint64_t *)(d + 24) = v;
3088         d += 32;
3089     }
3090 }
3091
3092 /*********************************************************************
3093  *                  memset (MSVCRT.@)
3094  */
3095 void *__cdecl memset(void *dst, int c, size_t n)
3096 {
3097     typedef uint64_t DECLSPEC_ALIGN(1) unaligned_ui64;
3098     typedef uint32_t DECLSPEC_ALIGN(1) unaligned_ui32;
3099     typedef uint16_t DECLSPEC_ALIGN(1) unaligned_ui16;
3100
3101     uint64_t v = 0x101010101010101ull * (unsigned char)c;
3102     unsigned char *d = (unsigned char *)dst;
3103     size_t a = 0x20 - ((uintptr_t)d & 0x1f);
3104
3105     if (n >= 16)
3106     {
3107         *(unaligned_ui64 *)(d + 0) = v;
3108         *(unaligned_ui64 *)(d + 8) = v;
3109         *(unaligned_ui64 *)(d + n - 16) = v;
3110         *(unaligned_ui64 *)(d + n - 8) = v;
3111         if (n <= 32) return dst;
3112         *(unaligned_ui64 *)(d + 16) = v;
3113         *(unaligned_ui64 *)(d + 24) = v;
3114         *(unaligned_ui64 *)(d + n - 32) = v;
3115         *(unaligned_ui64 *)(d + n - 24) = v;
3116         if (n <= 64) return dst;
3117
3118         n = (n - a) & ~0x1f;
3119         memset_aligned_32(d + a, v, n);
3120         return dst;
3121     }
3122     if (n >= 8)
3123     {
3124         *(unaligned_ui64 *)d = v;
3125         *(unaligned_ui64 *)(d + n - 8) = v;
3126         return dst;
3127     }
3128     if (n >= 4)
3129     {
3130         *(unaligned_ui32 *)d = v;
3131         *(unaligned_ui32 *)(d + n - 4) = v;
3132         return dst;
3133     }
3134     if (n >= 2)
3135     {
3136         *(unaligned_ui16 *)d = v;
3137         *(unaligned_ui16 *)(d + n - 2) = v;
3138         return dst;
3139     }
3140     if (n >= 1)
3141     {
3142         *(uint8_t *)d = v;
3143         return dst;
3144     }
3145     return dst;
3146 }
3147
3148 /*********************************************************************
3149  *                  strchr (MSVCRT.@)
3150  */
3151 char* __cdecl strchr(const char *str, int c)
3152 {
3153     do
3154     {
3155         if (*str == (char)c) return (char*)str;
3156     } while (*str++);
3157     return NULL;
3158 }
3159
3160 /*********************************************************************
3161  *                  strrchr (MSVCRT.@)
3162  */
3163 char* __cdecl strrchr(const char *str, int c)
3164 {
3165     char *ret = NULL;
3166     do { if (*str == (char)c) ret = (char*)str; } while (*str++);
3167     return ret;
3168 }
3169
3170 /*********************************************************************
3171  *                  memchr   (MSVCRT.@)
3172  */
3173 void* __cdecl memchr(const void *ptr, int c, size_t n)
3174 {
3175     const unsigned char *p = ptr;
3176
3177     for (p = ptr; n; n--, p++) if (*p == (unsigned char)c) return (void *)(ULONG_PTR)p;
3178     return NULL;
3179 }
3180
3181 /*********************************************************************
3182  *                  strcmp (MSVCRT.@)
3183  */
3184 int __cdecl strcmp(const char *str1, const char *str2)
3185 {
3186     while (*str1 && *str1 == *str2) { str1++; str2++; }
3187     if ((unsigned char)*str1 > (unsigned char)*str2) return 1;
3188     if ((unsigned char)*str1 < (unsigned char)*str2) return -1;
3189     return 0;
3190 }
3191
3192 /*********************************************************************
3193  *                  strncmp   (MSVCRT.@)
3194  */
3195 int __cdecl strncmp(const char *str1, const char *str2, size_t len)
3196 {
3197     if (!len) return 0;
3198     while (--len && *str1 && *str1 == *str2) { str1++; str2++; }
3199     return (unsigned char)*str1 - (unsigned char)*str2;
3200 }
3201
3202 /*********************************************************************
3203  *                  _strnicmp_l   (MSVCRT.@)
3204  */
3205 int __cdecl _strnicmp_l(const char *s1, const char *s2,
3206         size_t count, _locale_t locale)
3207 {
3208     pthreadlocinfo locinfo;
3209     int c1, c2;
3210
3211     if(s1==NULL || s2==NULL)
3212         return _NLSCMPERROR;
3213
3214     if(!count)
3215         return 0;
3216
3217     if(!locale)
3218         locinfo = get_locinfo();
3219     else
3220         locinfo = locale->locinfo;
3221
3222     if(!locinfo->lc_handle[LC_CTYPE])
3223     {
3224         do {
3225             if ((c1 = *s1++) >= 'A' && c1 <= 'Z')
3226                 c1 -= 'A' - 'a';
3227             if ((c2 = *s2++) >= 'A' && c2 <= 'Z')
3228                 c2 -= 'A' - 'a';
3229         }while(--count && c1 && c1==c2);
3230
3231         return c1-c2;
3232     }
3233
3234     do {
3235         c1 = _tolower_l((unsigned char)*s1++, locale);
3236         c2 = _tolower_l((unsigned char)*s2++, locale);
3237     }while(--count && c1 && c1==c2);
3238
3239     return c1-c2;
3240 }
3241
3242 /*********************************************************************
3243  *                  _stricmp_l   (MSVCRT.@)
3244  */
3245 int __cdecl _stricmp_l(const char *s1, const char *s2, _locale_t locale)
3246 {
3247     return _strnicmp_l(s1, s2, -1, locale);
3248 }
3249
3250 /*********************************************************************
3251  *                  _strnicmp   (MSVCRT.@)
3252  */
3253 int __cdecl _strnicmp(const char *s1, const char *s2, size_t count)
3254 {
3255     return _strnicmp_l(s1, s2, count, NULL);
3256 }
3257
3258 /*********************************************************************
3259  *                  _stricmp   (MSVCRT.@)
3260  */
3261 int __cdecl _stricmp(const char *s1, const char *s2)
3262 {
3263     return _strnicmp_l(s1, s2, -1, NULL);
3264 }
3265
3266 /*********************************************************************
3267  *                  strstr   (MSVCRT.@)
3268  */
3269 char* __cdecl strstr(const char *haystack, const char *needle)
3270 {
3271     size_t i, j, len, needle_len, lps_len;
3272     BYTE lps[256];
3273
3274     needle_len = strlen(needle);
3275     if (!needle_len) return (char*)haystack;
3276     lps_len = needle_len > ARRAY_SIZE(lps) ? ARRAY_SIZE(lps) : needle_len;
3277
3278     lps[0] = 0;
3279     len = 0;
3280     i = 1;
3281     while (i < lps_len)
3282     {
3283         if (needle[i] == needle[len]) lps[i++] = ++len;
3284         else if (len) len = lps[len-1];
3285         else lps[i++] = 0;
3286     }
3287
3288     i = j = 0;
3289     while (haystack[i])
3290     {
3291         while (j < lps_len && haystack[i] && haystack[i] == needle[j])
3292         {
3293             i++;
3294             j++;
3295         }
3296
3297         if (j == needle_len) return (char*)haystack + i - j;
3298         else if (j)
3299         {
3300             if (j == ARRAY_SIZE(lps) && !strncmp(haystack + i, needle + j, needle_len - j))
3301                 return (char*)haystack + i - j;
3302             j = lps[j-1];
3303         }
3304         else if (haystack[i]) i++;
3305     }
3306     return NULL;
3307 }
3308
3309 /*********************************************************************
3310  *                  _memicmp_l   (MSVCRT.@)
3311  */
3312 int __cdecl _memicmp_l(const void *v1, const void *v2, size_t len, _locale_t locale)
3313 {
3314     const char *s1 = v1, *s2 = v2;
3315     int ret = 0;
3316
3317 #if _MSVCR_VER == 0 || _MSVCR_VER >= 80
3318     if (!s1 || !s2)
3319     {
3320         if (len)
3321             MSVCRT_INVALID_PMT(NULL, EINVAL);
3322         return len ? _NLSCMPERROR : 0;
3323     }
3324 #endif
3325
3326     while (len--)
3327     {
3328         if ((ret = _tolower_l(*s1, locale) - _tolower_l(*s2, locale)))
3329             break;
3330         s1++;
3331         s2++;
3332     }
3333     return ret;
3334 }
3335
3336 /*********************************************************************
3337  *                  _memicmp   (MSVCRT.@)
3338  */
3339 int __cdecl _memicmp(const void *s1, const void *s2, size_t len)
3340 {
3341     return _memicmp_l(s1, s2, len, NULL);
3342 }
3343
3344 /*********************************************************************
3345  *                  strcspn   (MSVCRT.@)
3346  */
3347 size_t __cdecl strcspn(const char *str, const char *reject)
3348 {
3349     BOOL rejects[256];
3350     const char *p;
3351
3352     memset(rejects, 0, sizeof(rejects));
3353
3354     p = reject;
3355     while(*p)
3356     {
3357         rejects[(unsigned char)*p] = TRUE;
3358         p++;
3359     }
3360
3361     p = str;
3362     while(*p && !rejects[(unsigned char)*p]) p++;
3363     return p - str;
3364 }
3365
3366 /*********************************************************************
3367  *                  strspn   (MSVCRT.@)
3368  */
3369 size_t __cdecl strspn(const char *str, const char *accept)
3370 {
3371     const char *ptr;
3372     for (ptr = str; *ptr; ptr++) if (!strchr( accept, *ptr )) break;
3373     return ptr - str;
3374 }
3375
3376 /*********************************************************************
3377  *                  strpbrk   (MSVCRT.@)
3378  */
3379 char* __cdecl strpbrk(const char *str, const char *accept)
3380 {
3381     for (; *str; str++) if (strchr( accept, *str )) return (char*)str;
3382     return NULL;
3383 }
3384
3385 /*********************************************************************
3386  *                  __strncnt   (MSVCRT.@)
3387  */
3388 size_t __cdecl __strncnt(const char *str, size_t size)
3389 {
3390     size_t ret = 0;
3391
3392 #if _MSVCR_VER >= 140
3393     while (*str++ && size--)
3394 #else
3395     while (size-- && *str++)
3396 #endif
3397     {
3398         ret++;
3399     }
3400
3401     return ret;
3402 }
3403
3404
3405 #ifdef _CRTDLL
3406 /*********************************************************************
3407  *              _strdec (CRTDLL.@)
3408  */
3409 char * CDECL _strdec(const char *str1, const char *str2)
3410 {
3411     return (char *)(str2 - 1);
3412 }
3413
3414 /*********************************************************************
3415  *              _strinc (CRTDLL.@)
3416  */
3417 char * CDECL _strinc(const char *str)
3418 {
3419     return (char *)(str + 1);
3420 }
3421
3422 /*********************************************************************
3423  *              _strnextc (CRTDLL.@)
3424  */
3425 unsigned int CDECL _strnextc(const char *str)
3426 {
3427     return (unsigned char)str[0];
3428 }
3429
3430 /*********************************************************************
3431  *              _strninc (CRTDLL.@)
3432  */
3433 char * CDECL _strninc(const char *str, size_t len)
3434 {
3435     return (char *)(str + len);
3436 }
3437
3438 /*********************************************************************
3439  *              _strspnp (CRTDLL.@)
3440  */
3441 char * CDECL _strspnp( const char *str1, const char *str2)
3442 {
3443     str1 += strspn( str1, str2 );
3444     return *str1 ? (char*)str1 : NULL;
3445 }
3446 #endif