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

void expand_notes_ref(struct strbuf *sb){	if (starts_with(sb->buf, "refs/notes/"))		return; /* we're happy */	else if (starts_with(sb->buf, "notes/"))		strbuf_insert(sb, 0, "refs/", 5);	else		strbuf_insert(sb, 0, "refs/notes/", 11);}

static size_t format_commit_item(struct strbuf *sb, /* in UTF-8 */				 const char *placeholder,				 void *context){	int consumed;	size_t orig_len;	enum {		NO_MAGIC,		ADD_LF_BEFORE_NON_EMPTY,		DEL_LF_BEFORE_EMPTY,		ADD_SP_BEFORE_NON_EMPTY	} magic = NO_MAGIC;	switch (placeholder[0]) {	case '-':		magic = DEL_LF_BEFORE_EMPTY;		break;	case '+':		magic = ADD_LF_BEFORE_NON_EMPTY;		break;	case ' ':		magic = ADD_SP_BEFORE_NON_EMPTY;		break;	default:		break;	}	if (magic != NO_MAGIC)		placeholder++;	orig_len = sb->len;	if (((struct format_commit_context *)context)->flush_type != no_flush)		consumed = format_and_pad_commit(sb, placeholder, context);	else		consumed = format_commit_one(sb, placeholder, context);	if (magic == NO_MAGIC)		return consumed;	if ((orig_len == sb->len) && magic == DEL_LF_BEFORE_EMPTY) {		while (sb->len && sb->buf[sb->len - 1] == '/n')			strbuf_setlen(sb, sb->len - 1);	} else if (orig_len != sb->len) {		if (magic == ADD_LF_BEFORE_NON_EMPTY)			strbuf_insert(sb, orig_len, "/n", 1);		else if (magic == ADD_SP_BEFORE_NON_EMPTY)			strbuf_insert(sb, orig_len, " ", 1);	}	return consumed + 1;}

static inline void strbuf_write(struct strbuf *sb, const char *buf, int len){	if (sb)		strbuf_insert(sb, sb->len, buf, len);	else		fwrite(buf, len, 1, stdout);}

static int grep_oid(struct grep_opt *opt, const struct object_id *oid,		     const char *filename, int tree_name_len,		     const char *path){	struct strbuf pathbuf = STRBUF_INIT;	if (opt->relative && opt->prefix_length) {		quote_path_relative(filename + tree_name_len, opt->prefix, &pathbuf);		strbuf_insert(&pathbuf, 0, filename, tree_name_len);	} else {		strbuf_addstr(&pathbuf, filename);	}#ifndef NO_PTHREADS	if (num_threads) {		add_work(opt, GREP_SOURCE_OID, pathbuf.buf, path, oid);		strbuf_release(&pathbuf);		return 0;	} else#endif	{		struct grep_source gs;		int hit;		grep_source_init(&gs, GREP_SOURCE_OID, pathbuf.buf, path, oid);		strbuf_release(&pathbuf);		hit = grep_source(opt, &gs);		grep_source_clear(&gs);		return hit;	}}

static int grep_sha1(struct grep_opt *opt, const unsigned char *sha1,		     const char *filename, int tree_name_len,		     const char *path){	struct strbuf pathbuf = STRBUF_INIT;	if (opt->relative && opt->prefix_length) {		quote_path_relative(filename + tree_name_len, -1, &pathbuf,				    opt->prefix);		strbuf_insert(&pathbuf, 0, filename, tree_name_len);	} else {		strbuf_addstr(&pathbuf, filename);	}#ifndef NO_PTHREADS	if (use_threads) {		add_work(opt, GREP_SOURCE_SHA1, pathbuf.buf, path, sha1);		strbuf_release(&pathbuf);		return 0;	} else#endif	{		struct grep_source gs;		int hit;		grep_source_init(&gs, GREP_SOURCE_SHA1, pathbuf.buf, path, sha1);		strbuf_release(&pathbuf);		hit = grep_source(opt, &gs);		grep_source_clear(&gs);		return hit;	}}

static int check_header(const struct strbuf *line,				struct strbuf *hdr_data[], int overwrite){	int i, ret = 0, len;	struct strbuf sb = STRBUF_INIT;	/* search for the interesting parts */	for (i = 0; header[i]; i++) {		int len = strlen(header[i]);		if ((!hdr_data[i] || overwrite) && cmp_header(line, header[i])) {			/* Unwrap inline B and Q encoding, and optionally			 * normalize the meta information to utf8.			 */			strbuf_add(&sb, line->buf + len + 2, line->len - len - 2);			decode_header(&sb);			handle_header(&hdr_data[i], &sb);			ret = 1;			goto check_header_out;		}	}	/* Content stuff */	if (cmp_header(line, "Content-Type")) {		len = strlen("Content-Type: ");		strbuf_add(&sb, line->buf + len, line->len - len);		decode_header(&sb);		strbuf_insert(&sb, 0, "Content-Type: ", len);		handle_content_type(&sb);		ret = 1;		goto check_header_out;	}	if (cmp_header(line, "Content-Transfer-Encoding")) {		len = strlen("Content-Transfer-Encoding: ");		strbuf_add(&sb, line->buf + len, line->len - len);		decode_header(&sb);		handle_content_transfer_encoding(&sb);		ret = 1;		goto check_header_out;	}	/* for inbody stuff */	if (!prefixcmp(line->buf, ">From") && isspace(line->buf[5])) {		ret = 1; /* Should this return 0? */		goto check_header_out;	}	if (!prefixcmp(line->buf, "[PATCH]") && isspace(line->buf[7])) {		for (i = 0; header[i]; i++) {			if (!memcmp("Subject", header[i], 7)) {				handle_header(&hdr_data[i], line);				ret = 1;				goto check_header_out;			}		}	}check_header_out:	strbuf_release(&sb);	return ret;}

static int check_header(struct mailinfo *mi,			const struct strbuf *line,			struct strbuf *hdr_data[], int overwrite){	int i, ret = 0, len;	struct strbuf sb = STRBUF_INIT;	/* search for the interesting parts */	for (i = 0; header[i]; i++) {		int len = strlen(header[i]);		if ((!hdr_data[i] || overwrite) && cmp_header(line, header[i])) {			/* Unwrap inline B and Q encoding, and optionally			 * normalize the meta information to utf8.			 */			strbuf_add(&sb, line->buf + len + 2, line->len - len - 2);			decode_header(mi, &sb);			handle_header(&hdr_data[i], &sb);			ret = 1;			goto check_header_out;		}	}	/* Content stuff */	if (cmp_header(line, "Content-Type")) {		len = strlen("Content-Type: ");		strbuf_add(&sb, line->buf + len, line->len - len);		decode_header(mi, &sb);		strbuf_insert(&sb, 0, "Content-Type: ", len);		handle_content_type(mi, &sb);		ret = 1;		goto check_header_out;	}	if (cmp_header(line, "Content-Transfer-Encoding")) {		len = strlen("Content-Transfer-Encoding: ");		strbuf_add(&sb, line->buf + len, line->len - len);		decode_header(mi, &sb);		handle_content_transfer_encoding(mi, &sb);		ret = 1;		goto check_header_out;	}	if (cmp_header(line, "Message-Id")) {		len = strlen("Message-Id: ");		strbuf_add(&sb, line->buf + len, line->len - len);		decode_header(mi, &sb);		if (mi->add_message_id)			mi->message_id = strbuf_detach(&sb, NULL);		ret = 1;		goto check_header_out;	}check_header_out:	strbuf_release(&sb);	return ret;}

static void fmt_merge_msg_sigs(struct strbuf *out){	int i, tag_number = 0, first_tag = 0;	struct strbuf tagbuf = STRBUF_INIT;	for (i = 0; i < origins.nr; i++) {		unsigned char *sha1 = origins.items[i].util;		enum object_type type;		unsigned long size, len;		char *buf = read_sha1_file(sha1, &type, &size);		struct strbuf sig = STRBUF_INIT;		if (!buf || type != OBJ_TAG)			goto next;		len = parse_signature(buf, size);		if (size == len)			; /* merely annotated */		else if (verify_signed_buffer(buf, len, buf + len, size - len, &sig, NULL)) {			if (!sig.len)				strbuf_addstr(&sig, "gpg verification failed./n");		}		if (!tag_number++) {			fmt_tag_signature(&tagbuf, &sig, buf, len);			first_tag = i;		} else {			if (tag_number == 2) {				struct strbuf tagline = STRBUF_INIT;				strbuf_addch(&tagline, '/n');				strbuf_add_commented_lines(&tagline,						origins.items[first_tag].string,						strlen(origins.items[first_tag].string));				strbuf_insert(&tagbuf, 0, tagline.buf,					      tagline.len);				strbuf_release(&tagline);			}			strbuf_addch(&tagbuf, '/n');			strbuf_add_commented_lines(&tagbuf,					origins.items[i].string,					strlen(origins.items[i].string));			fmt_tag_signature(&tagbuf, &sig, buf, len);		}		strbuf_release(&sig);	next:		free(buf);	}	if (tagbuf.len) {		strbuf_addch(out, '/n');		strbuf_addbuf(out, &tagbuf);	}	strbuf_release(&tagbuf);}

static int merge_commit(struct notes_merge_options *o){	struct strbuf msg = STRBUF_INIT;	unsigned char sha1[20], parent_sha1[20];	struct notes_tree *t;	struct commit *partial;	struct pretty_print_context pretty_ctx;	void *local_ref_to_free;	int ret;	/*	 * Read partial merge result from .git/NOTES_MERGE_PARTIAL,	 * and target notes ref from .git/NOTES_MERGE_REF.	 */	if (get_sha1("NOTES_MERGE_PARTIAL", sha1))		die("Failed to read ref NOTES_MERGE_PARTIAL");	else if (!(partial = lookup_commit_reference(sha1)))		die("Could not find commit from NOTES_MERGE_PARTIAL.");	else if (parse_commit(partial))		die("Could not parse commit from NOTES_MERGE_PARTIAL.");	if (partial->parents)		hashcpy(parent_sha1, partial->parents->item->object.sha1);	else		hashclr(parent_sha1);	t = xcalloc(1, sizeof(struct notes_tree));	init_notes(t, "NOTES_MERGE_PARTIAL", combine_notes_overwrite, 0);	o->local_ref = local_ref_to_free =		resolve_refdup("NOTES_MERGE_REF", 0, sha1, NULL);	if (!o->local_ref)		die("Failed to resolve NOTES_MERGE_REF");	if (notes_merge_commit(o, t, partial, sha1))		die("Failed to finalize notes merge");	/* Reuse existing commit message in reflog message */	memset(&pretty_ctx, 0, sizeof(pretty_ctx));	format_commit_message(partial, "%s", &msg, &pretty_ctx);	strbuf_trim(&msg);	strbuf_insert(&msg, 0, "notes: ", 7);	update_ref(msg.buf, o->local_ref, sha1,		   is_null_sha1(parent_sha1) ? NULL : parent_sha1,		   0, UPDATE_REFS_DIE_ON_ERR);	free_notes(t);	strbuf_release(&msg);	ret = merge_abort(o);	free(local_ref_to_free);	return ret;}

int main() {    struct strbuf buffer;    strbuf_init(&buffer, 0);    strbuf_grow(&buffer, 100);    print(buffer);    strbuf_addchars(&buffer, 'a', 90);    print(buffer);    strbuf_insert(&buffer, 40, "prince dhaliwal", 15);    strbuf_fread(&buffer, 100, stdin);    print(buffer);    printf("%zd", strbuf_avail(&buffer));    strbuf_release(&buffer);    return 0;}

static int fill_entry_new_sha1(struct trunk_entry *entry){	struct strbuf buf = STRBUF_INIT;	int fd, ret = 0;	struct sha1_file_hdr hdr = { .priv = 0 };	memcpy(hdr.tag, TAG_DATA, TAG_LEN);	strbuf_addstr(&buf, obj_path);	strbuf_addf(&buf, "%016" PRIx64, entry->oid);	fd = open(buf.buf, O_RDONLY);	strbuf_reset(&buf);	if (fd < 0) {		dprintf("%m/n");		ret = -1;		goto out;	}	if (!strbuf_read(&buf, fd, SD_DATA_OBJ_SIZE) == SD_DATA_OBJ_SIZE) {		dprintf("strbuf_read fail to read full/n");		ret = -1;		goto out_close;	}	hdr.size = buf.len;	strbuf_insert(&buf, 0, &hdr, sizeof(hdr));	if (sha1_file_write((void *)buf.buf, buf.len, entry->sha1) < 0) {		ret = -1;		goto out_close;	}	dprintf("data sha1:%s, %"PRIx64"/n", sha1_to_hex(entry->sha1),		entry->oid);out_close:	close(fd);out:	strbuf_release(&buf);	return ret;}static int inc_object_nr(uint64_t oid, void *arg){	uint64_t *object_nr = arg;	(*object_nr)++;	return 0;}

static int fill_entry_new_sha1(struct trunk_entry_incore *entry){	struct strbuf buf = STRBUF_INIT;	int fd, ret = 0;	struct sha1_file_hdr hdr = { .priv = 0 };	memcpy(hdr.tag, TAG_DATA, TAG_LEN);	strbuf_addstr(&buf, obj_path);	strbuf_addf(&buf, "%016" PRIx64, entry->raw.oid);	fd = open(buf.buf, O_RDONLY);	strbuf_reset(&buf);	if (fd < 0) {		dprintf("%m/n");		ret = -1;		goto out;	}	if (!strbuf_read(&buf, fd, SD_DATA_OBJ_SIZE) == SD_DATA_OBJ_SIZE) {		dprintf("strbuf_read fail to read full/n");		ret = -1;		goto out_close;	}	hdr.size = buf.len;	strbuf_insert(&buf, 0, &hdr, sizeof(hdr));	if (sha1_file_write((void *)buf.buf, buf.len, entry->raw.sha1) < 0) {		ret = -1;		goto out_close;	}	dprintf("data sha1:%s, %"PRIx64"/n", sha1_to_hex(entry->raw.sha1),		entry->raw.oid);out_close:	close(fd);out:	strbuf_release(&buf);	return ret;}static inline int trunk_entry_no_sha1(struct trunk_entry_incore *entry){	unsigned char empty[SHA1_LEN] = {0};	return memcmp(entry->raw.sha1, empty, SHA1_LEN) == 0;}

void commit_notes(struct notes_tree *t, const char *msg){	struct strbuf buf = STRBUF_INIT;	unsigned char commit_sha1[20];	if (!t)		t = &default_notes_tree;	if (!t->initialized || !t->ref || !*t->ref)		die(_("Cannot commit uninitialized/unreferenced notes tree"));	if (!t->dirty)		return; /* don't have to commit an unchanged tree */	/* Prepare commit message and reflog message */	strbuf_addstr(&buf, msg);	strbuf_complete_line(&buf);	create_notes_commit(t, NULL, buf.buf, buf.len, commit_sha1);	strbuf_insert(&buf, 0, "notes: ", 7); /* commit message starts at index 7 */	update_ref(buf.buf, t->ref, commit_sha1, NULL, 0,		   UPDATE_REFS_DIE_ON_ERR);	strbuf_release(&buf);}

static void handle_content_type(struct strbuf *line){	struct strbuf *boundary = xmalloc(sizeof(struct strbuf));	strbuf_init(boundary, line->len);	if (!strcasestr(line->buf, "text/"))		 message_type = TYPE_OTHER;	if (slurp_attr(line->buf, "boundary=", boundary)) {		strbuf_insert(boundary, 0, "--", 2);		if (++content_top > &content[MAX_BOUNDARIES]) {			fprintf(stderr, "Too many boundaries to handle/n");			exit(1);		}		*content_top = boundary;		boundary = NULL;	}	slurp_attr(line->buf, "charset=", &charset);	if (boundary) {		strbuf_release(boundary);		free(boundary);	}}

static void handle_content_type(struct mailinfo *mi, struct strbuf *line){	struct strbuf *boundary = xmalloc(sizeof(struct strbuf));	strbuf_init(boundary, line->len);	if (slurp_attr(line->buf, "boundary=", boundary)) {		strbuf_insert(boundary, 0, "--", 2);		if (++mi->content_top >= &mi->content[MAX_BOUNDARIES]) {			error("Too many boundaries to handle");			mi->input_error = -1;			mi->content_top = &mi->content[MAX_BOUNDARIES] - 1;			return;		}		*(mi->content_top) = boundary;		boundary = NULL;	}	slurp_attr(line->buf, "charset=", &mi->charset);	if (boundary) {		strbuf_release(boundary);		free(boundary);	}}

static int grep_sha1(struct grep_opt *opt, const unsigned char *sha1,		     const char *filename, int tree_name_len){	struct strbuf pathbuf = STRBUF_INIT;	char *name;	if (opt->relative && opt->prefix_length) {		quote_path_relative(filename + tree_name_len, -1, &pathbuf,				    opt->prefix);		strbuf_insert(&pathbuf, 0, filename, tree_name_len);	} else {		strbuf_addstr(&pathbuf, filename);	}	name = strbuf_detach(&pathbuf, NULL);#ifndef NO_PTHREADS	if (use_threads) {		grep_sha1_async(opt, name, sha1);		return 0;	} else#endif	{		int hit;		unsigned long sz;		void *data = load_sha1(sha1, &sz, name);		if (!data)			hit = 0;		else			hit = grep_buffer(opt, name, data, sz);		free(data);		free(name);		return hit;	}}

static int grep_oid(struct grep_opt *opt, const struct object_id *oid,		     const char *filename, int tree_name_len,		     const char *path){	struct strbuf pathbuf = STRBUF_INIT;	struct grep_source gs;	if (opt->relative && opt->prefix_length) {		quote_path_relative(filename + tree_name_len, opt->prefix, &pathbuf);		strbuf_insert(&pathbuf, 0, filename, tree_name_len);	} else {		strbuf_addstr(&pathbuf, filename);	}	grep_source_init(&gs, GREP_SOURCE_OID, pathbuf.buf, path, oid);	strbuf_release(&pathbuf);#ifndef NO_PTHREADS	if (num_threads) {		/*		 * add_work() copies gs and thus assumes ownership of		 * its fields, so do not call grep_source_clear()		 */		add_work(opt, &gs);		return 0;	} else#endif	{		int hit;		hit = grep_source(opt, &gs);		grep_source_clear(&gs);		return hit;	}}

static void create_note(const unsigned char *object, struct msg_arg *msg,			int append_only, const unsigned char *prev,			unsigned char *result){	char *path = NULL;	if (msg->use_editor || !msg->given) {		int fd;		/* write the template message before editing: */		path = git_pathdup("NOTES_EDITMSG");		fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0600);		if (fd < 0)			die_errno("could not create file '%s'", path);		if (msg->given)			write_or_die(fd, msg->buf.buf, msg->buf.len);		else if (prev && !append_only)			write_note_data(fd, prev);		write_or_die(fd, note_template, strlen(note_template));		write_commented_object(fd, object);		close(fd);		strbuf_reset(&(msg->buf));		if (launch_editor(path, &(msg->buf), NULL)) {			die("Please supply the note contents using either -m" /			    " or -F option");		}		stripspace(&(msg->buf), 1);	}	if (prev && append_only) {		/* Append buf to previous note contents */		unsigned long size;		enum object_type type;		char *prev_buf = read_sha1_file(prev, &type, &size);		strbuf_grow(&(msg->buf), size + 1);		if (msg->buf.len && prev_buf && size)			strbuf_insert(&(msg->buf), 0, "/n", 1);		if (prev_buf && size)			strbuf_insert(&(msg->buf), 0, prev_buf, size);		free(prev_buf);	}	if (!msg->buf.len) {		fprintf(stderr, "Removing note for object %s/n",			sha1_to_hex(object));		hashclr(result);	} else {		if (write_sha1_file(msg->buf.buf, msg->buf.len, blob_type, result)) {			error("unable to write note object");			if (path)				error("The note contents has been left in %s",				      path);			exit(128);		}	}	if (path) {		unlink_or_warn(path);		free(path);	}}

static size_t format_and_pad_commit(struct strbuf *sb, /* in UTF-8 */				    const char *placeholder,				    struct format_commit_context *c){	struct strbuf local_sb = STRBUF_INIT;	int total_consumed = 0, len, padding = c->padding;	if (padding < 0) {		const char *start = strrchr(sb->buf, '/n');		int occupied;		if (!start)			start = sb->buf;		occupied = utf8_strnwidth(start, -1, 1);		padding = (-padding) - occupied;	}	while (1) {		int modifier = *placeholder == 'C';		int consumed = format_commit_one(&local_sb, placeholder, c);		total_consumed += consumed;		if (!modifier)			break;		placeholder += consumed;		if (*placeholder != '%')			break;		placeholder++;		total_consumed++;	}	len = utf8_strnwidth(local_sb.buf, -1, 1);	if (c->flush_type == flush_left_and_steal) {		const char *ch = sb->buf + sb->len - 1;		while (len > padding && ch > sb->buf) {			const char *p;			if (*ch == ' ') {				ch--;				padding++;				continue;			}			/* check for trailing ansi sequences */			if (*ch != 'm')				break;			p = ch - 1;			while (ch - p < 10 && *p != '/033')				p--;			if (*p != '/033' ||			    ch + 1 - p != display_mode_esc_sequence_len(p))				break;			/*			 * got a good ansi sequence, put it back to			 * local_sb as we're cutting sb			 */			strbuf_insert(&local_sb, 0, p, ch + 1 - p);			ch = p - 1;		}		strbuf_setlen(sb, ch + 1 - sb->buf);		c->flush_type = flush_left;	}	if (len > padding) {		switch (c->truncate) {		case trunc_left:			strbuf_utf8_replace(&local_sb,					    0, len - (padding - 2),					    "..");			break;		case trunc_middle:			strbuf_utf8_replace(&local_sb,					    padding / 2 - 1,					    len - (padding - 2),					    "..");			break;		case trunc_right:			strbuf_utf8_replace(&local_sb,					    padding - 2, len - (padding - 2),					    "..");			break;		case trunc_none:			break;		}		strbuf_addbuf(sb, &local_sb);	} else {		int sb_len = sb->len, offset = 0;		if (c->flush_type == flush_left)			offset = padding - len;		else if (c->flush_type == flush_both)			offset = (padding - len) / 2;		/*		 * we calculate padding in columns, now		 * convert it back to chars		 */		padding = padding - len + local_sb.len;		strbuf_grow(sb, padding);		strbuf_setlen(sb, sb_len + padding);		memset(sb->buf + sb_len, ' ', sb->len - sb_len);		memcpy(sb->buf + sb_len + offset, local_sb.buf,		       local_sb.len);	}	strbuf_release(&local_sb);	c->flush_type = no_flush;//.........这里部分代码省略.........

//.........这里部分代码省略.........				  git_path("MERGE_HEAD"));		while (strbuf_getline(&m, fp, '/n') != EOF) {			unsigned char sha1[20];			if (get_sha1_hex(m.buf, sha1) < 0)				die("Corrupt MERGE_HEAD file (%s)", m.buf);			pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;		}		fclose(fp);		strbuf_release(&m);		if (!stat(git_path("MERGE_MODE"), &statbuf)) {			if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)				die_errno("could not read MERGE_MODE");			if (!strcmp(sb.buf, "no-ff"))				allow_fast_forward = 0;		}		if (allow_fast_forward)			parents = reduce_heads(parents);	} else {		if (!reflog_msg)			reflog_msg = "commit";		pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;	}	/* Finally, get the commit message */	strbuf_reset(&sb);	if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {		int saved_errno = errno;		rollback_index_files();		die("could not read commit message: %s", strerror(saved_errno));	}	/* Truncate the message just before the diff, if any. */	if (verbose) {		p = strstr(sb.buf, "/ndiff --git ");		if (p != NULL)			strbuf_setlen(&sb, p - sb.buf + 1);	}	if (cleanup_mode != CLEANUP_NONE)		stripspace(&sb, cleanup_mode == CLEANUP_ALL);	if (message_is_empty(&sb) && !allow_empty_message) {		rollback_index_files();		fprintf(stderr, "Aborting commit due to empty commit message./n");		exit(1);	}	if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,			fmt_ident(author_name, author_email, author_date,				IDENT_ERROR_ON_NO_NAME))) {		rollback_index_files();		die("failed to write commit object");	}	ref_lock = lock_any_ref_for_update("HEAD",					   initial_commit ? NULL : head_sha1,					   0);	nl = strchr(sb.buf, '/n');	if (nl)		strbuf_setlen(&sb, nl + 1 - sb.buf);	else		strbuf_addch(&sb, '/n');	strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));	strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);	if (!ref_lock) {		rollback_index_files();		die("cannot lock HEAD ref");	}	if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {		rollback_index_files();		die("cannot update HEAD ref");	}	unlink(git_path("MERGE_HEAD"));	unlink(git_path("MERGE_MSG"));	unlink(git_path("MERGE_MODE"));	unlink(git_path("SQUASH_MSG"));	if (commit_index_files())		die ("Repository has been updated, but unable to write/n"		     "new_index file. Check that disk is not full or quota is/n"		     "not exceeded, and then /"git reset HEAD/" to recover.");	rerere(0);	run_hook(get_index_file(), "post-commit", NULL);	if (amend && !no_post_rewrite) {		struct notes_rewrite_cfg *cfg;		cfg = init_copy_notes_for_rewrite("amend");		if (cfg) {			copy_note_for_rewrite(cfg, head_sha1, commit_sha1);			finish_copy_notes_for_rewrite(cfg);		}		run_rewrite_hook(head_sha1, commit_sha1);	}	if (!quiet)		print_summary(prefix, commit_sha1);	return 0;}

static void create_tag(const unsigned char *object, const char *tag,		       struct strbuf *buf, struct create_tag_options *opt,		       unsigned char *prev, unsigned char *result){	enum object_type type;	char header_buf[1024];	int header_len;	char *path = NULL;	type = sha1_object_info(object, NULL);	if (type <= OBJ_NONE)	    die(_("bad object type."));	header_len = snprintf(header_buf, sizeof(header_buf),			  "object %s/n"			  "type %s/n"			  "tag %s/n"			  "tagger %s/n/n",			  sha1_to_hex(object),			  typename(type),			  tag,			  git_committer_info(IDENT_STRICT));	if (header_len > sizeof(header_buf) - 1)		die(_("tag header too big."));	if (!opt->message_given) {		int fd;		/* write the template message before editing: */		path = git_pathdup("TAG_EDITMSG");		fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0600);		if (fd < 0)			die_errno(_("could not create file '%s'"), path);		if (!is_null_sha1(prev)) {			write_tag_body(fd, prev);		} else {			struct strbuf buf = STRBUF_INIT;			strbuf_addch(&buf, '/n');			if (opt->cleanup_mode == CLEANUP_ALL)				strbuf_commented_addf(&buf, _(tag_template), tag, comment_line_char);			else				strbuf_commented_addf(&buf, _(tag_template_nocleanup), tag, comment_line_char);			write_or_die(fd, buf.buf, buf.len);			strbuf_release(&buf);		}		close(fd);		if (launch_editor(path, buf, NULL)) {			fprintf(stderr,			_("Please supply the message using either -m or -F option./n"));			exit(1);		}	}	if (opt->cleanup_mode != CLEANUP_NONE)		strbuf_stripspace(buf, opt->cleanup_mode == CLEANUP_ALL);	if (!opt->message_given && !buf->len)		die(_("no tag message?"));	strbuf_insert(buf, 0, header_buf, header_len);	if (build_tag_object(buf, opt->sign, result) < 0) {		if (path)			fprintf(stderr, _("The tag message has been left in %s/n"),				path);		exit(128);	}	if (path) {		unlink_or_warn(path);		free(path);	}}

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(the_repository,				      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(the_repository);	strbuf_release(&msg);	if (!opts->quiet &&	    (new_branch_info->path || (!opts->force_detach && !strcmp(new_branch_info->name, "HEAD"))))		report_tracking(new_branch_info);}

static void handle_body(void){	struct strbuf prev = STRBUF_INIT;	/* Skip up to the first boundary */	if (*content_top) {		if (!find_boundary())			goto handle_body_out;	}	do {		/* process any boundary lines */		if (*content_top && is_multipart_boundary(&line)) {			/* flush any leftover */			if (prev.len) {				handle_filter(&prev);				strbuf_reset(&prev);			}			if (!handle_boundary())				goto handle_body_out;		}		/* Unwrap transfer encoding */		decode_transfer_encoding(&line);		switch (transfer_encoding) {		case TE_BASE64:		case TE_QP:		{			struct strbuf **lines, **it, *sb;			/* Prepend any previous partial lines */			strbuf_insert(&line, 0, prev.buf, prev.len);			strbuf_reset(&prev);			/* binary data most likely doesn't have newlines */			if (message_type != TYPE_TEXT) {				handle_filter(&line);				break;			}			/*			 * This is a decoded line that may contain			 * multiple new lines.  Pass only one chunk			 * at a time to handle_filter()			 */			lines = strbuf_split(&line, '/n');			for (it = lines; (sb = *it); it++) {				if (*(it + 1) == NULL) /* The last line */					if (sb->buf[sb->len - 1] != '/n') {						/* Partial line, save it for later. */						strbuf_addbuf(&prev, sb);						break;					}				handle_filter(sb);			}			/*			 * The partial chunk is saved in "prev" and will be			 * appended by the next iteration of read_line_with_nul().			 */			strbuf_list_free(lines);			break;		}		default:			handle_filter(&line);		}	} while (!strbuf_getwholeline(&line, fin, '/n'));handle_body_out:	strbuf_release(&prev);}

//.........这里部分代码省略.........		if (!reflog_msg)			reflog_msg = (whence == FROM_CHERRY_PICK)					? "commit (cherry-pick)"					: "commit";		pptr = &commit_list_insert(current_head, pptr)->next;	}	/* Finally, get the commit message */	strbuf_reset(&sb);	if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {		int saved_errno = errno;		rollback_index_files();		die(_("could not read commit message: %s"), strerror(saved_errno));	}	/* Truncate the message just before the diff, if any. */	if (verbose)		wt_status_truncate_message_at_cut_line(&sb);	if (cleanup_mode != CLEANUP_NONE)		stripspace(&sb, cleanup_mode == CLEANUP_ALL);	if (template_untouched(&sb) && !allow_empty_message) {		rollback_index_files();		fprintf(stderr, _("Aborting commit; you did not edit the message./n"));		exit(1);	}	if (message_is_empty(&sb) && !allow_empty_message) {		rollback_index_files();		fprintf(stderr, _("Aborting commit due to empty commit message./n"));		exit(1);	}	if (amend) {		const char *exclude_gpgsig[2] = { "gpgsig", NULL };		extra = read_commit_extra_headers(current_head, exclude_gpgsig);	} else {		struct commit_extra_header **tail = &extra;		append_merge_tag_headers(parents, &tail);	}	if (commit_tree_extended(&sb, active_cache_tree->sha1, parents, sha1,				 author_ident.buf, sign_commit, extra)) {		rollback_index_files();		die(_("failed to write commit object"));	}	strbuf_release(&author_ident);	free_commit_extra_headers(extra);	ref_lock = lock_any_ref_for_update("HEAD",					   !current_head					   ? NULL					   : current_head->object.sha1,					   0, NULL);	nl = strchr(sb.buf, '/n');	if (nl)		strbuf_setlen(&sb, nl + 1 - sb.buf);	else		strbuf_addch(&sb, '/n');	strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));	strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);	if (!ref_lock) {		rollback_index_files();		die(_("cannot lock HEAD ref"));	}	if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {		rollback_index_files();		die(_("cannot update HEAD ref"));	}	unlink(git_path("CHERRY_PICK_HEAD"));	unlink(git_path("REVERT_HEAD"));	unlink(git_path("MERGE_HEAD"));	unlink(git_path("MERGE_MSG"));	unlink(git_path("MERGE_MODE"));	unlink(git_path("SQUASH_MSG"));	if (commit_index_files())		die (_("Repository has been updated, but unable to write/n"		     "new_index file. Check that disk is not full or quota is/n"		     "not exceeded, and then /"git reset HEAD/" to recover."));	rerere(0);	run_hook(get_index_file(), "post-commit", NULL);	if (amend && !no_post_rewrite) {		struct notes_rewrite_cfg *cfg;		cfg = init_copy_notes_for_rewrite("amend");		if (cfg) {			/* we are amending, so current_head is not NULL */			copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);			finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");		}		run_rewrite_hook(current_head->object.sha1, sha1);	}	if (!quiet)		print_summary(prefix, sha1, !current_head);	return 0;}

//.........这里部分代码省略.........			die("could not parse HEAD commit");		for (c = commit->parents; c; c = c->next)			add_parent(&sb, c->item->object.sha1);	} else if (in_merge) {		struct strbuf m;		FILE *fp;		reflog_msg = "commit (merge)";		add_parent(&sb, head_sha1);		strbuf_init(&m, 0);		fp = fopen(git_path("MERGE_HEAD"), "r");		if (fp == NULL)			die("could not open %s for reading: %s",			    git_path("MERGE_HEAD"), strerror(errno));		while (strbuf_getline(&m, fp, '/n') != EOF) {			unsigned char sha1[20];			if (get_sha1_hex(m.buf, sha1) < 0)				die("Corrupt MERGE_HEAD file (%s)", m.buf);			add_parent(&sb, sha1);		}		fclose(fp);		strbuf_release(&m);	} else {		reflog_msg = "commit";		strbuf_addf(&sb, "parent %s/n", sha1_to_hex(head_sha1));	}	strbuf_addf(&sb, "author %s/n",		    fmt_ident(author_name, author_email, author_date, IDENT_ERROR_ON_NO_NAME));	strbuf_addf(&sb, "committer %s/n", git_committer_info(IDENT_ERROR_ON_NO_NAME));	if (!is_encoding_utf8(git_commit_encoding))		strbuf_addf(&sb, "encoding %s/n", git_commit_encoding);	strbuf_addch(&sb, '/n');	/* Finally, get the commit message */	header_len = sb.len;	if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {		rollback_index_files();		die("could not read commit message");	}	/* Truncate the message just before the diff, if any. */	p = strstr(sb.buf, "/ndiff --git a/");	if (p != NULL)		strbuf_setlen(&sb, p - sb.buf + 1);	if (cleanup_mode != CLEANUP_NONE)		stripspace(&sb, cleanup_mode == CLEANUP_ALL);	if (sb.len < header_len || message_is_empty(&sb, header_len)) {		rollback_index_files();		die("no commit message?  aborting commit.");	}	strbuf_addch(&sb, '/0');	if (is_encoding_utf8(git_commit_encoding) && !is_utf8(sb.buf))		fprintf(stderr, commit_utf8_warn);	if (write_sha1_file(sb.buf, sb.len - 1, commit_type, commit_sha1)) {		rollback_index_files();		die("failed to write commit object");	}	ref_lock = lock_any_ref_for_update("HEAD",					   initial_commit ? NULL : head_sha1,					   0);	nl = strchr(sb.buf + header_len, '/n');	if (nl)		strbuf_setlen(&sb, nl + 1 - sb.buf);	else		strbuf_addch(&sb, '/n');	strbuf_remove(&sb, 0, header_len);	strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));	strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);	if (!ref_lock) {		rollback_index_files();		die("cannot lock HEAD ref");	}	if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {		rollback_index_files();		die("cannot update HEAD ref");	}	unlink(git_path("MERGE_HEAD"));	unlink(git_path("MERGE_MSG"));	unlink(git_path("SQUASH_MSG"));	if (commit_index_files())		die ("Repository has been updated, but unable to write/n"		     "new_index file. Check that disk is not full or quota is/n"		     "not exceeded, and then /"git reset HEAD/" to recover.");	rerere();	run_hook(get_index_file(), "post-commit", NULL);	if (!quiet)		print_summary(prefix, commit_sha1);	return 0;}

static int append_edit(int argc, const char **argv, const char *prefix){	int allow_empty = 0;	const char *object_ref;	struct notes_tree *t;	unsigned char object[20], new_note[20];	const unsigned char *note;	char logmsg[100];	const char * const *usage;	struct note_data d = { 0, 0, NULL, STRBUF_INIT };	struct option options[] = {		{ OPTION_CALLBACK, 'm', "message", &d, N_("message"),			N_("note contents as a string"), PARSE_OPT_NONEG,			parse_msg_arg},		{ OPTION_CALLBACK, 'F', "file", &d, N_("file"),			N_("note contents in a file"), PARSE_OPT_NONEG,			parse_file_arg},		{ OPTION_CALLBACK, 'c', "reedit-message", &d, N_("object"),			N_("reuse and edit specified note object"), PARSE_OPT_NONEG,			parse_reedit_arg},		{ OPTION_CALLBACK, 'C', "reuse-message", &d, N_("object"),			N_("reuse specified note object"), PARSE_OPT_NONEG,			parse_reuse_arg},		OPT_BOOL(0, "allow-empty", &allow_empty,			N_("allow storing empty note")),		OPT_END()	};	int edit = !strcmp(argv[0], "edit");	usage = edit ? git_notes_edit_usage : git_notes_append_usage;	argc = parse_options(argc, argv, prefix, options, usage,			     PARSE_OPT_KEEP_ARGV0);	if (2 < argc) {		error(_("too many parameters"));		usage_with_options(usage, options);	}	if (d.given && edit)		fprintf(stderr, _("The -m/-F/-c/-C options have been deprecated "			"for the 'edit' subcommand./n"			"Please use 'git notes add -f -m/-F/-c/-C' instead./n"));	object_ref = 1 < argc ? argv[1] : "HEAD";	if (get_sha1(object_ref, object))		die(_("Failed to resolve '%s' as a valid ref."), object_ref);	t = init_notes_check(argv[0]);	note = get_note(t, object);	prepare_note_data(object, &d, edit ? note : NULL);	if (note && !edit) {		/* Append buf to previous note contents */		unsigned long size;		enum object_type type;		char *prev_buf = read_sha1_file(note, &type, &size);		strbuf_grow(&d.buf, size + 1);		if (d.buf.len && prev_buf && size)			strbuf_insert(&d.buf, 0, "/n", 1);		if (prev_buf && size)			strbuf_insert(&d.buf, 0, prev_buf, size);		free(prev_buf);	}	if (d.buf.len || allow_empty) {		write_note_data(&d, new_note);		if (add_note(t, object, new_note, combine_notes_overwrite))			die("BUG: combine_notes_overwrite failed");		snprintf(logmsg, sizeof(logmsg), "Notes added by 'git notes %s'",			argv[0]);	} else {		fprintf(stderr, _("Removing note for object %s/n"),			sha1_to_hex(object));		remove_note(t, object);		snprintf(logmsg, sizeof(logmsg), "Notes removed by 'git notes %s'",			argv[0]);	}	commit_notes(t, logmsg);	free_note_data(&d);	free_notes(t);	return 0;}

uint32_tinsert_style_post(Style *style, StrBuf *strbuf, uint32_t pos){	strbuf_insert(strbuf, pos, style->post_string);	return strlen(style->post_string);}