entry              36 bisect.c       static int count_distance(struct commit_list *entry)
entry              40 bisect.c       	while (entry) {
entry              41 bisect.c       		struct commit *commit = entry->item;
entry              50 bisect.c       		entry = p;
entry             118 builtin/add.c  		struct dir_entry *entry = *src++;
entry             119 builtin/add.c  		if (dir_path_match(entry, pathspec, prefix, seen))
entry             120 builtin/add.c  			*dst++ = entry;
entry              41 builtin/describe.c 	struct hashmap_entry entry;
entry             393 builtin/diff.c 		struct object_array_entry *entry = &rev.pending.objects[i];
entry             394 builtin/diff.c 		struct object *obj = entry->item;
entry             395 builtin/diff.c 		const char *name = entry->name;
entry             413 builtin/diff.c 			blob[blobs].mode = entry->mode;
entry             166 builtin/fsck.c 		struct object_array_entry *entry;
entry             169 builtin/fsck.c 		entry = pending.objects + --pending.nr;
entry             170 builtin/fsck.c 		obj = entry->item;
entry             390 builtin/fsck.c 	struct sha1_entry *entry[MAX_SHA1_ENTRIES];
entry             405 builtin/fsck.c 		qsort(sha1_list.entry, nr,
entry             408 builtin/fsck.c 		struct sha1_entry *entry = sha1_list.entry[i];
entry             409 builtin/fsck.c 		unsigned char *sha1 = entry->sha1;
entry             411 builtin/fsck.c 		sha1_list.entry[i] = NULL;
entry             414 builtin/fsck.c 		free(entry);
entry             421 builtin/fsck.c 	struct sha1_entry *entry = xmalloc(sizeof(*entry));
entry             424 builtin/fsck.c 	entry->ino = ino;
entry             425 builtin/fsck.c 	hashcpy(entry->sha1, sha1);
entry             431 builtin/fsck.c 	sha1_list.entry[nr] = entry;
entry             413 builtin/grep.c 	struct name_entry entry;
entry             416 builtin/grep.c 	while (tree_entry(tree, &entry)) {
entry             417 builtin/grep.c 		int te_len = tree_entry_len(&entry);
entry             420 builtin/grep.c 			match = tree_entry_interesting(&entry, base, tn_len, pathspec);
entry             427 builtin/grep.c 		strbuf_add(base, entry.path, te_len);
entry             429 builtin/grep.c 		if (S_ISREG(entry.mode)) {
entry             430 builtin/grep.c 			hit |= grep_sha1(opt, entry.sha1, base->buf, tn_len,
entry             433 builtin/grep.c 		else if (S_ISDIR(entry.mode)) {
entry             439 builtin/grep.c 			data = lock_and_read_sha1_file(entry.sha1, &type, &size);
entry             442 builtin/grep.c 				    sha1_to_hex(entry.sha1));
entry             723 builtin/index-pack.c 	struct object_entry *entry;
entry             744 builtin/index-pack.c 			    sha1_to_hex(data->entry->idx.sha1));
entry             747 builtin/index-pack.c 			    sha1_to_hex(data->entry->idx.sha1));
entry             750 builtin/index-pack.c 			    sha1_to_hex(data->entry->idx.sha1));
entry             757 builtin/index-pack.c static int check_collison(struct object_entry *entry)
entry             763 builtin/index-pack.c 	if (entry->size <= big_file_threshold || entry->type != OBJ_BLOB)
entry             767 builtin/index-pack.c 	data.entry = entry;
entry             768 builtin/index-pack.c 	data.st = open_istream(entry->idx.sha1, &type, &size, NULL);
entry             771 builtin/index-pack.c 	if (size != entry->size || type != entry->type)
entry             773 builtin/index-pack.c 		    sha1_to_hex(entry->idx.sha1));
entry             774 builtin/index-pack.c 	unpack_data(entry, compare_objects, &data);
entry              22 builtin/merge-tree.c static void add_merge_entry(struct merge_list *entry)
entry              24 builtin/merge-tree.c 	*merge_result_end = entry;
entry              25 builtin/merge-tree.c 	merge_result_end = &entry->next;
entry              30 builtin/merge-tree.c static const char *explanation(struct merge_list *entry)
entry              32 builtin/merge-tree.c 	switch (entry->stage) {
entry              38 builtin/merge-tree.c 		if (entry->link)
entry              44 builtin/merge-tree.c 	entry = entry->link;
entry              45 builtin/merge-tree.c 	if (!entry)
entry              48 builtin/merge-tree.c 	if (entry->link)
entry              51 builtin/merge-tree.c 	if (entry->stage == 3)
entry              56 builtin/merge-tree.c static void *result(struct merge_list *entry, unsigned long *size)
entry              60 builtin/merge-tree.c 	const char *path = entry->path;
entry              62 builtin/merge-tree.c 	if (!entry->stage)
entry              63 builtin/merge-tree.c 		return read_sha1_file(entry->blob->object.sha1, &type, size);
entry              65 builtin/merge-tree.c 	if (entry->stage == 1) {
entry              66 builtin/merge-tree.c 		base = entry->blob;
entry              67 builtin/merge-tree.c 		entry = entry->link;
entry              70 builtin/merge-tree.c 	if (entry && entry->stage == 2) {
entry              71 builtin/merge-tree.c 		our = entry->blob;
entry              72 builtin/merge-tree.c 		entry = entry->link;
entry              75 builtin/merge-tree.c 	if (entry)
entry              76 builtin/merge-tree.c 		their = entry->blob;
entry              80 builtin/merge-tree.c static void *origin(struct merge_list *entry, unsigned long *size)
entry              83 builtin/merge-tree.c 	while (entry) {
entry              84 builtin/merge-tree.c 		if (entry->stage == 2)
entry              85 builtin/merge-tree.c 			return read_sha1_file(entry->blob->object.sha1, &type, size);
entry              86 builtin/merge-tree.c 		entry = entry->link;
entry              99 builtin/merge-tree.c static void show_diff(struct merge_list *entry)
entry             113 builtin/merge-tree.c 	src.ptr = origin(entry, &size);
entry             117 builtin/merge-tree.c 	dst.ptr = result(entry, &size);
entry             127 builtin/merge-tree.c static void show_result_list(struct merge_list *entry)
entry             129 builtin/merge-tree.c 	printf("%s\n", explanation(entry));
entry             131 builtin/merge-tree.c 		struct merge_list *link = entry->link;
entry             133 builtin/merge-tree.c 		printf("  %-6s %o %s %s\n", desc[entry->stage], entry->mode, sha1_to_hex(entry->blob->object.sha1), entry->path);
entry             134 builtin/merge-tree.c 		entry = link;
entry             135 builtin/merge-tree.c 	} while (entry);
entry             231 builtin/merge-tree.c static struct merge_list *link_entry(unsigned stage, const struct traverse_info *info, struct name_entry *n, struct merge_list *entry)
entry             237 builtin/merge-tree.c 		return entry;
entry             238 builtin/merge-tree.c 	if (entry)
entry             239 builtin/merge-tree.c 		path = entry->path;
entry             243 builtin/merge-tree.c 	link->link = entry;
entry             249 builtin/merge-tree.c 	struct merge_list *entry = NULL;
entry             269 builtin/merge-tree.c 		entry = link_entry(3, info, n + 2, entry);
entry             271 builtin/merge-tree.c 		entry = link_entry(2, info, n + 1, entry);
entry             273 builtin/merge-tree.c 		entry = link_entry(1, info, n + 0, entry);
entry             275 builtin/merge-tree.c 	add_merge_entry(entry);
entry             307 builtin/merge-tree.c static int threeway_callback(int n, unsigned long mask, unsigned long dirmask, struct name_entry *entry, struct traverse_info *info)
entry             310 builtin/merge-tree.c 	if (same_entry(entry+1, entry+2) || both_empty(entry+1, entry+2)) {
entry             312 builtin/merge-tree.c 		resolve(info, NULL, entry+1);
entry             316 builtin/merge-tree.c 	if (same_entry(entry+0, entry+1)) {
entry             317 builtin/merge-tree.c 		if (entry[2].sha1 && !S_ISDIR(entry[2].mode)) {
entry             319 builtin/merge-tree.c 			resolve(info, entry+1, entry+2);
entry             329 builtin/merge-tree.c 	if (same_entry(entry+0, entry+2) || both_empty(entry+0, entry+2)) {
entry             331 builtin/merge-tree.c 		resolve(info, NULL, entry+1);
entry             335 builtin/merge-tree.c 	unresolved(info, entry);
entry             101 builtin/pack-objects.c static void *get_delta(struct object_entry *entry)
entry             107 builtin/pack-objects.c 	buf = read_sha1_file(entry->idx.sha1, &type, &size);
entry             109 builtin/pack-objects.c 		die("unable to read %s", sha1_to_hex(entry->idx.sha1));
entry             110 builtin/pack-objects.c 	base_buf = read_sha1_file(entry->delta->idx.sha1, &type, &base_size);
entry             112 builtin/pack-objects.c 		die("unable to read %s", sha1_to_hex(entry->delta->idx.sha1));
entry             115 builtin/pack-objects.c 	if (!delta_buf || delta_size != entry->delta_size)
entry             236 builtin/pack-objects.c static unsigned long write_no_reuse_object(struct sha1file *f, struct object_entry *entry,
entry             247 builtin/pack-objects.c 		if (entry->type == OBJ_BLOB &&
entry             248 builtin/pack-objects.c 		    entry->size > big_file_threshold &&
entry             249 builtin/pack-objects.c 		    (st = open_istream(entry->idx.sha1, &type, &size, NULL)) != NULL)
entry             252 builtin/pack-objects.c 			buf = read_sha1_file(entry->idx.sha1, &type, &size);
entry             254 builtin/pack-objects.c 				die(_("unable to read %s"), sha1_to_hex(entry->idx.sha1));
entry             260 builtin/pack-objects.c 		free(entry->delta_data);
entry             261 builtin/pack-objects.c 		entry->delta_data = NULL;
entry             262 builtin/pack-objects.c 		entry->z_delta_size = 0;
entry             263 builtin/pack-objects.c 	} else if (entry->delta_data) {
entry             264 builtin/pack-objects.c 		size = entry->delta_size;
entry             265 builtin/pack-objects.c 		buf = entry->delta_data;
entry             266 builtin/pack-objects.c 		entry->delta_data = NULL;
entry             267 builtin/pack-objects.c 		type = (allow_ofs_delta && entry->delta->idx.offset) ?
entry             270 builtin/pack-objects.c 		buf = get_delta(entry);
entry             271 builtin/pack-objects.c 		size = entry->delta_size;
entry             272 builtin/pack-objects.c 		type = (allow_ofs_delta && entry->delta->idx.offset) ?
entry             278 builtin/pack-objects.c 	else if (entry->z_delta_size)
entry             279 builtin/pack-objects.c 		datalen = entry->z_delta_size;
entry             295 builtin/pack-objects.c 		off_t ofs = entry->idx.offset - entry->delta->idx.offset;
entry             321 builtin/pack-objects.c 		sha1write(f, entry->delta->idx.sha1, 20);
entry             333 builtin/pack-objects.c 		datalen = write_large_blob_data(st, f, entry->idx.sha1);
entry             344 builtin/pack-objects.c static unsigned long write_reuse_object(struct sha1file *f, struct object_entry *entry,
entry             347 builtin/pack-objects.c 	struct packed_git *p = entry->in_pack;
entry             351 builtin/pack-objects.c 	enum object_type type = entry->type;
entry             356 builtin/pack-objects.c 	if (entry->delta)
entry             357 builtin/pack-objects.c 		type = (allow_ofs_delta && entry->delta->idx.offset) ?
entry             359 builtin/pack-objects.c 	hdrlen = encode_in_pack_object_header(type, entry->size, header);
entry             361 builtin/pack-objects.c 	offset = entry->in_pack_offset;
entry             366 builtin/pack-objects.c 		error("bad packed object CRC for %s", sha1_to_hex(entry->idx.sha1));
entry             368 builtin/pack-objects.c 		return write_no_reuse_object(f, entry, limit, usable_delta);
entry             371 builtin/pack-objects.c 	offset += entry->in_pack_header_size;
entry             372 builtin/pack-objects.c 	datalen -= entry->in_pack_header_size;
entry             375 builtin/pack-objects.c 	    check_pack_inflate(p, &w_curs, offset, datalen, entry->size)) {
entry             376 builtin/pack-objects.c 		error("corrupt packed object for %s", sha1_to_hex(entry->idx.sha1));
entry             378 builtin/pack-objects.c 		return write_no_reuse_object(f, entry, limit, usable_delta);
entry             382 builtin/pack-objects.c 		off_t ofs = entry->idx.offset - entry->delta->idx.offset;
entry             401 builtin/pack-objects.c 		sha1write(f, entry->delta->idx.sha1, 20);
entry             419 builtin/pack-objects.c 				  struct object_entry *entry,
entry             440 builtin/pack-objects.c 	if (!entry->delta)
entry             444 builtin/pack-objects.c 	else if (entry->delta->idx.offset == (off_t)-1)
entry             446 builtin/pack-objects.c 	else if (entry->delta->idx.offset)
entry             453 builtin/pack-objects.c 	else if (!entry->in_pack)
entry             455 builtin/pack-objects.c 	else if (entry->type == OBJ_REF_DELTA || entry->type == OBJ_OFS_DELTA)
entry             459 builtin/pack-objects.c 	else if (entry->type != entry->in_pack_type)
entry             461 builtin/pack-objects.c 	else if (entry->delta)
entry             469 builtin/pack-objects.c 		len = write_no_reuse_object(f, entry, limit, usable_delta);
entry             471 builtin/pack-objects.c 		len = write_reuse_object(f, entry, limit, usable_delta);
entry             479 builtin/pack-objects.c 		entry->idx.crc32 = crc32_end(f);
entry             547 builtin/pack-objects.c 	struct object_entry *entry = packlist_find(&to_pack, oid->hash, NULL);
entry             549 builtin/pack-objects.c 	if (entry)
entry             550 builtin/pack-objects.c 		entry->tagged = 1;
entry             552 builtin/pack-objects.c 		entry = packlist_find(&to_pack, peeled, NULL);
entry             553 builtin/pack-objects.c 		if (entry)
entry             554 builtin/pack-objects.c 			entry->tagged = 1;
entry             924 builtin/pack-objects.c 	struct object_entry *entry;
entry             926 builtin/pack-objects.c 	entry = packlist_find(&to_pack, sha1, index_pos);
entry             927 builtin/pack-objects.c 	if (!entry)
entry             931 builtin/pack-objects.c 		if (!entry->preferred_base)
entry             933 builtin/pack-objects.c 		entry->preferred_base = 1;
entry             992 builtin/pack-objects.c 	struct object_entry *entry;
entry             994 builtin/pack-objects.c 	entry = packlist_alloc(&to_pack, sha1, index_pos);
entry             995 builtin/pack-objects.c 	entry->hash = hash;
entry             997 builtin/pack-objects.c 		entry->type = type;
entry             999 builtin/pack-objects.c 		entry->preferred_base = 1;
entry            1003 builtin/pack-objects.c 		entry->in_pack = found_pack;
entry            1004 builtin/pack-objects.c 		entry->in_pack_offset = found_offset;
entry            1007 builtin/pack-objects.c 	entry->no_try_delta = no_try_delta;
entry            1175 builtin/pack-objects.c 	struct name_entry entry;
entry            1178 builtin/pack-objects.c 	while (tree_entry(tree,&entry)) {
entry            1179 builtin/pack-objects.c 		if (S_ISGITLINK(entry.mode))
entry            1181 builtin/pack-objects.c 		cmp = tree_entry_len(&entry) != cmplen ? 1 :
entry            1182 builtin/pack-objects.c 		      memcmp(name, entry.path, cmplen);
entry            1188 builtin/pack-objects.c 			add_object_entry(entry.sha1,
entry            1189 builtin/pack-objects.c 					 object_type(entry.mode),
entry            1193 builtin/pack-objects.c 		if (S_ISDIR(entry.mode)) {
entry            1199 builtin/pack-objects.c 			tree = pbase_tree_get(entry.sha1);
entry            1326 builtin/pack-objects.c static void check_object(struct object_entry *entry)
entry            1328 builtin/pack-objects.c 	if (entry->in_pack) {
entry            1329 builtin/pack-objects.c 		struct packed_git *p = entry->in_pack;
entry            1338 builtin/pack-objects.c 		buf = use_pack(p, &w_curs, entry->in_pack_offset, &avail);
entry            1345 builtin/pack-objects.c 						   &entry->in_pack_type,
entry            1346 builtin/pack-objects.c 						   &entry->size);
entry            1355 builtin/pack-objects.c 		switch (entry->in_pack_type) {
entry            1358 builtin/pack-objects.c 			entry->type = entry->in_pack_type;
entry            1359 builtin/pack-objects.c 			entry->in_pack_header_size = used;
entry            1360 builtin/pack-objects.c 			if (entry->type < OBJ_COMMIT || entry->type > OBJ_BLOB)
entry            1365 builtin/pack-objects.c 			if (reuse_delta && !entry->preferred_base)
entry            1367 builtin/pack-objects.c 						entry->in_pack_offset + used, NULL);
entry            1368 builtin/pack-objects.c 			entry->in_pack_header_size = used + 20;
entry            1372 builtin/pack-objects.c 				       entry->in_pack_offset + used, NULL);
entry            1380 builtin/pack-objects.c 					      sha1_to_hex(entry->idx.sha1));
entry            1386 builtin/pack-objects.c 			ofs = entry->in_pack_offset - ofs;
entry            1387 builtin/pack-objects.c 			if (ofs <= 0 || ofs >= entry->in_pack_offset) {
entry            1389 builtin/pack-objects.c 				      sha1_to_hex(entry->idx.sha1));
entry            1392 builtin/pack-objects.c 			if (reuse_delta && !entry->preferred_base) {
entry            1399 builtin/pack-objects.c 			entry->in_pack_header_size = used + used_0;
entry            1414 builtin/pack-objects.c 			entry->type = entry->in_pack_type;
entry            1415 builtin/pack-objects.c 			entry->delta = base_entry;
entry            1416 builtin/pack-objects.c 			entry->delta_size = entry->size;
entry            1417 builtin/pack-objects.c 			entry->delta_sibling = base_entry->delta_child;
entry            1418 builtin/pack-objects.c 			base_entry->delta_child = entry;
entry            1423 builtin/pack-objects.c 		if (entry->type) {
entry            1429 builtin/pack-objects.c 			entry->size = get_size_from_delta(p, &w_curs,
entry            1430 builtin/pack-objects.c 					entry->in_pack_offset + entry->in_pack_header_size);
entry            1431 builtin/pack-objects.c 			if (entry->size == 0)
entry            1446 builtin/pack-objects.c 	entry->type = sha1_object_info(entry->idx.sha1, &entry->size);
entry            1483 builtin/pack-objects.c 		struct object_entry *entry = sorted_by_offset[i];
entry            1484 builtin/pack-objects.c 		check_object(entry);
entry            1485 builtin/pack-objects.c 		if (big_file_threshold < entry->size)
entry            1486 builtin/pack-objects.c 			entry->no_try_delta = 1;
entry            1526 builtin/pack-objects.c 	struct object_entry *entry;
entry            1576 builtin/pack-objects.c 	struct object_entry *trg_entry = trg->entry;
entry            1577 builtin/pack-objects.c 	struct object_entry *src_entry = src->entry;
entry            1735 builtin/pack-objects.c 		freed_mem += n->entry->size;
entry            1739 builtin/pack-objects.c 	n->entry = NULL;
entry            1754 builtin/pack-objects.c 		struct object_entry *entry;
entry            1763 builtin/pack-objects.c 		entry = *list++;
entry            1765 builtin/pack-objects.c 		if (!entry->preferred_base) {
entry            1772 builtin/pack-objects.c 		n->entry = entry;
entry            1785 builtin/pack-objects.c 		if (entry->preferred_base)
entry            1794 builtin/pack-objects.c 		if (entry->delta_child) {
entry            1795 builtin/pack-objects.c 			max_depth -= check_delta_limit(entry, 0);
entry            1808 builtin/pack-objects.c 			if (!m->entry)
entry            1831 builtin/pack-objects.c 		if (entry->delta_data && !pack_to_stdout) {
entry            1832 builtin/pack-objects.c 			entry->z_delta_size = do_compress(&entry->delta_data,
entry            1833 builtin/pack-objects.c 							  entry->delta_size);
entry            1835 builtin/pack-objects.c 			delta_cache_size -= entry->delta_size;
entry            1836 builtin/pack-objects.c 			delta_cache_size += entry->z_delta_size;
entry            1844 builtin/pack-objects.c 		if (entry->delta && max_depth <= n->depth)
entry            1852 builtin/pack-objects.c 		if (entry->delta) {
entry            2136 builtin/pack-objects.c 		struct object_entry *entry = to_pack.objects + i;
entry            2138 builtin/pack-objects.c 		if (entry->delta)
entry            2144 builtin/pack-objects.c 		if (entry->size < 50)
entry            2147 builtin/pack-objects.c 		if (entry->no_try_delta)
entry            2150 builtin/pack-objects.c 		if (!entry->preferred_base) {
entry            2152 builtin/pack-objects.c 			if (entry->type < 0)
entry            2154 builtin/pack-objects.c 				    sha1_to_hex(entry->idx.sha1));
entry            2156 builtin/pack-objects.c 			if (entry->type < 0) {
entry            2165 builtin/pack-objects.c 		delta_list[n++] = entry;
entry             207 builtin/pack-redundant.c 					   struct pack_list *entry)
entry             210 builtin/pack-redundant.c 	memcpy(p, entry, sizeof(struct pack_list));
entry              61 builtin/reflog.c 	struct name_entry entry;
entry              86 builtin/reflog.c 	while (tree_entry(&desc, &entry)) {
entry              87 builtin/reflog.c 		if (!has_sha1_file(entry.sha1) ||
entry              88 builtin/reflog.c 		    (S_ISDIR(entry.mode) && !tree_is_complete(entry.sha1))) {
entry             231 builtin/reflog.c 		struct commit_list *entry = pending;
entry             233 builtin/reflog.c 		pending = entry->next;
entry             234 builtin/reflog.c 		commit = entry->item;
entry             235 builtin/reflog.c 		free(entry);
entry              26 builtin/rm.c   	} *entry;
entry              84 builtin/rm.c   		const char *name = list.entry[i].name;
entry             131 builtin/rm.c   		const char *name = list.entry[i].name;
entry             312 builtin/rm.c   		ALLOC_GROW(list.entry, list.nr + 1, list.alloc);
entry             313 builtin/rm.c   		list.entry[list.nr].name = xstrdup(ce->name);
entry             314 builtin/rm.c   		list.entry[list.nr].is_submodule = S_ISGITLINK(ce->ce_mode);
entry             315 builtin/rm.c   		if (list.entry[list.nr++].is_submodule &&
entry             369 builtin/rm.c   		const char *path = list.entry[i].name;
entry             391 builtin/rm.c   			const char *path = list.entry[i].name;
entry             392 builtin/rm.c   			if (list.entry[i].is_submodule) {
entry             150 builtin/tag.c  		struct stack_entry *entry = &stack.stack[stack.nr - 1];
entry             151 builtin/tag.c  		struct commit *commit = entry->commit;
entry             152 builtin/tag.c  		struct commit_list *parents = entry->parents;
entry             168 builtin/tag.c  			entry->parents = parents->next;
entry             657 cache-tree.c   	struct name_entry entry;
entry             663 cache-tree.c   	while (tree_entry(&desc, &entry)) {
entry             664 cache-tree.c   		if (!S_ISDIR(entry.mode))
entry             668 cache-tree.c   			struct tree *subtree = lookup_tree(entry.sha1);
entry             671 cache-tree.c   			sub = cache_tree_sub(it, entry.path);
entry             626 compat/regex/regcomp.c 	struct re_state_table_entry *entry = dfa->state_table + i;
entry             627 compat/regex/regcomp.c 	for (j = 0; j < entry->num; ++j)
entry             629 compat/regex/regcomp.c 	    re_dfastate_t *state = entry->array[j];
entry             632 compat/regex/regcomp.c 	re_free (entry->array);
entry            2148 compat/regex/regexec.c       struct re_backref_cache_entry *entry;
entry            2157 compat/regex/regexec.c       entry = mctx->bkref_ents + first_idx;
entry            2167 compat/regex/regexec.c 	  if (entry->node != node)
entry            2169 compat/regex/regexec.c 	  subexp_len = entry->subexp_to - entry->subexp_from;
entry            2212 compat/regex/regexec.c 	  entry = mctx->bkref_ents + enabled_idx;
entry            2214 compat/regex/regexec.c       while (enabled_idx++, entry++->more);
entry            2694 compat/regex/regexec.c       const struct re_backref_cache_entry *entry
entry            2697 compat/regex/regexec.c 	if (entry->node == bkref_node)
entry            2699 compat/regex/regexec.c       while (entry++->more);
entry            1284 config.c       	struct config_set_element *entry;
entry            1289 config.c       		entry = list->items[i].e;
entry            1291 config.c       		values = &entry->value_list;
entry            1292 config.c       		if (fn(entry->key, values->items[value_index].string, data) < 0) {
entry            1294 config.c       			git_die_config_linenr(entry->key, kv_info->filename, kv_info->linenr);
entry            1385 config.c       	struct config_set_element *entry;
entry            1391 config.c       	while ((entry = hashmap_iter_next(&iter))) {
entry            1392 config.c       		free(entry->key);
entry            1393 config.c       		string_list_clear(&entry->value_list, 1);
entry              14 contrib/convert-objects/convert-objects.c static struct entry *convert[MAXOBJECTS];
entry              17 contrib/convert-objects/convert-objects.c static struct entry * convert_entry(unsigned char *sha1);
entry              19 contrib/convert-objects/convert-objects.c static struct entry *insert_new(unsigned char *sha1, int pos)
entry              21 contrib/convert-objects/convert-objects.c 	struct entry *new = xcalloc(1, sizeof(struct entry));
entry              23 contrib/convert-objects/convert-objects.c 	memmove(convert + pos + 1, convert + pos, (nr_convert - pos) * sizeof(struct entry *));
entry              31 contrib/convert-objects/convert-objects.c static struct entry *lookup_entry(unsigned char *sha1)
entry              37 contrib/convert-objects/convert-objects.c 		struct entry *n = convert[next];
entry              52 contrib/convert-objects/convert-objects.c 	struct entry *entry = convert_entry(buffer);
entry              53 contrib/convert-objects/convert-objects.c 	hashcpy(buffer, entry->new_sha1);
entry              59 contrib/convert-objects/convert-objects.c 	struct entry *entry;
entry              63 contrib/convert-objects/convert-objects.c 	entry = convert_entry(sha1);
entry              64 contrib/convert-objects/convert-objects.c 	memcpy(buffer, sha1_to_hex(entry->new_sha1), 40);
entry             284 contrib/convert-objects/convert-objects.c static struct entry * convert_entry(unsigned char *sha1)
entry             286 contrib/convert-objects/convert-objects.c 	struct entry *entry = lookup_entry(sha1);
entry             291 contrib/convert-objects/convert-objects.c 	if (entry->converted)
entry             292 contrib/convert-objects/convert-objects.c 		return entry;
entry             301 contrib/convert-objects/convert-objects.c 		write_sha1_file(buffer, size, blob_type, entry->new_sha1);
entry             303 contrib/convert-objects/convert-objects.c 		convert_tree(buffer, size, entry->new_sha1);
entry             305 contrib/convert-objects/convert-objects.c 		convert_commit(buffer, size, entry->new_sha1);
entry             308 contrib/convert-objects/convert-objects.c 	entry->converted = 1;
entry             311 contrib/convert-objects/convert-objects.c 	return entry;
entry             317 contrib/convert-objects/convert-objects.c 	struct entry *entry;
entry             326 contrib/convert-objects/convert-objects.c 	entry = convert_entry(sha1);
entry             327 contrib/convert-objects/convert-objects.c 	printf("new sha1: %s\n", sha1_to_hex(entry->new_sha1));
entry              16 credential-store.c 	struct credential entry = CREDENTIAL_INIT;
entry              27 credential-store.c 		credential_from_url(&entry, line.buf);
entry              28 credential-store.c 		if (entry.username && entry.password &&
entry              29 credential-store.c 		    credential_match(c, &entry)) {
entry              32 credential-store.c 				match_cb(&entry);
entry              40 credential-store.c 	credential_clear(&entry);
entry             121 diff-delta.c   	struct index_entry entry;
entry             138 diff-delta.c   	struct unpacked_index_entry *entry, **hash;
entry             164 diff-delta.c   		  sizeof(*entry) * entries;
entry             170 diff-delta.c   	entry = mem;
entry             191 diff-delta.c   			entry[-1].entry.ptr = data + RABIN_WINDOW;
entry             196 diff-delta.c   			entry->entry.ptr = data + RABIN_WINDOW;
entry             197 diff-delta.c   			entry->entry.val = val;
entry             198 diff-delta.c   			entry->next = hash[i];
entry             199 diff-delta.c   			hash[i] = entry++;
entry             225 diff-delta.c   		entry = hash[i];
entry             243 diff-delta.c   				struct unpacked_index_entry *keep = entry;
entry             245 diff-delta.c   					entry = entry->next;
entry             248 diff-delta.c   				keep->next = entry->next;
entry             250 diff-delta.c   			entry = entry->next;
entry             251 diff-delta.c   		} while (entry);
entry             285 diff-delta.c   		for (entry = hash[i]; entry; entry = entry->next)
entry             286 diff-delta.c   			*packed_entry++ = entry->entry;
entry             371 diff-delta.c   			struct index_entry *entry;
entry             375 diff-delta.c   			for (entry = index->hash[i]; entry < index->hash[i+1]; entry++) {
entry             376 diff-delta.c   				const unsigned char *ref = entry->ptr;
entry             379 diff-delta.c   				if (entry->val != val)
entry             387 diff-delta.c   				if (msize < ref - entry->ptr) {
entry             389 diff-delta.c   					msize = ref - entry->ptr;
entry             390 diff-delta.c   					moff = entry->ptr - ref_data;
entry             256 diffcore-rename.c 	struct hashmap_entry entry;
entry             322 diffcore-rename.c 	struct file_similarity *entry = xmalloc(sizeof(*entry));
entry             324 diffcore-rename.c 	entry->index = index;
entry             325 diffcore-rename.c 	entry->filespec = filespec;
entry             327 diffcore-rename.c 	hashmap_entry_init(entry, hash_filespec(filespec));
entry             328 diffcore-rename.c 	hashmap_add(table, entry);
entry             686 dir.c          	char *buf, *entry;
entry             747 dir.c          	entry = buf;
entry             751 dir.c          			if (entry != buf + i && entry[0] != '#') {
entry             753 dir.c          				trim_trailing_spaces(entry);
entry             754 dir.c          				add_exclude(entry, base, baselen, el, lineno);
entry             757 dir.c          			entry = buf + i + 1;
entry             301 fsck.c         	struct name_entry entry;
entry             308 fsck.c         	while (tree_entry(&desc, &entry)) {
entry             311 fsck.c         		if (S_ISGITLINK(entry.mode))
entry             313 fsck.c         		if (S_ISDIR(entry.mode))
entry             314 fsck.c         			result = options->walk(&lookup_tree(entry.sha1)->object, OBJ_TREE, data, options);
entry             315 fsck.c         		else if (S_ISREG(entry.mode) || S_ISLNK(entry.mode))
entry             316 fsck.c         			result = options->walk(&lookup_blob(entry.sha1)->object, OBJ_BLOB, data, options);
entry             319 fsck.c         					sha1_to_hex(tree->object.sha1), entry.path, entry.mode);
entry             158 hashmap.c      void *hashmap_get_next(const struct hashmap *map, const void *entry)
entry             160 hashmap.c      	struct hashmap_entry *e = ((struct hashmap_entry *) entry)->next;
entry             162 hashmap.c      		if (entry_equals(map, entry, e, NULL))
entry             167 hashmap.c      void hashmap_add(struct hashmap *map, void *entry)
entry             169 hashmap.c      	unsigned int b = bucket(map, entry);
entry             172 hashmap.c      	((struct hashmap_entry *) entry)->next = map->table[b];
entry             173 hashmap.c      	map->table[b] = entry;
entry             200 hashmap.c      void *hashmap_put(struct hashmap *map, void *entry)
entry             202 hashmap.c      	struct hashmap_entry *old = hashmap_remove(map, entry, NULL);
entry             203 hashmap.c      	hashmap_add(map, entry);
entry              34 hashmap.h      typedef int (*hashmap_cmp_fn)(const void *entry, const void *entry_or_key,
entry              57 hashmap.h      static inline void hashmap_entry_init(void *entry, unsigned int hash)
entry              59 hashmap.h      	struct hashmap_entry *e = entry;
entry              65 hashmap.h      extern void *hashmap_get_next(const struct hashmap *map, const void *entry);
entry              66 hashmap.h      extern void hashmap_add(struct hashmap *map, void *entry);
entry              67 hashmap.h      extern void *hashmap_put(struct hashmap *map, void *entry);
entry             496 http-push.c    	struct transfer_request *entry = request_queue_head;
entry             501 http-push.c    		while (entry->next != NULL && entry->next != request)
entry             502 http-push.c    			entry = entry->next;
entry             503 http-push.c    		if (entry->next == request)
entry             504 http-push.c    			entry->next = entry->next->next;
entry            1271 http-push.c    	struct object_list *entry = xmalloc(sizeof(struct object_list));
entry            1272 http-push.c    	entry->item = obj;
entry            1273 http-push.c    	entry->next = *p;
entry            1274 http-push.c    	*p = entry;
entry            1275 http-push.c    	return &entry->next;
entry            1301 http-push.c    	struct name_entry entry;
entry            1320 http-push.c    	while (tree_entry(&desc, &entry))
entry            1321 http-push.c    		switch (object_type(entry.mode)) {
entry            1323 http-push.c    			p = process_tree(lookup_tree(entry.sha1), p, &me, name);
entry            1326 http-push.c    			p = process_blob(lookup_blob(entry.sha1), p, &me, name);
entry            1352 http-push.c    		struct object_array_entry *entry = revs->pending.objects + i;
entry            1353 http-push.c    		struct object *obj = entry->item;
entry            1354 http-push.c    		const char *name = entry->name;
entry             113 http-walker.c  	struct object_request *entry = object_queue_head;
entry             120 http-walker.c  		while (entry->next != NULL && entry->next != obj_req)
entry             121 http-walker.c  			entry = entry->next;
entry             122 http-walker.c  		if (entry->next == obj_req)
entry             123 http-walker.c  			entry->next = entry->next->next;
entry              72 list-objects.c 	struct name_entry entry;
entry             103 list-objects.c 	while (tree_entry(&desc, &entry)) {
entry             105 list-objects.c 			match = tree_entry_interesting(&entry, base, 0,
entry             113 list-objects.c 		if (S_ISDIR(entry.mode))
entry             115 list-objects.c 				     lookup_tree(entry.sha1),
entry             116 list-objects.c 				     show, &me, base, entry.path,
entry             118 list-objects.c 		else if (S_ISGITLINK(entry.mode))
entry             119 list-objects.c 			process_gitlink(revs, entry.sha1,
entry             120 list-objects.c 					show, &me, entry.path,
entry             124 list-objects.c 				     lookup_blob(entry.sha1),
entry             125 list-objects.c 				     show, &me, entry.path,
entry             563 merge-recursive.c static void update_entry(struct stage_data *entry,
entry             568 merge-recursive.c 	entry->processed = 0;
entry             569 merge-recursive.c 	entry->stages[1].mode = o->mode;
entry             570 merge-recursive.c 	entry->stages[2].mode = a->mode;
entry             571 merge-recursive.c 	entry->stages[3].mode = b->mode;
entry             572 merge-recursive.c 	hashcpy(entry->stages[1].sha, o->sha1);
entry             573 merge-recursive.c 	hashcpy(entry->stages[2].sha, a->sha1);
entry             574 merge-recursive.c 	hashcpy(entry->stages[3].sha, b->sha1);
entry            1105 merge-recursive.c 						 struct stage_data *entry,
entry            1108 merge-recursive.c 	unsigned char *sha = entry->stages[stage].sha;
entry            1109 merge-recursive.c 	unsigned mode = entry->stages[stage].mode;
entry            1688 merge-recursive.c 			 const char *path, struct stage_data *entry)
entry            1692 merge-recursive.c 	unsigned o_mode = entry->stages[1].mode;
entry            1693 merge-recursive.c 	unsigned a_mode = entry->stages[2].mode;
entry            1694 merge-recursive.c 	unsigned b_mode = entry->stages[3].mode;
entry            1695 merge-recursive.c 	unsigned char *o_sha = stage_sha(entry->stages[1].sha, o_mode);
entry            1696 merge-recursive.c 	unsigned char *a_sha = stage_sha(entry->stages[2].sha, a_mode);
entry            1697 merge-recursive.c 	unsigned char *b_sha = stage_sha(entry->stages[3].sha, b_mode);
entry            1699 merge-recursive.c 	entry->processed = 1;
entry            1700 merge-recursive.c 	if (entry->rename_conflict_info) {
entry            1701 merge-recursive.c 		struct rename_conflict_info *conflict_info = entry->rename_conflict_info;
entry            1724 merge-recursive.c 			entry->processed = 0;
entry             192 notes.c        		struct leaf_node *entry)
entry             197 notes.c        	void **p = note_tree_search(t, &tree, &n, entry->key_sha1);
entry             199 notes.c        	assert(GET_PTR_TYPE(entry) == 0); /* no type bits set */
entry             203 notes.c        	if (hashcmp(l->key_sha1, entry->key_sha1))
entry             207 notes.c        	hashcpy(entry->val_sha1, l->val_sha1);
entry             217 notes.c        		j = GET_NIBBLE(i, entry->key_sha1);
entry             224 notes.c        				      GET_NIBBLE(i - 1, entry->key_sha1)))
entry             242 notes.c        		unsigned char n, struct leaf_node *entry, unsigned char type,
entry             247 notes.c        	void **p = note_tree_search(t, &tree, &n, entry->key_sha1);
entry             250 notes.c        	assert(GET_PTR_TYPE(entry) == 0); /* no type bits set */
entry             255 notes.c        		if (is_null_sha1(entry->val_sha1))
entry             256 notes.c        			free(entry);
entry             258 notes.c        			*p = SET_PTR_TYPE(entry, type);
entry             263 notes.c        			if (!hashcmp(l->key_sha1, entry->key_sha1)) {
entry             265 notes.c        				if (!hashcmp(l->val_sha1, entry->val_sha1))
entry             269 notes.c        						    entry->val_sha1);
entry             271 notes.c        					note_tree_remove(t, tree, n, entry);
entry             272 notes.c        				free(entry);
entry             278 notes.c        						    entry->key_sha1)) {
entry             280 notes.c        				load_subtree(t, entry, tree, n);
entry             281 notes.c        				free(entry);
entry             288 notes.c        		if (!SUBTREE_SHA1_PREFIXCMP(entry->key_sha1, l->key_sha1)) {
entry             293 notes.c        			return note_tree_insert(t, tree, n, entry, type,
entry             302 notes.c        	if (is_null_sha1(entry->val_sha1)) { /* skip insertion of empty note */
entry             303 notes.c        		free(entry);
entry             312 notes.c        	return note_tree_insert(t, new_node, n + 1, entry, type, combine_notes);
entry             418 notes.c        	struct name_entry entry;
entry             431 notes.c        	while (tree_entry(&desc, &entry)) {
entry             432 notes.c        		path_len = strlen(entry.path);
entry             433 notes.c        		len = get_sha1_hex_segment(entry.path, path_len,
entry             449 notes.c        			hashcpy(l->val_sha1, entry.sha1);
entry             451 notes.c        				if (!S_ISDIR(entry.mode) || path_len != 2)
entry             494 notes.c        			strbuf_addstr(&non_note_path, entry.path);
entry             496 notes.c        				     entry.mode, entry.sha1);
entry             318 object.c       	struct object_array_entry *entry;
entry             326 object.c       	entry = &objects[nr];
entry             327 object.c       	entry->item = obj;
entry             329 object.c       		entry->name = NULL;
entry             332 object.c       		entry->name = object_array_slopbuf;
entry             334 object.c       		entry->name = xstrdup(name);
entry             335 object.c       	entry->mode = mode;
entry             337 object.c       		entry->path = xstrdup(path);
entry             339 object.c       		entry->path = NULL;
entry              62 pack-bitmap-write.c 		struct object_entry *entry = (struct object_entry *)index[i];
entry              65 pack-bitmap-write.c 		entry->in_pack_pos = i;
entry              67 pack-bitmap-write.c 		switch (entry->type) {
entry              72 pack-bitmap-write.c 			real_type = entry->type;
entry              76 pack-bitmap-write.c 			real_type = sha1_object_info(entry->idx.sha1, NULL);
entry              99 pack-bitmap-write.c 			    sha1_to_hex(entry->idx.sha1), real_type, entry->type);
entry             141 pack-bitmap-write.c 	struct object_entry *entry = packlist_find(writer.to_pack, sha1, NULL);
entry             143 pack-bitmap-write.c 	if (!entry) {
entry             148 pack-bitmap-write.c 	return entry->in_pack_pos;
entry             497 pack-bitmap-write.c 		struct object_entry *entry = (struct object_entry *)index[i];
entry             498 pack-bitmap-write.c 		uint32_t hash_value = htonl(entry->hash);
entry             627 pack-bitmap.c  			struct revindex_entry *entry;
entry             638 pack-bitmap.c  			entry = &bitmap_git.reverse_index->revindex[pos + offset];
entry             639 pack-bitmap.c  			sha1 = nth_packed_object_sha1(bitmap_git.pack, entry->nr);
entry             642 pack-bitmap.c  				hash = ntohl(bitmap_git.hashes[entry->nr]);
entry             644 pack-bitmap.c  			show_reach(sha1, object_type, 0, hash, bitmap_git.pack, entry->offset);
entry             785 pack-bitmap.c  		struct revindex_entry *entry;
entry             787 pack-bitmap.c  		entry = &bitmap_git.reverse_index->revindex[reuse_objects];
entry             788 pack-bitmap.c  		sha1 = nth_packed_object_sha1(bitmap_git.pack, entry->nr);
entry            1043 pack-bitmap.c  		struct revindex_entry *entry;
entry            1046 pack-bitmap.c  		entry = &bitmap_git.reverse_index->revindex[i];
entry            1047 pack-bitmap.c  		sha1 = nth_packed_object_sha1(bitmap_git.pack, entry->nr);
entry              43 pack-objects.c 	struct object_entry *entry;
entry              52 pack-objects.c 	entry = pdata->objects;
entry              56 pack-objects.c 		uint32_t ix = locate_object_entry_hash(pdata, entry->idx.sha1, &found);
entry              62 pack-objects.c 		entry++;
entry             366 pathspec.c     	const char *entry = argv ? *argv : NULL;
entry             375 pathspec.c     	if (!entry && !prefix)
entry             383 pathspec.c     	if (!entry) {
entry             415 pathspec.c     		entry = argv[i];
entry             419 pathspec.c     						prefix, prefixlen, entry);
entry             426 pathspec.c     			unsupported_magic(entry,
entry             432 pathspec.c     			die(_("pathspec '%s' is beyond a symbolic link"), entry);
entry             308 refs.c         static struct ref_dir *get_ref_dir(struct ref_entry *entry)
entry             311 refs.c         	assert(entry->flag & REF_DIR);
entry             312 refs.c         	dir = &entry->u.subdir;
entry             313 refs.c         	if (entry->flag & REF_INCOMPLETE) {
entry             314 refs.c         		read_loose_refs(entry->name, dir);
entry             315 refs.c         		entry->flag &= ~REF_INCOMPLETE;
entry             374 refs.c         static void free_ref_entry(struct ref_entry *entry)
entry             376 refs.c         	if (entry->flag & REF_DIR) {
entry             381 refs.c         		clear_ref_dir(&entry->u.subdir);
entry             383 refs.c         	free(entry);
entry             391 refs.c         static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry)
entry             394 refs.c         	dir->entries[dir->nr++] = entry;
entry             495 refs.c         	struct ref_entry *entry;
entry             505 refs.c         		entry = create_dir_entry(dir->ref_cache, subdirname, len, 0);
entry             506 refs.c         		add_entry_to_dir(dir, entry);
entry             508 refs.c         		entry = dir->entries[entry_index];
entry             510 refs.c         	return get_ref_dir(entry);
entry             548 refs.c         	struct ref_entry *entry;
entry             555 refs.c         	entry = dir->entries[entry_index];
entry             556 refs.c         	return (entry->flag & REF_DIR) ? NULL : entry;
entry             577 refs.c         	struct ref_entry *entry;
entry             597 refs.c         	entry = dir->entries[entry_index];
entry             606 refs.c         	free_ref_entry(entry);
entry             667 refs.c         		struct ref_entry *entry = dir->entries[j];
entry             668 refs.c         		if (last && is_dup_ref(last, entry))
entry             669 refs.c         			free_ref_entry(entry);
entry             671 refs.c         			last = dir->entries[i++] = entry;
entry             684 refs.c         static int ref_resolves_to_object(struct ref_entry *entry)
entry             686 refs.c         	if (entry->flag & REF_ISBROKEN)
entry             688 refs.c         	if (!has_sha1_file(entry->u.value.oid.hash)) {
entry             689 refs.c         		error("%s does not point to a valid object!", entry->name);
entry             706 refs.c         typedef int each_ref_entry_fn(struct ref_entry *entry, void *cb_data);
entry             720 refs.c         static int do_one_ref(struct ref_entry *entry, void *cb_data)
entry             726 refs.c         	if (!starts_with(entry->name, data->base))
entry             730 refs.c         	      !ref_resolves_to_object(entry))
entry             735 refs.c         	current_ref = entry;
entry             736 refs.c         	retval = data->fn(entry->name + data->trim, &entry->u.value.oid,
entry             737 refs.c         			  entry->flag, data->cb_data);
entry             755 refs.c         		struct ref_entry *entry = dir->entries[i];
entry             757 refs.c         		if (entry->flag & REF_DIR) {
entry             758 refs.c         			struct ref_dir *subdir = get_ref_dir(entry);
entry             762 refs.c         			retval = fn(entry, cb_data);
entry             852 refs.c         		struct ref_entry *entry = dir->entries[i];
entry             853 refs.c         		if (entry->flag & REF_DIR)
entry             854 refs.c         			prime_ref_dir(get_ref_dir(entry));
entry             863 refs.c         static int nonmatching_ref_fn(struct ref_entry *entry, void *vdata)
entry             867 refs.c         	if (data->skip && string_list_has_string(data->skip, entry->name))
entry             870 refs.c         	data->conflicting_refname = entry->name;
entry            1558 refs.c         	struct ref_entry *entry;
entry            1564 refs.c         	entry = get_packed_ref(refname);
entry            1565 refs.c         	if (entry) {
entry            1566 refs.c         		hashcpy(sha1, entry->u.value.oid.hash);
entry            1872 refs.c         static enum peel_status peel_entry(struct ref_entry *entry, int repeel)
entry            1876 refs.c         	if (entry->flag & REF_KNOWS_PEELED) {
entry            1878 refs.c         			entry->flag &= ~REF_KNOWS_PEELED;
entry            1879 refs.c         			oidclr(&entry->u.value.peeled);
entry            1881 refs.c         			return is_null_oid(&entry->u.value.peeled) ?
entry            1885 refs.c         	if (entry->flag & REF_ISBROKEN)
entry            1887 refs.c         	if (entry->flag & REF_ISSYMREF)
entry            1890 refs.c         	status = peel_object(entry->u.value.oid.hash, entry->u.value.peeled.hash);
entry            1892 refs.c         		entry->flag |= REF_KNOWS_PEELED;
entry            2540 refs.c         static int write_packed_entry_fn(struct ref_entry *entry, void *cb_data)
entry            2542 refs.c         	enum peel_status peel_status = peel_entry(entry, 0);
entry            2546 refs.c         		      entry->name);
entry            2547 refs.c         	write_packed_entry(cb_data, entry->name, entry->u.value.oid.hash,
entry            2549 refs.c         			   entry->u.value.peeled.hash : NULL);
entry            2658 refs.c         static int pack_if_possible_fn(struct ref_entry *entry, void *cb_data)
entry            2663 refs.c         	int is_tag_ref = starts_with(entry->name, "refs/tags/");
entry            2670 refs.c         	if ((entry->flag & REF_ISSYMREF) || !ref_resolves_to_object(entry))
entry            2674 refs.c         	peel_status = peel_entry(entry, 1);
entry            2677 refs.c         		    entry->name, oid_to_hex(&entry->u.value.oid));
entry            2678 refs.c         	packed_entry = find_ref(cb->packed_refs, entry->name);
entry            2682 refs.c         		oidcpy(&packed_entry->u.value.oid, &entry->u.value.oid);
entry            2684 refs.c         		packed_entry = create_ref_entry(entry->name, entry->u.value.oid.hash,
entry            2688 refs.c         	oidcpy(&packed_entry->u.value.peeled, &entry->u.value.peeled);
entry            2692 refs.c         		int namelen = strlen(entry->name) + 1;
entry            2694 refs.c         		hashcpy(n->sha1, entry->u.value.oid.hash);
entry            2695 refs.c         		strcpy(n->name, entry->name);
entry            2311 remote.c       		free(cas->entry[i].refname);
entry            2312 remote.c       	free(cas->entry);
entry            2320 remote.c       	struct push_cas *entry;
entry            2321 remote.c       	ALLOC_GROW(cas->entry, cas->nr + 1, cas->alloc);
entry            2322 remote.c       	entry = &cas->entry[cas->nr++];
entry            2323 remote.c       	memset(entry, 0, sizeof(*entry));
entry            2324 remote.c       	entry->refname = xmemdupz(refname, refnamelen);
entry            2325 remote.c       	return entry;
entry            2331 remote.c       	struct push_cas *entry;
entry            2347 remote.c       	entry = add_cas_entry(cas, arg, colon - arg);
entry            2349 remote.c       		entry->use_tracking = 1;
entry            2350 remote.c       	else if (get_sha1(colon + 1, entry->expect))
entry            2392 remote.c       		struct push_cas *entry = &cas->entry[i];
entry            2393 remote.c       		if (!refname_match(entry->refname, ref->name))
entry            2396 remote.c       		if (!entry->use_tracking)
entry            2397 remote.c       			hashcpy(ref->old_sha1_expect, cas->entry[i].expect);
entry             281 remote.h       	} *entry;
entry             106 revision.c     	struct name_entry entry;
entry             115 revision.c     	while (tree_entry(&desc, &entry)) {
entry             116 revision.c     		switch (object_type(entry.mode)) {
entry             118 revision.c     			mark_tree_uninteresting(lookup_tree(entry.sha1));
entry             121 revision.c     			mark_blob_uninteresting(lookup_blob(entry.sha1));
entry             271 revision.c     				    struct object_array_entry *entry)
entry             273 revision.c     	struct object *object = entry->item;
entry             274 revision.c     	const char *name = entry->name;
entry             275 revision.c     	const char *path = entry->path;
entry             276 revision.c     	unsigned int mode = entry->mode;
entry            1105 revision.c     		struct commit_list *entry = list;
entry            1111 revision.c     		free(entry);
entry            3128 revision.c     		struct commit_list *entry = revs->commits;
entry            3129 revision.c     		struct commit *commit = entry->item;
entry            3131 revision.c     		revs->commits = entry->next;
entry            3132 revision.c     		free(entry);
entry            3175 revision.c     static int entry_unshown(struct object_array_entry *entry, void *cb_data_unused)
entry            3177 revision.c     	return !(entry->item->flags & SHOWN);
entry             269 sha1_file.c    static int link_alt_odb_entry(const char *entry, const char *relative_base,
entry             277 sha1_file.c    	if (!is_absolute_path(entry) && relative_base) {
entry             281 sha1_file.c    	strbuf_addstr(&pathbuf, entry);
entry             360 sha1_file.c    		const char *entry = entries.items[i].string;
entry             361 sha1_file.c    		if (entry[0] == '\0' || entry[0] == '#')
entry             363 sha1_file.c    		if (!is_absolute_path(entry) && depth) {
entry             365 sha1_file.c    					relative_base, entry);
entry             367 sha1_file.c    			link_alt_odb_entry(entry, relative_base, depth, objdirbuf.buf);
entry            3241 sha1_file.c    	struct name_entry entry;
entry            3244 sha1_file.c    	while (tree_entry(&desc, &entry))
entry              40 show-index.c   			unsigned int offset, entry[6];
entry              42 show-index.c   			if (fread(entry, 4 + 20, 1, stdin) != 1)
entry              44 show-index.c   			offset = ntohl(entry[0]);
entry              45 show-index.c   			printf("%u %s\n", offset, sha1_to_hex((void *)(entry+1)));
entry              58 submodule-config.c static void free_one_config(struct submodule_entry *entry)
entry              60 submodule-config.c 	free((void *) entry->config->path);
entry              61 submodule-config.c 	free((void *) entry->config->name);
entry              62 submodule-config.c 	free(entry->config);
entry              68 submodule-config.c 	struct submodule_entry *entry;
entry              76 submodule-config.c 	while ((entry = hashmap_iter_next(&iter)))
entry              77 submodule-config.c 		free_one_config(entry);
entry             127 submodule-config.c 	struct submodule_entry *entry;
entry             138 submodule-config.c 	entry = hashmap_get(&cache->for_path, &key, NULL);
entry             139 submodule-config.c 	if (entry)
entry             140 submodule-config.c 		return entry->config;
entry             147 submodule-config.c 	struct submodule_entry *entry;
entry             158 submodule-config.c 	entry = hashmap_get(&cache->for_name, &key, NULL);
entry             159 submodule-config.c 	if (entry)
entry             160 submodule-config.c 		return entry->config;
entry             380 submodule-config.c 		struct submodule_entry *entry;
entry             383 submodule-config.c 		entry = hashmap_iter_next(&iter);
entry             384 submodule-config.c 		if (!entry)
entry             386 submodule-config.c 		return entry->config;
entry              54 submodule.c    	struct strbuf entry = STRBUF_INIT;
entry              68 submodule.c    	strbuf_addstr(&entry, "submodule.");
entry              69 submodule.c    	strbuf_addstr(&entry, submodule->name);
entry              70 submodule.c    	strbuf_addstr(&entry, ".path");
entry              71 submodule.c    	if (git_config_set_in_file(".gitmodules", entry.buf, newpath) < 0) {
entry              73 submodule.c    		warning(_("Could not update .gitmodules entry %s"), entry.buf);
entry              74 submodule.c    		strbuf_release(&entry);
entry              77 submodule.c    	strbuf_release(&entry);
entry              31 test-hashmap.c 	struct test_entry *entry = malloc(sizeof(struct test_entry) + klen
entry              33 test-hashmap.c 	hashmap_entry_init(entry, hash);
entry              34 test-hashmap.c 	memcpy(entry->key, key, klen + 1);
entry              35 test-hashmap.c 	memcpy(entry->key + klen + 1, value, vlen + 1);
entry              36 test-hashmap.c 	return entry;
entry             156 test-hashmap.c 		struct test_entry *entry;
entry             182 test-hashmap.c 			entry = alloc_test_entry(hash, p1, l1, p2, l2);
entry             185 test-hashmap.c 			hashmap_add(&map, entry);
entry             190 test-hashmap.c 			entry = alloc_test_entry(hash, p1, l1, p2, l2);
entry             193 test-hashmap.c 			entry = hashmap_put(&map, entry);
entry             196 test-hashmap.c 			puts(entry ? get_value(entry) : "NULL");
entry             197 test-hashmap.c 			free(entry);
entry             202 test-hashmap.c 			entry = hashmap_get_from_hash(&map, hash, p1);
entry             205 test-hashmap.c 			if (!entry)
entry             207 test-hashmap.c 			while (entry) {
entry             208 test-hashmap.c 				puts(get_value(entry));
entry             209 test-hashmap.c 				entry = hashmap_get_next(&map, entry);
entry             219 test-hashmap.c 			entry = hashmap_remove(&map, &key, p1);
entry             222 test-hashmap.c 			puts(entry ? get_value(entry) : "NULL");
entry             223 test-hashmap.c 			free(entry);
entry             229 test-hashmap.c 			while ((entry = hashmap_iter_next(&iter)))
entry             230 test-hashmap.c 				printf("%s %s\n", entry->key, get_value(entry));
entry              49 tree-diff.c    	e1 = &t1->entry;
entry              50 tree-diff.c    	e2 = &t2->entry;
entry             187 tree-diff.c    		pathlen = tree_entry_len(&t->entry);
entry             198 tree-diff.c    		pathlen = tree_entry_len(&tp[imin].entry);
entry             220 tree-diff.c    			int tpi_valid = tp && !(tp[i].entry.mode & S_IFXMIN_NEQ);
entry             232 tree-diff.c    				sha1_i = tp[i].entry.sha1;
entry             233 tree-diff.c    				mode_i = tp[i].entry.mode;
entry             271 tree-diff.c    			int tpi_valid = tp && !(tp[i].entry.mode & S_IFXMIN_NEQ);
entry             273 tree-diff.c    			parents_sha1[i] = tpi_valid ? tp[i].entry.sha1
entry             293 tree-diff.c    		match = tree_entry_interesting(&t->entry, base, 0, &opt->pathspec);
entry             392 tree-diff.c    		if (!(tp[i].entry.mode & S_IFXMIN_NEQ))
entry             450 tree-diff.c    		tp[0].entry.mode &= ~S_IFXMIN_NEQ;
entry             456 tree-diff.c    				tp[i].entry.mode &= ~S_IFXMIN_NEQ;
entry             459 tree-diff.c    				tp[i].entry.mode &= ~S_IFXMIN_NEQ;
entry             462 tree-diff.c    				tp[i].entry.mode |= S_IFXMIN_NEQ;
entry             468 tree-diff.c    			tp[i].entry.mode |= S_IFXMIN_NEQ;	/* pi > p[imin] */
entry             481 tree-diff.c    					if (tp[i].entry.mode & S_IFXMIN_NEQ)
entry             485 tree-diff.c    					if (hashcmp(t.entry.sha1, tp[i].entry.sha1) ||
entry             486 tree-diff.c    					    (t.entry.mode != tp[i].entry.mode))
entry             518 tree-diff.c    					if (tp[i].entry.mode & S_IFXMIN_NEQ)
entry              39 tree-walk.c    	desc->entry.path = path;
entry              40 tree-walk.c    	desc->entry.mode = canon_mode(mode);
entry              41 tree-walk.c    	desc->entry.sha1 = (const unsigned char *)(path + len);
entry              73 tree-walk.c    	*a = t->entry;
entry              79 tree-walk.c    	const unsigned char *end = desc->entry.sha1 + 20;
entry              93 tree-walk.c    int tree_entry(struct tree_desc *desc, struct name_entry *entry)
entry              98 tree-walk.c    	*entry = desc->entry;
entry             282 tree-walk.c    	if (t->d.entry.path == a->path) {
entry             318 tree-walk.c    	struct name_entry *entry = xmalloc(n*sizeof(*entry));
entry             342 tree-walk.c    			e = entry + i;
entry             353 tree-walk.c    			e = entry + i;
entry             370 tree-walk.c    				e = entry + i;
entry             385 tree-walk.c    			if (!entry[i].path)
entry             388 tree-walk.c    			if (S_ISDIR(entry[i].mode))
entry             390 tree-walk.c    			e = &entry[i];
entry             398 tree-walk.c    			trees_used = info->fn(n, mask, dirmask, entry, info);
entry             408 tree-walk.c    				update_extended_entry(tx + i, entry + i);
entry             410 tree-walk.c    	free(entry);
entry             428 tree-walk.c    		const char *entry;
entry             432 tree-walk.c    		sha1 = tree_entry_extract(t, &entry, mode);
entry             433 tree-walk.c    		entrylen = tree_entry_len(&t->entry);
entry             437 tree-walk.c    		cmp = memcmp(name, entry, entrylen);
entry             688 tree-walk.c    		       const struct name_entry *entry, int pathlen,
entry             715 tree-walk.c    		m = strncmp(match, entry->path,
entry             742 tree-walk.c    		if (!S_ISDIR(entry->mode) && !S_ISGITLINK(entry->mode))
entry             751 tree-walk.c    		m = ps_strncmp(item, match, entry->path, pathlen);
entry             861 tree-walk.c    static enum interesting do_match(const struct name_entry *entry,
entry             885 tree-walk.c    				    !!S_ISDIR(entry->mode),
entry             890 tree-walk.c    	pathlen = tree_entry_len(entry);
entry             914 tree-walk.c    					    !!S_ISDIR(entry->mode),
entry             921 tree-walk.c    			if (match_entry(item, entry, pathlen,
entry             927 tree-walk.c    				if (!git_fnmatch(item, match + baselen, entry->path,
entry             935 tree-walk.c    				if (ps->recursive && S_ISDIR(entry->mode))
entry             966 tree-walk.c    		strbuf_add(base, entry->path, pathlen);
entry             982 tree-walk.c    		if (ps->recursive && S_ISDIR(entry->mode))
entry             994 tree-walk.c    enum interesting tree_entry_interesting(const struct name_entry *entry,
entry             999 tree-walk.c    	positive = do_match(entry, base, base_offset, ps, 0);
entry            1036 tree-walk.c    	negative = do_match(entry, base, base_offset, ps, 1);
entry            1043 tree-walk.c    	if (S_ISDIR(entry->mode) &&
entry              12 tree-walk.h    	struct name_entry entry;
entry              18 tree-walk.h    	*pathp = desc->entry.path;
entry              19 tree-walk.h    	*modep = desc->entry.mode;
entry              20 tree-walk.h    	return desc->entry.sha1;
entry              40 tree-walk.h    typedef int (*traverse_callback_t)(int n, unsigned long mask, unsigned long dirmask, struct name_entry *entry, struct traverse_info *);
entry              60 tree.c         	struct name_entry entry;
entry              70 tree.c         	while (tree_entry(&desc, &entry)) {
entry              72 tree.c         			retval = tree_entry_interesting(&entry, base, 0, pathspec);
entry              79 tree.c         		switch (fn(entry.sha1, base,
entry              80 tree.c         			   entry.path, entry.mode, stage, context)) {
entry              89 tree.c         		if (S_ISDIR(entry.mode))
entry              90 tree.c         			hashcpy(sha1, entry.sha1);
entry              91 tree.c         		else if (S_ISGITLINK(entry.mode)) {
entry              94 tree.c         			commit = lookup_commit(entry.sha1);
entry              97 tree.c         				    sha1_to_hex(entry.sha1),
entry              98 tree.c         				    base->buf, entry.path);
entry             102 tree.c         				    sha1_to_hex(entry.sha1),
entry             103 tree.c         				    base->buf, entry.path);
entry             110 tree.c         		len = tree_entry_len(&entry);
entry             111 tree.c         		strbuf_add(base, entry.path, len);
entry              34 walker.c       	struct name_entry entry;
entry              40 walker.c       	while (tree_entry(&desc, &entry)) {
entry              44 walker.c       		if (S_ISGITLINK(entry.mode))
entry              46 walker.c       		if (S_ISDIR(entry.mode)) {
entry              47 walker.c       			struct tree *tree = lookup_tree(entry.sha1);
entry              52 walker.c       			struct blob *blob = lookup_blob(entry.sha1);
entry              64 xdiff/xpatience.c 		struct entry *next, *previous;
entry             142 xdiff/xpatience.c 	result->entries = (struct entry *)
entry             143 xdiff/xpatience.c 		xdl_malloc(result->alloc * sizeof(struct entry));
entry             146 xdiff/xpatience.c 	memset(result->entries, 0, result->alloc * sizeof(struct entry));
entry             163 xdiff/xpatience.c static int binary_search(struct entry **sequence, int longest,
entry             164 xdiff/xpatience.c 		struct entry *entry)
entry             171 xdiff/xpatience.c 		if (sequence[middle]->line2 > entry->line2)
entry             189 xdiff/xpatience.c static struct entry *find_longest_common_sequence(struct hashmap *map)
entry             191 xdiff/xpatience.c 	struct entry **sequence = xdl_malloc(map->nr * sizeof(struct entry *));
entry             193 xdiff/xpatience.c 	struct entry *entry;
entry             195 xdiff/xpatience.c 	for (entry = map->first; entry; entry = entry->next) {
entry             196 xdiff/xpatience.c 		if (!entry->line2 || entry->line2 == NON_UNIQUE)
entry             198 xdiff/xpatience.c 		i = binary_search(sequence, longest, entry);
entry             199 xdiff/xpatience.c 		entry->previous = i < 0 ? NULL : sequence[i];
entry             200 xdiff/xpatience.c 		sequence[++i] = entry;
entry             212 xdiff/xpatience.c 	entry = sequence[longest - 1];
entry             213 xdiff/xpatience.c 	entry->next = NULL;
entry             214 xdiff/xpatience.c 	while (entry->previous) {
entry             215 xdiff/xpatience.c 		entry->previous->next = entry;
entry             216 xdiff/xpatience.c 		entry = entry->previous;
entry             219 xdiff/xpatience.c 	return entry;
entry             234 xdiff/xpatience.c static int walk_common_sequence(struct hashmap *map, struct entry *first,
entry             308 xdiff/xpatience.c 	struct entry *first;