自学教程：C++ strbuf_release函数代码示例

void show_date_relative(unsigned long time, int tz,			       const struct timeval *now,			       struct strbuf *timebuf){	unsigned long diff;	if (now->tv_sec < time) {		strbuf_addstr(timebuf, _("in the future"));		return;	}	diff = now->tv_sec - time;	if (diff < 90) {		strbuf_addf(timebuf,			 Q_("%lu second ago", "%lu seconds ago", diff), diff);		return;	}	/* Turn it into minutes */	diff = (diff + 30) / 60;	if (diff < 90) {		strbuf_addf(timebuf,			 Q_("%lu minute ago", "%lu minutes ago", diff), diff);		return;	}	/* Turn it into hours */	diff = (diff + 30) / 60;	if (diff < 36) {		strbuf_addf(timebuf,			 Q_("%lu hour ago", "%lu hours ago", diff), diff);		return;	}	/* We deal with number of days from here on */	diff = (diff + 12) / 24;	if (diff < 14) {		strbuf_addf(timebuf,			 Q_("%lu day ago", "%lu days ago", diff), diff);		return;	}	/* Say weeks for the past 10 weeks or so */	if (diff < 70) {		strbuf_addf(timebuf,			 Q_("%lu week ago", "%lu weeks ago", (diff + 3) / 7),			 (diff + 3) / 7);		return;	}	/* Say months for the past 12 months or so */	if (diff < 365) {		strbuf_addf(timebuf,			 Q_("%lu month ago", "%lu months ago", (diff + 15) / 30),			 (diff + 15) / 30);		return;	}	/* Give years and months for 5 years or so */	if (diff < 1825) {		unsigned long totalmonths = (diff * 12 * 2 + 365) / (365 * 2);		unsigned long years = totalmonths / 12;		unsigned long months = totalmonths % 12;		if (months) {			struct strbuf sb = STRBUF_INIT;			strbuf_addf(&sb, Q_("%lu year", "%lu years", years), years);			strbuf_addf(timebuf,				 /* TRANSLATORS: "%s" is "<n> years" */				 Q_("%s, %lu month ago", "%s, %lu months ago", months),				 sb.buf, months);			strbuf_release(&sb);		} else			strbuf_addf(timebuf,				 Q_("%lu year ago", "%lu years ago", years), years);		return;	}	/* Otherwise, just years. Centuries is probably overkill. */	strbuf_addf(timebuf,		 Q_("%lu year ago", "%lu years ago", (diff + 183) / 365),		 (diff + 183) / 365);}

//.........这里部分代码省略.........		}		if (opt->reflog_info) {			/*			 * setup_revisions() ensures that opt->reflog_info			 * and opt->graph cannot both be set,			 * so we don't need to worry about printing the			 * graph info here.			 */			show_reflog_message(opt->reflog_info,					    opt->commit_format == CMIT_FMT_ONELINE,					    &opt->date_mode,					    opt->date_mode_explicit);			if (opt->commit_format == CMIT_FMT_ONELINE)				return;		}	}	if (opt->show_signature) {		show_signature(opt, commit);		show_mergetag(opt, commit);	}	if (!get_cached_commit_buffer(commit, NULL))		return;	if (opt->show_notes) {		int raw;		struct strbuf notebuf = STRBUF_INIT;		raw = (opt->commit_format == CMIT_FMT_USERFORMAT);		format_display_notes(commit->object.oid.hash, &notebuf,				     get_log_output_encoding(), raw);		ctx.notes_message = notebuf.len			? strbuf_detach(&notebuf, NULL)			: xcalloc(1, 1);	}	/*	 * And then the pretty-printed message itself	 */	if (ctx.need_8bit_cte >= 0 && opt->add_signoff)		ctx.need_8bit_cte =			has_non_ascii(fmt_name(getenv("GIT_COMMITTER_NAME"),					       getenv("GIT_COMMITTER_EMAIL")));	ctx.date_mode = opt->date_mode;	ctx.date_mode_explicit = opt->date_mode_explicit;	ctx.abbrev = opt->diffopt.abbrev;	ctx.after_subject = extra_headers;	ctx.preserve_subject = opt->preserve_subject;	ctx.reflog_info = opt->reflog_info;	ctx.fmt = opt->commit_format;	ctx.mailmap = opt->mailmap;	ctx.color = opt->diffopt.use_color;	ctx.expand_tabs_in_log = opt->expand_tabs_in_log;	ctx.output_encoding = get_log_output_encoding();	if (opt->from_ident.mail_begin && opt->from_ident.name_begin)		ctx.from_ident = &opt->from_ident;	if (opt->graph)		ctx.graph_width = graph_width(opt->graph);	pretty_print_commit(&ctx, commit, &msgbuf);	if (opt->add_signoff)		append_signoff(&msgbuf, 0, APPEND_SIGNOFF_DEDUP);	if ((ctx.fmt != CMIT_FMT_USERFORMAT) &&	    ctx.notes_message && *ctx.notes_message) {		if (cmit_fmt_is_mail(ctx.fmt)) {			strbuf_addstr(&msgbuf, "---/n");			opt->shown_dashes = 1;		}		strbuf_addstr(&msgbuf, ctx.notes_message);	}	if (opt->show_log_size) {		printf("log size %i/n", (int)msgbuf.len);		graph_show_oneline(opt->graph);	}	/*	 * Set opt->missing_newline if msgbuf doesn't	 * end in a newline (including if it is empty)	 */	if (!msgbuf.len || msgbuf.buf[msgbuf.len - 1] != '/n')		opt->missing_newline = 1;	else		opt->missing_newline = 0;	if (opt->graph)		graph_show_commit_msg(opt->graph, &msgbuf);	else		fwrite(msgbuf.buf, sizeof(char), msgbuf.len, stdout);	if (opt->use_terminator && !commit_format_is_empty(opt->commit_format)) {		if (!opt->missing_newline)			graph_show_padding(opt->graph);		putchar(opt->diffopt.line_termination);	}	strbuf_release(&msgbuf);	free(ctx.notes_message);}

int cmd_mv(int argc, const char **argv, const char *prefix){	int i, newfd, gitmodules_modified = 0;	int verbose = 0, show_only = 0, force = 0, ignore_errors = 0;	struct option builtin_mv_options[] = {		OPT__VERBOSE(&verbose, N_("be verbose")),		OPT__DRY_RUN(&show_only, N_("dry run")),		OPT__FORCE(&force, N_("force move/rename even if target exists")),		OPT_BOOL('k', NULL, &ignore_errors, N_("skip move/rename errors")),		OPT_END(),	};	const char **source, **destination, **dest_path, **submodule_gitfile;	enum update_mode { BOTH = 0, WORKING_DIRECTORY, INDEX } *modes;	struct stat st;	struct string_list src_for_dst = STRING_LIST_INIT_NODUP;	gitmodules_config();	git_config(git_default_config, NULL);	argc = parse_options(argc, argv, prefix, builtin_mv_options,			     builtin_mv_usage, 0);	if (--argc < 1)		usage_with_options(builtin_mv_usage, builtin_mv_options);	newfd = hold_locked_index(&lock_file, 1);	if (read_cache() < 0)		die(_("index file corrupt"));	source = internal_copy_pathspec(prefix, argv, argc, 0);	modes = xcalloc(argc, sizeof(enum update_mode));	/*	 * Keep trailing slash, needed to let	 * "git mv file no-such-dir/" error out.	 */	dest_path = internal_copy_pathspec(prefix, argv + argc, 1,					   KEEP_TRAILING_SLASH);	submodule_gitfile = xcalloc(argc, sizeof(char *));	if (dest_path[0][0] == '/0')		/* special case: "." was normalized to "" */		destination = internal_copy_pathspec(dest_path[0], argv, argc, DUP_BASENAME);	else if (!lstat(dest_path[0], &st) &&			S_ISDIR(st.st_mode)) {		dest_path[0] = add_slash(dest_path[0]);		destination = internal_copy_pathspec(dest_path[0], argv, argc, DUP_BASENAME);	} else {		if (argc != 1)			die("destination '%s' is not a directory", dest_path[0]);		destination = dest_path;	}	/* Checking */	for (i = 0; i < argc; i++) {		const char *src = source[i], *dst = destination[i];		int length, src_is_dir;		const char *bad = NULL;		if (show_only)			printf(_("Checking rename of '%s' to '%s'/n"), src, dst);		length = strlen(src);		if (lstat(src, &st) < 0)			bad = _("bad source");		else if (!strncmp(src, dst, length) &&				(dst[length] == 0 || dst[length] == '/')) {			bad = _("can not move directory into itself");		} else if ((src_is_dir = S_ISDIR(st.st_mode))				&& lstat(dst, &st) == 0)			bad = _("cannot move directory over file");		else if (src_is_dir) {			int first = cache_name_pos(src, length);			if (first >= 0) {				struct strbuf submodule_dotgit = STRBUF_INIT;				if (!S_ISGITLINK(active_cache[first]->ce_mode))					die (_("Huh? Directory %s is in index and no submodule?"), src);				if (!is_staging_gitmodules_ok())					die (_("Please, stage your changes to .gitmodules or stash them to proceed"));				strbuf_addf(&submodule_dotgit, "%s/.git", src);				submodule_gitfile[i] = read_gitfile(submodule_dotgit.buf);				if (submodule_gitfile[i])					submodule_gitfile[i] = xstrdup(submodule_gitfile[i]);				else					submodule_gitfile[i] = SUBMODULE_WITH_GITDIR;				strbuf_release(&submodule_dotgit);			} else {				const char *src_w_slash = add_slash(src);				int last, len_w_slash = length + 1;				modes[i] = WORKING_DIRECTORY;				first = cache_name_pos(src_w_slash, len_w_slash);				if (first >= 0)					die (_("Huh? %.*s is in index?"),							len_w_slash, src_w_slash);				first = -1 - first;				for (last = first; last < active_nr; last++) {					const char *path = active_cache[last]->name;					if (strncmp(path, src_w_slash, len_w_slash))						break;//.........这里部分代码省略.........

static int locking_available(void){	struct active_request_slot *slot;	struct slot_results results;	struct strbuf in_buffer = STRBUF_INIT;	struct buffer out_buffer = { STRBUF_INIT, 0 };	struct curl_slist *dav_headers = http_copy_default_headers();	struct xml_ctx ctx;	int lock_flags = 0;	char *escaped;	escaped = xml_entities(repo->url);	strbuf_addf(&out_buffer.buf, PROPFIND_SUPPORTEDLOCK_REQUEST, escaped);	free(escaped);	dav_headers = curl_slist_append(dav_headers, "Depth: 0");	dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");	slot = get_active_slot();	slot->results = &results;	curl_setup_http(slot->curl, repo->url, DAV_PROPFIND,			&out_buffer, fwrite_buffer);	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);	curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);	if (start_active_slot(slot)) {		run_active_slot(slot);		if (results.curl_result == CURLE_OK) {			XML_Parser parser = XML_ParserCreate(NULL);			enum XML_Status result;			ctx.name = xcalloc(10, 1);			ctx.len = 0;			ctx.cdata = NULL;			ctx.userFunc = handle_lockprop_ctx;			ctx.userData = &lock_flags;			XML_SetUserData(parser, &ctx);			XML_SetElementHandler(parser, xml_start_tag,					      xml_end_tag);			result = XML_Parse(parser, in_buffer.buf,					   in_buffer.len, 1);			free(ctx.name);			if (result != XML_STATUS_OK) {				fprintf(stderr, "XML error: %s/n",					XML_ErrorString(						XML_GetErrorCode(parser)));				lock_flags = 0;			}			XML_ParserFree(parser);			if (!lock_flags)				error("no DAV locking support on %s",				      repo->url);		} else {			error("Cannot access URL %s, return code %d",			      repo->url, results.curl_result);			lock_flags = 0;		}	} else {		error("Unable to start PROPFIND request on %s", repo->url);	}	strbuf_release(&out_buffer.buf);	strbuf_release(&in_buffer);	curl_slist_free_all(dav_headers);	return lock_flags;}

//.........这里部分代码省略.........			/* symbol for signaling line-wrap (in PAGE_ENCODING) */			const char wrap_symbol[] = { ' ', 0xE2, 0x86, 0xB5, 0 };			int i = ctx.cfg.max_msg_len - strlen(wrap_symbol);			/* Rewind i to preceding space character */			while (i > 0 && !isspace(info->subject[i]))				--i;			if (!i) /* Oops, zero spaces. Reset i */				i = ctx.cfg.max_msg_len - strlen(wrap_symbol);			/* add remainder starting at i to msgbuf */			strbuf_add(&msgbuf, info->subject + i, subject_len - i);			strbuf_trim(&msgbuf);			strbuf_add(&msgbuf, "/n/n", 2);			/* Place wrap_symbol at position i in info->subject */			strcpy(info->subject + i, wrap_symbol);		}	}	cgit_commit_link(info->subject, NULL, NULL, ctx.qry.head,			 sha1_to_hex(commit->object.sha1), ctx.qry.vpath, 0);	show_commit_decorations(commit);	html("</td><td>");	html_txt(info->author);	if (revs->graph) {		html("</td><td>");		cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE);	}	if (ctx.repo->enable_log_filecount || ctx.repo->enable_log_linecount) {		files = 0;		add_lines = 0;		rem_lines = 0;		cgit_diff_commit(commit, inspect_files, ctx.qry.vpath);	}	if (ctx.repo->enable_log_filecount)		htmlf("</td><td>%d", files);	if (ctx.repo->enable_log_linecount)		htmlf("</td><td>-%d/+%d", rem_lines, add_lines);	html("</td></tr>/n");	if (revs->graph || ctx.qry.showmsg) { /* Print a second table row */		html("<tr class='nohover'>");		if (ctx.qry.showmsg) {			/* Concatenate commit message + notes in msgbuf */			if (info->msg && *(info->msg)) {				strbuf_addstr(&msgbuf, info->msg);				strbuf_addch(&msgbuf, '/n');			}			format_note(NULL, commit->object.sha1, &msgbuf,			            PAGE_ENCODING,			            NOTES_SHOW_HEADER | NOTES_INDENT);			strbuf_addch(&msgbuf, '/n');			strbuf_ltrim(&msgbuf);		}		if (revs->graph) {			int lines = 0;			/* Calculate graph padding */			if (ctx.qry.showmsg) {				/* Count #lines in commit message + notes */				const char *p = msgbuf.buf;				lines = 1;				while ((p = strchr(p, '/n'))) {					p++;					lines++;				}			}			/* Print graph padding */			html("<td class='commitgraph'>");			while (lines > 0 || !graph_is_commit_finished(revs->graph)) {				if (graphbuf.len)					html("/n");				strbuf_setlen(&graphbuf, 0);				graph_next_line(revs->graph, &graphbuf);				html(graphbuf.buf);				lines--;			}			html("</td>/n");		}		else			html("<td/>"); /* Empty 'Age' column */		/* Print msgbuf into remainder of table row */		htmlf("<td colspan='%d'%s>/n", cols,			ctx.qry.showmsg ? " class='logmsg'" : "");		html_txt(msgbuf.buf);		html("</td></tr>/n");	}	strbuf_release(&msgbuf);	strbuf_release(&graphbuf);	cgit_free_commitinfo(info);}

//.........这里部分代码省略.........	} else		path = end;	if (!path || !*path)		die("No path specified. See 'man git-pull' for valid url syntax");	/*	 * null-terminate hostname and point path to ~ for URL's like this:	 *    ssh://host.xz/~user/repo	 */	if (protocol != PROTO_LOCAL && host != url) {		char *ptr = path;		if (path[1] == '~')			path++;		else {			path = xstrdup(ptr);			free_path = 1;		}		*ptr = '/0';	}	/*	 * Add support for ssh port: ssh://host.xy:<port>/...	 */	if (protocol == PROTO_SSH && host != url)		port = get_port(end);	if (protocol == PROTO_GIT) {		/* These underlying connection commands die() if they		 * cannot connect.		 */		char *target_host = xstrdup(host);		if (git_use_proxy(host))			conn = git_proxy_connect(fd, host);		else			git_tcp_connect(fd, host, flags);		/*		 * Separate original protocol components prog and path		 * from extended host header with a NUL byte.		 *		 * Note: Do not add any other headers here!  Doing so		 * will cause older git-daemon servers to crash.		 */		packet_write(fd[1],			     "%s %s%chost=%s%c",			     prog, path, 0,			     target_host, 0);		free(target_host);		free(url);		if (free_path)			free(path);		return conn;	}	conn = xcalloc(1, sizeof(*conn));	strbuf_init(&cmd, MAX_CMD_LEN);	strbuf_addstr(&cmd, prog);	strbuf_addch(&cmd, ' ');	sq_quote_buf(&cmd, path);	if (cmd.len >= MAX_CMD_LEN)		die("command line too long");	conn->in = conn->out = -1;	conn->argv = arg = xcalloc(7, sizeof(*arg));	if (protocol == PROTO_SSH) {		const char *ssh = getenv("GIT_SSH");		int putty = ssh && strcasestr(ssh, "plink");		if (!ssh) ssh = "ssh";		*arg++ = ssh;		if (putty && !strcasestr(ssh, "tortoiseplink"))			*arg++ = "-batch";		if (port) {			/* P is for PuTTY, p is for OpenSSH */			*arg++ = putty ? "-P" : "-p";			*arg++ = port;		}		*arg++ = host;	}	else {		/* remove repo-local variables from the environment */		conn->env = local_repo_env;		conn->use_shell = 1;	}	*arg++ = cmd.buf;	*arg = NULL;	if (start_command(conn))		die("unable to fork");	fd[0] = conn->out; /* read from child's stdout */	fd[1] = conn->in;  /* write to child's stdin */	strbuf_release(&cmd);	free(url);	if (free_path)		free(path);	return conn;}

/* * Create a newly-allocated `snapshot` of the `packed-refs` file in * its current state and return it. The return value will already have * its reference count incremented. * * A comment line of the form "# pack-refs with: " may contain zero or * more traits. We interpret the traits as follows: * *   Neither `peeled` nor `fully-peeled`: * *      Probably no references are peeled. But if the file contains a *      peeled value for a reference, we will use it. * *   `peeled`: * *      References under "refs/tags/", if they *can* be peeled, *are* *      peeled in this file. References outside of "refs/tags/" are *      probably not peeled even if they could have been, but if we find *      a peeled value for such a reference we will use it. * *   `fully-peeled`: * *      All references in the file that can be peeled are peeled. *      Inversely (and this is more important), any references in the *      file for which no peeled value is recorded is not peelable. This *      trait should typically be written alongside "peeled" for *      compatibility with older clients, but we do not require it *      (i.e., "peeled" is a no-op if "fully-peeled" is set). * *   `sorted`: * *      The references in this file are known to be sorted by refname. */static struct snapshot *create_snapshot(struct packed_ref_store *refs){	struct snapshot *snapshot = xcalloc(1, sizeof(*snapshot));	int sorted = 0;	snapshot->refs = refs;	acquire_snapshot(snapshot);	snapshot->peeled = PEELED_NONE;	if (!load_contents(snapshot))		return snapshot;	/* If the file has a header line, process it: */	if (snapshot->buf < snapshot->eof && *snapshot->buf == '#') {		struct strbuf tmp = STRBUF_INIT;		char *p;		const char *eol;		struct string_list traits = STRING_LIST_INIT_NODUP;		eol = memchr(snapshot->buf, '/n',			     snapshot->eof - snapshot->buf);		if (!eol)			die_unterminated_line(refs->path,					      snapshot->buf,					      snapshot->eof - snapshot->buf);		strbuf_add(&tmp, snapshot->buf, eol - snapshot->buf);		if (!skip_prefix(tmp.buf, "# pack-refs with:", (const char **)&p))			die_invalid_line(refs->path,					 snapshot->buf,					 snapshot->eof - snapshot->buf);		string_list_split_in_place(&traits, p, ' ', -1);		if (unsorted_string_list_has_string(&traits, "fully-peeled"))			snapshot->peeled = PEELED_FULLY;		else if (unsorted_string_list_has_string(&traits, "peeled"))			snapshot->peeled = PEELED_TAGS;		sorted = unsorted_string_list_has_string(&traits, "sorted");		/* perhaps other traits later as well */		/* The "+ 1" is for the LF character. */		snapshot->header_len = eol + 1 - snapshot->buf;		string_list_clear(&traits, 0);		strbuf_release(&tmp);	}	verify_buffer_safe(snapshot);	if (!sorted) {		sort_snapshot(snapshot);		/*		 * Reordering the records might have moved a short one		 * to the end of the buffer, so verify the buffer's		 * safety again:		 */		verify_buffer_safe(snapshot);	}	if (mmap_strategy != MMAP_OK && snapshot->mmapped) {		/*		 * We don't want to leave the file mmapped, so we are//.........这里部分代码省略.........

static int module_clone(int argc, const char **argv, const char *prefix){	const char *name = NULL, *url = NULL, *depth = NULL;	int quiet = 0;	int progress = 0;	char *p, *path = NULL, *sm_gitdir;	struct strbuf sb = STRBUF_INIT;	struct string_list reference = STRING_LIST_INIT_NODUP;	char *sm_alternate = NULL, *error_strategy = NULL;	struct option module_clone_options[] = {		OPT_STRING(0, "prefix", &prefix,			   N_("path"),			   N_("alternative anchor for relative paths")),		OPT_STRING(0, "path", &path,			   N_("path"),			   N_("where the new submodule will be cloned to")),		OPT_STRING(0, "name", &name,			   N_("string"),			   N_("name of the new submodule")),		OPT_STRING(0, "url", &url,			   N_("string"),			   N_("url where to clone the submodule from")),		OPT_STRING_LIST(0, "reference", &reference,			   N_("repo"),			   N_("reference repository")),		OPT_STRING(0, "depth", &depth,			   N_("string"),			   N_("depth for shallow clones")),		OPT__QUIET(&quiet, "Suppress output for cloning a submodule"),		OPT_BOOL(0, "progress", &progress,			   N_("force cloning progress")),		OPT_END()	};	const char *const git_submodule_helper_usage[] = {		N_("git submodule--helper clone [--prefix=<path>] [--quiet] "		   "[--reference <repository>] [--name <name>] [--depth <depth>] "		   "--url <url> --path <path>"),		NULL	};	argc = parse_options(argc, argv, prefix, module_clone_options,			     git_submodule_helper_usage, 0);	if (argc || !url || !path || !*path)		usage_with_options(git_submodule_helper_usage,				   module_clone_options);	strbuf_addf(&sb, "%s/modules/%s", get_git_dir(), name);	sm_gitdir = absolute_pathdup(sb.buf);	strbuf_reset(&sb);	if (!is_absolute_path(path)) {		strbuf_addf(&sb, "%s/%s", get_git_work_tree(), path);		path = strbuf_detach(&sb, NULL);	} else		path = xstrdup(path);	if (!file_exists(sm_gitdir)) {		if (safe_create_leading_directories_const(sm_gitdir) < 0)			die(_("could not create directory '%s'"), sm_gitdir);		prepare_possible_alternates(name, &reference);		if (clone_submodule(path, sm_gitdir, url, depth, &reference,				    quiet, progress))			die(_("clone of '%s' into submodule path '%s' failed"),			    url, path);	} else {		if (safe_create_leading_directories_const(path) < 0)			die(_("could not create directory '%s'"), path);		strbuf_addf(&sb, "%s/index", sm_gitdir);		unlink_or_warn(sb.buf);		strbuf_reset(&sb);	}	/* Connect module worktree and git dir */	connect_work_tree_and_git_dir(path, sm_gitdir);	p = git_pathdup_submodule(path, "config");	if (!p)		die(_("could not get submodule directory for '%s'"), path);	/* setup alternateLocation and alternateErrorStrategy in the cloned submodule if needed */	git_config_get_string("submodule.alternateLocation", &sm_alternate);	if (sm_alternate)		git_config_set_in_file(p, "submodule.alternateLocation",					   sm_alternate);	git_config_get_string("submodule.alternateErrorStrategy", &error_strategy);	if (error_strategy)		git_config_set_in_file(p, "submodule.alternateErrorStrategy",					   error_strategy);	free(sm_alternate);	free(error_strategy);	strbuf_release(&sb);	free(sm_gitdir);	free(path);//.........这里部分代码省略.........

static int parse_config(const char *var, const char *value, void *data){	struct parse_config_parameter *me = data;	struct submodule *submodule;	struct strbuf name = STRBUF_INIT, item = STRBUF_INIT;	int ret = 0;	/* this also ensures that we only parse submodule entries */	if (!name_and_item_from_var(var, &name, &item))		return 0;	submodule = lookup_or_create_by_name(me->cache, me->gitmodules_sha1,			name.buf);	if (!strcmp(item.buf, "path")) {		struct strbuf path = STRBUF_INIT;		if (!value) {			ret = config_error_nonbool(var);			goto release_return;		}		if (!me->overwrite && submodule->path != NULL) {			warn_multiple_config(me->commit_sha1, submodule->name,					"path");			goto release_return;		}		if (submodule->path)			cache_remove_path(me->cache, submodule);		free((void *) submodule->path);		strbuf_addstr(&path, value);		submodule->path = strbuf_detach(&path, NULL);		cache_put_path(me->cache, submodule);	} else if (!strcmp(item.buf, "fetchrecursesubmodules")) {		/* when parsing worktree configurations we can die early */		int die_on_error = is_null_sha1(me->gitmodules_sha1);		if (!me->overwrite &&		    submodule->fetch_recurse != RECURSE_SUBMODULES_NONE) {			warn_multiple_config(me->commit_sha1, submodule->name,					"fetchrecursesubmodules");			goto release_return;		}		submodule->fetch_recurse = parse_fetch_recurse(var, value,								die_on_error);	} else if (!strcmp(item.buf, "ignore")) {		struct strbuf ignore = STRBUF_INIT;		if (!me->overwrite && submodule->ignore != NULL) {			warn_multiple_config(me->commit_sha1, submodule->name,					"ignore");			goto release_return;		}		if (!value) {			ret = config_error_nonbool(var);			goto release_return;		}		if (strcmp(value, "untracked") && strcmp(value, "dirty") &&		    strcmp(value, "all") && strcmp(value, "none")) {			warning("Invalid parameter '%s' for config option "					"'submodule.%s.ignore'", value, var);			goto release_return;		}		free((void *) submodule->ignore);		strbuf_addstr(&ignore, value);		submodule->ignore = strbuf_detach(&ignore, NULL);	} else if (!strcmp(item.buf, "url")) {		struct strbuf url = STRBUF_INIT;		if (!value) {			ret = config_error_nonbool(var);			goto release_return;		}		if (!me->overwrite && submodule->url != NULL) {			warn_multiple_config(me->commit_sha1, submodule->name,					"url");			goto release_return;		}		free((void *) submodule->url);		strbuf_addstr(&url, value);		submodule->url = strbuf_detach(&url, NULL);	}release_return:	strbuf_release(&name);	strbuf_release(&item);	return ret;}

static int run_service(const char *dir, struct daemon_service *service,		       struct hostinfo *hi){	const char *path;	int enabled = service->enabled;	struct strbuf var = STRBUF_INIT;	loginfo("Request %s for '%s'", service->name, dir);	if (!enabled && !service->overridable) {		logerror("'%s': service not enabled.", service->name);		errno = EACCES;		return daemon_error(dir, "service not enabled");	}	if (!(path = path_ok(dir, hi)))		return daemon_error(dir, "no such repository");	/*	 * Security on the cheap.	 *	 * We want a readable HEAD, usable "objects" directory, and	 * a "git-daemon-export-ok" flag that says that the other side	 * is ok with us doing this.	 *	 * path_ok() uses enter_repo() and does whitelist checking.	 * We only need to make sure the repository is exported.	 */	if (!export_all_trees && access("git-daemon-export-ok", F_OK)) {		logerror("'%s': repository not exported.", path);		errno = EACCES;		return daemon_error(dir, "repository not exported");	}	if (service->overridable) {		strbuf_addf(&var, "daemon.%s", service->config_name);		git_config_get_bool(var.buf, &enabled);		strbuf_release(&var);	}	if (!enabled) {		logerror("'%s': service not enabled for '%s'",			 service->name, path);		errno = EACCES;		return daemon_error(dir, "service not enabled");	}	/*	 * Optionally, a hook can choose to deny access to the	 * repository depending on the phase of the moon.	 */	if (access_hook && run_access_hook(service, dir, path, hi))		return -1;	/*	 * We'll ignore SIGTERM from now on, we have a	 * good client.	 */	signal(SIGTERM, SIG_IGN);	return service->fn();}

static void init_submodule(const char *path, const char *prefix, int quiet){	const struct submodule *sub;	struct strbuf sb = STRBUF_INIT;	char *upd = NULL, *url = NULL, *displaypath;	/* Only loads from .gitmodules, no overlay with .git/config */	gitmodules_config();	if (prefix && get_super_prefix())		die("BUG: cannot have prefix and superprefix");	else if (prefix)		displaypath = xstrdup(relative_path(path, prefix, &sb));	else if (get_super_prefix()) {		strbuf_addf(&sb, "%s%s", get_super_prefix(), path);		displaypath = strbuf_detach(&sb, NULL);	} else		displaypath = xstrdup(path);	sub = submodule_from_path(null_sha1, path);	if (!sub)		die(_("No url found for submodule path '%s' in .gitmodules"),			displaypath);	/*	 * NEEDSWORK: In a multi-working-tree world, this needs to be	 * set in the per-worktree config.	 *	 * Set active flag for the submodule being initialized	 */	if (!is_submodule_initialized(path)) {		strbuf_reset(&sb);		strbuf_addf(&sb, "submodule.%s.active", sub->name);		git_config_set_gently(sb.buf, "true");	}	/*	 * Copy url setting when it is not set yet.	 * To look up the url in .git/config, we must not fall back to	 * .gitmodules, so look it up directly.	 */	strbuf_reset(&sb);	strbuf_addf(&sb, "submodule.%s.url", sub->name);	if (git_config_get_string(sb.buf, &url)) {		if (!sub->url)			die(_("No url found for submodule path '%s' in .gitmodules"),				displaypath);		url = xstrdup(sub->url);		/* Possibly a url relative to parent */		if (starts_with_dot_dot_slash(url) ||		    starts_with_dot_slash(url)) {			char *remoteurl, *relurl;			char *remote = get_default_remote();			struct strbuf remotesb = STRBUF_INIT;			strbuf_addf(&remotesb, "remote.%s.url", remote);			free(remote);			if (git_config_get_string(remotesb.buf, &remoteurl)) {				warning(_("could not lookup configuration '%s'. Assuming this repository is its own authoritative upstream."), remotesb.buf);				remoteurl = xgetcwd();			}			relurl = relative_url(remoteurl, url, NULL);			strbuf_release(&remotesb);			free(remoteurl);			free(url);			url = relurl;		}		if (git_config_set_gently(sb.buf, url))			die(_("Failed to register url for submodule path '%s'"),			    displaypath);		if (!quiet)			fprintf(stderr,				_("Submodule '%s' (%s) registered for path '%s'/n"),				sub->name, url, displaypath);	}	/* Copy "update" setting when it is not set yet */	strbuf_reset(&sb);	strbuf_addf(&sb, "submodule.%s.update", sub->name);	if (git_config_get_string(sb.buf, &upd) &&	    sub->update_strategy.type != SM_UPDATE_UNSPECIFIED) {		if (sub->update_strategy.type == SM_UPDATE_COMMAND) {			fprintf(stderr, _("warning: command update mode suggested for submodule '%s'/n"),				sub->name);			upd = xstrdup("none");		} else			upd = xstrdup(submodule_strategy_to_string(&sub->update_strategy));		if (git_config_set_gently(sb.buf, upd))			die(_("Failed to register update mode for submodule path '%s'"), displaypath);	}	strbuf_release(&sb);	free(displaypath);	free(url);	free(upd);}

static const char *path_ok(const char *directory, struct hostinfo *hi){	static char rpath[PATH_MAX];	static char interp_path[PATH_MAX];	const char *path;	const char *dir;	dir = directory;	if (daemon_avoid_alias(dir)) {		logerror("'%s': aliased", dir);		return NULL;	}	if (*dir == '~') {		if (!user_path) {			logerror("'%s': User-path not allowed", dir);			return NULL;		}		if (*user_path) {			/* Got either "~alice" or "~alice/foo";			 * rewrite them to "~alice/%s" or			 * "~alice/%s/foo".			 */			int namlen, restlen = strlen(dir);			const char *slash = strchr(dir, '/');			if (!slash)				slash = dir + restlen;			namlen = slash - dir;			restlen -= namlen;			loginfo("userpath <%s>, request <%s>, namlen %d, restlen %d, slash <%s>", user_path, dir, namlen, restlen, slash);			snprintf(rpath, PATH_MAX, "%.*s/%s%.*s",				 namlen, dir, user_path, restlen, slash);			dir = rpath;		}	}	else if (interpolated_path && hi->saw_extended_args) {		struct strbuf expanded_path = STRBUF_INIT;		struct expand_path_context context;		context.directory = directory;		context.hostinfo = hi;		if (*dir != '/') {			/* Allow only absolute */			logerror("'%s': Non-absolute path denied (interpolated-path active)", dir);			return NULL;		}		strbuf_expand(&expanded_path, interpolated_path,			      expand_path, &context);		strlcpy(interp_path, expanded_path.buf, PATH_MAX);		strbuf_release(&expanded_path);		loginfo("Interpolated dir '%s'", interp_path);		dir = interp_path;	}	else if (base_path) {		if (*dir != '/') {			/* Allow only absolute */			logerror("'%s': Non-absolute path denied (base-path active)", dir);			return NULL;		}		snprintf(rpath, PATH_MAX, "%s%s", base_path, dir);		dir = rpath;	}	path = enter_repo(dir, strict_paths);	if (!path && base_path && base_path_relaxed) {		/*		 * if we fail and base_path_relaxed is enabled, try without		 * prefixing the base path		 */		dir = directory;		path = enter_repo(dir, strict_paths);	}	if (!path) {		logerror("'%s' does not appear to be a git repository", dir);		return NULL;	}	if ( ok_paths && *ok_paths ) {		char **pp;		int pathlen = strlen(path);		/* The validation is done on the paths after enter_repo		 * appends optional {.git,.git/.git} and friends, but		 * it does not use getcwd().  So if your /pub is		 * a symlink to /mnt/pub, you can whitelist /pub and		 * do not have to say /mnt/pub.		 * Do not say /pub/.		 */		for ( pp = ok_paths ; *pp ; pp++ ) {			int len = strlen(*pp);			if (len <= pathlen &&			    !memcmp(*pp, path, len) &&			    (path[len] == '/0' ||			     (!strict_paths && path[len] == '/')))				return path;//.........这里部分代码省略.........

static void wt_status_print_change_data(struct wt_status *s,					int change_type,					struct string_list_item *it){	struct wt_status_change_data *d = it->util;	const char *c = color(change_type, s);	int status;	char *one_name;	char *two_name;	const char *one, *two;	struct strbuf onebuf = STRBUF_INIT, twobuf = STRBUF_INIT;	struct strbuf extra = STRBUF_INIT;	one_name = two_name = it->string;	switch (change_type) {	case WT_STATUS_UPDATED:		status = d->index_status;		if (d->head_path)			one_name = d->head_path;		break;	case WT_STATUS_CHANGED:		if (d->new_submodule_commits || d->dirty_submodule) {			strbuf_addstr(&extra, " (");			if (d->new_submodule_commits)				strbuf_addf(&extra, _("new commits, "));			if (d->dirty_submodule & DIRTY_SUBMODULE_MODIFIED)				strbuf_addf(&extra, _("modified content, "));			if (d->dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)				strbuf_addf(&extra, _("untracked content, "));			strbuf_setlen(&extra, extra.len - 2);			strbuf_addch(&extra, ')');		}		status = d->worktree_status;		break;	default:		die("BUG: unhandled change_type %d in wt_status_print_change_data",		    change_type);	}	one = quote_path(one_name, -1, &onebuf, s->prefix);	two = quote_path(two_name, -1, &twobuf, s->prefix);	status_printf(s, color(WT_STATUS_HEADER, s), "/t");	switch (status) {	case DIFF_STATUS_ADDED:		status_printf_more(s, c, _("new file:   %s"), one);		break;	case DIFF_STATUS_COPIED:		status_printf_more(s, c, _("copied:     %s -> %s"), one, two);		break;	case DIFF_STATUS_DELETED:		status_printf_more(s, c, _("deleted:    %s"), one);		break;	case DIFF_STATUS_MODIFIED:		status_printf_more(s, c, _("modified:   %s"), one);		break;	case DIFF_STATUS_RENAMED:		status_printf_more(s, c, _("renamed:    %s -> %s"), one, two);		break;	case DIFF_STATUS_TYPE_CHANGED:		status_printf_more(s, c, _("typechange: %s"), one);		break;	case DIFF_STATUS_UNKNOWN:		status_printf_more(s, c, _("unknown:    %s"), one);		break;	case DIFF_STATUS_UNMERGED:		status_printf_more(s, c, _("unmerged:   %s"), one);		break;	default:		die(_("bug: unhandled diff status %c"), status);	}	if (extra.len) {		status_printf_more(s, color(WT_STATUS_HEADER, s), "%s", extra.buf);		strbuf_release(&extra);	}	status_printf_more(s, GIT_COLOR_NORMAL, "/n");	strbuf_release(&onebuf);	strbuf_release(&twobuf);}

void create_branch(const char *head,		   const char *name, const char *start_name,		   int force, int reflog, int clobber_head,		   int quiet, enum branch_track track){	struct commit *commit;	unsigned char sha1[20];	char *real_ref, msg[PATH_MAX + 20];	struct strbuf ref = STRBUF_INIT;	int forcing = 0;	int dont_change_ref = 0;	int explicit_tracking = 0;	if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)		explicit_tracking = 1;	if (validate_new_branchname(name, &ref, force,				    track == BRANCH_TRACK_OVERRIDE ||				    clobber_head)) {		if (!force)			dont_change_ref = 1;		else			forcing = 1;	}	real_ref = NULL;	if (get_sha1(start_name, sha1)) {		if (explicit_tracking) {			if (advice_set_upstream_failure) {				error(_(upstream_missing), start_name);				advise(_(upstream_advice));				exit(1);			}			die(_(upstream_missing), start_name);		}		die(_("Not a valid object name: '%s'."), start_name);	}	switch (dwim_ref(start_name, strlen(start_name), sha1, &real_ref)) {	case 0:		/* Not branching from any existing branch */		if (explicit_tracking)			die(_(upstream_not_branch), start_name);		break;	case 1:		/* Unique completion -- good, only if it is a real branch */		if (!starts_with(real_ref, "refs/heads/") &&		    validate_remote_tracking_branch(real_ref)) {			if (explicit_tracking)				die(_(upstream_not_branch), start_name);			else				real_ref = NULL;		}		break;	default:		die(_("Ambiguous object name: '%s'."), start_name);		break;	}	if ((commit = lookup_commit_reference(sha1)) == NULL)		die(_("Not a valid branch point: '%s'."), start_name);	hashcpy(sha1, commit->object.sha1);	if (forcing)		snprintf(msg, sizeof msg, "branch: Reset to %s",			 start_name);	else if (!dont_change_ref)		snprintf(msg, sizeof msg, "branch: Created from %s",			 start_name);	if (reflog)		log_all_ref_updates = 1;	if (!dont_change_ref) {		struct ref_transaction *transaction;		struct strbuf err = STRBUF_INIT;		transaction = ref_transaction_begin(&err);		if (!transaction ||		    ref_transaction_update(transaction, ref.buf, sha1,					   null_sha1, 0, !forcing, msg, &err) ||		    ref_transaction_commit(transaction, &err))			die("%s", err.buf);		ref_transaction_free(transaction);		strbuf_release(&err);	}	if (real_ref && track)		setup_tracking(ref.buf + 11, real_ref, track, quiet);	strbuf_release(&ref);	free(real_ref);}

static struct ref *get_refs_via_rsync(struct transport *transport, int for_push){	struct strbuf buf = STRBUF_INIT, temp_dir = STRBUF_INIT;	struct ref dummy = {NULL}, *tail = &dummy;	struct child_process rsync = CHILD_PROCESS_INIT;	const char *args[5];	int temp_dir_len;	if (for_push)		return NULL;	/* copy the refs to the temporary directory */	strbuf_addstr(&temp_dir, git_path("rsync-refs-XXXXXX"));	if (!mkdtemp(temp_dir.buf))		die_errno ("Could not make temporary directory");	temp_dir_len = temp_dir.len;	strbuf_addstr(&buf, rsync_url(transport->url));	strbuf_addstr(&buf, "/refs");	rsync.argv = args;	rsync.stdout_to_stderr = 1;	args[0] = "rsync";	args[1] = (transport->verbose > 1) ? "-rv" : "-r";	args[2] = buf.buf;	args[3] = temp_dir.buf;	args[4] = NULL;	if (run_command(&rsync))		die ("Could not run rsync to get refs");	strbuf_reset(&buf);	strbuf_addstr(&buf, rsync_url(transport->url));	strbuf_addstr(&buf, "/packed-refs");	args[2] = buf.buf;	if (run_command(&rsync))		die ("Could not run rsync to get refs");	/* read the copied refs */	strbuf_addstr(&temp_dir, "/refs");	read_loose_refs(&temp_dir, temp_dir_len + 1, &tail);	strbuf_setlen(&temp_dir, temp_dir_len);	tail = &dummy;	strbuf_addstr(&temp_dir, "/packed-refs");	insert_packed_refs(temp_dir.buf, &tail);	strbuf_setlen(&temp_dir, temp_dir_len);	if (remove_dir_recursively(&temp_dir, 0))		warning ("Error removing temporary directory %s.",				temp_dir.buf);	strbuf_release(&buf);	strbuf_release(&temp_dir);	return dummy.next;}

//.........这里部分代码省略.........	if (conflict_style) {		opts.merge = 1; /* implied */		git_xmerge_config("merge.conflictstyle", conflict_style, NULL);	}	if ((!!opts.new_branch + !!opts.new_branch_force + !!opts.new_orphan_branch) > 1)		die(_("-b, -B and --orphan are mutually exclusive"));	/*	 * From here on, new_branch will contain the branch to be checked out,	 * and new_branch_force and new_orphan_branch will tell us which one of	 * -b/-B/--orphan is being used.	 */	if (opts.new_branch_force)		opts.new_branch = opts.new_branch_force;	if (opts.new_orphan_branch)		opts.new_branch = opts.new_orphan_branch;	/* --track without -b/-B/--orphan should DWIM */	if (opts.track != BRANCH_TRACK_UNSPECIFIED && !opts.new_branch) {		const char *argv0 = argv[0];		if (!argc || !strcmp(argv0, "--"))			die (_("--track needs a branch name"));		skip_prefix(argv0, "refs/", &argv0);		skip_prefix(argv0, "remotes/", &argv0);		argv0 = strchr(argv0, '/');		if (!argv0 || !argv0[1])			die (_("Missing branch name; try -b"));		opts.new_branch = argv0 + 1;	}	/*	 * Extract branch name from command line arguments, so	 * all that is left is pathspecs.	 *	 * Handle	 *	 *  1) git checkout <tree> -- [<paths>]	 *  2) git checkout -- [<paths>]	 *  3) git checkout <something> [<paths>]	 *	 * including "last branch" syntax and DWIM-ery for names of	 * remote branches, erroring out for invalid or ambiguous cases.	 */	if (argc) {		struct object_id rev;		int dwim_ok =			!opts.patch_mode &&			dwim_new_local_branch &&			opts.track == BRANCH_TRACK_UNSPECIFIED &&			!opts.new_branch;		int n = parse_branchname_arg(argc, argv, dwim_ok,					     &new_branch_info, &opts, &rev);		argv += n;		argc -= n;	}	if (argc) {		parse_pathspec(&opts.pathspec, 0,			       opts.patch_mode ? PATHSPEC_PREFIX_ORIGIN : 0,			       prefix, argv);		if (!opts.pathspec.nr)			die(_("invalid path specification"));		/*		 * Try to give more helpful suggestion.		 * new_branch && argc > 1 will be caught later.		 */		if (opts.new_branch && argc == 1)			die(_("'%s' is not a commit and a branch '%s' cannot be created from it"),				argv[0], opts.new_branch);		if (opts.force_detach)			die(_("git checkout: --detach does not take a path argument '%s'"),			    argv[0]);		if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge)			die(_("git checkout: --ours/--theirs, --force and --merge are incompatible when/n"			      "checking out of the index."));	}	if (opts.new_branch) {		struct strbuf buf = STRBUF_INIT;		if (opts.new_branch_force)			opts.branch_exists = validate_branchname(opts.new_branch, &buf);		else			opts.branch_exists =				validate_new_branchname(opts.new_branch, &buf, 0);		strbuf_release(&buf);	}	UNLEAK(opts);	if (opts.patch_mode || opts.pathspec.nr)		return checkout_paths(&opts, new_branch_info.name);	else		return checkout_branch(&opts, &new_branch_info);}

static int rsync_transport_push(struct transport *transport,		int refspec_nr, const char **refspec, int flags){	struct strbuf buf = STRBUF_INIT, temp_dir = STRBUF_INIT;	int result = 0, i;	struct child_process rsync = CHILD_PROCESS_INIT;	const char *args[10];	if (flags & TRANSPORT_PUSH_MIRROR)		return error("rsync transport does not support mirror mode");	/* first push the objects */	strbuf_addstr(&buf, rsync_url(transport->url));	strbuf_addch(&buf, '/');	rsync.argv = args;	rsync.stdout_to_stderr = 1;	i = 0;	args[i++] = "rsync";	args[i++] = "-a";	if (flags & TRANSPORT_PUSH_DRY_RUN)		args[i++] = "--dry-run";	if (transport->verbose > 1)		args[i++] = "-v";	args[i++] = "--ignore-existing";	args[i++] = "--exclude";	args[i++] = "info";	args[i++] = get_object_directory();	args[i++] = buf.buf;	args[i++] = NULL;	if (run_command(&rsync))		return error("Could not push objects to %s",				rsync_url(transport->url));	/* copy the refs to the temporary directory; they could be packed. */	strbuf_addstr(&temp_dir, git_path("rsync-refs-XXXXXX"));	if (!mkdtemp(temp_dir.buf))		die_errno ("Could not make temporary directory");	strbuf_addch(&temp_dir, '/');	if (flags & TRANSPORT_PUSH_ALL) {		if (for_each_ref(write_one_ref, &temp_dir))			return -1;	} else if (write_refs_to_temp_dir(&temp_dir, refspec_nr, refspec))		return -1;	i = 2;	if (flags & TRANSPORT_PUSH_DRY_RUN)		args[i++] = "--dry-run";	if (!(flags & TRANSPORT_PUSH_FORCE))		args[i++] = "--ignore-existing";	args[i++] = temp_dir.buf;	args[i++] = rsync_url(transport->url);	args[i++] = NULL;	if (run_command(&rsync))		result = error("Could not push to %s",				rsync_url(transport->url));	if (remove_dir_recursively(&temp_dir, 0))		warning ("Could not remove temporary directory %s.",				temp_dir.buf);	strbuf_release(&buf);	strbuf_release(&temp_dir);	return result;}

//.........这里部分代码省略.........		topts.update = 1;		topts.merge = 1;		topts.gently = opts->merge && old_branch_info->commit;		topts.verbose_update = opts->show_progress;		topts.fn = twoway_merge;		if (opts->overwrite_ignore) {			topts.dir = xcalloc(1, sizeof(*topts.dir));			topts.dir->flags |= DIR_SHOW_IGNORED;			setup_standard_excludes(topts.dir);		}		tree = parse_tree_indirect(old_branch_info->commit ?					   &old_branch_info->commit->object.oid :					   the_hash_algo->empty_tree);		init_tree_desc(&trees[0], tree->buffer, tree->size);		tree = parse_tree_indirect(&new_branch_info->commit->object.oid);		init_tree_desc(&trees[1], tree->buffer, tree->size);		ret = unpack_trees(2, trees, &topts);		if (ret == -1) {			/*			 * Unpack couldn't do a trivial merge; either			 * give up or do a real merge, depending on			 * whether the merge flag was used.			 */			struct tree *result;			struct tree *work;			struct merge_options o;			if (!opts->merge)				return 1;			/*			 * Without old_branch_info->commit, the below is the same as			 * the two-tree unpack we already tried and failed.			 */			if (!old_branch_info->commit)				return 1;			/* Do more real merge */			/*			 * We update the index fully, then write the			 * tree from the index, then merge the new			 * branch with the current tree, with the old			 * branch as the base. Then we reset the index			 * (but not the working tree) to the new			 * branch, leaving the working tree as the			 * merged version, but skipping unmerged			 * entries in the index.			 */			add_files_to_cache(NULL, NULL, 0);			/*			 * NEEDSWORK: carrying over local changes			 * when branches have different end-of-line			 * normalization (or clean+smudge rules) is			 * a pain; plumb in an option to set			 * o.renormalize?			 */			init_merge_options(&o);			o.verbosity = 0;			work = write_tree_from_memory(&o);			ret = reset_tree(get_commit_tree(new_branch_info->commit),					 opts, 1,					 writeout_error);			if (ret)				return ret;			o.ancestor = old_branch_info->name;			o.branch1 = new_branch_info->name;			o.branch2 = "local";			ret = merge_trees(&o,					  get_commit_tree(new_branch_info->commit),					  work,					  get_commit_tree(old_branch_info->commit),					  &result);			if (ret < 0)				exit(128);			ret = reset_tree(get_commit_tree(new_branch_info->commit),					 opts, 0,					 writeout_error);			strbuf_release(&o.obuf);			if (ret)				return ret;		}	}	if (!active_cache_tree)		active_cache_tree = cache_tree();	if (!cache_tree_fully_valid(active_cache_tree))		cache_tree_update(&the_index, WRITE_TREE_SILENT | WRITE_TREE_REPAIR);	if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))		die(_("unable to write new index file"));	if (!opts->force && !opts->quiet)		show_local_changes(&new_branch_info->commit->object, &opts->diff_options);	return 0;}

/* * Write the packed refs from the current snapshot to the packed-refs * tempfile, incorporating any changes from `updates`. `updates` must * be a sorted string list whose keys are the refnames and whose util * values are `struct ref_update *`. On error, rollback the tempfile, * write an error message to `err`, and return a nonzero value. * * The packfile must be locked before calling this function and will * remain locked when it is done. */static int write_with_updates(struct packed_ref_store *refs,			      struct string_list *updates,			      struct strbuf *err){	struct ref_iterator *iter = NULL;	size_t i;	int ok;	FILE *out;	struct strbuf sb = STRBUF_INIT;	char *packed_refs_path;	if (!is_lock_file_locked(&refs->lock))		die("BUG: write_with_updates() called while unlocked");	/*	 * If packed-refs is a symlink, we want to overwrite the	 * symlinked-to file, not the symlink itself. Also, put the	 * staging file next to it:	 */	packed_refs_path = get_locked_file_path(&refs->lock);	strbuf_addf(&sb, "%s.new", packed_refs_path);	free(packed_refs_path);	refs->tempfile = create_tempfile(sb.buf);	if (!refs->tempfile) {		strbuf_addf(err, "unable to create file %s: %s",			    sb.buf, strerror(errno));		strbuf_release(&sb);		return -1;	}	strbuf_release(&sb);	out = fdopen_tempfile(refs->tempfile, "w");	if (!out) {		strbuf_addf(err, "unable to fdopen packed-refs tempfile: %s",			    strerror(errno));		goto error;	}	if (fprintf(out, "%s", PACKED_REFS_HEADER) < 0)		goto write_error;	/*	 * We iterate in parallel through the current list of refs and	 * the list of updates, processing an entry from at least one	 * of the lists each time through the loop. When the current	 * list of refs is exhausted, set iter to NULL. When the list	 * of updates is exhausted, leave i set to updates->nr.	 */	iter = packed_ref_iterator_begin(&refs->base, "",					 DO_FOR_EACH_INCLUDE_BROKEN);	if ((ok = ref_iterator_advance(iter)) != ITER_OK)		iter = NULL;	i = 0;	while (iter || i < updates->nr) {		struct ref_update *update = NULL;		int cmp;		if (i >= updates->nr) {			cmp = -1;		} else {			update = updates->items[i].util;			if (!iter)				cmp = +1;			else				cmp = strcmp(iter->refname, update->refname);		}		if (!cmp) {			/*			 * There is both an old value and an update			 * for this reference. Check the old value if			 * necessary:			 */			if ((update->flags & REF_HAVE_OLD)) {				if (is_null_oid(&update->old_oid)) {					strbuf_addf(err, "cannot update ref '%s': "						    "reference already exists",						    update->refname);					goto error;				} else if (oidcmp(&update->old_oid, iter->oid)) {					strbuf_addf(err, "cannot update ref '%s': "						    "is at %s but expected %s",						    update->refname,						    oid_to_hex(iter->oid),						    oid_to_hex(&update->old_oid));					goto error;				}//.........这里部分代码省略.........

static void update_refs_for_switch(const struct checkout_opts *opts,				   struct branch_info *old_branch_info,				   struct branch_info *new_branch_info){	struct strbuf msg = STRBUF_INIT;	const char *old_desc, *reflog_msg;	if (opts->new_branch) {		if (opts->new_orphan_branch) {			char *refname;			refname = mkpathdup("refs/heads/%s", opts->new_orphan_branch);			if (opts->new_branch_log &&			    !should_autocreate_reflog(refname)) {				int ret;				struct strbuf err = STRBUF_INIT;				ret = safe_create_reflog(refname, 1, &err);				if (ret) {					fprintf(stderr, _("Can not do reflog for '%s': %s/n"),						opts->new_orphan_branch, err.buf);					strbuf_release(&err);					free(refname);					return;				}				strbuf_release(&err);			}			free(refname);		}		else			create_branch(opts->new_branch, new_branch_info->name,				      opts->new_branch_force ? 1 : 0,				      opts->new_branch_force ? 1 : 0,				      opts->new_branch_log,				      opts->quiet,				      opts->track);		new_branch_info->name = opts->new_branch;		setup_branch_path(new_branch_info);	}	old_desc = old_branch_info->name;	if (!old_desc && old_branch_info->commit)		old_desc = oid_to_hex(&old_branch_info->commit->object.oid);	reflog_msg = getenv("GIT_REFLOG_ACTION");	if (!reflog_msg)		strbuf_addf(&msg, "checkout: moving from %s to %s",			old_desc ? old_desc : "(invalid)", new_branch_info->name);	else		strbuf_insert(&msg, 0, reflog_msg, strlen(reflog_msg));	if (!strcmp(new_branch_info->name, "HEAD") && !new_branch_info->path && !opts->force_detach) {		/* Nothing to do. */	} else if (opts->force_detach || !new_branch_info->path) {	/* No longer on any branch. */		update_ref(msg.buf, "HEAD", &new_branch_info->commit->object.oid, NULL,			   REF_NO_DEREF, UPDATE_REFS_DIE_ON_ERR);		if (!opts->quiet) {			if (old_branch_info->path &&			    advice_detached_head && !opts->force_detach)				detach_advice(new_branch_info->name);			describe_detached_head(_("HEAD is now at"), new_branch_info->commit);		}	} else if (new_branch_info->path) {	/* Switch branches. */		if (create_symref("HEAD", new_branch_info->path, msg.buf) < 0)			die(_("unable to update HEAD"));		if (!opts->quiet) {			if (old_branch_info->path && !strcmp(new_branch_info->path, old_branch_info->path)) {				if (opts->new_branch_force)					fprintf(stderr, _("Reset branch '%s'/n"),						new_branch_info->name);				else					fprintf(stderr, _("Already on '%s'/n"),						new_branch_info->name);			} else if (opts->new_branch) {				if (opts->branch_exists)					fprintf(stderr, _("Switched to and reset branch '%s'/n"), new_branch_info->name);				else					fprintf(stderr, _("Switched to a new branch '%s'/n"), new_branch_info->name);			} else {				fprintf(stderr, _("Switched to branch '%s'/n"),					new_branch_info->name);			}		}		if (old_branch_info->path && old_branch_info->name) {			if (!ref_exists(old_branch_info->path) && reflog_exists(old_branch_info->path))				delete_reflog(old_branch_info->path);		}	}	remove_branch_state();	strbuf_release(&msg);	if (!opts->quiet &&	    (new_branch_info->path || (!opts->force_detach && !strcmp(new_branch_info->name, "HEAD"))))		report_tracking(new_branch_info);}

/* * NEEDSWORK: remote_ls() ignores info/refs on the remote side.  But it * should _only_ heed the information from that file, instead of trying to * determine the refs from the remote file system (badly: it does not even * know about packed-refs). */static void remote_ls(const char *path, int flags,		      void (*userFunc)(struct remote_ls_ctx *ls),		      void *userData){	char *url = xstrfmt("%s%s", repo->url, path);	struct active_request_slot *slot;	struct slot_results results;	struct strbuf in_buffer = STRBUF_INIT;	struct buffer out_buffer = { STRBUF_INIT, 0 };	struct curl_slist *dav_headers = http_copy_default_headers();	struct xml_ctx ctx;	struct remote_ls_ctx ls;	ls.flags = flags;	ls.path = xstrdup(path);	ls.dentry_name = NULL;	ls.dentry_flags = 0;	ls.userData = userData;	ls.userFunc = userFunc;	strbuf_addstr(&out_buffer.buf, PROPFIND_ALL_REQUEST);	dav_headers = curl_slist_append(dav_headers, "Depth: 1");	dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");	slot = get_active_slot();	slot->results = &results;	curl_setup_http(slot->curl, url, DAV_PROPFIND,			&out_buffer, fwrite_buffer);	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);	curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);	if (start_active_slot(slot)) {		run_active_slot(slot);		if (results.curl_result == CURLE_OK) {			XML_Parser parser = XML_ParserCreate(NULL);			enum XML_Status result;			ctx.name = xcalloc(10, 1);			ctx.len = 0;			ctx.cdata = NULL;			ctx.userFunc = handle_remote_ls_ctx;			ctx.userData = &ls;			XML_SetUserData(parser, &ctx);			XML_SetElementHandler(parser, xml_start_tag,					      xml_end_tag);			XML_SetCharacterDataHandler(parser, xml_cdata);			result = XML_Parse(parser, in_buffer.buf,					   in_buffer.len, 1);			free(ctx.name);			if (result != XML_STATUS_OK) {				fprintf(stderr, "XML error: %s/n",					XML_ErrorString(						XML_GetErrorCode(parser)));			}			XML_ParserFree(parser);		}	} else {		fprintf(stderr, "Unable to start PROPFIND request/n");	}	free(ls.path);	free(url);	strbuf_release(&out_buffer.buf);	strbuf_release(&in_buffer);	curl_slist_free_all(dav_headers);}

int fetch_populated_submodules(const struct argv_array *options,			       const char *prefix, int command_line_option,			       int quiet){	int i, result = 0;	struct child_process cp = CHILD_PROCESS_INIT;	struct argv_array argv = ARGV_ARRAY_INIT;	struct string_list_item *name_for_path;	const char *work_tree = get_git_work_tree();	if (!work_tree)		goto out;	if (read_cache() < 0)		die("index file corrupt");	argv_array_push(&argv, "fetch");	for (i = 0; i < options->argc; i++)		argv_array_push(&argv, options->argv[i]);	argv_array_push(&argv, "--recurse-submodules-default");	/* default value, "--submodule-prefix" and its value are added later */	cp.env = local_repo_env;	cp.git_cmd = 1;	cp.no_stdin = 1;	calculate_changed_submodule_paths();	for (i = 0; i < active_nr; i++) {		struct strbuf submodule_path = STRBUF_INIT;		struct strbuf submodule_git_dir = STRBUF_INIT;		struct strbuf submodule_prefix = STRBUF_INIT;		const struct cache_entry *ce = active_cache[i];		const char *git_dir, *name, *default_argv;		if (!S_ISGITLINK(ce->ce_mode))			continue;		name = ce->name;		name_for_path = unsorted_string_list_lookup(&config_name_for_path, ce->name);		if (name_for_path)			name = name_for_path->util;		default_argv = "yes";		if (command_line_option == RECURSE_SUBMODULES_DEFAULT) {			struct string_list_item *fetch_recurse_submodules_option;			fetch_recurse_submodules_option = unsorted_string_list_lookup(&config_fetch_recurse_submodules_for_name, name);			if (fetch_recurse_submodules_option) {				if ((intptr_t)fetch_recurse_submodules_option->util == RECURSE_SUBMODULES_OFF)					continue;				if ((intptr_t)fetch_recurse_submodules_option->util == RECURSE_SUBMODULES_ON_DEMAND) {					if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))						continue;					default_argv = "on-demand";				}			} else {				if ((config_fetch_recurse_submodules == RECURSE_SUBMODULES_OFF) ||				    gitmodules_is_unmerged)					continue;				if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND) {					if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))						continue;					default_argv = "on-demand";				}			}		} else if (command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {			if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))				continue;			default_argv = "on-demand";		}		strbuf_addf(&submodule_path, "%s/%s", work_tree, ce->name);		strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);		strbuf_addf(&submodule_prefix, "%s%s/", prefix, ce->name);		git_dir = read_gitfile(submodule_git_dir.buf);		if (!git_dir)			git_dir = submodule_git_dir.buf;		if (is_directory(git_dir)) {			if (!quiet)				printf("Fetching submodule %s%s/n", prefix, ce->name);			cp.dir = submodule_path.buf;			argv_array_push(&argv, default_argv);			argv_array_push(&argv, "--submodule-prefix");			argv_array_push(&argv, submodule_prefix.buf);			cp.argv = argv.argv;			if (run_command(&cp))				result = 1;			argv_array_pop(&argv);			argv_array_pop(&argv);			argv_array_pop(&argv);		}		strbuf_release(&submodule_path);		strbuf_release(&submodule_git_dir);		strbuf_release(&submodule_prefix);	}	argv_array_clear(&argv);out:	string_list_clear(&changed_submodule_paths, 1);	return result;}

static struct remote_lock *lock_remote(const char *path, long timeout){	struct active_request_slot *slot;	struct slot_results results;	struct buffer out_buffer = { STRBUF_INIT, 0 };	struct strbuf in_buffer = STRBUF_INIT;	char *url;	char *ep;	char timeout_header[25];	struct remote_lock *lock = NULL;	struct curl_slist *dav_headers = http_copy_default_headers();	struct xml_ctx ctx;	char *escaped;	url = xstrfmt("%s%s", repo->url, path);	/* Make sure leading directories exist for the remote ref */	ep = strchr(url + strlen(repo->url) + 1, '/');	while (ep) {		char saved_character = ep[1];		ep[1] = '/0';		slot = get_active_slot();		slot->results = &results;		curl_setup_http_get(slot->curl, url, DAV_MKCOL);		if (start_active_slot(slot)) {			run_active_slot(slot);			if (results.curl_result != CURLE_OK &&			    results.http_code != 405) {				fprintf(stderr,					"Unable to create branch path %s/n",					url);				free(url);				return NULL;			}		} else {			fprintf(stderr, "Unable to start MKCOL request/n");			free(url);			return NULL;		}		ep[1] = saved_character;		ep = strchr(ep + 1, '/');	}	escaped = xml_entities(ident_default_email());	strbuf_addf(&out_buffer.buf, LOCK_REQUEST, escaped);	free(escaped);	xsnprintf(timeout_header, sizeof(timeout_header), "Timeout: Second-%ld", timeout);	dav_headers = curl_slist_append(dav_headers, timeout_header);	dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");	slot = get_active_slot();	slot->results = &results;	curl_setup_http(slot->curl, url, DAV_LOCK, &out_buffer, fwrite_buffer);	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);	curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);	lock = xcalloc(1, sizeof(*lock));	lock->timeout = -1;	if (start_active_slot(slot)) {		run_active_slot(slot);		if (results.curl_result == CURLE_OK) {			XML_Parser parser = XML_ParserCreate(NULL);			enum XML_Status result;			ctx.name = xcalloc(10, 1);			ctx.len = 0;			ctx.cdata = NULL;			ctx.userFunc = handle_new_lock_ctx;			ctx.userData = lock;			XML_SetUserData(parser, &ctx);			XML_SetElementHandler(parser, xml_start_tag,					      xml_end_tag);			XML_SetCharacterDataHandler(parser, xml_cdata);			result = XML_Parse(parser, in_buffer.buf,					   in_buffer.len, 1);			free(ctx.name);			if (result != XML_STATUS_OK) {				fprintf(stderr, "XML error: %s/n",					XML_ErrorString(						XML_GetErrorCode(parser)));				lock->timeout = -1;			}			XML_ParserFree(parser);		}	} else {		fprintf(stderr, "Unable to start LOCK request/n");	}	curl_slist_free_all(dav_headers);	strbuf_release(&out_buffer.buf);	strbuf_release(&in_buffer);	if (lock->token == NULL || lock->timeout <= 0) {		free(lock->token);		free(lock->owner);		free(url);		FREE_AND_NULL(lock);	} else {		lock->url = url;//.........这里部分代码省略.........

unsigned is_submodule_modified(const char *path, int ignore_untracked){	ssize_t len;	struct child_process cp = CHILD_PROCESS_INIT;	const char *argv[] = {		"status",		"--porcelain",		NULL,		NULL,	};	struct strbuf buf = STRBUF_INIT;	unsigned dirty_submodule = 0;	const char *line, *next_line;	const char *git_dir;	strbuf_addf(&buf, "%s/.git", path);	git_dir = read_gitfile(buf.buf);	if (!git_dir)		git_dir = buf.buf;	if (!is_directory(git_dir)) {		strbuf_release(&buf);		/* The submodule is not checked out, so it is not modified */		return 0;	}	strbuf_reset(&buf);	if (ignore_untracked)		argv[2] = "-uno";	cp.argv = argv;	cp.env = local_repo_env;	cp.git_cmd = 1;	cp.no_stdin = 1;	cp.out = -1;	cp.dir = path;	if (start_command(&cp))		die("Could not run 'git status --porcelain' in submodule %s", path);	len = strbuf_read(&buf, cp.out, 1024);	line = buf.buf;	while (len > 2) {		if ((line[0] == '?') && (line[1] == '?')) {			dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;			if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)				break;		} else {			dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;			if (ignore_untracked ||			    (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED))				break;		}		next_line = strchr(line, '/n');		if (!next_line)			break;		next_line++;		len -= (next_line - line);		line = next_line;	}	close(cp.out);	if (finish_command(&cp))		die("'git status --porcelain' failed in submodule %s", path);	strbuf_release(&buf);	return dirty_submodule;}

void log_write_email_headers(struct rev_info *opt, struct commit *commit,			     const char **subject_p,			     const char **extra_headers_p,			     int *need_8bit_cte_p){	const char *subject = NULL;	const char *extra_headers = opt->extra_headers;	const char *name = oid_to_hex(opt->zero_commit ?				      &null_oid : &commit->object.oid);	*need_8bit_cte_p = 0; /* unknown */	if (opt->total > 0) {		static char buffer[64];		snprintf(buffer, sizeof(buffer),			 "Subject: [%s%s%0*d/%d] ",			 opt->subject_prefix,			 *opt->subject_prefix ? " " : "",			 digits_in_number(opt->total),			 opt->nr, opt->total);		subject = buffer;	} else if (opt->total == 0 && opt->subject_prefix && *opt->subject_prefix) {		static char buffer[256];		snprintf(buffer, sizeof(buffer),			 "Subject: [%s] ",			 opt->subject_prefix);		subject = buffer;	} else {		subject = "Subject: ";	}	printf("From %s Mon Sep 17 00:00:00 2001/n", name);	graph_show_oneline(opt->graph);	if (opt->message_id) {		printf("Message-Id: <%s>/n", opt->message_id);		graph_show_oneline(opt->graph);	}	if (opt->ref_message_ids && opt->ref_message_ids->nr > 0) {		int i, n;		n = opt->ref_message_ids->nr;		printf("In-Reply-To: <%s>/n", opt->ref_message_ids->items[n-1].string);		for (i = 0; i < n; i++)			printf("%s<%s>/n", (i > 0 ? "/t" : "References: "),			       opt->ref_message_ids->items[i].string);		graph_show_oneline(opt->graph);	}	if (opt->mime_boundary) {		static char subject_buffer[1024];		static char buffer[1024];		struct strbuf filename =  STRBUF_INIT;		*need_8bit_cte_p = -1; /* NEVER */		snprintf(subject_buffer, sizeof(subject_buffer) - 1,			 "%s"			 "MIME-Version: 1.0/n"			 "Content-Type: multipart/mixed;"			 " boundary=/"%s%s/"/n"			 "/n"			 "This is a multi-part message in MIME "			 "format./n"			 "--%s%s/n"			 "Content-Type: text/plain; "			 "charset=UTF-8; format=fixed/n"			 "Content-Transfer-Encoding: 8bit/n/n",			 extra_headers ? extra_headers : "",			 mime_boundary_leader, opt->mime_boundary,			 mime_boundary_leader, opt->mime_boundary);		extra_headers = subject_buffer;		if (opt->numbered_files)			strbuf_addf(&filename, "%d", opt->nr);		else			fmt_output_commit(&filename, commit, opt);		snprintf(buffer, sizeof(buffer) - 1,			 "/n--%s%s/n"			 "Content-Type: text/x-patch;"			 " name=/"%s/"/n"			 "Content-Transfer-Encoding: 8bit/n"			 "Content-Disposition: %s;"			 " filename=/"%s/"/n/n",			 mime_boundary_leader, opt->mime_boundary,			 filename.buf,			 opt->no_inline ? "attachment" : "inline",			 filename.buf);		opt->diffopt.stat_sep = buffer;		strbuf_release(&filename);	}	*subject_p = subject;	*extra_headers_p = extra_headers;}

int cmd_reset(int argc, const char **argv, const char *prefix){	int reset_type = NONE, update_ref_status = 0, quiet = 0;	int patch_mode = 0, nul_term_line = 0, read_from_stdin = 0, unborn;	char **stdin_paths = NULL;	int stdin_nr = 0, stdin_alloc = 0;	const char *rev;	struct object_id oid;	struct pathspec pathspec;	int intent_to_add = 0;	const struct option options[] = {		OPT__QUIET(&quiet, N_("be quiet, only report errors")),		OPT_SET_INT(0, "mixed", &reset_type,						N_("reset HEAD and index"), MIXED),		OPT_SET_INT(0, "soft", &reset_type, N_("reset only HEAD"), SOFT),		OPT_SET_INT(0, "hard", &reset_type,				N_("reset HEAD, index and working tree"), HARD),		OPT_SET_INT(0, "merge", &reset_type,				N_("reset HEAD, index and working tree"), MERGE),		OPT_SET_INT(0, "keep", &reset_type,				N_("reset HEAD but keep local changes"), KEEP),		{ OPTION_CALLBACK, 0, "recurse-submodules", NULL,			    "reset", "control recursive updating of submodules",			    PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater },		OPT_BOOL('p', "patch", &patch_mode, N_("select hunks interactively")),		OPT_BOOL('N', "intent-to-add", &intent_to_add,				N_("record only the fact that removed paths will be added later")),		OPT_BOOL('z', NULL, &nul_term_line,			N_("EXPERIMENTAL: paths are separated with NUL character")),		OPT_BOOL(0, "stdin", &read_from_stdin,				N_("EXPERIMENTAL: read paths from <stdin>")),		OPT_END()	};	git_config(git_reset_config, NULL);	argc = parse_options(argc, argv, prefix, options, git_reset_usage,						PARSE_OPT_KEEP_DASHDASH);	parse_args(&pathspec, argv, prefix, patch_mode, &rev);	if (read_from_stdin) {		strbuf_getline_fn getline_fn = nul_term_line ?			strbuf_getline_nul : strbuf_getline_lf;		int flags = PATHSPEC_PREFER_FULL;		struct strbuf buf = STRBUF_INIT;		struct strbuf unquoted = STRBUF_INIT;		if (patch_mode)			die(_("--stdin is incompatible with --patch"));		if (pathspec.nr)			die(_("--stdin is incompatible with path arguments"));		while (getline_fn(&buf, stdin) != EOF) {			if (!nul_term_line && buf.buf[0] == '"') {				strbuf_reset(&unquoted);				if (unquote_c_style(&unquoted, buf.buf, NULL))					die(_("line is badly quoted"));				strbuf_swap(&buf, &unquoted);			}			ALLOC_GROW(stdin_paths, stdin_nr + 1, stdin_alloc);			stdin_paths[stdin_nr++] = xstrdup(buf.buf);			strbuf_reset(&buf);		}		strbuf_release(&unquoted);		strbuf_release(&buf);		ALLOC_GROW(stdin_paths, stdin_nr + 1, stdin_alloc);		stdin_paths[stdin_nr++] = NULL;		flags |= PATHSPEC_LITERAL_PATH;		parse_pathspec(&pathspec, 0, flags, prefix,			       (const char **)stdin_paths);	} else if (nul_term_line)		die(_("-z requires --stdin"));	unborn = !strcmp(rev, "HEAD") && get_oid("HEAD", &oid);	if (unborn) {		/* reset on unborn branch: treat as reset to empty tree */		hashcpy(oid.hash, EMPTY_TREE_SHA1_BIN);	} else if (!pathspec.nr) {		struct commit *commit;		if (get_oid_committish(rev, &oid))			die(_("Failed to resolve '%s' as a valid revision."), rev);		commit = lookup_commit_reference(&oid);		if (!commit)			die(_("Could not parse object '%s'."), rev);		oidcpy(&oid, &commit->object.oid);	} else {		struct tree *tree;		if (get_oid_treeish(rev, &oid))			die(_("Failed to resolve '%s' as a valid tree."), rev);		tree = parse_tree_indirect(&oid);		if (!tree)			die(_("Could not parse object '%s'."), rev);		oidcpy(&oid, &tree->object.oid);	}	if (patch_mode) {		if (reset_type != NONE)//.........这里部分代码省略.........

static void run_shell(void){	int done = 0;	static const char *help_argv[] = { HELP_COMMAND, NULL };	if (!access(NOLOGIN_COMMAND, F_OK)) {		/* Interactive login disabled. */		const char *argv[] = { NOLOGIN_COMMAND, NULL };		int status;		status = run_command_v_opt(argv, 0);		if (status < 0)			exit(127);		exit(status);	}	/* Print help if enabled */	run_command_v_opt(help_argv, RUN_SILENT_EXEC_FAILURE);	do {		struct strbuf line = STRBUF_INIT;		const char *prog;		char *full_cmd;		char *rawargs;		char *split_args;		const char **argv;		int code;		int count;		fprintf(stderr, "git> ");		if (strbuf_getline_lf(&line, stdin) == EOF) {			fprintf(stderr, "/n");			strbuf_release(&line);			break;		}		strbuf_trim(&line);		rawargs = strbuf_detach(&line, NULL);		split_args = xstrdup(rawargs);		count = split_cmdline(split_args, &argv);		if (count < 0) {			fprintf(stderr, "invalid command format '%s': %s/n", rawargs,				split_cmdline_strerror(count));			free(split_args);			free(rawargs);			continue;		}		prog = argv[0];		if (!strcmp(prog, "")) {		} else if (!strcmp(prog, "quit") || !strcmp(prog, "logout") ||			   !strcmp(prog, "exit") || !strcmp(prog, "bye")) {			done = 1;		} else if (is_valid_cmd_name(prog)) {			full_cmd = make_cmd(prog);			argv[0] = full_cmd;			code = run_command_v_opt(argv, RUN_SILENT_EXEC_FAILURE);			if (code == -1 && errno == ENOENT) {				fprintf(stderr, "unrecognized command '%s'/n", prog);			}			free(full_cmd);		} else {			fprintf(stderr, "invalid command format '%s'/n", prog);		}		free(argv);		free(rawargs);	} while (!done);}

//.........这里部分代码省略.........         * has to be unambiguous.         */        else if (!get_sha1(argv[i], sha1)) {            /*             * Ok, argv[i] looks like a rev; it should not             * be a filename.             */            verify_non_filename(prefix, argv[i]);            rev = argv[i++];        } else {            /* Otherwise we treat this as a filename */            verify_filename(prefix, argv[i]);        }    }    if (get_sha1(rev, sha1))        die(_("Failed to resolve '%s' as a valid ref."), rev);    commit = lookup_commit_reference(sha1);    if (!commit)        die(_("Could not parse object '%s'."), rev);    hashcpy(sha1, commit->object.sha1);    if (patch_mode) {        if (reset_type != NONE)            die(_("--patch is incompatible with --{hard,mixed,soft}"));        return interactive_reset(rev, argv + i, prefix);    }    /* git reset tree [--] paths... can be used to     * load chosen paths from the tree into the index without     * affecting the working tree nor HEAD. */    if (i < argc) {        if (reset_type == MIXED)            warning(_("--mixed with paths is deprecated; use 'git reset -- <paths>' instead."));        else if (reset_type != NONE)            die(_("Cannot do %s reset with paths."),                _(reset_type_names[reset_type]));        return read_from_tree(prefix, argv + i, sha1,                              quiet ? REFRESH_QUIET : REFRESH_IN_PORCELAIN);    }    if (reset_type == NONE)        reset_type = MIXED; /* by default */    if (reset_type != SOFT && reset_type != MIXED)        setup_work_tree();    if (reset_type == MIXED && is_bare_repository())        die(_("%s reset is not allowed in a bare repository"),            _(reset_type_names[reset_type]));    /* Soft reset does not touch the index file nor the working tree     * at all, but requires them in a good order.  Other resets reset     * the index file to the tree object we are switching to. */    if (reset_type == SOFT)        die_if_unmerged_cache(reset_type);    else {        int err;        if (reset_type == KEEP)            die_if_unmerged_cache(reset_type);        err = reset_index_file(sha1, reset_type, quiet);        if (reset_type == KEEP)            err = err || reset_index_file(sha1, MIXED, quiet);        if (err)            die(_("Could not reset index file to revision '%s'."), rev);    }    /* Any resets update HEAD to the head being switched to,     * saving the previous head in ORIG_HEAD before. */    if (!get_sha1("ORIG_HEAD", sha1_old_orig))        old_orig = sha1_old_orig;    if (!get_sha1("HEAD", sha1_orig)) {        orig = sha1_orig;        set_reflog_message(&msg, "updating ORIG_HEAD", NULL);        update_ref(msg.buf, "ORIG_HEAD", orig, old_orig, 0, MSG_ON_ERR);    }    else if (old_orig)        delete_ref("ORIG_HEAD", old_orig, 0);    set_reflog_message(&msg, "updating HEAD", rev);    update_ref_status = update_ref(msg.buf, "HEAD", sha1, orig, 0, MSG_ON_ERR);    switch (reset_type) {    case HARD:        if (!update_ref_status && !quiet)            print_new_head_line(commit);        break;    case SOFT: /* Nothing else to do. */        break;    case MIXED: /* Report what has not been updated. */        update_index_refresh(0, NULL,                             quiet ? REFRESH_QUIET : REFRESH_IN_PORCELAIN);        break;    }    remove_branch_state();    strbuf_release(&msg);    return update_ref_status;}

int fetch_populated_submodules(int num_options, const char **options,			       const char *prefix, int command_line_option,			       int quiet){	int i, result = 0, argc = 0, default_argc;	struct child_process cp;	const char **argv;	struct string_list_item *name_for_path;	const char *work_tree = get_git_work_tree();	if (!work_tree)		goto out;	if (!the_index.initialized)		if (read_cache() < 0)			die("index file corrupt");	/* 6: "fetch" (options) --recurse-submodules-default default "--submodule-prefix" prefix NULL */	argv = xcalloc(num_options + 6, sizeof(const char *));	argv[argc++] = "fetch";	for (i = 0; i < num_options; i++)		argv[argc++] = options[i];	argv[argc++] = "--recurse-submodules-default";	default_argc = argc++;	argv[argc++] = "--submodule-prefix";	memset(&cp, 0, sizeof(cp));	cp.argv = argv;	cp.env = local_repo_env;	cp.git_cmd = 1;	cp.no_stdin = 1;	for (i = 0; i < active_nr; i++) {		struct strbuf submodule_path = STRBUF_INIT;		struct strbuf submodule_git_dir = STRBUF_INIT;		struct strbuf submodule_prefix = STRBUF_INIT;		struct cache_entry *ce = active_cache[i];		const char *git_dir, *name, *default_argv;		if (!S_ISGITLINK(ce->ce_mode))			continue;		name = ce->name;		name_for_path = unsorted_string_list_lookup(&config_name_for_path, ce->name);		if (name_for_path)			name = name_for_path->util;		default_argv = "yes";		if (command_line_option == RECURSE_SUBMODULES_DEFAULT) {			struct string_list_item *fetch_recurse_submodules_option;			fetch_recurse_submodules_option = unsorted_string_list_lookup(&config_fetch_recurse_submodules_for_name, name);			if (fetch_recurse_submodules_option) {				if ((intptr_t)fetch_recurse_submodules_option->util == RECURSE_SUBMODULES_OFF)					continue;				if ((intptr_t)fetch_recurse_submodules_option->util == RECURSE_SUBMODULES_ON_DEMAND) {					if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))						continue;					default_argv = "on-demand";				}			} else {				if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_OFF)					continue;				if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND) {					if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))						continue;					default_argv = "on-demand";				}			}		} else if (command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {			if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))				continue;			default_argv = "on-demand";		}		strbuf_addf(&submodule_path, "%s/%s", work_tree, ce->name);		strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);		strbuf_addf(&submodule_prefix, "%s%s/", prefix, ce->name);		git_dir = read_gitfile_gently(submodule_git_dir.buf);		if (!git_dir)			git_dir = submodule_git_dir.buf;		if (is_directory(git_dir)) {			if (!quiet)				printf("Fetching submodule %s%s/n", prefix, ce->name);			cp.dir = submodule_path.buf;			argv[default_argc] = default_argv;			argv[argc] = submodule_prefix.buf;			if (run_command(&cp))				result = 1;		}		strbuf_release(&submodule_path);		strbuf_release(&submodule_git_dir);		strbuf_release(&submodule_prefix);	}	free(argv);out:	string_list_clear(&changed_submodule_paths, 1);	return result;}

//.........这里部分代码省略.........		else			revs->count_right++;		finish_commit(commit, data);		return;	}	if (info->show_timestamp)		printf("%lu ", commit->date);	if (info->header_prefix)		fputs(info->header_prefix, stdout);	if (!revs->graph)		fputs(get_revision_mark(revs, commit), stdout);	if (revs->abbrev_commit && revs->abbrev)		fputs(find_unique_abbrev(commit->object.sha1, revs->abbrev),		      stdout);	else		fputs(sha1_to_hex(commit->object.sha1), stdout);	if (revs->print_parents) {		struct commit_list *parents = commit->parents;		while (parents) {			printf(" %s", sha1_to_hex(parents->item->object.sha1));			parents = parents->next;		}	}	if (revs->children.name) {		struct commit_list *children;		children = lookup_decoration(&revs->children, &commit->object);		while (children) {			printf(" %s", sha1_to_hex(children->item->object.sha1));			children = children->next;		}	}	show_decorations(revs, commit);	if (revs->commit_format == CMIT_FMT_ONELINE)		putchar(' ');	else		putchar('/n');	if (revs->verbose_header && commit->buffer) {		struct strbuf buf = STRBUF_INIT;		struct pretty_print_context ctx = {0};		ctx.abbrev = revs->abbrev;		ctx.date_mode = revs->date_mode;		ctx.date_mode_explicit = revs->date_mode_explicit;		ctx.fmt = revs->commit_format;		ctx.output_encoding = get_log_output_encoding();		pretty_print_commit(&ctx, commit, &buf);		if (revs->graph) {			if (buf.len) {				if (revs->commit_format != CMIT_FMT_ONELINE)					graph_show_oneline(revs->graph);				graph_show_commit_msg(revs->graph, &buf);				/*				 * Add a newline after the commit message.				 *				 * Usually, this newline produces a blank				 * padding line between entries, in which case				 * we need to add graph padding on this line.				 *				 * However, the commit message may not end in a				 * newline.  In this case the newline simply				 * ends the last line of the commit message,				 * and we don't need any graph output.  (This				 * always happens with CMIT_FMT_ONELINE, and it				 * happens with CMIT_FMT_USERFORMAT when the				 * format doesn't explicitly end in a newline.)				 */				if (buf.len && buf.buf[buf.len - 1] == '/n')					graph_show_padding(revs->graph);				putchar('/n');			} else {				/*				 * If the message buffer is empty, just show				 * the rest of the graph output for this				 * commit.				 */				if (graph_show_remainder(revs->graph))					putchar('/n');				if (revs->commit_format == CMIT_FMT_ONELINE)					putchar('/n');			}		} else {			if (revs->commit_format != CMIT_FMT_USERFORMAT ||			    buf.len) {				fwrite(buf.buf, 1, buf.len, stdout);				putchar(info->hdr_termination);			}		}		strbuf_release(&buf);	} else {		if (graph_show_remainder(revs->graph))			putchar('/n');	}	maybe_flush_or_die(stdout, "stdout");	finish_commit(commit, data);}