wchar_t * __cdecl _wcsdup (
const wchar_t * string
)
#endif /* _DEBUG */
{
wchar_t *memory;
size_t size = 0;
if (!string)
return(NULL);
size = wcslen(string) + 1;
#ifdef _DEBUG
if (memory = (wchar_t *) _calloc_dbg(size, sizeof(wchar_t), nBlockUse, szFileName, nLine))
#else /* _DEBUG */
if (memory = (wchar_t *) calloc(size, sizeof(wchar_t)))
#endif /* _DEBUG */
{
_ERRCHECK(wcscpy_s(memory, size, string));
return memory;
}
return(NULL);
}
/**
Allocate a sized block of memory.
@param size The size of the memory block in bytes.
@param flags Failure action modifiers (bitmasks).
@return A pointer to the allocated memory block, or NULL on failure.
*/
static void *my_raw_malloc(size_t size, myf my_flags)
{
void* point;
DBUG_ENTER("my_raw_malloc");
DBUG_PRINT("my",("size: %lu my_flags: %d", (ulong) size, my_flags));
/* Safety */
if (!size)
size=1;
#if defined(MY_MSCRT_DEBUG)
if (my_flags & MY_ZEROFILL)
point= _calloc_dbg(size, 1, _CLIENT_BLOCK, __FILE__, __LINE__);
else
point= _malloc_dbg(size, _CLIENT_BLOCK, __FILE__, __LINE__);
#else
if (my_flags & MY_ZEROFILL)
point= calloc(size, 1);
else
point= malloc(size);
#endif
DBUG_EXECUTE_IF("simulate_out_of_memory",
{
free(point);
point= NULL;
});
static Character* __cdecl common_tempnam(
Character const* const alternative,
Character const* const prefix,
int const block_use,
char const* const file_name,
int const line_number
) throw()
{
// These are referenced only in the Debug CRT build
UNREFERENCED_PARAMETER(block_use);
UNREFERENCED_PARAMETER(file_name);
UNREFERENCED_PARAMETER(line_number);
typedef __acrt_stdio_char_traits<Character> stdio_traits;
Character const* directory = nullptr;
__crt_unique_heap_ptr<Character const> const directory_cleanup(get_directory(alternative, &directory));
unsigned const prefix_length = prefix != nullptr
? static_cast<unsigned>(stdio_traits::tcslen(prefix))
: 0;
// The 12 allows for a backslash, a ten character temporary string, and a
// null terminator.
unsigned const buffer_size = static_cast<unsigned>(stdio_traits::tcslen(directory)) + prefix_length + 12;
__crt_unique_heap_ptr<Character, __crt_public_free_policy> result(
static_cast<Character*>(_calloc_dbg(
buffer_size,
sizeof(Character),
block_use,
file_name,
line_number)));
if (!result)
return nullptr;
*result.get() = 0;
_ERRCHECK(stdio_traits::tcscat_s(result.get(), buffer_size, directory));
if (__crt_stdio_path_requires_backslash(directory))
{
static Character const backslash[] = { '\\', '\0' };
_ERRCHECK(stdio_traits::tcscat_s(result.get(), buffer_size, backslash));
}
if (prefix != nullptr)
{
_ERRCHECK(stdio_traits::tcscat_s(result.get(), buffer_size, prefix));
}
Character* const ptr = result.get() + stdio_traits::tcslen(result.get());
size_t const ptr_size = buffer_size - (ptr - result.get());
if (!compute_name(result.get(), ptr, ptr_size, prefix_length))
return nullptr;
return result.detach();
}
void* BioAPI _BioAPI_calloc(uint32 num, uint32 size, void* ref,
const char * szFilename, uint32 u32LineNumber)
{
#ifdef _DEBUG
return _calloc_dbg( num, size, _NORMAL_BLOCK, szFilename, u32LineNumber );
#else
return calloc( num, size );
#endif
}
void allocCalloc(bool bFree)
{
int* leaked_memory = (int*)calloc(47, sizeof(int));
int* leaked_memory_dbg = (int*)_calloc_dbg(39, sizeof(int), _NORMAL_BLOCK, __FILE__, __LINE__);
if (bFree)
{
free(leaked_memory);
_free_dbg(leaked_memory_dbg, _NORMAL_BLOCK);
}
}
static void *CallocCHK(size_t count, size_t size)
#endif
{
unsigned long *p;
unsigned char *tmp;
#if defined BLAK_PLATFORM_WINDOWS && !defined NDEBUG
tmp = (unsigned char*)_calloc_dbg(count, (sizeof(unsigned long) * 3), _NORMAL_BLOCK, filename, linenumber);
#else
tmp = (unsigned char *)calloc(count, size);
#endif
if (tmp == NULL) {
return NULL;
}
p = (unsigned long *)tmp;
#ifdef MDEBUG
printf("Size Req: %d Size Got: %d\n", count * size, count * (size + (sizeof(unsigned long) * 3)));
printf("Block at: 0x%lx\n", p);
#endif
/* store actual size of allocated block */
p[0] = size;
/* store our check token */
p[1] = MCHK_START;
p = (unsigned long*)(tmp + (count * (size + (sizeof(unsigned long) * 2))));
p[0] = MCHK_END;
tmp += 8;
#ifdef MDEBUG
printf("End: 0x%lx \n", p);
printf("Actual: 0x%lx \n", tmp);
#endif
/*
Charlie:
Boundschecker 6.604 will complain about memory being leaked from this scope,
its half right, if theres two messages about it, then it really is
being leaked
*/
return tmp;
}
/*
* A calloc() that fails if no memory. It's pretty hopeless to continue
* this program if calloc() fails.
*/
void *calloc_at (size_t num, size_t size, const char *file, unsigned line)
{
struct mem_head *head;
size = (size * num) + sizeof(*head);
#if defined(_CRTDBG_MAP_ALLOC) /* cl -MDd .. */
head = _calloc_dbg (1, size, _NORMAL_BLOCK, file, line);
#else
head = calloc (1, size);
#endif
if (!head)
FATAL ("calloc() failed at %s, line %u\n", file, line);
head->marker = MEM_MARKER;
head->size = size;
add_to_mem_list (head, file, line);
mem_max += size;
mem_allocs++;
return (head+1);
}
void *__cdecl _calloc_dbg_impl( size_t nNum, size_t nSize, int nBlockUse,
const char * szFileName, int nLine, int * errno_tmp )
{
return _calloc_dbg( nNum, nSize, nBlockUse, szFileName, nLine );
}
