[PATCH 12/20] untracked cache: load from UNTR index extension
FIXME: load check_only
---
dir.c | 107 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
dir.h | 1 +
read-cache.c | 3 ++
3 files changed, 111 insertions(+)
diff --git a/dir.c b/dir.c
index b7d394a..3c61b42 100644
--- a/dir.c
+++ b/dir.c
@@ -2256,3 +2256,110 @@ void write_untracked_extension(struct strbuf *out, struct untracked_cache *untra
if (untracked->root)
write_one_dir(out, untracked->root);
}
+
+static void stat_data_from_disk(struct stat_data *to, const struct stat_data *from)
+{
+ to->sd_ctime.sec = get_be32(&from->sd_ctime.sec);
+ to->sd_ctime.nsec = get_be32(&from->sd_ctime.nsec);
+ to->sd_mtime.sec = get_be32(&from->sd_mtime.sec);
+ to->sd_mtime.nsec = get_be32(&from->sd_mtime.nsec);
+ to->sd_dev = get_be32(&from->sd_dev);
+ to->sd_ino = get_be32(&from->sd_ino);
+ to->sd_uid = get_be32(&from->sd_uid);
+ to->sd_gid = get_be32(&from->sd_gid);
+ to->sd_size = get_be32(&from->sd_size);
+}
+
+static int read_one_dir(struct untracked_cache_dir **untracked_,
+ const unsigned char *data_, unsigned long sz)
+{
+#define NEXT(x) \
+ next = data + (x); \
+ if (next > data_ + sz) \
+ return -1;
+
+ struct untracked_cache_dir ud, *untracked;
+ const unsigned char *next, *data = data_;
+ unsigned int value;
+ int i, len;
+
+ memset(&ud, 0, sizeof(ud));
+ ud.recurse = 1;
+
+ NEXT(sizeof(struct stat_data));
+ stat_data_from_disk(&ud.stat_data, (struct stat_data *)data);
+ data = next;
+
+ NEXT(20);
+ hashcpy(ud.exclude_sha1, data);
+ data = next;
+
+ next = data;
+ value = decode_varint(&next);
+ if (next > data_ + sz)
+ return -1;
+ ud.untracked_alloc = ud.untracked_nr = value >> 2;
+ if (ud.untracked_nr)
+ ud.untracked = xmalloc(sizeof(*ud.untracked) * ud.untracked_nr);
+ if (value & 1)
+ ud.valid = 1;
+ if (value & 2)
+ ud.check_only = 1;
+ data = next;
+
+ next = data;
+ ud.dirs_alloc = ud.dirs_nr = decode_varint(&next);
+ if (next > data_ + sz)
+ return -1;
+ ud.dirs = xmalloc(sizeof(*ud.dirs) * ud.dirs_nr);
+ data = next;
+
+ len = strlen((const char *)data);
+ NEXT(len + 1);
+ *untracked_ = untracked = xmalloc(sizeof(*untracked) + len);
+ memcpy(untracked, &ud, sizeof(ud));
+ memcpy(untracked->name, data, len + 1);
+ data = next;
+
+ for (i = 0; i < untracked->untracked_nr; i++) {
+ len = strlen((const char *)data);
+ NEXT(len + 1);
+ untracked->untracked[i] = xstrdup((const char*)data);
+ data = next;
+ }
+
+ for (i = 0; i < untracked->dirs_nr; i++) {
+ len = read_one_dir(untracked->dirs + i, data, sz - (data - data_));
+ if (len < 0)
+ return -1;
+ data += len;
+ }
+ return data - data_;
+}
+
+struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz)
+{
+ const struct ondisk_untracked_cache *ouc = data;
+ struct untracked_cache *uc;
+ int len;
+
+ if (sz < sizeof(*ouc))
+ return NULL;
+
+ uc = xcalloc(1, sizeof(*uc));
+ stat_data_from_disk(&uc->info_exclude_stat, &ouc->info_exclude_stat);
+ stat_data_from_disk(&uc->excludes_file_stat, &ouc->excludes_file_stat);
+ hashcpy(uc->info_exclude_sha1, ouc->info_exclude_sha1);
+ hashcpy(uc->excludes_file_sha1, ouc->excludes_file_sha1);
+ uc->dir_flags = get_be32(&ouc->dir_flags);
+ uc->exclude_per_dir = xstrdup(ouc->exclude_per_dir);
+ len = sizeof(*ouc) + strlen(ouc->exclude_per_dir);
+ if (sz == len)
+ return uc;
+ if (sz > len &&
+ read_one_dir(&uc->root, (const unsigned char *)data + len,
+ sz - len) == sz - len)
+ return uc;
+ free(uc);
+ return NULL;
+}
diff --git a/dir.h b/dir.h
index e520d58..42a09ff 100644
--- a/dir.h
+++ b/dir.h
@@ -295,5 +295,6 @@ static inline int dir_path_match(const struct dir_entry *ent,
has_trailing_dir);
}
+struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz);
void write_untracked_extension(struct strbuf *out, struct untracked_cache *untracked);
#endif
diff --git a/read-cache.c b/read-cache.c
index a619666..c350b7b 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -1332,6 +1332,9 @@ static int read_index_extension(struct index_state *istate,
case CACHE_EXT_RESOLVE_UNDO:
istate->resolve_undo = resolve_undo_read(data, sz);
break;
+ case CACHE_EXT_UNTRACKED:
+ istate->untracked = read_untracked_extension(data, sz);
+ break;
default:
if (*ext < 'A' || 'Z' < *ext)
return error("index uses %.4s extension, which we do not understand",
--
1.9.1.346.ga2b5940
Nguyễn Thái Ngọc Duy <pclouds@gmail.com>