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 dir_entry *dir_add_ignored(struct dir_struct *dir, const char *pathname, int len) { if (!cache_name_is_other(pathname, len)) return NULL; ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc); return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len); }
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; }