git.saurik.com Git - apple/icu.git/blame_incremental

... / ...

Commit	Line	Data
	1	/*
	2	******************************************************************************
	3	*
	4	* Copyright (C) 2002-2015, International Business Machines
	5	* Corporation and others. All Rights Reserved.
	6	*
	7	******************************************************************************
	8	*
	9	* File cmemory.c ICU Heap allocation.
	10	* All ICU heap allocation, both for C and C++ new of ICU
	11	* class types, comes through these functions.
	12	*
	13	* If you have a need to replace ICU allocation, this is the
	14	* place to do it.
	15	*
	16	* Note that uprv_malloc(0) returns a non-NULL pointer, and
	17	* that a subsequent free of that pointer value is a NOP.
	18	*
	19	******************************************************************************
	20	*/
	21	#include "unicode/uclean.h"
	22	#include "cmemory.h"
	23	#include "putilimp.h"
	24	#include "uassert.h"
	25	#include <stdlib.h>
	26
	27	/* uprv_malloc(0) returns a pointer to this read-only data. */
	28	static const int32_t zeroMem[] = {0, 0, 0, 0, 0, 0};
	29
	30	/* Function Pointers for user-supplied heap functions */
	31	static const void *pContext;
	32	static UMemAllocFn *pAlloc;
	33	static UMemReallocFn *pRealloc;
	34	static UMemFreeFn *pFree;
	35
	36	#if U_DEBUG && defined(UPRV_MALLOC_COUNT)
	37	#include <stdio.h>
	38	static int n=0;
	39	static long b=0;
	40	#endif
	41
	42	#if U_DEBUG
	43
	44	static char gValidMemorySink = 0;
	45
	46	U_CAPI void uprv_checkValidMemory(const void *p, size_t n) {
	47	/*
	48	* Access the memory to ensure that it's all valid.
	49	* Load and save a computed value to try to ensure that the compiler
	50	* does not throw away the whole loop.
	51	* A thread analyzer might complain about un-mutexed access to gValidMemorySink
	52	* which is true but harmless because no one ever uses the value in gValidMemorySink.
	53	*/
	54	const char s = (const char )p;
	55	char c = gValidMemorySink;
	56	size_t i;
	57	U_ASSERT(p != NULL);
	58	for(i = 0; i < n; ++i) {
	59	c ^= s[i];
	60	}
	61	gValidMemorySink = c;
	62	}
	63
	64	#endif /* U_DEBUG */
	65
	66	U_CAPI void * U_EXPORT2
	67	uprv_malloc(size_t s) {
	68	#if U_DEBUG && defined(UPRV_MALLOC_COUNT)
	69	#if 1
	70	putchar('>');
	71	fflush(stdout);
	72	#else
	73	fprintf(stderr,"MALLOC\t#%d\t%ul bytes\t%ul total\n", ++n,s,(b+=s)); fflush(stderr);
	74	#endif
	75	#endif
	76	if (s > 0) {
	77	if (pAlloc) {
	78	return (*pAlloc)(pContext, s);
	79	} else {
	80	return uprv_default_malloc(s);
	81	}
	82	} else {
	83	return (void *)zeroMem;
	84	}
	85	}
	86
	87	U_CAPI void * U_EXPORT2
	88	uprv_realloc(void * buffer, size_t size) {
	89	#if U_DEBUG && defined(UPRV_MALLOC_COUNT)
	90	putchar('~');
	91	fflush(stdout);
	92	#endif
	93	if (buffer == zeroMem) {
	94	return uprv_malloc(size);
	95	} else if (size == 0) {
	96	if (pFree) {
	97	(*pFree)(pContext, buffer);
	98	} else {
	99	uprv_default_free(buffer);
	100	}
	101	return (void *)zeroMem;
	102	} else {
	103	if (pRealloc) {
	104	return (*pRealloc)(pContext, buffer, size);
	105	} else {
	106	return uprv_default_realloc(buffer, size);
	107	}
	108	}
	109	}
	110
	111	U_CAPI void U_EXPORT2
	112	uprv_free(void *buffer) {
	113	#if U_DEBUG && defined(UPRV_MALLOC_COUNT)
	114	putchar('<');
	115	fflush(stdout);
	116	#endif
	117	if (buffer != zeroMem) {
	118	if (pFree) {
	119	(*pFree)(pContext, buffer);
	120	} else {
	121	uprv_default_free(buffer);
	122	}
	123	}
	124	}
	125
	126	U_CAPI void * U_EXPORT2
	127	uprv_calloc(size_t num, size_t size) {
	128	void *mem = NULL;
	129	size *= num;
	130	mem = uprv_malloc(size);
	131	if (mem) {
	132	uprv_memset(mem, 0, size);
	133	}
	134	return mem;
	135	}
	136
	137	U_CAPI void U_EXPORT2
	138	u_setMemoryFunctions(const void context, UMemAllocFn a, UMemReallocFn r, UMemFreeFn f, UErrorCode *status)
	139	{
	140	if (U_FAILURE(*status)) {
	141	return;
	142	}
	143	if (a==NULL \|\| r==NULL \|\| f==NULL) {
	144	*status = U_ILLEGAL_ARGUMENT_ERROR;
	145	return;
	146	}
	147	pContext = context;
	148	pAlloc = a;
	149	pRealloc = r;
	150	pFree = f;
	151	}
	152
	153
	154	U_CFUNC UBool cmemory_cleanup(void) {
	155	pContext = NULL;
	156	pAlloc = NULL;
	157	pRealloc = NULL;
	158	pFree = NULL;
	159	return TRUE;
	160	}