mirror of
https://github.com/git/git.git
synced 2024-11-01 06:47:52 +01:00
9c5e6c802c
I attempted to make index_state->cache[] a "const struct cache_entry **"
to find out how existing entries in index are modified and where. The
question I have is what do we do if we really need to keep track of on-disk
changes in the index. The result is
- diff-lib.c: setting CE_UPTODATE
- name-hash.c: setting CE_HASHED
- preload-index.c, read-cache.c, unpack-trees.c and
builtin/update-index: obvious
- entry.c: write_entry() may refresh the checked out entry via
fill_stat_cache_info(). This causes "non-const struct cache_entry
*" in builtin/apply.c, builtin/checkout-index.c and
builtin/checkout.c
- builtin/ls-files.c: --with-tree changes stagemask and may set
CE_UPDATE
Of these, write_entry() and its call sites are probably most
interesting because it modifies on-disk info. But this is stat info
and can be retrieved via refresh, at least for porcelain
commands. Other just uses ce_flags for local purposes.
So, keeping track of "dirty" entries is just a matter of setting a
flag in index modification functions exposed by read-cache.c. Except
unpack-trees, the rest of the code base does not do anything funny
behind read-cache's back.
The actual patch is less valueable than the summary above. But if
anyone wants to re-identify the above sites. Applying this patch, then
this:
diff --git a/cache.h b/cache.h
index 430d021..1692891 100644
--- a/cache.h
+++ b/cache.h
@@ -267,7 +267,7 @@ static inline unsigned int canon_mode(unsigned int mode)
#define cache_entry_size(len) (offsetof(struct cache_entry,name) + (len) + 1)
struct index_state {
- struct cache_entry **cache;
+ const struct cache_entry **cache;
unsigned int version;
unsigned int cache_nr, cache_alloc, cache_changed;
struct string_list *resolve_undo;
will help quickly identify them without bogus warnings.
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
66 lines
1.5 KiB
C
66 lines
1.5 KiB
C
#include "cache.h"
|
|
#include "tree.h"
|
|
#include "cache-tree.h"
|
|
|
|
|
|
static void dump_one(struct cache_tree *it, const char *pfx, const char *x)
|
|
{
|
|
if (it->entry_count < 0)
|
|
printf("%-40s %s%s (%d subtrees)\n",
|
|
"invalid", x, pfx, it->subtree_nr);
|
|
else
|
|
printf("%s %s%s (%d entries, %d subtrees)\n",
|
|
sha1_to_hex(it->sha1), x, pfx,
|
|
it->entry_count, it->subtree_nr);
|
|
}
|
|
|
|
static int dump_cache_tree(struct cache_tree *it,
|
|
struct cache_tree *ref,
|
|
const char *pfx)
|
|
{
|
|
int i;
|
|
int errs = 0;
|
|
|
|
if (!it || !ref)
|
|
/* missing in either */
|
|
return 0;
|
|
|
|
if (it->entry_count < 0) {
|
|
dump_one(it, pfx, "");
|
|
dump_one(ref, pfx, "#(ref) ");
|
|
if (it->subtree_nr != ref->subtree_nr)
|
|
errs = 1;
|
|
}
|
|
else {
|
|
dump_one(it, pfx, "");
|
|
if (hashcmp(it->sha1, ref->sha1) ||
|
|
ref->entry_count != it->entry_count ||
|
|
ref->subtree_nr != it->subtree_nr) {
|
|
dump_one(ref, pfx, "#(ref) ");
|
|
errs = 1;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < it->subtree_nr; i++) {
|
|
char path[PATH_MAX];
|
|
struct cache_tree_sub *down = it->down[i];
|
|
struct cache_tree_sub *rdwn;
|
|
|
|
rdwn = cache_tree_sub(ref, down->name);
|
|
sprintf(path, "%s%.*s/", pfx, down->namelen, down->name);
|
|
if (dump_cache_tree(down->cache_tree, rdwn->cache_tree, path))
|
|
errs = 1;
|
|
}
|
|
return errs;
|
|
}
|
|
|
|
int main(int ac, char **av)
|
|
{
|
|
struct cache_tree *another = cache_tree();
|
|
if (read_cache() < 0)
|
|
die("unable to read index file");
|
|
cache_tree_update(another,
|
|
(const struct cache_entry * const *)active_cache,
|
|
active_nr, WRITE_TREE_DRY_RUN);
|
|
return dump_cache_tree(active_cache_tree, another, "");
|
|
}
|