stringfields.h File Reference

#include "asterisk/inline_api.h"
#include "asterisk/vector.h"

Include dependency graph for stringfields.h:

Go to the source code of this file.

Data Structures
struct	ast_string_field_mgr
struct	ast_string_field_pool
struct	ast_string_field_vector

Macros
#define	__ast_string_field_ptr_set_by_fields(field_mgr_pool, field_mgr, ptr, data, file, lineno, func)
#define	ast_calloc_with_stringfields(n, type, size)
	Allocate a structure with embedded stringfields in a single allocation. More...
#define	AST_DECLARE_STRING_FIELDS(field_list)
	Declare the fields needed in a structure. More...
#define	AST_STRING_FIELD(name)   const ast_string_field name
	Declare a string field. More...
#define	AST_STRING_FIELD_ALLOCATION(x)   *((ast_string_field_allocation *) (x - __alignof__(ast_string_field_allocation)))
	Macro to provide access to the allocation field that lives immediately in front of a string field. More...
#define	ast_string_field_build(x, field, fmt, args...)
	Set a field to a complex (built) value. More...
#define	ast_string_field_build_va(x, field, fmt, args)
	Set a field to a complex (built) value. More...
#define	AST_STRING_FIELD_EXTENDED(name)   AST_STRING_FIELD(name)
	Declare an extended string field. More...
#define	ast_string_field_free_memory(x)
	free all memory - to be called before destroying the object More...
#define	ast_string_field_init(x, size)
	Initialize a field pool and fields. More...
#define	ast_string_field_init_extended(x, field)
	Initialize an extended string field. More...
#define	ast_string_field_ptr_build(x, ptr, fmt, args...)
	Set a field to a complex (built) value. More...
#define	ast_string_field_ptr_build_va(x, ptr, fmt, args)
	Set a field to a complex (built) value with prebuilt va_lists. More...
#define	ast_string_field_ptr_set(x, ptr, data)
	Set a field to a simple string value. More...
#define	ast_string_field_ptr_set_by_fields(field_mgr_pool, field_mgr, ptr, data)    __ast_string_field_ptr_set_by_fields(field_mgr_pool, field_mgr, ptr, data, __FILE__, __LINE__, __PRETTY_FUNCTION__)
#define	ast_string_field_set(x, field, data)
	Set a field to a simple string value. More...
#define	ast_string_fields_cmp(instance1, instance2)
	Compare the string fields in two instances of the same structure. More...
#define	ast_string_fields_copy(copy, orig)
	Copy all string fields from one instance to another of the same structure. More...

Typedefs
typedef const char *	ast_string_field
typedef uint16_t	ast_string_field_allocation

Enumerations
enum	ast_stringfield_cleanup_type { AST_STRINGFIELD_RESET = 0 , AST_STRINGFIELD_DESTROY = -1 }

Functions
void *	__ast_calloc_with_stringfields (unsigned int num_structs, size_t struct_size, size_t field_mgr_offset, size_t field_mgr_pool_offset, size_t pool_size, const char *file, int lineno, const char *func)
ast_string_field	__ast_string_field_alloc_space (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed, const char *file, int lineno, const char *func)
int	__ast_string_field_free_memory (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, enum ast_stringfield_cleanup_type cleanup_type, const char *file, int lineno, const char *func)
	Internal cleanup function. More...
int	__ast_string_field_init (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, int needed, const char *file, int lineno, const char *func)
	Internal initialization function. More...
void	__ast_string_field_ptr_build (const char *file, int lineno, const char *func, struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format,...)
void	__ast_string_field_ptr_build_va (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format, va_list ap, const char *file, int lineno, const char *func)
int	__ast_string_field_ptr_grow (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed, const ast_string_field *ptr)
void	__ast_string_field_release_active (struct ast_string_field_pool *pool_head, const ast_string_field ptr)
int	__ast_string_fields_cmp (struct ast_string_field_vector *left, struct ast_string_field_vector *right)
int	__ast_string_fields_copy (struct ast_string_field_pool *copy_pool, struct ast_string_field_mgr *copy_mgr, struct ast_string_field_mgr *orig_mgr, const char *file, int lineno, const char *func)

Variables
const char *	__ast_string_field_empty

Macro Definition Documentation

__ast_string_field_ptr_set_by_fields

#define __ast_string_field_ptr_set_by_fields	(		field_mgr_pool,
			field_mgr,
			ptr,
			data,
			file,
			lineno,
			func
	)

Definition at line 484 of file stringfields.h.

ast_calloc_with_stringfields

#define ast_calloc_with_stringfields	(		n,
			type,
			size
	)

Value:

    __ast_calloc_with_stringfields(n, sizeof(type), offsetof(type, __field_mgr), \
        offsetof(type, __field_mgr_pool), size, __FILE__, __LINE__, __PRETTY_FUNCTION__)

Allocate a structure with embedded stringfields in a single allocation.

Parameters

n	Current implementation only allows 1 structure to be allocated
type	The type of structure to allocate
size	The number of bytes of space (minimum) to allocate for stringfields to use in each structure

This function will allocate memory for one or more structures that use stringfields, and also allocate space for the stringfields and initialize the stringfield management structure embedded in the outer structure.

Since

1.8

Definition at line 432 of file stringfields.h.

AST_DECLARE_STRING_FIELDS

#define AST_DECLARE_STRING_FIELDS

(

field_list

)

Value:

    struct ast_string_field_pool *__field_mgr_pool; \
    field_list                  \
    struct ast_string_field_mgr __field_mgr

Declare the fields needed in a structure.

Parameters

field_list

The list of fields to declare, using AST_STRING_FIELD() for each one. Internally, string fields are stored as a pointer to the head of the pool, followed by individual string fields, and then a struct ast_string_field_mgr which describes the space allocated. We split the two variables so they can be used as markers around the field_list, and this allows us to determine how many entries are in the field, and play with them. In particular, for writing to the fields, we rely on __field_mgr_pool to be a non-const pointer, so we know it has the same size as ast_string_field, and we can use it to locate the fields.

Examples

app_skel.c.

Definition at line 341 of file stringfields.h.

AST_STRING_FIELD

#define AST_STRING_FIELD

(

name

)

const ast_string_field name

Declare a string field.

Parameters

name	The field name

Examples

app_skel.c.

Definition at line 303 of file stringfields.h.

AST_STRING_FIELD_ALLOCATION

#define AST_STRING_FIELD_ALLOCATION

(

x

)

*((ast_string_field_allocation *) (x - __alignof__(ast_string_field_allocation)))

Macro to provide access to the allocation field that lives immediately in front of a string field.

Parameters

x	Pointer to the string field

Note that x must be a pointer to a byte-sized type – normally (char *) – or this calculation would break horribly

Definition at line 465 of file stringfields.h.

ast_string_field_build

#define ast_string_field_build	(		x,
			field,
			fmt,
			args...
	)

Set a field to a complex (built) value.

Parameters

x	Pointer to a structure containing fields
field	Name of the field to set
fmt	printf-style format string
args	Arguments for format string

Definition at line 555 of file stringfields.h.

ast_string_field_build_va

#define ast_string_field_build_va	(		x,
			field,
			fmt,
			args
	)

Set a field to a complex (built) value.

Parameters

x	Pointer to a structure containing fields
field	Name of the field to set
fmt	printf-style format string
args	Arguments for format string in va_list format

Definition at line 591 of file stringfields.h.

AST_STRING_FIELD_EXTENDED

#define AST_STRING_FIELD_EXTENDED

(

name

)

AST_STRING_FIELD(name)

Declare an extended string field.

Since

13.9.0

Parameters

name	The field name

Definition at line 311 of file stringfields.h.

ast_string_field_free_memory

#define ast_string_field_free_memory

(

x

)

free all memory - to be called before destroying the object

Parameters

x

Examples

app_skel.c.

Definition at line 374 of file stringfields.h.

ast_string_field_init

#define ast_string_field_init	(		x,
			size
	)

Initialize a field pool and fields.

Parameters

x	Pointer to a structure containing fields
size	Amount of storage to allocate. Use AST_STRINGFIELD_RESET to reset fields to the default value, and release all but the most recent pool. AST_STRINGFIELD_DESTROY (used internally) means free all pools which is equivalent to calling ast_string_field_free_memory.

Return values

zero	on success
non-zero	on failure

Examples

app_skel.c.

Definition at line 359 of file stringfields.h.

ast_string_field_init_extended

#define ast_string_field_init_extended	(		x,
			field
	)

Initialize an extended string field.

Since

13.9.0

Parameters

x	Pointer to a structure containing the field
field	The extended field to initialize

Return values

zero	on success
non-zero	on error

Note

This macro must be called on ALL fields defined with AST_STRING_FIELD_EXTENDED after ast_string_field_init has been called.

Definition at line 401 of file stringfields.h.

ast_string_field_ptr_build

#define ast_string_field_ptr_build	(		x,
			ptr,
			fmt,
			args...
	)

Set a field to a complex (built) value.

Parameters

x	Pointer to a structure containing fields
ptr	Pointer to a field within the structure
fmt	printf-style format string
args	Arguments for format string

Definition at line 537 of file stringfields.h.

ast_string_field_ptr_build_va

#define ast_string_field_ptr_build_va	(		x,
			ptr,
			fmt,
			args
	)

Set a field to a complex (built) value with prebuilt va_lists.

Parameters

x	Pointer to a structure containing fields
ptr	Pointer to a field within the structure
fmt	printf-style format string
args	Arguments for format string in va_list format

Definition at line 573 of file stringfields.h.

ast_string_field_ptr_set

#define ast_string_field_ptr_set	(		x,
			ptr,
			data
	)

Set a field to a simple string value.

Parameters

x	Pointer to a structure containing fields
ptr	Pointer to a field within the structure
data	String value to be copied into the field

Return values

zero	on success
non-zero	on error

Definition at line 475 of file stringfields.h.

ast_string_field_ptr_set_by_fields

#define ast_string_field_ptr_set_by_fields	(		field_mgr_pool,
			field_mgr,
			ptr,
			data
	)		__ast_string_field_ptr_set_by_fields(field_mgr_pool, field_mgr, ptr, data, __FILE__, __LINE__, __PRETTY_FUNCTION__)

Definition at line 510 of file stringfields.h.

ast_string_field_set

#define ast_string_field_set	(		x,
			field,
			data
	)

Set a field to a simple string value.

Parameters

x	Pointer to a structure containing fields
field	Name of the field to set
data	String value to be copied into the field

Return values

zero	on success
non-zero	on error

Examples

app_skel.c.

Definition at line 521 of file stringfields.h.

ast_string_fields_cmp

#define ast_string_fields_cmp	(		instance1,
			instance2
	)

Compare the string fields in two instances of the same structure.

Since

12

Parameters

instance1	The first instance of the structure to be compared
instance2	The second instance of the structure to be compared

Return values

zero	if all string fields are equal (does not compare non-string field data)
non-zero	if the values of the string fields differ

Definition at line 610 of file stringfields.h.

ast_string_fields_copy

#define ast_string_fields_copy	(		copy,
			orig
	)

Copy all string fields from one instance to another of the same structure.

Since

12

Parameters

copy	The instance of the structure to be copied into
orig	The instance of the structure to be copied from

Return values

zero	on success
non-zero	on error

Definition at line 630 of file stringfields.h.

Typedef Documentation

ast_string_field

typedef const char* ast_string_field

Definition at line 190 of file stringfields.h.

ast_string_field_allocation

typedef uint16_t ast_string_field_allocation

Definition at line 194 of file stringfields.h.

Enumeration Type Documentation

ast_stringfield_cleanup_type

enum ast_stringfield_cleanup_type

Enumerator
AST_STRINGFIELD_RESET	Reset all string fields and free all extra pools that may have been created The allocation or structure can be reused as is.
AST_STRINGFIELD_DESTROY	Reset all string fields and free all pools. If the pointer was returned by ast_calloc_with_stringfields, it can NOT be reused and should be immediately freed. Otherwise, you must call ast_string_field_init again if you want to reuse it.

Definition at line 313 of file stringfields.h.

                                  {
    /*!
     * Reset all string fields and free all extra pools that may have been created
     * The allocation or structure can be reused as is.
     */
    AST_STRINGFIELD_RESET = 0,
    /*!
     * Reset all string fields and free all pools.
     * If the pointer was returned by ast_calloc_with_stringfields, it can NOT be reused
     * and should be immediately freed.  Otherwise, you must call ast_string_field_init
     * again if you want to reuse it.
     */
    AST_STRINGFIELD_DESTROY = -1,
};

Function Documentation

__ast_calloc_with_stringfields()

void * __ast_calloc_with_stringfields	(	unsigned int	num_structs,
		size_t	struct_size,
		size_t	field_mgr_offset,
		size_t	field_mgr_pool_offset,
		size_t	pool_size,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 380 of file stringfields.c.

{
    struct ast_string_field_mgr *mgr;
    struct ast_string_field_pool *pool;
    struct ast_string_field_pool **pool_head;
    size_t pool_size_needed = sizeof(*pool) + pool_size;
    size_t size_to_alloc = optimal_alloc_size(struct_size + pool_size_needed);
    void *allocation;
    const char **p;
    size_t initial_vector_size;
 
    ast_assert(num_structs == 1);
 
    allocation = __ast_calloc(num_structs, size_to_alloc, file, lineno, func);
    if (!allocation) {
        return NULL;
    }
 
    mgr = allocation + field_mgr_offset;
 
    pool = allocation + struct_size;
    pool_head = allocation + field_mgr_pool_offset;
    p = (const char **) pool_head + 1;
    initial_vector_size = ((size_t) (((char *)mgr) - ((char *)p))) / sizeof(*p);
 
    if (AST_VECTOR_INIT(&mgr->string_fields, initial_vector_size)) {
        ast_free(allocation);
        return NULL;
    }
 
    while ((struct ast_string_field_mgr *) p != mgr) {
        AST_VECTOR_APPEND(&mgr->string_fields, p);
        *p++ = __ast_string_field_empty;
    }
 
    mgr->embedded_pool = pool;
    *pool_head = pool;
    pool->size = size_to_alloc - struct_size - sizeof(*pool);
 
    return allocation;
}

References __ast_calloc(), __ast_string_field_empty, allocation, ast_assert, ast_free, AST_VECTOR_APPEND, AST_VECTOR_INIT, ast_string_field_mgr::embedded_pool, make_ari_stubs::file, NULL, optimal_alloc_size(), ast_string_field_pool::size, and ast_string_field_mgr::string_fields.

__ast_string_field_alloc_space()

ast_string_field __ast_string_field_alloc_space	(	struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		size_t	needed,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 202 of file stringfields.c.

{
    char *result = NULL;
    size_t space = (*pool_head)->size - (*pool_head)->used;
    size_t to_alloc;
 
    /* Make room for ast_string_field_allocation and make it a multiple of that. */
    to_alloc = ast_make_room_for(needed, ast_string_field_allocation);
    ast_assert(to_alloc % ast_alignof(ast_string_field_allocation) == 0);
 
    if (__builtin_expect(to_alloc > space, 0)) {
        size_t new_size = (*pool_head)->size;
 
        while (new_size < to_alloc) {
            new_size *= 2;
        }
 
        if (add_string_pool(mgr, pool_head, new_size, file, lineno, func)) {
            return NULL;
        }
    }
 
    /* pool->base is always aligned (gcc aligned attribute). We ensure that
     * to_alloc is also a multiple of ast_alignof(ast_string_field_allocation)
     * causing result to always be aligned as well; which in turn fixes that
     * AST_STRING_FIELD_ALLOCATION(result) is aligned. */
    result = (*pool_head)->base + (*pool_head)->used;
    (*pool_head)->used += to_alloc;
    (*pool_head)->active += needed;
    result += ast_alignof(ast_string_field_allocation);
    AST_STRING_FIELD_ALLOCATION(result) = needed;
    mgr->last_alloc = result;
 
    return result;
}

References add_string_pool(), ast_alignof, ast_assert, ast_make_room_for, AST_STRING_FIELD_ALLOCATION, make_ari_stubs::file, ast_string_field_mgr::last_alloc, NULL, and result.

Referenced by __ast_string_field_ptr_build_va().

__ast_string_field_free_memory()

int __ast_string_field_free_memory	(	struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		enum ast_stringfield_cleanup_type	cleanup_type,
		const char *	file,
		int	lineno,
		const char *	func
	)

Internal cleanup function.

Definition at line 103 of file stringfields.c.

{
    struct ast_string_field_pool *cur = NULL;
    struct ast_string_field_pool *preserve = NULL;
 
    /* reset all the fields regardless of cleanup type */
    AST_VECTOR_CALLBACK_VOID(&mgr->string_fields, reset_field);
 
    switch (cleanup_type) {
    case AST_STRINGFIELD_DESTROY:
        AST_VECTOR_FREE(&mgr->string_fields);
 
        if (mgr->embedded_pool) { /* ALWAYS preserve the embedded pool if there is one */
            preserve = mgr->embedded_pool;
            preserve->used = preserve->active = 0;
        }
 
        break;
    case AST_STRINGFIELD_RESET:
        /* Preserve the embedded pool if there is one, otherwise the last pool */
        if (mgr->embedded_pool) {
            preserve = mgr->embedded_pool;
        } else {
            if (*pool_head == NULL) {
                ast_log(LOG_WARNING, "trying to reset empty pool\n");
                return -1;
            }
            preserve = *pool_head;
        }
        preserve->used = preserve->active = 0;
        break;
    default:
        return -1;
    }
 
    cur = *pool_head;
    while (cur) {
        struct ast_string_field_pool *prev = cur->prev;
 
        if (cur != preserve) {
            ast_free(cur);
        }
        cur = prev;
    }
 
    *pool_head = preserve;
    if (preserve) {
        preserve->prev = NULL;
    }
 
    return 0;
}

References ast_string_field_pool::active, ast_free, ast_log, AST_STRINGFIELD_DESTROY, AST_STRINGFIELD_RESET, AST_VECTOR_CALLBACK_VOID, AST_VECTOR_FREE, ast_string_field_mgr::embedded_pool, LOG_WARNING, NULL, ast_string_field_pool::prev, reset_field(), ast_string_field_mgr::string_fields, and ast_string_field_pool::used.

Referenced by __ast_string_field_init().

__ast_string_field_init()

int __ast_string_field_init	(	struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		int	needed,
		const char *	file,
		int	lineno,
		const char *	func
	)

Internal initialization function.

Definition at line 171 of file stringfields.c.

{
    const char **p = (const char **) pool_head + 1;
    size_t initial_vector_size = ((size_t) (((char *)mgr) - ((char *)p))) / sizeof(*p);
 
    if (needed <= 0) {
        return __ast_string_field_free_memory(mgr, pool_head, needed, file, lineno, func);
    }
 
    mgr->last_alloc = NULL;
 
    if (AST_VECTOR_INIT(&mgr->string_fields, initial_vector_size)) {
        return -1;
    }
 
    while ((struct ast_string_field_mgr *) p != mgr) {
        AST_VECTOR_APPEND(&mgr->string_fields, p);
        *p++ = __ast_string_field_empty;
    }
 
    *pool_head = NULL;
    mgr->embedded_pool = NULL;
    if (add_string_pool(mgr, pool_head, needed, file, lineno, func)) {
        AST_VECTOR_FREE(&mgr->string_fields);
        return -1;
    }
 
    return 0;
}

References __ast_string_field_empty, __ast_string_field_free_memory(), add_string_pool(), AST_VECTOR_APPEND, AST_VECTOR_FREE, AST_VECTOR_INIT, ast_string_field_mgr::embedded_pool, make_ari_stubs::file, ast_string_field_mgr::last_alloc, NULL, and ast_string_field_mgr::string_fields.

__ast_string_field_ptr_build()

void __ast_string_field_ptr_build	(	const char *	file,
		int	lineno,
		const char *	func,
		struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		ast_string_field *	ptr,
		const char *	format,
			...
	)

Definition at line 369 of file stringfields.c.

{
    va_list ap;
 
    va_start(ap, format);
    __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap, file, lineno, func);
    va_end(ap);
}

References __ast_string_field_ptr_build_va(), and make_ari_stubs::file.

__ast_string_field_ptr_build_va()

void __ast_string_field_ptr_build_va	(	struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		ast_string_field *	ptr,
		const char *	format,
		va_list	ap,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 286 of file stringfields.c.

{
    size_t needed;
    size_t available;
    size_t space = (*pool_head)->size - (*pool_head)->used;
    int res;
    ssize_t grow;
    char *target;
    va_list ap2;
 
    /* if the field already has space allocated, try to reuse it;
       otherwise, try to use the empty space at the end of the current
       pool
    */
    if (*ptr != __ast_string_field_empty) {
        target = (char *) *ptr;
        available = AST_STRING_FIELD_ALLOCATION(*ptr);
        if (*ptr == mgr->last_alloc) {
            available += space;
        }
    } else {
        /* pool->used is always a multiple of ast_alignof(ast_string_field_allocation)
         * so we don't need to re-align anything here.
         */
        target = (*pool_head)->base + (*pool_head)->used + ast_alignof(ast_string_field_allocation);
        if (space > ast_alignof(ast_string_field_allocation)) {
            available = space - ast_alignof(ast_string_field_allocation);
        } else {
            available = 0;
        }
    }
 
    va_copy(ap2, ap);
    res = vsnprintf(target, available, format, ap2);
    va_end(ap2);
 
    if (res < 0) {
        /* Are we out of memory? */
        return;
    }
    if (res == 0) {
        __ast_string_field_release_active(*pool_head, *ptr);
        *ptr = __ast_string_field_empty;
        return;
    }
    needed = (size_t)res + 1; /* NUL byte */
 
    if (needed > available) {
        /* the allocation could not be satisfied using the field's current allocation
           (if it has one), or the space available in the pool (if it does not). allocate
           space for it, adding a new string pool if necessary.
        */
        target = (char *) __ast_string_field_alloc_space(mgr, pool_head, needed, file, lineno, func);
        if (!target) {
            return;
        }
        vsprintf(target, format, ap);
        va_end(ap); /* XXX va_end without va_start? */
        __ast_string_field_release_active(*pool_head, *ptr);
        *ptr = target;
    } else if (*ptr != target) {
        /* the allocation was satisfied using available space in the pool, but not
           using the space already allocated to the field
        */
        __ast_string_field_release_active(*pool_head, *ptr);
        mgr->last_alloc = *ptr = target;
            ast_assert(needed < (ast_string_field_allocation)-1);
        AST_STRING_FIELD_ALLOCATION(target) = (ast_string_field_allocation)needed;
        (*pool_head)->used += ast_make_room_for(needed, ast_string_field_allocation);
        (*pool_head)->active += needed;
    } else if ((grow = (needed - AST_STRING_FIELD_ALLOCATION(*ptr))) > 0) {
        /* the allocation was satisfied by using available space in the pool *and*
           the field was the last allocated field from the pool, so it grew
        */
        AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
        (*pool_head)->used += ast_align_for(grow, ast_string_field_allocation);
        (*pool_head)->active += grow;
    }
}

References __ast_string_field_alloc_space(), __ast_string_field_empty, __ast_string_field_release_active(), ast_align_for, ast_alignof, ast_assert, ast_make_room_for, AST_STRING_FIELD_ALLOCATION, available(), make_ari_stubs::file, grow(), and ast_string_field_mgr::last_alloc.

Referenced by __ast_string_field_ptr_build().

__ast_string_field_ptr_grow()

int __ast_string_field_ptr_grow	(	struct ast_string_field_mgr *	mgr,
		struct ast_string_field_pool **	pool_head,
		size_t	needed,
		const ast_string_field *	ptr
	)

Definition at line 240 of file stringfields.c.

{
    ssize_t grow = needed - AST_STRING_FIELD_ALLOCATION(*ptr);
    size_t space = (*pool_head)->size - (*pool_head)->used;
 
    if (*ptr != mgr->last_alloc) {
        return 1;
    }
 
    if (space < grow) {
        return 1;
    }
 
    (*pool_head)->used += grow;
    (*pool_head)->active += grow;
    AST_STRING_FIELD_ALLOCATION(*ptr) += grow;
 
    return 0;
}

References AST_STRING_FIELD_ALLOCATION, grow(), and ast_string_field_mgr::last_alloc.

__ast_string_field_release_active()

void __ast_string_field_release_active	(	struct ast_string_field_pool *	pool_head,
		const ast_string_field	ptr
	)

Definition at line 261 of file stringfields.c.

{
    struct ast_string_field_pool *pool, *prev;
 
    if (ptr == __ast_string_field_empty) {
        return;
    }
 
    for (pool = pool_head, prev = NULL; pool; prev = pool, pool = pool->prev) {
        if ((ptr >= pool->base) && (ptr <= (pool->base + pool->size))) {
            pool->active -= AST_STRING_FIELD_ALLOCATION(ptr);
            if (pool->active == 0) {
                if (prev) {
                    prev->prev = pool->prev;
                    ast_free(pool);
                } else {
                    pool->used = 0;
                }
            }
            break;
        }
    }
}

References __ast_string_field_empty, ast_string_field_pool::active, ast_free, AST_STRING_FIELD_ALLOCATION, ast_string_field_pool::base, NULL, ast_string_field_pool::prev, ast_string_field_pool::size, and ast_string_field_pool::used.

Referenced by __ast_string_field_ptr_build_va(), and __ast_string_fields_copy().

__ast_string_fields_cmp()

int __ast_string_fields_cmp	(	struct ast_string_field_vector *	left,
		struct ast_string_field_vector *	right
	)

Definition at line 424 of file stringfields.c.

{
    int i;
    int res = 0;
 
    ast_assert(AST_VECTOR_SIZE(left) == AST_VECTOR_SIZE(right));
 
    for (i = 0; i < AST_VECTOR_SIZE(left); i++) {
        if ((res = strcmp(*AST_VECTOR_GET(left, i), *AST_VECTOR_GET(right, i)))) {
            return res;
        }
    }
 
    return res;
}

References ast_assert, AST_VECTOR_GET, and AST_VECTOR_SIZE.

__ast_string_fields_copy()

int __ast_string_fields_copy	(	struct ast_string_field_pool *	copy_pool,
		struct ast_string_field_mgr *	copy_mgr,
		struct ast_string_field_mgr *	orig_mgr,
		const char *	file,
		int	lineno,
		const char *	func
	)

Definition at line 441 of file stringfields.c.

{
    int i;
    struct ast_string_field_vector *dest = &(copy_mgr->string_fields);
    struct ast_string_field_vector *src = &(orig_mgr->string_fields);
 
    ast_assert(AST_VECTOR_SIZE(dest) == AST_VECTOR_SIZE(src));
 
    for (i = 0; i < AST_VECTOR_SIZE(dest); i++) {
        __ast_string_field_release_active(copy_pool, *AST_VECTOR_GET(dest, i));
        *AST_VECTOR_GET(dest, i) = __ast_string_field_empty;
    }
 
    for (i = 0; i < AST_VECTOR_SIZE(dest); i++) {
        if (__ast_string_field_ptr_set_by_fields(copy_pool, *copy_mgr, AST_VECTOR_GET(dest, i),
            *AST_VECTOR_GET(src, i), file, lineno, func)) {
            return -1;
        }
    }
 
    return 0;
}

References __ast_string_field_empty, __ast_string_field_ptr_set_by_fields, __ast_string_field_release_active(), ast_assert, AST_VECTOR_GET, AST_VECTOR_SIZE, make_ari_stubs::file, and ast_string_field_mgr::string_fields.

Variable Documentation

__ast_string_field_empty

const char* __ast_string_field_empty

extern

Definition at line 43 of file stringfields.c.

Referenced by __ast_calloc_with_stringfields(), __ast_string_field_init(), __ast_string_field_ptr_build_va(), __ast_string_field_release_active(), __ast_string_fields_copy(), AST_TEST_DEFINE(), and reset_field().