static int compare_tree_entry(struct tree_desc *t1, struct tree_desc *t2, const char *base, int baselen, struct diff_options *opt) { unsigned mode1, mode2; const char *path1, *path2; const unsigned char *sha1, *sha2; int cmp, pathlen1, pathlen2; char *fullname; sha1 = tree_entry_extract(t1, &path1, &mode1); sha2 = tree_entry_extract(t2, &path2, &mode2); pathlen1 = tree_entry_len(path1, sha1); pathlen2 = tree_entry_len(path2, sha2); cmp = base_name_compare(path1, pathlen1, mode1, path2, pathlen2, mode2); if (cmp < 0) { show_entry(opt, "-", t1, base, baselen); return -1; } if (cmp > 0) { show_entry(opt, "+", t2, base, baselen); return 1; } if (!DIFF_OPT_TST(opt, FIND_COPIES_HARDER) && !hashcmp(sha1, sha2) && mode1 == mode2) return 0; /* * If the filemode has changed to/from a directory from/to a regular * file, we need to consider it a remove and an add. */ if (S_ISDIR(mode1) != S_ISDIR(mode2)) { show_entry(opt, "-", t1, base, baselen); show_entry(opt, "+", t2, base, baselen); return 0; } if (DIFF_OPT_TST(opt, RECURSIVE) && S_ISDIR(mode1)) { int retval; char *newbase = malloc_base(base, baselen, path1, pathlen1); if (DIFF_OPT_TST(opt, TREE_IN_RECURSIVE)) { newbase[baselen + pathlen1] = 0; opt->change(opt, mode1, mode2, sha1, sha2, newbase); newbase[baselen + pathlen1] = '/'; } retval = diff_tree_sha1(sha1, sha2, newbase, opt); free(newbase); return retval; } fullname = malloc_fullname(base, baselen, path1, pathlen1); opt->change(opt, mode1, mode2, sha1, sha2, fullname); free(fullname); return 0; }
static int compare_tree_entry(struct tree_desc *t1, struct tree_desc *t2, struct strbuf *base, struct diff_options *opt) { unsigned mode1, mode2; const char *path1, *path2; const unsigned char *sha1, *sha2; int cmp, pathlen1, pathlen2; int old_baselen = base->len; sha1 = tree_entry_extract(t1, &path1, &mode1); sha2 = tree_entry_extract(t2, &path2, &mode2); pathlen1 = tree_entry_len(path1, sha1); pathlen2 = tree_entry_len(path2, sha2); cmp = base_name_compare(path1, pathlen1, mode1, path2, pathlen2, mode2); if (cmp < 0) { show_entry(opt, "-", t1, base); return -1; } if (cmp > 0) { show_entry(opt, "+", t2, base); return 1; } if (!DIFF_OPT_TST(opt, FIND_COPIES_HARDER) && !hashcmp(sha1, sha2) && mode1 == mode2) return 0; /* * If the filemode has changed to/from a directory from/to a regular * file, we need to consider it a remove and an add. */ if (S_ISDIR(mode1) != S_ISDIR(mode2)) { show_entry(opt, "-", t1, base); show_entry(opt, "+", t2, base); return 0; } strbuf_add(base, path1, pathlen1); if (DIFF_OPT_TST(opt, RECURSIVE) && S_ISDIR(mode1)) { if (DIFF_OPT_TST(opt, TREE_IN_RECURSIVE)) { opt->change(opt, mode1, mode2, sha1, sha2, base->buf, 0, 0); } strbuf_addch(base, '/'); diff_tree_sha1(sha1, sha2, base->buf, opt); } else { opt->change(opt, mode1, mode2, sha1, sha2, base->buf, 0, 0); } strbuf_setlen(base, old_baselen); return 0; }
static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char *result, unsigned *mode) { int namelen = strlen(name); while (t->size) { const char *entry; const unsigned char *sha1; int entrylen, cmp; sha1 = tree_entry_extract(t, &entry, mode); update_tree_entry(t); entrylen = tree_entry_len(entry, sha1); if (entrylen > namelen) continue; cmp = memcmp(name, entry, entrylen); if (cmp > 0) continue; if (cmp < 0) break; if (entrylen == namelen) { hashcpy(result, sha1); return 0; } if (name[entrylen] != '/') continue; if (!S_ISDIR(*mode)) break; if (++entrylen == namelen) { hashcpy(result, sha1); return 0; } return get_tree_entry(sha1, name + entrylen, result, mode); } return -1; }
/* A file entry went away or appeared */ static void show_entry(struct diff_options *opt, const char *prefix, struct tree_desc *desc, const char *base, int baselen) { unsigned mode; const char *path; const unsigned char *sha1 = tree_entry_extract(desc, &path, &mode); int pathlen = tree_entry_len(path, sha1); if (DIFF_OPT_TST(opt, RECURSIVE) && S_ISDIR(mode)) { enum object_type type; char *newbase = malloc_base(base, baselen, path, pathlen); struct tree_desc inner; void *tree; unsigned long size; tree = read_sha1_file(sha1, &type, &size); if (!tree || type != OBJ_TREE) die("corrupt tree sha %s", sha1_to_hex(sha1)); init_tree_desc(&inner, tree, size); show_tree(opt, prefix, &inner, newbase, baselen + 1 + pathlen); free(tree); free(newbase); } else { char *fullname = malloc_fullname(base, baselen, path, pathlen); opt->add_remove(opt, prefix[0], mode, sha1, fullname); free(fullname); } }
/* A file entry went away or appeared */ static void show_entry(struct diff_options *opt, const char *prefix, struct tree_desc *desc, struct strbuf *base) { unsigned mode; const char *path; const unsigned char *sha1 = tree_entry_extract(desc, &path, &mode); int pathlen = tree_entry_len(path, sha1); int old_baselen = base->len; strbuf_add(base, path, pathlen); if (DIFF_OPT_TST(opt, RECURSIVE) && S_ISDIR(mode)) { enum object_type type; struct tree_desc inner; void *tree; unsigned long size; tree = read_sha1_file(sha1, &type, &size); if (!tree || type != OBJ_TREE) die("corrupt tree sha %s", sha1_to_hex(sha1)); if (DIFF_OPT_TST(opt, TREE_IN_RECURSIVE)) opt->add_remove(opt, *prefix, mode, sha1, base->buf, 0); strbuf_addch(base, '/'); init_tree_desc(&inner, tree, size); show_tree(opt, prefix, &inner, base); free(tree); } else opt->add_remove(opt, prefix[0], mode, sha1, base->buf, 0); strbuf_setlen(base, old_baselen); }
static int do_compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n) { int len, pathlen, ce_len; const char *ce_name; int cmp; /* * If we have not precomputed the traverse path, it is quicker * to avoid doing so. But if we have precomputed it, * it is quicker to use the precomputed version. */ if (!info->traverse_path) return do_compare_entry_piecewise(ce, info, n); cmp = strncmp(ce->name, info->traverse_path, info->pathlen); if (cmp) return cmp; pathlen = info->pathlen; ce_len = ce_namelen(ce); if (ce_len < pathlen) return -1; ce_len -= pathlen; ce_name = ce->name + pathlen; len = tree_entry_len(n); return df_name_compare(ce_name, ce_len, S_IFREG, n->path, len, n->mode); }
/* * Compare two tree entries, taking into account only path/S_ISDIR(mode), * but not their sha1's. * * NOTE files and directories *always* compare differently, even when having * the same name - thanks to base_name_compare(). * * NOTE empty (=invalid) descriptor(s) take part in comparison as +infty, * so that they sort *after* valid tree entries. * * Due to this convention, if trees are scanned in sorted order, all * non-empty descriptors will be processed first. */ static int tree_entry_pathcmp(struct tree_desc *t1, struct tree_desc *t2) { struct name_entry *e1, *e2; int cmp; /* empty descriptors sort after valid tree entries */ if (!t1->size) return t2->size ? 1 : 0; else if (!t2->size) return -1; e1 = &t1->entry; e2 = &t2->entry; cmp = base_name_compare(e1->path, tree_entry_len(e1), e1->mode, e2->path, tree_entry_len(e2), e2->mode); return cmp; }
static int grep_tree(struct grep_opt *opt, const char **paths, struct tree_desc *tree, const char *tree_name, const char *base) { int len; int hit = 0; struct name_entry entry; char *down; int tn_len = strlen(tree_name); struct strbuf pathbuf; strbuf_init(&pathbuf, PATH_MAX + tn_len); if (tn_len) { strbuf_add(&pathbuf, tree_name, tn_len); strbuf_addch(&pathbuf, ':'); tn_len = pathbuf.len; } strbuf_addstr(&pathbuf, base); len = pathbuf.len; while (tree_entry(tree, &entry)) { int te_len = tree_entry_len(entry.path, entry.sha1); pathbuf.len = len; strbuf_add(&pathbuf, entry.path, te_len); if (S_ISDIR(entry.mode)) /* Match "abc/" against pathspec to * decide if we want to descend into "abc" * directory. */ strbuf_addch(&pathbuf, '/'); down = pathbuf.buf + tn_len; if (!pathspec_matches(paths, down, opt->max_depth)) ; else if (S_ISREG(entry.mode)) hit |= grep_sha1(opt, entry.sha1, pathbuf.buf, tn_len); else if (S_ISDIR(entry.mode)) { enum object_type type; struct tree_desc sub; void *data; unsigned long size; data = lock_and_read_sha1_file(entry.sha1, &type, &size); if (!data) die("unable to read tree (%s)", sha1_to_hex(entry.sha1)); init_tree_desc(&sub, data, size); hit |= grep_tree(opt, paths, &sub, tree_name, down); free(data); } if (hit && opt->status_only) break; } strbuf_release(&pathbuf); return hit; }
char *make_traverse_path(char *path, const struct traverse_info *info, const struct name_entry *n) { int len = tree_entry_len(n->path, n->sha1); int pathlen = info->pathlen; path[pathlen + len] = 0; for (;;) { memcpy(path + pathlen, n->path, len); if (!pathlen) break; path[--pathlen] = '/'; n = &info->name; len = tree_entry_len(n->path, n->sha1); info = info->prev; pathlen -= len; } return path; }
/* * The tree traversal is looking at name p. If we have a matching entry, * return it. If name p is a directory in the index, do not return * anything, as we will want to match it when the traversal descends into * the directory. */ static int find_cache_pos(struct traverse_info *info, const struct name_entry *p) { int pos; struct unpack_trees_options *o = info->data; struct index_state *index = o->src_index; int pfxlen = info->pathlen; int p_len = tree_entry_len(p); for (pos = o->cache_bottom; pos < index->cache_nr; pos++) { const struct cache_entry *ce = index->cache[pos]; const char *ce_name, *ce_slash; int cmp, ce_len; if (ce->ce_flags & CE_UNPACKED) { /* * cache_bottom entry is already unpacked, so * we can never match it; don't check it * again. */ if (pos == o->cache_bottom) ++o->cache_bottom; continue; } if (!ce_in_traverse_path(ce, info)) continue; ce_name = ce->name + pfxlen; ce_slash = strchr(ce_name, '/'); if (ce_slash) ce_len = ce_slash - ce_name; else ce_len = ce_namelen(ce) - pfxlen; cmp = name_compare(p->path, p_len, ce_name, ce_len); /* * Exact match; if we have a directory we need to * delay returning it. */ if (!cmp) return ce_slash ? -2 - pos : pos; if (0 < cmp) continue; /* keep looking */ /* * ce_name sorts after p->path; could it be that we * have files under p->path directory in the index? * E.g. ce_name == "t-i", and p->path == "t"; we may * have "t/a" in the index. */ if (p_len < ce_len && !memcmp(ce_name, p->path, p_len) && ce_name[p_len] < '/') continue; /* keep looking */ break; } return -1; }
static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec, struct tree_desc *tree, struct strbuf *base, int tn_len, int check_attr) { int hit = 0; enum interesting match = entry_not_interesting; struct name_entry entry; int old_baselen = base->len; while (tree_entry(tree, &entry)) { int te_len = tree_entry_len(&entry); if (match != all_entries_interesting) { match = tree_entry_interesting(&entry, base, tn_len, pathspec); if (match == all_entries_not_interesting) break; if (match == entry_not_interesting) continue; } strbuf_add(base, entry.path, te_len); if (S_ISREG(entry.mode)) { hit |= grep_sha1(opt, entry.sha1, base->buf, tn_len, check_attr ? base->buf + tn_len : NULL); } else if (S_ISDIR(entry.mode)) { enum object_type type; struct tree_desc sub; void *data; unsigned long size; data = lock_and_read_sha1_file(entry.sha1, &type, &size); if (!data) die(_("unable to read tree (%s)"), sha1_to_hex(entry.sha1)); strbuf_addch(base, '/'); init_tree_desc(&sub, data, size); hit |= grep_tree(opt, pathspec, &sub, base, tn_len, check_attr); free(data); } strbuf_setlen(base, old_baselen); if (hit && opt->status_only) break; } return hit; }
static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec, struct tree_desc *tree, struct strbuf *base, int tn_len) { int hit = 0, matched = 0; struct name_entry entry; int old_baselen = base->len; while (tree_entry(tree, &entry)) { int te_len = tree_entry_len(entry.path, entry.sha1); if (matched != 2) { matched = tree_entry_interesting(&entry, base, tn_len, pathspec); if (matched == -1) break; /* no more matches */ if (!matched) continue; } strbuf_add(base, entry.path, te_len); if (S_ISREG(entry.mode)) { hit |= grep_sha1(opt, entry.sha1, base->buf, tn_len); } else if (S_ISDIR(entry.mode)) { enum object_type type; struct tree_desc sub; void *data; unsigned long size; data = lock_and_read_sha1_file(entry.sha1, &type, &size); if (!data) die("unable to read tree (%s)", sha1_to_hex(entry.sha1)); strbuf_addch(base, '/'); init_tree_desc(&sub, data, size); hit |= grep_tree(opt, pathspec, &sub, base, tn_len); free(data); } strbuf_setlen(base, old_baselen); if (hit && opt->status_only) break; } return hit; }
int read_tree_recursive(struct tree *tree, const char *base, int baselen, int stage, const char **match, read_tree_fn_t fn) { struct tree_desc desc; struct name_entry entry; if (parse_tree(tree)) return -1; init_tree_desc(&desc, tree->buffer, tree->size); while (tree_entry(&desc, &entry)) { if (!match_tree_entry(base, baselen, entry.path, entry.mode, match)) continue; switch (fn(entry.sha1, base, baselen, entry.path, entry.mode, stage)) { case 0: continue; case READ_TREE_RECURSIVE: break;; default: return -1; } if (S_ISDIR(entry.mode)) { int retval; char *newbase; unsigned int pathlen = tree_entry_len(entry.path, entry.sha1); newbase = xmalloc(baselen + 1 + pathlen); memcpy(newbase, base, baselen); memcpy(newbase + baselen, entry.path, pathlen); newbase[baselen + pathlen] = '/'; retval = read_tree_recursive(lookup_tree(entry.sha1), newbase, baselen + pathlen + 1, stage, match, fn); free(newbase); if (retval) return -1; continue; } } return 0; }
static int traverse_trees_recursive(int n, unsigned long dirmask, unsigned long df_conflicts, struct name_entry *names, struct traverse_info *info) { int i, ret, bottom; struct tree_desc t[MAX_UNPACK_TREES]; void *buf[MAX_UNPACK_TREES]; struct traverse_info newinfo; struct name_entry *p; p = names; while (!p->mode) p++; newinfo = *info; newinfo.prev = info; newinfo.pathspec = info->pathspec; newinfo.name = *p; newinfo.pathlen += tree_entry_len(p) + 1; newinfo.df_conflicts |= df_conflicts; for (i = 0; i < n; i++, dirmask >>= 1) { const unsigned char *sha1 = NULL; if (dirmask & 1) sha1 = names[i].sha1; buf[i] = fill_tree_descriptor(t+i, sha1); } bottom = switch_cache_bottom(&newinfo); ret = traverse_trees(n, t, &newinfo); restore_cache_bottom(&newinfo, bottom); for (i = 0; i < n; i++) free(buf[i]); return ret; }
/* * Compare the traverse-path to the cache entry without actually * having to generate the textual representation of the traverse * path. * * NOTE! This *only* compares up to the size of the traverse path * itself - the caller needs to do the final check for the cache * entry having more data at the end! */ static int do_compare_entry(const struct cache_entry *ce, const struct traverse_info *info, const struct name_entry *n) { int len, pathlen, ce_len; const char *ce_name; if (info->prev) { int cmp = do_compare_entry(ce, info->prev, &info->name); if (cmp) return cmp; } pathlen = info->pathlen; ce_len = ce_namelen(ce); /* If ce_len < pathlen then we must have previously hit "name == directory" entry */ if (ce_len < pathlen) return -1; ce_len -= pathlen; ce_name = ce->name + pathlen; len = tree_entry_len(n); return df_name_compare(ce_name, ce_len, S_IFREG, n->path, len, n->mode); }
static void extended_entry_extract(struct tree_desc_x *t, struct name_entry *a, const char *first, int first_len) { const char *path; int len; struct tree_desc probe; struct tree_desc_skip *skip; /* * Extract the first entry from the tree_desc, but skip the * ones that we already returned in earlier rounds. */ while (1) { if (!t->d.size) { entry_clear(a); break; /* not found */ } entry_extract(&t->d, a); for (skip = t->skip; skip; skip = skip->prev) if (a->path == skip->ptr) break; /* found */ if (!skip) break; /* We have processed this entry already. */ update_tree_entry(&t->d); } if (!first || !a->path) return; /* * The caller wants "first" from this tree, or nothing. */ path = a->path; len = tree_entry_len(a->path, a->sha1); switch (check_entry_match(first, first_len, path, len)) { case -1: entry_clear(a); case 0: return; default: break; } /* * We need to look-ahead -- we suspect that a subtree whose * name is "first" may be hiding behind the current entry "path". */ probe = t->d; while (probe.size) { entry_extract(&probe, a); path = a->path; len = tree_entry_len(a->path, a->sha1); switch (check_entry_match(first, first_len, path, len)) { case -1: entry_clear(a); case 0: return; default: update_tree_entry(&probe); break; } /* keep looking */ } entry_clear(a); }
static int entry_compare(struct name_entry *a, struct name_entry *b) { return df_name_compare( a->path, tree_entry_len(a->path, a->sha1), a->mode, b->path, tree_entry_len(b->path, b->sha1), b->mode); }
int traverse_trees(int n, struct tree_desc *t, struct traverse_info *info) { int error = 0; struct name_entry *entry = xmalloc(n*sizeof(*entry)); int i; struct tree_desc_x *tx = xcalloc(n, sizeof(*tx)); struct strbuf base = STRBUF_INIT; int interesting = 1; for (i = 0; i < n; i++) tx[i].d = t[i]; if (info->prev) { strbuf_grow(&base, info->pathlen); make_traverse_path(base.buf, info->prev, &info->name); base.buf[info->pathlen-1] = '/'; strbuf_setlen(&base, info->pathlen); } for (;;) { int trees_used; unsigned long mask, dirmask; const char *first = NULL; int first_len = 0; struct name_entry *e = NULL; int len; for (i = 0; i < n; i++) { e = entry + i; extended_entry_extract(tx + i, e, NULL, 0); } /* * A tree may have "t-2" at the current location even * though it may have "t" that is a subtree behind it, * and another tree may return "t". We want to grab * all "t" from all trees to match in such a case. */ for (i = 0; i < n; i++) { e = entry + i; if (!e->path) continue; len = tree_entry_len(e); if (!first) { first = e->path; first_len = len; continue; } if (name_compare(e->path, len, first, first_len) < 0) { first = e->path; first_len = len; } } if (first) { for (i = 0; i < n; i++) { e = entry + i; extended_entry_extract(tx + i, e, first, first_len); /* Cull the ones that are not the earliest */ if (!e->path) continue; len = tree_entry_len(e); if (name_compare(e->path, len, first, first_len)) entry_clear(e); } } /* Now we have in entry[i] the earliest name from the trees */ mask = 0; dirmask = 0; for (i = 0; i < n; i++) { if (!entry[i].path) continue; mask |= 1ul << i; if (S_ISDIR(entry[i].mode)) dirmask |= 1ul << i; e = &entry[i]; } if (!mask) break; interesting = prune_traversal(e, info, &base, interesting); if (interesting < 0) break; if (interesting) { trees_used = info->fn(n, mask, dirmask, entry, info); if (trees_used < 0) { error = trees_used; if (!info->show_all_errors) break; } mask &= trees_used; } for (i = 0; i < n; i++) if (mask & (1ul << i)) update_extended_entry(tx + i, entry + i); } free(entry); for (i = 0; i < n; i++) free_extended_entry(tx + i); free(tx); strbuf_release(&base); return error; }
/* * Is a tree entry interesting given the pathspec we have? * * Return: * - 2 for "yes, and all subsequent entries will be" * - 1 for yes * - zero for no * - negative for "no, and no subsequent entries will be either" */ static int tree_entry_interesting(struct tree_desc *desc, const char *base, int baselen, struct diff_options *opt) { const char *path; const unsigned char *sha1; unsigned mode; int i; int pathlen; int never_interesting = -1; if (!opt->nr_paths) return 1; sha1 = tree_entry_extract(desc, &path, &mode); pathlen = tree_entry_len(path, sha1); for (i = 0; i < opt->nr_paths; i++) { const char *match = opt->paths[i]; int matchlen = opt->pathlens[i]; int m = -1; /* signals that we haven't called strncmp() */ if (baselen >= matchlen) { /* If it doesn't match, move along... */ if (strncmp(base, match, matchlen)) continue; /* * The base is a subdirectory of a path which * was specified, so all of them are interesting. */ return 2; } /* Does the base match? */ if (strncmp(base, match, baselen)) continue; match += baselen; matchlen -= baselen; if (never_interesting) { /* * We have not seen any match that sorts later * than the current path. */ /* * Does match sort strictly earlier than path * with their common parts? */ m = strncmp(match, path, (matchlen < pathlen) ? matchlen : pathlen); if (m < 0) continue; /* * If we come here even once, that means there is at * least one pathspec that would sort equal to or * later than the path we are currently looking at. * In other words, if we have never reached this point * after iterating all pathspecs, it means all * pathspecs are either outside of base, or inside the * base but sorts strictly earlier than the current * one. In either case, they will never match the * subsequent entries. In such a case, we initialized * the variable to -1 and that is what will be * returned, allowing the caller to terminate early. */ never_interesting = 0; } if (pathlen > matchlen) continue; if (matchlen > pathlen) { if (match[pathlen] != '/') continue; if (!S_ISDIR(mode)) continue; } if (m == -1) /* * we cheated and did not do strncmp(), so we do * that here. */ m = strncmp(match, path, pathlen); /* * If common part matched earlier then it is a hit, * because we rejected the case where path is not a * leading directory and is shorter than match. */ if (!m) return 1; } return never_interesting; /* No matches */ }
static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec, struct tree_desc *tree, struct strbuf *base, int tn_len, int check_attr) { int hit = 0; enum interesting match = entry_not_interesting; struct name_entry entry; int old_baselen = base->len; struct strbuf name = STRBUF_INIT; int name_base_len = 0; if (super_prefix) { strbuf_addstr(&name, super_prefix); name_base_len = name.len; } while (tree_entry(tree, &entry)) { int te_len = tree_entry_len(&entry); if (match != all_entries_interesting) { strbuf_addstr(&name, base->buf + tn_len); match = tree_entry_interesting(&entry, &name, 0, pathspec); strbuf_setlen(&name, name_base_len); if (match == all_entries_not_interesting) break; if (match == entry_not_interesting) continue; } strbuf_add(base, entry.path, te_len); if (S_ISREG(entry.mode)) { hit |= grep_sha1(opt, entry.oid->hash, base->buf, tn_len, check_attr ? base->buf + tn_len : NULL); } else if (S_ISDIR(entry.mode)) { enum object_type type; struct tree_desc sub; void *data; unsigned long size; data = lock_and_read_sha1_file(entry.oid->hash, &type, &size); if (!data) die(_("unable to read tree (%s)"), oid_to_hex(entry.oid)); strbuf_addch(base, '/'); init_tree_desc(&sub, data, size); hit |= grep_tree(opt, pathspec, &sub, base, tn_len, check_attr); free(data); } else if (recurse_submodules && S_ISGITLINK(entry.mode)) { hit |= grep_submodule(opt, entry.oid->hash, base->buf, base->buf + tn_len); } strbuf_setlen(base, old_baselen); if (hit && opt->status_only) break; } strbuf_release(&name); return hit; }
/* * Is a tree entry interesting given the pathspec we have? * * Pre-condition: either baselen == base_offset (i.e. empty path) * or base[baselen-1] == '/' (i.e. with trailing slash). */ static enum interesting do_match(const struct name_entry *entry, struct strbuf *base, int base_offset, const struct pathspec *ps, int exclude) { int i; int pathlen, baselen = base->len - base_offset; enum interesting never_interesting = ps->has_wildcard ? entry_not_interesting : all_entries_not_interesting; GUARD_PATHSPEC(ps, PATHSPEC_FROMTOP | PATHSPEC_MAXDEPTH | PATHSPEC_LITERAL | PATHSPEC_GLOB | PATHSPEC_ICASE | PATHSPEC_EXCLUDE); if (!ps->nr) { if (!ps->recursive || !(ps->magic & PATHSPEC_MAXDEPTH) || ps->max_depth == -1) return all_entries_interesting; return within_depth(base->buf + base_offset, baselen, !!S_ISDIR(entry->mode), ps->max_depth) ? entry_interesting : entry_not_interesting; } pathlen = tree_entry_len(entry); for (i = ps->nr - 1; i >= 0; i--) { const struct pathspec_item *item = ps->items+i; const char *match = item->match; const char *base_str = base->buf + base_offset; int matchlen = item->len, matched = 0; if ((!exclude && item->magic & PATHSPEC_EXCLUDE) || ( exclude && !(item->magic & PATHSPEC_EXCLUDE))) continue; if (baselen >= matchlen) { /* If it doesn't match, move along... */ if (!match_dir_prefix(item, base_str, match, matchlen)) goto match_wildcards; if (!ps->recursive || !(ps->magic & PATHSPEC_MAXDEPTH) || ps->max_depth == -1) return all_entries_interesting; return within_depth(base_str + matchlen + 1, baselen - matchlen - 1, !!S_ISDIR(entry->mode), ps->max_depth) ? entry_interesting : entry_not_interesting; } /* Either there must be no base, or the base must match. */ if (baselen == 0 || !basecmp(item, base_str, match, baselen)) { if (match_entry(item, entry, pathlen, match + baselen, matchlen - baselen, &never_interesting)) return entry_interesting; if (item->nowildcard_len < item->len) { if (!git_fnmatch(item, match + baselen, entry->path, item->nowildcard_len - baselen)) return entry_interesting; /* * Match all directories. We'll try to * match files later on. */ if (ps->recursive && S_ISDIR(entry->mode)) return entry_interesting; } continue; } match_wildcards: if (item->nowildcard_len == item->len) continue; if (item->nowildcard_len && !match_wildcard_base(item, base_str, baselen, &matched)) continue; /* * Concatenate base and entry->path into one and do * fnmatch() on it. * * While we could avoid concatenation in certain cases * [1], which saves a memcpy and potentially a * realloc, it turns out not worth it. Measurement on * linux-2.6 does not show any clear improvements, * partly because of the nowildcard_len optimization * in git_fnmatch(). Avoid micro-optimizations here. * * [1] if match_wildcard_base() says the base * directory is already matched, we only need to match * the rest, which is shorter so _in theory_ faster. */ strbuf_add(base, entry->path, pathlen); if (!git_fnmatch(item, match, base->buf + base_offset, item->nowildcard_len)) { strbuf_setlen(base, base_offset + baselen); return entry_interesting; } strbuf_setlen(base, base_offset + baselen); /* * Match all directories. We'll try to match files * later on. * max_depth is ignored but we may consider support it * in future, see * http://thread.gmane.org/gmane.comp.version-control.git/163757/focus=163840 */ if (ps->recursive && S_ISDIR(entry->mode)) return entry_interesting; } return never_interesting; /* No matches */ }
static int base_name_entries_compare(const struct name_entry *a, const struct name_entry *b) { return base_name_compare(a->path, tree_entry_len(a), a->mode, b->path, tree_entry_len(b), b->mode); }
static int read_tree_1(struct tree *tree, struct strbuf *base, int stage, const struct pathspec *pathspec, read_tree_fn_t fn, void *context) { struct tree_desc desc; struct name_entry entry; unsigned char sha1[20]; int len, oldlen = base->len; enum interesting retval = entry_not_interesting; if (parse_tree(tree)) return -1; init_tree_desc(&desc, tree->buffer, tree->size); while (tree_entry(&desc, &entry)) { if (retval != all_entries_interesting) { retval = tree_entry_interesting(&entry, base, 0, pathspec); if (retval == all_entries_not_interesting) break; if (retval == entry_not_interesting) continue; } switch (fn(entry.sha1, base, entry.path, entry.mode, stage, context)) { case 0: continue; case READ_TREE_RECURSIVE: break; default: return -1; } if (S_ISDIR(entry.mode)) hashcpy(sha1, entry.sha1); else if (S_ISGITLINK(entry.mode)) { struct commit *commit; commit = lookup_commit(entry.sha1); if (!commit) die("Commit %s in submodule path %s%s not found", sha1_to_hex(entry.sha1), base->buf, entry.path); if (parse_commit(commit)) die("Invalid commit %s in submodule path %s%s", sha1_to_hex(entry.sha1), base->buf, entry.path); hashcpy(sha1, commit->tree->object.sha1); } else continue; len = tree_entry_len(&entry); strbuf_add(base, entry.path, len); strbuf_addch(base, '/'); retval = read_tree_1(lookup_tree(sha1), base, stage, pathspec, fn, context); strbuf_setlen(base, oldlen); if (retval) return -1; } return 0; }
int traverse_trees(int n, struct tree_desc *t, struct traverse_info *info) { int ret = 0; struct name_entry *entry = xmalloc(n*sizeof(*entry)); int i; struct tree_desc_x *tx = xcalloc(n, sizeof(*tx)); for (i = 0; i < n; i++) tx[i].d = t[i]; for (;;) { unsigned long mask, dirmask; const char *first = NULL; int first_len = 0; struct name_entry *e; int len; for (i = 0; i < n; i++) { e = entry + i; extended_entry_extract(tx + i, e, NULL, 0); } /* * A tree may have "t-2" at the current location even * though it may have "t" that is a subtree behind it, * and another tree may return "t". We want to grab * all "t" from all trees to match in such a case. */ for (i = 0; i < n; i++) { e = entry + i; if (!e->path) continue; len = tree_entry_len(e->path, e->sha1); if (!first) { first = e->path; first_len = len; continue; } if (name_compare(e->path, len, first, first_len) < 0) { first = e->path; first_len = len; } } if (first) { for (i = 0; i < n; i++) { e = entry + i; extended_entry_extract(tx + i, e, first, first_len); /* Cull the ones that are not the earliest */ if (!e->path) continue; len = tree_entry_len(e->path, e->sha1); if (name_compare(e->path, len, first, first_len)) entry_clear(e); } } /* Now we have in entry[i] the earliest name from the trees */ mask = 0; dirmask = 0; for (i = 0; i < n; i++) { if (!entry[i].path) continue; mask |= 1ul << i; if (S_ISDIR(entry[i].mode)) dirmask |= 1ul << i; } if (!mask) break; ret = info->fn(n, mask, dirmask, entry, info); if (ret < 0) break; mask &= ret; ret = 0; for (i = 0; i < n; i++) if (mask & (1ul << i)) update_extended_entry(tx + i, entry + i); } free(entry); for (i = 0; i < n; i++) free_extended_entry(tx + i); free(tx); return ret; }
/* * new path should be added to combine diff * * 3 cases on how/when it should be called and behaves: * * t, !tp -> path added, all parents lack it * !t, tp -> path removed from all parents * t, tp -> path modified/added * (M for tp[i]=tp[imin], A otherwise) */ static struct combine_diff_path *emit_path(struct combine_diff_path *p, struct strbuf *base, struct diff_options *opt, int nparent, struct tree_desc *t, struct tree_desc *tp, int imin) { unsigned mode; const char *path; const unsigned char *sha1; int pathlen; int old_baselen = base->len; int i, isdir, recurse = 0, emitthis = 1; /* at least something has to be valid */ assert(t || tp); if (t) { /* path present in resulting tree */ sha1 = tree_entry_extract(t, &path, &mode)->hash; pathlen = tree_entry_len(&t->entry); isdir = S_ISDIR(mode); } else { /* * a path was removed - take path from imin parent. Also take * mode from that parent, to decide on recursion(1). * * 1) all modes for tp[i]=tp[imin] should be the same wrt * S_ISDIR, thanks to base_name_compare(). */ tree_entry_extract(&tp[imin], &path, &mode); pathlen = tree_entry_len(&tp[imin].entry); isdir = S_ISDIR(mode); sha1 = NULL; mode = 0; } if (DIFF_OPT_TST(opt, RECURSIVE) && isdir) { recurse = 1; emitthis = DIFF_OPT_TST(opt, TREE_IN_RECURSIVE); } if (emitthis) { int keep; struct combine_diff_path *pprev = p; p = path_appendnew(p, nparent, base, path, pathlen, mode, sha1); for (i = 0; i < nparent; ++i) { /* * tp[i] is valid, if present and if tp[i]==tp[imin] - * otherwise, we should ignore it. */ int tpi_valid = tp && !(tp[i].entry.mode & S_IFXMIN_NEQ); const unsigned char *sha1_i; unsigned mode_i; p->parent[i].status = !t ? DIFF_STATUS_DELETED : tpi_valid ? DIFF_STATUS_MODIFIED : DIFF_STATUS_ADDED; if (tpi_valid) { sha1_i = tp[i].entry.oid->hash; mode_i = tp[i].entry.mode; } else { sha1_i = NULL; mode_i = 0; } p->parent[i].mode = mode_i; hashcpy(p->parent[i].oid.hash, sha1_i ? sha1_i : null_sha1); } keep = 1; if (opt->pathchange) keep = opt->pathchange(opt, p); /* * If a path was filtered or consumed - we don't need to add it * to the list and can reuse its memory, leaving it as * pre-allocated element on the tail. * * On the other hand, if path needs to be kept, we need to * correct its .next to NULL, as it was pre-initialized to how * much memory was allocated. * * see path_appendnew() for details. */ if (!keep) p = pprev; else p->next = NULL; } if (recurse) { const unsigned char **parents_sha1; FAST_ARRAY_ALLOC(parents_sha1, nparent); for (i = 0; i < nparent; ++i) { /* same rule as in emitthis */ int tpi_valid = tp && !(tp[i].entry.mode & S_IFXMIN_NEQ); parents_sha1[i] = tpi_valid ? tp[i].entry.oid->hash : NULL; } strbuf_add(base, path, pathlen); strbuf_addch(base, '/'); p = ll_diff_tree_paths(p, sha1, parents_sha1, nparent, base, opt); FAST_ARRAY_FREE(parents_sha1, nparent); } strbuf_setlen(base, old_baselen); return p; }