dlls/msvcrt/misc.c

   1 /*
   2  * msvcrt.dll misc functions
   3  *
   4  * Copyright 2000 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdlib.h>
  25
  26 #include "msvcrt.h"
  27 #include "wine/debug.h"
  28 #include "ntsecapi.h"
  29 #include "windows.h"
  30 #include "wine/asm.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  33
  34 static unsigned int output_format;
  35
  36 /*********************************************************************
  37  *              _beep (MSVCRT.@)
  38  */
  39 void CDECL MSVCRT__beep( unsigned int freq, unsigned int duration)
  40 {
  41     TRACE(":Freq %d, Duration %d\n",freq,duration);
  42     Beep(freq, duration);
  43 }
  44
  45 /*********************************************************************
  46  *              srand (MSVCRT.@)
  47  */
  48 void CDECL MSVCRT_srand( unsigned int seed )
  49 {
  50     thread_data_t *data = msvcrt_get_thread_data();
  51     data->random_seed = seed;
  52 }
  53
  54 /*********************************************************************
  55  *              rand (MSVCRT.@)
  56  */
  57 int CDECL MSVCRT_rand(void)
  58 {
  59     thread_data_t *data = msvcrt_get_thread_data();
  60
  61     /* this is the algorithm used by MSVC, according to
  62      * http://en.wikipedia.org/wiki/List_of_pseudorandom_number_generators */
  63     data->random_seed = data->random_seed * 214013 + 2531011;
  64     return (data->random_seed >> 16) & MSVCRT_RAND_MAX;
  65 }
  66
  67 /*********************************************************************
  68  *              rand_s (MSVCRT.@)
  69  */
  70 int CDECL MSVCRT_rand_s(unsigned int *pval)
  71 {
  72     if (!pval || !RtlGenRandom(pval, sizeof(*pval)))
  73     {
  74         *MSVCRT__errno() = MSVCRT_EINVAL;
  75         return MSVCRT_EINVAL;
  76     }
  77     return 0;
  78 }
  79
  80 /*********************************************************************
  81  *              _sleep (MSVCRT.@)
  82  */
  83 void CDECL MSVCRT__sleep(MSVCRT_ulong timeout)
  84 {
  85   TRACE("_sleep for %d milliseconds\n",timeout);
  86   Sleep((timeout)?timeout:1);
  87 }
  88
  89 /*********************************************************************
  90  *              _lfind (MSVCRT.@)
  91  */
  92 void* CDECL _lfind(const void* match, const void* start,
  93                    unsigned int* array_size, unsigned int elem_size,
  94                    int (CDECL *cf)(const void*,const void*) )
  95 {
  96   unsigned int size = *array_size;
  97   if (size)
  98     do
  99     {
 100       if (cf(match, start) == 0)
 101         return (void *)start; /* found */
 102       start = (const char *)start + elem_size;
 103     } while (--size);
 104   return NULL;
 105 }
 106
 107 /*********************************************************************
 108  *              _lfind_s (MSVCRT.@)
 109  */
 110 void* CDECL _lfind_s(const void* match, const void* start,
 111                    unsigned int* array_size, unsigned int elem_size,
 112                    int (CDECL *cf)(void*,const void*,const void*),
 113                    void* context)
 114 {
 115   unsigned int size;
 116   if (!MSVCRT_CHECK_PMT(match != NULL)) return NULL;
 117   if (!MSVCRT_CHECK_PMT(array_size != NULL)) return NULL;
 118   if (!MSVCRT_CHECK_PMT(start != NULL || *array_size == 0)) return NULL;
 119   if (!MSVCRT_CHECK_PMT(cf != NULL)) return NULL;
 120   if (!MSVCRT_CHECK_PMT(elem_size != 0)) return NULL;
 121
 122   size = *array_size;
 123   if (size)
 124     do
 125     {
 126       if (cf(context, match, start) == 0)
 127         return (void *)start; /* found */
 128       start = (const char *)start + elem_size;
 129     } while (--size);
 130   return NULL;
 131 }
 132
 133 /*********************************************************************
 134  *              _lsearch (MSVCRT.@)
 135  */
 136 void* CDECL _lsearch(const void* match, void* start,
 137                      unsigned int* array_size, unsigned int elem_size,
 138                      int (CDECL *cf)(const void*,const void*) )
 139 {
 140   unsigned int size = *array_size;
 141   if (size)
 142     do
 143     {
 144       if (cf(match, start) == 0)
 145         return start; /* found */
 146       start = (char*)start + elem_size;
 147     } while (--size);
 148
 149   /* not found, add to end */
 150   memcpy(start, match, elem_size);
 151   array_size[0]++;
 152   return start;
 153 }
 154
 155 /*********************************************************************
 156  *                  bsearch_s (msvcrt.@)
 157  */
 158 void* CDECL MSVCRT_bsearch_s(const void *key, const void *base,
 159                              MSVCRT_size_t nmemb, MSVCRT_size_t size,
 160                              int (__cdecl *compare)(void *, const void *, const void *), void *ctx)
 161 {
 162     ssize_t min = 0;
 163     ssize_t max = nmemb - 1;
 164
 165     if (!MSVCRT_CHECK_PMT(size != 0)) return NULL;
 166     if (!MSVCRT_CHECK_PMT(compare != NULL)) return NULL;
 167
 168     while (min <= max)
 169     {
 170         ssize_t cursor = min + (max - min) / 2;
 171         int ret = compare(ctx, key,(const char *)base+(cursor*size));
 172         if (!ret)
 173             return (char*)base+(cursor*size);
 174         if (ret < 0)
 175             max = cursor - 1;
 176         else
 177             min = cursor + 1;
 178     }
 179     return NULL;
 180 }
 181
 182 static int CDECL compare_wrapper(void *ctx, const void *e1, const void *e2)
 183 {
 184     int (__cdecl *compare)(const void *, const void *) = ctx;
 185     return compare(e1, e2);
 186 }
 187
 188 /*********************************************************************
 189  *                  bsearch (msvcrt.@)
 190  */
 191 void* CDECL MSVCRT_bsearch(const void *key, const void *base, MSVCRT_size_t nmemb,
 192         MSVCRT_size_t size, int (__cdecl *compar)(const void *, const void *))
 193 {
 194     return MSVCRT_bsearch_s(key, base, nmemb, size, compare_wrapper, compar);
 195 }
 196 /*********************************************************************
 197  *              _chkesp (MSVCRT.@)
 198  *
 199  * Trap to a debugger if the value of the stack pointer has changed.
 200  *
 201  * PARAMS
 202  *  None.
 203  *
 204  * RETURNS
 205  *  Does not return.
 206  *
 207  * NOTES
 208  *  This function is available for iX86 only.
 209  *
 210  *  When VC++ generates debug code, it stores the value of the stack pointer
 211  *  before calling any external function, and checks the value following
 212  *  the call. It then calls this function, which will trap if the values are
 213  *  not the same. Usually this means that the prototype used to call
 214  *  the function is incorrect.  It can also mean that the .spec entry has
 215  *  the wrong calling convention or parameters.
 216  */
 217 #ifdef __i386__
 218
 219 # ifdef __GNUC__
 220
 221 __ASM_GLOBAL_FUNC(_chkesp,
 222                   "jnz 1f\n\t"
 223                   "ret\n"
 224                   "1:\tpushl %ebp\n\t"
 225                   __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 226                   __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
 227                   "movl %esp,%ebp\n\t"
 228                   __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
 229                   "subl $12,%esp\n\t"
 230                   "pushl %eax\n\t"
 231                   "pushl %ecx\n\t"
 232                   "pushl %edx\n\t"
 233                   "call " __ASM_NAME("MSVCRT_chkesp_fail") "\n\t"
 234                   "popl %edx\n\t"
 235                   "popl %ecx\n\t"
 236                   "popl %eax\n\t"
 237                   "leave\n\t"
 238                   __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
 239                   __ASM_CFI(".cfi_same_value %ebp\n\t")
 240                   "ret")
 241
 242 void CDECL DECLSPEC_HIDDEN MSVCRT_chkesp_fail(void)
 243 {
 244   ERR("Stack pointer incorrect after last function call - Bad prototype/spec entry?\n");
 245   DebugBreak();
 246 }
 247
 248 # else  /* __GNUC__ */
 249
 250 /**********************************************************************/
 251
 252 void CDECL _chkesp(void)
 253 {
 254 }
 255
 256 # endif  /* __GNUC__ */
 257
 258 #endif  /* __i386__ */
 259
 260 static inline void swap(char *l, char *r, MSVCRT_size_t size)
 261 {
 262     char tmp;
 263
 264     while(size--) {
 265         tmp = *l;
 266         *l++ = *r;
 267         *r++ = tmp;
 268     }
 269 }
 270
 271 static void small_sort(void *base, MSVCRT_size_t nmemb, MSVCRT_size_t size,
 272         int (CDECL *compar)(void *, const void *, const void *), void *context)
 273 {
 274     MSVCRT_size_t e, i;
 275     char *max, *p;
 276
 277     for(e=nmemb; e>1; e--) {
 278         max = base;
 279         for(i=1; i<e; i++) {
 280             p = (char*)base + i*size;
 281             if(compar(context, p, max) > 0)
 282                 max = p;
 283         }
 284
 285         if(p != max)
 286             swap(p, max, size);
 287     }
 288 }
 289
 290 static void quick_sort(void *base, MSVCRT_size_t nmemb, MSVCRT_size_t size,
 291         int (CDECL *compar)(void *, const void *, const void *), void *context)
 292 {
 293     MSVCRT_size_t stack_lo[8*sizeof(MSVCRT_size_t)], stack_hi[8*sizeof(MSVCRT_size_t)];
 294     MSVCRT_size_t beg, end, lo, hi, med;
 295     int stack_pos;
 296
 297     stack_pos = 0;
 298     stack_lo[stack_pos] = 0;
 299     stack_hi[stack_pos] = nmemb-1;
 300
 301 #define X(i) ((char*)base+size*(i))
 302     while(stack_pos >= 0) {
 303         beg = stack_lo[stack_pos];
 304         end = stack_hi[stack_pos--];
 305
 306         if(end-beg < 8) {
 307             small_sort(X(beg), end-beg+1, size, compar, context);
 308             continue;
 309         }
 310
 311         lo = beg;
 312         hi = end;
 313         med = lo + (hi-lo+1)/2;
 314         if(compar(context, X(lo), X(med)) > 0)
 315             swap(X(lo), X(med), size);
 316         if(compar(context, X(lo), X(hi)) > 0)
 317             swap(X(lo), X(hi), size);
 318         if(compar(context, X(med), X(hi)) > 0)
 319             swap(X(med), X(hi), size);
 320
 321         lo++;
 322         hi--;
 323         while(1) {
 324             while(lo <= hi) {
 325                 if(lo!=med && compar(context, X(lo), X(med))>0)
 326                     break;
 327                 lo++;
 328             }
 329
 330             while(med != hi) {
 331                 if(compar(context, X(hi), X(med)) <= 0)
 332                     break;
 333                 hi--;
 334             }
 335
 336             if(hi < lo)
 337                 break;
 338
 339             swap(X(lo), X(hi), size);
 340             if(hi == med)
 341                 med = lo;
 342             lo++;
 343             hi--;
 344         }
 345
 346         while(hi > beg) {
 347             if(hi!=med && compar(context, X(hi), X(med))!=0)
 348                 break;
 349             hi--;
 350         }
 351
 352         if(hi-beg >= end-lo) {
 353             stack_lo[++stack_pos] = beg;
 354             stack_hi[stack_pos] = hi;
 355             stack_lo[++stack_pos] = lo;
 356             stack_hi[stack_pos] = end;
 357         }else {
 358             stack_lo[++stack_pos] = lo;
 359             stack_hi[stack_pos] = end;
 360             stack_lo[++stack_pos] = beg;
 361             stack_hi[stack_pos] = hi;
 362         }
 363     }
 364 #undef X
 365 }
 366
 367 /*********************************************************************
 368  * qsort_s (MSVCRT.@)
 369  *
 370  * This function is trying to sort data doing identical comparisons
 371  * as native does. There are still cases where it behaves differently.
 372  */
 373 void CDECL MSVCRT_qsort_s(void *base, MSVCRT_size_t nmemb, MSVCRT_size_t size,
 374     int (CDECL *compar)(void *, const void *, const void *), void *context)
 375 {
 376     const MSVCRT_size_t total_size = nmemb*size;
 377
 378     if (!MSVCRT_CHECK_PMT(base != NULL || (base == NULL && nmemb == 0))) return;
 379     if (!MSVCRT_CHECK_PMT(size > 0)) return;
 380     if (!MSVCRT_CHECK_PMT(compar != NULL)) return;
 381     if (total_size / size != nmemb) return;
 382
 383     if (nmemb < 2) return;
 384
 385     quick_sort(base, nmemb, size, compar, context);
 386 }
 387
 388 /*********************************************************************
 389  * qsort (MSVCRT.@)
 390  */
 391 void CDECL MSVCRT_qsort(void *base, MSVCRT_size_t nmemb, MSVCRT_size_t size,
 392         int (CDECL *compar)(const void*, const void*))
 393 {
 394     MSVCRT_qsort_s(base, nmemb, size, compare_wrapper, compar);
 395 }
 396
 397 /*********************************************************************
 398  * _get_output_format (MSVCRT.@)
 399  */
 400 unsigned int CDECL MSVCRT__get_output_format(void)
 401 {
 402    return output_format;
 403 }
 404
 405 /*********************************************************************
 406  * _set_output_format (MSVCRT.@)
 407  */
 408 unsigned int CDECL MSVCRT__set_output_format(unsigned int new_output_format)
 409 {
 410     unsigned int ret = output_format;
 411
 412     if(!MSVCRT_CHECK_PMT(new_output_format==0 || new_output_format==MSVCRT__TWO_DIGIT_EXPONENT))
 413         return ret;
 414
 415     output_format = new_output_format;
 416     return ret;
 417 }
 418
 419 /*********************************************************************
 420  * _resetstkoflw (MSVCRT.@)
 421  */
 422 int CDECL MSVCRT__resetstkoflw(void)
 423 {
 424     int stack_addr;
 425     DWORD oldprot;
 426
 427     /* causes stack fault that updates NtCurrentTeb()->Tib.StackLimit */
 428     return VirtualProtect(&stack_addr, 1, PAGE_GUARD|PAGE_READWRITE, &oldprot);
 429 }
 430
 431 #if _MSVCR_VER>=80 && _MSVCR_VER<=90
 432
 433 /*********************************************************************
 434  *  _decode_pointer (MSVCR80.@)
 435  */
 436 void * CDECL MSVCRT_decode_pointer(void * ptr)
 437 {
 438     return DecodePointer(ptr);
 439 }
 440
 441 /*********************************************************************
 442  *  _encode_pointer (MSVCR80.@)
 443  */
 444 void * CDECL MSVCRT_encode_pointer(void * ptr)
 445 {
 446     return EncodePointer(ptr);
 447 }
 448
 449 #endif /* _MSVCR_VER>=80 && _MSVCR_VER<=90 */
 450
 451 #if _MSVCR_VER>=80 && _MSVCR_VER<=100
 452 /*********************************************************************
 453  *  _encoded_null (MSVCR80.@)
 454  */
 455 void * CDECL _encoded_null(void)
 456 {
 457     TRACE("\n");
 458
 459     return EncodePointer(NULL);
 460 }
 461 #endif
 462
 463 #if _MSVCR_VER>=70
 464 /*********************************************************************
 465  * _CRT_RTC_INIT (MSVCR70.@)
 466  */
 467 void* CDECL _CRT_RTC_INIT(void *unk1, void *unk2, int unk3, int unk4, int unk5)
 468 {
 469     TRACE("%p %p %x %x %x\n", unk1, unk2, unk3, unk4, unk5);
 470     return NULL;
 471 }
 472 #endif
 473
 474 #if _MSVCR_VER>=80
 475
 476 /*********************************************************************
 477  * _CRT_RTC_INITW (MSVCR80.@)
 478  */
 479 void* CDECL _CRT_RTC_INITW(void *unk1, void *unk2, int unk3, int unk4, int unk5)
 480 {
 481     TRACE("%p %p %x %x %x\n", unk1, unk2, unk3, unk4, unk5);
 482     return NULL;
 483 }
 484
 485 /*********************************************************************
 486  * _byteswap_ushort (MSVCR80.@)
 487  */
 488 unsigned short CDECL _byteswap_ushort(unsigned short s)
 489 {
 490     return (s<<8) + (s>>8);
 491 }
 492
 493 /*********************************************************************
 494  * _byteswap_ulong (MSVCR80.@)
 495  */
 496 ULONG CDECL MSVCRT__byteswap_ulong(ULONG l)
 497 {
 498     return (l<<24) + ((l<<8)&0xFF0000) + ((l>>8)&0xFF00) + (l>>24);
 499 }
 500
 501 /*********************************************************************
 502  * _byteswap_uint64 (MSVCR80.@)
 503  */
 504 unsigned __int64 CDECL _byteswap_uint64(unsigned __int64 i)
 505 {
 506     return (i<<56) + ((i&0xFF00)<<40) + ((i&0xFF0000)<<24) + ((i&0xFF000000)<<8) +
 507         ((i>>8)&0xFF000000) + ((i>>24)&0xFF0000) + ((i>>40)&0xFF00) + (i>>56);
 508 }
 509
 510 #endif /* _MSVCR_VER>=80 */
 511
 512 #if _MSVCR_VER>=110
 513
 514 /*********************************************************************
 515  *  __crtGetShowWindowMode (MSVCR110.@)
 516  */
 517 int CDECL MSVCR110__crtGetShowWindowMode(void)
 518 {
 519     STARTUPINFOW si;
 520
 521     GetStartupInfoW(&si);
 522     TRACE("flags=%x window=%d\n", si.dwFlags, si.wShowWindow);
 523     return si.dwFlags & STARTF_USESHOWWINDOW ? si.wShowWindow : SW_SHOWDEFAULT;
 524 }
 525
 526 /*********************************************************************
 527  *  __crtInitializeCriticalSectionEx (MSVCR110.@)
 528  */
 529 BOOL CDECL MSVCR110__crtInitializeCriticalSectionEx(
 530         CRITICAL_SECTION *cs, DWORD spin_count, DWORD flags)
 531 {
 532     TRACE("(%p %x %x)\n", cs, spin_count, flags);
 533     return InitializeCriticalSectionEx(cs, spin_count, flags);
 534 }
 535
 536 #endif /* _MSVCR_VER>=110 */
 537
 538 #if _MSVCR_VER>=120
 539 /*********************************************************************
 540  * _vacopy (MSVCR120.@)
 541  */
 542 void CDECL MSVCR120__vacopy(__ms_va_list *dest, __ms_va_list src)
 543 {
 544     __ms_va_copy(*dest, src);
 545 }
 546 #endif
 547
 548 #if _MSVCR_VER>=80
 549 /*********************************************************************
 550  * _crt_debugger_hook (MSVCR80.@)
 551  */
 552 void CDECL MSVCRT__crt_debugger_hook(int reserved)
 553 {
 554     WARN("(%x)\n", reserved);
 555 }
 556 #endif
 557
 558 #if _MSVCR_VER>=110
 559 /*********************************************************************
 560  *  __crtUnhandledException (MSVCR110.@)
 561  */
 562 LONG CDECL MSVCRT__crtUnhandledException(EXCEPTION_POINTERS *ep)
 563 {
 564     TRACE("(%p)\n", ep);
 565     SetUnhandledExceptionFilter(NULL);
 566     return UnhandledExceptionFilter(ep);
 567 }
 568
 569 /* ?_Trace_agents@Concurrency@@YAXW4Agents_EventType@1@_JZZ */
 570 void WINAPIV _Trace_agents(/*enum Concurrency::Agents_EventType*/int type, __int64 id, ...)
 571 {
 572     FIXME("(%d %s)\n", type, wine_dbgstr_longlong(id));
 573 }
 574 #endif
 575
 576 #if _MSVCR_VER>=120
 577 /*********************************************************************
 578  *              __crtSleep (MSVCR120.@)
 579  */
 580 void CDECL MSVCRT__crtSleep(DWORD timeout)
 581 {
 582   TRACE("(%u)\n", timeout);
 583   Sleep(timeout);
 584 }
 585
 586 /*********************************************************************
 587  * _SetWinRTOutOfMemoryExceptionCallback (MSVCR120.@)
 588  */
 589 void CDECL MSVCR120__SetWinRTOutOfMemoryExceptionCallback(void *callback)
 590 {
 591     FIXME("(%p): stub\n", callback);
 592 }
 593 #endif