dlls/msvcrt/heap.c

   1 /*
   2  * msvcrt.dll heap 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  * Note: Win32 heap operations are MT safe. We only lock the new
  21  *       handler and non atomic heap operations
  22  */
  23
  24 #include "msvcrt.h"
  25 #include "mtdll.h"
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  29
  30 /* MT */
  31 #define LOCK_HEAP   _mlock( _HEAP_LOCK )
  32 #define UNLOCK_HEAP _munlock( _HEAP_LOCK )
  33
  34 /* _aligned */
  35 #define SAVED_PTR(x) ((void *)((DWORD_PTR)((char *)x - sizeof(void *)) & \
  36                                ~(sizeof(void *) - 1)))
  37 #define ALIGN_PTR(ptr, alignment, offset) ((void *) \
  38     ((((DWORD_PTR)((char *)ptr + alignment + sizeof(void *) + offset)) & \
  39       ~(alignment - 1)) - offset))
  40
  41 static HANDLE heap;
  42
  43 typedef int (CDECL *MSVCRT_new_handler_func)(MSVCRT_size_t size);
  44
  45 static MSVCRT_new_handler_func MSVCRT_new_handler;
  46 static int MSVCRT_new_mode;
  47
  48 /* FIXME - According to documentation it should be 8*1024, at runtime it returns 16 */
  49 static unsigned int MSVCRT_amblksiz = 16;
  50 /* FIXME - According to documentation it should be 480 bytes, at runtime default is 0 */
  51 static MSVCRT_size_t MSVCRT_sbh_threshold = 0;
  52
  53 /*********************************************************************
  54  *              ??2@YAPAXI@Z (MSVCRT.@)
  55  */
  56 void* CDECL MSVCRT_operator_new(MSVCRT_size_t size)
  57 {
  58   void *retval;
  59   int freed;
  60
  61   do
  62   {
  63     retval = HeapAlloc(heap, 0, size);
  64     if(retval)
  65     {
  66       TRACE("(%ld) returning %p\n", size, retval);
  67       return retval;
  68     }
  69
  70     LOCK_HEAP;
  71     if(MSVCRT_new_handler)
  72       freed = (*MSVCRT_new_handler)(size);
  73     else
  74       freed = 0;
  75     UNLOCK_HEAP;
  76   } while(freed);
  77
  78   TRACE("(%ld) out of memory\n", size);
  79   return NULL;
  80 }
  81
  82
  83 /*********************************************************************
  84  *              ??2@YAPAXIHPBDH@Z (MSVCRT.@)
  85  */
  86 void* CDECL MSVCRT_operator_new_dbg(MSVCRT_size_t size, int type, const char *file, int line)
  87 {
  88     return MSVCRT_operator_new( size );
  89 }
  90
  91
  92 /*********************************************************************
  93  *              ??3@YAXPAX@Z (MSVCRT.@)
  94  */
  95 void CDECL MSVCRT_operator_delete(void *mem)
  96 {
  97   TRACE("(%p)\n", mem);
  98   HeapFree(heap, 0, mem);
  99 }
 100
 101
 102 /*********************************************************************
 103  *              ?_query_new_handler@@YAP6AHI@ZXZ (MSVCRT.@)
 104  */
 105 MSVCRT_new_handler_func CDECL MSVCRT__query_new_handler(void)
 106 {
 107   return MSVCRT_new_handler;
 108 }
 109
 110
 111 /*********************************************************************
 112  *              ?_query_new_mode@@YAHXZ (MSVCRT.@)
 113  */
 114 int CDECL MSVCRT__query_new_mode(void)
 115 {
 116   return MSVCRT_new_mode;
 117 }
 118
 119 /*********************************************************************
 120  *              ?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z (MSVCRT.@)
 121  */
 122 MSVCRT_new_handler_func CDECL MSVCRT__set_new_handler(MSVCRT_new_handler_func func)
 123 {
 124   MSVCRT_new_handler_func old_handler;
 125   LOCK_HEAP;
 126   old_handler = MSVCRT_new_handler;
 127   MSVCRT_new_handler = func;
 128   UNLOCK_HEAP;
 129   return old_handler;
 130 }
 131
 132 /*********************************************************************
 133  *              ?set_new_handler@@YAP6AXXZP6AXXZ@Z (MSVCRT.@)
 134  */
 135 MSVCRT_new_handler_func CDECL MSVCRT_set_new_handler(void *func)
 136 {
 137   TRACE("(%p)\n",func);
 138   MSVCRT__set_new_handler(NULL);
 139   return NULL;
 140 }
 141
 142 /*********************************************************************
 143  *              ?_set_new_mode@@YAHH@Z (MSVCRT.@)
 144  */
 145 int CDECL MSVCRT__set_new_mode(int mode)
 146 {
 147   int old_mode;
 148   LOCK_HEAP;
 149   old_mode = MSVCRT_new_mode;
 150   MSVCRT_new_mode = mode;
 151   UNLOCK_HEAP;
 152   return old_mode;
 153 }
 154
 155 /*********************************************************************
 156  *              _callnewh (MSVCRT.@)
 157  */
 158 int CDECL _callnewh(MSVCRT_size_t size)
 159 {
 160   if(MSVCRT_new_handler)
 161     (*MSVCRT_new_handler)(size);
 162   return 0;
 163 }
 164
 165 /*********************************************************************
 166  *              _expand (MSVCRT.@)
 167  */
 168 void* CDECL _expand(void* mem, MSVCRT_size_t size)
 169 {
 170   return HeapReAlloc(heap, HEAP_REALLOC_IN_PLACE_ONLY, mem, size);
 171 }
 172
 173 /*********************************************************************
 174  *              _heapchk (MSVCRT.@)
 175  */
 176 int CDECL _heapchk(void)
 177 {
 178   if (!HeapValidate( heap, 0, NULL))
 179   {
 180     msvcrt_set_errno(GetLastError());
 181     return MSVCRT__HEAPBADNODE;
 182   }
 183   return MSVCRT__HEAPOK;
 184 }
 185
 186 /*********************************************************************
 187  *              _heapmin (MSVCRT.@)
 188  */
 189 int CDECL _heapmin(void)
 190 {
 191   if (!HeapCompact( heap, 0 ))
 192   {
 193     if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
 194       msvcrt_set_errno(GetLastError());
 195     return -1;
 196   }
 197   return 0;
 198 }
 199
 200 /*********************************************************************
 201  *              _heapwalk (MSVCRT.@)
 202  */
 203 int CDECL _heapwalk(struct MSVCRT__heapinfo* next)
 204 {
 205   PROCESS_HEAP_ENTRY phe;
 206
 207   LOCK_HEAP;
 208   phe.lpData = next->_pentry;
 209   phe.cbData = next->_size;
 210   phe.wFlags = next->_useflag == MSVCRT__USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0;
 211
 212   if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY &&
 213       !HeapValidate( heap, 0, phe.lpData ))
 214   {
 215     UNLOCK_HEAP;
 216     msvcrt_set_errno(GetLastError());
 217     return MSVCRT__HEAPBADNODE;
 218   }
 219
 220   do
 221   {
 222     if (!HeapWalk( heap, &phe ))
 223     {
 224       UNLOCK_HEAP;
 225       if (GetLastError() == ERROR_NO_MORE_ITEMS)
 226          return MSVCRT__HEAPEND;
 227       msvcrt_set_errno(GetLastError());
 228       if (!phe.lpData)
 229         return MSVCRT__HEAPBADBEGIN;
 230       return MSVCRT__HEAPBADNODE;
 231     }
 232   } while (phe.wFlags & (PROCESS_HEAP_REGION|PROCESS_HEAP_UNCOMMITTED_RANGE));
 233
 234   UNLOCK_HEAP;
 235   next->_pentry = phe.lpData;
 236   next->_size = phe.cbData;
 237   next->_useflag = phe.wFlags & PROCESS_HEAP_ENTRY_BUSY ? MSVCRT__USEDENTRY : MSVCRT__FREEENTRY;
 238   return MSVCRT__HEAPOK;
 239 }
 240
 241 /*********************************************************************
 242  *              _heapset (MSVCRT.@)
 243  */
 244 int CDECL _heapset(unsigned int value)
 245 {
 246   int retval;
 247   struct MSVCRT__heapinfo heap;
 248
 249   memset( &heap, 0, sizeof(heap) );
 250   LOCK_HEAP;
 251   while ((retval = _heapwalk(&heap)) == MSVCRT__HEAPOK)
 252   {
 253     if (heap._useflag == MSVCRT__FREEENTRY)
 254       memset(heap._pentry, value, heap._size);
 255   }
 256   UNLOCK_HEAP;
 257   return retval == MSVCRT__HEAPEND? MSVCRT__HEAPOK : retval;
 258 }
 259
 260 /*********************************************************************
 261  *              _heapadd (MSVCRT.@)
 262  */
 263 int CDECL _heapadd(void* mem, MSVCRT_size_t size)
 264 {
 265   TRACE("(%p,%ld) unsupported in Win32\n", mem,size);
 266   *MSVCRT__errno() = MSVCRT_ENOSYS;
 267   return -1;
 268 }
 269
 270 /*********************************************************************
 271  *              _get_heap_handle (MSVCRT.@)
 272  */
 273 MSVCRT_intptr_t CDECL _get_heap_handle(void)
 274 {
 275     return (MSVCRT_intptr_t)heap;
 276 }
 277
 278 /*********************************************************************
 279  *              _msize (MSVCRT.@)
 280  */
 281 MSVCRT_size_t CDECL _msize(void* mem)
 282 {
 283   MSVCRT_size_t size = HeapSize(heap,0,mem);
 284   if (size == ~(MSVCRT_size_t)0)
 285   {
 286     WARN(":Probably called with non wine-allocated memory, ret = -1\n");
 287     /* At least the Win32 crtdll/msvcrt also return -1 in this case */
 288   }
 289   return size;
 290 }
 291
 292 /*********************************************************************
 293  * _aligned_msize (MSVCR100.@)
 294  */
 295 size_t CDECL _aligned_msize(void *p, MSVCRT_size_t alignment, MSVCRT_size_t offset)
 296 {
 297     void **alloc_ptr;
 298
 299     if(!MSVCRT_CHECK_PMT(p)) return -1;
 300
 301     if(alignment < sizeof(void*))
 302         alignment = sizeof(void*);
 303
 304     alloc_ptr = SAVED_PTR(p);
 305     return _msize(*alloc_ptr)-alignment-sizeof(void*);
 306 }
 307
 308 /*********************************************************************
 309  *              calloc (MSVCRT.@)
 310  */
 311 void* CDECL MSVCRT_calloc(MSVCRT_size_t size, MSVCRT_size_t count)
 312 {
 313   return HeapAlloc( heap, HEAP_ZERO_MEMORY, size * count );
 314 }
 315
 316 /*********************************************************************
 317  *              free (MSVCRT.@)
 318  */
 319 void CDECL MSVCRT_free(void* ptr)
 320 {
 321   HeapFree(heap,0,ptr);
 322 }
 323
 324 /*********************************************************************
 325  *                  malloc (MSVCRT.@)
 326  */
 327 void* CDECL MSVCRT_malloc(MSVCRT_size_t size)
 328 {
 329   void *ret = HeapAlloc(heap,0,size);
 330   if (!ret)
 331       *MSVCRT__errno() = MSVCRT_ENOMEM;
 332   return ret;
 333 }
 334
 335 /*********************************************************************
 336  *              realloc (MSVCRT.@)
 337  */
 338 void* CDECL MSVCRT_realloc(void* ptr, MSVCRT_size_t size)
 339 {
 340   if (!ptr) return MSVCRT_malloc(size);
 341   if (size) return HeapReAlloc(heap, 0, ptr, size);
 342   MSVCRT_free(ptr);
 343   return NULL;
 344 }
 345
 346 /*********************************************************************
 347  * _recalloc (MSVCR100.@)
 348  */
 349 void* CDECL _recalloc(void *mem, MSVCRT_size_t num, MSVCRT_size_t size)
 350 {
 351     MSVCRT_size_t old_size;
 352     void *ret;
 353
 354     if(!mem)
 355         return MSVCRT_calloc(num, size);
 356
 357     size = num*size;
 358     old_size = _msize(mem);
 359
 360     ret = MSVCRT_realloc(mem, size);
 361     if(!ret) {
 362         *MSVCRT__errno() = MSVCRT_ENOMEM;
 363         return NULL;
 364     }
 365
 366     if(size>old_size)
 367         memset((BYTE*)ret+old_size, 0, size-old_size);
 368     return ret;
 369 }
 370
 371 /*********************************************************************
 372  *              __p__amblksiz (MSVCRT.@)
 373  */
 374 unsigned int* CDECL __p__amblksiz(void)
 375 {
 376   return &MSVCRT_amblksiz;
 377 }
 378
 379 /*********************************************************************
 380  *              _get_sbh_threshold (MSVCRT.@)
 381  */
 382 MSVCRT_size_t CDECL _get_sbh_threshold(void)
 383 {
 384   return MSVCRT_sbh_threshold;
 385 }
 386
 387 /*********************************************************************
 388  *              _set_sbh_threshold (MSVCRT.@)
 389  */
 390 int CDECL _set_sbh_threshold(MSVCRT_size_t threshold)
 391 {
 392   if(threshold > 1016)
 393      return 0;
 394   else
 395      MSVCRT_sbh_threshold = threshold;
 396   return 1;
 397 }
 398
 399 /*********************************************************************
 400  *              _aligned_free (MSVCRT.@)
 401  */
 402 void CDECL _aligned_free(void *memblock)
 403 {
 404     TRACE("(%p)\n", memblock);
 405
 406     if (memblock)
 407     {
 408         void **saved = SAVED_PTR(memblock);
 409         MSVCRT_free(*saved);
 410     }
 411 }
 412
 413 /*********************************************************************
 414  *              _aligned_offset_malloc (MSVCRT.@)
 415  */
 416 void * CDECL _aligned_offset_malloc(MSVCRT_size_t size, MSVCRT_size_t alignment, MSVCRT_size_t offset)
 417 {
 418     void *memblock, *temp, **saved;
 419     TRACE("(%lu, %lu, %lu)\n", size, alignment, offset);
 420
 421     /* alignment must be a power of 2 */
 422     if ((alignment & (alignment - 1)) != 0)
 423     {
 424         *MSVCRT__errno() = MSVCRT_EINVAL;
 425         return NULL;
 426     }
 427
 428     /* offset must be less than size */
 429     if (offset && offset >= size)
 430     {
 431         *MSVCRT__errno() = MSVCRT_EINVAL;
 432         return NULL;
 433     }
 434
 435     /* don't align to less than void pointer size */
 436     if (alignment < sizeof(void *))
 437         alignment = sizeof(void *);
 438
 439     /* allocate enough space for void pointer and alignment */
 440     temp = MSVCRT_malloc(size + alignment + sizeof(void *));
 441
 442     if (!temp)
 443         return NULL;
 444
 445     /* adjust pointer for proper alignment and offset */
 446     memblock = ALIGN_PTR(temp, alignment, offset);
 447
 448     /* Save the real allocation address below returned address */
 449     /* so it can be found later to free. */
 450     saved = SAVED_PTR(memblock);
 451     *saved = temp;
 452
 453     return memblock;
 454 }
 455
 456 /*********************************************************************
 457  *              _aligned_malloc (MSVCRT.@)
 458  */
 459 void * CDECL _aligned_malloc(MSVCRT_size_t size, MSVCRT_size_t alignment)
 460 {
 461     TRACE("(%lu, %lu)\n", size, alignment);
 462     return _aligned_offset_malloc(size, alignment, 0);
 463 }
 464
 465 /*********************************************************************
 466  *              _aligned_offset_realloc (MSVCRT.@)
 467  */
 468 void * CDECL _aligned_offset_realloc(void *memblock, MSVCRT_size_t size,
 469                                      MSVCRT_size_t alignment, MSVCRT_size_t offset)
 470 {
 471     void * temp, **saved;
 472     MSVCRT_size_t old_padding, new_padding, old_size;
 473     TRACE("(%p, %lu, %lu, %lu)\n", memblock, size, alignment, offset);
 474
 475     if (!memblock)
 476         return _aligned_offset_malloc(size, alignment, offset);
 477
 478     /* alignment must be a power of 2 */
 479     if ((alignment & (alignment - 1)) != 0)
 480     {
 481         *MSVCRT__errno() = MSVCRT_EINVAL;
 482         return NULL;
 483     }
 484
 485     /* offset must be less than size */
 486     if (offset >= size)
 487     {
 488         *MSVCRT__errno() = MSVCRT_EINVAL;
 489         return NULL;
 490     }
 491
 492     if (size == 0)
 493     {
 494         _aligned_free(memblock);
 495         return NULL;
 496     }
 497
 498     /* don't align to less than void pointer size */
 499     if (alignment < sizeof(void *))
 500         alignment = sizeof(void *);
 501
 502     /* make sure alignment and offset didn't change */
 503     saved = SAVED_PTR(memblock);
 504     if (memblock != ALIGN_PTR(*saved, alignment, offset))
 505     {
 506         *MSVCRT__errno() = MSVCRT_EINVAL;
 507         return NULL;
 508     }
 509
 510     old_padding = (char *)memblock - (char *)*saved;
 511
 512     /* Get previous size of block */
 513     old_size = _msize(*saved);
 514     if (old_size == -1)
 515     {
 516         /* It seems this function was called with an invalid pointer. Bail out. */
 517         return NULL;
 518     }
 519
 520     /* Adjust old_size to get amount of actual data in old block. */
 521     if (old_size < old_padding)
 522     {
 523         /* Shouldn't happen. Something's weird, so bail out. */
 524         return NULL;
 525     }
 526     old_size -= old_padding;
 527
 528     temp = MSVCRT_realloc(*saved, size + alignment + sizeof(void *));
 529
 530     if (!temp)
 531         return NULL;
 532
 533     /* adjust pointer for proper alignment and offset */
 534     memblock = ALIGN_PTR(temp, alignment, offset);
 535
 536     /* Save the real allocation address below returned address */
 537     /* so it can be found later to free. */
 538     saved = SAVED_PTR(memblock);
 539
 540     new_padding = (char *)memblock - (char *)temp;
 541
 542 /*
 543    Memory layout of old block is as follows:
 544    +-------+---------------------+-+--------------------------+-----------+
 545    |  ...  | "old_padding" bytes | | ... "old_size" bytes ... |    ...    |
 546    +-------+---------------------+-+--------------------------+-----------+
 547            ^                     ^ ^
 548            |                     | |
 549         *saved               saved memblock
 550
 551    Memory layout of new block is as follows:
 552    +-------+-----------------------------+-+----------------------+-------+
 553    |  ...  |    "new_padding" bytes      | | ... "size" bytes ... |  ...  |
 554    +-------+-----------------------------+-+----------------------+-------+
 555            ^                             ^ ^
 556            |                             | |
 557           temp                       saved memblock
 558
 559    However, in the new block, actual data is still written as follows
 560    (because it was copied by MSVCRT_realloc):
 561    +-------+---------------------+--------------------------------+-------+
 562    |  ...  | "old_padding" bytes |   ... "old_size" bytes ...     |  ...  |
 563    +-------+---------------------+--------------------------------+-------+
 564            ^                             ^ ^
 565            |                             | |
 566           temp                       saved memblock
 567
 568    Therefore, min(old_size,size) bytes of actual data have to be moved
 569    from the offset they were at in the old block (temp + old_padding),
 570    to the offset they have to be in the new block (temp + new_padding == memblock).
 571 */
 572     if (new_padding != old_padding)
 573         memmove((char *)memblock, (char *)temp + old_padding, (old_size < size) ? old_size : size);
 574
 575     *saved = temp;
 576
 577     return memblock;
 578 }
 579
 580 /*********************************************************************
 581  *              _aligned_realloc (MSVCRT.@)
 582  */
 583 void * CDECL _aligned_realloc(void *memblock, MSVCRT_size_t size, MSVCRT_size_t alignment)
 584 {
 585     TRACE("(%p, %lu, %lu)\n", memblock, size, alignment);
 586     return _aligned_offset_realloc(memblock, size, alignment, 0);
 587 }
 588
 589 /*********************************************************************
 590  *              memmove_s (MSVCRT.@)
 591  */
 592 int CDECL MSVCRT_memmove_s(void *dest, MSVCRT_size_t numberOfElements, const void *src, MSVCRT_size_t count)
 593 {
 594     TRACE("(%p %lu %p %lu)\n", dest, numberOfElements, src, count);
 595
 596     if(!count)
 597         return 0;
 598
 599     if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
 600     if (!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
 601     if (!MSVCRT_CHECK_PMT_ERR( count <= numberOfElements, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
 602
 603     memmove(dest, src, count);
 604     return 0;
 605 }
 606
 607 /*********************************************************************
 608  *              wmemmove_s (MSVCR100.@)
 609  */
 610 int CDECL wmemmove_s(MSVCRT_wchar_t *dest, MSVCRT_size_t numberOfElements,
 611         const MSVCRT_wchar_t *src, MSVCRT_size_t count)
 612 {
 613     TRACE("(%p %lu %p %lu)\n", dest, numberOfElements, src, count);
 614
 615     if (!count)
 616         return 0;
 617
 618     /* Native does not seem to conform to 6.7.1.2.3 in
 619      * http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1225.pdf
 620      * in that it does not zero the output buffer on constraint violation.
 621      */
 622     if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
 623     if (!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
 624     if (!MSVCRT_CHECK_PMT_ERR(count <= numberOfElements, MSVCRT_ERANGE)) return MSVCRT_ERANGE;
 625
 626     memmove(dest, src, sizeof(MSVCRT_wchar_t)*count);
 627     return 0;
 628 }
 629
 630 /*********************************************************************
 631  *              memcpy_s (MSVCRT.@)
 632  */
 633 int CDECL MSVCRT_memcpy_s(void *dest, MSVCRT_size_t numberOfElements, const void *src, MSVCRT_size_t count)
 634 {
 635     TRACE("(%p %lu %p %lu)\n", dest, numberOfElements, src, count);
 636
 637     if(!count)
 638         return 0;
 639
 640     if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
 641     if (!MSVCRT_CHECK_PMT(src != NULL))
 642     {
 643         memset(dest, 0, numberOfElements);
 644         return MSVCRT_EINVAL;
 645     }
 646     if (!MSVCRT_CHECK_PMT_ERR( count <= numberOfElements, MSVCRT_ERANGE ))
 647     {
 648         memset(dest, 0, numberOfElements);
 649         return MSVCRT_ERANGE;
 650     }
 651
 652     memcpy(dest, src, count);
 653     return 0;
 654 }
 655
 656 /*********************************************************************
 657  *              wmemcpy_s (MSVCR100.@)
 658  */
 659 int CDECL wmemcpy_s(MSVCRT_wchar_t *dest, MSVCRT_size_t numberOfElements,
 660         const MSVCRT_wchar_t *src, MSVCRT_size_t count)
 661 {
 662     TRACE("(%p %lu %p %lu)\n", dest, numberOfElements, src, count);
 663
 664     if (!count)
 665         return 0;
 666
 667     if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
 668
 669     if (!MSVCRT_CHECK_PMT(src != NULL)) {
 670         memset(dest, 0, numberOfElements*sizeof(MSVCRT_wchar_t));
 671         return MSVCRT_EINVAL;
 672     }
 673     if (!MSVCRT_CHECK_PMT_ERR(count <= numberOfElements, MSVCRT_ERANGE)) {
 674         memset(dest, 0, numberOfElements*sizeof(MSVCRT_wchar_t));
 675         return MSVCRT_ERANGE;
 676     }
 677
 678     memcpy(dest, src, sizeof(MSVCRT_wchar_t)*count);
 679     return 0;
 680 }
 681
 682 /*********************************************************************
 683  *              strncpy_s (MSVCRT.@)
 684  */
 685 int CDECL MSVCRT_strncpy_s(char *dest, MSVCRT_size_t numberOfElements,
 686         const char *src, MSVCRT_size_t count)
 687 {
 688     MSVCRT_size_t i, end;
 689
 690     TRACE("(%p %lu %s %lu)\n", dest, numberOfElements, debugstr_a(src), count);
 691
 692     if(!count) {
 693         if(dest && numberOfElements)
 694             *dest = 0;
 695         return 0;
 696     }
 697
 698     if (!MSVCRT_CHECK_PMT(dest != NULL)) return MSVCRT_EINVAL;
 699     if (!MSVCRT_CHECK_PMT(src != NULL)) return MSVCRT_EINVAL;
 700     if (!MSVCRT_CHECK_PMT(numberOfElements != 0)) return MSVCRT_EINVAL;
 701
 702     if(count!=MSVCRT__TRUNCATE && count<numberOfElements)
 703         end = count;
 704     else
 705         end = numberOfElements-1;
 706
 707     for(i=0; i<end && src[i]; i++)
 708         dest[i] = src[i];
 709
 710     if(!src[i] || end==count || count==MSVCRT__TRUNCATE) {
 711         dest[i] = '\0';
 712         return 0;
 713     }
 714
 715     MSVCRT_INVALID_PMT("dest[numberOfElements] is too small", MSVCRT_EINVAL);
 716     dest[0] = '\0';
 717     return MSVCRT_EINVAL;
 718 }
 719
 720 BOOL msvcrt_init_heap(void)
 721 {
 722     heap = HeapCreate(0, 0, 0);
 723     return heap != NULL;
 724 }
 725
 726 void msvcrt_destroy_heap(void)
 727 {
 728     HeapDestroy(heap);
 729 }