static void filter_ansi(FILE *file, const char *fmt, va_list args)
{
_cleanup_free_ char *str = NULL;
size_t len, i, j;
if (color_mode == COLOR_MODE_ALWAYS ||
(color_mode == COLOR_MODE_AUTO && isatty(fileno(file)))) {
vfprintf(file, fmt, args);
return;
}
len = xvasprintf(&str, fmt, args);
for (i = 0; i < len - 2; ++i) {
if (str[i] == '\x1b' && str[i + 1] == '[') {
str[i] = str[i + 1] = '\0';
for (j = i + 2; j < len; ++j) {
if (isalpha(str[j]))
break;
str[j] = '\0';
}
str[j] = '\0';
}
}
for (i = 0; i < len; i = j) {
fputs(&str[i], file);
for (j = i + strlen(&str[i]); j < len; ++j) {
if (str[j] != '\0')
break;
}
}
}
void printflike2
attach_log(struct attach *atr, const char *fmt, ...)
{
va_list ap;
char *prefix;
u_int n;
va_start(ap, fmt);
xvasprintf(&prefix, fmt, ap);
va_end(ap);
n = 0;
while (atr != NULL) {
if (TAILQ_EMPTY(&atr->children)) {
if (atr->name == NULL) {
log_debug3("%s:%*s%u, %s: offset %zu, size %zu,"
" body %zu", prefix, n + 1, " ", atr->idx,
atr->type, atr->data, atr->size, atr->body);
} else {
log_debug3("%s:%*s%u, %s: offset %zu, size %zu,"
" body %zu: %s", prefix, n + 1, " ",
atr->idx, atr->type, atr->data, atr->size,
atr->body, atr->name);
}
} else {
log_debug3("%s:%*s%u, %s", prefix, n + 1, " ", atr->idx,
atr->type);
}
atr = attach_visit(atr, &n);
}
xfree(prefix);
}
/* Calculate string length, with embedded formatting. */
size_t
screen_write_cstrlen(const char *fmt, ...)
{
va_list ap;
char *msg, *msg2, *ptr, *ptr2;
size_t size;
va_start(ap, fmt);
xvasprintf(&msg, fmt, ap);
va_end(ap);
msg2 = xmalloc(strlen(msg) + 1);
ptr = msg;
ptr2 = msg2;
while (*ptr != '\0') {
if (ptr[0] == '#' && ptr[1] == '[') {
while (*ptr != ']' && *ptr != '\0')
ptr++;
if (*ptr == ']')
ptr++;
continue;
}
*ptr2++ = *ptr++;
}
*ptr2 = '\0';
size = screen_write_strlen("%s", msg2);
free(msg);
free(msg2);
return (size);
}
/* Calculate string length. */
size_t printflike2
screen_write_strlen(int utf8flag, const char *fmt, ...)
{
va_list ap;
char *msg;
struct utf8_data utf8data;
u_char *ptr;
size_t left, size = 0;
va_start(ap, fmt);
xvasprintf(&msg, fmt, ap);
va_end(ap);
ptr = msg;
while (*ptr != '\0') {
if (utf8flag && *ptr > 0x7f && utf8_open(&utf8data, *ptr)) {
ptr++;
left = strlen(ptr);
if (left < utf8data.size - 1)
break;
while (utf8_append(&utf8data, *ptr))
ptr++;
ptr++;
size += utf8data.width;
} else {
size++;
ptr++;
}
}
free(msg);
return (size);
}
xvasprintf_wrapper(char **strp, const char *format, ...)
{
va_list args;
va_start(args, format);
xvasprintf(strp, format, args);
va_end(args);
}
static char *
test_xvasprintf_helper( const char *fmt, ... ) {
va_list ap;
va_start(ap, fmt );
char *str = xvasprintf( fmt, ap );
va_end( ap );
return str;
}
char *xasprintf(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
char *strp = xvasprintf(fmt, ap);
va_end(ap);
return strp;
}
/* Insert header, before specified header if not NULL, otherwise at end. */
int printflike3
insert_header(struct mail *m, const char *before, const char *fmt, ...)
{
va_list ap;
char *hdr, *ptr;
size_t hdrlen, len, off;
u_int newlines;
newlines = 1;
if (before != NULL) {
/* Insert before header. */
ptr = find_header(m, before, &len, 0);
if (ptr == NULL)
return (-1);
off = ptr - m->data;
} else {
/* Insert at the end. */
if (m->body == 0) {
/*
* Creating the headers section. Insert at the start,
* and add an extra newline.
*/
off = 0;
newlines++;
} else {
/*
* Body points just after the blank line. Insert before
* the blank line.
*/
off = m->body - 1;
}
}
/* Create the header. */
va_start(ap, fmt);
hdrlen = xvasprintf(&hdr, fmt, ap);
va_end(ap);
/* Include the newlines. */
hdrlen += newlines;
/* Make space for the header. */
if (mail_resize(m, m->size + hdrlen) != 0) {
xfree(hdr);
return (-1);
}
ptr = m->data + off;
memmove(ptr + hdrlen, ptr, m->size - off);
/* Copy the header. */
memcpy(ptr, hdr, hdrlen - newlines);
memset(ptr + hdrlen - newlines, '\n', newlines);
m->size += hdrlen;
m->body += hdrlen;
xfree(hdr);
return (0);
}
void flux_log_verror (flux_t *h, const char *fmt, va_list ap)
{
int saved_errno = errno;
char *s = xvasprintf (fmt, ap);
flux_log (h, LOG_ERR, "%s: %s", s, flux_strerror (errno));
free (s);
errno = saved_errno;
}
static void link_arg_f(const char *fmt, ...)
{
va_list ap;
assert(n_args < MAX_ARGS);
va_start(ap, fmt);
args[n_args] = xvasprintf(fmt, ap);
va_end(ap);
args[++n_args] = NULL;
}
/* ARGSUSED */
void printflike2
cfg_error(unused struct cmd_ctx *ctx, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
xvasprintf(&cfg_cause, fmt, ap);
va_end(ap);
}
static struct ovsdb_error *
ovsdb_error_valist(const char *tag, const char *details, va_list args)
{
struct ovsdb_error *error = xmalloc(sizeof *error);
error->tag = tag ? tag : "ovsdb error";
error->details = details ? xvasprintf(details, args) : NULL;
error->syntax = NULL;
error->errno_ = 0;
return error;
}
int
xasprintf (char **strp, const char *fmt, ...)
{
va_list ap;
int result;
va_start (ap, fmt);
result = xvasprintf (strp, fmt, ap);
va_end (ap);
return result;
}
static int tcl_error(Tcl_Interp *interp, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
char *buf LOCAL = xvasprintf(fmt, ap);
va_end(ap);
Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, -1));
return TCL_ERROR;
}
char *
xasprintf (const char *fmt, ...)
{
char *buf;
va_list ap;
va_start (ap, fmt);
buf = xvasprintf (fmt, ap);
va_end (ap);
return buf;
}
// Die with an error message if we can't malloc() enough space and do an
// sprintf() into that space., sizeof() into that space.)
char* xasprintf(const char *format, ...)
{
va_list p;
char *string_ptr;
va_start(p, format);
string_ptr = xvasprintf(format, p);
va_end(p);
return string_ptr;
}
action_error(struct action_context *ctx, const char *message, ...)
{
if (action_error_handle_common(ctx)) {
return;
}
va_list args;
va_start(args, message);
ctx->error = xvasprintf(message, args);
va_end(args);
}
void
screen_write_vnputs(struct screen_write_ctx *ctx, ssize_t maxlen,
struct grid_cell *gc, const char *fmt, va_list ap)
{
char *msg;
struct utf8_data ud;
u_char *ptr;
size_t left, size = 0;
enum utf8_state more;
xvasprintf(&msg, fmt, ap);
ptr = msg;
while (*ptr != '\0') {
if (*ptr > 0x7f && utf8_open(&ud, *ptr) == UTF8_MORE) {
ptr++;
left = strlen(ptr);
if (left < (size_t)ud.size - 1)
break;
while ((more = utf8_append(&ud, *ptr)) == UTF8_MORE)
ptr++;
ptr++;
if (more == UTF8_DONE) {
if (maxlen > 0 &&
size + ud.width > (size_t) maxlen) {
while (size < (size_t) maxlen) {
screen_write_putc(ctx, gc, ' ');
size++;
}
break;
}
size += ud.width;
utf8_copy(&gc->data, &ud);
screen_write_cell(ctx, gc);
}
} else {
if (maxlen > 0 && size + 1 > (size_t) maxlen)
break;
if (*ptr == '\001')
gc->attr ^= GRID_ATTR_CHARSET;
else if (*ptr > 0x1f && *ptr < 0x7f) {
size++;
screen_write_putc(ctx, gc, *ptr);
}
ptr++;
}
}
free(msg);
}
static char *
my_xasprintf (const char *format, ...)
{
va_list args;
char *ret;
va_start (args, format);
ret = xvasprintf (format, args);
va_end (args);
return ret;
}
void
g_warning (const gchar *format, ...)
{
va_list args;
char *msg;
va_start (args, format);
msg = xvasprintf (format, args);
va_end (args);
fprintf (stderr, "warning: %s", msg);
}
char *
xasprintf(const char *format, ...)
{
va_list args;
char *s;
va_start(args, format);
s = xvasprintf(format, args);
va_end(args);
return s;
}
void
cfg_add_cause(const char* fmt, ...)
{
va_list ap;
char* msg;
va_start(ap, fmt);
xvasprintf(&msg, fmt, ap);
va_end (ap);
ARRAY_ADD(&cfg_causes, msg);
}
int printflike2
xasprintf(char **ret, const char *fmt, ...)
{
va_list ap;
int i;
va_start(ap, fmt);
i = xvasprintf(ret, fmt, ap);
va_end(ap);
return (i);
}
/* Append bytes to the byteq, va_list style.
* This function cannot fail!
*/
int
byteq_vappendf(ByteQ *bq, const char *format, va_list ap)
{
char *str;
size_t len;
str = xvasprintf(format, ap);
len = strlen(str);
byteq_append(bq, str, len);
free(str);
return len;
}
void
screen_write_vnputs(struct screen_write_ctx *ctx, ssize_t maxlen,
const struct grid_cell *gcp, const char *fmt, va_list ap)
{
struct grid_cell gc;
struct utf8_data *ud = &gc.data;
char *msg;
u_char *ptr;
size_t left, size = 0;
enum utf8_state more;
memcpy(&gc, gcp, sizeof gc);
xvasprintf(&msg, fmt, ap);
ptr = msg;
while (*ptr != '\0') {
if (*ptr > 0x7f && utf8_open(ud, *ptr) == UTF8_MORE) {
ptr++;
left = strlen(ptr);
if (left < (size_t)ud->size - 1)
break;
while ((more = utf8_append(ud, *ptr)) == UTF8_MORE)
ptr++;
ptr++;
if (more != UTF8_DONE)
continue;
if (maxlen > 0 && size + ud->width > (size_t)maxlen) {
while (size < (size_t)maxlen) {
screen_write_putc(ctx, &gc, ' ');
size++;
}
break;
}
size += ud->width;
screen_write_cell(ctx, &gc);
} else {
if (maxlen > 0 && size + 1 > (size_t)maxlen)
break;
if (*ptr == '\001')
gc.attr ^= GRID_ATTR_CHARSET;
else if (*ptr > 0x1f && *ptr < 0x7f) {
size++;
screen_write_putc(ctx, &gc, *ptr);
}
ptr++;
}
}
free(msg);
}
/* Return a malloc'd string containing MSG formatted a la printf. The
caller is responsible for freeing the memory. */
char *
build_message_string (const char *msg, ...)
{
char *str;
va_list ap;
va_start (ap, msg);
str = xvasprintf (msg, ap);
va_end (ap);
return str;
}
void printflike2
cfg_add_cause(struct causelist *causes, const char *fmt, ...)
{
char *cause;
va_list ap;
va_start(ap, fmt);
xvasprintf(&cause, fmt, ap);
va_end(ap);
ARRAY_ADD(causes, cause);
}
void
screen_write_vnputs(struct screen_write_ctx *ctx, ssize_t maxlen,
struct grid_cell *gc, int utf8flag, const char *fmt, va_list ap)
{
char *msg;
struct utf8_data utf8data;
u_char *ptr;
size_t left, size = 0;
xvasprintf(&msg, fmt, ap);
ptr = msg;
while (*ptr != '\0') {
if (utf8flag && *ptr > 0x7f && utf8_open(&utf8data, *ptr)) {
ptr++;
left = strlen(ptr);
if (left < utf8data.size - 1)
break;
while (utf8_append(&utf8data, *ptr))
ptr++;
ptr++;
if (maxlen > 0 &&
size + utf8data.width > (size_t) maxlen) {
while (size < (size_t) maxlen) {
screen_write_putc(ctx, gc, ' ');
size++;
}
break;
}
size += utf8data.width;
gc->flags |= GRID_FLAG_UTF8;
screen_write_cell(ctx, gc, &utf8data);
gc->flags &= ~GRID_FLAG_UTF8;
} else {
if (maxlen > 0 && size + 1 > (size_t) maxlen)
break;
if (*ptr == '\001')
gc->attr ^= GRID_ATTR_CHARSET;
else {
size++;
screen_write_putc(ctx, gc, *ptr);
}
ptr++;
}
}
free(msg);
}
void
lex_token_vsprintf(struct lex_token *token, const char *format, va_list args)
{
lex_token_destroy(token);
va_list args2;
va_copy(args2, args);
token->s = (vsnprintf(token->buffer, sizeof token->buffer, format, args)
< sizeof token->buffer
? token->buffer
: xvasprintf(format, args2));
va_end(args2);
}
char *StringVFormat(const char *fmt, va_list ap)
{
char *value;
int ret = xvasprintf(&value, fmt, ap);
if (ret < 0)
{
return NULL;
}
else
{
return value;
}
}
