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); }
const char *mkpath(const char *fmt, ...) { va_list args; struct strbuf *pathname = get_pathname(); va_start(args, fmt); strbuf_vaddf(pathname, fmt, args); va_end(args); return cleanup_path(pathname->buf); }
char *mkpathdup(const char *fmt, ...) { struct strbuf sb = STRBUF_INIT; va_list args; va_start(args, fmt); strbuf_vaddf(&sb, fmt, args); va_end(args); strbuf_cleanup_path(&sb); return strbuf_detach(&sb, NULL); }
static void do_git_common_path(struct strbuf *buf, const char *fmt, va_list args) { strbuf_addstr(buf, get_git_common_dir()); if (buf->len && !is_dir_sep(buf->buf[buf->len - 1])) strbuf_addch(buf, '/'); strbuf_vaddf(buf, fmt, args); strbuf_cleanup_path(buf); }
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 int 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; const struct submodule *sub; int err = 0; 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); } if (!is_git_directory(buf->buf)) { gitmodules_config(); sub = submodule_from_path(null_sha1, path); if (!sub) { err = SUBMODULE_PATH_ERR_NOT_CONFIGURED; goto cleanup; } strbuf_reset(buf); strbuf_git_path(buf, "%s/%s", "modules", sub->name); } strbuf_addch(buf, '/'); strbuf_addbuf(&git_submodule_dir, 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); cleanup: strbuf_release(&git_submodule_dir); strbuf_release(&git_submodule_common_dir); return err; }
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); }