git.oblomov.eu Git - wine/blob - 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
  30 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  31
  32
  33 /*********************************************************************
  34  *              _beep (MSVCRT.@)
  35  */
  36 void CDECL MSVCRT__beep( unsigned int freq, unsigned int duration)
  37 {
  38     TRACE(":Freq %d, Duration %d\n",freq,duration);
  39     Beep(freq, duration);
  40 }
  41
  42 /*********************************************************************
  43  *              srand (MSVCRT.@)
  44  */
  45 void CDECL MSVCRT_srand( unsigned int seed )
  46 {
  47     thread_data_t *data = msvcrt_get_thread_data();
  48     data->random_seed = seed;
  49 }
  50
  51 /*********************************************************************
  52  *              rand (MSVCRT.@)
  53  */
  54 int CDECL MSVCRT_rand(void)
  55 {
  56     thread_data_t *data = msvcrt_get_thread_data();
  57
  58     /* this is the algorithm used by MSVC, according to
  59      * http://en.wikipedia.org/wiki/List_of_pseudorandom_number_generators */
  60     data->random_seed = data->random_seed * 214013 + 2531011;
  61     return (data->random_seed >> 16) & MSVCRT_RAND_MAX;
  62 }
  63
  64 /*********************************************************************
  65  *              rand_s (MSVCRT.@)
  66  */
  67 int CDECL MSVCRT_rand_s(unsigned int *pval)
  68 {
  69     if (!pval || !RtlGenRandom(pval, sizeof(*pval)))
  70     {
  71         *MSVCRT__errno() = MSVCRT_EINVAL;
  72         return MSVCRT_EINVAL;
  73     }
  74     return 0;
  75 }
  76
  77 /*********************************************************************
  78  *              _sleep (MSVCRT.@)
  79  */
  80 void CDECL MSVCRT__sleep(MSVCRT_ulong timeout)
  81 {
  82   TRACE("_sleep for %d milliseconds\n",timeout);
  83   Sleep((timeout)?timeout:1);
  84 }
  85
  86 /*********************************************************************
  87  *              _lfind (MSVCRT.@)
  88  */
  89 void* CDECL _lfind(const void* match, const void* start,
  90                    unsigned int* array_size, unsigned int elem_size,
  91                    int (CDECL *cf)(const void*,const void*) )
  92 {
  93   unsigned int size = *array_size;
  94   if (size)
  95     do
  96     {
  97       if (cf(match, start) == 0)
  98         return (void *)start; /* found */
  99       start = (const char *)start + elem_size;
 100     } while (--size);
 101   return NULL;
 102 }
 103
 104 /*********************************************************************
 105  *              _lsearch (MSVCRT.@)
 106  */
 107 void* CDECL _lsearch(const void* match, void* start,
 108                      unsigned int* array_size, unsigned int elem_size,
 109                      int (CDECL *cf)(const void*,const void*) )
 110 {
 111   unsigned int size = *array_size;
 112   if (size)
 113     do
 114     {
 115       if (cf(match, start) == 0)
 116         return start; /* found */
 117       start = (char*)start + elem_size;
 118     } while (--size);
 119
 120   /* not found, add to end */
 121   memcpy(start, match, elem_size);
 122   array_size[0]++;
 123   return start;
 124 }
 125
 126 /*********************************************************************
 127  *              _chkesp (MSVCRT.@)
 128  *
 129  * Trap to a debugger if the value of the stack pointer has changed.
 130  *
 131  * PARAMS
 132  *  None.
 133  *
 134  * RETURNS
 135  *  Does not return.
 136  *
 137  * NOTES
 138  *  This function is available for iX86 only.
 139  *
 140  *  When VC++ generates debug code, it stores the value of the stack pointer
 141  *  before calling any external function, and checks the value following
 142  *  the call. It then calls this function, which will trap if the values are
 143  *  not the same. Usually this means that the prototype used to call
 144  *  the function is incorrect.  It can also mean that the .spec entry has
 145  *  the wrong calling convention or parameters.
 146  */
 147 #ifdef __i386__
 148
 149 # ifdef __GNUC__
 150
 151 __ASM_GLOBAL_FUNC(_chkesp,
 152                   "jnz 1f\n\t"
 153                   "ret\n"
 154                   "1:\tpushl %ebp\n\t"
 155                   __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 156                   __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
 157                   "movl %esp,%ebp\n\t"
 158                   __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
 159                   "subl $12,%esp\n\t"
 160                   "pushl %eax\n\t"
 161                   "pushl %ecx\n\t"
 162                   "pushl %edx\n\t"
 163                   "call " __ASM_NAME("MSVCRT_chkesp_fail") "\n\t"
 164                   "popl %edx\n\t"
 165                   "popl %ecx\n\t"
 166                   "popl %eax\n\t"
 167                   "leave\n\t"
 168                   __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
 169                   __ASM_CFI(".cfi_same_value %ebp\n\t")
 170                   "ret")
 171
 172 void CDECL MSVCRT_chkesp_fail(void)
 173 {
 174   ERR("Stack pointer incorrect after last function call - Bad prototype/spec entry?\n");
 175   DebugBreak();
 176 }
 177
 178 # else  /* __GNUC__ */
 179
 180 /**********************************************************************/
 181
 182 void CDECL _chkesp(void)
 183 {
 184 }
 185
 186 # endif  /* __GNUC__ */
 187
 188 #endif  /* __i386__ */
 189
 190 /*********************************************************************
 191  * Helper function for MSVCRT_qsort_s.
 192  *
 193  * Based on NTDLL_qsort in dlls/ntdll/misc.c
 194  */
 195 static void MSVCRT_mergesort( void *arr, void *barr, size_t elemsize,
 196         int (CDECL *compar)(void *, const void *, const void *),
 197         size_t left, size_t right, void *context )
 198 {
 199     if (right>left) {
 200         size_t i, j, k, m;
 201         m=left+(right-left)/2;
 202         MSVCRT_mergesort(arr, barr, elemsize, compar, left, m, context);
 203         MSVCRT_mergesort(arr, barr, elemsize, compar, m+1, right, context);
 204
 205 #define X(a,i) ((char*)a+elemsize*(i))
 206         for (i=m+1; i>left; i--)
 207             memcpy (X(barr,(i-1)),X(arr,(i-1)),elemsize);
 208         for (j=m; j<right; j++)
 209             memcpy (X(barr,(right+m-j)),X(arr,(j+1)),elemsize);
 210
 211         /* i=left; j=right; */
 212         for (k=left; i<=m && j>m; k++) {
 213             if (i==j || compar(context, X(barr,i),X(barr,j))<=0) {
 214                 memcpy(X(arr,k),X(barr,i),elemsize);
 215                 i++;
 216             } else {
 217                 memcpy(X(arr,k),X(barr,j),elemsize);
 218                 j--;
 219             }
 220         }
 221         for (; i<=m; i++, k++)
 222             memcpy(X(arr,k),X(barr,i),elemsize);
 223         for (; j>m; j--, k++)
 224             memcpy(X(arr,k),X(barr,j),elemsize);
 225     }
 226 #undef X
 227 }
 228
 229 /*********************************************************************
 230  * qsort_s (MSVCRT.@)
 231  *
 232  * Based on NTDLL_qsort in dlls/ntdll/misc.c
 233  */
 234 void CDECL MSVCRT_qsort_s(void *base, MSVCRT_size_t nmemb, MSVCRT_size_t size,
 235     int (CDECL *compar)(void *, const void *, const void *), void *context)
 236 {
 237     void *secondarr;
 238     const size_t total_size = nmemb*size;
 239
 240     if (!MSVCRT_CHECK_PMT(base != NULL || (base == NULL && nmemb == 0)) ||
 241             !MSVCRT_CHECK_PMT(size > 0) || !MSVCRT_CHECK_PMT(compar != NULL) ||
 242             total_size / size != nmemb)
 243     {
 244         *MSVCRT__errno() = MSVCRT_EINVAL;
 245         return;
 246     }
 247
 248     if (nmemb < 2) return;
 249
 250     secondarr = MSVCRT_malloc(total_size);
 251     if (!secondarr)
 252         return;
 253     MSVCRT_mergesort(base, secondarr, size, compar, 0, nmemb-1, context);
 254     MSVCRT_free(secondarr);
 255 }
 256
 257 /*********************************************************************
 258  * _get_output_format (MSVCRT.@)
 259  */
 260 unsigned int CDECL _get_output_format(void)
 261 {
 262    return 0;
 263 }
 264
 265 /*********************************************************************
 266  * _resetstkoflw (MSVCRT.@)
 267  */
 268 int CDECL MSVCRT__resetstkoflw(void)
 269 {
 270     int stack_addr;
 271
 272     /* causes stack fault that updates NtCurrentTeb()->Tib.StackLimit */
 273     return VirtualProtect( &stack_addr, 1, PAGE_GUARD|PAGE_READWRITE, NULL );
 274 }