data 34 archive-tar.c static void do_write_blocked(const void *data, unsigned long size) data 36 archive-tar.c const char *buf = data; data 70 archive-tar.c static void write_blocked(const void *data, unsigned long size) data 72 archive-tar.c do_write_blocked(data, size); data 327 archive-tar.c static int tar_filter_config(const char *var, const char *value, void *data) data 350 archive-tar.c free(ar->data); data 351 archive-tar.c ar->data = xstrdup(value); data 402 archive-tar.c if (!ar->data) data 405 archive-tar.c strbuf_addstr(&cmd, ar->data); data 450 archive-tar.c if (tar_filters[i]->data) data 171 archive-zip.c static void *zlib_deflate_raw(void *data, unsigned long size, data 184 archive-zip.c stream.next_in = data; data 26 archive.h void *data; data 79 base85.c void encode_85(char *buf, const unsigned char *data, int bytes) data 86 base85.c unsigned ch = *data++; data 206 block-sha1/sha1.c void blk_SHA1_Update(blk_SHA_CTX *ctx, const void *data, unsigned long len) data 217 block-sha1/sha1.c memcpy(lenW + (char *)ctx->W, data, left); data 220 block-sha1/sha1.c data = ((const char *)data + left); data 226 block-sha1/sha1.c blk_SHA1_Block(ctx, data); data 227 block-sha1/sha1.c data = ((const char *)data + 64); data 231 block-sha1/sha1.c memcpy(ctx->W, data, len); data 34 builtin/add.c struct update_callback_data *data) data 38 builtin/add.c if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode) data 58 builtin/add.c struct update_callback_data *data = cbdata; data 63 builtin/add.c switch (fix_unmerged_status(p, data)) { data 68 builtin/add.c if (add_file_to_index(&the_index, path, data->flags)) { data 69 builtin/add.c if (!(data->flags & ADD_CACHE_IGNORE_ERRORS)) data 71 builtin/add.c data->add_errors++; data 75 builtin/add.c if (data->flags & ADD_CACHE_IGNORE_REMOVAL) data 77 builtin/add.c if (!(data->flags & ADD_CACHE_PRETEND)) data 79 builtin/add.c if (data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE)) data 89 builtin/add.c struct update_callback_data data; data 92 builtin/add.c memset(&data, 0, sizeof(data)); data 93 builtin/add.c data.flags = flags; data 101 builtin/add.c rev.diffopt.format_callback_data = &data; data 104 builtin/add.c return !!data.add_errors; data 1745 builtin/apply.c static char *inflate_it(const void *data, unsigned long size, data 1754 builtin/apply.c stream.next_in = (unsigned char *)data; data 1795 builtin/apply.c char *data = NULL; data 1850 builtin/apply.c data = xrealloc(data, newsize); data 1851 builtin/apply.c if (decode_85(data + hunk_size, buffer + 1, byte_length)) data 1859 builtin/apply.c frag->patch = inflate_it(data, hunk_size, origlen); data 1863 builtin/apply.c free(data); data 1872 builtin/apply.c free(data); data 685 builtin/blame.c static const char *nth_line_cb(void *data, long lno) data 687 builtin/blame.c return nth_line((struct scoreboard *)data, lno); data 942 builtin/blame.c long start_b, long count_b, void *data) data 944 builtin/blame.c struct blame_chunk_cb_data *d = data; data 1087 builtin/blame.c long start_b, long count_b, void *data) data 1089 builtin/blame.c struct handle_split_cb_data *d = data; data 168 builtin/cat-file.c struct expand_data *data = vdata; data 171 builtin/cat-file.c if (!data->mark_query) data 172 builtin/cat-file.c strbuf_addstr(sb, sha1_to_hex(data->sha1)); data 174 builtin/cat-file.c if (data->mark_query) data 175 builtin/cat-file.c data->info.typep = &data->type; data 177 builtin/cat-file.c strbuf_addstr(sb, typename(data->type)); data 179 builtin/cat-file.c if (data->mark_query) data 180 builtin/cat-file.c data->info.sizep = &data->size; data 182 builtin/cat-file.c strbuf_addf(sb, "%lu", data->size); data 184 builtin/cat-file.c if (data->mark_query) data 185 builtin/cat-file.c data->info.disk_sizep = &data->disk_size; data 187 builtin/cat-file.c strbuf_addf(sb, "%lu", data->disk_size); data 189 builtin/cat-file.c if (data->mark_query) data 190 builtin/cat-file.c data->split_on_whitespace = 1; data 191 builtin/cat-file.c else if (data->rest) data 192 builtin/cat-file.c strbuf_addstr(sb, data->rest); data 194 builtin/cat-file.c if (data->mark_query) data 195 builtin/cat-file.c data->info.delta_base_sha1 = data->delta_base_sha1; data 197 builtin/cat-file.c strbuf_addstr(sb, sha1_to_hex(data->delta_base_sha1)); data 202 builtin/cat-file.c static size_t expand_format(struct strbuf *sb, const char *start, void *data) data 212 builtin/cat-file.c expand_atom(sb, start + 1, end - start - 1, data); data 217 builtin/cat-file.c static void batch_write(struct batch_options *opt, const void *data, int len) data 220 builtin/cat-file.c if (fwrite(data, 1, len, stdout) != len) data 223 builtin/cat-file.c write_or_die(1, data, len); data 226 builtin/cat-file.c static void print_object_or_die(struct batch_options *opt, struct expand_data *data) data 228 builtin/cat-file.c const unsigned char *sha1 = data->sha1; data 230 builtin/cat-file.c assert(data->info.typep); data 232 builtin/cat-file.c if (data->type == OBJ_BLOB) { data 246 builtin/cat-file.c if (type != data->type) data 248 builtin/cat-file.c if (data->info.sizep && size != data->size) data 257 builtin/cat-file.c struct expand_data *data) data 261 builtin/cat-file.c if (sha1_object_info_extended(data->sha1, &data->info, LOOKUP_REPLACE_OBJECT) < 0) { data 262 builtin/cat-file.c printf("%s missing\n", obj_name ? obj_name : sha1_to_hex(data->sha1)); data 267 builtin/cat-file.c strbuf_expand(&buf, opt->format, expand_format, data); data 273 builtin/cat-file.c print_object_or_die(opt, data); data 279 builtin/cat-file.c struct expand_data *data) data 285 builtin/cat-file.c result = get_sha1_with_context(obj_name, flags, data->sha1, &ctx); data 320 builtin/cat-file.c batch_object_write(obj_name, opt, data); data 330 builtin/cat-file.c struct object_cb_data *data = vdata; data 331 builtin/cat-file.c hashcpy(data->expand->sha1, sha1); data 332 builtin/cat-file.c batch_object_write(NULL, data->opt, data->expand); data 337 builtin/cat-file.c void *data) data 339 builtin/cat-file.c sha1_array_append(data, sha1); data 346 builtin/cat-file.c void *data) data 348 builtin/cat-file.c sha1_array_append(data, sha1); data 355 builtin/cat-file.c struct expand_data data; data 367 builtin/cat-file.c memset(&data, 0, sizeof(data)); data 368 builtin/cat-file.c data.mark_query = 1; data 369 builtin/cat-file.c strbuf_expand(&buf, opt->format, expand_format, &data); data 370 builtin/cat-file.c data.mark_query = 0; data 377 builtin/cat-file.c data.info.typep = &data.type; data 387 builtin/cat-file.c cb.expand = &data; data 405 builtin/cat-file.c if (data.split_on_whitespace) { data 416 builtin/cat-file.c data.rest = p; data 419 builtin/cat-file.c batch_one_object(buf.buf, opt, &data); data 733 builtin/clone.c static int write_one_config(const char *key, const char *value, void *data) data 33 builtin/count-objects.c static int count_loose(const unsigned char *sha1, const char *path, void *data) data 48 builtin/count-objects.c static int count_cruft(const char *basename, const char *path, void *data) data 96 builtin/fast-export.c const void *data) data 342 builtin/fast-export.c struct diff_options *options, void *data) data 48 builtin/fmt-merge-msg.c static void init_src_data(struct src_data *data) data 50 builtin/fmt-merge-msg.c data->branch.strdup_strings = 1; data 51 builtin/fmt-merge-msg.c data->tag.strdup_strings = 1; data 52 builtin/fmt-merge-msg.c data->r_branch.strdup_strings = 1; data 53 builtin/fmt-merge-msg.c data->generic.strdup_strings = 1; data 96 builtin/fsck.c static int mark_object(struct object *obj, int type, void *data, struct fsck_options *options) data 98 builtin/fsck.c struct object *parent = data; data 178 builtin/fsck.c static int mark_used(struct object *obj, int type, void *data, struct fsck_options *options) data 275 builtin/grep.c void *data; data 278 builtin/grep.c data = read_sha1_file(sha1, type, size); data 280 builtin/grep.c return data; data 345 builtin/grep.c static void append_path(struct grep_opt *opt, const void *data, size_t len) data 349 builtin/grep.c if (len == 1 && *(const char *)data == '\0') data 351 builtin/grep.c string_list_append(path_list, xstrndup(data, len)); data 436 builtin/grep.c void *data; data 439 builtin/grep.c data = lock_and_read_sha1_file(entry.sha1, &type, &size); data 440 builtin/grep.c if (!data) data 445 builtin/grep.c init_tree_desc(&sub, data, size); data 448 builtin/grep.c free(data); data 465 builtin/grep.c void *data; data 471 builtin/grep.c data = read_object_with_reference(obj->sha1, tree_type, data 475 builtin/grep.c if (!data) data 484 builtin/grep.c init_tree_desc(&tree, data, size); data 488 builtin/grep.c free(data); data 35 builtin/index-pack.c void *data; data 196 builtin/index-pack.c static int mark_link(struct object *obj, int type, void *data, struct fsck_options *options) data 367 builtin/index-pack.c static void set_thread_data(struct thread_local *data) data 370 builtin/index-pack.c pthread_setspecific(key, data); data 384 builtin/index-pack.c if (c->data) { data 385 builtin/index-pack.c free(c->data); data 386 builtin/index-pack.c c->data = NULL; data 394 builtin/index-pack.c struct thread_local *data = get_thread_data(); data 395 builtin/index-pack.c for (b = data->base_cache; data 396 builtin/index-pack.c data->base_cache_used > delta_base_cache_limit && b; data 398 builtin/index-pack.c if (b->data && b != retain) data 412 builtin/index-pack.c if (c->data) data 489 builtin/index-pack.c void *data; data 542 builtin/index-pack.c data = unpack_entry_data(obj->idx.offset, obj->size, obj->type, sha1); data 544 builtin/index-pack.c return data; data 553 builtin/index-pack.c unsigned char *data, *inbuf; data 557 builtin/index-pack.c data = xmallocz(consume ? 64*1024 : obj->size); data 562 builtin/index-pack.c stream.next_out = data; data 584 builtin/index-pack.c if (consume(data, stream.next_out - data, cb_data)) { data 586 builtin/index-pack.c free(data); data 589 builtin/index-pack.c stream.next_out = data; data 602 builtin/index-pack.c free(data); data 603 builtin/index-pack.c data = NULL; data 605 builtin/index-pack.c return data; data 732 builtin/index-pack.c struct compare_data *data = cb_data; data 734 builtin/index-pack.c if (data->buf_size < size) { data 735 builtin/index-pack.c free(data->buf); data 736 builtin/index-pack.c data->buf = xmalloc(size); data 737 builtin/index-pack.c data->buf_size = size; data 741 builtin/index-pack.c ssize_t len = read_istream(data->st, data->buf, size); data 744 builtin/index-pack.c sha1_to_hex(data->entry->idx.sha1)); data 747 builtin/index-pack.c sha1_to_hex(data->entry->idx.sha1)); data 748 builtin/index-pack.c if (memcmp(buf, data->buf, len)) data 750 builtin/index-pack.c sha1_to_hex(data->entry->idx.sha1)); data 759 builtin/index-pack.c struct compare_data data; data 766 builtin/index-pack.c memset(&data, 0, sizeof(data)); data 767 builtin/index-pack.c data.entry = entry; data 768 builtin/index-pack.c data.st = open_istream(entry->idx.sha1, &type, &size, NULL); data 769 builtin/index-pack.c if (!data.st) data 774 builtin/index-pack.c unpack_data(entry, compare_objects, &data); data 775 builtin/index-pack.c close_istream(data.st); data 776 builtin/index-pack.c free(data.buf); data 780 builtin/index-pack.c static void sha1_object(const void *data, struct object_entry *obj_entry, data 787 builtin/index-pack.c assert(data || obj_entry); data 793 builtin/index-pack.c if (collision_test_needed && !data) { data 809 builtin/index-pack.c if (!data) data 810 builtin/index-pack.c data = new_data = get_data_from_pack(obj_entry); data 814 builtin/index-pack.c memcmp(data, has_data, size) != 0) data 830 builtin/index-pack.c void *buf = (void *) data; data 832 builtin/index-pack.c assert(data && "data can only be NULL for large _blobs_"); data 854 builtin/index-pack.c if (detach_commit_buffer(commit, NULL) != data) data 889 builtin/index-pack.c if (!c->data) { data 894 builtin/index-pack.c while (is_delta_type(c->obj->type) && !c->data) { data 900 builtin/index-pack.c c->data = get_data_from_pack(obj); data 911 builtin/index-pack.c c->data = patch_delta( data 916 builtin/index-pack.c if (!c->data) data 923 builtin/index-pack.c return c->data; data 944 builtin/index-pack.c result->data = patch_delta(base_data, base->size, data 947 builtin/index-pack.c if (!result->data) data 949 builtin/index-pack.c hash_sha1_file(result->data, result->size, data 951 builtin/index-pack.c sha1_object(result->data, NULL, result->size, delta_obj->real_type, data 991 builtin/index-pack.c free(base->data); data 1073 builtin/index-pack.c base_obj->data = NULL; data 1078 builtin/index-pack.c static void *threaded_second_pass(void *data) data 1080 builtin/index-pack.c set_thread_data(data); data 1122 builtin/index-pack.c void *data = unpack_raw_entry(obj, &ofs_delta->offset, data 1134 builtin/index-pack.c } else if (!data) { data 1139 builtin/index-pack.c sha1_object(data, NULL, obj->size, obj->type, obj->idx.sha1); data 1140 builtin/index-pack.c free(data); data 1361 builtin/index-pack.c base_obj->data = read_sha1_file(d->sha1, &type, &base_obj->size); data 1362 builtin/index-pack.c if (!base_obj->data) data 1365 builtin/index-pack.c if (check_sha1_signature(d->sha1, base_obj->data, data 1369 builtin/index-pack.c base_obj->data, base_obj->size, type); data 92 builtin/log.c struct line_opt_callback_data *data = option->value; data 97 builtin/log.c data->rev->line_level_traverse = 1; data 98 builtin/log.c string_list_append(&data->args, arg); data 935 builtin/mailinfo.c static void output_header_lines(FILE *fout, const char *hdr, const struct strbuf *data) data 937 builtin/mailinfo.c const char *sp = data->buf; data 693 builtin/merge.c struct diff_options *opt, void *data) data 695 builtin/merge.c int *count = data; data 144 builtin/name-rev.c struct name_ref_data *data = cb_data; data 145 builtin/name-rev.c int can_abbreviate_output = data->tags_only && data->name_only; data 148 builtin/name-rev.c if (data->tags_only && !starts_with(path, "refs/tags/")) data 151 builtin/name-rev.c if (data->ref_filter) { data 152 builtin/name-rev.c switch (subpath_matches(path, data->ref_filter)) { data 261 builtin/name-rev.c static void name_rev_line(char *p, struct name_ref_data *data) data 290 builtin/name-rev.c if (data->name_only) data 307 builtin/name-rev.c struct name_ref_data data = { 0, 0, NULL }; data 309 builtin/name-rev.c OPT_BOOL(0, "name-only", &data.name_only, N_("print only names (no SHA-1)")), data 310 builtin/name-rev.c OPT_BOOL(0, "tags", &data.tags_only, N_("only use tags to name the commits")), data 311 builtin/name-rev.c OPT_STRING(0, "refs", &data.ref_filter, N_("pattern"), data 380 builtin/name-rev.c for_each_ref(name_ref, &data); data 389 builtin/name-rev.c name_rev_line(p, &data); data 400 builtin/name-rev.c always, allow_undefined, data.name_only); data 406 builtin/name-rev.c always, allow_undefined, data.name_only); data 1088 builtin/pack-objects.c void *data; data 1117 builtin/pack-objects.c data = read_sha1_file(sha1, &type, &size); data 1118 builtin/pack-objects.c if (!data) data 1121 builtin/pack-objects.c free(data); data 1144 builtin/pack-objects.c nent->tree_data = data; data 1272 builtin/pack-objects.c void *data; data 1279 builtin/pack-objects.c data = read_object_with_reference(sha1, tree_type, &size, tree_sha1); data 1280 builtin/pack-objects.c if (!data) data 1285 builtin/pack-objects.c free(data); data 1295 builtin/pack-objects.c it->pcache.tree_data = data; data 1527 builtin/pack-objects.c void *data; data 1627 builtin/pack-objects.c if (!trg->data) { data 1629 builtin/pack-objects.c trg->data = read_sha1_file(trg_entry->idx.sha1, &type, &sz); data 1631 builtin/pack-objects.c if (!trg->data) data 1639 builtin/pack-objects.c if (!src->data) { data 1641 builtin/pack-objects.c src->data = read_sha1_file(src_entry->idx.sha1, &type, &sz); data 1643 builtin/pack-objects.c if (!src->data) { data 1666 builtin/pack-objects.c src->index = create_delta_index(src->data, src_size); data 1676 builtin/pack-objects.c delta_buf = create_delta(src->index, trg->data, trg_size, &delta_size, max_size); data 1734 builtin/pack-objects.c if (n->data) { data 1736 builtin/pack-objects.c free(n->data); data 1737 builtin/pack-objects.c n->data = NULL; data 1874 builtin/pack-objects.c free(array[i].data); data 2278 builtin/pack-objects.c static void show_commit(struct commit *commit, void *data) data 2289 builtin/pack-objects.c void *data) data 2485 builtin/pack-objects.c void *data) data 2490 builtin/pack-objects.c static void record_recent_commit(struct commit *commit, void *data) data 13 builtin/prune-packed.c static int prune_subdir(int nr, const char *path, void *data) data 15 builtin/prune-packed.c int *opts = data; data 23 builtin/prune-packed.c void *data) data 25 builtin/prune-packed.c int *opts = data; data 34 builtin/prune.c void *data) data 62 builtin/prune.c static int prune_cruft(const char *basename, const char *path, void *data) data 71 builtin/prune.c static int prune_subdir(int nr, const char *path, void *data) data 244 builtin/receive-pack.c static void collect_one_alternate_ref(const struct ref *ref, void *data) data 246 builtin/receive-pack.c struct sha1_array *sa = data; data 316 builtin/receive-pack.c char data[128]; data 318 builtin/receive-pack.c ssize_t sz = xread(in, data, sizeof(data)); data 321 builtin/receive-pack.c send_sideband(1, 2, data, sz, use_sideband); data 1175 builtin/receive-pack.c struct iterate_data *data = cb_data; data 1176 builtin/receive-pack.c struct command **cmd_list = &data->cmds; data 1180 builtin/receive-pack.c if (shallow_update && data->si->shallow_ref[cmd->index]) data 1308 builtin/receive-pack.c struct iterate_data data; data 1316 builtin/receive-pack.c data.cmds = commands; data 1317 builtin/receive-pack.c data.si = si; data 1318 builtin/receive-pack.c if (check_everything_connected(iterate_receive_command_list, 0, &data)) data 76 builtin/reflog.c void *data = read_sha1_file(sha1, &type, &size); data 77 builtin/reflog.c if (!data) { data 81 builtin/reflog.c tree->buffer = data; data 41 builtin/replace.c struct show_data *data = cb_data; data 43 builtin/replace.c if (!wildmatch(data->pattern, refname, 0, NULL)) { data 44 builtin/replace.c if (data->format == REPLACE_FORMAT_SHORT) data 46 builtin/replace.c else if (data->format == REPLACE_FORMAT_MEDIUM) data 68 builtin/replace.c struct show_data data; data 72 builtin/replace.c data.pattern = pattern; data 75 builtin/replace.c data.format = REPLACE_FORMAT_SHORT; data 77 builtin/replace.c data.format = REPLACE_FORMAT_MEDIUM; data 79 builtin/replace.c data.format = REPLACE_FORMAT_LONG; data 85 builtin/replace.c for_each_replace_ref(show_reference, (void *)&data); data 344 builtin/replace.c void *data) data 346 builtin/replace.c struct check_mergetag_data *mergetag_data = (struct check_mergetag_data *)data; data 117 builtin/reset.c struct diff_options *opt, void *data) data 120 builtin/reset.c int intent_to_add = *(int *)data; data 52 builtin/rev-list.c static void finish_commit(struct commit *commit, void *data); data 53 builtin/rev-list.c static void show_commit(struct commit *commit, void *data) data 55 builtin/rev-list.c struct rev_list_info *info = data; data 59 builtin/rev-list.c finish_commit(commit, data); data 72 builtin/rev-list.c finish_commit(commit, data); data 168 builtin/rev-list.c finish_commit(commit, data); data 171 builtin/rev-list.c static void finish_commit(struct commit *commit, void *data) data 182 builtin/unpack-objects.c static int check_object(struct object *obj, int type, void *data, struct fsck_options *options) data 226 builtin/unpack-objects.c void *data, unsigned long size); data 290 builtin/unpack-objects.c void *data, unsigned long size) data 300 builtin/unpack-objects.c resolve_delta(info->nr, type, data, size, data 1343 cache.h void *data); data 1346 cache.h void *data); data 1349 cache.h void *data); data 1354 cache.h void *data); data 1359 cache.h void *data); data 1370 cache.h void *data); data 1433 cache.h const char *buf, size_t len, void *data); data 1435 cache.h extern int git_config_from_parameters(config_fn_t fn, void *data); data 1471 cache.h extern int git_config_parse_parameter(const char *, config_fn_t fn, void *data); data 1476 cache.h void *data; data 1479 cache.h extern int git_config_include(const char *name, const char *value, void *data); data 1541 cache.h extern void git_config_iter(config_fn_t fn, void *data); data 1610 cache.h void encode_85(char *buf, const unsigned char *data, int bytes); data 43 column.c static void layout(struct column_data *data, int *width) data 48 column.c for (i = 0; i < data->list->nr; i++) data 49 column.c if (*width < data->len[i]) data 50 column.c *width = data->len[i]; data 52 column.c *width += data->opts.padding; data 54 column.c data->cols = (data->opts.width - strlen(data->opts.indent)) / *width; data 55 column.c if (data->cols == 0) data 56 column.c data->cols = 1; data 58 column.c data->rows = DIV_ROUND_UP(data->list->nr, data->cols); data 61 column.c static void compute_column_width(struct column_data *data) data 64 column.c for (x = 0; x < data->cols; x++) { data 65 column.c data->width[x] = XY2LINEAR(data, x, 0); data 66 column.c for (y = 0; y < data->rows; y++) { data 67 column.c i = XY2LINEAR(data, x, y); data 68 column.c if (i < data->list->nr && data 69 column.c data->len[data->width[x]] < data->len[i]) data 70 column.c data->width[x] = i; data 82 column.c static void shrink_columns(struct column_data *data) data 84 column.c REALLOC_ARRAY(data->width, data->cols); data 85 column.c while (data->rows > 1) { data 87 column.c rows = data->rows; data 88 column.c cols = data->cols; data 90 column.c data->rows--; data 91 column.c data->cols = DIV_ROUND_UP(data->list->nr, data->rows); data 92 column.c if (data->cols != cols) data 93 column.c REALLOC_ARRAY(data->width, data->cols); data 94 column.c compute_column_width(data); data 96 column.c total_width = strlen(data->opts.indent); data 97 column.c for (x = 0; x < data->cols; x++) { data 98 column.c total_width += data->len[data->width[x]]; data 99 column.c total_width += data->opts.padding; data 101 column.c if (total_width > data->opts.width) { data 102 column.c data->rows = rows; data 103 column.c data->cols = cols; data 107 column.c compute_column_width(data); data 121 column.c static int display_cell(struct column_data *data, int initial_width, data 126 column.c i = XY2LINEAR(data, x, y); data 127 column.c if (i >= data->list->nr) data 130 column.c len = data->len[i]; data 131 column.c if (data->width && data->len[data->width[x]] < initial_width) { data 137 column.c len += initial_width - data->len[data->width[x]]; data 138 column.c len -= data->opts.padding; data 141 column.c if (COL_LAYOUT(data->colopts) == COL_COLUMN) data 142 column.c newline = i + data->rows >= data->list->nr; data 144 column.c newline = x == data->cols - 1 || i == data->list->nr - 1; data 147 column.c x == 0 ? data->opts.indent : "", data 148 column.c data->list->items[i].string, data 149 column.c newline ? data->opts.nl : empty_cell + len); data 158 column.c struct column_data data; data 162 column.c memset(&data, 0, sizeof(data)); data 163 column.c data.list = list; data 164 column.c data.colopts = colopts; data 165 column.c data.opts = *opts; data 167 column.c data.len = xmalloc(sizeof(*data.len) * list->nr); data 169 column.c data.len[i] = item_length(colopts, list->items[i].string); data 171 column.c layout(&data, &initial_width); data 174 column.c shrink_columns(&data); data 179 column.c for (y = 0; y < data.rows; y++) { data 180 column.c for (x = 0; x < data.cols; x++) data 181 column.c if (display_cell(&data, initial_width, empty_cell, x, y)) data 185 column.c free(data.len); data 186 column.c free(data.width); data 782 commit.c struct commit *commit = queue->array[i].data; data 1300 commit.c void for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data) data 1308 commit.c fn(commit, extra, data); data 352 commit.h extern void for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data); data 243 compat/poll/poll.c char data[64]; data 245 compat/poll/poll.c r = recv (h, data, sizeof (data), MSG_PEEK); data 292 compat/poll/poll.c char data[64]; data 293 compat/poll/poll.c r = recv (fd, data, sizeof (data), MSG_PEEK); data 3786 compat/regex/regcomp.c tree = &dfa->str_tree_storage->data[dfa->str_tree_storage_idx++]; data 501 compat/regex/regex_internal.h bin_tree_t data[BIN_TREE_STORAGE_SIZE]; data 142 config.c int git_config_include(const char *var, const char *value, void *data) data 144 config.c struct config_include_data *inc = data; data 151 config.c ret = inc->fn(var, value, inc->data); data 174 config.c config_fn_t fn, void *data) data 196 config.c if (fn(pair[0]->buf, value, data) < 0) { data 204 config.c int git_config_from_parameters(config_fn_t fn, void *data) data 223 config.c if (git_config_parse_parameter(argv[i], fn, data) < 0) { data 324 config.c static int get_value(config_fn_t fn, void *data, struct strbuf *name) data 357 config.c ret = fn(name->buf, value, data); data 414 config.c static int git_parse_source(config_fn_t fn, void *data) data 470 config.c if (get_value(fn, data, var) < 0) data 1041 config.c static int do_config_from(struct config_source *top, config_fn_t fn, void *data) data 1053 config.c ret = git_parse_source(fn, data); data 1064 config.c const char *name, const char *path, FILE *f, void *data) data 1076 config.c return do_config_from(&top, fn, data); data 1079 config.c static int git_config_from_stdin(config_fn_t fn, void *data) data 1081 config.c return do_config_from_file(fn, "<stdin>", NULL, stdin, data); data 1084 config.c int git_config_from_file(config_fn_t fn, const char *filename, void *data) data 1092 config.c ret = do_config_from_file(fn, filename, filename, f, data); data 1100 config.c size_t len, void *data) data 1114 config.c return do_config_from(&top, fn, data); data 1120 config.c void *data) data 1135 config.c ret = git_config_from_buf(fn, name, buf, size, data); data 1143 config.c void *data) data 1149 config.c return git_config_from_blob_sha1(fn, name, sha1, data); data 1187 config.c int git_config_early(config_fn_t fn, void *data, const char *repo_config) data 1195 config.c data); data 1200 config.c ret += git_config_from_file(fn, xdg_config, data); data 1205 config.c ret += git_config_from_file(fn, user_config, data); data 1210 config.c ret += git_config_from_file(fn, repo_config, data); data 1214 config.c switch (git_config_from_parameters(fn, data)) { data 1230 config.c int git_config_with_options(config_fn_t fn, void *data, data 1240 config.c inc.data = data; data 1242 config.c data = &inc; data 1250 config.c return git_config_from_stdin(fn, data); data 1252 config.c return git_config_from_file(fn, config_source->file, data); data 1254 config.c return git_config_from_blob_ref(fn, config_source->blob, data); data 1257 config.c ret = git_config_early(fn, data, repo_config); data 1263 config.c static void git_config_raw(config_fn_t fn, void *data) data 1265 config.c if (git_config_with_options(fn, data, NULL, 1) < 0) data 1280 config.c static void configset_iter(struct config_set *cs, config_fn_t fn, void *data) data 1292 config.c if (fn(entry->key, values->items[value_index].string, data) < 0) { data 1301 config.c void git_config(config_fn_t fn, void *data) data 1304 config.c configset_iter(&the_config_set, fn, data); data 288 contrib/convert-objects/convert-objects.c void *buffer, *data; data 293 contrib/convert-objects/convert-objects.c data = read_sha1_file(sha1, &type, &size); data 294 contrib/convert-objects/convert-objects.c if (!data) data 298 contrib/convert-objects/convert-objects.c memcpy(buffer, data, size); data 310 contrib/convert-objects/convert-objects.c free(data); data 98 contrib/credential/gnome-keyring/git-credential-gnome-keyring.c gpointer *data = (gpointer *)user_data; data 99 contrib/credential/gnome-keyring/git-credential-gnome-keyring.c int *done = (int *)data[0]; data 100 contrib/credential/gnome-keyring/git-credential-gnome-keyring.c GnomeKeyringResult *r = (GnomeKeyringResult *)data[1]; data 117 contrib/credential/gnome-keyring/git-credential-gnome-keyring.c gpointer data[] = { &done, &result }; data 119 contrib/credential/gnome-keyring/git-credential-gnome-keyring.c gnome_keyring_item_delete(keyring, id, gnome_keyring_done_cb, data, data 203 contrib/credential/gnome-keyring/git-credential-gnome-keyring.c password_data = (GnomeKeyringNetworkPasswordData *)entries->data; data 303 contrib/credential/gnome-keyring/git-credential-gnome-keyring.c password_data = (GnomeKeyringNetworkPasswordData *)entries->data; data 62 contrib/credential/osxkeychain/git-credential-osxkeychain.c write_item("username", attr.data, attr.length); data 157 convert.c void *data; data 160 convert.c data = read_blob_data_from_cache(path, &sz); data 161 convert.c if (!data) data 163 convert.c has_cr = memchr(data, '\r', sz) != NULL; data 164 convert.c free(data); data 320 convert.c static int filter_buffer_or_fd(int in, int out, void *data) data 326 convert.c struct filter_params *params = (struct filter_params *)data; data 406 convert.c async.data = ¶ms; data 38 credential.c void *data) data 40 credential.c struct credential *c = data; data 95 csum-file.c const void *data; data 102 csum-file.c data = buf; data 105 csum-file.c data = f->buffer; data 113 csum-file.c git_SHA1_Update(&f->ctx, data, offset); data 114 csum-file.c flush(f, data, offset); data 42 csum-file.h static inline void sha1write_u8(struct sha1file *f, uint8_t data) data 44 csum-file.h sha1write(f, &data, sizeof(data)); data 47 csum-file.h static inline void sha1write_be32(struct sha1file *f, uint32_t data) data 49 csum-file.h data = htonl(data); data 50 csum-file.h sha1write(f, &data, sizeof(data)); data 92 delta.h const unsigned char *data = *datap; data 96 delta.h cmd = *data++; data 99 delta.h } while (cmd & 0x80 && data < top); data 100 delta.h *datap = data; data 136 diff-delta.c const unsigned char *data, *buffer = buf; data 183 diff-delta.c for (data = buffer + entries * RABIN_WINDOW - RABIN_WINDOW; data 184 diff-delta.c data >= buffer; data 185 diff-delta.c data -= RABIN_WINDOW) { data 188 diff-delta.c val = ((val << 8) | data[i]) ^ T[val >> RABIN_SHIFT]; data 191 diff-delta.c entry[-1].entry.ptr = data + RABIN_WINDOW; data 196 diff-delta.c entry->entry.ptr = data + RABIN_WINDOW; data 324 diff-delta.c const unsigned char *ref_data, *ref_top, *data, *top; data 356 diff-delta.c data = trg_buf; data 361 diff-delta.c for (i = 0; i < RABIN_WINDOW && data < top; i++, data++) { data 362 diff-delta.c out[outpos++] = *data; data 363 diff-delta.c val = ((val << 8) | *data) ^ T[val >> RABIN_SHIFT]; data 369 diff-delta.c while (data < top) { data 372 diff-delta.c val ^= U[data[-RABIN_WINDOW]]; data 373 diff-delta.c val = ((val << 8) | *data) ^ T[val >> RABIN_SHIFT]; data 377 diff-delta.c const unsigned char *src = data; data 400 diff-delta.c out[outpos++] = *data++; data 412 diff-delta.c while (moff && ref_data[moff-1] == data[-1]) { data 416 diff-delta.c data--; data 451 diff-delta.c data += msize; data 459 diff-delta.c val = ((val << 8) | data[j]) data 72 diff-no-index.c s->data = strbuf_detach(&buf, &size); data 352 diff.c static int count_lines(const char *data, int size) data 357 diff.c ch = *data++; data 385 diff.c mf->ptr = one->data; data 643 diff.c int prefix, const char *data, int size) data 652 diff.c endp = memchr(data, '\n', size); data 653 diff.c len = endp ? (endp - data + 1) : size; data 656 diff.c emit_del_line(reset, ecb, data, len); data 659 diff.c emit_add_line(reset, ecb, data, len); data 662 diff.c data += len; data 1533 diff.c static void show_stats(struct diffstat_t *data, struct diff_options *options) data 1537 diff.c int total_files = data->nr, count; data 1543 diff.c if (data->nr == 0) data 1547 diff.c count = options->stat_count ? options->stat_count : data->nr; data 1556 diff.c for (i = 0; (i < count) && (i < data->nr); i++) { data 1557 diff.c struct diffstat_file *file = data->files[i]; data 1675 diff.c struct diffstat_file *file = data->files[i]; data 1752 diff.c for (i = 0; i < data->nr; i++) { data 1753 diff.c struct diffstat_file *file = data->files[i]; data 1777 diff.c static void show_shortstats(struct diffstat_t *data, struct diff_options *options) data 1779 diff.c int i, adds = 0, dels = 0, total_files = data->nr; data 1781 diff.c if (data->nr == 0) data 1784 diff.c for (i = 0; i < data->nr; i++) { data 1785 diff.c int added = data->files[i]->added; data 1786 diff.c int deleted= data->files[i]->deleted; data 1788 diff.c if (data->files[i]->is_unmerged || data 1789 diff.c (!data->files[i]->is_interesting && (added + deleted == 0))) { data 1791 diff.c } else if (!data->files[i]->is_binary) { /* don't count bytes */ data 1800 diff.c static void show_numstat(struct diffstat_t *data, struct diff_options *options) data 1804 diff.c if (data->nr == 0) data 1807 diff.c for (i = 0; i < data->nr; i++) { data 1808 diff.c struct diffstat_file *file = data->files[i]; data 2004 diff.c static void show_dirstat_by_line(struct diffstat_t *data, struct diff_options *options) data 2010 diff.c if (data->nr == 0) data 2020 diff.c for (i = 0; i < data->nr; i++) { data 2021 diff.c struct diffstat_file *file = data->files[i]; data 2096 diff.c struct checkdiff_t *data = priv; data 2097 diff.c int marker_size = data->conflict_marker_size; data 2098 diff.c const char *ws = diff_get_color(data->o->use_color, DIFF_WHITESPACE); data 2099 diff.c const char *reset = diff_get_color(data->o->use_color, DIFF_RESET); data 2100 diff.c const char *set = diff_get_color(data->o->use_color, DIFF_FILE_NEW); data 2104 diff.c assert(data->o); data 2105 diff.c line_prefix = diff_line_prefix(data->o); data 2109 diff.c data->lineno++; data 2111 diff.c data->status |= 1; data 2112 diff.c fprintf(data->o->file, data 2114 diff.c line_prefix, data->filename, data->lineno); data 2116 diff.c bad = ws_check(line + 1, len - 1, data->ws_rule); data 2119 diff.c data->status |= bad; data 2121 diff.c fprintf(data->o->file, "%s%s:%d: %s.\n", data 2122 diff.c line_prefix, data->filename, data->lineno, err); data 2124 diff.c emit_line(data->o, set, reset, line, 1); data 2125 diff.c ws_check_emit(line + 1, len - 1, data->ws_rule, data 2126 diff.c data->o->file, set, reset, ws); data 2128 diff.c data->lineno++; data 2132 diff.c data->lineno = strtol(plus, NULL, 10) - 1; data 2138 diff.c static unsigned char *deflate_it(char *data, data 2152 diff.c stream.next_in = (unsigned char *)data; data 2167 diff.c void *data; data 2193 diff.c data = delta; data 2199 diff.c data = deflated; data 2204 diff.c cp = data; data 2220 diff.c free(data); data 2238 diff.c if (!one->data && DIFF_FILE_VALID(one)) data 2240 diff.c if (one->is_binary == -1 && one->data) data 2241 diff.c one->is_binary = buffer_is_binary(one->data, data 2375 diff.c if (!one->data && !two->data && data 2482 diff.c struct diffstat_file *data; data 2491 diff.c data = diffstat_add(diffstat, name_a, name_b); data 2492 diff.c data->is_interesting = p->status != DIFF_STATUS_UNKNOWN; data 2495 diff.c data->is_unmerged = 1; data 2502 diff.c data->is_binary = 1; data 2504 diff.c data->added = 0; data 2505 diff.c data->deleted = 0; data 2507 diff.c data->added = diff_filespec_size(two); data 2508 diff.c data->deleted = diff_filespec_size(one); data 2515 diff.c data->deleted = count_lines(one->data, one->size); data 2516 diff.c data->added = count_lines(two->data, two->size); data 2548 diff.c struct checkdiff_t data; data 2553 diff.c memset(&data, 0, sizeof(data)); data 2554 diff.c data.filename = name_b ? name_b : name_a; data 2555 diff.c data.lineno = 0; data 2556 diff.c data.o = o; data 2557 diff.c data.ws_rule = whitespace_rule(attr_path); data 2558 diff.c data.conflict_marker_size = ll_merge_marker_size(attr_path); data 2580 diff.c if (xdi_diff_outf(&mf1, &mf2, checkdiff_consume, &data, data 2584 diff.c if (data.ws_rule & WS_BLANK_AT_EOF) { data 2588 diff.c ecbdata.ws_rule = data.ws_rule; data 2597 diff.c data.filename, blank_at_eof, err); data 2598 diff.c data.status = 1; /* report errors */ data 2605 diff.c if (data.status) data 2712 diff.c char *data = xmalloc(100), *dirty = ""; data 2718 diff.c len = snprintf(data, 100, data 2720 diff.c s->data = data; data 2724 diff.c s->data = NULL; data 2725 diff.c free(data); data 2752 diff.c if (s->data) data 2772 diff.c s->data = (char *)""; data 2786 diff.c s->data = strbuf_detach(&sb, NULL); data 2800 diff.c s->data = xmmap(NULL, s->size, PROT_READ, MAP_PRIVATE, fd, 0); data 2807 diff.c if (convert_to_git(s->path, s->data, s->size, &buf, crlf_warn)) { data 2809 diff.c munmap(s->data, s->size); data 2811 diff.c s->data = strbuf_detach(&buf, &size); data 2829 diff.c s->data = read_sha1_file(s->sha1, &type, &s->size); data 2830 diff.c if (!s->data) data 2840 diff.c free(s->data); data 2842 diff.c munmap(s->data, s->size); data 2846 diff.c s->data = NULL; data 2949 diff.c prep_temp_blob(name, temp, one->data, one->size, data 4421 diff.c struct patch_id_t *data = priv; data 4430 diff.c git_SHA1_Update(data->ctx, line, new_len); data 4431 diff.c data->patchlen += new_len; data 4440 diff.c struct patch_id_t data; data 4444 diff.c memset(&data, 0, sizeof(struct patch_id_t)); data 4445 diff.c data.ctx = &ctx; data 4517 diff.c if (xdi_diff_outf(&mf1, &mf2, patch_id_consume, &data, data 4777 diff.c return !memcmp(one->data, two->data, one->size); data 5091 diff.c *outbuf = df->data; data 39 diff.h struct diff_options *options, void *data); data 41 diff.h typedef struct strbuf *(*diff_prefix_fn_t)(struct diff_options *opt, void *data); data 46 diffcore-delta.c struct spanhash data[FLEX_ARRAY]; data 59 diffcore-delta.c memset(new->data, 0, sizeof(struct spanhash) * sz); data 61 diffcore-delta.c struct spanhash *o = &(orig->data[i]); data 67 diffcore-delta.c struct spanhash *h = &(new->data[bucket++]); data 91 diffcore-delta.c h = &(top->data[bucket++]); data 128 diffcore-delta.c unsigned char *buf = one->data; data 136 diffcore-delta.c memset(hash->data, 0, sizeof(struct spanhash) * (1<<i)); data 159 diffcore-delta.c qsort(hash->data, data 161 diffcore-delta.c sizeof(hash->data[0]), data 195 diffcore-delta.c s = src_count->data; data 196 diffcore-delta.c d = dst_count->data; data 22 diffcore-pickaxe.c struct diffgrep_cb *data = priv; data 28 diffcore-pickaxe.c if (data->hit) data 37 diffcore-pickaxe.c data->hit = !regexec(data->regexp, line + 1, 1, ®match, 0); data 74 diffcore-pickaxe.c const char *data; data 77 diffcore-pickaxe.c data = mf->ptr; data 84 diffcore-pickaxe.c assert(data[sz] == '\0'); data 85 diffcore-pickaxe.c while (*data && !regexec(regexp, data, 1, ®match, flags)) { data 87 diffcore-pickaxe.c data += regmatch.rm_eo; data 88 diffcore-pickaxe.c if (*data && regmatch.rm_so == regmatch.rm_eo) data 89 diffcore-pickaxe.c data++; data 96 diffcore-pickaxe.c size_t offset = kwsexec(kws, data, sz, &kwsm); data 100 diffcore-pickaxe.c data += offset + kwsm.size[0]; data 266 diffcore-rename.c hash_sha1_file(filespec->data, filespec->size, "blob", filespec->sha1); data 30 diffcore.h void *data; data 533 dir.c void *data; data 541 dir.c data = read_sha1_file(active_cache[pos]->sha1, &type, &sz); data 542 dir.c if (!data || type != OBJ_BLOB) { data 543 dir.c free(data); data 551 dir.c return data; data 2415 dir.c const unsigned char *data; data 2436 dir.c const unsigned char *next, *data = rd->data, *end = rd->end; data 2442 dir.c next = data; data 2451 dir.c data = next; data 2453 dir.c next = data; data 2458 dir.c data = next; data 2460 dir.c len = strlen((const char *)data); data 2461 dir.c next = data + len + 1; data 2466 dir.c memcpy(untracked->name, data, len + 1); data 2467 dir.c data = next; data 2470 dir.c len = strlen((const char *)data); data 2471 dir.c next = data + len + 1; data 2474 dir.c untracked->untracked[i] = xstrdup((const char*)data); data 2475 dir.c data = next; data 2479 dir.c rd->data = data; data 2500 dir.c if (rd->data + sizeof(struct stat_data) > rd->end) { data 2501 dir.c rd->data = rd->end + 1; data 2504 dir.c stat_data_from_disk(&ud->stat_data, (struct stat_data *)rd->data); data 2505 dir.c rd->data += sizeof(struct stat_data); data 2513 dir.c if (rd->data + 20 > rd->end) { data 2514 dir.c rd->data = rd->end + 1; data 2517 dir.c hashcpy(ud->exclude_sha1, rd->data); data 2518 dir.c rd->data += 20; data 2530 dir.c struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz) data 2535 dir.c const unsigned char *next = data, *end = (const unsigned char *)data + sz; data 2574 dir.c rd.data = next; data 2582 dir.c next = rd.data; data 2598 dir.c rd.data = next + len; data 2601 dir.c next = rd.data; data 308 dir.h struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz); data 149 ewah/bitmap.c void bitmap_each_bit(struct bitmap *self, ewah_callback callback, void *data) data 159 ewah/bitmap.c callback(pos++, data); data 166 ewah/bitmap.c callback(pos + offset, data); data 52 ewah/ewah_io.c void *data) data 64 ewah/ewah_io.c if (write_fun(data, &bitsize, 4) != 4) data 69 ewah/ewah_io.c if (write_fun(data, &word_count, 4) != 4) data 80 ewah/ewah_io.c if (write_fun(data, dump, sizeof(dump)) != sizeof(dump)) data 90 ewah/ewah_io.c if (write_fun(data, dump, words_left * 8) != words_left * 8) data 98 ewah/ewah_io.c if (write_fun(data, &rlw_pos, 4) != 4) data 114 ewah/ewah_io.c static int write_strbuf(void *user_data, const void *data, size_t len) data 117 ewah/ewah_io.c strbuf_add(sb, data, len); data 232 ewah/ewok.h void bitmap_each_bit(struct bitmap *self, ewah_callback callback, void *data); data 199 fast-import.c } data; data 204 fast-import.c struct strbuf data; data 658 fast-import.c s->data.sets[0] = marks; data 664 fast-import.c if (!s->data.sets[i]) { data 665 fast-import.c s->data.sets[i] = pool_calloc(1, sizeof(struct mark_set)); data 666 fast-import.c s->data.sets[i]->shift = s->shift - 10; data 668 fast-import.c s = s->data.sets[i]; data 670 fast-import.c if (!s->data.marked[idnum]) data 672 fast-import.c s->data.marked[idnum] = oe; data 684 fast-import.c s = s->data.sets[i]; data 687 fast-import.c oe = s->data.marked[idnum]; data 1012 fast-import.c strbuf_release(&last_blob.data); data 1061 fast-import.c if (last && last->data.buf && last->depth < max_depth && dat->len > 20) { data 1063 fast-import.c delta = diff_delta(last->data.buf, last->data.len, data 1147 fast-import.c last->data = *dat; data 1149 fast-import.c strbuf_swap(&last->data, dat); data 1452 fast-import.c lo.data = old_tree; data 1786 fast-import.c if (m->data.sets[k]) data 1788 fast-import.c m->data.sets[k]); data 1792 fast-import.c if (m->data.marked[k]) data 1794 fast-import.c sha1_to_hex(m->data.marked[k]->idx.sha1)); data 1948 fast-import.c const char *data; data 1951 fast-import.c if (!skip_prefix(command_buf.buf, "data ", &data)) data 1954 fast-import.c if (skip_prefix(data, "<<", &data)) { data 1955 fast-import.c char *term = xstrdup(data); data 1956 fast-import.c size_t term_len = command_buf.len - (data - command_buf.buf); data 1971 fast-import.c uintmax_t len = strtoumax(data, NULL, 10); data 2075 fast-import.c strbuf_release(&last->data); data 2929 fast-import.c strbuf_attach(&last_blob.data, buf, size, size); data 671 fetch-pack.c static int sideband_demux(int in, int out, void *data) data 673 fetch-pack.c int *xd = data; data 699 fetch-pack.c demux.data = xd; data 298 fsck.c static int fsck_walk_tree(struct tree *tree, void *data, struct fsck_options *options) data 314 fsck.c result = options->walk(&lookup_tree(entry.sha1)->object, OBJ_TREE, data, options); data 316 fsck.c result = options->walk(&lookup_blob(entry.sha1)->object, OBJ_BLOB, data, options); data 329 fsck.c static int fsck_walk_commit(struct commit *commit, void *data, struct fsck_options *options) data 338 fsck.c result = options->walk((struct object *)commit->tree, OBJ_TREE, data, options); data 345 fsck.c result = options->walk((struct object *)parents->item, OBJ_COMMIT, data, options); data 355 fsck.c static int fsck_walk_tag(struct tag *tag, void *data, struct fsck_options *options) data 359 fsck.c return options->walk(tag->tagged, OBJ_ANY, data, options); data 362 fsck.c int fsck_walk(struct object *obj, void *data, struct fsck_options *options) data 370 fsck.c return fsck_walk_tree((struct tree *)obj, data, options); data 372 fsck.c return fsck_walk_commit((struct commit *)obj, data, options); data 374 fsck.c return fsck_walk_tag((struct tag *)obj, data, options); data 530 fsck.c static int verify_headers(const void *data, unsigned long size, data 533 fsck.c const char *buffer = (const char *)data; data 674 fsck.c static int fsck_commit(struct commit *commit, const char *data, data 677 fsck.c const char *buffer = data ? data : get_commit_buffer(commit, &size); data 679 fsck.c if (!data) data 684 fsck.c static int fsck_tag_buffer(struct tag *tag, const char *data, data 693 fsck.c if (data) data 694 fsck.c buffer = data; data 777 fsck.c static int fsck_tag(struct tag *tag, const char *data, data 785 fsck.c return fsck_tag_buffer(tag, data, size, options); data 788 fsck.c int fsck_object(struct object *obj, void *data, unsigned long size, data 799 fsck.c return fsck_commit((struct commit *) obj, (const char *) data, data 802 fsck.c return fsck_tag((struct tag *) obj, (const char *) data, data 23 fsck.h typedef int (*fsck_walk_func)(struct object *obj, int type, void *data, struct fsck_options *options); data 48 fsck.h int fsck_walk(struct object *obj, void *data, struct fsck_options *options); data 50 fsck.h int fsck_object(struct object *obj, void *data, unsigned long size, data 718 git-compat-util.h extern void *xmemdupz(const void *data, size_t len); data 192 graph.c static struct strbuf *diff_output_prefix_callback(struct diff_options *opt, void *data) data 194 graph.c struct git_graph *graph = data; data 811 grep.c static void output_color(struct grep_opt *opt, const void *data, size_t size, data 816 grep.c opt->output(opt, data, size); data 819 grep.c opt->output(opt, data, size); data 1728 grep.c char *data; data 1744 grep.c data = xmalloc(size + 1); data 1745 grep.c if (st.st_size != read_in_full(i, data, size)) { data 1748 grep.c free(data); data 1752 grep.c data[size] = 0; data 1754 grep.c gs->buf = data; data 140 grep.h void (*output)(struct grep_opt *opt, const void *data, size_t size); data 233 hashmap.c unsigned char data[FLEX_ARRAY]; data 240 hashmap.c return e1->data != keydata && data 241 hashmap.c (e1->len != e2->len || memcmp(e1->data, keydata, e1->len)); data 244 hashmap.c const void *memintern(const void *data, size_t len) data 254 hashmap.c hashmap_entry_init(&key, memhash(data, len)); data 256 hashmap.c e = hashmap_get(&map, &key, data); data 262 hashmap.c memcpy(e->data, data, len); data 265 hashmap.c return e->data; data 92 hashmap.h extern const void *memintern(const void *data, size_t len); data 90 http-walker.c struct walker_data *data = walker->data; data 91 http-walker.c struct alt_base *alt = data->alt; data 152 http-walker.c struct walker_data *data = walker->data; data 157 http-walker.c newreq->repo = data->alt; data 184 http-walker.c struct walker_data *cdata = walker->data; data 189 http-walker.c char *data; data 223 http-walker.c data = alt_req->buffer->buf; data 227 http-walker.c while (posn < alt_req->buffer->len && data[posn] != '\n') data 229 http-walker.c if (data[posn] == '\n') { data 233 http-walker.c if (data[i] == '/') { data 247 http-walker.c } else if (!memcmp(data + i, "../", 3)) { data 269 http-walker.c !memcmp(data + i, "../", 3)) { data 280 http-walker.c char *colon = strchr(data + i, ':'); data 281 http-walker.c char *slash = strchr(data + i, '/'); data 282 http-walker.c if (colon && slash && colon < data + posn && data 283 http-walker.c slash < data + posn && colon < slash) { data 291 http-walker.c strbuf_add(&target, data + i, posn - i - 7); data 318 http-walker.c struct walker_data *cdata = walker->data; data 517 http-walker.c struct walker_data *data = walker->data; data 518 http-walker.c struct alt_base *altbase = data->alt; data 525 http-walker.c fetch_alternates(walker, data->alt->base); data 529 http-walker.c data->alt->base); data 534 http-walker.c struct walker_data *data = walker->data; data 535 http-walker.c return http_fetch_ref(data->alt->base, ref); data 540 http-walker.c struct walker_data *data = walker->data; data 543 http-walker.c if (data) { data 544 http-walker.c alt = data->alt; data 553 http-walker.c free(data); data 554 http-walker.c walker->data = NULL; data 561 http-walker.c struct walker_data *data = xmalloc(sizeof(struct walker_data)); data 564 http-walker.c data->alt = xmalloc(sizeof(*data->alt)); data 565 http-walker.c data->alt->base = xstrdup(url); data 566 http-walker.c for (s = data->alt->base + strlen(data->alt->base) - 1; *s == '/'; --s) data 569 http-walker.c data->alt->got_indices = 0; data 570 http-walker.c data->alt->packs = NULL; data 571 http-walker.c data->alt->next = NULL; data 572 http-walker.c data->got_alternates = -1; data 579 http-walker.c walker->data = data; data 179 http.c int curl_result = curl_message->data.result; data 717 http.c void *data; data 724 http.c void add_fill_function(void *data, int (*fill)(void *)) data 728 http.c new->data = data; data 743 http.c if (fill->fill(fill->data)) data 1473 http.c char *url, *data; data 1486 http.c data = buf.buf; data 1488 http.c switch (data[i]) { data 1492 http.c starts_with(data + i, " pack-") && data 1493 http.c starts_with(data + i + 46, ".pack\n")) { data 1494 http.c get_sha1_hex(data + i + 6, sha1); data 1501 http.c while (i < buf.len && data[i] != '\n') data 1638 http.c void *data) data 1644 http.c (struct http_object_request *)data; data 67 http.h void (*callback_func)(void *data); data 101 http.h extern void add_fill_function(void *data, int (*fill)(void *)); data 391 ident.c int git_ident_config(const char *var, const char *value, void *data) data 149 imap-send.c char *data; data 256 imap-send.c strlen((const char *)subj_alt_name->d.ia5->data) == (size_t)subj_alt_name->d.ia5->length && data 257 imap-send.c host_matches(hostname, (const char *)(subj_alt_name->d.ia5->data))) data 537 imap-send.c if (!cmd->cb.data) data 556 imap-send.c free(cb->data); data 559 imap-send.c if (cmd->cb.data) { data 561 imap-send.c n = socket_write(&imap->buf.sock, cmd->cb.data, cmd->cb.dlen); data 562 imap-send.c free(cmd->cb.data); data 569 imap-send.c cmd->cb.data = NULL; data 774 imap-send.c if (cmdp->cb.data) { data 775 imap-send.c n = socket_write(&imap->buf.sock, cmdp->cb.data, cmdp->cb.dlen); data 776 imap-send.c free(cmdp->cb.data); data 777 imap-send.c cmdp->cb.data = NULL; data 804 imap-send.c if (cmdp->cb.cont || cmdp->cb.data) data 823 imap-send.c free(cmdp->cb.data); data 1221 imap-send.c cb.data = strbuf_detach(msg, NULL); data 1300 imap-send.c char *p, *data; data 1306 imap-send.c data = &all_msgs->buf[*ofs]; data 1309 imap-send.c if (len < 5 || !starts_with(data, "From ")) data 1312 imap-send.c p = strchr(data, '\n'); data 1315 imap-send.c len -= p - data; data 1316 imap-send.c *ofs += p - data; data 1317 imap-send.c data = p; data 1320 imap-send.c p = strstr(data, "\nFrom "); data 1322 imap-send.c len = &p[1] - data; data 1324 imap-send.c strbuf_add(msg, data, len); data 316 line-log.c void *data) data 318 line-log.c struct collect_diff_cbdata *d = data; data 519 line-log.c char *data = NULL; data 526 line-log.c data = spec->data; data 528 line-log.c if (data[num] == '\n' || num == spec->size - 1) { data 547 line-log.c static const char *nth_line(void *data, long line) data 549 line-log.c struct nth_line_cb *d = data; data 551 line-log.c assert(d->spec && d->spec->data); data 554 line-log.c return (char *)d->spec->data; data 556 line-log.c return (char *)d->spec->data + d->line_ends[line] + 1; data 838 line-log.c static char *get_nth_line(long line, unsigned long *ends, void *data) data 841 line-log.c return (char *)data; data 843 line-log.c return (char *)data + ends[line] + 1; data 847 line-log.c long line, unsigned long *ends, void *data, data 850 line-log.c char *begin = get_nth_line(line, ends, data); data 851 line-log.c char *end = get_nth_line(line+1, ends, data); data 959 line-log.c print_line(prefix, ' ', t_cur, t_ends, pair->two->data, data 962 line-log.c print_line(prefix, '-', k, p_ends, pair->one->data, data 965 line-log.c print_line(prefix, '+', t_cur, t_ends, pair->two->data, data 970 line-log.c print_line(prefix, ' ', t_cur, t_ends, pair->two->data, data 1020 line-log.c file_target.ptr = pair->two->data; data 1025 line-log.c file_parent.ptr = pair->one->data; data 23 line-range.c void *data, long lines, long begin, long *ret) data 92 line-range.c line = nth_line(data, begin); data 100 line-range.c nline = nth_line(data, begin); data 20 line-range.h typedef const char *(*nth_line_fn_t)(void *data, long lno); data 191 list-objects.c void *data) data 205 list-objects.c show_commit(commit, data); data 216 list-objects.c show_object(obj, NULL, name, data); data 223 list-objects.c NULL, &base, path, data); data 228 list-objects.c NULL, path, data); data 488 log-tree.c void *data) data 490 log-tree.c struct rev_info *opt = (struct rev_info *)data; data 87 notes-cache.c const char *data, size_t size) data 91 notes-cache.c if (write_sha1_file(data, size, "blob", value_sha1) < 0) data 18 notes-cache.h const char *data, size_t size); data 859 notes.c char *data; data 867 notes.c data = read_sha1_file(sha1, &t, &len); data 868 notes.c if (t != OBJ_BLOB || !data || !len) { data 869 notes.c free(data); data 870 notes.c return t != OBJ_BLOB || !data; data 879 notes.c string_list_split(list, data, '\n', -1); data 880 notes.c free(data); data 152 pack-bitmap-write.c const char *last, void *data) data 154 pack-bitmap-write.c struct bitmap *base = data; data 159 pack-bitmap-write.c static void show_commit(struct commit *commit, void *data) data 426 pack-bitmap.c const char *last, void *data) data 428 pack-bitmap.c struct bitmap *base = data; data 442 pack-bitmap.c static void show_commit(struct commit *commit, void *data) data 446 pack-bitmap.c static int add_to_include_set(struct include_data *data, data 452 pack-bitmap.c if (data->seen && bitmap_get(data->seen, bitmap_pos)) data 455 pack-bitmap.c if (bitmap_get(data->base, bitmap_pos)) data 461 pack-bitmap.c bitmap_or_ewah(data->base, lookup_stored_bitmap(st)); data 465 pack-bitmap.c bitmap_set(data->base, bitmap_pos); data 471 pack-bitmap.c struct include_data *data = _data; data 478 pack-bitmap.c if (!add_to_include_set(data, commit->object.sha1, bitmap_pos)) { data 907 pack-bitmap.c const char *last, void *data) data 909 pack-bitmap.c struct bitmap_test_data *tdata = data; data 920 pack-bitmap.c static void test_show_commit(struct commit *commit, void *data) data 922 pack-bitmap.c struct bitmap_test_data *tdata = data; data 31 pack-check.c void *data = use_pack(p, w_curs, offset, &avail); data 34 pack-check.c data_crc = crc32(data_crc, data, avail); data 105 pack-check.c void *data; data 119 pack-check.c data = unpack_entry(p, entries[i].offset, &type, &size); data 120 pack-check.c if (!data) data 124 pack-check.c else if (check_sha1_signature(entries[i].sha1, data, size, typename(type))) data 129 pack-check.c fn(entries[i].sha1, type, size, data, &eaten); data 131 pack-check.c data = NULL; data 135 pack-check.c free(data); data 19 patch-delta.c const unsigned char *data, *top; data 26 patch-delta.c data = delta_buf; data 30 patch-delta.c size = get_delta_hdr_size(&data, top); data 35 patch-delta.c size = get_delta_hdr_size(&data, top); data 39 patch-delta.c while (data < top) { data 40 patch-delta.c cmd = *data++; data 43 patch-delta.c if (cmd & 0x01) cp_off = *data++; data 44 patch-delta.c if (cmd & 0x02) cp_off |= (*data++ << 8); data 45 patch-delta.c if (cmd & 0x04) cp_off |= (*data++ << 16); data 46 patch-delta.c if (cmd & 0x08) cp_off |= ((unsigned) *data++ << 24); data 47 patch-delta.c if (cmd & 0x10) cp_size = *data++; data 48 patch-delta.c if (cmd & 0x20) cp_size |= (*data++ << 8); data 49 patch-delta.c if (cmd & 0x40) cp_size |= (*data++ << 16); data 61 patch-delta.c memcpy(out, data, cmd); data 63 patch-delta.c data += cmd; data 77 patch-delta.c if (data != top || size != 0) { data 74 preload-index.c struct thread_data data[MAX_PARALLEL]; data 86 preload-index.c memset(&data, 0, sizeof(data)); data 88 preload-index.c struct thread_data *p = data+i; data 99 preload-index.c struct thread_data *p = data+i; data 6 prio-queue.c int cmp = queue->compare(queue->array[i].data, queue->array[j].data, data 46 prio-queue.c queue->array[queue->nr].data = thing; data 69 prio-queue.c return queue->array[--queue->nr].data; /* LIFO */ data 71 prio-queue.c result = queue->array[0].data; data 26 prio-queue.h void *data; data 47 reachable.c const char *name, void *data) data 49 reachable.c update_progress(data); data 52 reachable.c static void mark_commit(struct commit *c, void *data) data 54 reachable.c mark_object(&c->object, NULL, NULL, data); data 64 reachable.c struct recent_data *data) data 69 reachable.c if (mtime <= data->timestamp) data 102 reachable.c add_pending_object(data->revs, obj, ""); data 106 reachable.c const char *path, void *data) data 127 reachable.c add_recent_object(sha1, st.st_mtime, data); data 133 reachable.c void *data) data 139 reachable.c add_recent_object(sha1, p->mtime, data); data 146 reachable.c struct recent_data data; data 149 reachable.c data.revs = revs; data 150 reachable.c data.timestamp = timestamp; data 152 reachable.c r = for_each_loose_object(add_recent_loose, &data, data 156 reachable.c return for_each_packed_object(add_recent_packed, &data, data 1369 read-cache.c const char *ext, void *data, unsigned long sz) data 1373 read-cache.c istate->cache_tree = cache_tree_read(data, sz); data 1376 read-cache.c istate->resolve_undo = resolve_undo_read(data, sz); data 1379 read-cache.c if (read_link_extension(istate, data, sz)) data 1383 read-cache.c istate->untracked = read_untracked_extension(data, sz); data 1711 read-cache.c static int ce_write(git_SHA_CTX *context, int fd, void *data, unsigned int len) data 1718 read-cache.c memcpy(write_buffer + buffered, data, partial); data 1728 read-cache.c data = (char *) data + partial; data 2247 read-cache.c void *data; data 2266 read-cache.c data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz); data 2267 read-cache.c if (!data || type != OBJ_BLOB) { data 2268 read-cache.c free(data); data 2273 read-cache.c return data; data 722 refs.c struct ref_entry_cb *data = cb_data; data 726 refs.c if (!starts_with(entry->name, data->base)) data 729 refs.c if (!(data->flags & DO_FOR_EACH_INCLUDE_BROKEN) && data 736 refs.c retval = data->fn(entry->name + data->trim, &entry->u.value.oid, data 737 refs.c entry->flag, data->cb_data); data 865 refs.c struct nonmatching_ref_data *data = vdata; data 867 refs.c if (data->skip && string_list_has_string(data->skip, entry->name)) data 870 refs.c data->conflicting_refname = entry->name; data 989 refs.c struct nonmatching_ref_data data; data 991 refs.c data.skip = skip; data 992 refs.c data.conflicting_refname = NULL; data 995 refs.c if (do_for_each_entry_in_dir(dir, 0, nonmatching_ref_fn, &data)) { data 997 refs.c data.conflicting_refname, refname); data 1799 refs.c int flags, void *data) data 1801 refs.c struct ref_filter *filter = (struct ref_filter *)data; data 1965 refs.c struct warn_if_dangling_data data; data 1967 refs.c data.fp = fp; data 1968 refs.c data.refname = refname; data 1969 refs.c data.refnames = NULL; data 1970 refs.c data.msg_fmt = msg_fmt; data 1971 refs.c for_each_rawref(warn_if_dangling_symref, &data); data 1976 refs.c struct warn_if_dangling_data data; data 1978 refs.c data.fp = fp; data 1979 refs.c data.refname = NULL; data 1980 refs.c data.refnames = refnames; data 1981 refs.c data.msg_fmt = msg_fmt; data 1982 refs.c for_each_rawref(warn_if_dangling_symref, &data); data 2053 refs.c struct ref_entry_cb data; data 2054 refs.c data.base = base; data 2055 refs.c data.trim = trim; data 2056 refs.c data.flags = flags; data 2057 refs.c data.fn = fn; data 2058 refs.c data.cb_data = cb_data; data 2063 refs.c data.flags |= DO_FOR_EACH_INCLUDE_BROKEN; data 2065 refs.c return do_for_each_entry(refs, base, do_one_ref, &data); data 148 remote-curl.c char *data, *start, *mid; data 156 remote-curl.c data = heads->buf; data 158 remote-curl.c mid = data; data 161 remote-curl.c start = &data[i]; data 163 remote-curl.c if (data[i] == '\t') data 164 remote-curl.c mid = &data[i]; data 165 remote-curl.c if (data[i] == '\n') { data 169 remote-curl.c data[i] = 0; data 52 resolve-undo.c struct string_list *resolve_undo_read(const char *data, unsigned long size) data 66 resolve-undo.c len = strlen(data) + 1; data 69 resolve-undo.c lost = string_list_insert(resolve_undo, data); data 74 resolve-undo.c data += len; data 77 resolve-undo.c ui->mode[i] = strtoul(data, &endptr, 8); data 78 resolve-undo.c if (!endptr || endptr == data || *endptr) data 80 resolve-undo.c len = (endptr + 1) - (char*)data; data 84 resolve-undo.c data += len; data 92 resolve-undo.c hashcpy(ui->sha1[i], (const unsigned char *)data); data 94 resolve-undo.c data += 20; data 596 run-command.c static void *run_thread(void *data) data 598 run-command.c struct async *async = data; data 602 run-command.c ret = async->proc(async->proc_in, async->proc_out, async->data); data 727 run-command.c exit(!!async->proc(proc_in, proc_out, async->data)); data 108 run-command.h int (*proc)(int in, int out, void *data); data 109 run-command.h void *data; data 193 send-pack.c static int sideband_demux(int in, int out, void *data) data 195 send-pack.c int *fd = data, ret; data 519 send-pack.c demux.data = fd; data 764 sequencer.c static int populate_opts_cb(const char *key, const char *value, void *data) data 766 sequencer.c struct replay_opts *opts = data; data 244 setup.c struct strbuf data = STRBUF_INIT; data 250 setup.c if (strbuf_read_file(&data, path.buf, 0) <= 0) data 252 setup.c while (data.len && (data.buf[data.len - 1] == '\n' || data 253 setup.c data.buf[data.len - 1] == '\r')) data 254 setup.c data.len--; data 255 setup.c data.buf[data.len] = '\0'; data 257 setup.c if (!is_absolute_path(data.buf)) data 259 setup.c strbuf_addbuf(&path, &data); data 264 setup.c strbuf_release(&data); data 47 sha1-array.c void *data) data 57 sha1-array.c fn(array->sha1[i], data); data 18 sha1-array.h void *data); data 21 sha1-array.h void *data); data 1800 sha1_file.c const unsigned char *data; data 1826 sha1_file.c data = delta_head; data 1829 sha1_file.c get_delta_hdr_size(&data, delta_head+sizeof(delta_head)); data 1832 sha1_file.c return get_delta_hdr_size(&data, delta_head+sizeof(delta_head)); data 2129 sha1_file.c void *data; data 2155 sha1_file.c return (ent->data && ent->p == p && ent->base_offset == base_offset); data 2167 sha1_file.c ent->data = NULL; data 2184 sha1_file.c ret = ent->data; data 2189 sha1_file.c ret = xmemdupz(ent->data, ent->size); data 2197 sha1_file.c if (ent->data) { data 2198 sha1_file.c free(ent->data); data 2199 sha1_file.c ent->data = NULL; data 2242 sha1_file.c ent->data = base; data 2274 sha1_file.c void *data = NULL; data 2293 sha1_file.c data = ent->data; data 2324 sha1_file.c data = NULL; data 2350 sha1_file.c if (data) data 2358 sha1_file.c data = unpack_compressed_entry(p, &w_curs, curpos, size); data 2361 sha1_file.c data = NULL; data 2373 sha1_file.c void *base = data; data 2377 sha1_file.c data = NULL; data 2417 sha1_file.c data = NULL; data 2421 sha1_file.c data = patch_delta(base, base_size, data 2433 sha1_file.c if (!data) data 2447 sha1_file.c return data; data 2787 sha1_file.c void *data; data 2791 sha1_file.c data = cache_or_unpack_entry(e.p, e.offset, size, type, 1); data 2792 sha1_file.c if (!data) { data 2802 sha1_file.c data = read_object(sha1, type, size); data 2804 sha1_file.c return data; data 2862 sha1_file.c void *data; data 2867 sha1_file.c data = read_object(repl, type, size); data 2868 sha1_file.c if (data) data 2869 sha1_file.c return data; data 3479 sha1_file.c void *data) data 3507 sha1_file.c r = obj_cb(sha1, path->buf, data); data 3516 sha1_file.c r = cruft_cb(de->d_name, path->buf, data); data 3524 sha1_file.c r = subdir_cb(subdir_nr, path->buf, data); data 3534 sha1_file.c void *data) data 3543 sha1_file.c subdir_cb, data); data 3556 sha1_file.c void *data) data 3563 sha1_file.c subdir_cb, data); data 3571 sha1_file.c void *data; data 3577 sha1_file.c struct loose_alt_odb_data *data = vdata; data 3584 sha1_file.c data->cb, NULL, NULL, data 3585 sha1_file.c data->data); data 3590 sha1_file.c int for_each_loose_object(each_loose_object_fn cb, void *data, unsigned flags) data 3596 sha1_file.c cb, NULL, NULL, data); data 3604 sha1_file.c alt.data = data; data 3608 sha1_file.c static int for_each_object_in_pack(struct packed_git *p, each_packed_object_fn cb, void *data) data 3620 sha1_file.c r = cb(sha1, p, i, data); data 3627 sha1_file.c int for_each_packed_object(each_packed_object_fn cb, void *data, unsigned flags) data 3641 sha1_file.c r = for_each_object_in_pack(p, cb, data); data 162 shallow.c struct write_shallow_data *data = cb_data; data 166 shallow.c if (data->flags & SEEN_ONLY) { data 169 shallow.c if (data->flags & VERBOSE) data 175 shallow.c data->count++; data 176 shallow.c if (data->use_pack_protocol) data 177 shallow.c packet_buf_write(data->out, "shallow %s", hex); data 179 shallow.c strbuf_addstr(data->out, hex); data 180 shallow.c strbuf_addch(data->out, '\n'); data 189 shallow.c struct write_shallow_data data; data 191 shallow.c data.out = out; data 192 shallow.c data.use_pack_protocol = use_pack_protocol; data 193 shallow.c data.count = 0; data 194 shallow.c data.flags = flags; data 195 shallow.c for_each_commit_graft(write_one_shallow, &data); data 197 shallow.c return data.count; data 201 shallow.c data.count++; data 203 shallow.c return data.count; data 127 sideband.c ssize_t send_sideband(int fd, int band, const char *data, ssize_t sz, int packet_max) data 130 sideband.c const char *p = data; data 8 sideband.h ssize_t send_sideband(int fd, int band, const char *data, ssize_t sz, int packet_max); data 17 split-index.c const unsigned char *data = data_; data 24 split-index.c hashcpy(si->base_sha1, data); data 25 split-index.c data += 20; data 30 split-index.c ret = ewah_read_mmap(si->delete_bitmap, data, sz); data 33 split-index.c data += ret; data 36 split-index.c ret = ewah_read_mmap(si->replace_bitmap, data, sz); data 93 split-index.c static void mark_entry_for_delete(size_t pos, void *data) data 95 split-index.c struct index_state *istate = data; data 103 split-index.c static void replace_entry(size_t pos, void *data) data 105 split-index.c struct index_state *istate = data; data 26 split-index.h const void *data, unsigned long sz); data 165 strbuf.c const void *data, size_t dlen) data 179 strbuf.c memcpy(sb->buf + pos, data, dlen); data 183 strbuf.c void strbuf_insert(struct strbuf *sb, size_t pos, const void *data, size_t len) data 185 strbuf.c strbuf_splice(sb, pos, 0, data, len); data 193 strbuf.c void strbuf_add(struct strbuf *sb, const void *data, size_t len) data 196 strbuf.c memcpy(sb->buf + sb->len, data, len); data 249 submodule-config.c static int parse_config(const char *var, const char *value, void *data) data 251 submodule-config.c struct parse_config_parameter *me = data; data 387 submodule.c void *data) data 390 submodule.c struct string_list *needs_pushing = data; data 513 submodule.c void *data) data 543 submodule.c int flags, void *data) data 545 submodule.c sha1_array_append(data, oid->hash); data 559 submodule.c static void add_sha1_to_argv(const unsigned char sha1[20], void *data) data 561 submodule.c argv_array_push(data, sha1_to_hex(sha1)); data 61 tag.c int parse_tag_buffer(struct tag *item, const void *data, unsigned long size) data 65 tag.c const char *bufptr = data; data 124 tag.c void *data; data 130 tag.c data = read_sha1_file(item->object.sha1, &type, &size); data 131 tag.c if (!data) data 135 tag.c free(data); data 139 tag.c ret = parse_tag_buffer(item, data, size); data 140 tag.c free(data); data 16 tag.h extern int parse_tag_buffer(struct tag *item, const void *data, unsigned long size); data 5 test-dump-split-index.c static void show_bit(size_t pos, void *data) data 4 test-prio-queue.c static int intcmp(const void *va, const void *vb, void *data) data 4 test-sha1-array.c static void print_sha1(const unsigned char sha1[20], void *data) data 166 trace.c const struct strbuf *data) data 173 trace.c strbuf_addbuf(&buf, data); data 224 trace.c void trace_strbuf(struct trace_key *key, const struct strbuf *data) data 226 trace.c trace_strbuf_fl(NULL, 0, key, data); data 34 trace.h extern void trace_strbuf(struct trace_key *key, const struct strbuf *data); data 89 trace.h #define trace_strbuf(key, data) \ data 90 trace.h trace_strbuf_fl(TRACE_CONTEXT, __LINE__, key, data) data 107 trace.h const struct strbuf *data); data 93 transport-helper.c struct helper_data *data; data 94 transport-helper.c data = (struct helper_data *)transport->data; data 95 transport-helper.c transport_take_over(transport, data->helper); data 96 transport-helper.c fclose(data->out); data 97 transport-helper.c free(data); data 104 transport-helper.c struct helper_data *data = transport->data; data 113 transport-helper.c if (data->helper) data 114 transport-helper.c return data->helper; data 121 transport-helper.c argv_array_pushf(&helper->args, "git-remote-%s", data->name); data 132 transport-helper.c die("Unable to find remote helper for '%s'", data->name); data 136 transport-helper.c data->helper = helper; data 137 transport-helper.c data->no_disconnect_req = 0; data 147 transport-helper.c data->out = xfdopen(duped, "r"); data 154 transport-helper.c if (recvline(data, &buf)) data 169 transport-helper.c data->fetch = 1; data 171 transport-helper.c data->option = 1; data 173 transport-helper.c data->push = 1; data 175 transport-helper.c data->import = 1; data 177 transport-helper.c data->bidi_import = 1; data 179 transport-helper.c data->export = 1; data 181 transport-helper.c data->check_connectivity = 1; data 182 transport-helper.c else if (!data->refspecs && skip_prefix(capname, "refspec ", &arg)) { data 188 transport-helper.c data->connect = 1; data 190 transport-helper.c data->signed_tags = 1; data 192 transport-helper.c data->export_marks = xstrdup(arg); data 194 transport-helper.c data->import_marks = xstrdup(arg); data 196 transport-helper.c data->no_private_update = 1; data 205 transport-helper.c data->refspec_nr = refspec_nr; data 206 transport-helper.c data->refspecs = parse_fetch_refspec(refspec_nr, refspecs); data 210 transport-helper.c } else if (data->import || data->bidi_import || data->export) { data 217 transport-helper.c return data->helper; data 222 transport-helper.c struct helper_data *data = transport->data; data 225 transport-helper.c if (data->helper) { data 228 transport-helper.c if (!data->no_disconnect_req) { data 236 transport-helper.c xwrite(data->helper->in, "\n", 1); data 239 transport-helper.c close(data->helper->in); data 240 transport-helper.c close(data->helper->out); data 241 transport-helper.c fclose(data->out); data 242 transport-helper.c res = finish_command(data->helper); data 243 transport-helper.c free(data->helper); data 244 transport-helper.c data->helper = NULL; data 265 transport-helper.c struct helper_data *data = transport->data; data 271 transport-helper.c if (!data->option) data 293 transport-helper.c sendline(data, &buf); data 294 transport-helper.c if (recvline(data, &buf)) data 304 transport-helper.c warning("%s unexpectedly said: '%s'", data->name, buf.buf); data 328 transport-helper.c struct helper_data *data = transport->data; data 329 transport-helper.c free_refspec(data->refspec_nr, data->refspecs); data 330 transport-helper.c data->refspecs = NULL; data 332 transport-helper.c free(transport->data); data 339 transport-helper.c struct helper_data *data = transport->data; data 354 transport-helper.c sendline(data, &buf); data 357 transport-helper.c if (recvline(data, &buf)) data 363 transport-helper.c warning("%s also locked %s", data->name, name); data 367 transport-helper.c else if (data->check_connectivity && data 368 transport-helper.c data->transport_options.check_self_contained_and_connected && data 370 transport-helper.c data->transport_options.self_contained_and_connected = 1; data 374 transport-helper.c warning("%s unexpectedly said: '%s'", data->name, buf.buf); data 383 transport-helper.c struct helper_data *data = transport->data; data 390 transport-helper.c if (data->bidi_import) { data 404 transport-helper.c struct helper_data *data = transport->data; data 415 transport-helper.c argv_array_push(&fastexport->args, data->signed_tags ? data 417 transport-helper.c if (data->export_marks) data 418 transport-helper.c argv_array_pushf(&fastexport->args, "--export-marks=%s.tmp", data->export_marks); data 419 transport-helper.c if (data->import_marks) data 420 transport-helper.c argv_array_pushf(&fastexport->args, "--import-marks=%s", data->import_marks); data 433 transport-helper.c struct helper_data *data = transport->data; data 450 transport-helper.c sendline(data, &buf); data 454 transport-helper.c write_constant(data->helper->in, "\n"); data 487 transport-helper.c if (data->refspecs) data 488 transport-helper.c private = apply_refspecs(data->refspecs, data->refspec_nr, name); data 504 transport-helper.c struct helper_data *data = transport->data; data 536 transport-helper.c if (data->connect) data 541 transport-helper.c sendline(data, &cmdbuf); data 546 transport-helper.c data->no_disconnect_req = 1; data 567 transport-helper.c struct helper_data *data = transport->data; data 573 transport-helper.c exec = data->transport_options.receivepack; data 575 transport-helper.c exec = data->transport_options.uploadpack; data 583 transport-helper.c struct helper_data *data = transport->data; data 587 transport-helper.c if (!data->connect) data 593 transport-helper.c fd[0] = data->helper->out; data 594 transport-helper.c fd[1] = data->helper->in; data 601 transport-helper.c struct helper_data *data = transport->data; data 617 transport-helper.c if (data->check_connectivity && data 618 transport-helper.c data->transport_options.check_self_contained_and_connected) data 624 transport-helper.c if (data->transport_options.update_shallow) data 627 transport-helper.c if (data->fetch) data 630 transport-helper.c if (data->import) data 730 transport-helper.c static int push_update_refs_status(struct helper_data *data, data 741 transport-helper.c if (recvline(data, &buf)) { data 752 transport-helper.c if (flags & TRANSPORT_PUSH_DRY_RUN || !data->refspecs || data->no_private_update) data 756 transport-helper.c private = apply_refspecs(data->refspecs, data->refspec_nr, ref->name); data 786 transport-helper.c struct helper_data *data = transport->data; data 793 transport-helper.c if (!data->push) data 848 transport-helper.c set_common_push_options(transport, data->name, flags); data 851 transport-helper.c sendline(data, &buf); data 854 transport-helper.c return push_update_refs_status(data, remote_refs, flags); data 862 transport-helper.c struct helper_data *data = transport->data; data 866 transport-helper.c if (!data->refspecs) data 869 transport-helper.c set_common_push_options(transport, data->name, flags); data 872 transport-helper.c warning("helper %s does not support 'force'", data->name); data 883 transport-helper.c private = apply_refspecs(data->refspecs, data->refspec_nr, ref->name); data 925 transport-helper.c if (push_update_refs_status(data, remote_refs, flags)) data 928 transport-helper.c if (data->export_marks) { data 929 transport-helper.c strbuf_addf(&buf, "%s.tmp", data->export_marks); data 930 transport-helper.c rename(buf.buf, data->export_marks); data 940 transport-helper.c struct helper_data *data = transport->data; data 953 transport-helper.c if (data->push) data 956 transport-helper.c if (data->export) data 981 transport-helper.c struct helper_data *data = transport->data; data 995 transport-helper.c if (data->push && for_push) data 1002 transport-helper.c if (recvline(data, &buf)) data 1043 transport-helper.c struct helper_data *data = xcalloc(1, sizeof(*data)); data 1044 transport-helper.c data->name = name; data 1051 transport-helper.c transport->data = data; data 1058 transport-helper.c transport->smart_options = &(data->transport_options); data 282 transport.c int flags, void *data) data 284 transport.c struct strbuf *buf = data; data 400 transport.c struct bundle_transport_data *data = transport->data; data 407 transport.c if (data->fd > 0) data 408 transport.c close(data->fd); data 409 transport.c data->fd = read_bundle_header(transport->url, &data->header); data 410 transport.c if (data->fd < 0) data 412 transport.c for (i = 0; i < data->header.references.nr; i++) { data 413 transport.c struct ref_list_entry *e = data->header.references.list + i; data 425 transport.c struct bundle_transport_data *data = transport->data; data 426 transport.c return unbundle(&data->header, data->fd, data 432 transport.c struct bundle_transport_data *data = transport->data; data 433 transport.c if (data->fd > 0) data 434 transport.c close(data->fd); data 435 transport.c free(data); data 485 transport.c struct git_transport_data *data = transport->data; data 487 transport.c if (data->conn) data 490 transport.c data->conn = git_connect(data->fd, transport->url, data 491 transport.c for_push ? data->options.receivepack : data 492 transport.c data->options.uploadpack, data 500 transport.c struct git_transport_data *data = transport->data; data 504 transport.c get_remote_heads(data->fd[0], NULL, 0, &refs, data 506 transport.c &data->extra_have, data 507 transport.c &data->shallow); data 508 transport.c data->got_remote_heads = 1; data 516 transport.c struct git_transport_data *data = transport->data; data 523 transport.c args.uploadpack = data->options.uploadpack; data 524 transport.c args.keep_pack = data->options.keep; data 526 transport.c args.use_thin_pack = data->options.thin; data 527 transport.c args.include_tag = data->options.followtags; data 531 transport.c args.depth = data->options.depth; data 533 transport.c data->options.check_self_contained_and_connected; data 535 transport.c args.update_shallow = data->options.update_shallow; data 537 transport.c if (!data->got_remote_heads) { data 539 transport.c get_remote_heads(data->fd[0], NULL, 0, &refs_tmp, 0, data 540 transport.c NULL, &data->shallow); data 541 transport.c data->got_remote_heads = 1; data 544 transport.c refs = fetch_pack(&args, data->fd, data->conn, data 546 transport.c dest, to_fetch, nr_heads, &data->shallow, data 548 transport.c close(data->fd[0]); data 549 transport.c close(data->fd[1]); data 550 transport.c if (finish_connect(data->conn)) { data 554 transport.c data->conn = NULL; data 555 transport.c data->got_remote_heads = 0; data 556 transport.c data->options.self_contained_and_connected = data 807 transport.c struct git_transport_data *data = transport->data; data 811 transport.c if (!data->got_remote_heads) { data 815 transport.c get_remote_heads(data->fd[0], NULL, 0, &tmp_refs, REF_NORMAL, data 816 transport.c NULL, &data->shallow); data 817 transport.c data->got_remote_heads = 1; data 823 transport.c args.use_thin_pack = data->options.thin; data 839 transport.c ret = send_pack(&args, data->fd, data->conn, remote_refs, data 840 transport.c &data->extra_have); data 842 transport.c close(data->fd[1]); data 843 transport.c close(data->fd[0]); data 844 transport.c ret |= finish_connect(data->conn); data 845 transport.c data->conn = NULL; data 846 transport.c data->got_remote_heads = 0; data 854 transport.c struct git_transport_data *data = transport->data; data 855 transport.c data->conn = git_connect(data->fd, transport->url, data 857 transport.c fd[0] = data->fd[0]; data 858 transport.c fd[1] = data->fd[1]; data 864 transport.c struct git_transport_data *data = transport->data; data 865 transport.c if (data->conn) { data 866 transport.c if (data->got_remote_heads) data 867 transport.c packet_flush(data->fd[1]); data 868 transport.c close(data->fd[0]); data 869 transport.c close(data->fd[1]); data 870 transport.c finish_connect(data->conn); data 873 transport.c free(data); data 880 transport.c struct git_transport_data *data; data 886 transport.c data = xcalloc(1, sizeof(*data)); data 887 transport.c data->options = *transport->smart_options; data 888 transport.c data->conn = child; data 889 transport.c data->fd[0] = data->conn->out; data 890 transport.c data->fd[1] = data->conn->in; data 891 transport.c data->got_remote_heads = 0; data 892 transport.c transport->data = data; data 900 transport.c transport->smart_options = &(data->options); data 991 transport.c struct bundle_transport_data *data = xcalloc(1, sizeof(*data)); data 993 transport.c ret->data = data; data 1008 transport.c struct git_transport_data *data = xcalloc(1, sizeof(*data)); data 1009 transport.c ret->data = data; data 1016 transport.c ret->smart_options = &(data->options); data 1018 transport.c data->conn = NULL; data 1019 transport.c data->got_remote_heads = 0; data 1389 transport.c void *data; data 1393 transport.c void *data) data 1400 transport.c struct alternate_refs_data *cb = data; data 1421 transport.c cb->fn(extra, cb->data); data 1428 transport.c void for_each_alternate_ref(alternate_ref_fn fn, void *data) data 1432 transport.c cb.data = data; data 24 transport.h void *data; data 69 tree-walk.h void *data; data 429 unpack-trees.c struct unpack_trees_options *o = info->data; data 438 unpack-trees.c struct unpack_trees_options *o = info->data; data 573 unpack-trees.c struct unpack_trees_options *o = info->data; data 644 unpack-trees.c struct unpack_trees_options *o = info->data; data 699 unpack-trees.c struct unpack_trees_options *o = info->data; data 742 unpack-trees.c struct unpack_trees_options *o = info->data; data 1068 unpack-trees.c info.data = o; data 61 upload-pack.c static ssize_t send_client_data(int fd, const char *data, ssize_t sz) data 64 upload-pack.c return send_sideband(1, fd, data, sz, use_sideband); data 70 upload-pack.c xwrite(fd, data, sz); data 73 upload-pack.c write_or_die(fd, data, sz); data 88 upload-pack.c char data[8193], progress[128]; data 213 upload-pack.c char *cp = data; data 220 upload-pack.c sizeof(data) - outsz); data 231 upload-pack.c buffered = data[sz-1] & 0xFF; data 236 upload-pack.c sz = send_client_data(1, data, sz); data 264 upload-pack.c data[0] = buffered; data 265 upload-pack.c sz = send_client_data(1, data, 1); data 346 utf8.c void strbuf_add_wrapped_bytes(struct strbuf *buf, const char *data, int len, data 349 utf8.c char *tmp = xstrndup(data, len); data 21 utf8.h void strbuf_add_wrapped_bytes(struct strbuf *buf, const char *data, int len, data 237 vcs-svn/fast_export.c void fast_export_buf_to_data(const struct strbuf *data) data 239 vcs-svn/fast_export.c printf("data %"PRIuMAX"\n", (uintmax_t)data->len); data 240 vcs-svn/fast_export.c fwrite(data->buf, data->len, 1, stdout); data 20 vcs-svn/fast_export.h void fast_export_buf_to_data(const struct strbuf *data); data 32 vcs-svn/repo_tree.c static struct strbuf data = STRBUF_INIT; data 34 vcs-svn/repo_tree.c strbuf_reset(&data); data 35 vcs-svn/repo_tree.c err = fast_export_ls_rev(revision, src, &mode, &data); data 42 vcs-svn/repo_tree.c fast_export_modify(dst, mode, data.buf); data 51 vcs-svn/svndiff.c struct strbuf data; data 60 vcs-svn/svndiff.c strbuf_release(&ctx->data); data 198 vcs-svn/svndiff.c pos + nbytes > ctx->data.len) data 200 vcs-svn/svndiff.c strbuf_add(&ctx->out, ctx->data.buf + pos, nbytes); data 254 vcs-svn/svndiff.c if (data_pos != ctx->data.len) data 274 vcs-svn/svndiff.c read_chunk(delta, delta_len, &ctx.data, data_len)) data 7 walker.h void *data; data 121 wrapper.c void *xmemdupz(const void *data, size_t len) data 123 wrapper.c return memcpy(xmallocz(len), data, len); data 410 wt-status.c void *data) data 412 wt-status.c struct wt_status *s = data; data 460 wt-status.c void *data) data 462 wt-status.c struct wt_status *s = data; data 102 xdiff/xutils.c void *data; data 119 xdiff/xutils.c data = (char *) ancur + sizeof(chanode_t) + ancur->icurr; data 122 xdiff/xutils.c return data; data 127 xdiff/xutils.c char const *data, *cur, *top; data 129 xdiff/xutils.c if ((cur = data = xdl_mmfile_first(mf, &size)) != NULL) { data 130 xdiff/xutils.c for (top = data + size; nl < sample && cur < top; ) { data 137 xdiff/xutils.c tsize += (long) (cur - data); data 227 xdiff/xutils.c static unsigned long xdl_hash_record_with_whitespace(char const **data, data 230 xdiff/xutils.c char const *ptr = *data; data 260 xdiff/xutils.c *data = ptr < top ? ptr + 1: ptr; data 304 xdiff/xutils.c unsigned long xdl_hash_record(char const **data, char const *top, long flags) data 308 xdiff/xutils.c char const *ptr = *data; data 312 xdiff/xutils.c return xdl_hash_record_with_whitespace(data, top, flags); data 362 xdiff/xutils.c *data = ptr; data 369 xdiff/xutils.c unsigned long xdl_hash_record(char const **data, char const *top, long flags) { data 371 xdiff/xutils.c char const *ptr = *data; data 374 xdiff/xutils.c return xdl_hash_record_with_whitespace(data, top, flags); data 380 xdiff/xutils.c *data = ptr < top ? ptr + 1: ptr; data 37 xdiff/xutils.h unsigned long xdl_hash_record(char const **data, char const *top, long flags);