From: Junio C Hamano <gitster@pobox.com>
Date: Wed, 26 Oct 2016 20:14:45 +0000 (-0700)
Subject: Merge branch 'jc/cocci-xstrdup-or-null'
X-Git-Tag: v2.11.0-rc0~45
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/a03973893bdbc1a53c705daf70a73994ac46492f?hp=-c

Merge branch 'jc/cocci-xstrdup-or-null'

Code cleanup.

* jc/cocci-xstrdup-or-null:
cocci: refactor common patterns to use xstrdup_or_null()
---

a03973893bdbc1a53c705daf70a73994ac46492f
diff --combined git.c
index be58788deb,f914490e14..efa1059fe0
--- a/git.c
+++ b/git.c
@@@ -35,8 -35,7 +35,7 @@@ static void save_env_before_alias(void
  	orig_cwd = xgetcwd();
  	for (i = 0; i < ARRAY_SIZE(env_names); i++) {
  		orig_env[i] = getenv(env_names[i]);
- 		if (orig_env[i])
- 			orig_env[i] = xstrdup(orig_env[i]);
+ 		orig_env[i] = xstrdup_or_null(orig_env[i]);
  	}
  }
  
@@@ -164,20 -163,6 +163,20 @@@ static int handle_options(const char **
  			setenv(GIT_WORK_TREE_ENVIRONMENT, cmd, 1);
  			if (envchanged)
  				*envchanged = 1;
 +		} else if (!strcmp(cmd, "--super-prefix")) {
 +			if (*argc < 2) {
 +				fprintf(stderr, "No prefix given for --super-prefix.\n" );
 +				usage(git_usage_string);
 +			}
 +			setenv(GIT_SUPER_PREFIX_ENVIRONMENT, (*argv)[1], 1);
 +			if (envchanged)
 +				*envchanged = 1;
 +			(*argv)++;
 +			(*argc)--;
 +		} else if (skip_prefix(cmd, "--super-prefix=", &cmd)) {
 +			setenv(GIT_SUPER_PREFIX_ENVIRONMENT, cmd, 1);
 +			if (envchanged)
 +				*envchanged = 1;
  		} else if (!strcmp(cmd, "--bare")) {
  			char *cwd = xgetcwd();
  			is_bare_repository_cfg = 1;
@@@ -324,7 -309,6 +323,7 @@@ static int handle_alias(int *argcp, con
   * RUN_SETUP for reading from the configuration file.
   */
  #define NEED_WORK_TREE		(1<<3)
 +#define SUPPORT_SUPER_PREFIX	(1<<4)
  
  struct cmd_struct {
  	const char *cmd;
@@@ -359,13 -343,6 +358,13 @@@ static int run_builtin(struct cmd_struc
  	}
  	commit_pager_choice();
  
 +	if (!help && get_super_prefix()) {
 +		if (!(p->option & SUPPORT_SUPER_PREFIX))
 +			die("%s doesn't support --super-prefix", p->cmd);
 +		if (prefix)
 +			die("can't use --super-prefix from a subdirectory");
 +	}
 +
  	if (!help && p->option & NEED_WORK_TREE)
  		setup_work_tree();
  
@@@ -443,7 -420,7 +442,7 @@@ static struct cmd_struct commands[] = 
  	{ "init-db", cmd_init_db },
  	{ "interpret-trailers", cmd_interpret_trailers, RUN_SETUP_GENTLY },
  	{ "log", cmd_log, RUN_SETUP },
 -	{ "ls-files", cmd_ls_files, RUN_SETUP },
 +	{ "ls-files", cmd_ls_files, RUN_SETUP | SUPPORT_SUPER_PREFIX },
  	{ "ls-remote", cmd_ls_remote, RUN_SETUP_GENTLY },
  	{ "ls-tree", cmd_ls_tree, RUN_SETUP },
  	{ "mailinfo", cmd_mailinfo },
@@@ -466,7 -443,7 +465,7 @@@
  	{ "pack-objects", cmd_pack_objects, RUN_SETUP },
  	{ "pack-redundant", cmd_pack_redundant, RUN_SETUP },
  	{ "pack-refs", cmd_pack_refs, RUN_SETUP },
 -	{ "patch-id", cmd_patch_id },
 +	{ "patch-id", cmd_patch_id, RUN_SETUP_GENTLY },
  	{ "pickaxe", cmd_blame, RUN_SETUP },
  	{ "prune", cmd_prune, RUN_SETUP },
  	{ "prune-packed", cmd_prune_packed, RUN_SETUP },
@@@ -544,34 -521,21 +543,34 @@@ static void strip_extension(const char 
  
  static void handle_builtin(int argc, const char **argv)
  {
 +	struct argv_array args = ARGV_ARRAY_INIT;
  	const char *cmd;
  	struct cmd_struct *builtin;
  
  	strip_extension(argv);
  	cmd = argv[0];
  
 -	/* Turn "git cmd --help" into "git help cmd" */
 +	/* Turn "git cmd --help" into "git help --exclude-guides cmd" */
  	if (argc > 1 && !strcmp(argv[1], "--help")) {
 +		int i;
 +
  		argv[1] = argv[0];
  		argv[0] = cmd = "help";
 +
 +		for (i = 0; i < argc; i++) {
 +			argv_array_push(&args, argv[i]);
 +			if (!i)
 +				argv_array_push(&args, "--exclude-guides");
 +		}
 +
 +		argc++;
 +		argv = args.argv;
  	}
  
  	builtin = get_builtin(cmd);
  	if (builtin)
  		exit(run_builtin(builtin, argc, argv));
 +	argv_array_clear(&args);
  }
  
  static void execv_dashed_external(const char **argv)
@@@ -580,9 -544,6 +579,9 @@@
  	const char *tmp;
  	int status;
  
 +	if (get_super_prefix())
 +		die("%s doesn't support --super-prefix", argv[0]);
 +
  	if (use_pager == -1)
  		use_pager = check_pager_config(argv[0]);
  	commit_pager_choice();
diff --combined imap-send.c
index adb9738c30,9514ddc565..5c7e27a894
--- a/imap-send.c
+++ b/imap-send.c
@@@ -1082,10 -1082,8 +1082,8 @@@ static struct imap_store *imap_open_sto
  			cred.protocol = xstrdup(srvc->use_ssl ? "imaps" : "imap");
  			cred.host = xstrdup(srvc->host);
  
- 			if (srvc->user)
- 				cred.username = xstrdup(srvc->user);
- 			if (srvc->pass)
- 				cred.password = xstrdup(srvc->pass);
+ 			cred.username = xstrdup_or_null(srvc->user);
+ 			cred.password = xstrdup_or_null(srvc->pass);
  
  			credential_fill(&cred);
  
@@@ -1410,7 -1408,6 +1408,7 @@@ static CURL *setup_curl(struct imap_ser
  	curl_easy_setopt(curl, CURLOPT_USERNAME, server.user);
  	curl_easy_setopt(curl, CURLOPT_PASSWORD, server.pass);
  
 +	strbuf_addstr(&path, server.use_ssl ? "imaps://" : "imap://");
  	strbuf_addstr(&path, server.host);
  	if (!path.len || path.buf[path.len - 1] != '/')
  		strbuf_addch(&path, '/');
diff --combined refs.c
index abc721b607,62055ab091..9bd0bc177b
--- a/refs.c
+++ b/refs.c
@@@ -9,25 -9,6 +9,25 @@@
  #include "object.h"
  #include "tag.h"
  
 +/*
 + * List of all available backends
 + */
 +static struct ref_storage_be *refs_backends = &refs_be_files;
 +
 +static struct ref_storage_be *find_ref_storage_backend(const char *name)
 +{
 +	struct ref_storage_be *be;
 +	for (be = refs_backends; be; be = be->next)
 +		if (!strcmp(be->name, name))
 +			return be;
 +	return NULL;
 +}
 +
 +int ref_storage_backend_exists(const char *name)
 +{
 +	return find_ref_storage_backend(name) != NULL;
 +}
 +
  /*
   * How to handle various characters in refnames:
   * 0: An acceptable character for refs
@@@ -419,13 -400,6 +419,13 @@@ static char *substitute_branch_name(con
  int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
  {
  	char *last_branch = substitute_branch_name(&str, &len);
 +	int   refs_found  = expand_ref(str, len, sha1, ref);
 +	free(last_branch);
 +	return refs_found;
 +}
 +
 +int expand_ref(const char *str, int len, unsigned char *sha1, char **ref)
 +{
  	const char **p, *r;
  	int refs_found = 0;
  
@@@ -451,6 -425,7 +451,6 @@@
  			warning("ignoring broken ref %s.", fullref);
  		}
  	}
 -	free(last_branch);
  	return refs_found;
  }
  
@@@ -816,8 -791,7 +816,7 @@@ struct ref_update *ref_transaction_add_
  		hashcpy(update->new_sha1, new_sha1);
  	if (flags & REF_HAVE_OLD)
  		hashcpy(update->old_sha1, old_sha1);
- 	if (msg)
- 		update->msg = xstrdup(msg);
+ 	update->msg = xstrdup_or_null(msg);
  	return update;
  }
  
@@@ -883,14 -857,6 +882,14 @@@ int ref_transaction_verify(struct ref_t
  				      flags, NULL, err);
  }
  
 +int update_ref_oid(const char *msg, const char *refname,
 +	       const struct object_id *new_oid, const struct object_id *old_oid,
 +	       unsigned int flags, enum action_on_err onerr)
 +{
 +	return update_ref(msg, refname, new_oid ? new_oid->hash : NULL,
 +		old_oid ? old_oid->hash : NULL, flags, onerr);
 +}
 +
  int update_ref(const char *msg, const char *refname,
  	       const unsigned char *new_sha1, const unsigned char *old_sha1,
  	       unsigned int flags, enum action_on_err onerr)
@@@ -1114,20 -1080,20 +1113,20 @@@ const char *find_descendant_ref(const c
  	return NULL;
  }
  
 -int rename_ref_available(const char *oldname, const char *newname)
 +int rename_ref_available(const char *old_refname, const char *new_refname)
  {
  	struct string_list skip = STRING_LIST_INIT_NODUP;
  	struct strbuf err = STRBUF_INIT;
 -	int ret;
 +	int ok;
  
 -	string_list_insert(&skip, oldname);
 -	ret = !verify_refname_available(newname, NULL, &skip, &err);
 -	if (!ret)
 +	string_list_insert(&skip, old_refname);
 +	ok = !verify_refname_available(new_refname, NULL, &skip, &err);
 +	if (!ok)
  		error("%s", err.buf);
  
  	string_list_clear(&skip, 0);
  	strbuf_release(&err);
 -	return ret;
 +	return ok;
  }
  
  int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
@@@ -1165,13 -1131,9 +1164,13 @@@ int head_ref(each_ref_fn fn, void *cb_d
  static int do_for_each_ref(const char *submodule, const char *prefix,
  			   each_ref_fn fn, int trim, int flags, void *cb_data)
  {
 +	struct ref_store *refs = get_ref_store(submodule);
  	struct ref_iterator *iter;
  
 -	iter = files_ref_iterator_begin(submodule, prefix, flags);
 +	if (!refs)
 +		return 0;
 +
 +	iter = refs->be->iterator_begin(refs, prefix, flags);
  	iter = prefix_ref_iterator_begin(iter, prefix, trim);
  
  	return do_for_each_ref_iterator(iter, fn, cb_data);
@@@ -1230,10 -1192,8 +1229,10 @@@ int for_each_rawref(each_ref_fn fn, voi
  }
  
  /* This function needs to return a meaningful errno on failure */
 -const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
 -			       unsigned char *sha1, int *flags)
 +static const char *resolve_ref_recursively(struct ref_store *refs,
 +					   const char *refname,
 +					   int resolve_flags,
 +					   unsigned char *sha1, int *flags)
  {
  	static struct strbuf sb_refname = STRBUF_INIT;
  	int unused_flags;
@@@ -1265,8 -1225,7 +1264,8 @@@
  	for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
  		unsigned int read_flags = 0;
  
 -		if (read_raw_ref(refname, sha1, &sb_refname, &read_flags)) {
 +		if (refs->be->read_raw_ref(refs, refname,
 +					   sha1, &sb_refname, &read_flags)) {
  			*flags |= read_flags;
  			if (errno != ENOENT || (resolve_flags & RESOLVE_REF_READING))
  				return NULL;
@@@ -1305,266 -1264,3 +1304,266 @@@
  	errno = ELOOP;
  	return NULL;
  }
 +
 +/* backend functions */
 +int refs_init_db(struct strbuf *err)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->init_db(refs, err);
 +}
 +
 +const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
 +			       unsigned char *sha1, int *flags)
 +{
 +	return resolve_ref_recursively(get_ref_store(NULL), refname,
 +				       resolve_flags, sha1, flags);
 +}
 +
 +int resolve_gitlink_ref(const char *submodule, const char *refname,
 +			unsigned char *sha1)
 +{
 +	size_t len = strlen(submodule);
 +	struct ref_store *refs;
 +	int flags;
 +
 +	while (len && submodule[len - 1] == '/')
 +		len--;
 +
 +	if (!len)
 +		return -1;
 +
 +	if (submodule[len]) {
 +		/* We need to strip off one or more trailing slashes */
 +		char *stripped = xmemdupz(submodule, len);
 +
 +		refs = get_ref_store(stripped);
 +		free(stripped);
 +	} else {
 +		refs = get_ref_store(submodule);
 +	}
 +
 +	if (!refs)
 +		return -1;
 +
 +	if (!resolve_ref_recursively(refs, refname, 0, sha1, &flags) ||
 +	    is_null_sha1(sha1))
 +		return -1;
 +	return 0;
 +}
 +
 +/* A pointer to the ref_store for the main repository: */
 +static struct ref_store *main_ref_store;
 +
 +/* A linked list of ref_stores for submodules: */
 +static struct ref_store *submodule_ref_stores;
 +
 +void base_ref_store_init(struct ref_store *refs,
 +			 const struct ref_storage_be *be,
 +			 const char *submodule)
 +{
 +	refs->be = be;
 +	if (!submodule) {
 +		if (main_ref_store)
 +			die("BUG: main_ref_store initialized twice");
 +
 +		refs->submodule = "";
 +		refs->next = NULL;
 +		main_ref_store = refs;
 +	} else {
 +		if (lookup_ref_store(submodule))
 +			die("BUG: ref_store for submodule '%s' initialized twice",
 +			    submodule);
 +
 +		refs->submodule = xstrdup(submodule);
 +		refs->next = submodule_ref_stores;
 +		submodule_ref_stores = refs;
 +	}
 +}
 +
 +struct ref_store *ref_store_init(const char *submodule)
 +{
 +	const char *be_name = "files";
 +	struct ref_storage_be *be = find_ref_storage_backend(be_name);
 +
 +	if (!be)
 +		die("BUG: reference backend %s is unknown", be_name);
 +
 +	if (!submodule || !*submodule)
 +		return be->init(NULL);
 +	else
 +		return be->init(submodule);
 +}
 +
 +struct ref_store *lookup_ref_store(const char *submodule)
 +{
 +	struct ref_store *refs;
 +
 +	if (!submodule || !*submodule)
 +		return main_ref_store;
 +
 +	for (refs = submodule_ref_stores; refs; refs = refs->next) {
 +		if (!strcmp(submodule, refs->submodule))
 +			return refs;
 +	}
 +
 +	return NULL;
 +}
 +
 +struct ref_store *get_ref_store(const char *submodule)
 +{
 +	struct ref_store *refs;
 +
 +	if (!submodule || !*submodule) {
 +		refs = lookup_ref_store(NULL);
 +
 +		if (!refs)
 +			refs = ref_store_init(NULL);
 +	} else {
 +		refs = lookup_ref_store(submodule);
 +
 +		if (!refs) {
 +			struct strbuf submodule_sb = STRBUF_INIT;
 +
 +			strbuf_addstr(&submodule_sb, submodule);
 +			if (is_nonbare_repository_dir(&submodule_sb))
 +				refs = ref_store_init(submodule);
 +			strbuf_release(&submodule_sb);
 +		}
 +	}
 +
 +	return refs;
 +}
 +
 +void assert_main_repository(struct ref_store *refs, const char *caller)
 +{
 +	if (*refs->submodule)
 +		die("BUG: %s called for a submodule", caller);
 +}
 +
 +/* backend functions */
 +int pack_refs(unsigned int flags)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->pack_refs(refs, flags);
 +}
 +
 +int peel_ref(const char *refname, unsigned char *sha1)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->peel_ref(refs, refname, sha1);
 +}
 +
 +int create_symref(const char *ref_target, const char *refs_heads_master,
 +		  const char *logmsg)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->create_symref(refs, ref_target, refs_heads_master,
 +				       logmsg);
 +}
 +
 +int ref_transaction_commit(struct ref_transaction *transaction,
 +			   struct strbuf *err)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->transaction_commit(refs, transaction, err);
 +}
 +
 +int verify_refname_available(const char *refname,
 +			     const struct string_list *extra,
 +			     const struct string_list *skip,
 +			     struct strbuf *err)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->verify_refname_available(refs, refname, extra, skip, err);
 +}
 +
 +int for_each_reflog(each_ref_fn fn, void *cb_data)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +	struct ref_iterator *iter;
 +
 +	iter = refs->be->reflog_iterator_begin(refs);
 +
 +	return do_for_each_ref_iterator(iter, fn, cb_data);
 +}
 +
 +int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
 +				void *cb_data)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->for_each_reflog_ent_reverse(refs, refname,
 +						     fn, cb_data);
 +}
 +
 +int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
 +			void *cb_data)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
 +}
 +
 +int reflog_exists(const char *refname)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->reflog_exists(refs, refname);
 +}
 +
 +int safe_create_reflog(const char *refname, int force_create,
 +		       struct strbuf *err)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->create_reflog(refs, refname, force_create, err);
 +}
 +
 +int delete_reflog(const char *refname)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->delete_reflog(refs, refname);
 +}
 +
 +int reflog_expire(const char *refname, const unsigned char *sha1,
 +		  unsigned int flags,
 +		  reflog_expiry_prepare_fn prepare_fn,
 +		  reflog_expiry_should_prune_fn should_prune_fn,
 +		  reflog_expiry_cleanup_fn cleanup_fn,
 +		  void *policy_cb_data)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->reflog_expire(refs, refname, sha1, flags,
 +				       prepare_fn, should_prune_fn,
 +				       cleanup_fn, policy_cb_data);
 +}
 +
 +int initial_ref_transaction_commit(struct ref_transaction *transaction,
 +				   struct strbuf *err)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->initial_transaction_commit(refs, transaction, err);
 +}
 +
 +int delete_refs(struct string_list *refnames, unsigned int flags)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->delete_refs(refs, refnames, flags);
 +}
 +
 +int rename_ref(const char *oldref, const char *newref, const char *logmsg)
 +{
 +	struct ref_store *refs = get_ref_store(NULL);
 +
 +	return refs->be->rename_ref(refs, oldref, newref, logmsg);
 +}