* One should never declare a variable with this type, but only a pointer
* to it, e.g.
*
- * struct ast_dynamic_str *ds;
+ * struct ast_str *ds;
*
* The pointer can be initialized with the following:
*
- * ds = ast_dynamic_str_create(init_len);
+ * ds = ast_str_create(init_len);
* creates a malloc()'ed dynamic string;
*
- * ds = ast_dynamic_str_alloca(init_len);
+ * ds = ast_str_alloca(init_len);
* creates a string on the stack (not very dynamic!).
*
- * ds = ast_dynamic_str_thread_get(ts, init_len)
+ * ds = ast_str_thread_get(ts, init_len)
* creates a malloc()'ed dynamic string associated to
* the thread-local storage key ts
*
* Finally, the string can be manipulated with the following:
*
- * ast_dynamic_str_set(&buf, max_len, ts, fmt, ...)
- * ast_dynamic_str_append(&buf, max_len, ts, fmt, ...)
- * ast_dynamic_str_thread_set(&buf, max_len, ts, fmt, ...)
- * ast_dynamic_str_thread_append(&buf, max_len, ts, fmt, ...)
+ * ast_str_set(&buf, max_len, ts, fmt, ...)
+ * ast_str_append(&buf, max_len, ts, fmt, ...)
*
* and their varargs format.
*
* \arg max_len The maximum allowed length, reallocating if needed.
* 0 means unlimited, -1 means "at most the available space"
- *
- * XXX the [_thread] variants can be removed if we save the ts in the
- * string descriptor.
*/
-/*! \brief type of storage used for dynamic string */
-enum dynstr_type {
- DS_MALLOC = 1,
- DS_ALLOCA = 2,
- DS_STATIC = 3, /* XXX not supported yet */
-};
-
/*! \brief The descriptor of a dynamic string
* XXX storage will be optimized later if needed
+ * We use the ts field to indicate the type of storage.
+ * Three special constants indicate malloc, alloca() or static
+ * variables, all other values indicate a
+ * struct ast_threadstorage pointer.
*/
-struct ast_dynamic_str {
+struct ast_str {
size_t len; /*!< The current maximum length of the string */
size_t used; /*!< Amount of space used */
- enum dynstr_type type; /*!< What kind of storage is this ? */
+ struct ast_threadstorage *ts; /*!< What kind of storage is this ? */
+#define DS_MALLOC ((struct ast_threadstorage *)1)
+#define DS_ALLOCA ((struct ast_threadstorage *)2)
+#define DS_STATIC ((struct ast_threadstorage *)3) /* not supported yet */
char str[0]; /*!< The string buffer */
};
* be free()'d after it is no longer needed.
*/
AST_INLINE_API(
-struct ast_dynamic_str * attribute_malloc ast_dynamic_str_create(size_t init_len),
+struct ast_str * attribute_malloc ast_str_create(size_t init_len),
{
- struct ast_dynamic_str *buf;
+ struct ast_str *buf;
if (!(buf = ast_calloc(1, sizeof(*buf) + init_len)))
return NULL;
buf->len = init_len;
buf->used = 0;
- buf->type = DS_MALLOC;
+ buf->ts = DS_MALLOC;
return buf;
}
)
-#define ast_dynamic_str_alloca(init_len) \
+#define ast_str_alloca(init_len) \
({ \
- struct ast_dynamic_str *buf; \
+ struct ast_str *buf; \
buf = alloca(sizeof(*buf) + init_len); \
buf->len = init_len; \
buf->used = 0; \
- buf->type = DS_ALLOCA; \
+ buf->ts = DS_ALLOCA; \
buf->str[0] = '\0'; \
(buf); \
})
* ...
* void my_func(const char *fmt, ...)
* {
- * struct ast_dynamic_str *buf;
+ * struct ast_str *buf;
*
- * if (!(buf = ast_dynamic_str_thread_get(&my_str, MY_STR_INIT_SIZE)))
+ * if (!(buf = ast_str_thread_get(&my_str, MY_STR_INIT_SIZE)))
* return;
* ...
* }
* \endcode
*/
AST_INLINE_API(
-struct ast_dynamic_str *ast_dynamic_str_thread_get(struct ast_threadstorage *ts,
+struct ast_str *ast_str_thread_get(struct ast_threadstorage *ts,
size_t init_len),
{
- struct ast_dynamic_str *buf;
+ struct ast_str *buf;
if (!(buf = ast_threadstorage_get(ts, sizeof(*buf) + init_len)))
return NULL;
if (!buf->len) {
buf->len = init_len;
buf->used = 0;
- buf->type = DS_MALLOC;
+ buf->ts = ts;
}
return buf;
)
/*!
- * \brief Error codes from __ast_dyn_str_helper()
+ * \brief Error codes from __ast_str_helper()
* The undelying processing to manipulate dynamic string is done
- * by __ast_dyn_str_helper(), which can return a success, a
+ * by __ast_str_helper(), which can return a success, a
* permanent failure (e.g. no memory), or a temporary one (when
* the string needs to be reallocated, and we must run va_start()
* again; XXX this convoluted interface is only here because
* are undefined */
AST_DYNSTR_BUILD_FAILED = -1,
/*! The buffer size for the dynamic string had to be increased, and
- * ast_dynamic_str_thread_build_va() needs to be called again after
+ * __ast_str_helper() needs to be called again after
* a va_end() and va_start().
*/
AST_DYNSTR_BUILD_RETRY = -2
};
/*!
- * \brief Set a thread locally stored dynamic string from a va_list
+ * \brief Set a dynamic string from a va_list
*
- * \arg buf This is the address of a pointer to an ast_dynamic_str which should
- * have been retrieved using ast_dynamic_str_thread_get. It will need to
+ * \arg buf This is the address of a pointer to a struct ast_str.
+ * If it is retrieved using ast_str_thread_get, the
+ struct ast_threadstorage pointer will need to
* be updated in the case that the buffer has to be reallocated to
* accommodate a longer string than what it currently has space for.
* \arg max_len This is the maximum length to allow the string buffer to grow
* to. If this is set to 0, then there is no maximum length.
- * \arg ts This is a pointer to the thread storage structure declared by using
- * the AST_THREADSTORAGE macro. If declared with
- * AST_THREADSTORAGE(my_buf, my_buf_init), then this argument would be
- * (&my_buf).
* \arg fmt This is the format string (printf style)
* \arg ap This is the va_list
*
* \return The return value of this function is the same as that of the printf
* family of functions.
*
- * Example usage:
+ * Example usage (the first part is only for thread-local storage)
* \code
* AST_THREADSTORAGE(my_str, my_str_init);
* #define MY_STR_INIT_SIZE 128
* ...
* void my_func(const char *fmt, ...)
* {
- * struct ast_dynamic_str *buf;
+ * struct ast_str *buf;
* va_list ap;
*
- * if (!(buf = ast_dynamic_str_thread_get(&my_str, MY_STR_INIT_SIZE)))
+ * if (!(buf = ast_str_thread_get(&my_str, MY_STR_INIT_SIZE)))
* return;
* ...
* va_start(fmt, ap);
- * ast_dynamic_str_thread_set_va(&buf, 0, &my_str, fmt, ap);
+ * ast_str_set_va(&buf, 0, fmt, ap);
* va_end(ap);
*
* printf("This is the string we just built: %s\n", buf->str);
* \note: the following two functions must be implemented as macros
* because we must do va_end()/va_start() on the original arguments.
*/
-#define ast_dynamic_str_thread_set_va(buf, max_len, ts, fmt, ap) \
+#define ast_str_set_va(buf, max_len, fmt, ap) \
({ \
int __res; \
- while ((__res = __ast_dyn_str_helper(buf, max_len, \
- ts, 0, fmt, ap)) == AST_DYNSTR_BUILD_RETRY) { \
+ while ((__res = __ast_str_helper(buf, max_len, \
+ 0, fmt, ap)) == AST_DYNSTR_BUILD_RETRY) { \
va_end(ap); \
va_start(ap, fmt); \
} \
})
/*!
- * \brief Append to a thread local dynamic string using a va_list
+ * \brief Append to a dynamic string using a va_list
*
- * The arguments, return values, and usage of this are the same as those for
- * ast_dynamic_str_thread_set_va(). However, instead of setting a new value
- * for the string, this will append to the current value.
+ * Same as ast_str_set_va(), but append to the current content.
*/
-#define ast_dynamic_str_thread_append_va(buf, max_len, ts, fmt, ap) \
+#define ast_str_append_va(buf, max_len, fmt, ap) \
({ \
int __res; \
- while ((__res = __ast_dyn_str_helper(buf, max_len, \
- ts, 1, fmt, ap)) == AST_DYNSTR_BUILD_RETRY) { \
+ while ((__res = __ast_str_helper(buf, max_len, \
+ 1, fmt, ap)) == AST_DYNSTR_BUILD_RETRY) { \
va_end(ap); \
va_start(ap, fmt); \
} \
})
/*!
- * \brief Core functionality of ast_dynamic_str_[thread_](set|append)_va
+ * \brief Core functionality of ast_str_(set|append)_va
*
* The arguments to this function are the same as those described for
- * ast_dynamic_str_thread_set_va except for an addition argument, append.
+ * ast_str_set_va except for an addition argument, append.
* If append is non-zero, this will append to the current string instead of
* writing over it.
*
* through calling one of the other functions or macros defined in this
* file.
*/
-int __ast_dyn_str_helper(struct ast_dynamic_str **buf, size_t max_len,
- struct ast_threadstorage *ts, int append, const char *fmt, va_list ap);
+int __ast_str_helper(struct ast_str **buf, size_t max_len,
+ int append, const char *fmt, va_list ap);
/*!
- * \brief Set a thread locally stored dynamic string using variable arguments
+ * \brief Set a dynamic string using variable arguments
*
- * \arg buf This is the address of a pointer to an ast_dynamic_str which should
- * have been retrieved using ast_dynamic_str_thread_get. It will need to
+ * \arg buf This is the address of a pointer to a struct ast_str which should
+ * have been retrieved using ast_str_thread_get. It will need to
* be updated in the case that the buffer has to be reallocated to
* accomodate a longer string than what it currently has space for.
* \arg max_len This is the maximum length to allow the string buffer to grow
* to. If this is set to 0, then there is no maximum length.
- * \arg ts This is a pointer to the thread storage structure declared by using
- * the AST_THREADSTORAGE macro. If declared with
- * AST_THREADSTORAGE(my_buf, my_buf_init), then this argument would be
- * (&my_buf).
+ * If set to -1, we are bound to the current maximum length.
* \arg fmt This is the format string (printf style)
*
* \return The return value of this function is the same as that of the printf
* family of functions.
*
- * Example usage:
- * \code
- * AST_THREADSTORAGE(my_str, my_str_init);
- * #define MY_STR_INIT_SIZE 128
- * ...
- * void my_func(int arg1, int arg2)
- * {
- * struct ast_dynamic_str *buf;
- * va_list ap;
- *
- * if (!(buf = ast_dynamic_str_thread_get(&my_str, MY_STR_INIT_SIZE)))
- * return;
- * ...
- * ast_dynamic_str_thread_set(&buf, 0, &my_str, "arg1: %d arg2: %d\n",
- * arg1, arg2);
- *
- * printf("This is the string we just built: %s\n", buf->str);
- * ...
- * }
- * \endcode
+ * All the rest is the same as ast_str_set_va()
*/
AST_INLINE_API(
-int __attribute__ ((format (printf, 4, 5))) ast_dynamic_str_thread_set(
- struct ast_dynamic_str **buf, size_t max_len,
- struct ast_threadstorage *ts, const char *fmt, ...),
+int __attribute__ ((format (printf, 3, 4))) ast_str_set(
+ struct ast_str **buf, size_t max_len, const char *fmt, ...),
{
int res;
va_list ap;
va_start(ap, fmt);
- res = ast_dynamic_str_thread_set_va(buf, max_len, ts, fmt, ap);
+ res = ast_str_set_va(buf, max_len, fmt, ap);
va_end(ap);
return res;
* \brief Append to a thread local dynamic string
*
* The arguments, return values, and usage of this function are the same as
- * ast_dynamic_str_thread_set(). However, instead of setting a new value for
- * the string, this function appends to the current value.
- */
-AST_INLINE_API(
-int __attribute__ ((format (printf, 4, 5))) ast_dynamic_str_thread_append(
- struct ast_dynamic_str **buf, size_t max_len,
- struct ast_threadstorage *ts, const char *fmt, ...),
-{
- int res;
- va_list ap;
-
- va_start(ap, fmt);
- res = ast_dynamic_str_thread_append_va(buf, max_len, ts, fmt, ap);
- va_end(ap);
-
- return res;
-}
-)
-
-/*!
- * \brief Set a dynamic string
- *
- * \arg buf This is the address of a pointer to an ast_dynamic_str. It will
- * need to be updated in the case that the buffer has to be reallocated to
- * accommodate a longer string than what it currently has space for.
- * \arg max_len This is the maximum length to allow the string buffer to grow
- * to. If this is set to 0, then there is no maximum length.
- *
- * \return The return value of this function is the same as that of the printf
- * family of functions.
+ * ast_str_set(), but the new data is appended to the current value.
*/
AST_INLINE_API(
-int __attribute__ ((format (printf, 3, 4))) ast_dynamic_str_set(
- struct ast_dynamic_str **buf, size_t max_len,
- const char *fmt, ...),
+int __attribute__ ((format (printf, 3, 4))) ast_str_append(
+ struct ast_str **buf, size_t max_len, const char *fmt, ...),
{
int res;
va_list ap;
-
- va_start(ap, fmt);
- res = ast_dynamic_str_thread_set_va(buf, max_len, NULL, fmt, ap);
- va_end(ap);
-
- return res;
-}
-)
-/*!
- * \brief Append to a dynamic string
- *
- * The arguments, return values, and usage of this function are the same as
- * ast_dynamic_str_set(). However, this function appends to the string instead
- * of setting a new value.
- */
-AST_INLINE_API(
-int __attribute__ ((format (printf, 3, 4))) ast_dynamic_str_append(
- struct ast_dynamic_str **buf, size_t max_len,
- const char *fmt, ...),
-{
- int res;
- va_list ap;
-
va_start(ap, fmt);
- res = ast_dynamic_str_thread_append_va(buf, max_len, NULL, fmt, ap);
+ res = ast_str_append_va(buf, max_len, fmt, ap);
va_end(ap);
return res;
void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
{
struct logchannel *chan;
- struct ast_dynamic_str *buf;
+ struct ast_str *buf;
time_t t;
struct tm tm;
char date[256];
va_list ap;
- if (!(buf = ast_dynamic_str_thread_get(&log_buf, LOG_BUF_INIT_SIZE)))
+ if (!(buf = ast_str_thread_get(&log_buf, LOG_BUF_INIT_SIZE)))
return;
if (AST_LIST_EMPTY(&logchannels))
if (level != __LOG_VERBOSE) {
int res;
va_start(ap, fmt);
- res = ast_dynamic_str_thread_set_va(&buf, BUFSIZ, &log_buf, fmt, ap);
+ res = ast_str_set_va(&buf, BUFSIZ, fmt, ap); /* XXX BUFSIZ ? */
va_end(ap);
if (res != AST_DYNSTR_BUILD_FAILED) {
term_filter_escapes(buf->str);
if (level != __LOG_VERBOSE) {
int res;
sprintf(linestr, "%d", line);
- ast_dynamic_str_thread_set(&buf, BUFSIZ, &log_buf,
+ ast_str_set(&buf, BUFSIZ,
"[%s] %s[%ld]: %s:%s %s: ",
date,
term_color(tmp1, levels[level], colors[level], 0, sizeof(tmp1)),
ast_console_puts_mutable(buf->str);
va_start(ap, fmt);
- res = ast_dynamic_str_thread_set_va(&buf, BUFSIZ, &log_buf, fmt, ap);
+ res = ast_str_set_va(&buf, BUFSIZ, fmt, ap);
va_end(ap);
if (res != AST_DYNSTR_BUILD_FAILED)
ast_console_puts_mutable(buf->str);
/* File channels */
} else if ((chan->logmask & (1 << level)) && (chan->fileptr)) {
int res;
- ast_dynamic_str_thread_set(&buf, BUFSIZ, &log_buf,
+ ast_str_set(&buf, BUFSIZ,
"[%s] %s[%ld] %s: ",
date, levels[level], (long)GETTID(), file);
res = fprintf(chan->fileptr, "%s", buf->str);
int res;
/* No error message, continue printing */
va_start(ap, fmt);
- res = ast_dynamic_str_thread_set_va(&buf, BUFSIZ, &log_buf, fmt, ap);
+ res = ast_str_set_va(&buf, BUFSIZ, fmt, ap);
va_end(ap);
if (res != AST_DYNSTR_BUILD_FAILED) {
term_strip(buf->str, buf->str, buf->len);
void ast_verbose(const char *fmt, ...)
{
struct verb *v;
- struct ast_dynamic_str *buf;
+ struct ast_str *buf;
int res;
va_list ap;
fmt = datefmt;
}
- if (!(buf = ast_dynamic_str_thread_get(&verbose_buf, VERBOSE_BUF_INIT_SIZE)))
+ if (!(buf = ast_str_thread_get(&verbose_buf, VERBOSE_BUF_INIT_SIZE)))
return;
va_start(ap, fmt);
- res = ast_dynamic_str_thread_set_va(&buf, 0, &verbose_buf, fmt, ap);
+ res = ast_str_set_va(&buf, 0, fmt, ap);
va_end(ap);
if (res == AST_DYNSTR_BUILD_FAILED)
projects / thirdparty / asterisk.git / commitdiff
