Subject: Re: [PATCH 14/22] refs/files-backend.c: mark strings for translation

From: Junio C Hamano <[email-masked]>
Date: Mon, 29 Feb 2016 10:43:49 -0800

Nguyễn Thái Ngọc Duy  <[email-masked]> writes:

> Signed-off-by: Nguyễn Thái Ngọc Duy <[email-masked]>
> ---

I'd really prefer to avoid any code churn on this file before the
dust settles for David's and Michael's series (the former is in
'pu', the latter is not but was already rerolled once) both of which
touch this file heavily.

>  refs/files-backend.c | 86 ++++++++++++++++++++++++++--------------------------
>  1 file changed, 43 insertions(+), 43 deletions(-)
>
> diff --git a/refs/files-backend.c b/refs/files-backend.c
> index 81f68f8..bf76094 100644
> --- a/refs/files-backend.c
> +++ b/refs/files-backend.c
> @@ -203,7 +203,7 @@ static struct ref_entry *create_ref_entry(const char *refname,
>  
>  	if (check_name &&
>  	    check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
> -		die("Reference has invalid format: '%s'", refname);
> +		die(_("Reference has invalid format: '%s'"), refname);
>  	FLEX_ALLOC_STR(ref, name, refname);
>  	hashcpy(ref->u.value.oid.hash, sha1);
>  	oidclr(&ref->u.value.peeled);
> @@ -475,12 +475,12 @@ static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2
>  
>  	if ((ref1->flag & REF_DIR) || (ref2->flag & REF_DIR))
>  		/* This is impossible by construction */
> -		die("Reference directory conflict: %s", ref1->name);
> +		die(_("Reference directory conflict: %s"), ref1->name);
>  
>  	if (oidcmp(&ref1->u.value.oid, &ref2->u.value.oid))
> -		die("Duplicated ref, and SHA1s don't match: %s", ref1->name);
> +		die(_("Duplicated ref, and SHA1s don't match: %s"), ref1->name);
>  
> -	warning("Duplicated ref: %s", ref1->name);
> +	warning(_("Duplicated ref: %s"), ref1->name);
>  	return 1;
>  }
>  
> @@ -526,7 +526,7 @@ static int ref_resolves_to_object(struct ref_entry *entry)
>  	if (entry->flag & REF_ISBROKEN)
>  		return 0;
>  	if (!has_sha1_file(entry->u.value.oid.hash)) {
> -		error("%s does not point to a valid object!", entry->name);
> +		error(_("%s does not point to a valid object!"), entry->name);
>  		return 0;
>  	}
>  	return 1;
> @@ -653,7 +653,7 @@ static int do_for_each_entry_in_dirs(struct ref_dir *dir1,
>  				i1++;
>  				i2++;
>  			} else {
> -				die("conflict between reference and directory: %s",
> +				die(_("conflict between reference and directory: %s"),
>  				    e1->name);
>  			}
>  		} else {
> @@ -914,7 +914,7 @@ static void clear_packed_ref_cache(struct ref_cache *refs)
>  		struct packed_ref_cache *packed_refs = refs->packed;
>  
>  		if (packed_refs->lock)
> -			die("internal error: packed-ref cache cleared while locked");
> +			die(_("internal error: packed-ref cache cleared while locked"));
>  		refs->packed = NULL;
>  		release_packed_ref_cache(packed_refs);
>  	}
> @@ -1069,7 +1069,7 @@ static void read_packed_refs(FILE *f, struct ref_dir *dir)
>  
>  			if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
>  				if (!refname_is_safe(refname))
> -					die("packed refname is dangerous: %s", refname);
> +					die(_("packed refname is dangerous: %s"), refname);
>  				hashclr(sha1);
>  				flag |= REF_BAD_NAME | REF_ISBROKEN;
>  			}
> @@ -1239,7 +1239,7 @@ static void read_loose_refs(const char *dirname, struct ref_dir *dir)
>  			if (check_refname_format(refname.buf,
>  						 REFNAME_ALLOW_ONELEVEL)) {
>  				if (!refname_is_safe(refname.buf))
> -					die("loose refname is dangerous: %s", refname.buf);
> +					die(_("loose refname is dangerous: %s"), refname.buf);
>  				hashclr(sha1);
>  				flag |= REF_BAD_NAME | REF_ISBROKEN;
>  			}
> @@ -2099,7 +2099,7 @@ static int commit_packed_refs(void)
>  
>  	out = fdopen_lock_file(packed_ref_cache->lock, "w");
>  	if (!out)
> -		die_errno("unable to fdopen packed-refs descriptor");
> +		die_errno(_("unable to fdopen packed-refs descriptor"));
>  
>  	fprintf_or_die(out, "%s", PACKED_REFS_HEADER);
>  	do_for_each_entry_in_dir(get_packed_ref_dir(packed_ref_cache),
> @@ -2275,7 +2275,7 @@ int pack_refs(unsigned int flags)
>  				 pack_if_possible_fn, &cbdata);
>  
>  	if (commit_packed_refs())
> -		die_errno("unable to overwrite old ref-pack file");
> +		die_errno(_("unable to overwrite old ref-pack file"));
>  
>  	prune_refs(cbdata.ref_to_prune);
>  	return 0;
> @@ -2417,7 +2417,7 @@ static int rename_tmp_log(const char *newrefname)
>  			goto retry;
>  		/* fall through */
>  	default:
> -		error("unable to create directory for %s", newrefname);
> +		error(_("unable to create directory for %s"), newrefname);
>  		goto out;
>  	}
>  
> @@ -2429,7 +2429,7 @@ static int rename_tmp_log(const char *newrefname)
>  			 * Solaris 5.8 gives ENOTDIR.  Sheesh.
>  			 */
>  			if (remove_empty_directories(&path)) {
> -				error("Directory not empty: logs/%s", newrefname);
> +				error(_("Directory not empty: logs/%s"), newrefname);
>  				goto out;
>  			}
>  			goto retry;
> @@ -2441,8 +2441,8 @@ static int rename_tmp_log(const char *newrefname)
>  			 */
>  			goto retry;
>  		} else {
> -			error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s: %s",
> -				newrefname, strerror(errno));
> +			error(_("unable to move logfile %s to logs/%s: %s"),
> +				TMP_RENAMED_LOG, newrefname, strerror(errno));
>  			goto out;
>  		}
>  	}
> @@ -2486,25 +2486,25 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms
>  	struct strbuf err = STRBUF_INIT;
>  
>  	if (log && S_ISLNK(loginfo.st_mode))
> -		return error("reflog for %s is a symlink", oldrefname);
> +		return error(_("reflog for %s is a symlink"), oldrefname);
>  
>  	symref = resolve_ref_unsafe(oldrefname, RESOLVE_REF_READING,
>  				    orig_sha1, &flag);
>  	if (flag & REF_ISSYMREF)
> -		return error("refname %s is a symbolic ref, renaming it is not supported",
> +		return error(_("refname %s is a symbolic ref, renaming it is not supported"),
>  			oldrefname);
>  	if (!symref)
> -		return error("refname %s not found", oldrefname);
> +		return error(_("refname %s not found"), oldrefname);
>  
>  	if (!rename_ref_available(oldrefname, newrefname))
>  		return 1;
>  
>  	if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))
> -		return error("unable to move logfile logs/%s to "TMP_RENAMED_LOG": %s",
> -			oldrefname, strerror(errno));
> +		return error(_("unable to move logfile logs/%s to %s: %s"),
> +			     TMP_RENAMED_LOG, oldrefname, strerror(errno));
>  
>  	if (delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {
> -		error("unable to delete old %s", oldrefname);
> +		error(_("unable to delete old %s"), oldrefname);
>  		goto rollback;
>  	}
>  
> @@ -2519,11 +2519,11 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms
>  			strbuf_release(&path);
>  
>  			if (result) {
> -				error("Directory not empty: %s", newrefname);
> +				error(_("Directory not empty: %s"), newrefname);
>  				goto rollback;
>  			}
>  		} else {
> -			error("unable to delete existing %s", newrefname);
> +			error(_("unable to delete existing %s"), newrefname);
>  			goto rollback;
>  		}
>  	}
> @@ -2535,7 +2535,7 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms
>  
>  	lock = lock_ref_sha1_basic(newrefname, NULL, NULL, NULL, 0, NULL, &err);
>  	if (!lock) {
> -		error("unable to rename '%s' to '%s': %s", oldrefname, newrefname, err.buf);
> +		error(_("unable to rename '%s' to '%s': %s"), oldrefname, newrefname, err.buf);
>  		strbuf_release(&err);
>  		goto rollback;
>  	}
> @@ -2543,7 +2543,7 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms
>  
>  	if (write_ref_to_lockfile(lock, orig_sha1, &err) ||
>  	    commit_ref_update(lock, orig_sha1, logmsg, 0, &err)) {
> -		error("unable to write current sha1 into %s: %s", newrefname, err.buf);
> +		error(_("unable to write current sha1 into %s: %s"), newrefname, err.buf);
>  		strbuf_release(&err);
>  		goto rollback;
>  	}
> @@ -2553,7 +2553,7 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms
>   rollback:
>  	lock = lock_ref_sha1_basic(oldrefname, NULL, NULL, NULL, 0, NULL, &err);
>  	if (!lock) {
> -		error("unable to lock %s for rollback: %s", oldrefname, err.buf);
> +		error(_("unable to lock %s for rollback: %s"), oldrefname, err.buf);
>  		strbuf_release(&err);
>  		goto rollbacklog;
>  	}
> @@ -2562,19 +2562,19 @@ int rename_ref(const char *oldrefname, const char *newrefname, const char *logms
>  	log_all_ref_updates = 0;
>  	if (write_ref_to_lockfile(lock, orig_sha1, &err) ||
>  	    commit_ref_update(lock, orig_sha1, NULL, 0, &err)) {
> -		error("unable to write current sha1 into %s: %s", oldrefname, err.buf);
> +		error(_("unable to write current sha1 into %s: %s"), oldrefname, err.buf);
>  		strbuf_release(&err);
>  	}
>  	log_all_ref_updates = flag;
>  
>   rollbacklog:
>  	if (logmoved && rename(git_path("logs/%s", newrefname), git_path("logs/%s", oldrefname)))
> -		error("unable to restore logfile %s from %s: %s",
> +		error(_("unable to restore logfile %s from %s: %s"),
>  			oldrefname, newrefname, strerror(errno));
>  	if (!logmoved && log &&
>  	    rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", oldrefname)))
> -		error("unable to restore logfile %s from "TMP_RENAMED_LOG": %s",
> -			oldrefname, strerror(errno));
> +		error(_("unable to restore logfile %s from %s: %s"),
> +		      TMP_RENAMED_LOG, oldrefname, strerror(errno));
>  
>  	return 1;
>  }
> @@ -2817,7 +2817,7 @@ static int commit_ref_update(struct ref_lock *lock,
>  		}
>  	}
>  	if (commit_ref(lock)) {
> -		error("Couldn't set %s", lock->ref_name);
> +		error(_("Couldn't set %s"), lock->ref_name);
>  		unlock_ref(lock);
>  		return -1;
>  	}
> @@ -2862,7 +2862,7 @@ static int create_symref_locked(struct ref_lock *lock, const char *refname,
>  	}
>  
>  	if (!fdopen_lock_file(lock->lk, "w"))
> -		return error("unable to fdopen %s: %s",
> +		return error(_("unable to fdopen %s: %s"),
>  			     lock->lk->tempfile.filename.buf, strerror(errno));
>  
>  	update_symref_reflog(lock, refname, target, logmsg);
> @@ -2870,7 +2870,7 @@ static int create_symref_locked(struct ref_lock *lock, const char *refname,
>  	/* no error check; commit_ref will check ferror */
>  	fprintf(lock->lk->tempfile.fp, "ref: %s\n", target);
>  	if (commit_ref(lock) < 0)
> -		return error("unable to write symref for %s: %s", refname,
> +		return error(_("unable to write symref for %s: %s"), refname,
>  			     strerror(errno));
>  	return 0;
>  }
> @@ -2959,7 +2959,7 @@ int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void
>  
>  	/* Jump to the end */
>  	if (fseek(logfp, 0, SEEK_END) < 0)
> -		return error("cannot seek back reflog for %s: %s",
> +		return error(_("cannot seek back reflog for %s: %s"),
>  			     refname, strerror(errno));
>  	pos = ftell(logfp);
>  	while (!ret && 0 < pos) {
> @@ -2971,11 +2971,11 @@ int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void
>  		/* Fill next block from the end */
>  		cnt = (sizeof(buf) < pos) ? sizeof(buf) : pos;
>  		if (fseek(logfp, pos - cnt, SEEK_SET))
> -			return error("cannot seek back reflog for %s: %s",
> +			return error(_("cannot seek back reflog for %s: %s"),
>  				     refname, strerror(errno));
>  		nread = fread(buf, cnt, 1, logfp);
>  		if (nread != 1)
> -			return error("cannot read %d bytes from reflog for %s: %s",
> +			return error(_("cannot read %d bytes from reflog for %s: %s"),
>  				     cnt, refname, strerror(errno));
>  		pos -= cnt;
>  
> @@ -3097,7 +3097,7 @@ static int do_for_each_reflog(struct strbuf *name, each_ref_fn fn, void *cb_data
>  				struct object_id oid;
>  
>  				if (read_ref_full(name->buf, 0, oid.hash, NULL))
> -					retval = error("bad ref for %s", name->buf);
> +					retval = error(_("bad ref for %s"), name->buf);
>  				else
>  					retval = fn(name->buf, &oid, 0, cb_data);
>  			}
> @@ -3447,7 +3447,7 @@ int reflog_expire(const char *refname, const unsigned char *sha1,
>  	 */
>  	lock = lock_ref_sha1_basic(refname, sha1, NULL, NULL, 0, &type, &err);
>  	if (!lock) {
> -		error("cannot lock ref '%s': %s", refname, err.buf);
> +		error(_("cannot lock ref '%s': %s"), refname, err.buf);
>  		strbuf_release(&err);
>  		return -1;
>  	}
> @@ -3474,7 +3474,7 @@ int reflog_expire(const char *refname, const unsigned char *sha1,
>  		}
>  		cb.newlog = fdopen_lock_file(&reflog_lock, "w");
>  		if (!cb.newlog) {
> -			error("cannot fdopen %s (%s)",
> +			error(_("cannot fdopen %s (%s)"),
>  			      get_lock_file_path(&reflog_lock), strerror(errno));
>  			goto failure;
>  		}
> @@ -3497,21 +3497,21 @@ int reflog_expire(const char *refname, const unsigned char *sha1,
>  			!is_null_sha1(cb.last_kept_sha1);
>  
>  		if (close_lock_file(&reflog_lock)) {
> -			status |= error("couldn't write %s: %s", log_file,
> +			status |= error(_("couldn't write %s: %s"), log_file,
>  					strerror(errno));
>  		} else if (update &&
>  			   (write_in_full(get_lock_file_fd(lock->lk),
>  				sha1_to_hex(cb.last_kept_sha1), 40) != 40 ||
>  			    write_str_in_full(get_lock_file_fd(lock->lk), "\n") != 1 ||
>  			    close_ref(lock) < 0)) {
> -			status |= error("couldn't write %s",
> +			status |= error(_("couldn't write %s"),
>  					get_lock_file_path(lock->lk));
>  			rollback_lock_file(&reflog_lock);
>  		} else if (commit_lock_file(&reflog_lock)) {
> -			status |= error("unable to write reflog '%s' (%s)",
> +			status |= error(_("unable to write reflog '%s' (%s)"),
>  					log_file, strerror(errno));
>  		} else if (update && commit_ref(lock)) {
> -			status |= error("couldn't set %s", lock->ref_name);
> +			status |= error(_("couldn't set %s"), lock->ref_name);
>  		}
>  	}
>  	free(log_file);