501 lines
14 KiB
C
501 lines
14 KiB
C
/*
|
|
* msvcrt.dll misc functions
|
|
*
|
|
* Copyright 2000 Jon Griffiths
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "wine/port.h"
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "msvcrt.h"
|
|
#include "wine/debug.h"
|
|
#include "ntsecapi.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
|
|
|
|
static unsigned int output_format;
|
|
|
|
/*********************************************************************
|
|
* _beep (MSVCRT.@)
|
|
*/
|
|
void CDECL MSVCRT__beep( unsigned int freq, unsigned int duration)
|
|
{
|
|
TRACE(":Freq %d, Duration %d\n",freq,duration);
|
|
Beep(freq, duration);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* srand (MSVCRT.@)
|
|
*/
|
|
void CDECL MSVCRT_srand( unsigned int seed )
|
|
{
|
|
thread_data_t *data = msvcrt_get_thread_data();
|
|
data->random_seed = seed;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* rand (MSVCRT.@)
|
|
*/
|
|
int CDECL MSVCRT_rand(void)
|
|
{
|
|
thread_data_t *data = msvcrt_get_thread_data();
|
|
|
|
/* this is the algorithm used by MSVC, according to
|
|
* http://en.wikipedia.org/wiki/List_of_pseudorandom_number_generators */
|
|
data->random_seed = data->random_seed * 214013 + 2531011;
|
|
return (data->random_seed >> 16) & MSVCRT_RAND_MAX;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* rand_s (MSVCRT.@)
|
|
*/
|
|
int CDECL MSVCRT_rand_s(unsigned int *pval)
|
|
{
|
|
if (!pval || !RtlGenRandom(pval, sizeof(*pval)))
|
|
{
|
|
*MSVCRT__errno() = MSVCRT_EINVAL;
|
|
return MSVCRT_EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _sleep (MSVCRT.@)
|
|
*/
|
|
void CDECL MSVCRT__sleep(MSVCRT_ulong timeout)
|
|
{
|
|
TRACE("_sleep for %d milliseconds\n",timeout);
|
|
Sleep((timeout)?timeout:1);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _lfind (MSVCRT.@)
|
|
*/
|
|
void* CDECL _lfind(const void* match, const void* start,
|
|
unsigned int* array_size, unsigned int elem_size,
|
|
int (CDECL *cf)(const void*,const void*) )
|
|
{
|
|
unsigned int size = *array_size;
|
|
if (size)
|
|
do
|
|
{
|
|
if (cf(match, start) == 0)
|
|
return (void *)start; /* found */
|
|
start = (const char *)start + elem_size;
|
|
} while (--size);
|
|
return NULL;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _lsearch (MSVCRT.@)
|
|
*/
|
|
void* CDECL _lsearch(const void* match, void* start,
|
|
unsigned int* array_size, unsigned int elem_size,
|
|
int (CDECL *cf)(const void*,const void*) )
|
|
{
|
|
unsigned int size = *array_size;
|
|
if (size)
|
|
do
|
|
{
|
|
if (cf(match, start) == 0)
|
|
return start; /* found */
|
|
start = (char*)start + elem_size;
|
|
} while (--size);
|
|
|
|
/* not found, add to end */
|
|
memcpy(start, match, elem_size);
|
|
array_size[0]++;
|
|
return start;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* bsearch_s (msvcrt.@)
|
|
*/
|
|
void* CDECL MSVCRT_bsearch_s(const void *key, const void *base,
|
|
MSVCRT_size_t nmemb, MSVCRT_size_t size,
|
|
int (__cdecl *compare)(void *, const void *, const void *), void *ctx)
|
|
{
|
|
ssize_t min = 0;
|
|
ssize_t max = nmemb - 1;
|
|
|
|
if (!MSVCRT_CHECK_PMT(size != 0)) return NULL;
|
|
if (!MSVCRT_CHECK_PMT(compare != NULL)) return NULL;
|
|
|
|
while (min <= max)
|
|
{
|
|
ssize_t cursor = min + (max - min) / 2;
|
|
int ret = compare(ctx, key,(const char *)base+(cursor*size));
|
|
if (!ret)
|
|
return (char*)base+(cursor*size);
|
|
if (ret < 0)
|
|
max = cursor - 1;
|
|
else
|
|
min = cursor + 1;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int CDECL compare_wrapper(void *ctx, const void *e1, const void *e2)
|
|
{
|
|
int (__cdecl *compare)(const void *, const void *) = ctx;
|
|
return compare(e1, e2);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* bsearch (msvcrt.@)
|
|
*/
|
|
void* CDECL MSVCRT_bsearch(const void *key, const void *base, MSVCRT_size_t nmemb,
|
|
MSVCRT_size_t size, int (__cdecl *compar)(const void *, const void *))
|
|
{
|
|
return MSVCRT_bsearch_s(key, base, nmemb, size, compare_wrapper, compar);
|
|
}
|
|
/*********************************************************************
|
|
* _chkesp (MSVCRT.@)
|
|
*
|
|
* Trap to a debugger if the value of the stack pointer has changed.
|
|
*
|
|
* PARAMS
|
|
* None.
|
|
*
|
|
* RETURNS
|
|
* Does not return.
|
|
*
|
|
* NOTES
|
|
* This function is available for iX86 only.
|
|
*
|
|
* When VC++ generates debug code, it stores the value of the stack pointer
|
|
* before calling any external function, and checks the value following
|
|
* the call. It then calls this function, which will trap if the values are
|
|
* not the same. Usually this means that the prototype used to call
|
|
* the function is incorrect. It can also mean that the .spec entry has
|
|
* the wrong calling convention or parameters.
|
|
*/
|
|
#ifdef __i386__
|
|
|
|
# ifdef __GNUC__
|
|
|
|
__ASM_GLOBAL_FUNC(_chkesp,
|
|
"jnz 1f\n\t"
|
|
"ret\n"
|
|
"1:\tpushl %ebp\n\t"
|
|
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
|
|
__ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
|
|
"movl %esp,%ebp\n\t"
|
|
__ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
|
|
"subl $12,%esp\n\t"
|
|
"pushl %eax\n\t"
|
|
"pushl %ecx\n\t"
|
|
"pushl %edx\n\t"
|
|
"call " __ASM_NAME("MSVCRT_chkesp_fail") "\n\t"
|
|
"popl %edx\n\t"
|
|
"popl %ecx\n\t"
|
|
"popl %eax\n\t"
|
|
"leave\n\t"
|
|
__ASM_CFI(".cfi_def_cfa %esp,4\n\t")
|
|
__ASM_CFI(".cfi_same_value %ebp\n\t")
|
|
"ret")
|
|
|
|
void CDECL MSVCRT_chkesp_fail(void)
|
|
{
|
|
ERR("Stack pointer incorrect after last function call - Bad prototype/spec entry?\n");
|
|
DebugBreak();
|
|
}
|
|
|
|
# else /* __GNUC__ */
|
|
|
|
/**********************************************************************/
|
|
|
|
void CDECL _chkesp(void)
|
|
{
|
|
}
|
|
|
|
# endif /* __GNUC__ */
|
|
|
|
#endif /* __i386__ */
|
|
|
|
static inline void swap(char *l, char *r, MSVCRT_size_t size)
|
|
{
|
|
char tmp;
|
|
|
|
while(size--) {
|
|
tmp = *l;
|
|
*l++ = *r;
|
|
*r++ = tmp;
|
|
}
|
|
}
|
|
|
|
static void small_sort(void *base, MSVCRT_size_t nmemb, MSVCRT_size_t size,
|
|
int (CDECL *compar)(void *, const void *, const void *), void *context)
|
|
{
|
|
MSVCRT_size_t e, i;
|
|
char *max, *p;
|
|
|
|
for(e=nmemb; e>1; e--) {
|
|
max = base;
|
|
for(i=1; i<e; i++) {
|
|
p = (char*)base + i*size;
|
|
if(compar(context, p, max) > 0)
|
|
max = p;
|
|
}
|
|
|
|
if(p != max)
|
|
swap(p, max, size);
|
|
}
|
|
}
|
|
|
|
static void quick_sort(void *base, MSVCRT_size_t nmemb, MSVCRT_size_t size,
|
|
int (CDECL *compar)(void *, const void *, const void *), void *context)
|
|
{
|
|
MSVCRT_size_t stack_lo[8*sizeof(MSVCRT_size_t)], stack_hi[8*sizeof(MSVCRT_size_t)];
|
|
MSVCRT_size_t beg, end, lo, hi, med;
|
|
int stack_pos;
|
|
|
|
stack_pos = 0;
|
|
stack_lo[stack_pos] = 0;
|
|
stack_hi[stack_pos] = nmemb-1;
|
|
|
|
#define X(i) ((char*)base+size*(i))
|
|
while(stack_pos >= 0) {
|
|
beg = stack_lo[stack_pos];
|
|
end = stack_hi[stack_pos--];
|
|
|
|
if(end-beg < 8) {
|
|
small_sort(X(beg), end-beg+1, size, compar, context);
|
|
continue;
|
|
}
|
|
|
|
lo = beg;
|
|
hi = end;
|
|
med = lo + (hi-lo+1)/2;
|
|
if(compar(context, X(lo), X(med)) > 0)
|
|
swap(X(lo), X(med), size);
|
|
if(compar(context, X(lo), X(hi)) > 0)
|
|
swap(X(lo), X(hi), size);
|
|
if(compar(context, X(med), X(hi)) > 0)
|
|
swap(X(med), X(hi), size);
|
|
|
|
lo++;
|
|
hi--;
|
|
while(1) {
|
|
while(lo <= hi) {
|
|
if(lo!=med && compar(context, X(lo), X(med))>0)
|
|
break;
|
|
lo++;
|
|
}
|
|
|
|
while(med != hi) {
|
|
if(compar(context, X(hi), X(med)) <= 0)
|
|
break;
|
|
hi--;
|
|
}
|
|
|
|
if(hi < lo)
|
|
break;
|
|
|
|
swap(X(lo), X(hi), size);
|
|
if(hi == med)
|
|
med = lo;
|
|
lo++;
|
|
hi--;
|
|
}
|
|
|
|
while(hi > beg) {
|
|
if(hi!=med && compar(context, X(hi), X(med))!=0)
|
|
break;
|
|
hi--;
|
|
}
|
|
|
|
if(hi-beg >= end-lo) {
|
|
stack_lo[++stack_pos] = beg;
|
|
stack_hi[stack_pos] = hi;
|
|
stack_lo[++stack_pos] = lo;
|
|
stack_hi[stack_pos] = end;
|
|
}else {
|
|
stack_lo[++stack_pos] = lo;
|
|
stack_hi[stack_pos] = end;
|
|
stack_lo[++stack_pos] = beg;
|
|
stack_hi[stack_pos] = hi;
|
|
}
|
|
}
|
|
#undef X
|
|
}
|
|
|
|
/*********************************************************************
|
|
* qsort_s (MSVCRT.@)
|
|
*
|
|
* This function is trying to sort data doing identical comparisons
|
|
* as native does. There are still cases where it behaves differently.
|
|
*/
|
|
void CDECL MSVCRT_qsort_s(void *base, MSVCRT_size_t nmemb, MSVCRT_size_t size,
|
|
int (CDECL *compar)(void *, const void *, const void *), void *context)
|
|
{
|
|
const MSVCRT_size_t total_size = nmemb*size;
|
|
|
|
if (!MSVCRT_CHECK_PMT(base != NULL || (base == NULL && nmemb == 0))) return;
|
|
if (!MSVCRT_CHECK_PMT(size > 0)) return;
|
|
if (!MSVCRT_CHECK_PMT(compar != NULL)) return;
|
|
if (total_size / size != nmemb) return;
|
|
|
|
if (nmemb < 2) return;
|
|
|
|
quick_sort(base, nmemb, size, compar, context);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* qsort (MSVCRT.@)
|
|
*/
|
|
void CDECL MSVCRT_qsort(void *base, MSVCRT_size_t nmemb, MSVCRT_size_t size,
|
|
int (CDECL *compar)(const void*, const void*))
|
|
{
|
|
MSVCRT_qsort_s(base, nmemb, size, compare_wrapper, compar);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _get_output_format (MSVCRT.@)
|
|
*/
|
|
unsigned int CDECL MSVCRT__get_output_format(void)
|
|
{
|
|
return output_format;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _set_output_format (MSVCRT.@)
|
|
*/
|
|
unsigned int CDECL MSVCRT__set_output_format(unsigned int new_output_format)
|
|
{
|
|
unsigned int ret = output_format;
|
|
|
|
if(!MSVCRT_CHECK_PMT(new_output_format==0 || new_output_format==MSVCRT__TWO_DIGIT_EXPONENT))
|
|
return ret;
|
|
|
|
output_format = new_output_format;
|
|
return ret;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _resetstkoflw (MSVCRT.@)
|
|
*/
|
|
int CDECL MSVCRT__resetstkoflw(void)
|
|
{
|
|
int stack_addr;
|
|
DWORD oldprot;
|
|
|
|
/* causes stack fault that updates NtCurrentTeb()->Tib.StackLimit */
|
|
return VirtualProtect(&stack_addr, 1, PAGE_GUARD|PAGE_READWRITE, &oldprot);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _decode_pointer (MSVCR90.@)
|
|
*/
|
|
void * CDECL MSVCRT_decode_pointer(void * ptr)
|
|
{
|
|
return DecodePointer(ptr);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _encode_pointer (MSVCR90.@)
|
|
*/
|
|
void * CDECL MSVCRT_encode_pointer(void * ptr)
|
|
{
|
|
return EncodePointer(ptr);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _encoded_null (MSVCR100.@)
|
|
*/
|
|
void * CDECL _encoded_null(void)
|
|
{
|
|
TRACE("\n");
|
|
|
|
return EncodePointer(NULL);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _CRT_RTC_INIT (MSVCR100.@)
|
|
*/
|
|
void* CDECL _CRT_RTC_INIT(void *unk1, void *unk2, int unk3, int unk4, int unk5)
|
|
{
|
|
TRACE("%p %p %x %x %x\n", unk1, unk2, unk3, unk4, unk5);
|
|
return NULL;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _CRT_RTC_INITW (MSVCR100.@)
|
|
*/
|
|
void* CDECL _CRT_RTC_INITW(void *unk1, void *unk2, int unk3, int unk4, int unk5)
|
|
{
|
|
TRACE("%p %p %x %x %x\n", unk1, unk2, unk3, unk4, unk5);
|
|
return NULL;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _byteswap_ushort (MSVCR100.@)
|
|
*/
|
|
unsigned short CDECL _byteswap_ushort(unsigned short s)
|
|
{
|
|
return (s<<8) + (s>>8);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _byteswap_ulong (MSVCR100.@)
|
|
*/
|
|
ULONG CDECL MSVCRT__byteswap_ulong(ULONG l)
|
|
{
|
|
return (l<<24) + ((l<<8)&0xFF0000) + ((l>>8)&0xFF00) + (l>>24);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _byteswap_uint64 (MSVCR100.@)
|
|
*/
|
|
unsigned __int64 CDECL _byteswap_uint64(unsigned __int64 i)
|
|
{
|
|
return (i<<56) + ((i&0xFF00)<<40) + ((i&0xFF0000)<<24) + ((i&0xFF000000)<<8) +
|
|
((i>>8)&0xFF000000) + ((i>>24)&0xFF0000) + ((i>>40)&0xFF00) + (i>>56);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* __crtGetShowWindowMode (MSVCR110.@)
|
|
*/
|
|
int CDECL MSVCR110__crtGetShowWindowMode(void)
|
|
{
|
|
STARTUPINFOW si;
|
|
|
|
GetStartupInfoW(&si);
|
|
TRACE("window=%d\n", si.wShowWindow);
|
|
return si.wShowWindow;
|
|
}
|
|
|
|
/*********************************************************************
|
|
* __crtInitializeCriticalSectionEx (MSVCR110.@)
|
|
*/
|
|
BOOL CDECL MSVCR110__crtInitializeCriticalSectionEx(
|
|
CRITICAL_SECTION *cs, DWORD spin_count, DWORD flags)
|
|
{
|
|
TRACE("(%p %x %x)\n", cs, spin_count, flags);
|
|
return InitializeCriticalSectionEx(cs, spin_count, flags);
|
|
}
|
|
|
|
/*********************************************************************
|
|
* _vacopy (MSVCR120.@)
|
|
*/
|
|
void CDECL MSVCR120__vacopy(__ms_va_list *dest, __ms_va_list src)
|
|
{
|
|
__ms_va_copy(*dest, src);
|
|
}
|