kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

Merge branch 'cc/fast-import-export-i18n-cleanup' 

Messages from fast-import/export are now marked for i18n.

* cc/fast-import-export-i18n-cleanup:
  gpg-interface: mark a string for translation
  fast-import: mark strings for translation
  fast-export: mark strings for translation
  gpg-interface: use left shift to define GPG_VERIFY_*
  gpg-interface: simplify ssh fingerprint parsing
main
Junio C Hamano 2025-11-06 15:17:01 -08:00
parent 5db9d35a28 93cef5bda5
commit e569dced68
5 changed files with 195 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
builtin/fast-export.c
View File

@ -65,7 +65,7 @@ static int parse_opt_sign_mode(const struct option *opt,
return 0; return 0;


if (parse_sign_mode(arg, val)) if (parse_sign_mode(arg, val))
return error("Unknown %s mode: %s", opt->long_name, arg); return error(_("unknown %s mode: %s"), opt->long_name, arg);


return 0; return 0;
} }
@ -82,7 +82,7 @@ static int parse_opt_tag_of_filtered_mode(const struct option *opt,
else if (!strcmp(arg, "rewrite")) else if (!strcmp(arg, "rewrite"))
*val = REWRITE; *val = REWRITE;
else else
return error("Unknown tag-of-filtered mode: %s", arg); return error(_("unknown tag-of-filtered mode: %s"), arg);
return 0; return 0;
} }


@ -107,7 +107,7 @@ static int parse_opt_reencode_mode(const struct option *opt,
if (!strcasecmp(arg, "abort")) if (!strcasecmp(arg, "abort"))
*val = REENCODE_ABORT; *val = REENCODE_ABORT;
else else
return error("Unknown reencoding mode: %s", arg); return error(_("unknown reencoding mode: %s"), arg);
} }


return 0; return 0;
@ -318,16 +318,16 @@ static void export_blob(const struct object_id *oid)
} else { } else {
buf = odb_read_object(the_repository->objects, oid, &type, &size); buf = odb_read_object(the_repository->objects, oid, &type, &size);
if (!buf) if (!buf)
die("could not read blob %s", oid_to_hex(oid)); die(_("could not read blob %s"), oid_to_hex(oid));
if (check_object_signature(the_repository, oid, buf, size, if (check_object_signature(the_repository, oid, buf, size,
type) < 0) type) < 0)
die("oid mismatch in blob %s", oid_to_hex(oid)); die(_("oid mismatch in blob %s"), oid_to_hex(oid));
object = parse_object_buffer(the_repository, oid, type, object = parse_object_buffer(the_repository, oid, type,
size, buf, &eaten); size, buf, &eaten);
} }


if (!object) if (!object)
die("Could not read blob %s", oid_to_hex(oid)); die(_("could not read blob %s"), oid_to_hex(oid));


mark_next_object(object); mark_next_object(object);


@ -336,7 +336,7 @@ static void export_blob(const struct object_id *oid)
printf("original-oid %s\n", oid_to_hex(oid)); printf("original-oid %s\n", oid_to_hex(oid));
printf("data %"PRIuMAX"\n", (uintmax_t)size); printf("data %"PRIuMAX"\n", (uintmax_t)size);
if (size && fwrite(buf, size, 1, stdout) != 1) if (size && fwrite(buf, size, 1, stdout) != 1)
die_errno("could not write blob '%s'", oid_to_hex(oid)); die_errno(_("could not write blob '%s'"), oid_to_hex(oid));
printf("\n"); printf("\n");


show_progress(); show_progress();
@ -499,10 +499,10 @@ static void show_filemodify(struct diff_queue_struct *q,
break; break;


default: default:
die("Unexpected comparison status '%c' for %s, %s", die(_("unexpected comparison status '%c' for %s, %s"),
q->queue[i]->status, q->queue[i]->status,
ospec->path ? ospec->path : "none", ospec->path ? ospec->path : _("none"),
spec->path ? spec->path : "none"); spec->path ? spec->path : _("none"));
} }
} }
} }
@ -699,14 +699,14 @@ static void handle_commit(struct commit *commit, struct rev_info *rev,


author = strstr(commit_buffer_cursor, "\nauthor "); author = strstr(commit_buffer_cursor, "\nauthor ");
if (!author) if (!author)
die("could not find author in commit %s", die(_("could not find author in commit %s"),
oid_to_hex(&commit->object.oid)); oid_to_hex(&commit->object.oid));
author++; author++;
commit_buffer_cursor = author_end = strchrnul(author, '\n'); commit_buffer_cursor = author_end = strchrnul(author, '\n');


committer = strstr(commit_buffer_cursor, "\ncommitter "); committer = strstr(commit_buffer_cursor, "\ncommitter ");
if (!committer) if (!committer)
die("could not find committer in commit %s", die(_("could not find committer in commit %s"),
oid_to_hex(&commit->object.oid)); oid_to_hex(&commit->object.oid));
committer++; committer++;
commit_buffer_cursor = committer_end = strchrnul(committer, '\n'); commit_buffer_cursor = committer_end = strchrnul(committer, '\n');
@ -781,8 +781,8 @@ static void handle_commit(struct commit *commit, struct rev_info *rev,
case REENCODE_NO: case REENCODE_NO:
break; break;
case REENCODE_ABORT: case REENCODE_ABORT:
die("Encountered commit-specific encoding %.*s in commit " die(_("encountered commit-specific encoding %.*s in commit "
"%s; use --reencode=[yes|no] to handle it", "%s; use --reencode=[yes|no] to handle it"),
(int)encoding_len, encoding, (int)encoding_len, encoding,
oid_to_hex(&commit->object.oid)); oid_to_hex(&commit->object.oid));
} }
@ -798,11 +798,11 @@ static void handle_commit(struct commit *commit, struct rev_info *rev,
if (signatures.nr) { if (signatures.nr) {
switch (signed_commit_mode) { switch (signed_commit_mode) {
case SIGN_ABORT: case SIGN_ABORT:
die("encountered signed commit %s; use " die(_("encountered signed commit %s; use "
"--signed-commits=<mode> to handle it", "--signed-commits=<mode> to handle it"),
oid_to_hex(&commit->object.oid)); oid_to_hex(&commit->object.oid));
case SIGN_WARN_VERBATIM: case SIGN_WARN_VERBATIM:
warning("exporting %"PRIuMAX" signature(s) for commit %s", warning(_("exporting %"PRIuMAX" signature(s) for commit %s"),
(uintmax_t)signatures.nr, oid_to_hex(&commit->object.oid)); (uintmax_t)signatures.nr, oid_to_hex(&commit->object.oid));
/* fallthru */ /* fallthru */
case SIGN_VERBATIM: case SIGN_VERBATIM:
@ -812,7 +812,7 @@ static void handle_commit(struct commit *commit, struct rev_info *rev,
} }
break; break;
case SIGN_WARN_STRIP: case SIGN_WARN_STRIP:
warning("stripping signature(s) from commit %s", warning(_("stripping signature(s) from commit %s"),
oid_to_hex(&commit->object.oid)); oid_to_hex(&commit->object.oid));
/* fallthru */ /* fallthru */
case SIGN_STRIP: case SIGN_STRIP:
@ -890,7 +890,8 @@ static void handle_tag(const char *name, struct tag *tag)
tagged = ((struct tag *)tagged)->tagged; tagged = ((struct tag *)tagged)->tagged;
} }
if (tagged->type == OBJ_TREE) { if (tagged->type == OBJ_TREE) {
warning("Omitting tag %s,\nsince tags of trees (or tags of tags of trees, etc.) are not supported.", warning(_("omitting tag %s,\nsince tags of trees (or tags "
"of tags of trees, etc.) are not supported."),
oid_to_hex(&tag->object.oid)); oid_to_hex(&tag->object.oid));
return; return;
} }
@ -898,7 +899,7 @@ static void handle_tag(const char *name, struct tag *tag)
buf = odb_read_object(the_repository->objects, &tag->object.oid, buf = odb_read_object(the_repository->objects, &tag->object.oid,
&type, &size); &type, &size);
if (!buf) if (!buf)
die("could not read tag %s", oid_to_hex(&tag->object.oid)); die(_("could not read tag %s"), oid_to_hex(&tag->object.oid));
message = memmem(buf, size, "\n\n", 2); message = memmem(buf, size, "\n\n", 2);
if (message) { if (message) {
message += 2; message += 2;
@ -935,17 +936,17 @@ static void handle_tag(const char *name, struct tag *tag)
if (sig_offset < message_size) if (sig_offset < message_size)
switch (signed_tag_mode) { switch (signed_tag_mode) {
case SIGN_ABORT: case SIGN_ABORT:
die("encountered signed tag %s; use " die(_("encountered signed tag %s; use "
"--signed-tags=<mode> to handle it", "--signed-tags=<mode> to handle it"),
oid_to_hex(&tag->object.oid)); oid_to_hex(&tag->object.oid));
case SIGN_WARN_VERBATIM: case SIGN_WARN_VERBATIM:
warning("exporting signed tag %s", warning(_("exporting signed tag %s"),
oid_to_hex(&tag->object.oid)); oid_to_hex(&tag->object.oid));
/* fallthru */ /* fallthru */
case SIGN_VERBATIM: case SIGN_VERBATIM:
break; break;
case SIGN_WARN_STRIP: case SIGN_WARN_STRIP:
warning("stripping signature from tag %s", warning(_("stripping signature from tag %s"),
oid_to_hex(&tag->object.oid)); oid_to_hex(&tag->object.oid));
/* fallthru */ /* fallthru */
case SIGN_STRIP: case SIGN_STRIP:
@ -960,8 +961,8 @@ static void handle_tag(const char *name, struct tag *tag)
if (!tagged_mark) { if (!tagged_mark) {
switch (tag_of_filtered_mode) { switch (tag_of_filtered_mode) {
case TAG_FILTERING_ABORT: case TAG_FILTERING_ABORT:
die("tag %s tags unexported object; use " die(_("tag %s tags unexported object; use "
"--tag-of-filtered-object=<mode> to handle it", "--tag-of-filtered-object=<mode> to handle it"),
oid_to_hex(&tag->object.oid)); oid_to_hex(&tag->object.oid));
case DROP: case DROP:
/* Ignore this tag altogether */ /* Ignore this tag altogether */
@ -969,7 +970,7 @@ static void handle_tag(const char *name, struct tag *tag)
return; return;
case REWRITE: case REWRITE:
if (tagged->type == OBJ_TAG && !mark_tags) { if (tagged->type == OBJ_TAG && !mark_tags) {
die(_("Error: Cannot export nested tags unless --mark-tags is specified.")); die(_("cannot export nested tags unless --mark-tags is specified."));
} else if (tagged->type == OBJ_COMMIT) { } else if (tagged->type == OBJ_COMMIT) {
p = rewrite_commit((struct commit *)tagged); p = rewrite_commit((struct commit *)tagged);
if (!p) { if (!p) {
@ -1025,7 +1026,7 @@ static struct commit *get_commit(struct rev_cmdline_entry *e, const char *full_n
tag = (struct tag *)tag->tagged; tag = (struct tag *)tag->tagged;
} }
if (!tag) if (!tag)
die("Tag %s points nowhere?", e->name); die(_("tag %s points nowhere?"), e->name);
return (struct commit *)tag; return (struct commit *)tag;
} }
default: default:
@ -1063,7 +1064,7 @@ static void get_tags_and_duplicates(struct rev_cmdline_info *info)


commit = get_commit(e, full_name); commit = get_commit(e, full_name);
if (!commit) { if (!commit) {
warning("%s: Unexpected object of type %s, skipping.", warning(_("%s: unexpected object of type %s, skipping."),
e->name, e->name,
type_name(e->item->type)); type_name(e->item->type));
free(full_name); free(full_name);
@ -1078,7 +1079,7 @@ static void get_tags_and_duplicates(struct rev_cmdline_info *info)
free(full_name); free(full_name);
continue; continue;
default: /* OBJ_TAG (nested tags) is already handled */ default: /* OBJ_TAG (nested tags) is already handled */
warning("Tag points to object of unexpected type %s, skipping.", warning(_("tag points to object of unexpected type %s, skipping."),
type_name(commit->object.type)); type_name(commit->object.type));
free(full_name); free(full_name);
continue; continue;
@ -1174,7 +1175,7 @@ static void export_marks(char *file)


f = fopen_for_writing(file); f = fopen_for_writing(file);
if (!f) if (!f)
die_errno("Unable to open marks file %s for writing.", file); die_errno(_("unable to open marks file %s for writing."), file);


for (i = 0; i < idnums.size; i++) { for (i = 0; i < idnums.size; i++) {
if (deco->base && deco->base->type == 1) { if (deco->base && deco->base->type == 1) {
@ -1191,7 +1192,7 @@ static void export_marks(char *file)
e |= ferror(f); e |= ferror(f);
e |= fclose(f); e |= fclose(f);
if (e) if (e)
error("Unable to write marks file %s.", file); error(_("unable to write marks file %s."), file);
} }


static void import_marks(char *input_file, int check_exists) static void import_marks(char *input_file, int check_exists)
@ -1214,20 +1215,20 @@ static void import_marks(char *input_file, int check_exists)


line_end = strchr(line, '\n'); line_end = strchr(line, '\n');
if (line[0] != ':' || !line_end) if (line[0] != ':' || !line_end)
die("corrupt mark line: %s", line); die(_("corrupt mark line: %s"), line);
*line_end = '\0'; *line_end = '\0';


mark = strtoumax(line + 1, &mark_end, 10); mark = strtoumax(line + 1, &mark_end, 10);
if (!mark || mark_end == line + 1 if (!mark || mark_end == line + 1
|| *mark_end != ' ' || get_oid_hex(mark_end + 1, &oid)) || *mark_end != ' ' || get_oid_hex(mark_end + 1, &oid))
die("corrupt mark line: %s", line); die(_("corrupt mark line: %s"), line);


if (last_idnum < mark) if (last_idnum < mark)
last_idnum = mark; last_idnum = mark;


type = odb_read_object_info(the_repository->objects, &oid, NULL); type = odb_read_object_info(the_repository->objects, &oid, NULL);
if (type < 0) if (type < 0)
die("object not found: %s", oid_to_hex(&oid)); die(_("object not found: %s"), oid_to_hex(&oid));


if (type != OBJ_COMMIT) if (type != OBJ_COMMIT)
/* only commits */ /* only commits */
@ -1235,12 +1236,12 @@ static void import_marks(char *input_file, int check_exists)


commit = lookup_commit(the_repository, &oid); commit = lookup_commit(the_repository, &oid);
if (!commit) if (!commit)
die("not a commit? can't happen: %s", oid_to_hex(&oid)); die(_("not a commit? can't happen: %s"), oid_to_hex(&oid));


object = &commit->object; object = &commit->object;


if (object->flags & SHOWN) if (object->flags & SHOWN)
error("Object %s already has a mark", oid_to_hex(&oid)); error(_("object %s already has a mark"), oid_to_hex(&oid));


mark_object(object, mark); mark_object(object, mark);


@ -1394,7 +1395,7 @@ int cmd_fast_export(int argc,
get_tags_and_duplicates(&revs.cmdline); get_tags_and_duplicates(&revs.cmdline);


if (prepare_revision_walk(&revs)) if (prepare_revision_walk(&revs))
die("revision walk setup failed"); die(_("revision walk setup failed"));


revs.reverse = 1; revs.reverse = 1;
revs.diffopt.format_callback = show_filemodify; revs.diffopt.format_callback = show_filemodify;

280
builtin/fast-import.c
View File

@ -339,12 +339,12 @@ static void write_crash_report(const char *err)
struct recent_command *rc; struct recent_command *rc;


if (!rpt) { if (!rpt) {
error_errno("can't write crash report %s", loc); error_errno(_("can't write crash report %s"), loc);
free(loc); free(loc);
return; return;
} }


fprintf(stderr, "fast-import: dumping crash report to %s\n", loc); fprintf(stderr, _("fast-import: dumping crash report to %s\n"), loc);


fprintf(rpt, "fast-import crash report:\n"); fprintf(rpt, "fast-import crash report:\n");
fprintf(rpt, " fast-import process: %"PRIuMAX"\n", (uintmax_t) getpid()); fprintf(rpt, " fast-import process: %"PRIuMAX"\n", (uintmax_t) getpid());
@ -588,7 +588,7 @@ static void *find_mark(struct mark_set *s, uintmax_t idnum)
oe = s->data.marked[idnum]; oe = s->data.marked[idnum];
} }
if (!oe) if (!oe)
die("mark :%" PRIuMAX " not declared", orig_idnum); die(_("mark :%" PRIuMAX " not declared"), orig_idnum);
return oe; return oe;
} }


@ -628,9 +628,9 @@ static struct branch *new_branch(const char *name)
struct branch *b = lookup_branch(name); struct branch *b = lookup_branch(name);


if (b) if (b)
die("Invalid attempt to create duplicate branch: %s", name); die(_("invalid attempt to create duplicate branch: %s"), name);
if (check_refname_format(name, REFNAME_ALLOW_ONELEVEL)) if (check_refname_format(name, REFNAME_ALLOW_ONELEVEL))
die("Branch name doesn't conform to GIT standards: %s", name); die(_("branch name doesn't conform to Git standards: %s"), name);


b = mem_pool_calloc(&fi_mem_pool, 1, sizeof(struct branch)); b = mem_pool_calloc(&fi_mem_pool, 1, sizeof(struct branch));
b->name = mem_pool_strdup(&fi_mem_pool, name); b->name = mem_pool_strdup(&fi_mem_pool, name);
@ -801,7 +801,7 @@ static const char *create_index(void)
*c++ = &e->idx; *c++ = &e->idx;
last = idx + object_count; last = idx + object_count;
if (c != last) if (c != last)
die("internal consistency error creating the index"); die(_("internal consistency error creating the index"));


tmpfile = write_idx_file(the_repository, NULL, idx, object_count, tmpfile = write_idx_file(the_repository, NULL, idx, object_count,
&pack_idx_opts, pack_data->hash); &pack_idx_opts, pack_data->hash);
@ -819,18 +819,18 @@ static char *keep_pack(const char *curr_index_name)
keep_fd = safe_create_file_with_leading_directories(pack_data->repo, keep_fd = safe_create_file_with_leading_directories(pack_data->repo,
name.buf); name.buf);
if (keep_fd < 0) if (keep_fd < 0)
die_errno("cannot create keep file"); die_errno(_("cannot create keep file"));
write_or_die(keep_fd, keep_msg, strlen(keep_msg)); write_or_die(keep_fd, keep_msg, strlen(keep_msg));
if (close(keep_fd)) if (close(keep_fd))
die_errno("failed to write keep file"); die_errno(_("failed to write keep file"));


odb_pack_name(pack_data->repo, &name, pack_data->hash, "pack"); odb_pack_name(pack_data->repo, &name, pack_data->hash, "pack");
if (finalize_object_file(pack_data->repo, pack_data->pack_name, name.buf)) if (finalize_object_file(pack_data->repo, pack_data->pack_name, name.buf))
die("cannot store pack file"); die(_("cannot store pack file"));


odb_pack_name(pack_data->repo, &name, pack_data->hash, "idx"); odb_pack_name(pack_data->repo, &name, pack_data->hash, "idx");
if (finalize_object_file(pack_data->repo, curr_index_name, name.buf)) if (finalize_object_file(pack_data->repo, curr_index_name, name.buf))
die("cannot store index file"); die(_("cannot store index file"));
free((void *)curr_index_name); free((void *)curr_index_name);
return strbuf_detach(&name, NULL); return strbuf_detach(&name, NULL);
} }
@ -853,7 +853,7 @@ static int loosen_small_pack(const struct packed_git *p)
struct child_process unpack = CHILD_PROCESS_INIT; struct child_process unpack = CHILD_PROCESS_INIT;


if (lseek(p->pack_fd, 0, SEEK_SET) < 0) if (lseek(p->pack_fd, 0, SEEK_SET) < 0)
die_errno("Failed seeking to start of '%s'", p->pack_name); die_errno(_("failed seeking to start of '%s'"), p->pack_name);


unpack.in = p->pack_fd; unpack.in = p->pack_fd;
unpack.git_cmd = 1; unpack.git_cmd = 1;
@ -903,7 +903,7 @@ static void end_packfile(void)
new_p = packfile_store_load_pack(pack_data->repo->objects->packfiles, new_p = packfile_store_load_pack(pack_data->repo->objects->packfiles,
idx_name, 1); idx_name, 1);
if (!new_p) if (!new_p)
die("core git rejected index %s", idx_name); die(_("core Git rejected index %s"), idx_name);
all_packs[pack_id] = new_p; all_packs[pack_id] = new_p;
free(idx_name); free(idx_name);


@ -1090,7 +1090,7 @@ static int store_object(
static void truncate_pack(struct hashfile_checkpoint *checkpoint) static void truncate_pack(struct hashfile_checkpoint *checkpoint)
{ {
if (hashfile_truncate(pack_file, checkpoint)) if (hashfile_truncate(pack_file, checkpoint))
die_errno("cannot truncate pack to skip duplicate"); die_errno(_("cannot truncate pack to skip duplicate"));
pack_size = checkpoint->offset; pack_size = checkpoint->offset;
} }


@ -1138,7 +1138,7 @@ static void stream_blob(uintmax_t len, struct object_id *oidout, uintmax_t mark)
size_t cnt = in_sz < len ? in_sz : (size_t)len; size_t cnt = in_sz < len ? in_sz : (size_t)len;
size_t n = fread(in_buf, 1, cnt, stdin); size_t n = fread(in_buf, 1, cnt, stdin);
if (!n && feof(stdin)) if (!n && feof(stdin))
die("EOF in data (%" PRIuMAX " bytes remaining)", len); die(_("EOF in data (%" PRIuMAX " bytes remaining)"), len);


git_hash_update(&c, in_buf, n); git_hash_update(&c, in_buf, n);
s.next_in = in_buf; s.next_in = in_buf;
@ -1162,7 +1162,7 @@ static void stream_blob(uintmax_t len, struct object_id *oidout, uintmax_t mark)
case Z_STREAM_END: case Z_STREAM_END:
continue; continue;
default: default:
die("unexpected deflate failure: %d", status); die(_("unexpected deflate failure: %d"), status);
} }
} }
git_deflate_end(&s); git_deflate_end(&s);
@ -1264,16 +1264,16 @@ static void load_tree(struct tree_entry *root)
myoe = find_object(oid); myoe = find_object(oid);
if (myoe && myoe->pack_id != MAX_PACK_ID) { if (myoe && myoe->pack_id != MAX_PACK_ID) {
if (myoe->type != OBJ_TREE) if (myoe->type != OBJ_TREE)
die("Not a tree: %s", oid_to_hex(oid)); die(_("not a tree: %s"), oid_to_hex(oid));
t->delta_depth = myoe->depth; t->delta_depth = myoe->depth;
buf = gfi_unpack_entry(myoe, &size); buf = gfi_unpack_entry(myoe, &size);
if (!buf) if (!buf)
die("Can't load tree %s", oid_to_hex(oid)); die(_("can't load tree %s"), oid_to_hex(oid));
} else { } else {
enum object_type type; enum object_type type;
buf = odb_read_object(the_repository->objects, oid, &type, &size); buf = odb_read_object(the_repository->objects, oid, &type, &size);
if (!buf || type != OBJ_TREE) if (!buf || type != OBJ_TREE)
die("Can't load tree %s", oid_to_hex(oid)); die(_("can't load tree %s"), oid_to_hex(oid));
} }


c = buf; c = buf;
@ -1287,7 +1287,7 @@ static void load_tree(struct tree_entry *root)
e->tree = NULL; e->tree = NULL;
c = parse_mode(c, &e->versions[1].mode); c = parse_mode(c, &e->versions[1].mode);
if (!c) if (!c)
die("Corrupt mode in %s", oid_to_hex(oid)); die(_("corrupt mode in %s"), oid_to_hex(oid));
e->versions[0].mode = e->versions[1].mode; e->versions[0].mode = e->versions[1].mode;
e->name = to_atom(c, strlen(c)); e->name = to_atom(c, strlen(c));
c += e->name->str_len + 1; c += e->name->str_len + 1;
@ -1399,7 +1399,7 @@ static void tree_content_replace(
struct tree_content *newtree) struct tree_content *newtree)
{ {
if (!S_ISDIR(mode)) if (!S_ISDIR(mode))
die("Root cannot be a non-directory"); die(_("root cannot be a non-directory"));
oidclr(&root->versions[0].oid, the_repository->hash_algo); oidclr(&root->versions[0].oid, the_repository->hash_algo);
oidcpy(&root->versions[1].oid, oid); oidcpy(&root->versions[1].oid, oid);
if (root->tree) if (root->tree)
@ -1422,9 +1422,9 @@ static int tree_content_set(
slash1 = strchrnul(p, '/'); slash1 = strchrnul(p, '/');
n = slash1 - p; n = slash1 - p;
if (!n) if (!n)
die("Empty path component found in input"); die(_("empty path component found in input"));
if (!*slash1 && !S_ISDIR(mode) && subtree) if (!*slash1 && !S_ISDIR(mode) && subtree)
die("Non-directories cannot have subtrees"); die(_("non-directories cannot have subtrees"));


if (!root->tree) if (!root->tree)
load_tree(root); load_tree(root);
@ -1576,7 +1576,7 @@ static int tree_content_get(
slash1 = strchrnul(p, '/'); slash1 = strchrnul(p, '/');
n = slash1 - p; n = slash1 - p;
if (!n && !allow_root) if (!n && !allow_root)
die("Empty path component found in input"); die(_("empty path component found in input"));


if (!root->tree) if (!root->tree)
load_tree(root); load_tree(root);
@ -1622,8 +1622,8 @@ static int update_branch(struct branch *b)
!strcmp(b->name + strlen(replace_prefix), !strcmp(b->name + strlen(replace_prefix),
oid_to_hex(&b->oid))) { oid_to_hex(&b->oid))) {
if (!quiet) if (!quiet)
warning("Dropping %s since it would point to " warning(_("dropping %s since it would point to "
"itself (i.e. to %s)", "itself (i.e. to %s)"),
b->name, oid_to_hex(&b->oid)); b->name, oid_to_hex(&b->oid));
refs_delete_ref(get_main_ref_store(the_repository), refs_delete_ref(get_main_ref_store(the_repository),
NULL, b->name, NULL, 0); NULL, b->name, NULL, 0);
@ -1646,14 +1646,14 @@ static int update_branch(struct branch *b)
new_cmit = lookup_commit_reference_gently(the_repository, new_cmit = lookup_commit_reference_gently(the_repository,
&b->oid, 0); &b->oid, 0);
if (!old_cmit || !new_cmit) if (!old_cmit || !new_cmit)
return error("Branch %s is missing commits.", b->name); return error(_("branch %s is missing commits."), b->name);


ret = repo_in_merge_bases(the_repository, old_cmit, new_cmit); ret = repo_in_merge_bases(the_repository, old_cmit, new_cmit);
if (ret < 0) if (ret < 0)
exit(128); exit(128);
if (!ret) { if (!ret) {
warning("Not updating %s" warning(_("not updating %s"
" (new tip %s does not contain %s)", " (new tip %s does not contain %s)"),
b->name, oid_to_hex(&b->oid), b->name, oid_to_hex(&b->oid),
oid_to_hex(&old_oid)); oid_to_hex(&old_oid));
return -1; return -1;
@ -1729,13 +1729,13 @@ static void dump_marks(void)
return; return;


if (safe_create_leading_directories_const(the_repository, export_marks_file)) { if (safe_create_leading_directories_const(the_repository, export_marks_file)) {
failure |= error_errno("unable to create leading directories of %s", failure |= error_errno(_("unable to create leading directories of %s"),
export_marks_file); export_marks_file);
return; return;
} }


if (hold_lock_file_for_update(&mark_lock, export_marks_file, 0) < 0) { if (hold_lock_file_for_update(&mark_lock, export_marks_file, 0) < 0) {
failure |= error_errno("Unable to write marks file %s", failure |= error_errno(_("unable to write marks file %s"),
export_marks_file); export_marks_file);
return; return;
} }
@ -1744,14 +1744,14 @@ static void dump_marks(void)
if (!f) { if (!f) {
int saved_errno = errno; int saved_errno = errno;
rollback_lock_file(&mark_lock); rollback_lock_file(&mark_lock);
failure |= error("Unable to write marks file %s: %s", failure |= error(_("unable to write marks file %s: %s"),
export_marks_file, strerror(saved_errno)); export_marks_file, strerror(saved_errno));
return; return;
} }


for_each_mark(marks, 0, dump_marks_fn, f); for_each_mark(marks, 0, dump_marks_fn, f);
if (commit_lock_file(&mark_lock)) { if (commit_lock_file(&mark_lock)) {
failure |= error_errno("Unable to write file %s", failure |= error_errno(_("unable to write file %s"),
export_marks_file); export_marks_file);
return; return;
} }
@ -1765,7 +1765,7 @@ static void insert_object_entry(struct mark_set **s, struct object_id *oid, uint
enum object_type type = odb_read_object_info(the_repository->objects, enum object_type type = odb_read_object_info(the_repository->objects,
oid, NULL); oid, NULL);
if (type < 0) if (type < 0)
die("object not found: %s", oid_to_hex(oid)); die(_("object not found: %s"), oid_to_hex(oid));
e = insert_object(oid); e = insert_object(oid);
e->type = type; e->type = type;
e->pack_id = MAX_PACK_ID; e->pack_id = MAX_PACK_ID;
@ -1792,13 +1792,13 @@ static void read_mark_file(struct mark_set **s, FILE *f, mark_set_inserter_t ins


end = strchr(line, '\n'); end = strchr(line, '\n');
if (line[0] != ':' || !end) if (line[0] != ':' || !end)
die("corrupt mark line: %s", line); die(_("corrupt mark line: %s"), line);
*end = 0; *end = 0;
mark = strtoumax(line + 1, &end, 10); mark = strtoumax(line + 1, &end, 10);
if (!mark || end == line + 1 if (!mark || end == line + 1
|| *end != ' ' || *end != ' '
|| get_oid_hex_any(end + 1, &oid) == GIT_HASH_UNKNOWN) || get_oid_hex_any(end + 1, &oid) == GIT_HASH_UNKNOWN)
die("corrupt mark line: %s", line); die(_("corrupt mark line: %s"), line);
inserter(s, &oid, mark); inserter(s, &oid, mark);
} }
} }
@ -1811,7 +1811,7 @@ static void read_marks(void)
else if (import_marks_file_ignore_missing && errno == ENOENT) else if (import_marks_file_ignore_missing && errno == ENOENT)
goto done; /* Marks file does not exist */ goto done; /* Marks file does not exist */
else else
die_errno("cannot read '%s'", import_marks_file); die_errno(_("cannot read '%s'"), import_marks_file);
read_mark_file(&marks, f, insert_object_entry); read_mark_file(&marks, f, insert_object_entry);
fclose(f); fclose(f);
done: done:
@ -1897,7 +1897,7 @@ static int parse_data(struct strbuf *sb, uintmax_t limit, uintmax_t *len_res)
strbuf_reset(sb); strbuf_reset(sb);


if (!skip_prefix(command_buf.buf, "data ", &data)) if (!skip_prefix(command_buf.buf, "data ", &data))
die("Expected 'data n' command, found: %s", command_buf.buf); die(_("expected 'data n' command, found: %s"), command_buf.buf);


if (skip_prefix(data, "<<", &data)) { if (skip_prefix(data, "<<", &data)) {
char *term = xstrdup(data); char *term = xstrdup(data);
@ -1905,7 +1905,7 @@ static int parse_data(struct strbuf *sb, uintmax_t limit, uintmax_t *len_res)


for (;;) { for (;;) {
if (strbuf_getline_lf(&command_buf, stdin) == EOF) if (strbuf_getline_lf(&command_buf, stdin) == EOF)
die("EOF in data (terminator '%s' not found)", term); die(_("EOF in data (terminator '%s' not found)"), term);
if (term_len == command_buf.len if (term_len == command_buf.len
&& !strcmp(term, command_buf.buf)) && !strcmp(term, command_buf.buf))
break; break;
@ -1923,12 +1923,12 @@ static int parse_data(struct strbuf *sb, uintmax_t limit, uintmax_t *len_res)
return 0; return 0;
} }
if (length < len) if (length < len)
die("data is too large to use in this context"); die(_("data is too large to use in this context"));


while (n < length) { while (n < length) {
size_t s = strbuf_fread(sb, length - n, stdin); size_t s = strbuf_fread(sb, length - n, stdin);
if (!s && feof(stdin)) if (!s && feof(stdin))
die("EOF in data (%lu bytes remaining)", die(_("EOF in data (%lu bytes remaining)"),
(unsigned long)(length - n)); (unsigned long)(length - n));
n += s; n += s;
} }
@ -1985,15 +1985,15 @@ static char *parse_ident(const char *buf)


ltgt = buf + strcspn(buf, "<>"); ltgt = buf + strcspn(buf, "<>");
if (*ltgt != '<') if (*ltgt != '<')
die("Missing < in ident string: %s", buf); die(_("missing < in ident string: %s"), buf);
if (ltgt != buf && ltgt[-1] != ' ') if (ltgt != buf && ltgt[-1] != ' ')
die("Missing space before < in ident string: %s", buf); die(_("missing space before < in ident string: %s"), buf);
ltgt = ltgt + 1 + strcspn(ltgt + 1, "<>"); ltgt = ltgt + 1 + strcspn(ltgt + 1, "<>");
if (*ltgt != '>') if (*ltgt != '>')
die("Missing > in ident string: %s", buf); die(_("missing > in ident string: %s"), buf);
ltgt++; ltgt++;
if (*ltgt != ' ') if (*ltgt != ' ')
die("Missing space after > in ident string: %s", buf); die(_("missing space after > in ident string: %s"), buf);
ltgt++; ltgt++;
name_len = ltgt - buf; name_len = ltgt - buf;
strbuf_add(&ident, buf, name_len); strbuf_add(&ident, buf, name_len);
@ -2001,19 +2001,19 @@ static char *parse_ident(const char *buf)
switch (whenspec) { switch (whenspec) {
case WHENSPEC_RAW: case WHENSPEC_RAW:
if (validate_raw_date(ltgt, &ident, 1) < 0) if (validate_raw_date(ltgt, &ident, 1) < 0)
die("Invalid raw date \"%s\" in ident: %s", ltgt, buf); die(_("invalid raw date \"%s\" in ident: %s"), ltgt, buf);
break; break;
case WHENSPEC_RAW_PERMISSIVE: case WHENSPEC_RAW_PERMISSIVE:
if (validate_raw_date(ltgt, &ident, 0) < 0) if (validate_raw_date(ltgt, &ident, 0) < 0)
die("Invalid raw date \"%s\" in ident: %s", ltgt, buf); die(_("invalid raw date \"%s\" in ident: %s"), ltgt, buf);
break; break;
case WHENSPEC_RFC2822: case WHENSPEC_RFC2822:
if (parse_date(ltgt, &ident) < 0) if (parse_date(ltgt, &ident) < 0)
die("Invalid rfc2822 date \"%s\" in ident: %s", ltgt, buf); die(_("invalid rfc2822 date \"%s\" in ident: %s"), ltgt, buf);
break; break;
case WHENSPEC_NOW: case WHENSPEC_NOW:
if (strcmp("now", ltgt)) if (strcmp("now", ltgt))
die("Date in ident must be 'now': %s", buf); die(_("date in ident must be 'now': %s"), buf);
datestamp(&ident); datestamp(&ident);
break; break;
} }
@ -2107,7 +2107,7 @@ static void construct_path_with_fanout(const char *hex_sha1,
{ {
unsigned int i = 0, j = 0; unsigned int i = 0, j = 0;
if (fanout >= the_hash_algo->rawsz) if (fanout >= the_hash_algo->rawsz)
die("Too large fanout (%u)", fanout); die(_("too large fanout (%u)"), fanout);
while (fanout) { while (fanout) {
path[i++] = hex_sha1[j++]; path[i++] = hex_sha1[j++];
path[i++] = hex_sha1[j++]; path[i++] = hex_sha1[j++];
@ -2181,7 +2181,7 @@ static uintmax_t do_change_note_fanout(


/* Rename fullpath to realpath */ /* Rename fullpath to realpath */
if (!tree_content_remove(orig_root, fullpath, &leaf, 0)) if (!tree_content_remove(orig_root, fullpath, &leaf, 0))
die("Failed to remove path %s", fullpath); die(_("failed to remove path %s"), fullpath);
tree_content_set(orig_root, realpath, tree_content_set(orig_root, realpath,
&leaf.versions[1].oid, &leaf.versions[1].oid,
leaf.versions[1].mode, leaf.versions[1].mode,
@ -2254,7 +2254,7 @@ static uintmax_t parse_mark_ref(const char *p, char **endptr)
p++; p++;
mark = strtoumax(p, endptr, 10); mark = strtoumax(p, endptr, 10);
if (*endptr == p) if (*endptr == p)
die("No value after ':' in mark: %s", command_buf.buf); die(_("no value after ':' in mark: %s"), command_buf.buf);
return mark; return mark;
} }


@ -2269,7 +2269,7 @@ static uintmax_t parse_mark_ref_eol(const char *p)


mark = parse_mark_ref(p, &end); mark = parse_mark_ref(p, &end);
if (*end != '\0') if (*end != '\0')
die("Garbage after mark: %s", command_buf.buf); die(_("garbage after mark: %s"), command_buf.buf);
return mark; return mark;
} }


@ -2284,7 +2284,7 @@ static uintmax_t parse_mark_ref_space(const char **p)


mark = parse_mark_ref(*p, &end); mark = parse_mark_ref(*p, &end);
if (*end++ != ' ') if (*end++ != ' ')
die("Missing space after mark: %s", command_buf.buf); die(_("missing space after mark: %s"), command_buf.buf);
*p = end; *p = end;
return mark; return mark;
} }
@ -2300,9 +2300,9 @@ static void parse_path(struct strbuf *sb, const char *p, const char **endp,
{ {
if (*p == '"') { if (*p == '"') {
if (unquote_c_style(sb, p, endp)) if (unquote_c_style(sb, p, endp))
die("Invalid %s: %s", field, command_buf.buf); die(_("invalid %s: %s"), field, command_buf.buf);
if (strlen(sb->buf) != sb->len) if (strlen(sb->buf) != sb->len)
die("NUL in %s: %s", field, command_buf.buf); die(_("NUL in %s: %s"), field, command_buf.buf);
} else { } else {
/* /*
* Unless we are parsing the last field of a line, * Unless we are parsing the last field of a line,
@ -2325,7 +2325,7 @@ static void parse_path_eol(struct strbuf *sb, const char *p, const char *field)


parse_path(sb, p, &end, 1, field); parse_path(sb, p, &end, 1, field);
if (*end) if (*end)
die("Garbage after %s: %s", field, command_buf.buf); die(_("garbage after %s: %s"), field, command_buf.buf);
} }


/* /*
@ -2338,7 +2338,7 @@ static void parse_path_space(struct strbuf *sb, const char *p,
{ {
parse_path(sb, p, endp, 0, field); parse_path(sb, p, endp, 0, field);
if (**endp != ' ') if (**endp != ' ')
die("Missing space after %s: %s", field, command_buf.buf); die(_("missing space after %s: %s"), field, command_buf.buf);
(*endp)++; (*endp)++;
} }


@ -2351,7 +2351,7 @@ static void file_change_m(const char *p, struct branch *b)


p = parse_mode(p, &mode); p = parse_mode(p, &mode);
if (!p) if (!p)
die("Corrupt mode: %s", command_buf.buf); die(_("corrupt mode: %s"), command_buf.buf);
switch (mode) { switch (mode) {
case 0644: case 0644:
case 0755: case 0755:
@ -2364,7 +2364,7 @@ static void file_change_m(const char *p, struct branch *b)
/* ok */ /* ok */
break; break;
default: default:
die("Corrupt mode: %s", command_buf.buf); die(_("corrupt mode: %s"), command_buf.buf);
} }


if (*p == ':') { if (*p == ':') {
@ -2375,10 +2375,10 @@ static void file_change_m(const char *p, struct branch *b)
oe = NULL; /* not used with inline_data, but makes gcc happy */ oe = NULL; /* not used with inline_data, but makes gcc happy */
} else { } else {
if (parse_mapped_oid_hex(p, &oid, &p)) if (parse_mapped_oid_hex(p, &oid, &p))
die("Invalid dataref: %s", command_buf.buf); die(_("invalid dataref: %s"), command_buf.buf);
oe = find_object(&oid); oe = find_object(&oid);
if (*p++ != ' ') if (*p++ != ' ')
die("Missing space after SHA1: %s", command_buf.buf); die(_("missing space after SHA1: %s"), command_buf.buf);
} }


strbuf_reset(&path); strbuf_reset(&path);
@ -2394,11 +2394,11 @@ static void file_change_m(const char *p, struct branch *b)


if (S_ISGITLINK(mode)) { if (S_ISGITLINK(mode)) {
if (inline_data) if (inline_data)
die("Git links cannot be specified 'inline': %s", die(_("Git links cannot be specified 'inline': %s"),
command_buf.buf); command_buf.buf);
else if (oe) { else if (oe) {
if (oe->type != OBJ_COMMIT) if (oe->type != OBJ_COMMIT)
die("Not a commit (actually a %s): %s", die(_("not a commit (actually a %s): %s"),
type_name(oe->type), command_buf.buf); type_name(oe->type), command_buf.buf);
} }
/* /*
@ -2407,7 +2407,7 @@ static void file_change_m(const char *p, struct branch *b)
*/ */
} else if (inline_data) { } else if (inline_data) {
if (S_ISDIR(mode)) if (S_ISDIR(mode))
die("Directories cannot be specified 'inline': %s", die(_("directories cannot be specified 'inline': %s"),
command_buf.buf); command_buf.buf);
while (read_next_command() != EOF) { while (read_next_command() != EOF) {
const char *v; const char *v;
@ -2425,11 +2425,11 @@ static void file_change_m(const char *p, struct branch *b)
odb_read_object_info(the_repository->objects, odb_read_object_info(the_repository->objects,
&oid, NULL); &oid, NULL);
if (type < 0) if (type < 0)
die("%s not found: %s", die(_("%s not found: %s"),
S_ISDIR(mode) ? "Tree" : "Blob", S_ISDIR(mode) ? _("tree") : _("blob"),
command_buf.buf); command_buf.buf);
if (type != expected) if (type != expected)
die("Not a %s (actually a %s): %s", die(_("not a %s (actually a %s): %s"),
type_name(expected), type_name(type), type_name(expected), type_name(type),
command_buf.buf); command_buf.buf);
} }
@ -2440,7 +2440,7 @@ static void file_change_m(const char *p, struct branch *b)
} }


if (!verify_path(path.buf, mode)) if (!verify_path(path.buf, mode))
die("invalid path '%s'", path.buf); die(_("invalid path '%s'"), path.buf);
tree_content_set(&b->branch_tree, path.buf, &oid, mode, NULL); tree_content_set(&b->branch_tree, path.buf, &oid, mode, NULL);
} }


@ -2470,7 +2470,7 @@ static void file_change_cr(const char *p, struct branch *b, int rename)
else else
tree_content_get(&b->branch_tree, source.buf, &leaf, 1); tree_content_get(&b->branch_tree, source.buf, &leaf, 1);
if (!leaf.versions[1].mode) if (!leaf.versions[1].mode)
die("Path %s not in branch", source.buf); die(_("path %s not in branch"), source.buf);
if (!*dest.buf) { /* C "path/to/subdir" "" */ if (!*dest.buf) { /* C "path/to/subdir" "" */
tree_content_replace(&b->branch_tree, tree_content_replace(&b->branch_tree,
&leaf.versions[1].oid, &leaf.versions[1].oid,
@ -2479,7 +2479,7 @@ static void file_change_cr(const char *p, struct branch *b, int rename)
return; return;
} }
if (!verify_path(dest.buf, leaf.versions[1].mode)) if (!verify_path(dest.buf, leaf.versions[1].mode))
die("invalid path '%s'", dest.buf); die(_("invalid path '%s'"), dest.buf);
tree_content_set(&b->branch_tree, dest.buf, tree_content_set(&b->branch_tree, dest.buf,
&leaf.versions[1].oid, &leaf.versions[1].oid,
leaf.versions[1].mode, leaf.versions[1].mode,
@ -2521,23 +2521,23 @@ static void note_change_n(const char *p, struct branch *b, unsigned char *old_fa
oe = NULL; /* not used with inline_data, but makes gcc happy */ oe = NULL; /* not used with inline_data, but makes gcc happy */
} else { } else {
if (parse_mapped_oid_hex(p, &oid, &p)) if (parse_mapped_oid_hex(p, &oid, &p))
die("Invalid dataref: %s", command_buf.buf); die(_("invalid dataref: %s"), command_buf.buf);
oe = find_object(&oid); oe = find_object(&oid);
if (*p++ != ' ') if (*p++ != ' ')
die("Missing space after SHA1: %s", command_buf.buf); die(_("missing space after SHA1: %s"), command_buf.buf);
} }


/* <commit-ish> */ /* <commit-ish> */
s = lookup_branch(p); s = lookup_branch(p);
if (s) { if (s) {
if (is_null_oid(&s->oid)) if (is_null_oid(&s->oid))
die("Can't add a note on empty branch."); die(_("can't add a note on empty branch."));
oidcpy(&commit_oid, &s->oid); oidcpy(&commit_oid, &s->oid);
} else if (*p == ':') { } else if (*p == ':') {
uintmax_t commit_mark = parse_mark_ref_eol(p); uintmax_t commit_mark = parse_mark_ref_eol(p);
struct object_entry *commit_oe = find_mark(marks, commit_mark); struct object_entry *commit_oe = find_mark(marks, commit_mark);
if (commit_oe->type != OBJ_COMMIT) if (commit_oe->type != OBJ_COMMIT)
die("Mark :%" PRIuMAX " not a commit", commit_mark); die(_("mark :%" PRIuMAX " not a commit"), commit_mark);
oidcpy(&commit_oid, &commit_oe->idx.oid); oidcpy(&commit_oid, &commit_oe->idx.oid);
} else if (!repo_get_oid(the_repository, p, &commit_oid)) { } else if (!repo_get_oid(the_repository, p, &commit_oid)) {
unsigned long size; unsigned long size;
@ -2545,25 +2545,25 @@ static void note_change_n(const char *p, struct branch *b, unsigned char *old_fa
&commit_oid, OBJ_COMMIT, &size, &commit_oid, OBJ_COMMIT, &size,
&commit_oid); &commit_oid);
if (!buf || size < the_hash_algo->hexsz + 6) if (!buf || size < the_hash_algo->hexsz + 6)
die("Not a valid commit: %s", p); die(_("not a valid commit: %s"), p);
free(buf); free(buf);
} else } else
die("Invalid ref name or SHA1 expression: %s", p); die(_("invalid ref name or SHA1 expression: %s"), p);


if (inline_data) { if (inline_data) {
read_next_command(); read_next_command();
parse_and_store_blob(&last_blob, &oid, 0); parse_and_store_blob(&last_blob, &oid, 0);
} else if (oe) { } else if (oe) {
if (oe->type != OBJ_BLOB) if (oe->type != OBJ_BLOB)
die("Not a blob (actually a %s): %s", die(_("not a blob (actually a %s): %s"),
type_name(oe->type), command_buf.buf); type_name(oe->type), command_buf.buf);
} else if (!is_null_oid(&oid)) { } else if (!is_null_oid(&oid)) {
enum object_type type = odb_read_object_info(the_repository->objects, &oid, enum object_type type = odb_read_object_info(the_repository->objects, &oid,
NULL); NULL);
if (type < 0) if (type < 0)
die("Blob not found: %s", command_buf.buf); die(_("blob not found: %s"), command_buf.buf);
if (type != OBJ_BLOB) if (type != OBJ_BLOB)
die("Not a blob (actually a %s): %s", die(_("not a blob (actually a %s): %s"),
type_name(type), command_buf.buf); type_name(type), command_buf.buf);
} }


@ -2592,10 +2592,10 @@ static void file_change_deleteall(struct branch *b)
static void parse_from_commit(struct branch *b, char *buf, unsigned long size) static void parse_from_commit(struct branch *b, char *buf, unsigned long size)
{ {
if (!buf || size < the_hash_algo->hexsz + 6) if (!buf || size < the_hash_algo->hexsz + 6)
die("Not a valid commit: %s", oid_to_hex(&b->oid)); die(_("not a valid commit: %s"), oid_to_hex(&b->oid));
if (memcmp("tree ", buf, 5) if (memcmp("tree ", buf, 5)
|| get_oid_hex(buf + 5, &b->branch_tree.versions[1].oid)) || get_oid_hex(buf + 5, &b->branch_tree.versions[1].oid))
die("The commit %s is corrupt", oid_to_hex(&b->oid)); die(_("the commit %s is corrupt"), oid_to_hex(&b->oid));
oidcpy(&b->branch_tree.versions[0].oid, oidcpy(&b->branch_tree.versions[0].oid,
&b->branch_tree.versions[1].oid); &b->branch_tree.versions[1].oid);
} }
@ -2625,7 +2625,7 @@ static int parse_objectish(struct branch *b, const char *objectish)


s = lookup_branch(objectish); s = lookup_branch(objectish);
if (b == s) if (b == s)
die("Can't create a branch from itself: %s", b->name); die(_("can't create a branch from itself: %s"), b->name);
else if (s) { else if (s) {
struct object_id *t = &s->branch_tree.versions[1].oid; struct object_id *t = &s->branch_tree.versions[1].oid;
oidcpy(&b->oid, &s->oid); oidcpy(&b->oid, &s->oid);
@ -2635,7 +2635,7 @@ static int parse_objectish(struct branch *b, const char *objectish)
uintmax_t idnum = parse_mark_ref_eol(objectish); uintmax_t idnum = parse_mark_ref_eol(objectish);
struct object_entry *oe = find_mark(marks, idnum); struct object_entry *oe = find_mark(marks, idnum);
if (oe->type != OBJ_COMMIT) if (oe->type != OBJ_COMMIT)
die("Mark :%" PRIuMAX " not a commit", idnum); die(_("mark :%" PRIuMAX " not a commit"), idnum);
if (!oideq(&b->oid, &oe->idx.oid)) { if (!oideq(&b->oid, &oe->idx.oid)) {
oidcpy(&b->oid, &oe->idx.oid); oidcpy(&b->oid, &oe->idx.oid);
if (oe->pack_id != MAX_PACK_ID) { if (oe->pack_id != MAX_PACK_ID) {
@ -2652,7 +2652,7 @@ static int parse_objectish(struct branch *b, const char *objectish)
b->delete = 1; b->delete = 1;
} }
else else
die("Invalid ref name or SHA1 expression: %s", objectish); die(_("invalid ref name or SHA1 expression: %s"), objectish);


if (b->branch_tree.tree && !oideq(&oid, &b->branch_tree.versions[1].oid)) { if (b->branch_tree.tree && !oideq(&oid, &b->branch_tree.versions[1].oid)) {
release_tree_content_recursive(b->branch_tree.tree); release_tree_content_recursive(b->branch_tree.tree);
@ -2699,7 +2699,7 @@ static struct hash_list *parse_merge(unsigned int *count)
uintmax_t idnum = parse_mark_ref_eol(from); uintmax_t idnum = parse_mark_ref_eol(from);
struct object_entry *oe = find_mark(marks, idnum); struct object_entry *oe = find_mark(marks, idnum);
if (oe->type != OBJ_COMMIT) if (oe->type != OBJ_COMMIT)
die("Mark :%" PRIuMAX " not a commit", idnum); die(_("mark :%" PRIuMAX " not a commit"), idnum);
oidcpy(&n->oid, &oe->idx.oid); oidcpy(&n->oid, &oe->idx.oid);
} else if (!repo_get_oid(the_repository, from, &n->oid)) { } else if (!repo_get_oid(the_repository, from, &n->oid)) {
unsigned long size; unsigned long size;
@ -2707,10 +2707,10 @@ static struct hash_list *parse_merge(unsigned int *count)
&n->oid, OBJ_COMMIT, &n->oid, OBJ_COMMIT,
&size, &n->oid); &size, &n->oid);
if (!buf || size < the_hash_algo->hexsz + 6) if (!buf || size < the_hash_algo->hexsz + 6)
die("Not a valid commit: %s", from); die(_("not a valid commit: %s"), from);
free(buf); free(buf);
} else } else
die("Invalid ref name or SHA1 expression: %s", from); die(_("invalid ref name or SHA1 expression: %s"), from);


n->next = NULL; n->next = NULL;
*tail = n; *tail = n;
@ -2734,8 +2734,8 @@ static void parse_one_signature(struct signature_data *sig, const char *v)
char *space = strchr(args, ' '); char *space = strchr(args, ' ');


if (!space) if (!space)
die("Expected gpgsig format: 'gpgsig <hash-algo> <signature-format>', " die(_("expected gpgsig format: 'gpgsig <hash-algo> <signature-format>', "
"got 'gpgsig %s'", args); "got 'gpgsig %s'"), args);
*space = '\0'; *space = '\0';


sig->hash_algo = args; sig->hash_algo = args;
@ -2744,13 +2744,13 @@ static void parse_one_signature(struct signature_data *sig, const char *v)
/* Validate hash algorithm */ /* Validate hash algorithm */
if (strcmp(sig->hash_algo, "sha1") && if (strcmp(sig->hash_algo, "sha1") &&
strcmp(sig->hash_algo, "sha256")) strcmp(sig->hash_algo, "sha256"))
die("Unknown git hash algorithm in gpgsig: '%s'", sig->hash_algo); die(_("unknown git hash algorithm in gpgsig: '%s'"), sig->hash_algo);


/* Validate signature format */ /* Validate signature format */
if (!valid_signature_format(sig->sig_format)) if (!valid_signature_format(sig->sig_format))
die("Invalid signature format in gpgsig: '%s'", sig->sig_format); die(_("invalid signature format in gpgsig: '%s'"), sig->sig_format);
if (!strcmp(sig->sig_format, "unknown")) if (!strcmp(sig->sig_format, "unknown"))
warning("'unknown' signature format in gpgsig"); warning(_("'unknown' signature format in gpgsig"));


/* Read signature data */ /* Read signature data */
read_next_command(); read_next_command();
@ -2789,8 +2789,8 @@ static void store_signature(struct signature_data *stored_sig,
const char *hash_type) const char *hash_type)
{ {
if (stored_sig->hash_algo) { if (stored_sig->hash_algo) {
warning("multiple %s signatures found, " warning(_("multiple %s signatures found, "
"ignoring additional signature", "ignoring additional signature"),
hash_type); hash_type);
strbuf_release(&new_sig->data); strbuf_release(&new_sig->data);
free(new_sig->hash_algo); free(new_sig->hash_algo);
@ -2845,15 +2845,15 @@ static void parse_new_commit(const char *arg)
read_next_command(); read_next_command();
} }
if (!committer) if (!committer)
die("Expected committer but didn't get one"); die(_("expected committer but didn't get one"));


while (skip_prefix(command_buf.buf, "gpgsig ", &v)) { while (skip_prefix(command_buf.buf, "gpgsig ", &v)) {
switch (signed_commit_mode) { switch (signed_commit_mode) {


/* First, modes that don't need the signature to be parsed */ /* First, modes that don't need the signature to be parsed */
case SIGN_ABORT: case SIGN_ABORT:
die("encountered signed commit; use " die(_("encountered signed commit; use "
"--signed-commits=<mode> to handle it"); "--signed-commits=<mode> to handle it"));
case SIGN_WARN_STRIP: case SIGN_WARN_STRIP:
warning(_("stripping a commit signature")); warning(_("stripping a commit signature"));
/* fallthru */ /* fallthru */
@ -3025,11 +3025,11 @@ static void parse_new_tag(const char *arg)


/* from ... */ /* from ... */
if (!skip_prefix(command_buf.buf, "from ", &from)) if (!skip_prefix(command_buf.buf, "from ", &from))
die("Expected from command, got %s", command_buf.buf); die(_("expected 'from' command, got '%s'"), command_buf.buf);
s = lookup_branch(from); s = lookup_branch(from);
if (s) { if (s) {
if (is_null_oid(&s->oid)) if (is_null_oid(&s->oid))
die("Can't tag an empty branch."); die(_("can't tag an empty branch."));
oidcpy(&oid, &s->oid); oidcpy(&oid, &s->oid);
type = OBJ_COMMIT; type = OBJ_COMMIT;
} else if (*from == ':') { } else if (*from == ':') {
@ -3044,11 +3044,11 @@ static void parse_new_tag(const char *arg)
type = odb_read_object_info(the_repository->objects, type = odb_read_object_info(the_repository->objects,
&oid, NULL); &oid, NULL);
if (type < 0) if (type < 0)
die("Not a valid object: %s", from); die(_("not a valid object: %s"), from);
} else } else
type = oe->type; type = oe->type;
} else } else
die("Invalid ref name or SHA1 expression: %s", from); die(_("invalid ref name or SHA1 expression: %s"), from);
read_next_command(); read_next_command();


/* original-oid ... */ /* original-oid ... */
@ -3139,7 +3139,7 @@ static void parse_reset_branch(const char *arg)
static void cat_blob_write(const char *buf, unsigned long size) static void cat_blob_write(const char *buf, unsigned long size)
{ {
if (write_in_full(cat_blob_fd, buf, size) < 0) if (write_in_full(cat_blob_fd, buf, size) < 0)
die_errno("Write to frontend failed"); die_errno(_("write to frontend failed"));
} }


static void cat_blob(struct object_entry *oe, struct object_id *oid) static void cat_blob(struct object_entry *oe, struct object_id *oid)
@ -3168,9 +3168,9 @@ static void cat_blob(struct object_entry *oe, struct object_id *oid)
return; return;
} }
if (!buf) if (!buf)
die("Can't read object %s", oid_to_hex(oid)); die(_("can't read object %s"), oid_to_hex(oid));
if (type != OBJ_BLOB) if (type != OBJ_BLOB)
die("Object %s is a %s but a blob was expected.", die(_("object %s is a %s but a blob was expected."),
oid_to_hex(oid), type_name(type)); oid_to_hex(oid), type_name(type));
strbuf_reset(&line); strbuf_reset(&line);
strbuf_addf(&line, "%s %s %"PRIuMAX"\n", oid_to_hex(oid), strbuf_addf(&line, "%s %s %"PRIuMAX"\n", oid_to_hex(oid),
@ -3194,11 +3194,11 @@ static void parse_get_mark(const char *p)


/* get-mark SP <object> LF */ /* get-mark SP <object> LF */
if (*p != ':') if (*p != ':')
die("Not a mark: %s", p); die(_("not a mark: %s"), p);


oe = find_mark(marks, parse_mark_ref_eol(p)); oe = find_mark(marks, parse_mark_ref_eol(p));
if (!oe) if (!oe)
die("Unknown mark: %s", command_buf.buf); die(_("unknown mark: %s"), command_buf.buf);


xsnprintf(output, sizeof(output), "%s\n", oid_to_hex(&oe->idx.oid)); xsnprintf(output, sizeof(output), "%s\n", oid_to_hex(&oe->idx.oid));
cat_blob_write(output, the_hash_algo->hexsz + 1); cat_blob_write(output, the_hash_algo->hexsz + 1);
@ -3213,13 +3213,13 @@ static void parse_cat_blob(const char *p)
if (*p == ':') { if (*p == ':') {
oe = find_mark(marks, parse_mark_ref_eol(p)); oe = find_mark(marks, parse_mark_ref_eol(p));
if (!oe) if (!oe)
die("Unknown mark: %s", command_buf.buf); die(_("unknown mark: %s"), command_buf.buf);
oidcpy(&oid, &oe->idx.oid); oidcpy(&oid, &oe->idx.oid);
} else { } else {
if (parse_mapped_oid_hex(p, &oid, &p)) if (parse_mapped_oid_hex(p, &oid, &p))
die("Invalid dataref: %s", command_buf.buf); die(_("invalid dataref: %s"), command_buf.buf);
if (*p) if (*p)
die("Garbage after SHA1: %s", command_buf.buf); die(_("garbage after SHA1: %s"), command_buf.buf);
oe = find_object(&oid); oe = find_object(&oid);
} }


@ -3237,7 +3237,7 @@ static struct object_entry *dereference(struct object_entry *oe,
enum object_type type = odb_read_object_info(the_repository->objects, enum object_type type = odb_read_object_info(the_repository->objects,
oid, NULL); oid, NULL);
if (type < 0) if (type < 0)
die("object not found: %s", oid_to_hex(oid)); die(_("object not found: %s"), oid_to_hex(oid));
/* cache it! */ /* cache it! */
oe = insert_object(oid); oe = insert_object(oid);
oe->type = type; oe->type = type;
@ -3251,7 +3251,7 @@ static struct object_entry *dereference(struct object_entry *oe,
case OBJ_TAG: case OBJ_TAG:
break; break;
default: default:
die("Not a tree-ish: %s", command_buf.buf); die(_("not a tree-ish: %s"), command_buf.buf);
} }


if (oe->pack_id != MAX_PACK_ID) { /* in a pack being written */ if (oe->pack_id != MAX_PACK_ID) { /* in a pack being written */
@ -3262,19 +3262,19 @@ static struct object_entry *dereference(struct object_entry *oe,
&unused, &size); &unused, &size);
} }
if (!buf) if (!buf)
die("Can't load object %s", oid_to_hex(oid)); die(_("can't load object %s"), oid_to_hex(oid));


/* Peel one layer. */ /* Peel one layer. */
switch (oe->type) { switch (oe->type) {
case OBJ_TAG: case OBJ_TAG:
if (size < hexsz + strlen("object ") || if (size < hexsz + strlen("object ") ||
get_oid_hex(buf + strlen("object "), oid)) get_oid_hex(buf + strlen("object "), oid))
die("Invalid SHA1 in tag: %s", command_buf.buf); die(_("invalid SHA1 in tag: %s"), command_buf.buf);
break; break;
case OBJ_COMMIT: case OBJ_COMMIT:
if (size < hexsz + strlen("tree ") || if (size < hexsz + strlen("tree ") ||
get_oid_hex(buf + strlen("tree "), oid)) get_oid_hex(buf + strlen("tree "), oid))
die("Invalid SHA1 in commit: %s", command_buf.buf); die(_("invalid SHA1 in commit: %s"), command_buf.buf);
} }


free(buf); free(buf);
@ -3309,9 +3309,9 @@ static void build_mark_map(struct string_list *from, struct string_list *to)
for_each_string_list_item(fromp, from) { for_each_string_list_item(fromp, from) {
top = string_list_lookup(to, fromp->string); top = string_list_lookup(to, fromp->string);
if (!fromp->util) { if (!fromp->util) {
die(_("Missing from marks for submodule '%s'"), fromp->string); die(_("missing from marks for submodule '%s'"), fromp->string);
} else if (!top || !top->util) { } else if (!top || !top->util) {
die(_("Missing to marks for submodule '%s'"), fromp->string); die(_("missing to marks for submodule '%s'"), fromp->string);
} }
build_mark_map_one(fromp->util, top->util); build_mark_map_one(fromp->util, top->util);
} }
@ -3325,14 +3325,14 @@ static struct object_entry *parse_treeish_dataref(const char **p)
if (**p == ':') { /* <mark> */ if (**p == ':') { /* <mark> */
e = find_mark(marks, parse_mark_ref_space(p)); e = find_mark(marks, parse_mark_ref_space(p));
if (!e) if (!e)
die("Unknown mark: %s", command_buf.buf); die(_("unknown mark: %s"), command_buf.buf);
oidcpy(&oid, &e->idx.oid); oidcpy(&oid, &e->idx.oid);
} else { /* <sha1> */ } else { /* <sha1> */
if (parse_mapped_oid_hex(*p, &oid, p)) if (parse_mapped_oid_hex(*p, &oid, p))
die("Invalid dataref: %s", command_buf.buf); die(_("invalid dataref: %s"), command_buf.buf);
e = find_object(&oid); e = find_object(&oid);
if (*(*p)++ != ' ') if (*(*p)++ != ' ')
die("Missing space after tree-ish: %s", command_buf.buf); die(_("missing space after tree-ish: %s"), command_buf.buf);
} }


while (!e || e->type != OBJ_TREE) while (!e || e->type != OBJ_TREE)
@ -3376,7 +3376,7 @@ static void parse_ls(const char *p, struct branch *b)
/* ls SP (<tree-ish> SP)? <path> */ /* ls SP (<tree-ish> SP)? <path> */
if (*p == '"') { if (*p == '"') {
if (!b) if (!b)
die("Not in a commit: %s", command_buf.buf); die(_("not in a commit: %s"), command_buf.buf);
root = &b->branch_tree; root = &b->branch_tree;
} else { } else {
struct object_entry *e = parse_treeish_dataref(&p); struct object_entry *e = parse_treeish_dataref(&p);
@ -3439,12 +3439,12 @@ static void parse_alias(void)
/* mark ... */ /* mark ... */
parse_mark(); parse_mark();
if (!next_mark) if (!next_mark)
die(_("Expected 'mark' command, got %s"), command_buf.buf); die(_("expected 'mark' command, got %s"), command_buf.buf);


/* to ... */ /* to ... */
memset(&b, 0, sizeof(b)); memset(&b, 0, sizeof(b));
if (!parse_objectish_with_prefix(&b, "to ")) if (!parse_objectish_with_prefix(&b, "to "))
die(_("Expected 'to' command, got %s"), command_buf.buf); die(_("expected 'to' command, got %s"), command_buf.buf);
e = find_object(&b.oid); e = find_object(&b.oid);
assert(e); assert(e);
insert_mark(&marks, next_mark, e); insert_mark(&marks, next_mark, e);
@ -3462,7 +3462,7 @@ static void option_import_marks(const char *marks,
{ {
if (import_marks_file) { if (import_marks_file) {
if (from_stream) if (from_stream)
die("Only one import-marks command allowed per stream"); die(_("only one import-marks command allowed per stream"));


/* read previous mark file */ /* read previous mark file */
if(!import_marks_file_from_stream) if(!import_marks_file_from_stream)
@ -3486,7 +3486,7 @@ static void option_date_format(const char *fmt)
else if (!strcmp(fmt, "now")) else if (!strcmp(fmt, "now"))
whenspec = WHENSPEC_NOW; whenspec = WHENSPEC_NOW;
else else
die("unknown --date-format argument %s", fmt); die(_("unknown --date-format argument %s"), fmt);
} }


static unsigned long ulong_arg(const char *option, const char *arg) static unsigned long ulong_arg(const char *option, const char *arg)
@ -3494,7 +3494,7 @@ static unsigned long ulong_arg(const char *option, const char *arg)
char *endptr; char *endptr;
unsigned long rv = strtoul(arg, &endptr, 0); unsigned long rv = strtoul(arg, &endptr, 0);
if (strchr(arg, '-') || endptr == arg || *endptr) if (strchr(arg, '-') || endptr == arg || *endptr)
die("%s: argument must be a non-negative integer", option); die(_("%s: argument must be a non-negative integer"), option);
return rv; return rv;
} }


@ -3502,7 +3502,7 @@ static void option_depth(const char *depth)
{ {
max_depth = ulong_arg("--depth", depth); max_depth = ulong_arg("--depth", depth);
if (max_depth > MAX_DEPTH) if (max_depth > MAX_DEPTH)
die("--depth cannot exceed %u", MAX_DEPTH); die(_("--depth cannot exceed %u"), MAX_DEPTH);
} }


static void option_active_branches(const char *branches) static void option_active_branches(const char *branches)
@ -3520,7 +3520,7 @@ static void option_cat_blob_fd(const char *fd)
{ {
unsigned long n = ulong_arg("--cat-blob-fd", fd); unsigned long n = ulong_arg("--cat-blob-fd", fd);
if (n > (unsigned long) INT_MAX) if (n > (unsigned long) INT_MAX)
die("--cat-blob-fd cannot exceed %d", INT_MAX); die(_("--cat-blob-fd cannot exceed %d"), INT_MAX);
cat_blob_fd = (int) n; cat_blob_fd = (int) n;
} }


@ -3540,7 +3540,7 @@ static void option_rewrite_submodules(const char *arg, struct string_list *list)
char *s = xstrdup(arg); char *s = xstrdup(arg);
char *f = strchr(s, ':'); char *f = strchr(s, ':');
if (!f) if (!f)
die(_("Expected format name:filename for submodule rewrite option")); die(_("expected format name:filename for submodule rewrite option"));
*f = '\0'; *f = '\0';
f++; f++;
CALLOC_ARRAY(ms, 1); CALLOC_ARRAY(ms, 1);
@ -3548,7 +3548,7 @@ static void option_rewrite_submodules(const char *arg, struct string_list *list)
f = prefix_filename(global_prefix, f); f = prefix_filename(global_prefix, f);
fp = fopen(f, "r"); fp = fopen(f, "r");
if (!fp) if (!fp)
die_errno("cannot read '%s'", f); die_errno(_("cannot read '%s'"), f);
read_mark_file(&ms, fp, insert_oid_entry); read_mark_file(&ms, fp, insert_oid_entry);
fclose(fp); fclose(fp);
free(f); free(f);
@ -3565,10 +3565,10 @@ static int parse_one_option(const char *option)
if (!git_parse_ulong(option, &v)) if (!git_parse_ulong(option, &v))
return 0; return 0;
if (v < 8192) { if (v < 8192) {
warning("max-pack-size is now in bytes, assuming --max-pack-size=%lum", v); warning(_("max-pack-size is now in bytes, assuming --max-pack-size=%lum"), v);
v *= 1024 * 1024; v *= 1024 * 1024;
} else if (v < 1024 * 1024) { } else if (v < 1024 * 1024) {
warning("minimum max-pack-size is 1 MiB"); warning(_("minimum max-pack-size is 1 MiB"));
v = 1024 * 1024; v = 1024 * 1024;
} }
max_packsize = v; max_packsize = v;
@ -3655,23 +3655,23 @@ static int parse_one_feature(const char *feature, int from_stream)
static void parse_feature(const char *feature) static void parse_feature(const char *feature)
{ {
if (seen_data_command) if (seen_data_command)
die("Got feature command '%s' after data command", feature); die(_("got feature command '%s' after data command"), feature);


if (parse_one_feature(feature, 1)) if (parse_one_feature(feature, 1))
return; return;


die("This version of fast-import does not support feature %s.", feature); die(_("this version of fast-import does not support feature %s."), feature);
} }


static void parse_option(const char *option) static void parse_option(const char *option)
{ {
if (seen_data_command) if (seen_data_command)
die("Got option command '%s' after data command", option); die(_("got option command '%s' after data command"), option);


if (parse_one_option(option)) if (parse_one_option(option))
return; return;


die("This version of fast-import does not support option: %s", option); die(_("this version of fast-import does not support option: %s"), option);
} }


static void git_pack_config(void) static void git_pack_config(void)
@ -3715,7 +3715,7 @@ static void parse_argv(void)
break; break;


if (!skip_prefix(a, "--", &a)) if (!skip_prefix(a, "--", &a))
die("unknown option %s", a); die(_("unknown option %s"), a);


if (parse_one_option(a)) if (parse_one_option(a))
continue; continue;
@ -3728,7 +3728,7 @@ static void parse_argv(void)
continue; continue;
} }


die("unknown option --%s", a); die(_("unknown option --%s"), a);
} }
if (i != global_argc) if (i != global_argc)
usage(fast_import_usage); usage(fast_import_usage);
@ -3817,7 +3817,7 @@ int cmd_fast_import(int argc,
else if (starts_with(command_buf.buf, "option ")) else if (starts_with(command_buf.buf, "option "))
/* ignore non-git options*/; /* ignore non-git options*/;
else else
die("Unsupported command: %s", command_buf.buf); die(_("unsupported command: %s"), command_buf.buf);


if (checkpoint_requested) if (checkpoint_requested)
checkpoint(); checkpoint();
@ -3828,7 +3828,7 @@ int cmd_fast_import(int argc,
parse_argv(); parse_argv();


if (require_explicit_termination && feof(stdin)) if (require_explicit_termination && feof(stdin))
die("stream ends early"); die(_("stream ends early"));


end_packfile(); end_packfile();



4
gpg-interface.c
View File

@ -443,7 +443,7 @@ static void parse_ssh_output(struct signature_check *sigc)


key = strstr(line, "key "); key = strstr(line, "key ");
if (key) { if (key) {
sigc->fingerprint = xstrdup(strstr(line, "key ") + 4); sigc->fingerprint = xstrdup(key + 4);
sigc->key = xstrdup(sigc->fingerprint); sigc->key = xstrdup(sigc->fingerprint);
} else { } else {
/* /*
@ -879,7 +879,7 @@ static char *get_default_ssh_signing_key(void)
n = split_cmdline(key_command, &argv); n = split_cmdline(key_command, &argv);


if (n < 0) if (n < 0)
die("malformed build-time gpg.ssh.defaultKeyCommand: %s", die(_("malformed build-time gpg.ssh.defaultKeyCommand: %s"),
split_cmdline_strerror(n)); split_cmdline_strerror(n));


strvec_pushv(&ssh_default_key.args, argv); strvec_pushv(&ssh_default_key.args, argv);

6
gpg-interface.h
View File

@ -3,9 +3,9 @@


struct strbuf; struct strbuf;


#define GPG_VERIFY_VERBOSE 1 #define GPG_VERIFY_VERBOSE (1<<0)
#define GPG_VERIFY_RAW 2 #define GPG_VERIFY_RAW (1<<1)
#define GPG_VERIFY_OMIT_STATUS 4 #define GPG_VERIFY_OMIT_STATUS (1<<2)


enum signature_trust_level { enum signature_trust_level {
TRUST_UNDEFINED, TRUST_UNDEFINED,

20
t/t9300-fast-import.sh
View File

@ -2927,16 +2927,16 @@ test_expect_success 'R: blob appears only once' '
# The error message when a space is missing not at the # The error message when a space is missing not at the
# end of the line is: # end of the line is:
# #
# Missing space after .. # missing space after ..
# #
# or when extra characters come after the mark at the end # or when extra characters come after the mark at the end
# of the line: # of the line:
# #
# Garbage after .. # garbage after ..
# #
# or when the dataref is neither "inline " or a known SHA1, # or when the dataref is neither "inline " or a known SHA1,
# #
# Invalid dataref .. # invalid dataref ..
# #
test_expect_success 'S: initialize for S tests' ' test_expect_success 'S: initialize for S tests' '
test_tick && test_tick &&
@ -3405,15 +3405,15 @@ test_path_fail () {


test_path_base_fail () { test_path_base_fail () {
local change="$1" prefix="$2" field="$3" suffix="$4" local change="$1" prefix="$2" field="$3" suffix="$4"
test_path_fail "$change" 'unclosed " in '"$field" "$prefix" '"hello.c' "$suffix" "Invalid $field" test_path_fail "$change" 'unclosed " in '"$field" "$prefix" '"hello.c' "$suffix" "invalid $field"
test_path_fail "$change" "invalid escape in quoted $field" "$prefix" '"hello\xff"' "$suffix" "Invalid $field" test_path_fail "$change" "invalid escape in quoted $field" "$prefix" '"hello\xff"' "$suffix" "invalid $field"
test_path_fail "$change" "escaped NUL in quoted $field" "$prefix" '"hello\000"' "$suffix" "NUL in $field" test_path_fail "$change" "escaped NUL in quoted $field" "$prefix" '"hello\000"' "$suffix" "NUL in $field"
} }
test_path_eol_quoted_fail () { test_path_eol_quoted_fail () {
local change="$1" prefix="$2" field="$3" local change="$1" prefix="$2" field="$3"
test_path_base_fail "$change" "$prefix" "$field" '' test_path_base_fail "$change" "$prefix" "$field" ''
test_path_fail "$change" "garbage after quoted $field" "$prefix" '"hello.c"' 'x' "Garbage after $field" test_path_fail "$change" "garbage after quoted $field" "$prefix" '"hello.c"' 'x' "garbage after $field"
test_path_fail "$change" "space after quoted $field" "$prefix" '"hello.c"' ' ' "Garbage after $field" test_path_fail "$change" "space after quoted $field" "$prefix" '"hello.c"' ' ' "garbage after $field"
} }
test_path_eol_fail () { test_path_eol_fail () {
local change="$1" prefix="$2" field="$3" local change="$1" prefix="$2" field="$3"
@ -3422,8 +3422,8 @@ test_path_eol_fail () {
test_path_space_fail () { test_path_space_fail () {
local change="$1" prefix="$2" field="$3" local change="$1" prefix="$2" field="$3"
test_path_base_fail "$change" "$prefix" "$field" ' world.c' test_path_base_fail "$change" "$prefix" "$field" ' world.c'
test_path_fail "$change" "missing space after quoted $field" "$prefix" '"hello.c"' 'x world.c' "Missing space after $field" test_path_fail "$change" "missing space after quoted $field" "$prefix" '"hello.c"' 'x world.c' "missing space after $field"
test_path_fail "$change" "missing space after unquoted $field" "$prefix" 'hello.c' '' "Missing space after $field" test_path_fail "$change" "missing space after unquoted $field" "$prefix" 'hello.c' '' "missing space after $field"
} }


test_path_eol_fail filemodify 'M 100644 :1 ' path test_path_eol_fail filemodify 'M 100644 :1 ' path
@ -3820,7 +3820,7 @@ test_expect_success 'X: replace ref that becomes useless is removed' '
sed -e s/othername/somename/ tmp >tmp2 && sed -e s/othername/somename/ tmp >tmp2 &&
git fast-import --force <tmp2 2>msgs && git fast-import --force <tmp2 2>msgs &&


grep "Dropping.*since it would point to itself" msgs && grep "dropping.*since it would point to itself" msgs &&
git show-ref >refs && git show-ref >refs &&
! grep refs/replace refs ! grep refs/replace refs
) )