extern "C" {
#endif
+/* for old gcc releases that don't have the feature test macro __has_attribute */
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif
+
+#ifndef _PUBLIC_
+#if __has_attribute(visibility)
+#define _PUBLIC_ __attribute__((visibility("default")))
+#else
+#define _PUBLIC_
+#endif
+#endif
+
/**
* @defgroup talloc The talloc API
*
#define TALLOC_VERSION_MAJOR 2
#define TALLOC_VERSION_MINOR 3
-int talloc_version_major(void);
-int talloc_version_minor(void);
+_PUBLIC_ int talloc_version_major(void);
+_PUBLIC_ int talloc_version_minor(void);
/* This is mostly useful only for testing */
-int talloc_test_get_magic(void);
+_PUBLIC_ int talloc_test_get_magic(void);
/**
* @brief Define a talloc parent type
#define TALLOC_DEPRECATED 0
#endif
-/* for old gcc releases that don't have the feature test macro __has_attribute */
-#ifndef __has_attribute
-#define __has_attribute(x) 0
-#endif
-
#ifndef PRINTF_ATTRIBUTE
#if __has_attribute(format) || (__GNUC__ >= 3)
/** Use gcc attribute to check printf fns. a1 is the 1-based index of
* @see talloc_steal
* @see talloc_free
*/
-void *talloc(const void *ctx, #type);
+_PUBLIC_ void *talloc(const void *ctx, #type);
#else
#define talloc(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type)
-void *_talloc(const void *context, size_t size);
+_PUBLIC_ void *_talloc(const void *context, size_t size);
#endif
/**
*
* @see talloc_named()
*/
-void *talloc_init(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
+_PUBLIC_ void *talloc_init(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
#ifdef DOXYGEN
/**
* @see talloc_set_destructor()
* @see talloc_unlink()
*/
-int talloc_free(void *ptr);
+_PUBLIC_ int talloc_free(void *ptr);
#else
#define talloc_free(ctx) _talloc_free(ctx, __location__)
-int _talloc_free(void *ptr, const char *location);
+_PUBLIC_ int _talloc_free(void *ptr, const char *location);
#endif
/**
* @param[in] ptr The chunk that you want to free the children of
* (NULL is allowed too)
*/
-void talloc_free_children(void *ptr);
+_PUBLIC_ void talloc_free_children(void *ptr);
#ifdef DOXYGEN
/**
* @see talloc()
* @see talloc_free()
*/
-void talloc_set_destructor(const void *ptr, int (*destructor)(void *));
+_PUBLIC_ void talloc_set_destructor(const void *ptr, int (*destructor)(void *));
/**
* @brief Change a talloc chunk's parent.
* if you are not careful with talloc_steal(). No guarantees are provided
* as to your sanity or the safety of your data if you do this.
*/
-void *talloc_steal(const void *new_ctx, const void *ptr);
+_PUBLIC_ void *talloc_steal(const void *new_ctx, const void *ptr);
#else /* DOXYGEN */
/* try to make talloc_set_destructor() and talloc_steal() type safe,
if we have a recent gcc */
#define _TALLOC_TYPEOF(ptr) void *
#define talloc_steal(ctx, ptr) (_TALLOC_TYPEOF(ptr))_talloc_steal_loc((ctx),(ptr), __location__)
#endif /* __GNUC__ >= 3 */
-void _talloc_set_destructor(const void *ptr, int (*_destructor)(void *));
-void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location);
+_PUBLIC_ void _talloc_set_destructor(const void *ptr, int (*_destructor)(void *));
+_PUBLIC_ void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location);
#endif /* DOXYGEN */
/**
* releasing the name. All of the memory is released when the ptr is freed
* using talloc_free().
*/
-const char *talloc_set_name(const void *ptr, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+_PUBLIC_ const char *talloc_set_name(const void *ptr, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
#ifdef DOXYGEN
/**
* It does not have any failure modes.
*
*/
-void *talloc_move(const void *new_ctx, void **pptr);
+_PUBLIC_ void *talloc_move(const void *new_ctx, void **pptr);
#else
#define talloc_move(ctx, pptr) (_TALLOC_TYPEOF(*(pptr)))_talloc_move((ctx),(void *)(pptr))
-void *_talloc_move(const void *new_ctx, const void *pptr);
+_PUBLIC_ void *_talloc_move(const void *new_ctx, const void *pptr);
#endif
/**
*
* @param[in] name Format string for the name.
*/
-void talloc_set_name_const(const void *ptr, const char *name);
+_PUBLIC_ void talloc_set_name_const(const void *ptr, const char *name);
/**
* @brief Create a named talloc chunk.
*
* @see talloc_set_name()
*/
-void *talloc_named(const void *context, size_t size,
+_PUBLIC_ void *talloc_named(const void *context, size_t size,
const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
/**
*
* @return The allocated memory chunk, NULL on error.
*/
-void *talloc_named_const(const void *context, size_t size, const char *name);
+_PUBLIC_ void *talloc_named_const(const void *context, size_t size, const char *name);
#ifdef DOXYGEN
/**
* void *mem = talloc_size(NULL, 100);
* @endcode
*/
-void *talloc_size(const void *ctx, size_t size);
+_PUBLIC_ void *talloc_size(const void *ctx, size_t size);
#else
#define talloc_size(ctx, size) talloc_named_const(ctx, size, __location__)
#endif
* unsigned int *a = talloc_ptrtype(NULL, a);
* @endcode
*/
-void *talloc_ptrtype(const void *ctx, #type);
+_PUBLIC_ void *talloc_ptrtype(const void *ctx, #type);
#else
#define talloc_ptrtype(ctx, ptr) (_TALLOC_TYPEOF(ptr))talloc_size(ctx, sizeof(*(ptr)))
#endif
*
* @return A new talloc chunk, NULL on error.
*/
-void *talloc_new(const void *ctx);
+_PUBLIC_ void *talloc_new(const void *ctx);
#else
#define talloc_new(ctx) talloc_named_const(ctx, 0, "talloc_new: " __location__)
#endif
* @see talloc_zero_size()
* @see talloc_zero_array()
*/
-void *talloc_zero(const void *ctx, #type);
+_PUBLIC_ void *talloc_zero(const void *ctx, #type);
/**
* @brief Allocate untyped, 0-initialized memory.
*
* @return The allocated memory chunk.
*/
-void *talloc_zero_size(const void *ctx, size_t size);
+_PUBLIC_ void *talloc_zero_size(const void *ctx, size_t size);
#else
#define talloc_zero(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type)
#define talloc_zero_size(ctx, size) _talloc_zero(ctx, size, __location__)
-void *_talloc_zero(const void *ctx, size_t size, const char *name);
+_PUBLIC_ void *_talloc_zero(const void *ctx, size_t size, const char *name);
#endif
/**
*
* @see talloc_set_name()
*/
-const char *talloc_get_name(const void *ptr);
+_PUBLIC_ const char *talloc_get_name(const void *ptr);
/**
* @brief Verify that a talloc chunk carries a specified name.
*
* @return The pointer if the name matches, NULL if it doesn't.
*/
-void *talloc_check_name(const void *ptr, const char *name);
+_PUBLIC_ void *talloc_check_name(const void *ptr, const char *name);
/**
* @brief Get the parent chunk of a pointer.
*
* @return The talloc parent of ptr, NULL on error.
*/
-void *talloc_parent(const void *ptr);
+_PUBLIC_ void *talloc_parent(const void *ptr);
/**
* @brief Get a talloc chunk's parent name.
*
* @return The name of ptr's parent chunk.
*/
-const char *talloc_parent_name(const void *ptr);
+_PUBLIC_ const char *talloc_parent_name(const void *ptr);
/**
* @brief Get the total size of a talloc chunk including its children.
*
* @return The total size.
*/
-size_t talloc_total_size(const void *ptr);
+_PUBLIC_ size_t talloc_total_size(const void *ptr);
/**
* @brief Get the number of talloc chunks hanging off a chunk.
*
* @return The total size.
*/
-size_t talloc_total_blocks(const void *ptr);
+_PUBLIC_ size_t talloc_total_blocks(const void *ptr);
#ifdef DOXYGEN
/**
*
* @see talloc_size()
*/
-void *talloc_memdup(const void *t, const void *p, size_t size);
+_PUBLIC_ void *talloc_memdup(const void *t, const void *p, size_t size);
#else
#define talloc_memdup(t, p, size) _talloc_memdup(t, p, size, __location__)
-void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name);
+_PUBLIC_ void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name);
#endif
#ifdef DOXYGEN
*
* @param[in] type The type to assign.
*/
-void talloc_set_type(const char *ptr, #type);
+_PUBLIC_ void talloc_set_type(const char *ptr, #type);
/**
* @brief Get a typed pointer out of a talloc pointer.
*
* @return The same value as ptr, type-checked and properly cast.
*/
-void *talloc_get_type_abort(const void *ptr, #type);
+_PUBLIC_ void *talloc_get_type_abort(const void *ptr, #type);
#else
#ifdef TALLOC_GET_TYPE_ABORT_NOOP
#define talloc_get_type_abort(ptr, type) (type *)(ptr)
#else
#define talloc_get_type_abort(ptr, type) (type *)_talloc_get_type_abort(ptr, #type, __location__)
#endif
-void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location);
+_PUBLIC_ void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location);
#endif
/**
* @return The memory context we are looking for, NULL if not
* found.
*/
-void *talloc_find_parent_byname(const void *ctx, const char *name);
+_PUBLIC_ void *talloc_find_parent_byname(const void *ctx, const char *name);
#ifdef DOXYGEN
/**
* @return The memory context we are looking for, NULL if not
* found.
*/
-void *talloc_find_parent_bytype(const void *ptr, #type);
+_PUBLIC_ void *talloc_find_parent_bytype(const void *ptr, #type);
#else
#define talloc_find_parent_bytype(ptr, type) (type *)talloc_find_parent_byname(ptr, #type)
#endif
*
* @return The allocated talloc pool, NULL on error.
*/
-void *talloc_pool(const void *context, size_t size);
+_PUBLIC_ void *talloc_pool(const void *context, size_t size);
#ifdef DOXYGEN
/**
*
* @return The allocated talloc object, NULL on error.
*/
-void *talloc_pooled_object(const void *ctx, #type,
+_PUBLIC_ void *talloc_pooled_object(const void *ctx, #type,
unsigned num_subobjects,
size_t total_subobjects_size);
#else
(_type *)_talloc_pooled_object((_ctx), sizeof(_type), #_type, \
(_num_subobjects), \
(_total_subobjects_size))
-void *_talloc_pooled_object(const void *ctx,
+_PUBLIC_ void *_talloc_pooled_object(const void *ctx,
size_t type_size,
const char *type_name,
unsigned num_subobjects,
*
* @return 0 on success, -1 on error.
*/
-int talloc_increase_ref_count(const void *ptr);
+_PUBLIC_ int talloc_increase_ref_count(const void *ptr);
/**
* @brief Get the number of references to a talloc chunk.
*
* @return The number of references.
*/
-size_t talloc_reference_count(const void *ptr);
+_PUBLIC_ size_t talloc_reference_count(const void *ptr);
#ifdef DOXYGEN
/**
*
* @see talloc_unlink()
*/
-void *talloc_reference(const void *ctx, const void *ptr);
+_PUBLIC_ void *talloc_reference(const void *ctx, const void *ptr);
#else
#define talloc_reference(ctx, ptr) (_TALLOC_TYPEOF(ptr))_talloc_reference_loc((ctx),(ptr), __location__)
-void *_talloc_reference_loc(const void *context, const void *ptr, const char *location);
+_PUBLIC_ void *_talloc_reference_loc(const void *context, const void *ptr, const char *location);
#endif
/**
* talloc_unlink(b, c);
* @endcode
*/
-int talloc_unlink(const void *context, void *ptr);
+_PUBLIC_ int talloc_unlink(const void *context, void *ptr);
/**
* @brief Provide a talloc context that is freed at program exit.
*
* @return A talloc context, NULL on error.
*/
-void *talloc_autofree_context(void) _DEPRECATED_;
+_PUBLIC_ void *talloc_autofree_context(void) _DEPRECATED_;
/**
* @brief Get the size of a talloc chunk.
*
* @return The size of the talloc chunk.
*/
-size_t talloc_get_size(const void *ctx);
+_PUBLIC_ size_t talloc_get_size(const void *ctx);
/**
* @brief Show the parentage of a context.
*
* @param[in] file The output to use, a file, stdout or stderr.
*/
-void talloc_show_parents(const void *context, FILE *file);
+_PUBLIC_ void talloc_show_parents(const void *context, FILE *file);
/**
* @brief Check if a context is parent of a talloc chunk.
*
* @return Return 1 if this is the case, 0 if not.
*/
-int talloc_is_parent(const void *context, const void *ptr);
+_PUBLIC_ int talloc_is_parent(const void *context, const void *ptr);
/**
* @brief Change the parent context of a talloc pointer.
* @return Return the pointer you passed. It does not have any
* failure modes.
*/
-void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr);
+_PUBLIC_ void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr);
/* @} ******************************************************************/
* @see talloc()
* @see talloc_zero_array()
*/
-void *talloc_array(const void *ctx, #type, unsigned count);
+_PUBLIC_ void *talloc_array(const void *ctx, #type, unsigned count);
#else
#define talloc_array(ctx, type, count) (type *)_talloc_array(ctx, sizeof(type), count, #type)
-void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name);
+_PUBLIC_ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name);
#endif
#ifdef DOXYGEN
*
* @return The allocated result, NULL on error.
*/
-void *talloc_array_size(const void *ctx, size_t size, unsigned count);
+_PUBLIC_ void *talloc_array_size(const void *ctx, size_t size, unsigned count);
#else
#define talloc_array_size(ctx, size, count) _talloc_array(ctx, size, count, __location__)
#endif
void *talloc_zero_array(const void *ctx, #type, unsigned count);
#else
#define talloc_zero_array(ctx, type, count) (type *)_talloc_zero_array(ctx, sizeof(type), count, #type)
-void *_talloc_zero_array(const void *ctx,
+_PUBLIC_ void *_talloc_zero_array(const void *ctx,
size_t el_size,
unsigned count,
const char *name);
* due to a lack of memory, or because the pointer has more
* than one parent (see talloc_reference()).
*/
-void *talloc_realloc(const void *ctx, void *ptr, #type, size_t count);
+_PUBLIC_ void *talloc_realloc(const void *ctx, void *ptr, #type, size_t count);
#else
#define talloc_realloc(ctx, p, type, count) (type *)_talloc_realloc_array(ctx, p, sizeof(type), count, #type)
-void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name);
+_PUBLIC_ void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name);
#endif
#ifdef DOXYGEN
void *talloc_realloc_size(const void *ctx, void *ptr, size_t size);
#else
#define talloc_realloc_size(ctx, ptr, size) _talloc_realloc(ctx, ptr, size, __location__)
-void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name);
+_PUBLIC_ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name);
#endif
/**
*
* @return The new chunk, NULL on error.
*/
-void *talloc_realloc_fn(const void *context, void *ptr, size_t size);
+_PUBLIC_ void *talloc_realloc_fn(const void *context, void *ptr, size_t size);
/* @} ******************************************************************/
*
* @return The duplicated string, NULL on error.
*/
-char *talloc_strdup(const void *t, const char *p);
+_PUBLIC_ char *talloc_strdup(const void *t, const char *p);
/**
* @brief Append a string to given string.
* @see talloc_strdup()
* @see talloc_strdup_append_buffer()
*/
-char *talloc_strdup_append(char *s, const char *a);
+_PUBLIC_ char *talloc_strdup_append(char *s, const char *a);
/**
* @brief Append a string to a given buffer.
* @see talloc_strdup_append()
* @see talloc_array_length()
*/
-char *talloc_strdup_append_buffer(char *s, const char *a);
+_PUBLIC_ char *talloc_strdup_append_buffer(char *s, const char *a);
/**
* @brief Duplicate a length-limited string into a talloc chunk.
*
* @return The duplicated string, NULL on error.
*/
-char *talloc_strndup(const void *t, const char *p, size_t n);
+_PUBLIC_ char *talloc_strndup(const void *t, const char *p, size_t n);
/**
* @brief Append at most n characters of a string to given string.
* @see talloc_strndup()
* @see talloc_strndup_append_buffer()
*/
-char *talloc_strndup_append(char *s, const char *a, size_t n);
+_PUBLIC_ char *talloc_strndup_append(char *s, const char *a, size_t n);
/**
* @brief Append at most n characters of a string to given buffer
* @see talloc_strndup_append()
* @see talloc_array_length()
*/
-char *talloc_strndup_append_buffer(char *s, const char *a, size_t n);
+_PUBLIC_ char *talloc_strndup_append_buffer(char *s, const char *a, size_t n);
/**
* @brief Format a string given a va_list.
*
* @return The formatted string, NULL on error.
*/
-char *talloc_vasprintf(const void *t, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+_PUBLIC_ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
/**
* @brief Format a string given a va_list and append it to the given destination
*
* @see talloc_vasprintf()
*/
-char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+_PUBLIC_ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
/**
* @brief Format a string given a va_list and append it to the given destination
*
* @see talloc_vasprintf()
*/
-char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+_PUBLIC_ char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
/**
* @brief Format a string.
*
* @return The formatted string, NULL on error.
*/
-char *talloc_asprintf(const void *t, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+_PUBLIC_ char *talloc_asprintf(const void *t, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
/**
* @brief Append a formatted string to another string.
*
* @return The formatted string, NULL on error.
*/
-char *talloc_asprintf_append(char *s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+_PUBLIC_ char *talloc_asprintf_append(char *s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
/**
* @brief Append a formatted string to another string.
* @see talloc_asprintf()
* @see talloc_asprintf_append()
*/
-char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+_PUBLIC_ char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
/* @} ******************************************************************/
*
* @param[in] private_data Private pointer passed to callback.
*/
-void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
+_PUBLIC_ void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
void (*callback)(const void *ptr,
int depth, int max_depth,
int is_ref,
*
* @param[in] f The file handle to print to.
*/
-void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f);
+_PUBLIC_ void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f);
/**
* @brief Print a summary report of all memory used by ptr.
*
* @see talloc_report()
*/
-void talloc_report_full(const void *ptr, FILE *f);
+_PUBLIC_ void talloc_report_full(const void *ptr, FILE *f);
/**
* @brief Print a summary report of all memory used by ptr.
*
* @see talloc_report_full()
*/
-void talloc_report(const void *ptr, FILE *f);
+_PUBLIC_ void talloc_report(const void *ptr, FILE *f);
/**
* @brief Enable tracking the use of NULL memory contexts.
* reporting on exit. Useful for when you want to do your own leak
* reporting call via talloc_report_null_full();
*/
-void talloc_enable_null_tracking(void);
+_PUBLIC_ void talloc_enable_null_tracking(void);
/**
* @brief Enable tracking the use of NULL memory contexts.
* reporting on exit. Useful for when you want to do your own leak
* reporting call via talloc_report_null_full();
*/
-void talloc_enable_null_tracking_no_autofree(void);
+_PUBLIC_ void talloc_enable_null_tracking_no_autofree(void);
/**
* @brief Disable tracking of the NULL memory context.
*
* This disables tracking of the NULL memory context.
*/
-void talloc_disable_null_tracking(void);
+_PUBLIC_ void talloc_disable_null_tracking(void);
/**
* @brief Enable leak report when a program exits.
* iconv(UTF-16LE,UTF8) contains 45 bytes in 2 blocks
* @endcode
*/
-void talloc_enable_leak_report(void);
+_PUBLIC_ void talloc_enable_leak_report(void);
/**
* @brief Enable full leak report when a program exits.
* x1 contains 1 bytes in 1 blocks (ref 0)
* @endcode
*/
-void talloc_enable_leak_report_full(void);
+_PUBLIC_ void talloc_enable_leak_report_full(void);
/**
* @brief Set a custom "abort" function that is called on serious error.
* @see talloc_set_log_fn()
* @see talloc_get_type()
*/
-void talloc_set_abort_fn(void (*abort_fn)(const char *reason));
+_PUBLIC_ void talloc_set_abort_fn(void (*abort_fn)(const char *reason));
/**
* @brief Set a logging function.
* @see talloc_set_log_stderr()
* @see talloc_set_abort_fn()
*/
-void talloc_set_log_fn(void (*log_fn)(const char *message));
+_PUBLIC_ void talloc_set_log_fn(void (*log_fn)(const char *message));
/**
* @brief Set stderr as the output for logs.
* @see talloc_set_log_fn()
* @see talloc_set_abort_fn()
*/
-void talloc_set_log_stderr(void);
+_PUBLIC_ void talloc_set_log_stderr(void);
/**
* @brief Set a max memory limit for the current context hierarchy
* @param[in] ctx The talloc context to set the limit on
* @param[in] max_size The (new) max_size
*/
-int talloc_set_memlimit(const void *ctx, size_t max_size) _DEPRECATED_;
+_PUBLIC_ int talloc_set_memlimit(const void *ctx, size_t max_size) _DEPRECATED_;
/* @} ******************************************************************/
projects / thirdparty / samba.git / commitdiff
