undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'nd/i18n'

Browse Source 
More message strings marked for i18n.

By Nguyễn Thái Ngọc Duy (10) and Jonathan Nieder (1)
* nd/i18n:
  help: replace underlining "help -a" headers using hyphens with a blank line
  i18n: bundle: mark strings for translation
  i18n: index-pack: mark strings for translation
  i18n: apply: update say_patch_name to give translators complete sentence
  i18n: apply: mark strings for translation
  i18n: remote: mark strings for translation
  i18n: make warn_dangling_symref() automatically append \n
  i18n: help: mark strings for translation
  i18n: mark relative dates for translation
  strbuf: convenience format functions with \n automatically appended
  Makefile: feed all header files to xgettext
This commit is contained in:
Junio C Hamano 2012-05-02 13:51:35 -07:00
commit 1be65eda6a
17 changed files with 499 additions and 384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
Makefile
View File

@ -386,6 +386,7 @@ XDIFF_OBJS =
VCSSVN_H = VCSSVN_H =
VCSSVN_OBJS = VCSSVN_OBJS =
VCSSVN_TEST_OBJS = VCSSVN_TEST_OBJS =
MISC_H =
EXTRA_CPPFLAGS = EXTRA_CPPFLAGS =
LIB_H = LIB_H =
LIB_OBJS = LIB_OBJS =
@ -546,6 +547,36 @@ LIB_FILE=libgit.a
XDIFF_LIB=xdiff/lib.a XDIFF_LIB=xdiff/lib.a
VCSSVN_LIB=vcs-svn/lib.a VCSSVN_LIB=vcs-svn/lib.a
XDIFF_H += xdiff/xinclude.h
XDIFF_H += xdiff/xmacros.h
XDIFF_H += xdiff/xdiff.h
XDIFF_H += xdiff/xtypes.h
XDIFF_H += xdiff/xutils.h
XDIFF_H += xdiff/xprepare.h
XDIFF_H += xdiff/xdiffi.h
XDIFF_H += xdiff/xemit.h
VCSSVN_H += vcs-svn/line_buffer.h
VCSSVN_H += vcs-svn/sliding_window.h
VCSSVN_H += vcs-svn/repo_tree.h
VCSSVN_H += vcs-svn/fast_export.h
VCSSVN_H += vcs-svn/svndiff.h
VCSSVN_H += vcs-svn/svndump.h
MISC_H += branch.h
MISC_H += bundle.h
MISC_H += bisect.h
MISC_H += common-cmds.h
MISC_H += fetch-pack.h
MISC_H += thread-utils.h
MISC_H += send-pack.h
MISC_H += shortlog.h
MISC_H += reachable.h
MISC_H += wt-status.h
MISC_H += tar.h
MISC_H += url.h
MISC_H += walker.h
LIB_H += advice.h LIB_H += advice.h
LIB_H += archive.h LIB_H += archive.h
LIB_H += argv-array.h LIB_H += argv-array.h
@ -2184,24 +2215,8 @@ connect.o transport.o url.o http-backend.o: url.h
http-fetch.o http-walker.o remote-curl.o transport.o walker.o: walker.h http-fetch.o http-walker.o remote-curl.o transport.o walker.o: walker.h
http.o http-walker.o http-push.o http-fetch.o remote-curl.o: http.h url.h http.o http-walker.o http-push.o http-fetch.o remote-curl.o: http.h url.h
XDIFF_H += xdiff/xinclude.h
XDIFF_H += xdiff/xmacros.h
XDIFF_H += xdiff/xdiff.h
XDIFF_H += xdiff/xtypes.h
XDIFF_H += xdiff/xutils.h
XDIFF_H += xdiff/xprepare.h
XDIFF_H += xdiff/xdiffi.h
XDIFF_H += xdiff/xemit.h
xdiff-interface.o $(XDIFF_OBJS): $(XDIFF_H) xdiff-interface.o $(XDIFF_OBJS): $(XDIFF_H)
VCSSVN_H += vcs-svn/line_buffer.h
VCSSVN_H += vcs-svn/sliding_window.h
VCSSVN_H += vcs-svn/repo_tree.h
VCSSVN_H += vcs-svn/fast_export.h
VCSSVN_H += vcs-svn/svndiff.h
VCSSVN_H += vcs-svn/svndump.h
$(VCSSVN_OBJS) $(VCSSVN_TEST_OBJS): $(LIB_H) $(VCSSVN_H) $(VCSSVN_OBJS) $(VCSSVN_TEST_OBJS): $(LIB_H) $(VCSSVN_H)
endif endif
@ -2298,7 +2313,7 @@ XGETTEXT_FLAGS_C = $(XGETTEXT_FLAGS) --language=C \
--keyword=_ --keyword=N_ --keyword="Q_:1,2" --keyword=_ --keyword=N_ --keyword="Q_:1,2"
XGETTEXT_FLAGS_SH = $(XGETTEXT_FLAGS) --language=Shell XGETTEXT_FLAGS_SH = $(XGETTEXT_FLAGS) --language=Shell
XGETTEXT_FLAGS_PERL = $(XGETTEXT_FLAGS) --keyword=__ --language=Perl XGETTEXT_FLAGS_PERL = $(XGETTEXT_FLAGS) --keyword=__ --language=Perl
LOCALIZED_C := $(C_OBJ:o=c) LOCALIZED_C := $(C_OBJ:o=c) $(LIB_H) $(XDIFF_H) $(VCSSVN_H) $(MISC_H)
LOCALIZED_SH := $(SCRIPT_SH) LOCALIZED_SH := $(SCRIPT_SH)
LOCALIZED_PERL := $(SCRIPT_PERL) LOCALIZED_PERL := $(SCRIPT_PERL)

206
builtin/apply.c
View File

@ -103,7 +103,7 @@ static void parse_whitespace_option(const char *option)
ws_error_action = correct_ws_error; ws_error_action = correct_ws_error;
return; return;
} }
die("unrecognized whitespace option '%s'", option); die(_("unrecognized whitespace option '%s'"), option);
} }
static void parse_ignorewhitespace_option(const char *option) static void parse_ignorewhitespace_option(const char *option)
@ -118,7 +118,7 @@ static void parse_ignorewhitespace_option(const char *option)
ws_ignore_action = ignore_ws_change; ws_ignore_action = ignore_ws_change;
return; return;
} }
die("unrecognized whitespace ignore option '%s'", option); die(_("unrecognized whitespace ignore option '%s'"), option);
} }
static void set_default_whitespace_mode(const char *whitespace_option) static void set_default_whitespace_mode(const char *whitespace_option)
@ -375,22 +375,25 @@ static void clear_image(struct image *image)
image->len = 0; image->len = 0;
} }
static void say_patch_name(FILE *output, const char *pre, /* fmt must contain _one_ %s and no other substitution */
struct patch *patch, const char *post) static void say_patch_name(FILE *output, const char *fmt, struct patch *patch)
{ {
fputs(pre, output); struct strbuf sb = STRBUF_INIT;
if (patch->old_name && patch->new_name && if (patch->old_name && patch->new_name &&
strcmp(patch->old_name, patch->new_name)) { strcmp(patch->old_name, patch->new_name)) {
quote_c_style(patch->old_name, NULL, output, 0); quote_c_style(patch->old_name, &sb, NULL, 0);
fputs(" => ", output); strbuf_addstr(&sb, " => ");
quote_c_style(patch->new_name, NULL, output, 0); quote_c_style(patch->new_name, &sb, NULL, 0);
} else { } else {
const char *n = patch->new_name; const char *n = patch->new_name;
if (!n) if (!n)
n = patch->old_name; n = patch->old_name;
quote_c_style(n, NULL, output, 0); quote_c_style(n, &sb, NULL, 0);
} }
fputs(post, output); fprintf(output, fmt, sb.buf);
fputc('\n', output);
strbuf_release(&sb);
} }
#define SLOP (16) #define SLOP (16)
@ -809,7 +812,7 @@ static int has_epoch_timestamp(const char *nameline)
if (!stamp) { if (!stamp) {
stamp = xmalloc(sizeof(*stamp)); stamp = xmalloc(sizeof(*stamp));
if (regcomp(stamp, stamp_regexp, REG_EXTENDED)) { if (regcomp(stamp, stamp_regexp, REG_EXTENDED)) {
warning("Cannot prepare timestamp regexp %s", warning(_("Cannot prepare timestamp regexp %s"),
stamp_regexp); stamp_regexp);
return 0; return 0;
} }
@ -818,7 +821,7 @@ static int has_epoch_timestamp(const char *nameline)
status = regexec(stamp, timestamp, ARRAY_SIZE(m), m, 0); status = regexec(stamp, timestamp, ARRAY_SIZE(m), m, 0);
if (status) { if (status) {
if (status != REG_NOMATCH) if (status != REG_NOMATCH)
warning("regexec returned %d for input: %s", warning(_("regexec returned %d for input: %s"),
status, timestamp); status, timestamp);
return 0; return 0;
} }
@ -899,7 +902,7 @@ static void parse_traditional_patch(const char *first, const char *second, struc
} }
} }
if (!name) if (!name)
die("unable to find filename in patch at line %d", linenr); die(_("unable to find filename in patch at line %d"), linenr);
} }
static int gitdiff_hdrend(const char *line, struct patch *patch) static int gitdiff_hdrend(const char *line, struct patch *patch)
@ -928,17 +931,17 @@ static char *gitdiff_verify_name(const char *line, int isnull, char *orig_name,
name = orig_name; name = orig_name;
len = strlen(name); len = strlen(name);
if (isnull) if (isnull)
die("git apply: bad git-diff - expected /dev/null, got %s on line %d", name, linenr); die(_("git apply: bad git-diff - expected /dev/null, got %s on line %d"), name, linenr);
another = find_name(line, NULL, p_value, TERM_TAB); another = find_name(line, NULL, p_value, TERM_TAB);
if (!another || memcmp(another, name, len + 1)) if (!another || memcmp(another, name, len + 1))
die("git apply: bad git-diff - inconsistent %s filename on line %d", oldnew, linenr); die(_("git apply: bad git-diff - inconsistent %s filename on line %d"), oldnew, linenr);
free(another); free(another);
return orig_name; return orig_name;
} }
else { else {
/* expect "/dev/null" */ /* expect "/dev/null" */
if (memcmp("/dev/null", line, 9) || line[9] != '\n') if (memcmp("/dev/null", line, 9) || line[9] != '\n')
die("git apply: bad git-diff - expected /dev/null on line %d", linenr); die(_("git apply: bad git-diff - expected /dev/null on line %d"), linenr);
return NULL; return NULL;
} }
} }
@ -1381,7 +1384,7 @@ static void recount_diff(const char *line, int size, struct fragment *fragment)
break; break;
} }
if (ret) { if (ret) {
warning("recount: unexpected line: %.*s", warning(_("recount: unexpected line: %.*s"),
(int)linelen(line, size), line); (int)linelen(line, size), line);
return; return;
} }
@ -1438,7 +1441,7 @@ static int find_header(const char *line, unsigned long size, int *hdrsize, struc
struct fragment dummy; struct fragment dummy;
if (parse_fragment_header(line, len, &dummy) < 0) if (parse_fragment_header(line, len, &dummy) < 0)
continue; continue;
die("patch fragment without header at line %d: %.*s", die(_("patch fragment without header at line %d: %.*s"),
linenr, (int)len-1, line); linenr, (int)len-1, line);
} }
@ -1455,8 +1458,12 @@ static int find_header(const char *line, unsigned long size, int *hdrsize, struc
continue; continue;
if (!patch->old_name && !patch->new_name) { if (!patch->old_name && !patch->new_name) {
if (!patch->def_name) if (!patch->def_name)
die("git diff header lacks filename information when removing " die(Q_("git diff header lacks filename information when removing "
"%d leading pathname components (line %d)" , p_value, linenr); "%d leading pathname component (line %d)",
"git diff header lacks filename information when removing "
"%d leading pathname components (line %d)",
p_value),
p_value, linenr);
patch->old_name = xstrdup(patch->def_name); patch->old_name = xstrdup(patch->def_name);
patch->new_name = xstrdup(patch->def_name); patch->new_name = xstrdup(patch->def_name);
} }
@ -1611,9 +1618,9 @@ static int parse_fragment(const char *line, unsigned long size,
patch->lines_deleted += deleted; patch->lines_deleted += deleted;
if (0 < patch->is_new && oldlines) if (0 < patch->is_new && oldlines)
return error("new file depends on old contents"); return error(_("new file depends on old contents"));
if (0 < patch->is_delete && newlines) if (0 < patch->is_delete && newlines)
return error("deleted file still has contents"); return error(_("deleted file still has contents"));
return offset; return offset;
} }
@ -1639,7 +1646,7 @@ static int parse_single_patch(const char *line, unsigned long size, struct patch
fragment->linenr = linenr; fragment->linenr = linenr;
len = parse_fragment(line, size, patch, fragment); len = parse_fragment(line, size, patch, fragment);
if (len <= 0) if (len <= 0)
die("corrupt patch at line %d", linenr); die(_("corrupt patch at line %d"), linenr);
fragment->patch = line; fragment->patch = line;
fragment->size = len; fragment->size = len;
oldlines += fragment->oldlines; oldlines += fragment->oldlines;
@ -1675,12 +1682,14 @@ static int parse_single_patch(const char *line, unsigned long size, struct patch
patch->is_delete = 0; patch->is_delete = 0;
if (0 < patch->is_new && oldlines) if (0 < patch->is_new && oldlines)
die("new file %s depends on old contents", patch->new_name); die(_("new file %s depends on old contents"), patch->new_name);
if (0 < patch->is_delete && newlines) if (0 < patch->is_delete && newlines)
die("deleted file %s still has contents", patch->old_name); die(_("deleted file %s still has contents"), patch->old_name);
if (!patch->is_delete && !newlines && context) if (!patch->is_delete && !newlines && context)
fprintf(stderr, "** warning: file %s becomes empty but " fprintf_ln(stderr,
"is not deleted\n", patch->new_name); _("** warning: "
"file %s becomes empty but is not deleted"),
patch->new_name);
return offset; return offset;
} }
@ -1824,7 +1833,7 @@ static struct fragment *parse_binary_hunk(char **buf_p,
corrupt: corrupt:
free(data); free(data);
*status_p = -1; *status_p = -1;
error("corrupt binary patch at line %d: %.*s", error(_("corrupt binary patch at line %d: %.*s"),
linenr-1, llen-1, buffer); linenr-1, llen-1, buffer);
return NULL; return NULL;
} }
@ -1853,7 +1862,7 @@ static int parse_binary(char *buffer, unsigned long size, struct patch *patch)
forward = parse_binary_hunk(&buffer, &size, &status, &used); forward = parse_binary_hunk(&buffer, &size, &status, &used);
if (!forward && !status) if (!forward && !status)
/* there has to be one hunk (forward hunk) */ /* there has to be one hunk (forward hunk) */
return error("unrecognized binary patch at line %d", linenr-1); return error(_("unrecognized binary patch at line %d"), linenr-1);
if (status) if (status)
/* otherwise we already gave an error message */ /* otherwise we already gave an error message */
return status; return status;
@ -1939,7 +1948,7 @@ static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
*/ */
if ((apply || check) && if ((apply || check) &&
(!patch->is_binary && !metadata_changes(patch))) (!patch->is_binary && !metadata_changes(patch)))
die("patch with only garbage at line %d", linenr); die(_("patch with only garbage at line %d"), linenr);
} }
return offset + hdrsize + patchsize; return offset + hdrsize + patchsize;
@ -2029,11 +2038,11 @@ static int read_old_data(struct stat *st, const char *path, struct strbuf *buf)
switch (st->st_mode & S_IFMT) { switch (st->st_mode & S_IFMT) {
case S_IFLNK: case S_IFLNK:
if (strbuf_readlink(buf, path, st->st_size) < 0) if (strbuf_readlink(buf, path, st->st_size) < 0)
return error("unable to read symlink %s", path); return error(_("unable to read symlink %s"), path);
return 0; return 0;
case S_IFREG: case S_IFREG:
if (strbuf_read_file(buf, path, st->st_size) != st->st_size) if (strbuf_read_file(buf, path, st->st_size) != st->st_size)
return error("unable to open or read %s", path); return error(_("unable to open or read %s"), path);
convert_to_git(path, buf->buf, buf->len, buf, 0); convert_to_git(path, buf->buf, buf->len, buf, 0);
return 0; return 0;
default: default:
@ -2104,7 +2113,7 @@ static void update_pre_post_images(struct image *preimage,
ctx++; ctx++;
} }
if (preimage->nr <= ctx) if (preimage->nr <= ctx)
die("oops"); die(_("oops"));
/* and copy it in, while fixing the line length */ /* and copy it in, while fixing the line length */
len = preimage->line[ctx].len; len = preimage->line[ctx].len;
@ -2626,7 +2635,7 @@ static int apply_one_fragment(struct image *img, struct fragment *frag,
break; break;
default: default:
if (apply_verbosely) if (apply_verbosely)
error("invalid start of line: '%c'", first); error(_("invalid start of line: '%c'"), first);
return -1; return -1;
} }
if (added_blank_line) { if (added_blank_line) {
@ -2743,9 +2752,11 @@ static int apply_one_fragment(struct image *img, struct fragment *frag,
int offset = applied_pos - pos; int offset = applied_pos - pos;
if (apply_in_reverse) if (apply_in_reverse)
offset = 0 - offset; offset = 0 - offset;
fprintf(stderr, fprintf_ln(stderr,
"Hunk #%d succeeded at %d (offset %d lines).\n", Q_("Hunk #%d succeeded at %d (offset %d line).",
nth_fragment, applied_pos + 1, offset); "Hunk #%d succeeded at %d (offset %d lines).",
offset),
nth_fragment, applied_pos + 1, offset);
} }
/* /*
@ -2754,13 +2765,13 @@ static int apply_one_fragment(struct image *img, struct fragment *frag,
*/ */
if ((leading != frag->leading) || if ((leading != frag->leading) ||
(trailing != frag->trailing)) (trailing != frag->trailing))
fprintf(stderr, "Context reduced to (%ld/%ld)" fprintf_ln(stderr, _("Context reduced to (%ld/%ld)"
" to apply fragment at %d\n", " to apply fragment at %d"),
leading, trailing, applied_pos+1); leading, trailing, applied_pos+1);
update_image(img, applied_pos, &preimage, &postimage); update_image(img, applied_pos, &preimage, &postimage);
} else { } else {
if (apply_verbosely) if (apply_verbosely)
error("while searching for:\n%.*s", error(_("while searching for:\n%.*s"),
(int)(old - oldlines), oldlines); (int)(old - oldlines), oldlines);
} }
@ -2779,7 +2790,7 @@ static int apply_binary_fragment(struct image *img, struct patch *patch)
void *dst; void *dst;
if (!fragment) if (!fragment)
return error("missing binary patch data for '%s'", return error(_("missing binary patch data for '%s'"),
patch->new_name ? patch->new_name ?
patch->new_name : patch->new_name :
patch->old_name); patch->old_name);
@ -2882,13 +2893,13 @@ static int apply_binary(struct image *img, struct patch *patch)
* in the patch->fragments->{patch,size}. * in the patch->fragments->{patch,size}.
*/ */
if (apply_binary_fragment(img, patch)) if (apply_binary_fragment(img, patch))
return error("binary patch does not apply to '%s'", return error(_("binary patch does not apply to '%s'"),
name); name);
/* verify that the result matches */ /* verify that the result matches */
hash_sha1_file(img->buf, img->len, blob_type, sha1); hash_sha1_file(img->buf, img->len, blob_type, sha1);
if (strcmp(sha1_to_hex(sha1), patch->new_sha1_prefix)) if (strcmp(sha1_to_hex(sha1), patch->new_sha1_prefix))
return error("binary patch to '%s' creates incorrect result (expecting %s, got %s)", return error(_("binary patch to '%s' creates incorrect result (expecting %s, got %s)"),
name, patch->new_sha1_prefix, sha1_to_hex(sha1)); name, patch->new_sha1_prefix, sha1_to_hex(sha1));
} }
@ -2909,7 +2920,7 @@ static int apply_fragments(struct image *img, struct patch *patch)
while (frag) { while (frag) {
nth++; nth++;
if (apply_one_fragment(img, frag, inaccurate_eof, ws_rule, nth)) { if (apply_one_fragment(img, frag, inaccurate_eof, ws_rule, nth)) {
error("patch failed: %s:%ld", name, frag->oldpos); error(_("patch failed: %s:%ld"), name, frag->oldpos);
if (!apply_with_reject) if (!apply_with_reject)
return -1; return -1;
frag->rejected = 1; frag->rejected = 1;
@ -3024,14 +3035,14 @@ static int apply_data(struct patch *patch, struct stat *st, struct cache_entry *
if (!(patch->is_copy || patch->is_rename) && if (!(patch->is_copy || patch->is_rename) &&
(tpatch = in_fn_table(patch->old_name)) != NULL && !to_be_deleted(tpatch)) { (tpatch = in_fn_table(patch->old_name)) != NULL && !to_be_deleted(tpatch)) {
if (was_deleted(tpatch)) { if (was_deleted(tpatch)) {
return error("patch %s has been renamed/deleted", return error(_("patch %s has been renamed/deleted"),
patch->old_name); patch->old_name);
} }
/* We have a patched copy in memory; use that. */ /* We have a patched copy in memory; use that. */
strbuf_add(&buf, tpatch->result, tpatch->resultsize); strbuf_add(&buf, tpatch->result, tpatch->resultsize);
} else if (cached) { } else if (cached) {
if (read_file_or_gitlink(ce, &buf)) if (read_file_or_gitlink(ce, &buf))
return error("read of %s failed", patch->old_name); return error(_("read of %s failed"), patch->old_name);
} else if (patch->old_name) { } else if (patch->old_name) {
if (S_ISGITLINK(patch->old_mode)) { if (S_ISGITLINK(patch->old_mode)) {
if (ce) { if (ce) {
@ -3048,7 +3059,7 @@ static int apply_data(struct patch *patch, struct stat *st, struct cache_entry *
} }
} else { } else {
if (read_old_data(st, patch->old_name, &buf)) if (read_old_data(st, patch->old_name, &buf))
return error("read of %s failed", patch->old_name); return error(_("read of %s failed"), patch->old_name);
} }
} }
@ -3063,7 +3074,7 @@ static int apply_data(struct patch *patch, struct stat *st, struct cache_entry *
free(image.line_allocated); free(image.line_allocated);
if (0 < patch->is_delete && patch->resultsize) if (0 < patch->is_delete && patch->resultsize)
return error("removal patch leaves file contents"); return error(_("removal patch leaves file contents"));
return 0; return 0;
} }
@ -3084,7 +3095,7 @@ static int check_to_create_blob(const char *new_name, int ok_if_exists)
if (has_symlink_leading_path(new_name, strlen(new_name))) if (has_symlink_leading_path(new_name, strlen(new_name)))
return 0; return 0;
return error("%s: already exists in working directory", new_name); return error(_("%s: already exists in working directory"), new_name);
} }
else if ((errno != ENOENT) && (errno != ENOTDIR)) else if ((errno != ENOENT) && (errno != ENOTDIR))
return error("%s: %s", new_name, strerror(errno)); return error("%s: %s", new_name, strerror(errno));
@ -3122,12 +3133,12 @@ static int check_preimage(struct patch *patch, struct cache_entry **ce, struct s
if (!(patch->is_copy || patch->is_rename) && if (!(patch->is_copy || patch->is_rename) &&
(tpatch = in_fn_table(old_name)) != NULL && !to_be_deleted(tpatch)) { (tpatch = in_fn_table(old_name)) != NULL && !to_be_deleted(tpatch)) {
if (was_deleted(tpatch)) if (was_deleted(tpatch))
return error("%s: has been deleted/renamed", old_name); return error(_("%s: has been deleted/renamed"), old_name);
st_mode = tpatch->new_mode; st_mode = tpatch->new_mode;
} else if (!cached) { } else if (!cached) {
stat_ret = lstat(old_name, st); stat_ret = lstat(old_name, st);
if (stat_ret && errno != ENOENT) if (stat_ret && errno != ENOENT)
return error("%s: %s", old_name, strerror(errno)); return error(_("%s: %s"), old_name, strerror(errno));
} }
if (to_be_deleted(tpatch)) if (to_be_deleted(tpatch))
@ -3138,7 +3149,7 @@ static int check_preimage(struct patch *patch, struct cache_entry **ce, struct s
if (pos < 0) { if (pos < 0) {
if (patch->is_new < 0) if (patch->is_new < 0)
goto is_new; goto is_new;
return error("%s: does not exist in index", old_name); return error(_("%s: does not exist in index"), old_name);
} }
*ce = active_cache[pos]; *ce = active_cache[pos];
if (stat_ret < 0) { if (stat_ret < 0) {
@ -3152,13 +3163,13 @@ static int check_preimage(struct patch *patch, struct cache_entry **ce, struct s
return -1; return -1;
} }
if (!cached && verify_index_match(*ce, st)) if (!cached && verify_index_match(*ce, st))
return error("%s: does not match index", old_name); return error(_("%s: does not match index"), old_name);
if (cached) if (cached)
st_mode = (*ce)->ce_mode; st_mode = (*ce)->ce_mode;
} else if (stat_ret < 0) { } else if (stat_ret < 0) {
if (patch->is_new < 0) if (patch->is_new < 0)
goto is_new; goto is_new;
return error("%s: %s", old_name, strerror(errno)); return error(_("%s: %s"), old_name, strerror(errno));
} }
if (!cached && !tpatch) if (!cached && !tpatch)
@ -3169,9 +3180,9 @@ static int check_preimage(struct patch *patch, struct cache_entry **ce, struct s
if (!patch->old_mode) if (!patch->old_mode)
patch->old_mode = st_mode; patch->old_mode = st_mode;
if ((st_mode ^ patch->old_mode) & S_IFMT) if ((st_mode ^ patch->old_mode) & S_IFMT)
return error("%s: wrong type", old_name); return error(_("%s: wrong type"), old_name);
if (st_mode != patch->old_mode) if (st_mode != patch->old_mode)
warning("%s has type %o, expected %o", warning(_("%s has type %o, expected %o"),
old_name, st_mode, patch->old_mode); old_name, st_mode, patch->old_mode);
if (!patch->new_mode && !patch->is_delete) if (!patch->new_mode && !patch->is_delete)
patch->new_mode = st_mode; patch->new_mode = st_mode;
@ -3226,7 +3237,7 @@ static int check_patch(struct patch *patch)
if (check_index && if (check_index &&
cache_name_pos(new_name, strlen(new_name)) >= 0 && cache_name_pos(new_name, strlen(new_name)) >= 0 &&
!ok_if_exists) !ok_if_exists)
return error("%s: already exists in index", new_name); return error(_("%s: already exists in index"), new_name);
if (!cached) { if (!cached) {
int err = check_to_create_blob(new_name, ok_if_exists); int err = check_to_create_blob(new_name, ok_if_exists);
if (err) if (err)
@ -3245,13 +3256,13 @@ static int check_patch(struct patch *patch)
if (!patch->new_mode) if (!patch->new_mode)
patch->new_mode = patch->old_mode; patch->new_mode = patch->old_mode;
if ((patch->old_mode ^ patch->new_mode) & S_IFMT) if ((patch->old_mode ^ patch->new_mode) & S_IFMT)
return error("new mode (%o) of %s does not match old mode (%o)%s%s", return error(_("new mode (%o) of %s does not match old mode (%o)%s%s"),
patch->new_mode, new_name, patch->old_mode, patch->new_mode, new_name, patch->old_mode,
same ? "" : " of ", same ? "" : old_name); same ? "" : " of ", same ? "" : old_name);
} }
if (apply_data(patch, &st, ce) < 0) if (apply_data(patch, &st, ce) < 0)
return error("%s: patch does not apply", name); return error(_("%s: patch does not apply"), name);
patch->rejected = 0; patch->rejected = 0;
return 0; return 0;
} }
@ -3264,7 +3275,7 @@ static int check_patch_list(struct patch *patch)
while (patch) { while (patch) {
if (apply_verbosely) if (apply_verbosely)
say_patch_name(stderr, say_patch_name(stderr,
"Checking patch ", patch, "...\n"); _("Checking patch %s..."), patch);
err |= check_patch(patch); err |= check_patch(patch);
patch = patch->next; patch = patch->next;
} }
@ -3319,7 +3330,7 @@ static void build_fake_ancestor(struct patch *list, const char *filename)
ce = make_cache_entry(patch->old_mode, sha1_ptr, name, 0, 0); ce = make_cache_entry(patch->old_mode, sha1_ptr, name, 0, 0);
if (!ce) if (!ce)
die("make_cache_entry failed for path '%s'", name); die(_("make_cache_entry failed for path '%s'"), name);
if (add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD)) if (add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD))
die ("Could not add %s to temporary index", name); die ("Could not add %s to temporary index", name);
} }
@ -3462,7 +3473,7 @@ static void remove_file(struct patch *patch, int rmdir_empty)
{ {
if (update_index) { if (update_index) {
if (remove_file_from_cache(patch->old_name) < 0) if (remove_file_from_cache(patch->old_name) < 0)
die("unable to remove %s from index", patch->old_name); die(_("unable to remove %s from index"), patch->old_name);
} }
if (!cached) { if (!cached) {
if (!remove_or_warn(patch->old_mode, patch->old_name) && rmdir_empty) { if (!remove_or_warn(patch->old_mode, patch->old_name) && rmdir_empty) {
@ -3489,19 +3500,19 @@ static void add_index_file(const char *path, unsigned mode, void *buf, unsigned
const char *s = buf; const char *s = buf;
if (get_sha1_hex(s + strlen("Subproject commit "), ce->sha1)) if (get_sha1_hex(s + strlen("Subproject commit "), ce->sha1))
die("corrupt patch for subproject %s", path); die(_("corrupt patch for subproject %s"), path);
} else { } else {
if (!cached) { if (!cached) {
if (lstat(path, &st) < 0) if (lstat(path, &st) < 0)
die_errno("unable to stat newly created file '%s'", die_errno(_("unable to stat newly created file '%s'"),
path); path);
fill_stat_cache_info(ce, &st); fill_stat_cache_info(ce, &st);
} }
if (write_sha1_file(buf, size, blob_type, ce->sha1) < 0) if (write_sha1_file(buf, size, blob_type, ce->sha1) < 0)
die("unable to create backing store for newly created file %s", path); die(_("unable to create backing store for newly created file %s"), path);
} }
if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0) if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)
die("unable to add cache entry for %s", path); die(_("unable to add cache entry for %s"), path);
} }
static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size) static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size)
@ -3534,7 +3545,7 @@ static int try_create_file(const char *path, unsigned int mode, const char *buf,
strbuf_release(&nbuf); strbuf_release(&nbuf);
if (close(fd) < 0) if (close(fd) < 0)
die_errno("closing file '%s'", path); die_errno(_("closing file '%s'"), path);
return 0; return 0;
} }
@ -3583,7 +3594,7 @@ static void create_one_file(char *path, unsigned mode, const char *buf, unsigned
++nr; ++nr;
} }
} }
die_errno("unable to write file '%s' mode %o", path, mode); die_errno(_("unable to write file '%s' mode %o"), path, mode);
} }
static void create_file(struct patch *patch) static void create_file(struct patch *patch)
@ -3628,6 +3639,7 @@ static int write_out_one_reject(struct patch *patch)
char namebuf[PATH_MAX]; char namebuf[PATH_MAX];
struct fragment *frag; struct fragment *frag;
int cnt = 0; int cnt = 0;
struct strbuf sb = STRBUF_INIT;
for (cnt = 0, frag = patch->fragments; frag; frag = frag->next) { for (cnt = 0, frag = patch->fragments; frag; frag = frag->next) {
if (!frag->rejected) if (!frag->rejected)
@ -3638,7 +3650,7 @@ static int write_out_one_reject(struct patch *patch)
if (!cnt) { if (!cnt) {
if (apply_verbosely) if (apply_verbosely)
say_patch_name(stderr, say_patch_name(stderr,
"Applied patch ", patch, " cleanly.\n"); _("Applied patch %s cleanly."), patch);
return 0; return 0;
} }
@ -3646,16 +3658,20 @@ static int write_out_one_reject(struct patch *patch)
* contents are marked "rejected" at the patch level. * contents are marked "rejected" at the patch level.
*/ */
if (!patch->new_name) if (!patch->new_name)
die("internal error"); die(_("internal error"));
/* Say this even without --verbose */ /* Say this even without --verbose */
say_patch_name(stderr, "Applying patch ", patch, " with"); strbuf_addf(&sb, Q_("Applying patch %%s with %d reject...",
fprintf(stderr, " %d rejects...\n", cnt); "Applying patch %%s with %d rejects...",
cnt),
cnt);
say_patch_name(stderr, sb.buf, patch);
strbuf_release(&sb);
cnt = strlen(patch->new_name); cnt = strlen(patch->new_name);
if (ARRAY_SIZE(namebuf) <= cnt + 5) { if (ARRAY_SIZE(namebuf) <= cnt + 5) {
cnt = ARRAY_SIZE(namebuf) - 5; cnt = ARRAY_SIZE(namebuf) - 5;
warning("truncating .rej filename to %.*s.rej", warning(_("truncating .rej filename to %.*s.rej"),
cnt - 1, patch->new_name); cnt - 1, patch->new_name);
} }
memcpy(namebuf, patch->new_name, cnt); memcpy(namebuf, patch->new_name, cnt);
@ -3663,7 +3679,7 @@ static int write_out_one_reject(struct patch *patch)
rej = fopen(namebuf, "w"); rej = fopen(namebuf, "w");
if (!rej) if (!rej)
return error("cannot open %s: %s", namebuf, strerror(errno)); return error(_("cannot open %s: %s"), namebuf, strerror(errno));
/* Normal git tools never deal with .rej, so do not pretend /* Normal git tools never deal with .rej, so do not pretend
* this is a git patch by saying --git nor give extended * this is a git patch by saying --git nor give extended
@ -3676,10 +3692,10 @@ static int write_out_one_reject(struct patch *patch)
frag; frag;
cnt++, frag = frag->next) { cnt++, frag = frag->next) {
if (!frag->rejected) { if (!frag->rejected) {
fprintf(stderr, "Hunk #%d applied cleanly.\n", cnt); fprintf_ln(stderr, _("Hunk #%d applied cleanly."), cnt);
continue; continue;
} }
fprintf(stderr, "Rejected hunk #%d.\n", cnt); fprintf_ln(stderr, _("Rejected hunk #%d."), cnt);
fprintf(rej, "%.*s", frag->size, frag->patch); fprintf(rej, "%.*s", frag->size, frag->patch);
if (frag->patch[frag->size-1] != '\n') if (frag->patch[frag->size-1] != '\n')
fputc('\n', rej); fputc('\n', rej);
@ -3810,7 +3826,7 @@ static int apply_patch(int fd, const char *filename, int options)
} }
if (!list && !skipped_patch) if (!list && !skipped_patch)
die("unrecognized input"); die(_("unrecognized input"));
if (whitespace_error && (ws_error_action == die_on_ws_error)) if (whitespace_error && (ws_error_action == die_on_ws_error))
apply = 0; apply = 0;
@ -3821,7 +3837,7 @@ static int apply_patch(int fd, const char *filename, int options)
if (check_index) { if (check_index) {
if (read_cache() < 0) if (read_cache() < 0)
die("unable to read index file"); die(_("unable to read index file"));
} }
if ((check || apply) && if ((check || apply) &&
@ -4016,10 +4032,10 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
if (!force_apply && (diffstat || numstat || summary || check || fake_ancestor)) if (!force_apply && (diffstat || numstat || summary || check || fake_ancestor))
apply = 0; apply = 0;
if (check_index && is_not_gitdir) if (check_index && is_not_gitdir)
die("--index outside a repository"); die(_("--index outside a repository"));
if (cached) { if (cached) {
if (is_not_gitdir) if (is_not_gitdir)
die("--cached outside a repository"); die(_("--cached outside a repository"));
check_index = 1; check_index = 1;
} }
for (i = 0; i < argc; i++) { for (i = 0; i < argc; i++) {
@ -4035,7 +4051,7 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
fd = open(arg, O_RDONLY); fd = open(arg, O_RDONLY);
if (fd < 0) if (fd < 0)
die_errno("can't open patch '%s'", arg); die_errno(_("can't open patch '%s'"), arg);
read_stdin = 0; read_stdin = 0;
set_default_whitespace_mode(whitespace_option); set_default_whitespace_mode(whitespace_option);
errs |= apply_patch(fd, arg, options); errs |= apply_patch(fd, arg, options);
@ -4049,32 +4065,32 @@ int cmd_apply(int argc, const char **argv, const char *prefix_)
squelch_whitespace_errors < whitespace_error) { squelch_whitespace_errors < whitespace_error) {
int squelched = int squelched =
whitespace_error - squelch_whitespace_errors; whitespace_error - squelch_whitespace_errors;
warning("squelched %d " warning(Q_("squelched %d whitespace error",
"whitespace error%s", "squelched %d whitespace errors",
squelched, squelched),
squelched == 1 ? "" : "s"); squelched);
} }
if (ws_error_action == die_on_ws_error) if (ws_error_action == die_on_ws_error)
die("%d line%s add%s whitespace errors.", die(Q_("%d line adds whitespace errors.",
whitespace_error, "%d lines add whitespace errors.",
whitespace_error == 1 ? "" : "s", whitespace_error),
whitespace_error == 1 ? "s" : ""); whitespace_error);
if (applied_after_fixing_ws && apply) if (applied_after_fixing_ws && apply)
warning("%d line%s applied after" warning("%d line%s applied after"
" fixing whitespace errors.", " fixing whitespace errors.",
applied_after_fixing_ws, applied_after_fixing_ws,
applied_after_fixing_ws == 1 ? "" : "s"); applied_after_fixing_ws == 1 ? "" : "s");
else if (whitespace_error) else if (whitespace_error)
warning("%d line%s add%s whitespace errors.", warning(Q_("%d line adds whitespace errors.",
whitespace_error, "%d lines add whitespace errors.",
whitespace_error == 1 ? "" : "s", whitespace_error),
whitespace_error == 1 ? "s" : ""); whitespace_error);
} }
if (update_index) { if (update_index) {
if (write_cache(newfd, active_cache, active_nr) || if (write_cache(newfd, active_cache, active_nr) ||
commit_locked_index(&lock_file)) commit_locked_index(&lock_file))
die("Unable to write new index file"); die(_("Unable to write new index file"));
} }
return !!errs; return !!errs;

4
builtin/fetch.c
View File

@ -546,8 +546,8 @@ static int prune_refs(struct refspec *refs, int ref_count, struct ref *ref_map)
int result = 0; int result = 0;
struct ref *ref, *stale_refs = get_stale_heads(refs, ref_count, ref_map); struct ref *ref, *stale_refs = get_stale_heads(refs, ref_count, ref_map);
const char *dangling_msg = dry_run const char *dangling_msg = dry_run
? _(" (%s will become dangling)\n") ? _(" (%s will become dangling)")
: _(" (%s has become dangling)\n"); : _(" (%s has become dangling)");
for (ref = stale_refs; ref; ref = ref->next) { for (ref = stale_refs; ref; ref = ref->next) {
if (!dry_run) if (!dry_run)

48
builtin/help.c
View File

@ -54,7 +54,7 @@ static enum help_format parse_help_format(const char *format)
return HELP_FORMAT_INFO; return HELP_FORMAT_INFO;
if (!strcmp(format, "web") || !strcmp(format, "html")) if (!strcmp(format, "web") || !strcmp(format, "html"))
return HELP_FORMAT_WEB; return HELP_FORMAT_WEB;
die("unrecognized help format '%s'", format); die(_("unrecognized help format '%s'"), format);
} }
static const char *get_man_viewer_info(const char *name) static const char *get_man_viewer_info(const char *name)
@ -82,7 +82,7 @@ static int check_emacsclient_version(void)
ec_process.err = -1; ec_process.err = -1;
ec_process.stdout_to_stderr = 1; ec_process.stdout_to_stderr = 1;
if (start_command(&ec_process)) if (start_command(&ec_process))
return error("Failed to start emacsclient."); return error(_("Failed to start emacsclient."));
strbuf_read(&buffer, ec_process.err, 20); strbuf_read(&buffer, ec_process.err, 20);
close(ec_process.err); close(ec_process.err);
@ -95,7 +95,7 @@ static int check_emacsclient_version(void)
if (prefixcmp(buffer.buf, "emacsclient")) { if (prefixcmp(buffer.buf, "emacsclient")) {
strbuf_release(&buffer); strbuf_release(&buffer);
return error("Failed to parse emacsclient version."); return error(_("Failed to parse emacsclient version."));
} }
strbuf_remove(&buffer, 0, strlen("emacsclient")); strbuf_remove(&buffer, 0, strlen("emacsclient"));
@ -103,7 +103,7 @@ static int check_emacsclient_version(void)
if (version < 22) { if (version < 22) {
strbuf_release(&buffer); strbuf_release(&buffer);
return error("emacsclient version '%d' too old (< 22).", return error(_("emacsclient version '%d' too old (< 22)."),
version); version);
} }
@ -121,7 +121,7 @@ static void exec_woman_emacs(const char *path, const char *page)
path = "emacsclient"; path = "emacsclient";
strbuf_addf(&man_page, "(woman \"%s\")", page); strbuf_addf(&man_page, "(woman \"%s\")", page);
execlp(path, "emacsclient", "-e", man_page.buf, (char *)NULL); execlp(path, "emacsclient", "-e", man_page.buf, (char *)NULL);
warning("failed to exec '%s': %s", path, strerror(errno)); warning(_("failed to exec '%s': %s"), path, strerror(errno));
} }
} }
@ -149,7 +149,7 @@ static void exec_man_konqueror(const char *path, const char *page)
path = "kfmclient"; path = "kfmclient";
strbuf_addf(&man_page, "man:%s(1)", page); strbuf_addf(&man_page, "man:%s(1)", page);
execlp(path, filename, "newTab", man_page.buf, (char *)NULL); execlp(path, filename, "newTab", man_page.buf, (char *)NULL);
warning("failed to exec '%s': %s", path, strerror(errno)); warning(_("failed to exec '%s': %s"), path, strerror(errno));
} }
} }
@ -158,7 +158,7 @@ static void exec_man_man(const char *path, const char *page)
if (!path) if (!path)
path = "man"; path = "man";
execlp(path, "man", page, (char *)NULL); execlp(path, "man", page, (char *)NULL);
warning("failed to exec '%s': %s", path, strerror(errno)); warning(_("failed to exec '%s': %s"), path, strerror(errno));
} }
static void exec_man_cmd(const char *cmd, const char *page) static void exec_man_cmd(const char *cmd, const char *page)
@ -166,7 +166,7 @@ static void exec_man_cmd(const char *cmd, const char *page)
struct strbuf shell_cmd = STRBUF_INIT; struct strbuf shell_cmd = STRBUF_INIT;
strbuf_addf(&shell_cmd, "%s %s", cmd, page); strbuf_addf(&shell_cmd, "%s %s", cmd, page);
execl("/bin/sh", "sh", "-c", shell_cmd.buf, (char *)NULL); execl("/bin/sh", "sh", "-c", shell_cmd.buf, (char *)NULL);
warning("failed to exec '%s': %s", cmd, strerror(errno)); warning(_("failed to exec '%s': %s"), cmd, strerror(errno));
} }
static void add_man_viewer(const char *name) static void add_man_viewer(const char *name)
@ -206,8 +206,8 @@ static int add_man_viewer_path(const char *name,
if (supported_man_viewer(name, len)) if (supported_man_viewer(name, len))
do_add_man_viewer_info(name, len, value); do_add_man_viewer_info(name, len, value);
else else
warning("'%s': path for unsupported man viewer.\n" warning(_("'%s': path for unsupported man viewer.\n"
"Please consider using 'man.<tool>.cmd' instead.", "Please consider using 'man.<tool>.cmd' instead."),
name); name);
return 0; return 0;
@ -218,8 +218,8 @@ static int add_man_viewer_cmd(const char *name,
const char *value) const char *value)
{ {
if (supported_man_viewer(name, len)) if (supported_man_viewer(name, len))
warning("'%s': cmd for supported man viewer.\n" warning(_("'%s': cmd for supported man viewer.\n"
"Please consider using 'man.<tool>.path' instead.", "Please consider using 'man.<tool>.path' instead."),
name); name);
else else
do_add_man_viewer_info(name, len, value); do_add_man_viewer_info(name, len, value);
@ -280,11 +280,11 @@ void list_common_cmds_help(void)
longest = strlen(common_cmds[i].name); longest = strlen(common_cmds[i].name);
} }
puts("The most commonly used git commands are:"); puts(_("The most commonly used git commands are:"));
for (i = 0; i < ARRAY_SIZE(common_cmds); i++) { for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
printf(" %s ", common_cmds[i].name); printf(" %s ", common_cmds[i].name);
mput_char(' ', longest - strlen(common_cmds[i].name)); mput_char(' ', longest - strlen(common_cmds[i].name));
puts(common_cmds[i].help); puts(_(common_cmds[i].help));
} }
} }
@ -348,7 +348,7 @@ static void exec_viewer(const char *name, const char *page)
else if (info) else if (info)
exec_man_cmd(info, page); exec_man_cmd(info, page);
else else
warning("'%s': unknown man viewer.", name); warning(_("'%s': unknown man viewer."), name);
} }
static void show_man_page(const char *git_cmd) static void show_man_page(const char *git_cmd)
@ -365,7 +365,7 @@ static void show_man_page(const char *git_cmd)
if (fallback) if (fallback)
exec_viewer(fallback, page); exec_viewer(fallback, page);
exec_viewer("man", page); exec_viewer("man", page);
die("no man viewer handled the request"); die(_("no man viewer handled the request"));
} }
static void show_info_page(const char *git_cmd) static void show_info_page(const char *git_cmd)
@ -373,7 +373,7 @@ static void show_info_page(const char *git_cmd)
const char *page = cmd_to_page(git_cmd); const char *page = cmd_to_page(git_cmd);
setenv("INFOPATH", system_path(GIT_INFO_PATH), 1); setenv("INFOPATH", system_path(GIT_INFO_PATH), 1);
execlp("info", "info", "gitman", page, (char *)NULL); execlp("info", "info", "gitman", page, (char *)NULL);
die("no info viewer handled the request"); die(_("no info viewer handled the request"));
} }
static void get_html_page_path(struct strbuf *page_path, const char *page) static void get_html_page_path(struct strbuf *page_path, const char *page)
@ -384,7 +384,7 @@ static void get_html_page_path(struct strbuf *page_path, const char *page)
/* Check that we have a git documentation directory. */ /* Check that we have a git documentation directory. */
if (stat(mkpath("%s/git.html", html_path), &st) if (stat(mkpath("%s/git.html", html_path), &st)
|| !S_ISREG(st.st_mode)) || !S_ISREG(st.st_mode))
die("'%s': not a documentation directory.", html_path); die(_("'%s': not a documentation directory."), html_path);
strbuf_init(page_path, 0); strbuf_init(page_path, 0);
strbuf_addf(page_path, "%s/%s.html", html_path, page); strbuf_addf(page_path, "%s/%s.html", html_path, page);
@ -424,16 +424,16 @@ int cmd_help(int argc, const char **argv, const char *prefix)
parsed_help_format = help_format; parsed_help_format = help_format;
if (show_all) { if (show_all) {
printf("usage: %s\n\n", git_usage_string); printf(_("usage: %s%s"), _(git_usage_string), "\n\n");
list_commands("git commands", &main_cmds, &other_cmds); list_commands(&main_cmds, &other_cmds);
printf("%s\n", git_more_info_string); printf("%s\n", _(git_more_info_string));
return 0; return 0;
} }
if (!argv[0]) { if (!argv[0]) {
printf("usage: %s\n\n", git_usage_string); printf(_("usage: %s%s"), _(git_usage_string), "\n\n");
list_common_cmds_help(); list_common_cmds_help();
printf("\n%s\n", git_more_info_string); printf("\n%s\n", _(git_more_info_string));
return 0; return 0;
} }
@ -445,7 +445,7 @@ int cmd_help(int argc, const char **argv, const char *prefix)
alias = alias_lookup(argv[0]); alias = alias_lookup(argv[0]);
if (alias && !is_git_command(argv[0])) { if (alias && !is_git_command(argv[0])) {
printf("`git %s' is aliased to `%s'\n", argv[0], alias); printf_ln(_("`git %s' is aliased to `%s'"), argv[0], alias);
return 0; return 0;
} }

125
builtin/index-pack.c
View File

@ -81,7 +81,7 @@ static int mark_link(struct object *obj, int type, void *data)
return -1; return -1;
if (type != OBJ_ANY && obj->type != type) if (type != OBJ_ANY && obj->type != type)
die("object type mismatch at %s", sha1_to_hex(obj->sha1)); die(_("object type mismatch at %s"), sha1_to_hex(obj->sha1));
obj->flags |= FLAG_LINK; obj->flags |= FLAG_LINK;
return 0; return 0;
@ -101,7 +101,7 @@ static void check_object(struct object *obj)
unsigned long size; unsigned long size;
int type = sha1_object_info(obj->sha1, &size); int type = sha1_object_info(obj->sha1, &size);
if (type != obj->type || type <= 0) if (type != obj->type || type <= 0)
die("object of unexpected type"); die(_("object of unexpected type"));
obj->flags |= FLAG_CHECKED; obj->flags |= FLAG_CHECKED;
return; return;
} }
@ -138,15 +138,18 @@ static void *fill(int min)
if (min <= input_len) if (min <= input_len)
return input_buffer + input_offset; return input_buffer + input_offset;
if (min > sizeof(input_buffer)) if (min > sizeof(input_buffer))
die("cannot fill %d bytes", min); die(Q_("cannot fill %d byte",
"cannot fill %d bytes",
min),
min);
flush(); flush();
do { do {
ssize_t ret = xread(input_fd, input_buffer + input_len, ssize_t ret = xread(input_fd, input_buffer + input_len,
sizeof(input_buffer) - input_len); sizeof(input_buffer) - input_len);
if (ret <= 0) { if (ret <= 0) {
if (!ret) if (!ret)
die("early EOF"); die(_("early EOF"));
die_errno("read error on input"); die_errno(_("read error on input"));
} }
input_len += ret; input_len += ret;
if (from_stdin) if (from_stdin)
@ -158,14 +161,14 @@ static void *fill(int min)
static void use(int bytes) static void use(int bytes)
{ {
if (bytes > input_len) if (bytes > input_len)
die("used more bytes than were available"); die(_("used more bytes than were available"));
input_crc32 = crc32(input_crc32, input_buffer + input_offset, bytes); input_crc32 = crc32(input_crc32, input_buffer + input_offset, bytes);
input_len -= bytes; input_len -= bytes;
input_offset += bytes; input_offset += bytes;
/* make sure off_t is sufficiently large not to wrap */ /* make sure off_t is sufficiently large not to wrap */
if (signed_add_overflows(consumed_bytes, bytes)) if (signed_add_overflows(consumed_bytes, bytes))
die("pack too large for current definition of off_t"); die(_("pack too large for current definition of off_t"));
consumed_bytes += bytes; consumed_bytes += bytes;
} }
@ -181,12 +184,12 @@ static const char *open_pack_file(const char *pack_name)
} else } else
output_fd = open(pack_name, O_CREAT|O_EXCL|O_RDWR, 0600); output_fd = open(pack_name, O_CREAT|O_EXCL|O_RDWR, 0600);
if (output_fd < 0) if (output_fd < 0)
die_errno("unable to create '%s'", pack_name); die_errno(_("unable to create '%s'"), pack_name);
pack_fd = output_fd; pack_fd = output_fd;
} else { } else {
input_fd = open(pack_name, O_RDONLY); input_fd = open(pack_name, O_RDONLY);
if (input_fd < 0) if (input_fd < 0)
die_errno("cannot open packfile '%s'", pack_name); die_errno(_("cannot open packfile '%s'"), pack_name);
output_fd = -1; output_fd = -1;
pack_fd = input_fd; pack_fd = input_fd;
} }
@ -200,7 +203,7 @@ static void parse_pack_header(void)
/* Header consistency check */ /* Header consistency check */
if (hdr->hdr_signature != htonl(PACK_SIGNATURE)) if (hdr->hdr_signature != htonl(PACK_SIGNATURE))
die("pack signature mismatch"); die(_("pack signature mismatch"));
if (!pack_version_ok(hdr->hdr_version)) if (!pack_version_ok(hdr->hdr_version))
die("pack version %"PRIu32" unsupported", die("pack version %"PRIu32" unsupported",
ntohl(hdr->hdr_version)); ntohl(hdr->hdr_version));
@ -220,7 +223,7 @@ static NORETURN void bad_object(unsigned long offset, const char *format, ...)
va_start(params, format); va_start(params, format);
vsnprintf(buf, sizeof(buf), format, params); vsnprintf(buf, sizeof(buf), format, params);
va_end(params); va_end(params);
die("pack has bad object at offset %lu: %s", offset, buf); die(_("pack has bad object at offset %lu: %s"), offset, buf);
} }
static struct base_data *alloc_base_data(void) static struct base_data *alloc_base_data(void)
@ -294,7 +297,7 @@ static void *unpack_entry_data(unsigned long offset, unsigned long size)
use(input_len - stream.avail_in); use(input_len - stream.avail_in);
} while (status == Z_OK); } while (status == Z_OK);
if (stream.total_out != size || status != Z_STREAM_END) if (stream.total_out != size || status != Z_STREAM_END)
bad_object(offset, "inflate returned %d", status); bad_object(offset, _("inflate returned %d"), status);
git_inflate_end(&stream); git_inflate_end(&stream);
return buf; return buf;
} }
@ -339,7 +342,7 @@ static void *unpack_raw_entry(struct object_entry *obj, union delta_base *delta_
while (c & 128) { while (c & 128) {
base_offset += 1; base_offset += 1;
if (!base_offset || MSB(base_offset, 7)) if (!base_offset || MSB(base_offset, 7))
bad_object(obj->idx.offset, "offset value overflow for delta base object"); bad_object(obj->idx.offset, _("offset value overflow for delta base object"));
p = fill(1); p = fill(1);
c = *p; c = *p;
use(1); use(1);
@ -347,7 +350,7 @@ static void *unpack_raw_entry(struct object_entry *obj, union delta_base *delta_
} }
delta_base->offset = obj->idx.offset - base_offset; delta_base->offset = obj->idx.offset - base_offset;
if (delta_base->offset <= 0 || delta_base->offset >= obj->idx.offset) if (delta_base->offset <= 0 || delta_base->offset >= obj->idx.offset)
bad_object(obj->idx.offset, "delta base offset is out of bound"); bad_object(obj->idx.offset, _("delta base offset is out of bound"));
break; break;
case OBJ_COMMIT: case OBJ_COMMIT:
case OBJ_TREE: case OBJ_TREE:
@ -355,7 +358,7 @@ static void *unpack_raw_entry(struct object_entry *obj, union delta_base *delta_
case OBJ_TAG: case OBJ_TAG:
break; break;
default: default:
bad_object(obj->idx.offset, "unknown object type %d", obj->type); bad_object(obj->idx.offset, _("unknown object type %d"), obj->type);
} }
obj->hdr_size = consumed_bytes - obj->idx.offset; obj->hdr_size = consumed_bytes - obj->idx.offset;
@ -384,9 +387,12 @@ static void *get_data_from_pack(struct object_entry *obj)
ssize_t n = (len < 64*1024) ? len : 64*1024; ssize_t n = (len < 64*1024) ? len : 64*1024;
n = pread(pack_fd, inbuf, n, from); n = pread(pack_fd, inbuf, n, from);
if (n < 0) if (n < 0)
die_errno("cannot pread pack file"); die_errno(_("cannot pread pack file"));
if (!n) if (!n)
die("premature end of pack file, %lu bytes missing", len); die(Q_("premature end of pack file, %lu byte missing",
"premature end of pack file, %lu bytes missing",
len),
len);
from += n; from += n;
len -= n; len -= n;
stream.next_in = inbuf; stream.next_in = inbuf;
@ -396,7 +402,7 @@ static void *get_data_from_pack(struct object_entry *obj)
/* This has been inflated OK when first encountered, so... */ /* This has been inflated OK when first encountered, so... */
if (status != Z_STREAM_END || stream.total_out != obj->size) if (status != Z_STREAM_END || stream.total_out != obj->size)
die("serious inflate inconsistency"); die(_("serious inflate inconsistency"));
git_inflate_end(&stream); git_inflate_end(&stream);
free(inbuf); free(inbuf);
@ -467,10 +473,10 @@ static void sha1_object(const void *data, unsigned long size,
unsigned long has_size; unsigned long has_size;
has_data = read_sha1_file(sha1, &has_type, &has_size); has_data = read_sha1_file(sha1, &has_type, &has_size);
if (!has_data) if (!has_data)
die("cannot read existing object %s", sha1_to_hex(sha1)); die(_("cannot read existing object %s"), sha1_to_hex(sha1));
if (size != has_size || type != has_type || if (size != has_size || type != has_type ||
memcmp(data, has_data, size) != 0) memcmp(data, has_data, size) != 0)
die("SHA1 COLLISION FOUND WITH %s !", sha1_to_hex(sha1)); die(_("SHA1 COLLISION FOUND WITH %s !"), sha1_to_hex(sha1));
free(has_data); free(has_data);
} }
if (strict) { if (strict) {
@ -479,7 +485,7 @@ static void sha1_object(const void *data, unsigned long size,
if (blob) if (blob)
blob->object.flags |= FLAG_CHECKED; blob->object.flags |= FLAG_CHECKED;
else else
die("invalid blob object %s", sha1_to_hex(sha1)); die(_("invalid blob object %s"), sha1_to_hex(sha1));
} else { } else {
struct object *obj; struct object *obj;
int eaten; int eaten;
@ -491,11 +497,11 @@ static void sha1_object(const void *data, unsigned long size,
*/ */
obj = parse_object_buffer(sha1, type, size, buf, &eaten); obj = parse_object_buffer(sha1, type, size, buf, &eaten);
if (!obj) if (!obj)
die("invalid %s", typename(type)); die(_("invalid %s"), typename(type));
if (fsck_object(obj, 1, fsck_error_function)) if (fsck_object(obj, 1, fsck_error_function))
die("Error in object"); die(_("Error in object"));
if (fsck_walk(obj, mark_link, NULL)) if (fsck_walk(obj, mark_link, NULL))
die("Not all child objects of %s are reachable", sha1_to_hex(obj->sha1)); die(_("Not all child objects of %s are reachable"), sha1_to_hex(obj->sha1));
if (obj->type == OBJ_TREE) { if (obj->type == OBJ_TREE) {
struct tree *item = (struct tree *) obj; struct tree *item = (struct tree *) obj;
@ -567,7 +573,7 @@ static void *get_base_data(struct base_data *c)
&c->size); &c->size);
free(raw); free(raw);
if (!c->data) if (!c->data)
bad_object(obj->idx.offset, "failed to apply delta"); bad_object(obj->idx.offset, _("failed to apply delta"));
base_cache_used += c->size; base_cache_used += c->size;
prune_base_data(c); prune_base_data(c);
} }
@ -593,7 +599,7 @@ static void resolve_delta(struct object_entry *delta_obj,
delta_data, delta_obj->size, &result->size); delta_data, delta_obj->size, &result->size);
free(delta_data); free(delta_data);
if (!result->data) if (!result->data)
bad_object(delta_obj->idx.offset, "failed to apply delta"); bad_object(delta_obj->idx.offset, _("failed to apply delta"));
sha1_object(result->data, result->size, delta_obj->real_type, sha1_object(result->data, result->size, delta_obj->real_type,
delta_obj->idx.sha1); delta_obj->idx.sha1);
nr_resolved_deltas++; nr_resolved_deltas++;
@ -697,7 +703,7 @@ static void parse_pack_objects(unsigned char *sha1)
*/ */
if (verbose) if (verbose)
progress = start_progress( progress = start_progress(
from_stdin ? "Receiving objects" : "Indexing objects", from_stdin ? _("Receiving objects") : _("Indexing objects"),
nr_objects); nr_objects);
for (i = 0; i < nr_objects; i++) { for (i = 0; i < nr_objects; i++) {
struct object_entry *obj = &objects[i]; struct object_entry *obj = &objects[i];
@ -719,15 +725,15 @@ static void parse_pack_objects(unsigned char *sha1)
flush(); flush();
git_SHA1_Final(sha1, &input_ctx); git_SHA1_Final(sha1, &input_ctx);
if (hashcmp(fill(20), sha1)) if (hashcmp(fill(20), sha1))
die("pack is corrupted (SHA1 mismatch)"); die(_("pack is corrupted (SHA1 mismatch)"));
use(20); use(20);
/* If input_fd is a file, we should have reached its end now. */ /* If input_fd is a file, we should have reached its end now. */
if (fstat(input_fd, &st)) if (fstat(input_fd, &st))
die_errno("cannot fstat packfile"); die_errno(_("cannot fstat packfile"));
if (S_ISREG(st.st_mode) && if (S_ISREG(st.st_mode) &&
lseek(input_fd, 0, SEEK_CUR) - input_len != st.st_size) lseek(input_fd, 0, SEEK_CUR) - input_len != st.st_size)
die("pack has junk at the end"); die(_("pack has junk at the end"));
if (!nr_deltas) if (!nr_deltas)
return; return;
@ -745,7 +751,7 @@ static void parse_pack_objects(unsigned char *sha1)
* for some more deltas. * for some more deltas.
*/ */
if (verbose) if (verbose)
progress = start_progress("Resolving deltas", nr_deltas); progress = start_progress(_("Resolving deltas"), nr_deltas);
for (i = 0; i < nr_objects; i++) { for (i = 0; i < nr_objects; i++) {
struct object_entry *obj = &objects[i]; struct object_entry *obj = &objects[i];
struct base_data *base_obj = alloc_base_data(); struct base_data *base_obj = alloc_base_data();
@ -778,7 +784,7 @@ static int write_compressed(struct sha1file *f, void *in, unsigned int size)
} while (status == Z_OK); } while (status == Z_OK);
if (status != Z_STREAM_END) if (status != Z_STREAM_END)
die("unable to deflate appended object (%d)", status); die(_("unable to deflate appended object (%d)"), status);
size = stream.total_out; size = stream.total_out;
git_deflate_end(&stream); git_deflate_end(&stream);
return size; return size;
@ -857,7 +863,7 @@ static void fix_unresolved_deltas(struct sha1file *f, int nr_unresolved)
if (check_sha1_signature(d->base.sha1, base_obj->data, if (check_sha1_signature(d->base.sha1, base_obj->data,
base_obj->size, typename(type))) base_obj->size, typename(type)))
die("local object %s is corrupt", sha1_to_hex(d->base.sha1)); die(_("local object %s is corrupt"), sha1_to_hex(d->base.sha1));
base_obj->obj = append_obj_to_pack(f, d->base.sha1, base_obj->obj = append_obj_to_pack(f, d->base.sha1,
base_obj->data, base_obj->size, type); base_obj->data, base_obj->size, type);
find_unresolved_deltas(base_obj); find_unresolved_deltas(base_obj);
@ -881,7 +887,7 @@ static void final(const char *final_pack_name, const char *curr_pack_name,
fsync_or_die(output_fd, curr_pack_name); fsync_or_die(output_fd, curr_pack_name);
err = close(output_fd); err = close(output_fd);
if (err) if (err)
die_errno("error while closing pack file"); die_errno(_("error while closing pack file"));
} }
if (keep_msg) { if (keep_msg) {
@ -894,7 +900,7 @@ static void final(const char *final_pack_name, const char *curr_pack_name,
if (keep_fd < 0) { if (keep_fd < 0) {
if (errno != EEXIST) if (errno != EEXIST)
die_errno("cannot write keep file '%s'", die_errno(_("cannot write keep file '%s'"),
keep_name); keep_name);
} else { } else {
if (keep_msg_len > 0) { if (keep_msg_len > 0) {
@ -902,7 +908,7 @@ static void final(const char *final_pack_name, const char *curr_pack_name,
write_or_die(keep_fd, "\n", 1); write_or_die(keep_fd, "\n", 1);
} }
if (close(keep_fd) != 0) if (close(keep_fd) != 0)
die_errno("cannot close written keep file '%s'", die_errno(_("cannot close written keep file '%s'"),
keep_name); keep_name);
report = "keep"; report = "keep";
} }
@ -915,7 +921,7 @@ static void final(const char *final_pack_name, const char *curr_pack_name,
final_pack_name = name; final_pack_name = name;
} }
if (move_temp_to_file(curr_pack_name, final_pack_name)) if (move_temp_to_file(curr_pack_name, final_pack_name))
die("cannot store pack file"); die(_("cannot store pack file"));
} else if (from_stdin) } else if (from_stdin)
chmod(final_pack_name, 0444); chmod(final_pack_name, 0444);
@ -926,7 +932,7 @@ static void final(const char *final_pack_name, const char *curr_pack_name,
final_index_name = name; final_index_name = name;
} }
if (move_temp_to_file(curr_index_name, final_index_name)) if (move_temp_to_file(curr_index_name, final_index_name))
die("cannot store index file"); die(_("cannot store index file"));
} else } else
chmod(final_index_name, 0444); chmod(final_index_name, 0444);
@ -1015,9 +1021,9 @@ static void read_idx_option(struct pack_idx_option *opts, const char *pack_name)
struct packed_git *p = add_packed_git(pack_name, strlen(pack_name), 1); struct packed_git *p = add_packed_git(pack_name, strlen(pack_name), 1);
if (!p) if (!p)
die("Cannot open existing pack file '%s'", pack_name); die(_("Cannot open existing pack file '%s'"), pack_name);
if (open_pack_index(p)) if (open_pack_index(p))
die("Cannot open existing pack idx file for '%s'", pack_name); die(_("Cannot open existing pack idx file for '%s'"), pack_name);
/* Read the attributes from the existing idx file */ /* Read the attributes from the existing idx file */
opts->version = p->index_version; opts->version = p->index_version;
@ -1064,15 +1070,18 @@ static void show_pack_info(int stat_only)
} }
if (baseobjects) if (baseobjects)
printf("non delta: %d object%s\n", printf_ln(Q_("non delta: %d object",
baseobjects, baseobjects > 1 ? "s" : ""); "non delta: %d objects",
baseobjects),
baseobjects);
for (i = 0; i < deepest_delta; i++) { for (i = 0; i < deepest_delta; i++) {
if (!chain_histogram[i]) if (!chain_histogram[i])
continue; continue;
printf("chain length = %d: %lu object%s\n", printf_ln(Q_("chain length = %d: %lu object",
i + 1, "chain length = %d: %lu objects",
chain_histogram[i], chain_histogram[i]),
chain_histogram[i] > 1 ? "s" : ""); i + 1,
chain_histogram[i]);
} }
} }
@ -1095,7 +1104,7 @@ int cmd_index_pack(int argc, const char **argv, const char *prefix)
reset_pack_idx_option(&opts); reset_pack_idx_option(&opts);
git_config(git_index_pack_config, &opts); git_config(git_index_pack_config, &opts);
if (prefix && chdir(prefix)) if (prefix && chdir(prefix))
die("Cannot come back to cwd"); die(_("Cannot come back to cwd"));
for (i = 1; i < argc; i++) { for (i = 1; i < argc; i++) {
const char *arg = argv[i]; const char *arg = argv[i];
@ -1128,10 +1137,10 @@ int cmd_index_pack(int argc, const char **argv, const char *prefix)
hdr->hdr_signature = htonl(PACK_SIGNATURE); hdr->hdr_signature = htonl(PACK_SIGNATURE);
hdr->hdr_version = htonl(strtoul(arg + 14, &c, 10)); hdr->hdr_version = htonl(strtoul(arg + 14, &c, 10));
if (*c != ',') if (*c != ',')
die("bad %s", arg); die(_("bad %s"), arg);
hdr->hdr_entries = htonl(strtoul(c + 1, &c, 10)); hdr->hdr_entries = htonl(strtoul(c + 1, &c, 10));
if (*c) if (*c)
die("bad %s", arg); die(_("bad %s"), arg);
input_len = sizeof(*hdr); input_len = sizeof(*hdr);
} else if (!strcmp(arg, "-v")) { } else if (!strcmp(arg, "-v")) {
verbose = 1; verbose = 1;
@ -1143,11 +1152,11 @@ int cmd_index_pack(int argc, const char **argv, const char *prefix)
char *c; char *c;
opts.version = strtoul(arg + 16, &c, 10); opts.version = strtoul(arg + 16, &c, 10);
if (opts.version > 2) if (opts.version > 2)
die("bad %s", arg); die(_("bad %s"), arg);
if (*c == ',') if (*c == ',')
opts.off32_limit = strtoul(c+1, &c, 0); opts.off32_limit = strtoul(c+1, &c, 0);
if (*c || opts.off32_limit & 0x80000000) if (*c || opts.off32_limit & 0x80000000)
die("bad %s", arg); die(_("bad %s"), arg);
} else } else
usage(index_pack_usage); usage(index_pack_usage);
continue; continue;
@ -1161,11 +1170,11 @@ int cmd_index_pack(int argc, const char **argv, const char *prefix)
if (!pack_name && !from_stdin) if (!pack_name && !from_stdin)
usage(index_pack_usage); usage(index_pack_usage);
if (fix_thin_pack && !from_stdin) if (fix_thin_pack && !from_stdin)
die("--fix-thin cannot be used without --stdin"); die(_("--fix-thin cannot be used without --stdin"));
if (!index_name && pack_name) { if (!index_name && pack_name) {
int len = strlen(pack_name); int len = strlen(pack_name);
if (!has_extension(pack_name, ".pack")) if (!has_extension(pack_name, ".pack"))
die("packfile name '%s' does not end with '.pack'", die(_("packfile name '%s' does not end with '.pack'"),
pack_name); pack_name);
index_name_buf = xmalloc(len); index_name_buf = xmalloc(len);
memcpy(index_name_buf, pack_name, len - 5); memcpy(index_name_buf, pack_name, len - 5);
@ -1175,7 +1184,7 @@ int cmd_index_pack(int argc, const char **argv, const char *prefix)
if (keep_msg && !keep_name && pack_name) { if (keep_msg && !keep_name && pack_name) {
int len = strlen(pack_name); int len = strlen(pack_name);
if (!has_extension(pack_name, ".pack")) if (!has_extension(pack_name, ".pack"))
die("packfile name '%s' does not end with '.pack'", die(_("packfile name '%s' does not end with '.pack'"),
pack_name); pack_name);
keep_name_buf = xmalloc(len); keep_name_buf = xmalloc(len);
memcpy(keep_name_buf, pack_name, len - 5); memcpy(keep_name_buf, pack_name, len - 5);
@ -1184,7 +1193,7 @@ int cmd_index_pack(int argc, const char **argv, const char *prefix)
} }
if (verify) { if (verify) {
if (!index_name) if (!index_name)
die("--verify with no packfile name given"); die(_("--verify with no packfile name given"));
read_idx_option(&opts, index_name); read_idx_option(&opts, index_name);
opts.flags |= WRITE_IDX_VERIFY | WRITE_IDX_STRICT; opts.flags |= WRITE_IDX_VERIFY | WRITE_IDX_STRICT;
} }
@ -1208,7 +1217,7 @@ int cmd_index_pack(int argc, const char **argv, const char *prefix)
int nr_unresolved = nr_deltas - nr_resolved_deltas; int nr_unresolved = nr_deltas - nr_resolved_deltas;
int nr_objects_initial = nr_objects; int nr_objects_initial = nr_objects;
if (nr_unresolved <= 0) if (nr_unresolved <= 0)
die("confusion beyond insanity"); die(_("confusion beyond insanity"));
objects = xrealloc(objects, objects = xrealloc(objects,
(nr_objects + nr_unresolved + 1) (nr_objects + nr_unresolved + 1)
* sizeof(*objects)); * sizeof(*objects));
@ -1227,7 +1236,9 @@ int cmd_index_pack(int argc, const char **argv, const char *prefix)
"(disk corruption?)", curr_pack); "(disk corruption?)", curr_pack);
} }
if (nr_deltas != nr_resolved_deltas) if (nr_deltas != nr_resolved_deltas)
die("pack has %d unresolved deltas", die(Q_("pack has %d unresolved delta",
"pack has %d unresolved deltas",
nr_deltas - nr_resolved_deltas),
nr_deltas - nr_resolved_deltas); nr_deltas - nr_resolved_deltas);
} }
free(deltas); free(deltas);

227
builtin/remote.c
View File

@ -95,9 +95,9 @@ static int fetch_remote(const char *name)
argv[1] = "-v"; argv[1] = "-v";
argv[2] = name; argv[2] = name;
} }
printf("Updating %s\n", name); printf_ln(_("Updating %s"), name);
if (run_command_v_opt(argv, RUN_GIT_CMD)) if (run_command_v_opt(argv, RUN_GIT_CMD))
return error("Could not fetch %s", name); return error(_("Could not fetch %s"), name);
return 0; return 0;
} }
@ -127,8 +127,8 @@ static int add_branch(const char *key, const char *branchname,
} }
static const char mirror_advice[] = static const char mirror_advice[] =
"--mirror is dangerous and deprecated; please\n" N_("--mirror is dangerous and deprecated; please\n"
"\t use --mirror=fetch or --mirror=push instead"; "\t use --mirror=fetch or --mirror=push instead");
static int parse_mirror_opt(const struct option *opt, const char *arg, int not) static int parse_mirror_opt(const struct option *opt, const char *arg, int not)
{ {
@ -136,7 +136,7 @@ static int parse_mirror_opt(const struct option *opt, const char *arg, int not)
if (not) if (not)
*mirror = MIRROR_NONE; *mirror = MIRROR_NONE;
else if (!arg) { else if (!arg) {
warning("%s", mirror_advice); warning("%s", _(mirror_advice));
*mirror = MIRROR_BOTH; *mirror = MIRROR_BOTH;
} }
else if (!strcmp(arg, "fetch")) else if (!strcmp(arg, "fetch"))
@ -144,7 +144,7 @@ static int parse_mirror_opt(const struct option *opt, const char *arg, int not)
else if (!strcmp(arg, "push")) else if (!strcmp(arg, "push"))
*mirror = MIRROR_PUSH; *mirror = MIRROR_PUSH;
else else
return error("unknown mirror argument: %s", arg); return error(_("unknown mirror argument: %s"), arg);
return 0; return 0;
} }
@ -182,9 +182,9 @@ static int add(int argc, const char **argv)
usage_with_options(builtin_remote_add_usage, options); usage_with_options(builtin_remote_add_usage, options);
if (mirror && master) if (mirror && master)
die("specifying a master branch makes no sense with --mirror"); die(_("specifying a master branch makes no sense with --mirror"));
if (mirror && !(mirror & MIRROR_FETCH) && track.nr) if (mirror && !(mirror & MIRROR_FETCH) && track.nr)
die("specifying branches to track makes sense only with fetch mirrors"); die(_("specifying branches to track makes sense only with fetch mirrors"));
name = argv[0]; name = argv[0];
url = argv[1]; url = argv[1];
@ -192,11 +192,11 @@ static int add(int argc, const char **argv)
remote = remote_get(name); remote = remote_get(name);
if (remote && (remote->url_nr > 1 || strcmp(name, remote->url[0]) || if (remote && (remote->url_nr > 1 || strcmp(name, remote->url[0]) ||
remote->fetch_refspec_nr)) remote->fetch_refspec_nr))
die("remote %s already exists.", name); die(_("remote %s already exists."), name);
strbuf_addf(&buf2, "refs/heads/test:refs/remotes/%s/test", name); strbuf_addf(&buf2, "refs/heads/test:refs/remotes/%s/test", name);
if (!valid_fetch_refspec(buf2.buf)) if (!valid_fetch_refspec(buf2.buf))
die("'%s' is not a valid remote name", name); die(_("'%s' is not a valid remote name"), name);
strbuf_addf(&buf, "remote.%s.url", name); strbuf_addf(&buf, "remote.%s.url", name);
if (git_config_set(buf.buf, url)) if (git_config_set(buf.buf, url))
@ -240,7 +240,7 @@ static int add(int argc, const char **argv)
strbuf_addf(&buf2, "refs/remotes/%s/%s", name, master); strbuf_addf(&buf2, "refs/remotes/%s/%s", name, master);
if (create_symref(buf.buf, buf2.buf, "remote add")) if (create_symref(buf.buf, buf2.buf, "remote add"))
return error("Could not setup master '%s'", master); return error(_("Could not setup master '%s'"), master);
} }
strbuf_release(&buf); strbuf_release(&buf);
@ -296,7 +296,7 @@ static int config_read_branches(const char *key, const char *value, void *cb)
info = item->util; info = item->util;
if (type == REMOTE) { if (type == REMOTE) {
if (info->remote_name) if (info->remote_name)
warning("more than one %s", orig_key); warning(_("more than one %s"), orig_key);
info->remote_name = xstrdup(value); info->remote_name = xstrdup(value);
} else if (type == MERGE) { } else if (type == MERGE) {
char *space = strchr(value, ' '); char *space = strchr(value, ' ');
@ -336,7 +336,7 @@ static int get_ref_states(const struct ref *remote_refs, struct ref_states *stat
for (i = 0; i < states->remote->fetch_refspec_nr; i++) for (i = 0; i < states->remote->fetch_refspec_nr; i++)
if (get_fetch_map(remote_refs, states->remote->fetch + i, &tail, 1)) if (get_fetch_map(remote_refs, states->remote->fetch + i, &tail, 1))
die("Could not get fetch map for refspec %s", die(_("Could not get fetch map for refspec %s"),
states->remote->fetch_refspec[i]); states->remote->fetch_refspec[i]);
states->new.strdup_strings = 1; states->new.strdup_strings = 1;
@ -437,7 +437,7 @@ static int get_push_ref_states_noquery(struct ref_states *states)
states->push.strdup_strings = 1; states->push.strdup_strings = 1;
if (!remote->push_refspec_nr) { if (!remote->push_refspec_nr) {
item = string_list_append(&states->push, "(matching)"); item = string_list_append(&states->push, _("(matching)"));
info = item->util = xcalloc(sizeof(struct push_info), 1); info = item->util = xcalloc(sizeof(struct push_info), 1);
info->status = PUSH_STATUS_NOTQUERIED; info->status = PUSH_STATUS_NOTQUERIED;
info->dest = xstrdup(item->string); info->dest = xstrdup(item->string);
@ -445,11 +445,11 @@ static int get_push_ref_states_noquery(struct ref_states *states)
for (i = 0; i < remote->push_refspec_nr; i++) { for (i = 0; i < remote->push_refspec_nr; i++) {
struct refspec *spec = remote->push + i; struct refspec *spec = remote->push + i;
if (spec->matching) if (spec->matching)
item = string_list_append(&states->push, "(matching)"); item = string_list_append(&states->push, _("(matching)"));
else if (strlen(spec->src)) else if (strlen(spec->src))
item = string_list_append(&states->push, spec->src); item = string_list_append(&states->push, spec->src);
else else
item = string_list_append(&states->push, "(delete)"); item = string_list_append(&states->push, _("(delete)"));
info = item->util = xcalloc(sizeof(struct push_info), 1); info = item->util = xcalloc(sizeof(struct push_info), 1);
info->forced = spec->force; info->forced = spec->force;
@ -592,19 +592,19 @@ static int migrate_file(struct remote *remote)
strbuf_addf(&buf, "remote.%s.url", remote->name); strbuf_addf(&buf, "remote.%s.url", remote->name);
for (i = 0; i < remote->url_nr; i++) for (i = 0; i < remote->url_nr; i++)
if (git_config_set_multivar(buf.buf, remote->url[i], "^$", 0)) if (git_config_set_multivar(buf.buf, remote->url[i], "^$", 0))
return error("Could not append '%s' to '%s'", return error(_("Could not append '%s' to '%s'"),
remote->url[i], buf.buf); remote->url[i], buf.buf);
strbuf_reset(&buf); strbuf_reset(&buf);
strbuf_addf(&buf, "remote.%s.push", remote->name); strbuf_addf(&buf, "remote.%s.push", remote->name);
for (i = 0; i < remote->push_refspec_nr; i++) for (i = 0; i < remote->push_refspec_nr; i++)
if (git_config_set_multivar(buf.buf, remote->push_refspec[i], "^$", 0)) if (git_config_set_multivar(buf.buf, remote->push_refspec[i], "^$", 0))
return error("Could not append '%s' to '%s'", return error(_("Could not append '%s' to '%s'"),
remote->push_refspec[i], buf.buf); remote->push_refspec[i], buf.buf);
strbuf_reset(&buf); strbuf_reset(&buf);
strbuf_addf(&buf, "remote.%s.fetch", remote->name); strbuf_addf(&buf, "remote.%s.fetch", remote->name);
for (i = 0; i < remote->fetch_refspec_nr; i++) for (i = 0; i < remote->fetch_refspec_nr; i++)
if (git_config_set_multivar(buf.buf, remote->fetch_refspec[i], "^$", 0)) if (git_config_set_multivar(buf.buf, remote->fetch_refspec[i], "^$", 0))
return error("Could not append '%s' to '%s'", return error(_("Could not append '%s' to '%s'"),
remote->fetch_refspec[i], buf.buf); remote->fetch_refspec[i], buf.buf);
if (remote->origin == REMOTE_REMOTES) if (remote->origin == REMOTE_REMOTES)
path = git_path("remotes/%s", remote->name); path = git_path("remotes/%s", remote->name);
@ -636,30 +636,30 @@ static int mv(int argc, const char **argv)
oldremote = remote_get(rename.old); oldremote = remote_get(rename.old);
if (!oldremote) if (!oldremote)
die("No such remote: %s", rename.old); die(_("No such remote: %s"), rename.old);
if (!strcmp(rename.old, rename.new) && oldremote->origin != REMOTE_CONFIG) if (!strcmp(rename.old, rename.new) && oldremote->origin != REMOTE_CONFIG)
return migrate_file(oldremote); return migrate_file(oldremote);
newremote = remote_get(rename.new); newremote = remote_get(rename.new);
if (newremote && (newremote->url_nr > 1 || newremote->fetch_refspec_nr)) if (newremote && (newremote->url_nr > 1 || newremote->fetch_refspec_nr))
die("remote %s already exists.", rename.new); die(_("remote %s already exists."), rename.new);
strbuf_addf(&buf, "refs/heads/test:refs/remotes/%s/test", rename.new); strbuf_addf(&buf, "refs/heads/test:refs/remotes/%s/test", rename.new);
if (!valid_fetch_refspec(buf.buf)) if (!valid_fetch_refspec(buf.buf))
die("'%s' is not a valid remote name", rename.new); die(_("'%s' is not a valid remote name"), rename.new);
strbuf_reset(&buf); strbuf_reset(&buf);
strbuf_addf(&buf, "remote.%s", rename.old); strbuf_addf(&buf, "remote.%s", rename.old);
strbuf_addf(&buf2, "remote.%s", rename.new); strbuf_addf(&buf2, "remote.%s", rename.new);
if (git_config_rename_section(buf.buf, buf2.buf) < 1) if (git_config_rename_section(buf.buf, buf2.buf) < 1)
return error("Could not rename config section '%s' to '%s'", return error(_("Could not rename config section '%s' to '%s'"),
buf.buf, buf2.buf); buf.buf, buf2.buf);
strbuf_reset(&buf); strbuf_reset(&buf);
strbuf_addf(&buf, "remote.%s.fetch", rename.new); strbuf_addf(&buf, "remote.%s.fetch", rename.new);
if (git_config_set_multivar(buf.buf, NULL, NULL, 1)) if (git_config_set_multivar(buf.buf, NULL, NULL, 1))
return error("Could not remove config section '%s'", buf.buf); return error(_("Could not remove config section '%s'"), buf.buf);
strbuf_addf(&old_remote_context, ":refs/remotes/%s/", rename.old); strbuf_addf(&old_remote_context, ":refs/remotes/%s/", rename.old);
for (i = 0; i < oldremote->fetch_refspec_nr; i++) { for (i = 0; i < oldremote->fetch_refspec_nr; i++) {
char *ptr; char *ptr;
@ -674,13 +674,13 @@ static int mv(int argc, const char **argv)
strlen(rename.old), rename.new, strlen(rename.old), rename.new,
strlen(rename.new)); strlen(rename.new));
} else } else
warning("Not updating non-default fetch respec\n" warning(_("Not updating non-default fetch respec\n"
"\t%s\n" "\t%s\n"
"\tPlease update the configuration manually if necessary.", "\tPlease update the configuration manually if necessary."),
buf2.buf); buf2.buf);
if (git_config_set_multivar(buf.buf, buf2.buf, "^$", 0)) if (git_config_set_multivar(buf.buf, buf2.buf, "^$", 0))
return error("Could not append '%s'", buf.buf); return error(_("Could not append '%s'"), buf.buf);
} }
read_branches(); read_branches();
@ -691,7 +691,7 @@ static int mv(int argc, const char **argv)
strbuf_reset(&buf); strbuf_reset(&buf);
strbuf_addf(&buf, "branch.%s.remote", item->string); strbuf_addf(&buf, "branch.%s.remote", item->string);
if (git_config_set(buf.buf, rename.new)) { if (git_config_set(buf.buf, rename.new)) {
return error("Could not set '%s'", buf.buf); return error(_("Could not set '%s'"), buf.buf);
} }
} }
} }
@ -713,7 +713,7 @@ static int mv(int argc, const char **argv)
if (!(flag & REF_ISSYMREF)) if (!(flag & REF_ISSYMREF))
continue; continue;
if (delete_ref(item->string, NULL, REF_NODEREF)) if (delete_ref(item->string, NULL, REF_NODEREF))
die("deleting '%s' failed", item->string); die(_("deleting '%s' failed"), item->string);
} }
for (i = 0; i < remote_branches.nr; i++) { for (i = 0; i < remote_branches.nr; i++) {
struct string_list_item *item = remote_branches.items + i; struct string_list_item *item = remote_branches.items + i;
@ -728,7 +728,7 @@ static int mv(int argc, const char **argv)
strbuf_addf(&buf2, "remote: renamed %s to %s", strbuf_addf(&buf2, "remote: renamed %s to %s",
item->string, buf.buf); item->string, buf.buf);
if (rename_ref(item->string, buf.buf, buf2.buf)) if (rename_ref(item->string, buf.buf, buf2.buf))
die("renaming '%s' failed", item->string); die(_("renaming '%s' failed"), item->string);
} }
for (i = 0; i < remote_branches.nr; i++) { for (i = 0; i < remote_branches.nr; i++) {
struct string_list_item *item = remote_branches.items + i; struct string_list_item *item = remote_branches.items + i;
@ -747,7 +747,7 @@ static int mv(int argc, const char **argv)
strbuf_addf(&buf3, "remote: renamed %s to %s", strbuf_addf(&buf3, "remote: renamed %s to %s",
item->string, buf.buf); item->string, buf.buf);
if (create_symref(buf.buf, buf2.buf, buf3.buf)) if (create_symref(buf.buf, buf2.buf, buf3.buf))
die("creating '%s' failed", buf.buf); die(_("creating '%s' failed"), buf.buf);
} }
return 0; return 0;
} }
@ -761,7 +761,7 @@ static int remove_branches(struct string_list *branches)
unsigned char *sha1 = item->util; unsigned char *sha1 = item->util;
if (delete_ref(refname, sha1, 0)) if (delete_ref(refname, sha1, 0))
result |= error("Could not remove branch %s", refname); result |= error(_("Could not remove branch %s"), refname);
} }
return result; return result;
} }
@ -789,14 +789,14 @@ static int rm(int argc, const char **argv)
remote = remote_get(argv[1]); remote = remote_get(argv[1]);
if (!remote) if (!remote)
die("No such remote: %s", argv[1]); die(_("No such remote: %s"), argv[1]);
known_remotes.to_delete = remote; known_remotes.to_delete = remote;
for_each_remote(add_known_remote, &known_remotes); for_each_remote(add_known_remote, &known_remotes);
strbuf_addf(&buf, "remote.%s", remote->name); strbuf_addf(&buf, "remote.%s", remote->name);
if (git_config_rename_section(buf.buf, NULL) < 1) if (git_config_rename_section(buf.buf, NULL) < 1)
return error("Could not remove config section '%s'", buf.buf); return error(_("Could not remove config section '%s'"), buf.buf);
read_branches(); read_branches();
for (i = 0; i < branch_list.nr; i++) { for (i = 0; i < branch_list.nr; i++) {
@ -830,11 +830,12 @@ static int rm(int argc, const char **argv)
string_list_clear(&branches, 1); string_list_clear(&branches, 1);
if (skipped.nr) { if (skipped.nr) {
fprintf(stderr, skipped.nr == 1 ? fprintf_ln(stderr,
"Note: A branch outside the refs/remotes/ hierarchy was not removed;\n" Q_("Note: A branch outside the refs/remotes/ hierarchy was not removed;\n"
"to delete it, use:\n" : "to delete it, use:",
"Note: Some branches outside the refs/remotes/ hierarchy were not removed;\n" "Note: Some branches outside the refs/remotes/ hierarchy were not removed;\n"
"to delete them, use:\n"); "to delete them, use:",
skipped.nr));
for (i = 0; i < skipped.nr; i++) for (i = 0; i < skipped.nr; i++)
fprintf(stderr, " git branch -d %s\n", fprintf(stderr, " git branch -d %s\n",
skipped.items[i].string); skipped.items[i].string);
@ -886,7 +887,7 @@ static int get_remote_ref_states(const char *name,
states->remote = remote_get(name); states->remote = remote_get(name);
if (!states->remote) if (!states->remote)
return error("No such remote: %s", name); return error(_("No such remote: %s"), name);
read_branches(); read_branches();
@ -939,14 +940,14 @@ static int show_remote_info_item(struct string_list_item *item, void *cb_data)
const char *fmt = "%s"; const char *fmt = "%s";
const char *arg = ""; const char *arg = "";
if (string_list_has_string(&states->new, name)) { if (string_list_has_string(&states->new, name)) {
fmt = " new (next fetch will store in remotes/%s)"; fmt = _(" new (next fetch will store in remotes/%s)");
arg = states->remote->name; arg = states->remote->name;
} else if (string_list_has_string(&states->tracked, name)) } else if (string_list_has_string(&states->tracked, name))
arg = " tracked"; arg = _(" tracked");
else if (string_list_has_string(&states->stale, name)) else if (string_list_has_string(&states->stale, name))
arg = " stale (use 'git remote prune' to remove)"; arg = _(" stale (use 'git remote prune' to remove)");
else else
arg = " ???"; arg = _(" ???");
printf(" %-*s", info->width, name); printf(" %-*s", info->width, name);
printf(fmt, arg); printf(fmt, arg);
printf("\n"); printf("\n");
@ -987,21 +988,21 @@ static int show_local_info_item(struct string_list_item *item, void *cb_data)
int i; int i;
if (branch_info->rebase && branch_info->merge.nr > 1) { if (branch_info->rebase && branch_info->merge.nr > 1) {
error("invalid branch.%s.merge; cannot rebase onto > 1 branch", error(_("invalid branch.%s.merge; cannot rebase onto > 1 branch"),
item->string); item->string);
return 0; return 0;
} }
printf(" %-*s ", show_info->width, item->string); printf(" %-*s ", show_info->width, item->string);
if (branch_info->rebase) { if (branch_info->rebase) {
printf("rebases onto remote %s\n", merge->items[0].string); printf_ln(_("rebases onto remote %s"), merge->items[0].string);
return 0; return 0;
} else if (show_info->any_rebase) { } else if (show_info->any_rebase) {
printf(" merges with remote %s\n", merge->items[0].string); printf_ln(_(" merges with remote %s"), merge->items[0].string);
also = " and with remote"; also = _(" and with remote");
} else { } else {
printf("merges with remote %s\n", merge->items[0].string); printf_ln(_("merges with remote %s"), merge->items[0].string);
also = " and with remote"; also = _(" and with remote");
} }
for (i = 1; i < merge->nr; i++) for (i = 1; i < merge->nr; i++)
printf(" %-*s %s %s\n", show_info->width, "", also, printf(" %-*s %s %s\n", show_info->width, "", also,
@ -1043,36 +1044,43 @@ static int show_push_info_item(struct string_list_item *item, void *cb_data)
{ {
struct show_info *show_info = cb_data; struct show_info *show_info = cb_data;
struct push_info *push_info = item->util; struct push_info *push_info = item->util;
char *src = item->string, *status = NULL; const char *src = item->string, *status = NULL;
switch (push_info->status) { switch (push_info->status) {
case PUSH_STATUS_CREATE: case PUSH_STATUS_CREATE:
status = "create"; status = _("create");
break; break;
case PUSH_STATUS_DELETE: case PUSH_STATUS_DELETE:
status = "delete"; status = _("delete");
src = "(none)"; src = _("(none)");
break; break;
case PUSH_STATUS_UPTODATE: case PUSH_STATUS_UPTODATE:
status = "up to date"; status = _("up to date");
break; break;
case PUSH_STATUS_FASTFORWARD: case PUSH_STATUS_FASTFORWARD:
status = "fast-forwardable"; status = _("fast-forwardable");
break; break;
case PUSH_STATUS_OUTOFDATE: case PUSH_STATUS_OUTOFDATE:
status = "local out of date"; status = _("local out of date");
break; break;
case PUSH_STATUS_NOTQUERIED: case PUSH_STATUS_NOTQUERIED:
break; break;
} }
if (status) if (status) {
printf(" %-*s %s to %-*s (%s)\n", show_info->width, src, if (push_info->forced)
push_info->forced ? "forces" : "pushes", printf_ln(_(" %-*s forces to %-*s (%s)"), show_info->width, src,
show_info->width2, push_info->dest, status); show_info->width2, push_info->dest, status);
else else
printf(" %-*s %s to %s\n", show_info->width, src, printf_ln(_(" %-*s pushes to %-*s (%s)"), show_info->width, src,
push_info->forced ? "forces" : "pushes", show_info->width2, push_info->dest, status);
push_info->dest); } else {
if (push_info->forced)
printf_ln(_(" %-*s forces to %s"), show_info->width, src,
push_info->dest);
else
printf_ln(_(" %-*s pushes to %s"), show_info->width, src,
push_info->dest);
}
return 0; return 0;
} }
@ -1107,9 +1115,9 @@ static int show(int argc, const char **argv)
get_remote_ref_states(*argv, &states, query_flag); get_remote_ref_states(*argv, &states, query_flag);
printf("* remote %s\n", *argv); printf_ln(_("* remote %s"), *argv);
printf(" Fetch URL: %s\n", states.remote->url_nr > 0 ? printf_ln(_(" Fetch URL: %s"), states.remote->url_nr > 0 ?
states.remote->url[0] : "(no URL)"); states.remote->url[0] : _("(no URL)"));
if (states.remote->pushurl_nr) { if (states.remote->pushurl_nr) {
url = states.remote->pushurl; url = states.remote->pushurl;
url_nr = states.remote->pushurl_nr; url_nr = states.remote->pushurl_nr;
@ -1118,18 +1126,18 @@ static int show(int argc, const char **argv)
url_nr = states.remote->url_nr; url_nr = states.remote->url_nr;
} }
for (i = 0; i < url_nr; i++) for (i = 0; i < url_nr; i++)
printf(" Push URL: %s\n", url[i]); printf_ln(_(" Push URL: %s"), url[i]);
if (!i) if (!i)
printf(" Push URL: %s\n", "(no URL)"); printf_ln(_(" Push URL: %s"), "(no URL)");
if (no_query) if (no_query)
printf(" HEAD branch: (not queried)\n"); printf_ln(_(" HEAD branch: %s"), "(not queried)");
else if (!states.heads.nr) else if (!states.heads.nr)
printf(" HEAD branch: (unknown)\n"); printf_ln(_(" HEAD branch: %s"), "(unknown)");
else if (states.heads.nr == 1) else if (states.heads.nr == 1)
printf(" HEAD branch: %s\n", states.heads.items[0].string); printf_ln(_(" HEAD branch: %s"), states.heads.items[0].string);
else { else {
printf(" HEAD branch (remote HEAD is ambiguous," printf(_(" HEAD branch (remote HEAD is ambiguous,"
" may be one of the following):\n"); " may be one of the following):\n"));
for (i = 0; i < states.heads.nr; i++) for (i = 0; i < states.heads.nr; i++)
printf(" %s\n", states.heads.items[i].string); printf(" %s\n", states.heads.items[i].string);
} }
@ -1140,9 +1148,10 @@ static int show(int argc, const char **argv)
for_each_string_list(&states.tracked, add_remote_to_show_info, &info); for_each_string_list(&states.tracked, add_remote_to_show_info, &info);
for_each_string_list(&states.stale, add_remote_to_show_info, &info); for_each_string_list(&states.stale, add_remote_to_show_info, &info);
if (info.list->nr) if (info.list->nr)
printf(" Remote branch%s:%s\n", printf_ln(Q_(" Remote branch:%s",
info.list->nr > 1 ? "es" : "", " Remote branches:%s",
no_query ? " (status not queried)" : ""); info.list->nr),
no_query ? _(" (status not queried)") : "");
for_each_string_list(info.list, show_remote_info_item, &info); for_each_string_list(info.list, show_remote_info_item, &info);
string_list_clear(info.list, 0); string_list_clear(info.list, 0);
@ -1151,23 +1160,25 @@ static int show(int argc, const char **argv)
info.any_rebase = 0; info.any_rebase = 0;
for_each_string_list(&branch_list, add_local_to_show_info, &info); for_each_string_list(&branch_list, add_local_to_show_info, &info);
if (info.list->nr) if (info.list->nr)
printf(" Local branch%s configured for 'git pull':\n", printf_ln(Q_(" Local branch configured for 'git pull':",
info.list->nr > 1 ? "es" : ""); " Local branches configured for 'git pull':",
info.list->nr));
for_each_string_list(info.list, show_local_info_item, &info); for_each_string_list(info.list, show_local_info_item, &info);
string_list_clear(info.list, 0); string_list_clear(info.list, 0);
/* git push info */ /* git push info */
if (states.remote->mirror) if (states.remote->mirror)
printf(" Local refs will be mirrored by 'git push'\n"); printf_ln(_(" Local refs will be mirrored by 'git push'"));
info.width = info.width2 = 0; info.width = info.width2 = 0;
for_each_string_list(&states.push, add_push_to_show_info, &info); for_each_string_list(&states.push, add_push_to_show_info, &info);
qsort(info.list->items, info.list->nr, qsort(info.list->items, info.list->nr,
sizeof(*info.list->items), cmp_string_with_push); sizeof(*info.list->items), cmp_string_with_push);
if (info.list->nr) if (info.list->nr)
printf(" Local ref%s configured for 'git push'%s:\n", printf_ln(Q_(" Local ref configured for 'git push'%s:",
info.list->nr > 1 ? "s" : "", " Local refs configured for 'git push'%s:",
no_query ? " (status not queried)" : ""); info.list->nr),
no_query ? _(" (status not queried)") : "");
for_each_string_list(info.list, show_push_info_item, &info); for_each_string_list(info.list, show_push_info_item, &info);
string_list_clear(info.list, 0); string_list_clear(info.list, 0);
@ -1202,10 +1213,10 @@ static int set_head(int argc, const char **argv)
memset(&states, 0, sizeof(states)); memset(&states, 0, sizeof(states));
get_remote_ref_states(argv[0], &states, GET_HEAD_NAMES); get_remote_ref_states(argv[0], &states, GET_HEAD_NAMES);
if (!states.heads.nr) if (!states.heads.nr)
result |= error("Cannot determine remote HEAD"); result |= error(_("Cannot determine remote HEAD"));
else if (states.heads.nr > 1) { else if (states.heads.nr > 1) {
result |= error("Multiple remote HEAD branches. " result |= error(_("Multiple remote HEAD branches. "
"Please choose one explicitly with:"); "Please choose one explicitly with:"));
for (i = 0; i < states.heads.nr; i++) for (i = 0; i < states.heads.nr; i++)
fprintf(stderr, " git remote set-head %s %s\n", fprintf(stderr, " git remote set-head %s %s\n",
argv[0], states.heads.items[i].string); argv[0], states.heads.items[i].string);
@ -1214,7 +1225,7 @@ static int set_head(int argc, const char **argv)
free_remote_ref_states(&states); free_remote_ref_states(&states);
} else if (opt_d && !opt_a && argc == 1) { } else if (opt_d && !opt_a && argc == 1) {
if (delete_ref(buf.buf, NULL, REF_NODEREF)) if (delete_ref(buf.buf, NULL, REF_NODEREF))
result |= error("Could not delete %s", buf.buf); result |= error(_("Could not delete %s"), buf.buf);
} else } else
usage_with_options(builtin_remote_sethead_usage, options); usage_with_options(builtin_remote_sethead_usage, options);
@ -1222,9 +1233,9 @@ static int set_head(int argc, const char **argv)
strbuf_addf(&buf2, "refs/remotes/%s/%s", argv[0], head_name); strbuf_addf(&buf2, "refs/remotes/%s/%s", argv[0], head_name);
/* make sure it's valid */ /* make sure it's valid */
if (!ref_exists(buf2.buf)) if (!ref_exists(buf2.buf))
result |= error("Not a valid ref: %s", buf2.buf); result |= error(_("Not a valid ref: %s"), buf2.buf);
else if (create_symref(buf.buf, buf2.buf, "remote set-head")) else if (create_symref(buf.buf, buf2.buf, "remote set-head"))
result |= error("Could not setup %s", buf.buf); result |= error(_("Could not setup %s"), buf.buf);
if (opt_a) if (opt_a)
printf("%s/HEAD set to %s\n", argv[0], head_name); printf("%s/HEAD set to %s\n", argv[0], head_name);
free(head_name); free(head_name);
@ -1260,18 +1271,18 @@ static int prune_remote(const char *remote, int dry_run)
int result = 0, i; int result = 0, i;
struct ref_states states; struct ref_states states;
const char *dangling_msg = dry_run const char *dangling_msg = dry_run
? " %s will become dangling!\n" ? _(" %s will become dangling!")
: " %s has become dangling!\n"; : _(" %s has become dangling!");
memset(&states, 0, sizeof(states)); memset(&states, 0, sizeof(states));
get_remote_ref_states(remote, &states, GET_REF_STATES); get_remote_ref_states(remote, &states, GET_REF_STATES);
if (states.stale.nr) { if (states.stale.nr) {
printf("Pruning %s\n", remote); printf_ln(_("Pruning %s"), remote);
printf("URL: %s\n", printf_ln(_("URL: %s"),
states.remote->url_nr states.remote->url_nr
? states.remote->url[0] ? states.remote->url[0]
: "(no URL)"); : _("(no URL)"));
} }
for (i = 0; i < states.stale.nr; i++) { for (i = 0; i < states.stale.nr; i++) {
@ -1280,8 +1291,12 @@ static int prune_remote(const char *remote, int dry_run)
if (!dry_run) if (!dry_run)
result |= delete_ref(refname, NULL, 0); result |= delete_ref(refname, NULL, 0);
printf(" * [%s] %s\n", dry_run ? "would prune" : "pruned", if (dry_run)
abbrev_ref(refname, "refs/remotes/")); printf_ln(_(" * [would prune] %s"),
abbrev_ref(refname, "refs/remotes/"));
else
printf_ln(_(" * [pruned] %s"),
abbrev_ref(refname, "refs/remotes/"));
warn_dangling_symref(stdout, dangling_msg, refname); warn_dangling_symref(stdout, dangling_msg, refname);
} }
@ -1369,7 +1384,7 @@ static int set_remote_branches(const char *remotename, const char **branches,
strbuf_addf(&key, "remote.%s.fetch", remotename); strbuf_addf(&key, "remote.%s.fetch", remotename);
if (!remote_is_configured(remotename)) if (!remote_is_configured(remotename))
die("No such remote '%s'", remotename); die(_("No such remote '%s'"), remotename);
remote = remote_get(remotename); remote = remote_get(remotename);
if (!add_mode && remove_all_fetch_refspecs(remotename, key.buf)) { if (!add_mode && remove_all_fetch_refspecs(remotename, key.buf)) {
@ -1396,7 +1411,7 @@ static int set_branches(int argc, const char **argv)
argc = parse_options(argc, argv, NULL, options, argc = parse_options(argc, argv, NULL, options,
builtin_remote_setbranches_usage, 0); builtin_remote_setbranches_usage, 0);
if (argc == 0) { if (argc == 0) {
error("no remote specified"); error(_("no remote specified"));
usage_with_options(builtin_remote_setbranches_usage, options); usage_with_options(builtin_remote_setbranches_usage, options);
} }
argv[argc] = NULL; argv[argc] = NULL;
@ -1429,7 +1444,7 @@ static int set_url(int argc, const char **argv)
PARSE_OPT_KEEP_ARGV0); PARSE_OPT_KEEP_ARGV0);
if (add_mode && delete_mode) if (add_mode && delete_mode)
die("--add --delete doesn't make sense"); die(_("--add --delete doesn't make sense"));
if (argc < 3 || argc > 4 || ((add_mode || delete_mode) && argc != 3)) if (argc < 3 || argc > 4 || ((add_mode || delete_mode) && argc != 3))
usage_with_options(builtin_remote_seturl_usage, options); usage_with_options(builtin_remote_seturl_usage, options);
@ -1443,7 +1458,7 @@ static int set_url(int argc, const char **argv)
oldurl = newurl; oldurl = newurl;
if (!remote_is_configured(remotename)) if (!remote_is_configured(remotename))
die("No such remote '%s'", remotename); die(_("No such remote '%s'"), remotename);
remote = remote_get(remotename); remote = remote_get(remotename);
if (push_mode) { if (push_mode) {
@ -1469,7 +1484,7 @@ static int set_url(int argc, const char **argv)
/* Old URL specified. Demand that one matches. */ /* Old URL specified. Demand that one matches. */
if (regcomp(&old_regex, oldurl, REG_EXTENDED)) if (regcomp(&old_regex, oldurl, REG_EXTENDED))
die("Invalid old URL pattern: %s", oldurl); die(_("Invalid old URL pattern: %s"), oldurl);
for (i = 0; i < urlset_nr; i++) for (i = 0; i < urlset_nr; i++)
if (!regexec(&old_regex, urlset[i], 0, NULL, 0)) if (!regexec(&old_regex, urlset[i], 0, NULL, 0))
@ -1477,9 +1492,9 @@ static int set_url(int argc, const char **argv)
else else
negative_matches++; negative_matches++;
if (!delete_mode && !matches) if (!delete_mode && !matches)
die("No such URL found: %s", oldurl); die(_("No such URL found: %s"), oldurl);
if (delete_mode && !negative_matches && !push_mode) if (delete_mode && !negative_matches && !push_mode)
die("Will not delete all non-push URLs"); die(_("Will not delete all non-push URLs"));
regfree(&old_regex); regfree(&old_regex);
@ -1580,7 +1595,7 @@ int cmd_remote(int argc, const char **argv, const char *prefix)
else if (!strcmp(argv[0], "update")) else if (!strcmp(argv[0], "update"))
result = update(argc, argv); result = update(argc, argv);
else { else {
error("Unknown subcommand: %s", argv[0]); error(_("Unknown subcommand: %s"), argv[0]);
usage_with_options(builtin_remote_usage, options); usage_with_options(builtin_remote_usage, options);
} }

38
bundle.c
View File

@ -33,7 +33,7 @@ static int parse_bundle_header(int fd, struct bundle_header *header,
if (strbuf_getwholeline_fd(&buf, fd, '\n') || if (strbuf_getwholeline_fd(&buf, fd, '\n') ||
strcmp(buf.buf, bundle_signature)) { strcmp(buf.buf, bundle_signature)) {
if (report_path) if (report_path)
error("'%s' does not look like a v2 bundle file", error(_("'%s' does not look like a v2 bundle file"),
report_path); report_path);
status = -1; status = -1;
goto abort; goto abort;
@ -60,7 +60,7 @@ static int parse_bundle_header(int fd, struct bundle_header *header,
(40 <= buf.len && !isspace(buf.buf[40])) || (40 <= buf.len && !isspace(buf.buf[40])) ||
(!is_prereq && buf.len <= 40)) { (!is_prereq && buf.len <= 40)) {
if (report_path) if (report_path)
error("unrecognized header: %s%s (%d)", error(_("unrecognized header: %s%s (%d)"),
(is_prereq ? "-" : ""), buf.buf, (int)buf.len); (is_prereq ? "-" : ""), buf.buf, (int)buf.len);
status = -1; status = -1;
break; break;
@ -86,7 +86,7 @@ int read_bundle_header(const char *path, struct bundle_header *header)
int fd = open(path, O_RDONLY); int fd = open(path, O_RDONLY);
if (fd < 0) if (fd < 0)
return error("could not open '%s'", path); return error(_("could not open '%s'"), path);
return parse_bundle_header(fd, header, path); return parse_bundle_header(fd, header, path);
} }
@ -137,7 +137,7 @@ int verify_bundle(struct bundle_header *header, int verbose)
struct object_array refs; struct object_array refs;
struct commit *commit; struct commit *commit;
int i, ret = 0, req_nr; int i, ret = 0, req_nr;
const char *message = "Repository lacks these prerequisite commits:"; const char *message = _("Repository lacks these prerequisite commits:");
init_revisions(&revs, NULL); init_revisions(&revs, NULL);
for (i = 0; i < p->nr; i++) { for (i = 0; i < p->nr; i++) {
@ -161,7 +161,7 @@ int verify_bundle(struct bundle_header *header, int verbose)
revs.leak_pending = 1; revs.leak_pending = 1;
if (prepare_revision_walk(&revs)) if (prepare_revision_walk(&revs))
die("revision walk setup failed"); die(_("revision walk setup failed"));
i = req_nr; i = req_nr;
while (i && (commit = get_revision(&revs))) while (i && (commit = get_revision(&revs)))
@ -183,12 +183,16 @@ int verify_bundle(struct bundle_header *header, int verbose)
struct ref_list *r; struct ref_list *r;
r = &header->references; r = &header->references;
printf("The bundle contains %d ref%s\n", printf_ln(Q_("The bundle contains %d ref",
r->nr, (1 < r->nr) ? "s" : ""); "The bundle contains %d refs",
r->nr),
r->nr);
list_refs(r, 0, NULL); list_refs(r, 0, NULL);
r = &header->prerequisites; r = &header->prerequisites;
printf("The bundle requires these %d ref%s\n", printf_ln(Q_("The bundle requires this ref",
r->nr, (1 < r->nr) ? "s" : ""); "The bundle requires these %d refs",
r->nr),
r->nr);
list_refs(r, 0, NULL); list_refs(r, 0, NULL);
} }
return ret; return ret;
@ -283,13 +287,13 @@ int create_bundle(struct bundle_header *header, const char *path,
strbuf_release(&buf); strbuf_release(&buf);
fclose(rls_fout); fclose(rls_fout);
if (finish_command(&rls)) if (finish_command(&rls))
return error("rev-list died"); return error(_("rev-list died"));
/* write references */ /* write references */
argc = setup_revisions(argc, argv, &revs, NULL); argc = setup_revisions(argc, argv, &revs, NULL);
if (argc > 1) if (argc > 1)
return error("unrecognized argument: %s", argv[1]); return error(_("unrecognized argument: %s"), argv[1]);
object_array_remove_duplicates(&revs.pending); object_array_remove_duplicates(&revs.pending);
@ -324,7 +328,7 @@ int create_bundle(struct bundle_header *header, const char *path,
* constraints. * constraints.
*/ */
if (!(e->item->flags & SHOWN) && e->item->type == OBJ_COMMIT) { if (!(e->item->flags & SHOWN) && e->item->type == OBJ_COMMIT) {
warning("ref '%s' is excluded by the rev-list options", warning(_("ref '%s' is excluded by the rev-list options"),
e->name); e->name);
free(ref); free(ref);
continue; continue;
@ -369,7 +373,7 @@ int create_bundle(struct bundle_header *header, const char *path,
free(ref); free(ref);
} }
if (!ref_count) if (!ref_count)
die ("Refusing to create empty bundle."); die(_("Refusing to create empty bundle."));
/* end header */ /* end header */
write_or_die(bundle_fd, "\n", 1); write_or_die(bundle_fd, "\n", 1);
@ -387,7 +391,7 @@ int create_bundle(struct bundle_header *header, const char *path,
rls.out = bundle_fd; rls.out = bundle_fd;
rls.git_cmd = 1; rls.git_cmd = 1;
if (start_command(&rls)) if (start_command(&rls))
return error("Could not spawn pack-objects"); return error(_("Could not spawn pack-objects"));
/* /*
* start_command closed bundle_fd if it was > 1 * start_command closed bundle_fd if it was > 1
@ -405,10 +409,10 @@ int create_bundle(struct bundle_header *header, const char *path,
} }
close(rls.in); close(rls.in);
if (finish_command(&rls)) if (finish_command(&rls))
return error ("pack-objects died"); return error(_("pack-objects died"));
if (!bundle_to_stdout) { if (!bundle_to_stdout) {
if (commit_lock_file(&lock)) if (commit_lock_file(&lock))
die_errno("cannot create '%s'", path); die_errno(_("cannot create '%s'"), path);
} }
return 0; return 0;
} }
@ -430,6 +434,6 @@ int unbundle(struct bundle_header *header, int bundle_fd, int flags)
ip.no_stdout = 1; ip.no_stdout = 1;
ip.git_cmd = 1; ip.git_cmd = 1;
if (run_command(&ip)) if (run_command(&ip))
return error("index-pack died"); return error(_("index-pack died"));
return 0; return 0;
} }

6
cache.h
View File

@ -877,10 +877,8 @@ enum date_mode {
}; };
const char *show_date(unsigned long time, int timezone, enum date_mode mode); const char *show_date(unsigned long time, int timezone, enum date_mode mode);
const char *show_date_relative(unsigned long time, int tz, void show_date_relative(unsigned long time, int tz, const struct timeval *now,
const struct timeval *now, struct strbuf *timebuf);
char *timebuf,
size_t timebuf_size);
int parse_date(const char *date, char *buf, int bufsize); int parse_date(const char *date, char *buf, int bufsize);
int parse_date_basic(const char *date, unsigned long *timestamp, int *offset); int parse_date_basic(const char *date, unsigned long *timestamp, int *offset);
void datestamp(char *buf, int bufsize); void datestamp(char *buf, int bufsize);

95
date.c
View File

@ -86,83 +86,98 @@ static int local_tzoffset(unsigned long time)
return offset * eastwest; return offset * eastwest;
} }
const char *show_date_relative(unsigned long time, int tz, void show_date_relative(unsigned long time, int tz,
const struct timeval *now, const struct timeval *now,
char *timebuf, struct strbuf *timebuf)
size_t timebuf_size)
{ {
unsigned long diff; unsigned long diff;
if (now->tv_sec < time) if (now->tv_sec < time) {
return "in the future"; strbuf_addstr(timebuf, _("in the future"));
return;
}
diff = now->tv_sec - time; diff = now->tv_sec - time;
if (diff < 90) { if (diff < 90) {
snprintf(timebuf, timebuf_size, "%lu seconds ago", diff); strbuf_addf(timebuf,
return timebuf; Q_("%lu second ago", "%lu seconds ago", diff), diff);
return;
} }
/* Turn it into minutes */ /* Turn it into minutes */
diff = (diff + 30) / 60; diff = (diff + 30) / 60;
if (diff < 90) { if (diff < 90) {
snprintf(timebuf, timebuf_size, "%lu minutes ago", diff); strbuf_addf(timebuf,
return timebuf; Q_("%lu minute ago", "%lu minutes ago", diff), diff);
return;
} }
/* Turn it into hours */ /* Turn it into hours */
diff = (diff + 30) / 60; diff = (diff + 30) / 60;
if (diff < 36) { if (diff < 36) {
snprintf(timebuf, timebuf_size, "%lu hours ago", diff); strbuf_addf(timebuf,
return timebuf; Q_("%lu hour ago", "%lu hours ago", diff), diff);
return;
} }
/* We deal with number of days from here on */ /* We deal with number of days from here on */
diff = (diff + 12) / 24; diff = (diff + 12) / 24;
if (diff < 14) { if (diff < 14) {
snprintf(timebuf, timebuf_size, "%lu days ago", diff); strbuf_addf(timebuf,
return timebuf; Q_("%lu day ago", "%lu days ago", diff), diff);
return;
} }
/* Say weeks for the past 10 weeks or so */ /* Say weeks for the past 10 weeks or so */
if (diff < 70) { if (diff < 70) {
snprintf(timebuf, timebuf_size, "%lu weeks ago", (diff + 3) / 7); strbuf_addf(timebuf,
return timebuf; Q_("%lu week ago", "%lu weeks ago", (diff + 3) / 7),
(diff + 3) / 7);
return;
} }
/* Say months for the past 12 months or so */ /* Say months for the past 12 months or so */
if (diff < 365) { if (diff < 365) {
snprintf(timebuf, timebuf_size, "%lu months ago", (diff + 15) / 30); strbuf_addf(timebuf,
return timebuf; Q_("%lu month ago", "%lu months ago", (diff + 15) / 30),
(diff + 15) / 30);
return;
} }
/* Give years and months for 5 years or so */ /* Give years and months for 5 years or so */
if (diff < 1825) { if (diff < 1825) {
unsigned long totalmonths = (diff * 12 * 2 + 365) / (365 * 2); unsigned long totalmonths = (diff * 12 * 2 + 365) / (365 * 2);
unsigned long years = totalmonths / 12; unsigned long years = totalmonths / 12;
unsigned long months = totalmonths % 12; unsigned long months = totalmonths % 12;
int n; if (months) {
n = snprintf(timebuf, timebuf_size, "%lu year%s", struct strbuf sb = STRBUF_INIT;
years, (years > 1 ? "s" : "")); strbuf_addf(&sb, Q_("%lu year", "%lu years", years), years);
if (months) /* TRANSLATORS: "%s" is "<n> years" */
snprintf(timebuf + n, timebuf_size - n, strbuf_addf(timebuf,
", %lu month%s ago", Q_("%s, %lu month ago", "%s, %lu months ago", months),
months, (months > 1 ? "s" : "")); sb.buf, months);
else strbuf_release(&sb);
snprintf(timebuf + n, timebuf_size - n, " ago"); } else
return timebuf; strbuf_addf(timebuf,
Q_("%lu year ago", "%lu years ago", years), years);
return;
} }
/* Otherwise, just years. Centuries is probably overkill. */ /* Otherwise, just years. Centuries is probably overkill. */
snprintf(timebuf, timebuf_size, "%lu years ago", (diff + 183) / 365); strbuf_addf(timebuf,
return timebuf; Q_("%lu year ago", "%lu years ago", (diff + 183) / 365),
(diff + 183) / 365);
} }
const char *show_date(unsigned long time, int tz, enum date_mode mode) const char *show_date(unsigned long time, int tz, enum date_mode mode)
{ {
struct tm *tm; struct tm *tm;
static char timebuf[200]; static struct strbuf timebuf = STRBUF_INIT;
if (mode == DATE_RAW) { if (mode == DATE_RAW) {
snprintf(timebuf, sizeof(timebuf), "%lu %+05d", time, tz); strbuf_reset(&timebuf);
return timebuf; strbuf_addf(&timebuf, "%lu %+05d", time, tz);
return timebuf.buf;
} }
if (mode == DATE_RELATIVE) { if (mode == DATE_RELATIVE) {
struct timeval now; struct timeval now;
strbuf_reset(&timebuf);
gettimeofday(&now, NULL); gettimeofday(&now, NULL);
return show_date_relative(time, tz, &now, show_date_relative(time, tz, &now, &timebuf);
timebuf, sizeof(timebuf)); return timebuf.buf;
} }
if (mode == DATE_LOCAL) if (mode == DATE_LOCAL)
@ -171,23 +186,25 @@ const char *show_date(unsigned long time, int tz, enum date_mode mode)
tm = time_to_tm(time, tz); tm = time_to_tm(time, tz);
if (!tm) if (!tm)
return NULL; return NULL;
strbuf_reset(&timebuf);
if (mode == DATE_SHORT) if (mode == DATE_SHORT)
sprintf(timebuf, "%04d-%02d-%02d", tm->tm_year + 1900, strbuf_addf(&timebuf, "%04d-%02d-%02d", tm->tm_year + 1900,
tm->tm_mon + 1, tm->tm_mday); tm->tm_mon + 1, tm->tm_mday);
else if (mode == DATE_ISO8601) else if (mode == DATE_ISO8601)
sprintf(timebuf, "%04d-%02d-%02d %02d:%02d:%02d %+05d", strbuf_addf(&timebuf, "%04d-%02d-%02d %02d:%02d:%02d %+05d",
tm->tm_year + 1900, tm->tm_year + 1900,
tm->tm_mon + 1, tm->tm_mon + 1,
tm->tm_mday, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_hour, tm->tm_min, tm->tm_sec,
tz); tz);
else if (mode == DATE_RFC2822) else if (mode == DATE_RFC2822)
sprintf(timebuf, "%.3s, %d %.3s %d %02d:%02d:%02d %+05d", strbuf_addf(&timebuf, "%.3s, %d %.3s %d %02d:%02d:%02d %+05d",
weekday_names[tm->tm_wday], tm->tm_mday, weekday_names[tm->tm_wday], tm->tm_mday,
month_names[tm->tm_mon], tm->tm_year + 1900, month_names[tm->tm_mon], tm->tm_year + 1900,
tm->tm_hour, tm->tm_min, tm->tm_sec, tz); tm->tm_hour, tm->tm_min, tm->tm_sec, tz);
else else
sprintf(timebuf, "%.3s %.3s %d %02d:%02d:%02d %d%c%+05d", strbuf_addf(&timebuf, "%.3s %.3s %d %02d:%02d:%02d %d%c%+05d",
weekday_names[tm->tm_wday], weekday_names[tm->tm_wday],
month_names[tm->tm_mon], month_names[tm->tm_mon],
tm->tm_mday, tm->tm_mday,
@ -195,7 +212,7 @@ const char *show_date(unsigned long time, int tz, enum date_mode mode)
tm->tm_year + 1900, tm->tm_year + 1900,
(mode == DATE_LOCAL) ? 0 : ' ', (mode == DATE_LOCAL) ? 0 : ' ',
tz); tz);
return timebuf; return timebuf.buf;
} }
/* /*

2
generate-cmdlist.sh
View File

@ -16,7 +16,7 @@ do
/^NAME/,/git-'"$cmd"'/H /^NAME/,/git-'"$cmd"'/H
${ ${
x x
s/.*git-'"$cmd"' - \(.*\)/ {"'"$cmd"'", "\1"},/ s/.*git-'"$cmd"' - \(.*\)/ {"'"$cmd"'", N_("\1")},/
p p
}' "Documentation/git-$cmd.txt" }' "Documentation/git-$cmd.txt"
done done

2
git.c
View File

@ -13,7 +13,7 @@ const char git_usage_string[] =
" <command> [<args>]"; " <command> [<args>]";
const char git_more_info_string[] = const char git_more_info_string[] =
"See 'git help <command>' for more information on a specific command."; N_("See 'git help <command>' for more information on a specific command.");
static struct startup_info git_startup_info; static struct startup_info git_startup_info;
static int use_pager = -1; static int use_pager = -1;

30
help.c
View File

@ -203,8 +203,7 @@ void load_command_list(const char *prefix,
exclude_cmds(other_cmds, main_cmds); exclude_cmds(other_cmds, main_cmds);
} }
void list_commands(const char *title, struct cmdnames *main_cmds, void list_commands(struct cmdnames *main_cmds, struct cmdnames *other_cmds)
struct cmdnames *other_cmds)
{ {
int i, longest = 0; int i, longest = 0;
@ -217,18 +216,14 @@ void list_commands(const char *title, struct cmdnames *main_cmds,
if (main_cmds->cnt) { if (main_cmds->cnt) {
const char *exec_path = git_exec_path(); const char *exec_path = git_exec_path();
printf("available %s in '%s'\n", title, exec_path); printf_ln(_("available git commands in '%s'"), exec_path);
printf("----------------");
mput_char('-', strlen(title) + strlen(exec_path));
putchar('\n'); putchar('\n');
pretty_print_string_list(main_cmds, longest); pretty_print_string_list(main_cmds, longest);
putchar('\n'); putchar('\n');
} }
if (other_cmds->cnt) { if (other_cmds->cnt) {
printf("%s available from elsewhere on your $PATH\n", title); printf_ln(_("git commands available from elsewhere on your $PATH"));
printf("---------------------------------------");
mput_char('-', strlen(title));
putchar('\n'); putchar('\n');
pretty_print_string_list(other_cmds, longest); pretty_print_string_list(other_cmds, longest);
putchar('\n'); putchar('\n');
@ -341,7 +336,7 @@ const char *help_unknown_cmd(const char *cmd)
sizeof(*main_cmds.names), levenshtein_compare); sizeof(*main_cmds.names), levenshtein_compare);
if (!main_cmds.cnt) if (!main_cmds.cnt)
die ("Uh oh. Your system reports no Git commands at all."); die(_("Uh oh. Your system reports no Git commands at all."));
/* skip and count prefix matches */ /* skip and count prefix matches */
for (n = 0; n < main_cmds.cnt && !main_cmds.names[n]->len; n++) for (n = 0; n < main_cmds.cnt && !main_cmds.names[n]->len; n++)
@ -362,23 +357,26 @@ const char *help_unknown_cmd(const char *cmd)
const char *assumed = main_cmds.names[0]->name; const char *assumed = main_cmds.names[0]->name;
main_cmds.names[0] = NULL; main_cmds.names[0] = NULL;
clean_cmdnames(&main_cmds); clean_cmdnames(&main_cmds);
fprintf(stderr, "WARNING: You called a Git command named '%s', " fprintf_ln(stderr,
"which does not exist.\n" _("WARNING: You called a Git command named '%s', "
"Continuing under the assumption that you meant '%s'\n", "which does not exist.\n"
"Continuing under the assumption that you meant '%s'"),
cmd, assumed); cmd, assumed);
if (autocorrect > 0) { if (autocorrect > 0) {
fprintf(stderr, "in %0.1f seconds automatically...\n", fprintf_ln(stderr, _("in %0.1f seconds automatically..."),
(float)autocorrect/10.0); (float)autocorrect/10.0);
poll(NULL, 0, autocorrect * 100); poll(NULL, 0, autocorrect * 100);
} }
return assumed; return assumed;
} }
fprintf(stderr, "git: '%s' is not a git command. See 'git --help'.\n", cmd); fprintf_ln(stderr, _("git: '%s' is not a git command. See 'git --help'."), cmd);
if (SIMILAR_ENOUGH(best_similarity)) { if (SIMILAR_ENOUGH(best_similarity)) {
fprintf(stderr, "\nDid you mean %s?\n", fprintf_ln(stderr,
n < 2 ? "this": "one of these"); Q_("\nDid you mean this?",
"\nDid you mean one of these?",
n));
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
fprintf(stderr, "\t%s\n", main_cmds.names[i]->name); fprintf(stderr, "\t%s\n", main_cmds.names[i]->name);

3
help.h
View File

@ -25,8 +25,7 @@ extern void add_cmdname(struct cmdnames *cmds, const char *name, int len);
/* Here we require that excludes is a sorted list. */ /* Here we require that excludes is a sorted list. */
extern void exclude_cmds(struct cmdnames *cmds, struct cmdnames *excludes); extern void exclude_cmds(struct cmdnames *cmds, struct cmdnames *excludes);
extern int is_in_cmdlist(struct cmdnames *cmds, const char *name); extern int is_in_cmdlist(struct cmdnames *cmds, const char *name);
extern void list_commands(const char *title, extern void list_commands(struct cmdnames *main_cmds,
struct cmdnames *main_cmds,
struct cmdnames *other_cmds); struct cmdnames *other_cmds);
#endif /* HELP_H */ #endif /* HELP_H */

1
refs.c
View File

@ -1126,6 +1126,7 @@ static int warn_if_dangling_symref(const char *refname, const unsigned char *sha
return 0; return 0;
fprintf(d->fp, d->msg_fmt, refname); fprintf(d->fp, d->msg_fmt, refname);
fputc('\n', d->fp);
return 0; return 0;
} }

33
strbuf.c
View File

@ -464,3 +464,36 @@ void strbuf_addstr_urlencode(struct strbuf *sb, const char *s,
{ {
strbuf_add_urlencode(sb, s, strlen(s), reserved); strbuf_add_urlencode(sb, s, strlen(s), reserved);
} }
void strbuf_addf_ln(struct strbuf *sb, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
strbuf_vaddf(sb, fmt, ap);
va_end(ap);
strbuf_addch(sb, '\n');
}
int printf_ln(const char *fmt, ...)
{
int ret;
va_list ap;
va_start(ap, fmt);
ret = vprintf(fmt, ap);
va_end(ap);
if (ret < 0 || putchar('\n') == EOF)
return -1;
return ret + 1;
}
int fprintf_ln(FILE *fp, const char *fmt, ...)
{
int ret;
va_list ap;
va_start(ap, fmt);
ret = vfprintf(fp, fmt, ap);
va_end(ap);
if (ret < 0 || putc('\n', fp) == EOF)
return -1;
return ret + 1;
}

7
strbuf.h
View File

@ -99,6 +99,8 @@ __attribute__((format (printf,2,3)))
extern void strbuf_addf(struct strbuf *sb, const char *fmt, ...); extern void strbuf_addf(struct strbuf *sb, const char *fmt, ...);
__attribute__((format (printf,2,0))) __attribute__((format (printf,2,0)))
extern void strbuf_vaddf(struct strbuf *sb, const char *fmt, va_list ap); extern void strbuf_vaddf(struct strbuf *sb, const char *fmt, va_list ap);
__attribute__((format (printf,2,3)))
extern void strbuf_addf_ln(struct strbuf *sb, const char *fmt, ...);
extern void strbuf_add_lines(struct strbuf *sb, const char *prefix, const char *buf, size_t size); extern void strbuf_add_lines(struct strbuf *sb, const char *prefix, const char *buf, size_t size);
@ -129,4 +131,9 @@ extern void strbuf_add_urlencode(struct strbuf *, const char *, size_t,
extern void strbuf_addstr_urlencode(struct strbuf *, const char *, extern void strbuf_addstr_urlencode(struct strbuf *, const char *,
int reserved); int reserved);
__attribute__((format (printf,1,2)))
extern int printf_ln(const char *fmt, ...);
__attribute__((format (printf,2,3)))
extern int fprintf_ln(FILE *fp, const char *fmt, ...);
#endif /* STRBUF_H */ #endif /* STRBUF_H */

7
test-date.c
View File

@ -7,13 +7,14 @@ static const char *usage_msg = "\n"
static void show_dates(char **argv, struct timeval *now) static void show_dates(char **argv, struct timeval *now)
{ {
char buf[128]; struct strbuf buf = STRBUF_INIT;
for (; *argv; argv++) { for (; *argv; argv++) {
time_t t = atoi(*argv); time_t t = atoi(*argv);
show_date_relative(t, 0, now, buf, sizeof(buf)); show_date_relative(t, 0, now, &buf);
printf("%s -> %s\n", *argv, buf); printf("%s -> %s\n", *argv, buf.buf);
} }
strbuf_release(&buf);
} }
static void parse_dates(char **argv, struct timeval *now) static void parse_dates(char **argv, struct timeval *now)