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

int transport_fetch_refs(struct transport *transport, struct ref *refs){	int rc;	int nr_heads = 0, nr_alloc = 0, nr_refs = 0;	struct ref **heads = NULL;	struct ref *rm;	for (rm = refs; rm; rm = rm->next) {		nr_refs++;		if (rm->peer_ref &&		    !is_null_sha1(rm->old_sha1) &&		    !hashcmp(rm->peer_ref->old_sha1, rm->old_sha1))			continue;		ALLOC_GROW(heads, nr_heads + 1, nr_alloc);		heads[nr_heads++] = rm;	}	if (!nr_heads) {		/*		 * When deepening of a shallow repository is requested,		 * then local and remote refs are likely to still be equal.		 * Just feed them all to the fetch method in that case.		 * This condition shouldn't be met in a non-deepening fetch		 * (see builtin-fetch.c:quickfetch()).		 */		heads = xmalloc(nr_refs * sizeof(*heads));		for (rm = refs; rm; rm = rm->next)			heads[nr_heads++] = rm;	}	rc = transport->fetch(transport, nr_heads, heads);	free(heads);	return rc;}

void add_exclude(const char *string, const char *base,		 int baselen, struct exclude_list *el, int srcpos){	struct exclude *x;	int patternlen;	int flags;	int nowildcardlen;	parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen);	if (flags & EXC_FLAG_MUSTBEDIR) {		char *s;		x = xmalloc(sizeof(*x) + patternlen + 1);		s = (char *)(x+1);		memcpy(s, string, patternlen);		s[patternlen] = '/0';		x->pattern = s;	} else {		x = xmalloc(sizeof(*x));		x->pattern = string;	}	x->patternlen = patternlen;	x->nowildcardlen = nowildcardlen;	x->base = base;	x->baselen = baselen;	x->flags = flags;	x->srcpos = srcpos;	ALLOC_GROW(el->excludes, el->nr + 1, el->alloc);	el->excludes[el->nr++] = x;	x->el = el;}

static int read_loose_refs(struct strbuf *path, int name_offset,		struct ref **tail){	DIR *dir = opendir(path->buf);	struct dirent *de;	struct {		char **entries;		int nr, alloc;	} list;	int i, pathlen;	if (!dir)		return -1;	memset (&list, 0, sizeof(list));	while ((de = readdir(dir))) {		if (is_dot_or_dotdot(de->d_name))			continue;		ALLOC_GROW(list.entries, list.nr + 1, list.alloc);		list.entries[list.nr++] = xstrdup(de->d_name);	}	closedir(dir);	/* sort the list */	qsort(list.entries, list.nr, sizeof(char *), str_cmp);	pathlen = path->len;	strbuf_addch(path, '/');	for (i = 0; i < list.nr; i++, strbuf_setlen(path, pathlen + 1)) {		strbuf_addstr(path, list.entries[i]);		if (read_loose_refs(path, name_offset, tail)) {			int fd = open(path->buf, O_RDONLY);			char buffer[40];			struct ref *next;			if (fd < 0)				continue;			next = alloc_ref(path->buf + name_offset);			if (read_in_full(fd, buffer, 40) != 40 ||					get_oid_hex(buffer, &next->old_oid)) {				close(fd);				free(next);				continue;			}			close(fd);			(*tail)->next = next;			*tail = next;		}	}	strbuf_setlen(path, pathlen);	for (i = 0; i < list.nr; i++)		free(list.entries[i]);	free(list.entries);	return 0;}

static int populate_opts_cb(const char *key, const char *value, void *data){	struct replay_opts *opts = data;	int error_flag = 1;	if (!value)		error_flag = 0;	else if (!strcmp(key, "options.no-commit"))		opts->no_commit = git_config_bool_or_int(key, value, &error_flag);	else if (!strcmp(key, "options.edit"))		opts->edit = git_config_bool_or_int(key, value, &error_flag);	else if (!strcmp(key, "options.signoff"))		opts->signoff = git_config_bool_or_int(key, value, &error_flag);	else if (!strcmp(key, "options.record-origin"))		opts->record_origin = git_config_bool_or_int(key, value, &error_flag);	else if (!strcmp(key, "options.allow-ff"))		opts->allow_ff = git_config_bool_or_int(key, value, &error_flag);	else if (!strcmp(key, "options.mainline"))		opts->mainline = git_config_int(key, value);	else if (!strcmp(key, "options.strategy"))		git_config_string(&opts->strategy, key, value);	else if (!strcmp(key, "options.strategy-option")) {		ALLOC_GROW(opts->xopts, opts->xopts_nr + 1, opts->xopts_alloc);		opts->xopts[opts->xopts_nr++] = xstrdup(value);	} else		return error(_("Invalid key: %s"), key);	if (!error_flag)		return error(_("Invalid value for %s: %s"), key, value);	return 0;}

static struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname, int len){	if (cache_name_exists(pathname, len, ignore_case))		return NULL;	ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);	return dir->entries[dir->nr++] = dir_entry_new(pathname, len);}

void strbuf_grow(struct strbuf *sb, size_t extra){	if (sb->len + extra + 1 <= sb->len)		die("you want to use way too much memory");	if (!sb->alloc)		sb->buf = NULL;	ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);}

static void add_to_ref_list(const unsigned char *sha1, const char *name,		struct ref_list *list){	ALLOC_GROW(list->list, list->nr + 1, list->alloc);	hashcpy(list->list[list->nr].sha1, sha1);	list->list[list->nr].name = xstrdup(name);	list->nr++;}

struct string_list_item *string_list_append(struct string_list *list, const char *string){	ALLOC_GROW(list->items, list->nr + 1, list->alloc);	list->items[list->nr].string =		list->strdup_strings ? xstrdup(string) : (char *)string;	list->items[list->nr].util = NULL;	return list->items + list->nr++;}

void set_dirpath(int wd, const char *path){	int old_alloc = wd_alloc;	ALLOC_GROW(wdpaths, wd+1, wd_alloc);	if (old_alloc < wd_alloc)		memset(wdpaths+old_alloc, 0,		       (wd_alloc-old_alloc)*sizeof(const char *));	wdpaths[wd] = strdup(path);}

void add_rewritten(struct rewritten *list, unsigned char *from, unsigned char *to){	struct rewritten_item *item;	ALLOC_GROW(list->items, list->nr + 1, list->alloc);	item = &list->items[list->nr];	hashcpy(item->from, from);	hashcpy(item->to, to);	list->nr++;}

static void add_header(const char *value){	int len = strlen(value);	while (len && value[len - 1] == '/n')		len--;	if (!strncasecmp(value, "to: ", 4)) {		ALLOC_GROW(extra_to, extra_to_nr + 1, extra_to_alloc);		extra_to[extra_to_nr++] = xstrndup(value + 4, len - 4);		return;	}	if (!strncasecmp(value, "cc: ", 4)) {		ALLOC_GROW(extra_cc, extra_cc_nr + 1, extra_cc_alloc);		extra_cc[extra_cc_nr++] = xstrndup(value + 4, len - 4);		return;	}	ALLOC_GROW(extra_hdr, extra_hdr_nr + 1, extra_hdr_alloc);	extra_hdr[extra_hdr_nr++] = xstrndup(value, len);}

static char *args_to_str(const char **argv){	char *buf = NULL;	unsigned long len, space = 0, nr = 0;	for (; *argv; argv++) {		len = strlen(*argv);		ALLOC_GROW(buf, nr + 1 + len, space);		if (nr)			buf[nr++] = ' ';		memcpy(buf + nr, *argv, len);		nr += len;	}	ALLOC_GROW(buf, nr + 1, space);	buf[nr] = '/0';	return buf;}

static struct ref_update *add_update(struct ref_transaction *transaction,				     const char *refname){	struct ref_update *update;	FLEX_ALLOC_STR(update, refname, refname);	ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);	transaction->updates[transaction->nr++] = update;	return update;}

void strbuf_grow(struct strbuf *sb, size_t extra){	int new_buf = !sb->alloc;	if (new_buf)		sb->buf = NULL;	ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);	if (new_buf)		sb->buf[0] = '/0';}

void add_cmdname(struct cmdnames *cmds, const char *name, int len){	struct cmdname *ent;	FLEX_ALLOC_MEM(ent, name, name, len);	ent->len = len;	ALLOC_GROW(cmds->names, cmds->cnt + 1, cmds->alloc);	cmds->names[cmds->cnt++] = ent;}

void strbuf_grow(struct strbuf *sb, size_t extra){	if (unsigned_add_overflows(extra, 1) ||	    unsigned_add_overflows(sb->len, extra + 1))		die("you want to use way too much memory");	if (!sb->alloc)		sb->buf = NULL;	ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);}

int run_hook(const char *index_file, const char *name, ...){	struct child_process hook;	const char **argv = NULL, *env[2];	char index[PATH_MAX];	va_list args;	int ret;	size_t i = 0, alloc = 0;	if (access(perf_path("hooks/%s", name), X_OK) < 0)		return 0;	va_start(args, name);	ALLOC_GROW(argv, i + 1, alloc);	argv[i++] = perf_path("hooks/%s", name);	while (argv[i-1]) {		ALLOC_GROW(argv, i + 1, alloc);		argv[i++] = va_arg(args, const char *);	}	va_end(args);	memset(&hook, 0, sizeof(hook));	hook.argv = argv;	hook.no_stdin = 1;	hook.stdout_to_stderr = 1;	if (index_file) {		snprintf(index, sizeof(index), "PERF_INDEX_FILE=%s", index_file);		env[0] = index;		env[1] = NULL;		hook.env = env;	}	ret = start_command(&hook);	free(argv);	if (ret) {		warning("Could not spawn %s", argv[0]);		return ret;	}	ret = finish_command(&hook);	if (ret == -ERR_RUN_COMMAND_WAITPID_SIGNAL)		warning("%s exited due to uncaught signal", argv[0]);	return ret;}

static int option_parse_x(const struct option *opt,			  const char *arg, int unset){	if (unset)		return 0;	ALLOC_GROW(xopts, xopts_nr + 1, xopts_alloc);	xopts[xopts_nr++] = xstrdup(arg);	return 0;}

void hkl_tests_grow(struct hkl_tests * tests, size_t extra){	if (tests->len + extra <= tests->len){		fprintf(stderr, "you want to use way too much memory");		exit(128);	}	if (!tests->alloc)		tests->tests = NULL;	ALLOC_GROW(tests->tests, tests->len + extra, tests->alloc);}

static void add_cmd_list(struct cmdnames *cmds, struct cmdnames *old){	int i;	ALLOC_GROW(cmds->names, cmds->cnt + old->cnt, cmds->alloc);	for (i = 0; i < old->cnt; i++)		cmds->names[cmds->cnt++] = old->names[i];	FREE_AND_NULL(old->names);	old->cnt = 0;}

static void add_commit_info(struct commit *commit, void *util,		struct commit_info_lifo *lifo){	struct commit_info *info;	ALLOC_GROW(lifo->items, lifo->nr + 1, lifo->alloc);	info = lifo->items + lifo->nr;	info->commit = commit;	info->util = util;	lifo->nr++;}

struct string_list_item *string_list_append_nodup(struct string_list *list,						  char *string){	struct string_list_item *retval;	ALLOC_GROW(list->items, list->nr + 1, list->alloc);	retval = &list->items[list->nr++];	retval->string = string;	retval->util = NULL;	return retval;}

static void fit_variant(struct rerere_dir *rr_dir, int variant){	variant++;	ALLOC_GROW(rr_dir->status, variant, rr_dir->status_alloc);	if (rr_dir->status_nr < variant) {		memset(rr_dir->status + rr_dir->status_nr,		       '/0', variant - rr_dir->status_nr);		rr_dir->status_nr = variant;	}}

struct attr_check_item *attr_check_append(struct attr_check *check,					  const struct git_attr *attr){	struct attr_check_item *item;	ALLOC_GROW(check->items, check->nr + 1, check->alloc);	item = &check->items[check->nr++];	item->attr = attr;	return item;}

static struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname,              int len, struct index_state *index){    if (index_name_exists(index, pathname, len, 0))        return NULL;    ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);    return dir->entries[dir->nr++] = dir_entry_new(pathname, len);}

static int git_format_config(const char *var, const char *value, void *cb){	if (!strcmp(var, "format.headers")) {		if (!value)			die("format.headers without value");		add_header(value);		return 0;	}	if (!strcmp(var, "format.suffix"))		return git_config_string(&fmt_patch_suffix, var, value);	if (!strcmp(var, "format.cc")) {		if (!value)			return config_error_nonbool(var);		ALLOC_GROW(extra_cc, extra_cc_nr + 1, extra_cc_alloc);		extra_cc[extra_cc_nr++] = xstrdup(value);		return 0;	}	if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {		return 0;	}	if (!strcmp(var, "format.numbered")) {		if (value && !strcasecmp(value, "auto")) {			auto_number = 1;			return 0;		}		numbered = git_config_bool(var, value);		auto_number = auto_number && numbered;		return 0;	}	if (!strcmp(var, "format.attach")) {		if (value && *value)			default_attach = xstrdup(value);		else			default_attach = xstrdup(git_version_string);		return 0;	}	if (!strcmp(var, "format.thread")) {		if (value && !strcasecmp(value, "deep")) {			thread = THREAD_DEEP;			return 0;		}		if (value && !strcasecmp(value, "shallow")) {			thread = THREAD_SHALLOW;			return 0;		}		thread = git_config_bool(var, value) && THREAD_SHALLOW;		return 0;	}	if (!strcmp(var, "format.signoff")) {		do_signoff = git_config_bool(var, value);		return 0;	}	return git_log_config(var, value, cb);}

int git_atexit(void (*handler)(void)){	ALLOC_GROW(git_atexit_hdlrs.handlers, git_atexit_hdlrs.nr + 1, git_atexit_hdlrs.alloc);	git_atexit_hdlrs.handlers[git_atexit_hdlrs.nr++] = handler;	if (!git_atexit_installed) {		if (atexit(&git_atexit_dispatch))			return -1;		git_atexit_installed = 1;	}	return 0;}

static void check_vector_add(struct attr_check *c){	vector_lock();	ALLOC_GROW(check_vector.checks,		   check_vector.nr + 1,		   check_vector.alloc);	check_vector.checks[check_vector.nr++] = c;	vector_unlock();}

void add_cmdname(struct cmdnames *cmds, const char *name, size_t len){	struct cmdname *ent = malloc(sizeof(*ent) + len + 1);	ent->len = len;	memcpy(ent->name, name, len);	ent->name[len] = 0;	ALLOC_GROW(cmds->names, cmds->cnt + 1, cmds->alloc);	cmds->names[cmds->cnt++] = ent;}