/*
 * msvcrt.dll heap functions
 *
 * Copyright 2000 Jon Griffiths
 *
 * Note: Win32 heap operations are MT safe. We only lock the new
 *       handler and non atomic heap operations
 */

#include "msvcrt.h"

DEFAULT_DEBUG_CHANNEL(msvcrt);

/* MT */
extern CRITICAL_SECTION MSVCRT_heap_cs;
#define LOCK_HEAP      EnterCriticalSection(&MSVCRT_heap_cs)
#define UNLOCK_HEAP    LeaveCriticalSection(&MSVCRT_heap_cs)

/* heap function constants */
#define MSVCRT_HEAPEMPTY    -1
#define MSVCRT_HEAPOK       -2
#define MSVCRT_HEAPBADBEGIN -3
#define MSVCRT_HEAPBADNODE  -4
#define MSVCRT_HEAPEND      -5
#define MSVCRT_HEAPBADPTR   -6
#define MSVCRT_FREEENTRY    0
#define MSVCRT_USEDENTRY    1

typedef struct MSVCRT_heapinfo
{
  int * _pentry;
  size_t _size;
  int    _useflag;
} MSVCRT_HEAPINFO;

typedef void (*MSVCRT_new_handler_func)(void);

static MSVCRT_new_handler_func MSVCRT_new_handler;
static int MSVCRT_new_mode;

/*********************************************************************
 *		??2@YAPAXI@Z (MSVCRT.@)
 */
void *__cdecl MSVCRT_operator_new(unsigned long size)
{
  void *retval = HeapAlloc(GetProcessHeap(), 0, size);
  TRACE("(%ld) returning %p\n", size, retval);
  LOCK_HEAP;
  if(retval && MSVCRT_new_handler)
    (*MSVCRT_new_handler)();
  UNLOCK_HEAP;
  return retval;
}

/*********************************************************************
 *		??3@YAXPAX@Z (MSVCRT.@)
 */
void __cdecl MSVCRT_operator_delete(void *mem)
{
  TRACE("(%p)\n", mem);
  HeapFree(GetProcessHeap(), 0, mem);
}


/*********************************************************************
 *		?_query_new_handler@@YAP6AHI@ZXZ (MSVCRT.@)
 */
MSVCRT_new_handler_func __cdecl MSVCRT__query_new_handler(void)
{
  return MSVCRT_new_handler;
}


/*********************************************************************
 *		?_query_new_mode@@YAHXZ (MSVCRT.@)
 */
int __cdecl MSVCRT__query_new_mode(void)
{
  return MSVCRT_new_mode;
}

/*********************************************************************
 *		?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z (MSVCRT.@)
 */
MSVCRT_new_handler_func __cdecl MSVCRT__set_new_handler(MSVCRT_new_handler_func func)
{
  MSVCRT_new_handler_func old_handler;
  LOCK_HEAP;
  old_handler = MSVCRT_new_handler;
  MSVCRT_new_handler = func;
  UNLOCK_HEAP;
  return old_handler;
}

/*********************************************************************
 *		?_set_new_mode@@YAHH@Z (MSVCRT.@)
 */
int __cdecl MSVCRT__set_new_mode(int mode)
{
  int old_mode;
  LOCK_HEAP;
  old_mode = MSVCRT_new_mode;
  MSVCRT_new_mode = mode;
  UNLOCK_HEAP;
  return old_mode;
}

/*********************************************************************
 *		_expand (MSVCRT.@)
 */
void *__cdecl MSVCRT__expand(void *mem, unsigned int size)
{
  return HeapReAlloc(GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, mem, size);
}

/*********************************************************************
 *		_heapchk (MSVCRT.@)
 */
int __cdecl MSVCRT__heapchk(void)
{
  if (!HeapValidate( GetProcessHeap(), 0, NULL))
  {
    MSVCRT__set_errno(GetLastError());
    return MSVCRT_HEAPBADNODE;
  }
  return MSVCRT_HEAPOK;
}

/*********************************************************************
 *		_heapmin (MSVCRT.@)
 */
int __cdecl MSVCRT__heapmin(void)
{
  if (!HeapCompact( GetProcessHeap(), 0 ))
  {
    if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
      MSVCRT__set_errno(GetLastError());
    return -1;
  }
  return 0;
}

/*********************************************************************
 *		_heapwalk (MSVCRT.@)
 */
int __cdecl MSVCRT__heapwalk(MSVCRT_HEAPINFO *next)
{
  PROCESS_HEAP_ENTRY phe;

  LOCK_HEAP;
  phe.lpData = next->_pentry;
  phe.cbData = next->_size;
  phe.wFlags = next->_useflag == MSVCRT_USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0;

  if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY &&
      !HeapValidate( GetProcessHeap(), 0, phe.lpData ))
  {
    UNLOCK_HEAP;
    MSVCRT__set_errno(GetLastError());
    return MSVCRT_HEAPBADNODE;
  }

  do
  {
    if (!HeapWalk( GetProcessHeap(), &phe ))
    {
      UNLOCK_HEAP;
      if (GetLastError() == ERROR_NO_MORE_ITEMS)
         return MSVCRT_HEAPEND;
      MSVCRT__set_errno(GetLastError());
      if (!phe.lpData)
        return MSVCRT_HEAPBADBEGIN;
      return MSVCRT_HEAPBADNODE;
    }
  } while (phe.wFlags & (PROCESS_HEAP_REGION|PROCESS_HEAP_UNCOMMITTED_RANGE));

  UNLOCK_HEAP;
  next->_pentry = phe.lpData;
  next->_size = phe.cbData;
  next->_useflag = phe.wFlags & PROCESS_HEAP_ENTRY_BUSY ? MSVCRT_USEDENTRY : MSVCRT_FREEENTRY;
  return MSVCRT_HEAPOK;
}

/*********************************************************************
 *		_heapset (MSVCRT.@)
 */
int __cdecl MSVCRT__heapset(unsigned int value)
{
  int retval;
  MSVCRT_HEAPINFO heap;

  memset( &heap, 0, sizeof(MSVCRT_HEAPINFO) );
  LOCK_HEAP;
  while ((retval = MSVCRT__heapwalk(&heap)) == MSVCRT_HEAPOK)
  {
    if (heap._useflag == MSVCRT_FREEENTRY)
      memset(heap._pentry, value, heap._size);
  }
  UNLOCK_HEAP;
  return retval == MSVCRT_HEAPEND? MSVCRT_HEAPOK : retval;
}

/*********************************************************************
 *		_msize (MSVCRT.@)
 */
long __cdecl MSVCRT__msize(void *mem)
{
  long size = HeapSize(GetProcessHeap(),0,mem);
  if (size == -1)
  {
    WARN(":Probably called with non wine-allocated memory, ret = -1\n");
    /* At least the Win32 crtdll/msvcrt also return -1 in this case */
  }
  return size;
}

/*********************************************************************
 *		calloc (MSVCRT.@)
 */
void *__cdecl MSVCRT_calloc(unsigned int size, unsigned int count)
{
  return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size * count );
}

/*********************************************************************
 *		free (MSVCRT.@)
 */
void __cdecl MSVCRT_free(void *ptr)
{
  HeapFree(GetProcessHeap(),0,ptr);
}

/*********************************************************************
 *                  malloc (MSVCRT.@)
 */
void * __cdecl MSVCRT_malloc(unsigned int size)
{
  void *ret = HeapAlloc(GetProcessHeap(),0,size);
  if (!ret)
    MSVCRT__set_errno(GetLastError());
  return ret;
}

/*********************************************************************
 *		realloc (MSVCRT.@)
 */
void *__cdecl MSVCRT_realloc(void *ptr, unsigned int size)
{
  return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
}