talloc: mark public functions as _PUBLIC_

1 files changed, 62 insertions, 62 deletions

diff --git a/lib/talloc/talloc.c b/lib/talloc/talloc.c
index bc1c697789..d3b5565fe2 100644
--- a/lib/talloc/talloc.c
+++ b/lib/talloc/talloc.c
@@ -139,19 +139,19 @@ struct talloc_chunk {
 #define TC_HDR_SIZE ((sizeof(struct talloc_chunk)+15)&~15)
 #define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
 
-int talloc_version_major(void)
+_PUBLIC_ int talloc_version_major(void)
 {
 	return TALLOC_VERSION_MAJOR;
 }
 
-int talloc_version_minor(void)
+_PUBLIC_ int talloc_version_minor(void)
 {
 	return TALLOC_VERSION_MINOR;
 }
 
 static void (*talloc_log_fn)(const char *message);
 
-void talloc_set_log_fn(void (*log_fn)(const char *message))
+_PUBLIC_ void talloc_set_log_fn(void (*log_fn)(const char *message))
 {
 	talloc_log_fn = log_fn;
 }
@@ -179,14 +179,14 @@ static void talloc_log_stderr(const char *message)
 	fprintf(stderr, "%s", message);
 }
 
-void talloc_set_log_stderr(void)
+_PUBLIC_ void talloc_set_log_stderr(void)
 {
 	talloc_set_log_fn(talloc_log_stderr);
 }
 
 static void (*talloc_abort_fn)(const char *reason);
 
-void talloc_set_abort_fn(void (*abort_fn)(const char *reason))
+_PUBLIC_ void talloc_set_abort_fn(void (*abort_fn)(const char *reason))
 {
 	talloc_abort_fn = abort_fn;
 }
@@ -291,7 +291,7 @@ static inline struct talloc_chunk *talloc_parent_chunk(const void *ptr)
 	return tc->parent;
 }
 
-void *talloc_parent(const void *ptr)
+_PUBLIC_ void *talloc_parent(const void *ptr)
 {
 	struct talloc_chunk *tc = talloc_parent_chunk(ptr);
 	return tc? TC_PTR_FROM_CHUNK(tc) : NULL;
@@ -300,7 +300,7 @@ void *talloc_parent(const void *ptr)
 /*
   find parents name
 */
-const char *talloc_parent_name(const void *ptr)
+_PUBLIC_ const char *talloc_parent_name(const void *ptr)
 {
 	struct talloc_chunk *tc = talloc_parent_chunk(ptr);
 	return tc? tc->name : NULL;
@@ -438,7 +438,7 @@ static inline void *__talloc(const void *context, size_t size)
  * Create a talloc pool
  */
 
-void *talloc_pool(const void *context, size_t size)
+_PUBLIC_ void *talloc_pool(const void *context, size_t size)
 {
 	void *result = __talloc(context, size + TALLOC_POOL_HDR_SIZE);
 	struct talloc_chunk *tc;
@@ -467,7 +467,7 @@ void *talloc_pool(const void *context, size_t size)
   if the destructor fails then the free is failed, and the memory can
   be continued to be used
 */
-void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
+_PUBLIC_ void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
 {
 	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 	tc->destructor = destructor;
@@ -476,7 +476,7 @@ void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
 /*
   increase the reference count on a piece of memory. 
 */
-int talloc_increase_ref_count(const void *ptr)
+_PUBLIC_ int talloc_increase_ref_count(const void *ptr)
 {
 	if (unlikely(!talloc_reference(null_context, ptr))) {
 		return -1;
@@ -532,7 +532,7 @@ static inline void *_talloc_named_const(const void *context, size_t size, const
   same underlying data, and you want to be able to free the two instances separately,
   and in either order
 */
-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)
 {
 	struct talloc_chunk *tc;
 	struct talloc_reference_handle *handle;
@@ -733,7 +733,7 @@ static void *_talloc_steal_internal(const void *new_ctx, const void *ptr)
    ptr on success, or NULL if it could not be transferred.
    passing NULL as ptr will always return NULL with no side effects.
 */
-void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location)
+_PUBLIC_ void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location)
 {
 	struct talloc_chunk *tc;
 
@@ -773,7 +773,7 @@ void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *locati
 
    The old parent can be either a reference or a parent
 */
-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)
 {
 	struct talloc_chunk *tc;
 	struct talloc_reference_handle *h;
@@ -833,7 +833,7 @@ static inline int talloc_unreference(const void *context, const void *ptr)
   remove a specific parent context from a pointer. This is a more
   controlled varient of talloc_free()
 */
-int talloc_unlink(const void *context, void *ptr)
+_PUBLIC_ int talloc_unlink(const void *context, void *ptr)
 {
 	struct talloc_chunk *tc_p, *new_p;
 	void *new_parent;
@@ -900,7 +900,7 @@ static inline const char *talloc_set_name_v(const void *ptr, const char *fmt, va
 /*
   add a name to an existing pointer
 */
-const char *talloc_set_name(const void *ptr, const char *fmt, ...)
+_PUBLIC_ const char *talloc_set_name(const void *ptr, const char *fmt, ...)
 {
 	const char *name;
 	va_list ap;
@@ -916,7 +916,7 @@ const char *talloc_set_name(const void *ptr, const char *fmt, ...)
   talloc_named() operates just like talloc() except that it allows you
   to name the pointer.
 */
-void *talloc_named(const void *context, size_t size, const char *fmt, ...)
+_PUBLIC_ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
 {
 	va_list ap;
 	void *ptr;
@@ -940,7 +940,7 @@ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
 /*
   return the name of a talloc ptr, or "UNNAMED"
 */
-const char *talloc_get_name(const void *ptr)
+_PUBLIC_ const char *talloc_get_name(const void *ptr)
 {
 	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 	if (unlikely(tc->name == TALLOC_MAGIC_REFERENCE)) {
@@ -957,7 +957,7 @@ const char *talloc_get_name(const void *ptr)
   check if a pointer has the given name. If it does, return the pointer,
   otherwise return NULL
 */
-void *talloc_check_name(const void *ptr, const char *name)
+_PUBLIC_ void *talloc_check_name(const void *ptr, const char *name)
 {
 	const char *pname;
 	if (unlikely(ptr == NULL)) return NULL;
@@ -986,7 +986,7 @@ static void talloc_abort_type_missmatch(const char *location,
 	talloc_abort(reason);
 }
 
-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)
 {
 	const char *pname;
 
@@ -1007,7 +1007,7 @@ void *_talloc_get_type_abort(const void *ptr, const char *name, const char *loca
 /*
   this is for compatibility with older versions of talloc
 */
-void *talloc_init(const char *fmt, ...)
+_PUBLIC_ void *talloc_init(const char *fmt, ...)
 {
 	va_list ap;
 	void *ptr;
@@ -1040,7 +1040,7 @@ void *talloc_init(const char *fmt, ...)
   should probably not be used in new code. It's in here to keep the talloc
   code consistent across Samba 3 and 4.
 */
-void talloc_free_children(void *ptr)
+_PUBLIC_ void talloc_free_children(void *ptr)
 {
 	struct talloc_chunk *tc;
 
@@ -1084,7 +1084,7 @@ void talloc_free_children(void *ptr)
 /* 
    Allocate a bit of memory as a child of an existing pointer
 */
-void *_talloc(const void *context, size_t size)
+_PUBLIC_ void *_talloc(const void *context, size_t size)
 {
 	return __talloc(context, size);
 }
@@ -1092,7 +1092,7 @@ void *_talloc(const void *context, size_t size)
 /*
   externally callable talloc_set_name_const()
 */
-void talloc_set_name_const(const void *ptr, const char *name)
+_PUBLIC_ void talloc_set_name_const(const void *ptr, const char *name)
 {
 	_talloc_set_name_const(ptr, name);
 }
@@ -1102,7 +1102,7 @@ void talloc_set_name_const(const void *ptr, const char *name)
   talloc_named() operates just like talloc() except that it allows you
   to name the pointer.
 */
-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)
 {
 	return _talloc_named_const(context, size, name);
 }
@@ -1115,7 +1115,7 @@ void *talloc_named_const(const void *context, size_t size, const char *name)
    will not be freed if the ref_count is > 1 or the destructor (if
    any) returns non-zero
 */
-int _talloc_free(void *ptr, const char *location)
+_PUBLIC_ int _talloc_free(void *ptr, const char *location)
 {
 	struct talloc_chunk *tc;
 
@@ -1147,7 +1147,7 @@ int _talloc_free(void *ptr, const char *location)
   A talloc version of realloc. The context argument is only used if
   ptr is NULL
 */
-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)
 {
 	struct talloc_chunk *tc;
 	void *new_ptr;
@@ -1249,7 +1249,7 @@ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *n
   a wrapper around talloc_steal() for situations where you are moving a pointer
   between two structures, and want the old pointer to be set to NULL
 */
-void *_talloc_move(const void *new_ctx, const void *_pptr)
+_PUBLIC_ void *_talloc_move(const void *new_ctx, const void *_pptr)
 {
 	const void **pptr = discard_const_p(const void *,_pptr);
 	void *ret = talloc_steal(new_ctx, discard_const_p(void, *pptr));
@@ -1260,7 +1260,7 @@ void *_talloc_move(const void *new_ctx, const void *_pptr)
 /*
   return the total size of a talloc pool (subtree)
 */
-size_t talloc_total_size(const void *ptr)
+_PUBLIC_ size_t talloc_total_size(const void *ptr)
 {
 	size_t total = 0;
 	struct talloc_chunk *c, *tc;
@@ -1295,7 +1295,7 @@ size_t talloc_total_size(const void *ptr)
 /*
   return the total number of blocks in a talloc pool (subtree)
 */
-size_t talloc_total_blocks(const void *ptr)
+_PUBLIC_ size_t talloc_total_blocks(const void *ptr)
 {
 	size_t total = 0;
 	struct talloc_chunk *c, *tc;
@@ -1328,7 +1328,7 @@ size_t talloc_total_blocks(const void *ptr)
 /*
   return the number of external references to a pointer
 */
-size_t talloc_reference_count(const void *ptr)
+_PUBLIC_ size_t talloc_reference_count(const void *ptr)
 {
 	struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 	struct talloc_reference_handle *h;
@@ -1343,7 +1343,7 @@ size_t talloc_reference_count(const void *ptr)
 /*
   report on memory usage by all children of a pointer, giving a full tree view
 */
-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,
@@ -1427,7 +1427,7 @@ static void talloc_report_depth_FILE_helper(const void *ptr, int depth, int max_
 /*
   report on memory usage by all children of a pointer, giving a full tree view
 */
-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)
 {
 	if (f) {
 		talloc_report_depth_cb(ptr, depth, max_depth, talloc_report_depth_FILE_helper, f);
@@ -1438,7 +1438,7 @@ void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f
 /*
   report on memory usage by all children of a pointer, giving a full tree view
 */
-void talloc_report_full(const void *ptr, FILE *f)
+_PUBLIC_ void talloc_report_full(const void *ptr, FILE *f)
 {
 	talloc_report_depth_file(ptr, 0, -1, f);
 }
@@ -1446,7 +1446,7 @@ void talloc_report_full(const void *ptr, FILE *f)
 /*
   report on memory usage by all children of a pointer
 */
-void talloc_report(const void *ptr, FILE *f)
+_PUBLIC_ void talloc_report(const void *ptr, FILE *f)
 {
 	talloc_report_depth_file(ptr, 0, 1, f);
 }
@@ -1474,7 +1474,7 @@ static void talloc_report_null_full(void)
 /*
   enable tracking of the NULL context
 */
-void talloc_enable_null_tracking(void)
+_PUBLIC_ void talloc_enable_null_tracking(void)
 {
 	if (null_context == NULL) {
 		null_context = _talloc_named_const(NULL, 0, "null_context");
@@ -1488,7 +1488,7 @@ void talloc_enable_null_tracking(void)
   enable tracking of the NULL context, not moving the autofree context
   into the NULL context. This is needed for the talloc testsuite
 */
-void talloc_enable_null_tracking_no_autofree(void)
+_PUBLIC_ void talloc_enable_null_tracking_no_autofree(void)
 {
 	if (null_context == NULL) {
 		null_context = _talloc_named_const(NULL, 0, "null_context");
@@ -1498,7 +1498,7 @@ void talloc_enable_null_tracking_no_autofree(void)
 /*
   disable tracking of the NULL context
 */
-void talloc_disable_null_tracking(void)
+_PUBLIC_ void talloc_disable_null_tracking(void)
 {
 	if (null_context != NULL) {
 		/* we have to move any children onto the real NULL
@@ -1523,7 +1523,7 @@ void talloc_disable_null_tracking(void)
 /*
   enable leak reporting on exit
 */
-void talloc_enable_leak_report(void)
+_PUBLIC_ void talloc_enable_leak_report(void)
 {
 	talloc_enable_null_tracking();
 	atexit(talloc_report_null);
@@ -1532,7 +1532,7 @@ void talloc_enable_leak_report(void)
 /*
   enable full leak reporting on exit
 */
-void talloc_enable_leak_report_full(void)
+_PUBLIC_ void talloc_enable_leak_report_full(void)
 {
 	talloc_enable_null_tracking();
 	atexit(talloc_report_null_full);
@@ -1541,7 +1541,7 @@ void talloc_enable_leak_report_full(void)
 /* 
    talloc and zero memory. 
 */
-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)
 {
 	void *p = _talloc_named_const(ctx, size, name);
 
@@ -1555,7 +1555,7 @@ void *_talloc_zero(const void *ctx, size_t size, const char *name)
 /*
   memdup with a talloc. 
 */
-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)
 {
 	void *newp = _talloc_named_const(t, size, name);
 
@@ -1583,7 +1583,7 @@ static inline char *__talloc_strlendup(const void *t, const char *p, size_t len)
 /*
   strdup with a talloc
 */
-char *talloc_strdup(const void *t, const char *p)
+_PUBLIC_ char *talloc_strdup(const void *t, const char *p)
 {
 	if (unlikely(!p)) return NULL;
 	return __talloc_strlendup(t, p, strlen(p));
@@ -1592,7 +1592,7 @@ char *talloc_strdup(const void *t, const char *p)
 /*
   strndup with a talloc
 */
-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)
 {
 	if (unlikely(!p)) return NULL;
 	return __talloc_strlendup(t, p, strnlen(p, n));
@@ -1617,7 +1617,7 @@ static inline char *__talloc_strlendup_append(char *s, size_t slen,
 /*
  * Appends at the end of the string.
  */
-char *talloc_strdup_append(char *s, const char *a)
+_PUBLIC_ char *talloc_strdup_append(char *s, const char *a)
 {
 	if (unlikely(!s)) {
 		return talloc_strdup(NULL, a);
@@ -1634,7 +1634,7 @@ char *talloc_strdup_append(char *s, const char *a)
  * Appends at the end of the talloc'ed buffer,
  * not the end of the string.
  */
-char *talloc_strdup_append_buffer(char *s, const char *a)
+_PUBLIC_ char *talloc_strdup_append_buffer(char *s, const char *a)
 {
 	size_t slen;
 
@@ -1657,7 +1657,7 @@ char *talloc_strdup_append_buffer(char *s, const char *a)
 /*
  * Appends at the end of the string.
  */
-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)
 {
 	if (unlikely(!s)) {
 		return talloc_strdup(NULL, a);
@@ -1674,7 +1674,7 @@ char *talloc_strndup_append(char *s, const char *a, size_t n)
  * Appends at the end of the talloc'ed buffer,
  * not the end of the string.
  */
-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)
 {
 	size_t slen;
 
@@ -1702,7 +1702,7 @@ char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
 #endif
 #endif
 
-char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
+_PUBLIC_ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
 {
 	int len;
 	char *ret;
@@ -1733,7 +1733,7 @@ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
   Perform string formatting, and return a pointer to newly allocated
   memory holding the result, inside a memory pool.
  */
-char *talloc_asprintf(const void *t, const char *fmt, ...)
+_PUBLIC_ char *talloc_asprintf(const void *t, const char *fmt, ...)
 {
 	va_list ap;
 	char *ret;
@@ -1786,7 +1786,7 @@ static inline char *__talloc_vaslenprintf_append(char *s, size_t slen,
  * accumulating output into a string buffer. Appends at the end
  * of the string.
  **/
-char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
+_PUBLIC_ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
 {
 	if (unlikely(!s)) {
 		return talloc_vasprintf(NULL, fmt, ap);
@@ -1800,7 +1800,7 @@ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
  * and return @p s, which may have moved. Always appends at the
  * end of the talloc'ed buffer, not the end of the string.
  **/
-char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
+_PUBLIC_ char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
 {
 	size_t slen;
 
@@ -1821,7 +1821,7 @@ char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
   s, which may have moved.  Good for gradually accumulating output
   into a string buffer.
  */
-char *talloc_asprintf_append(char *s, const char *fmt, ...)
+_PUBLIC_ char *talloc_asprintf_append(char *s, const char *fmt, ...)
 {
 	va_list ap;
 
@@ -1836,7 +1836,7 @@ char *talloc_asprintf_append(char *s, const char *fmt, ...)
   s, which may have moved.  Good for gradually accumulating output
   into a buffer.
  */
-char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
+_PUBLIC_ char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
 {
 	va_list ap;
 
@@ -1849,7 +1849,7 @@ char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
 /*
   alloc an array, checking for integer overflow in the array size
 */
-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)
 {
 	if (count >= MAX_TALLOC_SIZE/el_size) {
 		return NULL;
@@ -1860,7 +1860,7 @@ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char
 /*
   alloc an zero array, checking for integer overflow in the array size
 */
-void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
+_PUBLIC_ void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
 {
 	if (count >= MAX_TALLOC_SIZE/el_size) {
 		return NULL;
@@ -1871,7 +1871,7 @@ void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const
 /*
   realloc an array, checking for integer overflow in the array size
 */
-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)
 {
 	if (count >= MAX_TALLOC_SIZE/el_size) {
 		return NULL;
@@ -1884,7 +1884,7 @@ void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned
   to libraries that want a realloc function (a realloc function encapsulates
   all the basic capabilities of an allocation library, which is why this is useful)
 */
-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 _talloc_realloc(context, ptr, size, NULL);
 }
@@ -1905,7 +1905,7 @@ static void talloc_autofree(void)
   return a context which will be auto-freed on exit
   this is useful for reducing the noise in leak reports
 */
-void *talloc_autofree_context(void)
+_PUBLIC_ void *talloc_autofree_context(void)
 {
 	if (autofree_context == NULL) {
 		autofree_context = _talloc_named_const(NULL, 0, "autofree_context");
@@ -1915,7 +1915,7 @@ void *talloc_autofree_context(void)
 	return autofree_context;
 }
 
-size_t talloc_get_size(const void *context)
+_PUBLIC_ size_t talloc_get_size(const void *context)
 {
 	struct talloc_chunk *tc;
 
@@ -1934,7 +1934,7 @@ size_t talloc_get_size(const void *context)
 /*
   find a parent of this context that has the given name, if any
 */
-void *talloc_find_parent_byname(const void *context, const char *name)
+_PUBLIC_ void *talloc_find_parent_byname(const void *context, const char *name)
 {
 	struct talloc_chunk *tc;
 
@@ -1958,7 +1958,7 @@ void *talloc_find_parent_byname(const void *context, const char *name)
 /*
   show the parentage of a context
 */
-void talloc_show_parents(const void *context, FILE *file)
+_PUBLIC_ void talloc_show_parents(const void *context, FILE *file)
 {
 	struct talloc_chunk *tc;
 
@@ -2005,7 +2005,7 @@ static int _talloc_is_parent(const void *context, const void *ptr, int depth)
 /*
   return 1 if ptr is a parent of context
 */
-int talloc_is_parent(const void *context, const void *ptr)
+_PUBLIC_ int talloc_is_parent(const void *context, const void *ptr)
 {
 	return _talloc_is_parent(context, ptr, TALLOC_MAX_DEPTH);
 }