自学教程：C++ xvasprintf函数代码示例

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;		}	}}

/* Calculate string length, with embedded formatting. */size_tscreen_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 printflike2screen_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;}

/* Insert header, before specified header if not NULL, otherwise at end. */int printflike3insert_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 printflike2cfg_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;}

intxasprintf (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);}

voidscreen_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;}

voidg_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;}

voidcfg_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 printflike2xasprintf(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! */intbyteq_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;}

voidscreen_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 printflike2cfg_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);}

voidscreen_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);}

voidlex_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;    }}