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

static void show(struct string_list *expect, int *status, const char *fmt, ...){    struct string_list_item *item;    struct strbuf buf = STRBUF_INIT;    va_list args;    va_start(args, fmt);    strbuf_vaddf(&buf, fmt, args);    va_end(args);    if (!expect->nr)        printf("%s/n", buf.buf);    else {        char *colon = strchr(buf.buf, ':');        if (!colon)            die("malformed output format, output lacking colon: %s", fmt);        *colon = '/0';        item = string_list_lookup(expect, buf.buf);        *colon = ':';        if (!item)            ; /* not among entries being checked */        else {            if (strcmp((const char *)item->util, buf.buf)) {                printf("-%s/n", (char *)item->util);                printf("+%s/n", buf.buf);                *status = 1;            }        }    }    strbuf_release(&buf);}

void strbuf_addf (strbuf *sb, const char *fmt, ...){	va_list va;	va_start(va, fmt);	strbuf_vaddf(sb, fmt, va);	va_end(va);};

/* Returns 0 on success, negative on failure. */static int do_submodule_path(struct strbuf *buf, const char *path,			     const char *fmt, va_list args){	struct strbuf git_submodule_common_dir = STRBUF_INIT;	struct strbuf git_submodule_dir = STRBUF_INIT;	int ret;	ret = submodule_to_gitdir(&git_submodule_dir, path);	if (ret)		goto cleanup;	strbuf_complete(&git_submodule_dir, '/');	strbuf_addbuf(buf, &git_submodule_dir);	strbuf_vaddf(buf, fmt, args);	if (get_common_dir_noenv(&git_submodule_common_dir, git_submodule_dir.buf))		update_common_dir(buf, git_submodule_dir.len, git_submodule_common_dir.buf);	strbuf_cleanup_path(buf);cleanup:	strbuf_release(&git_submodule_dir);	strbuf_release(&git_submodule_common_dir);	return ret;}

void strbuf_addf(struct strbuf *sb, const char *fmt, ...){	va_list ap;	va_start(ap, fmt);	strbuf_vaddf(sb, fmt, ap);	va_end(ap);}

static int report(struct fsck_options *options, struct object *object,	enum fsck_msg_id id, const char *fmt, ...){	va_list ap;	struct strbuf sb = STRBUF_INIT;	int msg_type = fsck_msg_type(id, options), result;	if (msg_type == FSCK_IGNORE)		return 0;	if (options->skiplist && object &&			sha1_array_lookup(options->skiplist, object->oid.hash) >= 0)		return 0;	if (msg_type == FSCK_FATAL)		msg_type = FSCK_ERROR;	else if (msg_type == FSCK_INFO)		msg_type = FSCK_WARN;	append_msg_id(&sb, msg_id_info[id].id_string);	va_start(ap, fmt);	strbuf_vaddf(&sb, fmt, ap);	result = options->error_func(object, msg_type, sb.buf);	strbuf_release(&sb);	va_end(ap);	return result;}

static void do_submodule_path(struct strbuf *buf, const char *path,			      const char *fmt, va_list args){	const char *git_dir;	struct strbuf git_submodule_common_dir = STRBUF_INIT;	struct strbuf git_submodule_dir = STRBUF_INIT;	strbuf_addstr(buf, path);	strbuf_complete(buf, '/');	strbuf_addstr(buf, ".git");	git_dir = read_gitfile(buf->buf);	if (git_dir) {		strbuf_reset(buf);		strbuf_addstr(buf, git_dir);	}	strbuf_addch(buf, '/');	strbuf_addstr(&git_submodule_dir, buf->buf);	strbuf_vaddf(buf, fmt, args);	if (get_common_dir_noenv(&git_submodule_common_dir, git_submodule_dir.buf))		update_common_dir(buf, git_submodule_dir.len, git_submodule_common_dir.buf);	strbuf_cleanup_path(buf);	strbuf_release(&git_submodule_dir);	strbuf_release(&git_submodule_common_dir);}

void html_vtxtf(const char *format, va_list ap){	va_list cp;	struct strbuf buf = STRBUF_INIT;	va_copy(cp, ap);	strbuf_vaddf(&buf, format, cp);	va_end(cp);	html_txt(buf.buf);	strbuf_release(&buf);}

char *fmtalloc(const char *format, ...){	struct strbuf sb = STRBUF_INIT;	va_list args;	va_start(args, format);	strbuf_vaddf(&sb, format, args);	va_end(args);	return strbuf_detach(&sb, NULL);}

static void error_clnt(const char *fmt, ...){	struct strbuf buf = STRBUF_INIT;	va_list params;	va_start(params, fmt);	strbuf_vaddf(&buf, fmt, params);	va_end(params);	send_sideband(1, 3, buf.buf, buf.len, LARGE_PACKET_MAX);	die("sent error to the client: %s", buf.buf);}

static void do_git_common_path(const struct repository *repo,			       struct strbuf *buf,			       const char *fmt,			       va_list args){	strbuf_addstr(buf, repo->commondir);	if (buf->len && !is_dir_sep(buf->buf[buf->len - 1]))		strbuf_addch(buf, '/');	strbuf_vaddf(buf, fmt, args);	strbuf_cleanup_path(buf);}

void htmlf(const char *format, ...){	va_list args;	struct strbuf buf = STRBUF_INIT;	va_start(args, format);	strbuf_vaddf(&buf, format, args);	va_end(args);	html(buf.buf);	strbuf_release(&buf);}

/* convenient wrapper to deal with NULL strbuf */static void strbuf_addf_gently(struct strbuf *buf, const char *fmt, ...){	va_list params;	if (!buf)		return;	va_start(params, fmt);	strbuf_vaddf(buf, fmt, params);	va_end(params);}

static void do_git_path(struct strbuf *buf, const char *fmt, va_list args){	int gitdir_len;	strbuf_addstr(buf, get_git_dir());	if (buf->len && !is_dir_sep(buf->buf[buf->len - 1]))		strbuf_addch(buf, '/');	gitdir_len = buf->len;	strbuf_vaddf(buf, fmt, args);	adjust_git_path(buf, gitdir_len);	strbuf_cleanup_path(buf);}

void sq_quotef(struct strbuf *dst, const char *fmt, ...){	struct strbuf src = STRBUF_INIT;	va_list ap;	va_start(ap, fmt);	strbuf_vaddf(&src, fmt, ap);	va_end(ap);	sq_quote_buf(dst, src.buf);	strbuf_release(&src);}

void html_attrf(const char *fmt, ...){	va_list ap;	struct strbuf sb = STRBUF_INIT;	va_start(ap, fmt);	strbuf_vaddf(&sb, fmt, ap);	va_end(ap);	html_attr(sb.buf);	strbuf_release(&sb);}

static void trace_vprintf(const char *key, const char *fmt, va_list ap){	struct strbuf buf = STRBUF_INIT;	if (!trace_want(key))		return;	set_try_to_free_routine(NULL);	/* is never reset */	strbuf_vaddf(&buf, fmt, ap);	trace_strbuf(key, &buf);	strbuf_release(&buf);}

static void do_git_path(const struct repository *repo,			const struct worktree *wt, struct strbuf *buf,			const char *fmt, va_list args){	int gitdir_len;	strbuf_worktree_gitdir(buf, repo, wt);	if (buf->len && !is_dir_sep(buf->buf[buf->len - 1]))		strbuf_addch(buf, '/');	gitdir_len = buf->len;	strbuf_vaddf(buf, fmt, args);	if (!wt)		adjust_git_path(repo, buf, gitdir_len);	strbuf_cleanup_path(buf);}

char *mkpathdup(const char *fmt, ...){	char *path;	struct strbuf sb = STRBUF_INIT;	va_list args;	va_start(args, fmt);	strbuf_vaddf(&sb, fmt, args);	va_end(args);	path = xstrdup(cleanup_path(sb.buf));	strbuf_release(&sb);	return path;}

int fsck_error_function(struct object *obj, int type, const char *fmt, ...){	va_list ap;	struct strbuf sb = STRBUF_INIT;	strbuf_addf(&sb, "object %s:", sha1_to_hex(obj->sha1));	va_start(ap, fmt);	strbuf_vaddf(&sb, fmt, ap);	va_end(ap);	error("%s", sb.buf);	strbuf_release(&sb);	return 1;}

static void format_packet(struct strbuf *out, const char *fmt, va_list args){	size_t orig_len, n;	orig_len = out->len;	strbuf_addstr(out, "0000");	strbuf_vaddf(out, fmt, args);	n = out->len - orig_len;	if (n > LARGE_PACKET_MAX)		die("protocol error: impossibly long line");	set_packet_header(&out->buf[orig_len], n);	packet_trace(out->buf + orig_len + 4, n - 4, 1);}

/* * Wrapper for fprintf and returns the total number of columns required * for the printed string, assuming that the string is utf8. */int utf8_fprintf(FILE *stream, const char *format, ...){	struct strbuf buf = STRBUF_INIT;	va_list arg;	int columns;	va_start(arg, format);	strbuf_vaddf(&buf, format, arg);	va_end(arg);	columns = fputs(buf.buf, stream);	if (0 <= columns) /* keep the error from the I/O */		columns = utf8_strwidth(buf.buf);	strbuf_release(&buf);	return columns;}

void strbuf_commented_addf(struct strbuf *sb, const char *fmt, ...){	va_list params;	struct strbuf buf = STRBUF_INIT;	int incomplete_line = sb->len && sb->buf[sb->len - 1] != '/n';	va_start(params, fmt);	strbuf_vaddf(&buf, fmt, params);	va_end(params);	strbuf_add_commented_lines(sb, buf.buf, buf.len);	if (incomplete_line)		sb->buf[--sb->len] = '/0';	strbuf_release(&buf);}

static void maybe_append_string_va(struct strbuf *buf, const char *fmt,				   va_list ap){	if (fmt && *fmt) {		va_list copy_ap;		va_copy(copy_ap, ap);		strbuf_vaddf(buf, fmt, copy_ap);		va_end(copy_ap);		return;	}	if (fmt && *fmt) {		strbuf_addstr(buf, fmt);		return;	}}

static void put_object_name(struct fsck_options *options, struct object *obj,	const char *fmt, ...){	va_list ap;	struct strbuf buf = STRBUF_INIT;	char *existing;	if (!options->object_names)		return;	existing = lookup_decoration(options->object_names, obj);	if (existing)		return;	va_start(ap, fmt);	strbuf_vaddf(&buf, fmt, ap);	add_decoration(options->object_names, obj, strbuf_detach(&buf, NULL));	va_end(ap);}

static void status_vprintf(struct wt_status *s, int at_bol, const char *color,		const char *fmt, va_list ap, const char *trail){	struct strbuf sb = STRBUF_INIT;	struct strbuf linebuf = STRBUF_INIT;	const char *line, *eol;	strbuf_vaddf(&sb, fmt, ap);	if (!sb.len) {		if (s->display_comment_prefix) {			strbuf_addch(&sb, comment_line_char);			if (!trail)				strbuf_addch(&sb, ' ');		}		color_print_strbuf(s->fp, color, &sb);		if (trail)			fprintf(s->fp, "%s", trail);		strbuf_release(&sb);		return;	}	for (line = sb.buf; *line; line = eol + 1) {		eol = strchr(line, '/n');		strbuf_reset(&linebuf);		if (at_bol && s->display_comment_prefix) {			strbuf_addch(&linebuf, comment_line_char);			if (*line != '/n' && *line != '/t')				strbuf_addch(&linebuf, ' ');		}		if (eol)			strbuf_add(&linebuf, line, eol - line);		else			strbuf_addstr(&linebuf, line);		color_print_strbuf(s->fp, color, &linebuf);		if (eol)			fprintf(s->fp, "/n");		else			break;		at_bol = 1;	}	if (trail)		fprintf(s->fp, "%s", trail);	strbuf_release(&linebuf);	strbuf_release(&sb);}

void advise(const char *advice, ...){	struct strbuf buf = STRBUF_INIT;	va_list params;	const char *cp, *np;	va_start(params, advice);	strbuf_vaddf(&buf, advice, params);	va_end(params);	for (cp = buf.buf; *cp; cp = np) {		np = strchrnul(cp, '/n');		fprintf(stderr,	_("hint: %.*s/n"), (int)(np - cp), cp);		if (*np)			np++;	}	strbuf_release(&buf);}