#include <stdarg.h>
#include <sofia-sip/su_config.h>
Include dependency graph for su_alloc.h:
Go to the source code of this file.
Data Structures | |
struct | su_home_s |
Memory home structure. More... | |
Typedefs | |
typedef SU_HOME_T | su_home_t |
Memory home type. | |
typedef su_alock | su_alock_t |
Thread-locking function. | |
Functions | |
void * | su_home_new (int size)) |
Create a new su_home_t object. | |
void * | su_home_ref (su_home_t const *) |
Create a new reference to a home object. | |
int | su_home_unref (su_home_t *) |
Unreference a su_home_t object. | |
int | su_home_desctructor (su_home_t *, void(*)(void *)) |
Set destructor function. | |
void * | su_home_clone (su_home_t *parent, int size)) |
Clone a su_home_t object. | |
int | su_home_init (su_home_t *h) |
Initialize an su_home_t object. | |
void | su_home_deinit (su_home_t *h) |
Free memory blocks allocated through home. | |
void | su_home_preload (su_home_t *h, int n, int size) |
Preload a memory home. | |
su_home_t * | su_home_auto (void *area, int size) |
Preload a memory home from stack. | |
int | su_home_move (su_home_t *dst, su_home_t *src) |
Move allocations from a su_home_t object to another. | |
int | su_home_threadsafe (su_home_t *home) |
Convert su_home_t object to a thread-safe one. | |
int | su_home_has_parent (su_home_t const *home) |
Return true if home is a clone. | |
void | su_home_check (su_home_t const *home) |
Check home consistency. | |
int | su_home_mutex_lock (su_home_t *home) |
Obtain exclusive lock on home (if home is threadsafe). | |
int | su_home_mutex_unlock (su_home_t *home) |
Release exclusive lock on home (if home is threadsafe). | |
void * | su_alloc (su_home_t *h, int size)) |
Allocate a memory block. | |
void * | su_zalloc (su_home_t *h, int size)) |
Allocate and zero a memory block. | |
void * | su_salloc (su_home_t *h, int size)) |
Allocate a structure. | |
void * | su_realloc (su_home_t *h, void *data, int size)) |
Reallocate a memory block. | |
char * | su_strdup (su_home_t *home, char const *s)) |
Duplicate a string, allocate memory from home. | |
char * | su_strcat (su_home_t *home, char const *s1, char const *s2)) |
Concate two strings, allocate memory for result from home. | |
char * | su_strndup (su_home_t *home, char const *s, int n)) |
Duplicate a string with given size, allocate memory from home. | |
char * | su_strcat_all (su_home_t *home,...)) |
Concate multiple strings, allocate memory for result from home. | |
char * | su_sprintf (su_home_t *home, char const *fmt,...))) |
Copy a formatted string. | |
char * | su_vsprintf (su_home_t *home, char const *fmt, va_list ap)) |
Copy a formatted string. | |
void | su_free (su_home_t *h, void *) |
Free a memory block. | |
int | su_home_is_threadsafe (su_home_t const *home) |
Check if a memory home is threadsafe. | |
su_home_t * | su_home_create (void)) |
Create an su_home_t object. | |
void | su_home_destroy (su_home_t *h) |
Deinitialize a home object. |
void* su_alloc | ( | su_home_t * | home, | |
int | size | |||
) |
Allocate a memory block.
The function su_alloc() allocates a memory block of a given size.
If home is NULL, this function behaves exactly like malloc().
home | pointer to home object | |
size | size of the memory block to be allocated |
void su_free | ( | su_home_t * | home, | |
void * | data | |||
) |
Free a memory block.
The function su_free() frees a single memory block. The home must be the owner of the memory block (usually the memory home used to allocate the memory block, or NULL if no home was used).
home | pointer to home object | |
data | pointer to the memory block to be freed |
su_home_t* su_home_auto | ( | void * | area, | |
int | size | |||
) |
Preload a memory home from stack.
The function su_home_auto() initalizes a memory home using an area allocated from stack. Poor mans alloca().
void su_home_check | ( | su_home_t const * | home | ) |
Check home consistency.
The function su_home_check() ensures that the home structure and all memory blocks allocated through it are consistent. It can be used to catch memory allocation and usage errors.
home | Pointer to a memory home. |
void* su_home_clone | ( | su_home_t * | parent, | |
int | size | |||
) |
Clone a su_home_t object.
Clone a secondary home object used to collect multiple memoryf allocations under one handle. The memory is freed either when the cloned home is destroyed or when the parent home is destroyed.
An independent home object is created if NULL is passed as parent argument.
parent | a parent object (may be NULL) | |
size | size of home object |
su_home_t* su_home_create | ( | void | ) |
Create an su_home_t object.
The function su_home_create() creates a home object. A home object is used to collect multiple memory allocations, so that they all can be freed by calling su_home_destroy().
su_home_t
object, or NULL
upon an error.void su_home_deinit | ( | su_home_t * | home | ) |
Free memory blocks allocated through home.
The function su_home_deinit()
frees the memory blocks associated with the home object.
home | pointer to home object |
void su_home_destroy | ( | su_home_t * | home | ) |
Deinitialize a home object.
The function su_home_destroy() frees a home object, and all memory blocks associated with it.
home | pointer to a home object |
int su_home_init | ( | su_home_t * | home | ) |
Initialize an su_home_t object.
The function su_home_init() initializes an object derived from su_home_t.
home | pointer to home object |
Move allocations from a su_home_t object to another.
The function su_home_move() moves allocations made through the src home object under the dst home object. It is handy, for example, if an operation allocates some number of blocks that should be freed upon an error. It uses a temporary home and moves the blocks from temporary to a proper home when successful, but frees the temporary home upon an error.
If src has destructor, it is called before starting to move.
dst | destination home | |
src | source home |
0 | if succesful | |
-1 | upon an error |
void* su_home_new | ( | int | size | ) |
Create a new su_home_t object.
Create a home object used to collect multiple memory allocations under one handle. The memory allocations made using this home object is freed either when this home is destroyed.
size | size of home object |
void su_home_preload | ( | su_home_t * | home, | |
int | n, | |||
int | isize | |||
) |
Preload a memory home.
The function su_home_preload() preloads a memory home.
int su_home_threadsafe | ( | su_home_t * | home | ) |
Convert su_home_t object to a thread-safe one.
Convert a memory home object as thread-safe by allocating mutexes and modifying function pointers in su_alloc.c module.
home | memory home object to be converted thread-safe. |
0 | when successful, | |
-1 | upon an error. |
int su_home_unref | ( | su_home_t * | home | ) |
Unreference a su_home_t object.
The function su_home_unref() decrements the reference count on a home object and destroys and frees it and the memory allocations using it.
home | memory pool object to be unreferences |
1 | if object was freed | |
0 | if object is still alive |
void* su_realloc | ( | su_home_t * | home, | |
void * | data, | |||
int | size | |||
) |
Reallocate a memory block.
The function su_realloc() allocates a memory block of size bytes. It copies the old block contents to the new block and frees the old block.
If home is NULL, this function behaves exactly like realloc().
home | pointer to memory pool object | |
data | pointer to old memory block | |
size | size of the memory block to be allocated |
void* su_salloc | ( | su_home_t * | home, | |
int | size | |||
) |
Allocate a structure.
The function su_salloc() allocates a structure with a given size, zeros it, and initializes the size field to the given size. The size field is the first in the structure.
home | pointer to memory pool object | |
size | size of the structure |
struct test { int tst_size; char *tst_name; void *tst_ptr[3]; }; struct test *t; ... t = su_salloc(home, sizeof (*t)); assert(t && t->t_size == sizeof (*t)); t->name
char* su_sprintf | ( | su_home_t * | home, | |
char const * | fmt, | |||
... | ||||
) |
Copy a formatted string.
The function su_sprintf() print a string according to a fmt like printf() or snprintf(). The resulting string is copied to a memory area freshly allocated from a memory home. The returned string is reclaimed when home is destroyed. It can explicitly be freed with su_free() or free() if home is NULL.
home | pointer to memory home (may be NULL) | |
fmt | format string | |
... | argument list (must match with the fmt format string) |
char* su_strcat | ( | su_home_t * | home, | |
char const * | s1, | |||
char const * | s2 | |||
) |
Concate two strings, allocate memory for result from home.
Concatenate the strings s1 and s2. The strlen(s1)+strlen
(s2)+1 bytes is allocated from home, the contents of s1 and s2 is copied to the newly allocated memory area, and pointer to the concatenated string is returned.
home | pointer to memory home | |
s1 | string to be first string | |
s2 | string to be first string |
NULL
upon an error. char* su_strcat_all | ( | su_home_t * | home, | |
... | ||||
) |
Concate multiple strings, allocate memory for result from home.
Concatenate the strings in list. The lenght of result is calculate, result is allocated from home, the contents of strings is copied to the newly allocated memory arex, and pointer to the concatenated string is returned.
home | pointer to memory home | |
... | NULL-terminated list of strings to be concatenated |
NULL
upon an error. char* su_strdup | ( | su_home_t * | home, | |
char const * | s | |||
) |
Duplicate a string, allocate memory from home.
The function su_strdup() duplicates the string s. It allocates strlen(s)+1
bytes from home, copies the contents of s to the newly allocated memory, and returns pointer to the duplicated string.
home | pointer to memory home | |
s | string to be duplicated |
NULL
upon an error. char* su_strndup | ( | su_home_t * | home, | |
char const * | s, | |||
int | n | |||
) |
Duplicate a string with given size, allocate memory from home.
The function su_strndup() duplicates the string s. It allocates n+1
bytes from home, copies the contents of s to the newly allocated memory, and returns pointer to the duplicated string. The duplicated string is always NUL-terminated.
home | pointer to memory home | |
s | string to be duplicated | |
n | size of the resulting string |
NULL
upon an error. char* su_vsprintf | ( | su_home_t * | home, | |
char const * | fmt, | |||
va_list | ap | |||
) |
Copy a formatted string.
The function su_vsprintf() print a string according to a fmt like vprintf() or vsnprintf(). The resulting string is copied to a memory area fresly allocated from a memory home. The returned string is reclaimed when home is destroyed. It can explicitly be freed with su_free() or free() if home is NULL.
home | pointer to memory home (may be NULL) | |
fmt | format string | |
ap | stdarg argument list (must match with the fmt format string) |
void* su_zalloc | ( | su_home_t * | home, | |
int | size | |||
) |
Allocate and zero a memory block.
The function su_zalloc() allocates a memory block with a given size from given memory home home and zeroes the allocated block.
home | pointer to memory pool object | |
size | size of the memory block |
NULL
. In that case, the allocated memory block is not associated with any memory home, and it must be freed by calling su_free() or free().