dlls/msvcrt/string.c

   1 /*
   2  * MSVCRT string functions
   3  *
   4  * Copyright 1996,1998 Marcus Meissner
   5  * Copyright 1996 Jukka Iivonen
   6  * Copyright 1997,2000 Uwe Bonnes
   7  * Copyright 2000 Jon Griffiths
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #define _ISOC99_SOURCE
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <math.h>
  31 #include <limits.h>
  32 #include <errno.h>
  33 #include "msvcrt.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  37
  38 /*********************************************************************
  39  *              _mbsdup (MSVCRT.@)
  40  *              _strdup (MSVCRT.@)
  41  */
  42 char* CDECL _strdup(const char* str)
  43 {
  44     if(str)
  45     {
  46       char * ret = MSVCRT_malloc(strlen(str)+1);
  47       if (ret) strcpy( ret, str );
  48       return ret;
  49     }
  50     else return 0;
  51 }
  52
  53 /*********************************************************************
  54  *              _strlwr_s (MSVCRT.@)
  55  */
  56 int CDECL _strlwr_s(char *str, MSVCRT_size_t len)
  57 {
  58     char *ptr = str;
  59
  60     if (!str || !len)
  61     {
  62         *MSVCRT__errno() = MSVCRT_EINVAL;
  63         return MSVCRT_EINVAL;
  64     }
  65
  66     while (len && *ptr)
  67     {
  68         len--;
  69         ptr++;
  70     }
  71
  72     if (!len)
  73     {
  74         str[0] = '\0';
  75         *MSVCRT__errno() = MSVCRT_EINVAL;
  76         return MSVCRT_EINVAL;
  77     }
  78
  79     while (*str)
  80     {
  81         *str = tolower(*str);
  82         str++;
  83     }
  84
  85     return 0;
  86 }
  87
  88 /*********************************************************************
  89  *              _strnset (MSVCRT.@)
  90  */
  91 char* CDECL MSVCRT__strnset(char* str, int value, MSVCRT_size_t len)
  92 {
  93   if (len > 0 && str)
  94     while (*str && len--)
  95       *str++ = value;
  96   return str;
  97 }
  98
  99 /*********************************************************************
 100  *              _strrev (MSVCRT.@)
 101  */
 102 char* CDECL _strrev(char* str)
 103 {
 104   char * p1;
 105   char * p2;
 106
 107   if (str && *str)
 108     for (p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2)
 109     {
 110       *p1 ^= *p2;
 111       *p2 ^= *p1;
 112       *p1 ^= *p2;
 113     }
 114
 115   return str;
 116 }
 117
 118 /*********************************************************************
 119  *              _strset (MSVCRT.@)
 120  */
 121 char* CDECL _strset(char* str, int value)
 122 {
 123   char *ptr = str;
 124   while (*ptr)
 125     *ptr++ = value;
 126
 127   return str;
 128 }
 129
 130 /*********************************************************************
 131  *              strtok  (MSVCRT.@)
 132  */
 133 char * CDECL MSVCRT_strtok( char *str, const char *delim )
 134 {
 135     thread_data_t *data = msvcrt_get_thread_data();
 136     char *ret;
 137
 138     if (!str)
 139         if (!(str = data->strtok_next)) return NULL;
 140
 141     while (*str && strchr( delim, *str )) str++;
 142     if (!*str) return NULL;
 143     ret = str++;
 144     while (*str && !strchr( delim, *str )) str++;
 145     if (*str) *str++ = 0;
 146     data->strtok_next = str;
 147     return ret;
 148 }
 149
 150 /*********************************************************************
 151  *              strtok_s  (MSVCRT.@)
 152  */
 153 char * CDECL MSVCRT_strtok_s(char *str, const char *delim, char **ctx)
 154 {
 155     if (!MSVCRT_CHECK_PMT(delim != NULL) || !MSVCRT_CHECK_PMT(ctx != NULL) ||
 156         !MSVCRT_CHECK_PMT(str != NULL || *ctx != NULL)) {
 157         *MSVCRT__errno() = MSVCRT_EINVAL;
 158         return NULL;
 159     }
 160
 161     if(!str)
 162         str = *ctx;
 163
 164     while(*str && strchr(delim, *str))
 165         str++;
 166     if(!*str)
 167         return NULL;
 168
 169     *ctx = str+1;
 170     while(**ctx && !strchr(delim, **ctx))
 171         (*ctx)++;
 172     if(**ctx)
 173         *(*ctx)++ = 0;
 174
 175     return str;
 176 }
 177
 178 /*********************************************************************
 179  *              _swab (MSVCRT.@)
 180  */
 181 void CDECL MSVCRT__swab(char* src, char* dst, int len)
 182 {
 183   if (len > 1)
 184   {
 185     len = (unsigned)len >> 1;
 186
 187     while (len--) {
 188       char s0 = src[0];
 189       char s1 = src[1];
 190       *dst++ = s1;
 191       *dst++ = s0;
 192       src = src + 2;
 193     }
 194   }
 195 }
 196
 197 /*********************************************************************
 198  *              strtod_l  (MSVCRT.@)
 199  */
 200 double CDECL MSVCRT_strtod_l( const char *str, char **end, MSVCRT__locale_t locale)
 201 {
 202     unsigned __int64 d=0, hlp;
 203     unsigned fpcontrol;
 204     int exp=0, sign=1;
 205     const char *p;
 206     double ret;
 207     BOOL found_digit = FALSE;
 208
 209     if (!MSVCRT_CHECK_PMT(str != NULL)) {
 210         *MSVCRT__errno() = MSVCRT_EINVAL;
 211         return 0;
 212     }
 213
 214     if(!locale)
 215         locale = get_locale();
 216
 217     /* FIXME: use *_l functions */
 218     p = str;
 219     while(isspace(*p))
 220         p++;
 221
 222     if(*p == '-') {
 223         sign = -1;
 224         p++;
 225     } else  if(*p == '+')
 226         p++;
 227
 228     while(isdigit(*p)) {
 229         found_digit = TRUE;
 230         hlp = d*10+*(p++)-'0';
 231         if(d>MSVCRT_UI64_MAX/10 || hlp<d) {
 232             exp++;
 233             break;
 234         } else
 235             d = hlp;
 236     }
 237     while(isdigit(*p)) {
 238         exp++;
 239         p++;
 240     }
 241
 242     if(*p == *locale->locinfo->lconv->decimal_point)
 243         p++;
 244
 245     while(isdigit(*p)) {
 246         found_digit = TRUE;
 247         hlp = d*10+*(p++)-'0';
 248         if(d>MSVCRT_UI64_MAX/10 || hlp<d)
 249             break;
 250
 251         d = hlp;
 252         exp--;
 253     }
 254     while(isdigit(*p))
 255         p++;
 256
 257     if(!found_digit) {
 258         if(end)
 259             *end = (char*)str;
 260         return 0.0;
 261     }
 262
 263     if(*p=='e' || *p=='E' || *p=='d' || *p=='D') {
 264         int e=0, s=1;
 265
 266         p++;
 267         if(*p == '-') {
 268             s = -1;
 269             p++;
 270         } else if(*p == '+')
 271             p++;
 272
 273         if(isdigit(*p)) {
 274             while(isdigit(*p)) {
 275                 if(e>INT_MAX/10 || (e=e*10+*p-'0')<0)
 276                     e = INT_MAX;
 277                 p++;
 278             }
 279             e *= s;
 280
 281             if(exp<0 && e<0 && exp+e>=0) exp = INT_MIN;
 282             else if(exp>0 && e>0 && exp+e<0) exp = INT_MAX;
 283             else exp += e;
 284         } else {
 285             if(*p=='-' || *p=='+')
 286                 p--;
 287             p--;
 288         }
 289     }
 290
 291     fpcontrol = _control87(0, 0);
 292     _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE
 293             |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff);
 294
 295     if(exp>0)
 296         ret = (double)sign*d*pow(10, exp);
 297     else
 298         ret = (double)sign*d/pow(10, -exp);
 299
 300     _control87(fpcontrol, 0xffffffff);
 301
 302     if((d && ret==0.0) || isinf(ret))
 303         *MSVCRT__errno() = MSVCRT_ERANGE;
 304
 305     if(end)
 306         *end = (char*)p;
 307
 308     return ret;
 309 }
 310
 311 /*********************************************************************
 312  *              strtod  (MSVCRT.@)
 313  */
 314 double CDECL MSVCRT_strtod( const char *str, char **end )
 315 {
 316     return MSVCRT_strtod_l( str, end, NULL );
 317 }
 318
 319 /*********************************************************************
 320  *              atof  (MSVCRT.@)
 321  */
 322 double CDECL MSVCRT_atof( const char *str )
 323 {
 324     return MSVCRT_strtod_l(str, NULL, NULL);
 325 }
 326
 327 /*********************************************************************
 328  *              _atof_l  (MSVCRT.@)
 329  */
 330 double CDECL MSVCRT__atof_l( const char *str, MSVCRT__locale_t locale)
 331 {
 332     return MSVCRT_strtod_l(str, NULL, locale);
 333 }
 334
 335 /*********************************************************************
 336  *              _atoflt_l  (MSVCRT.@)
 337  */
 338 int CDECL MSVCRT__atoflt_l( MSVCRT__CRT_FLOAT *value, char *str, MSVCRT__locale_t locale)
 339 {
 340     unsigned __int64 d=0, hlp;
 341     unsigned fpcontrol;
 342     int exp=0, sign=1;
 343     const char *p;
 344     int ret=0;
 345     BOOL found_digit = FALSE;
 346
 347     if(!locale)
 348         locale = get_locale();
 349
 350     /* FIXME: use *_l functions */
 351     p = str;
 352     while(isspace(*p))
 353         p++;
 354
 355     if(*p == '-') {
 356         sign = -1;
 357         p++;
 358     } else if(*p == '+')
 359         p++;
 360
 361     while(isdigit(*p)) {
 362         found_digit = TRUE;
 363         hlp = d*10+*(p++)-'0';
 364         if(d>MSVCRT_UI64_MAX/10 || hlp<d) {
 365             exp++;
 366             break;
 367         } else
 368             d = hlp;
 369     }
 370     while(isdigit(*p)) {
 371         exp++;
 372         p++;
 373     }
 374
 375     if(*p == *locale->locinfo->lconv->decimal_point)
 376         p++;
 377
 378     while(isdigit(*p)) {
 379         found_digit = TRUE;
 380         hlp = d*10+*(p++)-'0';
 381         if(d>MSVCRT_UI64_MAX/10 || hlp<d)
 382             break;
 383
 384         d = hlp;
 385         exp--;
 386     }
 387     while(isdigit(*p))
 388         p++;
 389
 390     if(!found_digit) {
 391         value->f = 0.0;
 392         return 0;
 393     }
 394
 395     if(*p=='e' || *p=='E' || *p=='d' || *p=='D') {
 396         int e=0, s=1;
 397
 398         p++;
 399         if(*p == '-') {
 400             s = -1;
 401             p++;
 402         } else if(*p == '+')
 403             p++;
 404
 405         if(isdigit(*p)) {
 406             while(isdigit(*p)) {
 407                 if(e>INT_MAX/10 || (e=e*10+*p-'0')<0)
 408                     e = INT_MAX;
 409                 p++;
 410             }
 411             e *= s;
 412
 413             if(exp<0 && e<0 && exp+e>=0) exp = INT_MIN;
 414             else if(exp>0 && e>0 && exp+e<0) exp = INT_MAX;
 415             else exp += e;
 416         } else {
 417             if(*p=='-' || *p=='+')
 418                 p--;
 419             p--;
 420         }
 421     }
 422
 423     fpcontrol = _control87(0, 0);
 424     _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE
 425             |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff);
 426
 427     if(exp>0)
 428         value->f = (float)sign*d*powf(10, exp);
 429     else
 430         value->f = (float)sign*d/powf(10, -exp);
 431
 432     _control87(fpcontrol, 0xffffffff);
 433
 434     if((d && value->f==0.0) || isinf(value->f))
 435         ret = exp > 0 ? MSVCRT__OVERFLOW : MSVCRT__UNDERFLOW;
 436
 437     return ret;
 438 }
 439
 440 /*********************************************************************
 441  *              strcoll (MSVCRT.@)
 442  */
 443 int CDECL MSVCRT_strcoll( const char* str1, const char* str2 )
 444 {
 445     /* FIXME: handle Windows locale */
 446     return strcoll( str1, str2 );
 447 }
 448
 449 /*********************************************************************
 450  *      strcpy_s (MSVCRT.@)
 451  */
 452 int CDECL MSVCRT_strcpy_s( char* dst, MSVCRT_size_t elem, const char* src )
 453 {
 454     MSVCRT_size_t i;
 455     if(!elem) return MSVCRT_EINVAL;
 456     if(!dst) return MSVCRT_EINVAL;
 457     if(!src)
 458     {
 459         dst[0] = '\0';
 460         return MSVCRT_EINVAL;
 461     }
 462
 463     for(i = 0; i < elem; i++)
 464     {
 465         if((dst[i] = src[i]) == '\0') return 0;
 466     }
 467     dst[0] = '\0';
 468     return MSVCRT_ERANGE;
 469 }
 470
 471 /*********************************************************************
 472  *      strcat_s (MSVCRT.@)
 473  */
 474 int CDECL MSVCRT_strcat_s( char* dst, MSVCRT_size_t elem, const char* src )
 475 {
 476     MSVCRT_size_t i, j;
 477     if(!dst) return MSVCRT_EINVAL;
 478     if(elem == 0) return MSVCRT_EINVAL;
 479     if(!src)
 480     {
 481         dst[0] = '\0';
 482         return MSVCRT_EINVAL;
 483     }
 484
 485     for(i = 0; i < elem; i++)
 486     {
 487         if(dst[i] == '\0')
 488         {
 489             for(j = 0; (j + i) < elem; j++)
 490             {
 491                 if((dst[j + i] = src[j]) == '\0') return 0;
 492             }
 493         }
 494     }
 495     /* Set the first element to 0, not the first element after the skipped part */
 496     dst[0] = '\0';
 497     return MSVCRT_ERANGE;
 498 }
 499
 500 /*********************************************************************
 501  *      strncat_s (MSVCRT.@)
 502  */
 503 int CDECL MSVCRT_strncat_s( char* dst, MSVCRT_size_t elem, const char* src, MSVCRT_size_t count )
 504 {
 505     MSVCRT_size_t i, j;
 506     if(!MSVCRT_CHECK_PMT(dst != 0) || !MSVCRT_CHECK_PMT(elem != 0))
 507         return MSVCRT_EINVAL;
 508     if(!MSVCRT_CHECK_PMT(src != 0))
 509     {
 510         dst[0] = '\0';
 511         return MSVCRT_EINVAL;
 512     }
 513
 514     for(i = 0; i < elem; i++)
 515     {
 516         if(dst[i] == '\0')
 517         {
 518             for(j = 0; (j + i) < elem; j++)
 519             {
 520                 if(count == MSVCRT__TRUNCATE && j + i == elem - 1)
 521                 {
 522                     dst[j + i] = '\0';
 523                     return MSVCRT_STRUNCATE;
 524                 }
 525                 if(j == count || (dst[j + i] = src[j]) == '\0')
 526                 {
 527                     dst[j + i] = '\0';
 528                     return 0;
 529                 }
 530             }
 531         }
 532     }
 533     /* Set the first element to 0, not the first element after the skipped part */
 534     dst[0] = '\0';
 535     return MSVCRT_ERANGE;
 536 }
 537
 538 /*********************************************************************
 539  *              strxfrm (MSVCRT.@)
 540  */
 541 MSVCRT_size_t CDECL MSVCRT_strxfrm( char *dest, const char *src, MSVCRT_size_t len )
 542 {
 543     /* FIXME: handle Windows locale */
 544     return strxfrm( dest, src, len );
 545 }
 546
 547 /*********************************************************************
 548  *              _stricoll (MSVCRT.@)
 549  */
 550 int CDECL MSVCRT__stricoll( const char* str1, const char* str2 )
 551 {
 552   /* FIXME: handle collates */
 553   TRACE("str1 %s str2 %s\n", debugstr_a(str1), debugstr_a(str2));
 554   return lstrcmpiA( str1, str2 );
 555 }
 556
 557 /********************************************************************
 558  *              _atoldbl (MSVCRT.@)
 559  */
 560 int CDECL MSVCRT__atoldbl(MSVCRT__LDOUBLE *value, const char *str)
 561 {
 562   /* FIXME needs error checking for huge/small values */
 563 #ifdef HAVE_STRTOLD
 564   TRACE("str %s value %p\n",str,value);
 565   value->x = strtold(str,0);
 566 #else
 567   FIXME("stub, str %s value %p\n",str,value);
 568 #endif
 569   return 0;
 570 }
 571
 572 /********************************************************************
 573  *              __STRINGTOLD (MSVCRT.@)
 574  */
 575 int CDECL __STRINGTOLD( MSVCRT__LDOUBLE *value, char **endptr, const char *str, int flags )
 576 {
 577 #ifdef HAVE_STRTOLD
 578     FIXME("%p %p %s %x partial stub\n", value, endptr, str, flags );
 579     value->x = strtold(str,endptr);
 580 #else
 581     FIXME("%p %p %s %x stub\n", value, endptr, str, flags );
 582 #endif
 583     return 0;
 584 }
 585
 586 /******************************************************************
 587  *              strtol (MSVCRT.@)
 588  */
 589 MSVCRT_long CDECL MSVCRT_strtol(const char* nptr, char** end, int base)
 590 {
 591     /* wrapper to forward libc error code to msvcrt's error codes */
 592     long ret;
 593
 594     errno = 0;
 595     ret = strtol(nptr, end, base);
 596     switch (errno)
 597     {
 598     case ERANGE:        *MSVCRT__errno() = MSVCRT_ERANGE;       break;
 599     case EINVAL:        *MSVCRT__errno() = MSVCRT_EINVAL;       break;
 600     default:
 601         /* cope with the fact that we may use 64bit long integers on libc
 602          * while msvcrt always uses 32bit long integers
 603          */
 604         if (ret > MSVCRT_LONG_MAX)
 605         {
 606             ret = MSVCRT_LONG_MAX;
 607             *MSVCRT__errno() = MSVCRT_ERANGE;
 608         }
 609         else if (ret < -MSVCRT_LONG_MAX - 1)
 610         {
 611             ret = -MSVCRT_LONG_MAX - 1;
 612             *MSVCRT__errno() = MSVCRT_ERANGE;
 613         }
 614         break;
 615     }
 616
 617     return ret;
 618 }
 619
 620 /******************************************************************
 621  *              strtoul (MSVCRT.@)
 622  */
 623 MSVCRT_ulong CDECL MSVCRT_strtoul(const char* nptr, char** end, int base)
 624 {
 625     /* wrapper to forward libc error code to msvcrt's error codes */
 626     unsigned long ret;
 627
 628     errno = 0;
 629     ret = strtoul(nptr, end, base);
 630     switch (errno)
 631     {
 632     case ERANGE:        *MSVCRT__errno() = MSVCRT_ERANGE;       break;
 633     case EINVAL:        *MSVCRT__errno() = MSVCRT_EINVAL;       break;
 634     default:
 635         /* cope with the fact that we may use 64bit long integers on libc
 636          * while msvcrt always uses 32bit long integers
 637          */
 638         if (ret > MSVCRT_ULONG_MAX)
 639         {
 640             ret = MSVCRT_ULONG_MAX;
 641             *MSVCRT__errno() = MSVCRT_ERANGE;
 642         }
 643         break;
 644     }
 645
 646     return ret;
 647 }
 648
 649 /******************************************************************
 650  *              strnlen (MSVCRT.@)
 651  */
 652 MSVCRT_size_t CDECL MSVCRT_strnlen(const char *s, MSVCRT_size_t maxlen)
 653 {
 654     MSVCRT_size_t i;
 655
 656     for(i=0; i<maxlen; i++)
 657         if(!s[i]) break;
 658
 659     return i;
 660 }
 661
 662 /*********************************************************************
 663  *  _strtoi64_l (MSVCRT.@)
 664  *
 665  * FIXME: locale parameter is ignored
 666  */
 667 __int64 CDECL MSVCRT_strtoi64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
 668 {
 669     BOOL negative = FALSE;
 670     __int64 ret = 0;
 671
 672     TRACE("(%s %p %d %p)\n", nptr, endptr, base, locale);
 673
 674     if (!MSVCRT_CHECK_PMT(nptr != NULL) || !MSVCRT_CHECK_PMT(base == 0 || base >= 2) ||
 675         !MSVCRT_CHECK_PMT(base <= 36)) {
 676         return 0;
 677     }
 678
 679     while(isspace(*nptr)) nptr++;
 680
 681     if(*nptr == '-') {
 682         negative = TRUE;
 683         nptr++;
 684     } else if(*nptr == '+')
 685         nptr++;
 686
 687     if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') {
 688         base = 16;
 689         nptr += 2;
 690     }
 691
 692     if(base == 0) {
 693         if(*nptr=='0')
 694             base = 8;
 695         else
 696             base = 10;
 697     }
 698
 699     while(*nptr) {
 700         char cur = tolower(*nptr);
 701         int v;
 702
 703         if(isdigit(cur)) {
 704             if(cur >= '0'+base)
 705                 break;
 706             v = cur-'0';
 707         } else {
 708             if(cur<'a' || cur>='a'+base-10)
 709                 break;
 710             v = cur-'a'+10;
 711         }
 712
 713         if(negative)
 714             v = -v;
 715
 716         nptr++;
 717
 718         if(!negative && (ret>MSVCRT_I64_MAX/base || ret*base>MSVCRT_I64_MAX-v)) {
 719             ret = MSVCRT_I64_MAX;
 720             *MSVCRT__errno() = MSVCRT_ERANGE;
 721         } else if(negative && (ret<MSVCRT_I64_MIN/base || ret*base<MSVCRT_I64_MIN-v)) {
 722             ret = MSVCRT_I64_MIN;
 723             *MSVCRT__errno() = MSVCRT_ERANGE;
 724         } else
 725             ret = ret*base + v;
 726     }
 727
 728     if(endptr)
 729         *endptr = (char*)nptr;
 730
 731     return ret;
 732 }
 733
 734 /*********************************************************************
 735  *  _strtoi64 (MSVCRT.@)
 736  */
 737 __int64 CDECL MSVCRT_strtoi64(const char *nptr, char **endptr, int base)
 738 {
 739     return MSVCRT_strtoi64_l(nptr, endptr, base, NULL);
 740 }
 741
 742 /*********************************************************************
 743  *  _strtoui64_l (MSVCRT.@)
 744  *
 745  * FIXME: locale parameter is ignored
 746  */
 747 unsigned __int64 CDECL MSVCRT_strtoui64_l(const char *nptr, char **endptr, int base, MSVCRT__locale_t locale)
 748 {
 749     BOOL negative = FALSE;
 750     unsigned __int64 ret = 0;
 751
 752     TRACE("(%s %p %d %p)\n", nptr, endptr, base, locale);
 753
 754     if (!MSVCRT_CHECK_PMT(nptr != NULL) || !MSVCRT_CHECK_PMT(base == 0 || base >= 2) ||
 755         !MSVCRT_CHECK_PMT(base <= 36)) {
 756         return 0;
 757     }
 758
 759     while(isspace(*nptr)) nptr++;
 760
 761     if(*nptr == '-') {
 762         negative = TRUE;
 763         nptr++;
 764     } else if(*nptr == '+')
 765         nptr++;
 766
 767     if((base==0 || base==16) && *nptr=='0' && tolower(*(nptr+1))=='x') {
 768         base = 16;
 769         nptr += 2;
 770     }
 771
 772     if(base == 0) {
 773         if(*nptr=='0')
 774             base = 8;
 775         else
 776             base = 10;
 777     }
 778
 779     while(*nptr) {
 780         char cur = tolower(*nptr);
 781         int v;
 782
 783         if(isdigit(cur)) {
 784             if(cur >= '0'+base)
 785                 break;
 786             v = *nptr-'0';
 787         } else {
 788             if(cur<'a' || cur>='a'+base-10)
 789                 break;
 790             v = cur-'a'+10;
 791         }
 792
 793         nptr++;
 794
 795         if(ret>MSVCRT_UI64_MAX/base || ret*base>MSVCRT_UI64_MAX-v) {
 796             ret = MSVCRT_UI64_MAX;
 797             *MSVCRT__errno() = MSVCRT_ERANGE;
 798         } else
 799             ret = ret*base + v;
 800     }
 801
 802     if(endptr)
 803         *endptr = (char*)nptr;
 804
 805     return negative ? -ret : ret;
 806 }
 807
 808 /*********************************************************************
 809  *  _strtoui64 (MSVCRT.@)
 810  */
 811 unsigned __int64 CDECL MSVCRT_strtoui64(const char *nptr, char **endptr, int base)
 812 {
 813     return MSVCRT_strtoui64_l(nptr, endptr, base, NULL);
 814 }
 815
 816 /*********************************************************************
 817  *  _ltoa_s (MSVCRT.@)
 818  */
 819 int CDECL _ltoa_s(MSVCRT_long value, char *str, MSVCRT_size_t size, int radix)
 820 {
 821     MSVCRT_ulong val;
 822     unsigned int digit;
 823     int is_negative;
 824     char buffer[33], *pos;
 825     size_t len;
 826
 827     if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) ||
 828         !MSVCRT_CHECK_PMT(radix >= 2) || !MSVCRT_CHECK_PMT(radix <= 36))
 829     {
 830         if (str && size)
 831             str[0] = '\0';
 832
 833         *MSVCRT__errno() = MSVCRT_EINVAL;
 834         return MSVCRT_EINVAL;
 835     }
 836
 837     if (value < 0 && radix == 10)
 838     {
 839         is_negative = 1;
 840         val = -value;
 841     }
 842     else
 843     {
 844         is_negative = 0;
 845         val = value;
 846     }
 847
 848     pos = buffer + 32;
 849     *pos = '\0';
 850
 851     do
 852     {
 853         digit = val % radix;
 854         val /= radix;
 855
 856         if (digit < 10)
 857             *--pos = '0' + digit;
 858         else
 859             *--pos = 'a' + digit - 10;
 860     }
 861     while (val != 0);
 862
 863     if (is_negative)
 864         *--pos = '-';
 865
 866     len = buffer + 33 - pos;
 867     if (len > size)
 868     {
 869         size_t i;
 870         char *p = str;
 871
 872         /* Copy the temporary buffer backwards up to the available number of
 873          * characters. Don't copy the negative sign if present. */
 874
 875         if (is_negative)
 876         {
 877             p++;
 878             size--;
 879         }
 880
 881         for (pos = buffer + 31, i = 0; i < size; i++)
 882             *p++ = *pos--;
 883
 884         str[0] = '\0';
 885         MSVCRT_INVALID_PMT("str[size] is too small");
 886         *MSVCRT__errno() = MSVCRT_ERANGE;
 887         return MSVCRT_ERANGE;
 888     }
 889
 890     memcpy(str, pos, len);
 891     return 0;
 892 }
 893
 894 /*********************************************************************
 895  *  _ltow_s (MSVCRT.@)
 896  */
 897 int CDECL _ltow_s(MSVCRT_long value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
 898 {
 899     MSVCRT_ulong val;
 900     unsigned int digit;
 901     int is_negative;
 902     MSVCRT_wchar_t buffer[33], *pos;
 903     size_t len;
 904
 905     if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) ||
 906         !MSVCRT_CHECK_PMT(radix >= 2) || !MSVCRT_CHECK_PMT(radix <= 36))
 907     {
 908         if (str && size)
 909             str[0] = '\0';
 910
 911         *MSVCRT__errno() = MSVCRT_EINVAL;
 912         return MSVCRT_EINVAL;
 913     }
 914
 915     if (value < 0 && radix == 10)
 916     {
 917         is_negative = 1;
 918         val = -value;
 919     }
 920     else
 921     {
 922         is_negative = 0;
 923         val = value;
 924     }
 925
 926     pos = buffer + 32;
 927     *pos = '\0';
 928
 929     do
 930     {
 931         digit = val % radix;
 932         val /= radix;
 933
 934         if (digit < 10)
 935             *--pos = '0' + digit;
 936         else
 937             *--pos = 'a' + digit - 10;
 938     }
 939     while (val != 0);
 940
 941     if (is_negative)
 942         *--pos = '-';
 943
 944     len = buffer + 33 - pos;
 945     if (len > size)
 946     {
 947         size_t i;
 948         MSVCRT_wchar_t *p = str;
 949
 950         /* Copy the temporary buffer backwards up to the available number of
 951          * characters. Don't copy the negative sign if present. */
 952
 953         if (is_negative)
 954         {
 955             p++;
 956             size--;
 957         }
 958
 959         for (pos = buffer + 31, i = 0; i < size; i++)
 960             *p++ = *pos--;
 961
 962         MSVCRT_INVALID_PMT("str[size] is too small");
 963         str[0] = '\0';
 964         *MSVCRT__errno() = MSVCRT_ERANGE;
 965         return MSVCRT_ERANGE;
 966     }
 967
 968     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
 969     return 0;
 970 }
 971
 972 /*********************************************************************
 973  *  _itoa_s (MSVCRT.@)
 974  */
 975 int CDECL _itoa_s(int value, char *str, MSVCRT_size_t size, int radix)
 976 {
 977     return _ltoa_s(value, str, size, radix);
 978 }
 979
 980 /*********************************************************************
 981  *  _itow_s (MSVCRT.@)
 982  */
 983 int CDECL _itow_s(int value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
 984 {
 985     return _ltow_s(value, str, size, radix);
 986 }
 987
 988 /*********************************************************************
 989  *  _ui64toa_s (MSVCRT.@)
 990  */
 991 int CDECL MSVCRT__ui64toa_s(unsigned __int64 value, char *str,
 992         MSVCRT_size_t size, int radix)
 993 {
 994     char buffer[65], *pos;
 995     int digit;
 996
 997     if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) ||
 998         !MSVCRT_CHECK_PMT(radix>=2) || !MSVCRT_CHECK_PMT(radix<=36)) {
 999         *MSVCRT__errno() = MSVCRT_EINVAL;
1000         return MSVCRT_EINVAL;
1001     }
1002
1003     pos = buffer+64;
1004     *pos = '\0';
1005
1006     do {
1007         digit = value%radix;
1008         value /= radix;
1009
1010         if(digit < 10)
1011             *--pos = '0'+digit;
1012         else
1013             *--pos = 'a'+digit-10;
1014     }while(value != 0);
1015
1016     if(buffer-pos+65 > size) {
1017         MSVCRT_INVALID_PMT("str[size] is too small");
1018         *MSVCRT__errno() = MSVCRT_EINVAL;
1019         return MSVCRT_EINVAL;
1020     }
1021
1022     memcpy(str, pos, buffer-pos+65);
1023     return 0;
1024 }
1025
1026 /*********************************************************************
1027  *      _ui64tow_s  (MSVCRT.@)
1028  */
1029 int CDECL MSVCRT__ui64tow_s( unsigned __int64 value, MSVCRT_wchar_t *str,
1030                              MSVCRT_size_t size, int radix )
1031 {
1032     MSVCRT_wchar_t buffer[65], *pos;
1033     int digit;
1034
1035     if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) ||
1036         !MSVCRT_CHECK_PMT(radix>=2) || !MSVCRT_CHECK_PMT(radix<=36)) {
1037         *MSVCRT__errno() = MSVCRT_EINVAL;
1038         return MSVCRT_EINVAL;
1039     }
1040
1041     pos = &buffer[64];
1042     *pos = '\0';
1043
1044     do {
1045         digit = value % radix;
1046         value = value / radix;
1047         if (digit < 10)
1048             *--pos = '0' + digit;
1049         else
1050             *--pos = 'a' + digit - 10;
1051     } while (value != 0);
1052
1053     if(buffer-pos+65 > size) {
1054         MSVCRT_INVALID_PMT("str[size] is too small");
1055         *MSVCRT__errno() = MSVCRT_EINVAL;
1056         return MSVCRT_EINVAL;
1057     }
1058
1059     memcpy(str, pos, buffer-pos+65);
1060     return 0;
1061 }
1062
1063 /*********************************************************************
1064  *  _ultoa_s (MSVCRT.@)
1065  */
1066 int CDECL _ultoa_s(MSVCRT_ulong value, char *str, MSVCRT_size_t size, int radix)
1067 {
1068     MSVCRT_ulong digit;
1069     char buffer[33], *pos;
1070     size_t len;
1071
1072     if (!str || !size || radix < 2 || radix > 36)
1073     {
1074         if (str && size)
1075             str[0] = '\0';
1076
1077         *MSVCRT__errno() = MSVCRT_EINVAL;
1078         return MSVCRT_EINVAL;
1079     }
1080
1081     pos = buffer + 32;
1082     *pos = '\0';
1083
1084     do
1085     {
1086         digit = value % radix;
1087         value /= radix;
1088
1089         if (digit < 10)
1090             *--pos = '0' + digit;
1091         else
1092             *--pos = 'a' + digit - 10;
1093     }
1094     while (value != 0);
1095
1096     len = buffer + 33 - pos;
1097     if (len > size)
1098     {
1099         size_t i;
1100         char *p = str;
1101
1102         /* Copy the temporary buffer backwards up to the available number of
1103          * characters. */
1104
1105         for (pos = buffer + 31, i = 0; i < size; i++)
1106             *p++ = *pos--;
1107
1108         str[0] = '\0';
1109         *MSVCRT__errno() = MSVCRT_ERANGE;
1110         return MSVCRT_ERANGE;
1111     }
1112
1113     memcpy(str, pos, len);
1114     return 0;
1115 }
1116
1117 /*********************************************************************
1118  *  _i64toa_s (MSVCRT.@)
1119  */
1120 int CDECL _i64toa_s(__int64 value, char *str, MSVCRT_size_t size, int radix)
1121 {
1122     unsigned __int64 val;
1123     unsigned int digit;
1124     int is_negative;
1125     char buffer[65], *pos;
1126     size_t len;
1127
1128     if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) ||
1129         !MSVCRT_CHECK_PMT(radix >= 2) || !MSVCRT_CHECK_PMT(radix <= 36))
1130     {
1131         if (str && size)
1132             str[0] = '\0';
1133
1134         *MSVCRT__errno() = MSVCRT_EINVAL;
1135         return MSVCRT_EINVAL;
1136     }
1137
1138     if (value < 0 && radix == 10)
1139     {
1140         is_negative = 1;
1141         val = -value;
1142     }
1143     else
1144     {
1145         is_negative = 0;
1146         val = value;
1147     }
1148
1149     pos = buffer + 64;
1150     *pos = '\0';
1151
1152     do
1153     {
1154         digit = val % radix;
1155         val /= radix;
1156
1157         if (digit < 10)
1158             *--pos = '0' + digit;
1159         else
1160             *--pos = 'a' + digit - 10;
1161     }
1162     while (val != 0);
1163
1164     if (is_negative)
1165         *--pos = '-';
1166
1167     len = buffer + 65 - pos;
1168     if (len > size)
1169     {
1170         size_t i;
1171         char *p = str;
1172
1173         /* Copy the temporary buffer backwards up to the available number of
1174          * characters. Don't copy the negative sign if present. */
1175
1176         if (is_negative)
1177         {
1178             p++;
1179             size--;
1180         }
1181
1182         for (pos = buffer + 63, i = 0; i < size; i++)
1183             *p++ = *pos--;
1184
1185         str[0] = '\0';
1186         MSVCRT_INVALID_PMT("str[size] is too small");
1187         *MSVCRT__errno() = MSVCRT_ERANGE;
1188         return MSVCRT_ERANGE;
1189     }
1190
1191     memcpy(str, pos, len);
1192     return 0;
1193 }
1194
1195 /*********************************************************************
1196  *  _i64tow_s (MSVCRT.@)
1197  */
1198 int CDECL _i64tow_s(__int64 value, MSVCRT_wchar_t *str, MSVCRT_size_t size, int radix)
1199 {
1200     unsigned __int64 val;
1201     unsigned int digit;
1202     int is_negative;
1203     MSVCRT_wchar_t buffer[65], *pos;
1204     size_t len;
1205
1206     if (!MSVCRT_CHECK_PMT(str != NULL) || !MSVCRT_CHECK_PMT(size > 0) ||
1207         !MSVCRT_CHECK_PMT(radix >= 2) || !MSVCRT_CHECK_PMT(radix <= 36))
1208     {
1209         if (str && size)
1210             str[0] = '\0';
1211
1212         *MSVCRT__errno() = MSVCRT_EINVAL;
1213         return MSVCRT_EINVAL;
1214     }
1215
1216     if (value < 0 && radix == 10)
1217     {
1218         is_negative = 1;
1219         val = -value;
1220     }
1221     else
1222     {
1223         is_negative = 0;
1224         val = value;
1225     }
1226
1227     pos = buffer + 64;
1228     *pos = '\0';
1229
1230     do
1231     {
1232         digit = val % radix;
1233         val /= radix;
1234
1235         if (digit < 10)
1236             *--pos = '0' + digit;
1237         else
1238             *--pos = 'a' + digit - 10;
1239     }
1240     while (val != 0);
1241
1242     if (is_negative)
1243         *--pos = '-';
1244
1245     len = buffer + 65 - pos;
1246     if (len > size)
1247     {
1248         size_t i;
1249         MSVCRT_wchar_t *p = str;
1250
1251         /* Copy the temporary buffer backwards up to the available number of
1252          * characters. Don't copy the negative sign if present. */
1253
1254         if (is_negative)
1255         {
1256             p++;
1257             size--;
1258         }
1259
1260         for (pos = buffer + 63, i = 0; i < size; i++)
1261             *p++ = *pos--;
1262
1263         MSVCRT_INVALID_PMT("str[size] is too small");
1264         str[0] = '\0';
1265         *MSVCRT__errno() = MSVCRT_ERANGE;
1266         return MSVCRT_ERANGE;
1267     }
1268
1269     memcpy(str, pos, len * sizeof(MSVCRT_wchar_t));
1270     return 0;
1271 }
1272
1273 #define I10_OUTPUT_MAX_PREC 21
1274 /* Internal structure used by $I10_OUTPUT */
1275 struct _I10_OUTPUT_DATA {
1276     short pos;
1277     char sign;
1278     BYTE len;
1279     char str[I10_OUTPUT_MAX_PREC+1]; /* add space for '\0' */
1280 };
1281
1282 /*********************************************************************
1283  *              $I10_OUTPUT (MSVCRT.@)
1284  * ld - long double to be printed to data
1285  * prec - precision of part, we're interested in
1286  * flag - 0 for first prec digits, 1 for fractional part
1287  * data - data to be populated
1288  *
1289  * return value
1290  *      0 if given double is NaN or INF
1291  *      1 otherwise
1292  *
1293  * FIXME
1294  *      Native sets last byte of data->str to '0' or '9', I don't know what
1295  *      it means. Current implementation sets it always to '0'.
1296  */
1297 int CDECL MSVCRT_I10_OUTPUT(MSVCRT__LDOUBLE ld, int prec, int flag, struct _I10_OUTPUT_DATA *data)
1298 {
1299     static const char inf_str[] = "1#INF";
1300     static const char nan_str[] = "1#QNAN";
1301
1302     double d = ld.x;
1303     char format[8];
1304     char buf[I10_OUTPUT_MAX_PREC+9]; /* 9 = strlen("0.e+0000") + '\0' */
1305     char *p;
1306
1307     TRACE("(%lf %d %x %p)\n", d, prec, flag, data);
1308
1309     if(d<0) {
1310         data->sign = '-';
1311         d = -d;
1312     } else
1313         data->sign = ' ';
1314
1315     if(isinf(d)) {
1316         data->pos = 1;
1317         data->len = 5;
1318         memcpy(data->str, inf_str, sizeof(inf_str));
1319
1320         return 0;
1321     }
1322
1323     if(isnan(d)) {
1324         data->pos = 1;
1325         data->len = 6;
1326         memcpy(data->str, nan_str, sizeof(nan_str));
1327
1328         return 0;
1329     }
1330
1331     if(flag&1) {
1332         int exp = 1+floor(log10(d));
1333
1334         prec += exp;
1335         if(exp < 0)
1336             prec--;
1337     }
1338     prec--;
1339
1340     if(prec+1 > I10_OUTPUT_MAX_PREC)
1341         prec = I10_OUTPUT_MAX_PREC-1;
1342     else if(prec < 0) {
1343         d = 0.0;
1344         prec = 0;
1345     }
1346
1347     sprintf(format, "%%.%dle", prec);
1348     sprintf(buf, format, d);
1349
1350     buf[1] = buf[0];
1351     data->pos = atoi(buf+prec+3);
1352     if(buf[1] != '0')
1353         data->pos++;
1354
1355     for(p = buf+prec+1; p>buf+1 && *p=='0'; p--);
1356     data->len = p-buf;
1357
1358     memcpy(data->str, buf+1, data->len);
1359     data->str[data->len] = '\0';
1360
1361     if(buf[1]!='0' && prec-data->len+1>0)
1362         memcpy(data->str+data->len+1, buf+data->len+1, prec-data->len+1);
1363
1364     return 1;
1365 }
1366 #undef I10_OUTPUT_MAX_PREC