Make the cache management code behave more like a library. There are no longer any global variables in read-cache.c. Nothing ever uses more than one cache yet, but I can see how it might simplify some of the merge code. Signed-off-by: Brad Roberts <braddr@puremagic.com> --- cache.h | 36 +++------ check-files.c | 12 +-- checkout-cache.c | 22 +++--- diff-cache.c | 36 ++++----- merge-cache.c | 29 ++++--- read-cache.c | 200 ++++++++++++++++++++++++++++++++++++------------------- read-tree.c | 71 +++++++++++-------- show-diff.c | 19 +++-- show-files.c | 27 +++---- update-cache.c | 39 +++++----- write-tree.c | 24 +++--- 11 files changed, 292 insertions(+), 223 deletions(-) Index: cache.h =================================================================== --- c0260bfb82da04aeff4e598ced5295d6ae2e262d/cache.h (mode:100644 sha1:828d660ab82bb35a1ca632a2ba4620dc483889bd) +++ 38adb888a4c1adfe083f24d4ec51018e0b5a8335/cache.h (mode:100644 sha1:d8ade9f4b9bd9b6045f97b4df5bef8356c767d46) @@ -17,21 +17,6 @@ #include <zlib.h> /* - * Basic data structures for the directory cache - * - * NOTE NOTE NOTE! This is all in the native CPU byte format. It's - * not even trying to be portable. It's trying to be efficient. It's - * just a cache, after all. - */ - -#define CACHE_SIGNATURE 0x44495243 /* "DIRC" */ -struct cache_header { - unsigned int hdr_signature; - unsigned int hdr_version; - unsigned int hdr_entries; -}; - -/* * The "cache_time" is just the low 32 bits of the * time. It doesn't matter if it overflows - we only * check it for equality in the 32 bits we save. @@ -67,6 +52,8 @@ #define CE_STAGEMASK (0x3000) #define CE_STAGESHIFT 12 +extern int ce_match_stat(struct cache_entry *ce, struct stat *st); + #define create_ce_flags(len, stage) htons((len) | ((stage) << CE_STAGESHIFT)) #define ce_namelen(ce) (CE_NAMEMASK & ntohs((ce)->ce_flags)) #define ce_size(ce) cache_entry_size(ce_namelen(ce)) @@ -78,8 +65,6 @@ #define cache_entry_size(len) ((offsetof(struct cache_entry,name) + (len) + 8) & ~7) const char *sha1_file_directory; -struct cache_entry **active_cache; -unsigned int active_nr, active_alloc; #define DB_ENVIRONMENT "SHA1_FILE_DIRECTORY" #define DEFAULT_DB_ENVIRONMENT ".git/objects" @@ -87,12 +72,17 @@ #define alloc_nr(x) (((x)+16)*3/2) /* Initialize and use the cache information */ -extern int read_cache(void); -extern int write_cache(int newfd, struct cache_entry **cache, int entries); -extern int cache_name_pos(const char *name, int namelen); -extern int add_cache_entry(struct cache_entry *ce, int ok_to_add); -extern int remove_file_from_cache(char *path); -extern int cache_match_stat(struct cache_entry *ce, struct stat *st); +extern struct cache *new_cache(void); +extern struct cache *read_cache(void); +extern int write_cache(struct cache *cache, int newfd); +extern void free_cache(struct cache *cache); +extern int cache_name_pos(struct cache *cache, const char *name, int namelen); +extern int add_cache_entry(struct cache *cache, struct cache_entry *ce, int ok_to_add); +extern int remove_file_from_cache(struct cache *cache, char *path); +extern int get_num_cache_entries(struct cache *cache); +extern struct cache_entry * get_cache_entry(struct cache *cache, int pos); +extern void set_cache_entry(struct cache *cache, struct cache_entry *ce, int pos); +extern int remove_cache_entry_at(struct cache *cache, int pos); #define MTIME_CHANGED 0x0001 #define CTIME_CHANGED 0x0002 Index: check-files.c =================================================================== --- c0260bfb82da04aeff4e598ced5295d6ae2e262d/check-files.c (mode:100644 sha1:7d16691aa9d51b5b4670d5837b3527ee7c7da79c) +++ 38adb888a4c1adfe083f24d4ec51018e0b5a8335/check-files.c (mode:100644 sha1:4de6d39e4997d29f13261c21eeb378f74b3f8a8f) @@ -8,7 +8,7 @@ */ #include "cache.h" -static void check_file(const char *path) +static void check_file(struct cache *cache, const char *path) { int fd = open(path, O_RDONLY); struct cache_entry *ce; @@ -23,15 +23,15 @@ } /* Exists but is not in the cache is not fine */ - pos = cache_name_pos(path, strlen(path)); + pos = cache_name_pos(cache, path, strlen(path)); if (pos < 0) die("preparing to update existing file '%s' not in cache", path); - ce = active_cache[pos]; + ce = get_cache_entry(cache, pos); if (fstat(fd, &st) < 0) die("fstat(%s): %s", path, strerror(errno)); - changed = cache_match_stat(ce, &st); + changed = ce_match_stat(ce, &st); if (changed) die("preparing to update file '%s' not uptodate in cache", path); } @@ -39,9 +39,9 @@ int main(int argc, char **argv) { int i; + struct cache *cache = read_cache(); - read_cache(); for (i = 1; i < argc ; i++) - check_file(argv[i]); + check_file(cache, argv[i]); return 0; } Index: checkout-cache.c =================================================================== --- c0260bfb82da04aeff4e598ced5295d6ae2e262d/checkout-cache.c (mode:100644 sha1:8bf86016b5d5fd88a52ce694fc59bb9ecb550d22) +++ 38adb888a4c1adfe083f24d4ec51018e0b5a8335/checkout-cache.c (mode:100644 sha1:2e8c61323a72f6052d8c9ef76a4eef05aa5ac0f9) @@ -100,7 +100,7 @@ struct stat st; if (!stat(ce->name, &st)) { - unsigned changed = cache_match_stat(ce, &st); + unsigned changed = ce_match_stat(ce, &st); if (!changed) return 0; if (!force) { @@ -120,23 +120,23 @@ return write_entry(ce); } -static int checkout_file(const char *name) +static int checkout_file(struct cache *cache, const char *name) { - int pos = cache_name_pos(name, strlen(name)); + int pos = cache_name_pos(cache, name, strlen(name)); if (pos < 0) { if (!quiet) fprintf(stderr, "checkout-cache: %s is not in the cache\n", name); return -1; } - return checkout_entry(active_cache[pos]); + return checkout_entry(get_cache_entry(cache, pos)); } -static int checkout_all(void) +static int checkout_all(struct cache *cache) { int i; - for (i = 0; i < active_nr ; i++) { - struct cache_entry *ce = active_cache[i]; + for (i = 0; i < get_num_cache_entries(cache) ; i++) { + struct cache_entry *ce = get_cache_entry(cache, i); if (ce_stage(ce)) continue; if (checkout_entry(ce) < 0) @@ -149,15 +149,15 @@ { int i, force_filename = 0; - if (read_cache() < 0) { + struct cache * cache = read_cache(); + if (!cache) die("invalid cache"); - } for (i = 1; i < argc; i++) { const char *arg = argv[i]; if (!force_filename) { if (!strcmp(arg, "-a")) { - checkout_all(); + checkout_all(cache); continue; } if (!strcmp(arg, "--")) { @@ -173,7 +173,7 @@ continue; } } - checkout_file(arg); + checkout_file(cache, arg); } return 0; } Index: diff-cache.c =================================================================== --- c0260bfb82da04aeff4e598ced5295d6ae2e262d/diff-cache.c (mode:100644 sha1:fcbc4900d32f4ca24f67bb8f0fe344c6c5642ac9) +++ 38adb888a4c1adfe083f24d4ec51018e0b5a8335/diff-cache.c (mode:100644 sha1:1d39ca1f79d841e363a4be57871a5c1282d441e1) @@ -4,7 +4,7 @@ static int recursive = 0; static int line_termination = '\n'; -static int diff_cache(void *tree, unsigned long size, struct cache_entry **ac, int entries, const char *base); +static int diff_cache(void *tree, unsigned long size, struct cache *cache, int pos, const char *base); static void update_tree_entry(void **bufp, unsigned long *sizep) { @@ -82,10 +82,10 @@ } static int compare_tree_entry(const char *path1, unsigned int mode1, const unsigned char *sha1, - struct cache_entry **ac, int *entries, const char *base) + struct cache *cache, int *pos, const char *base) { int baselen = strlen(base); - struct cache_entry *ce = *ac; + struct cache_entry *ce = get_cache_entry(cache, *pos); const char *path2 = ce->name + baselen; unsigned int mode2 = ntohl(ce->ce_mode); const unsigned char *sha2 = ce->sha1; @@ -107,7 +107,7 @@ memcpy(newbase + baselen + pathlen1, "/", 2); if (!tree || strcmp(type, "tree")) die("unable to read tree object %s", sha1_to_hex(sha1)); - *entries = diff_cache(tree, size, ac, *entries, newbase); + *pos = diff_cache(tree, size, cache, *pos, newbase); free(newbase); free(tree); return -1; @@ -125,7 +125,7 @@ show_file("-", path1, mode1, sha1, base); return -1; } - changed = cache_match_stat(ce, &st); + changed = ce_match_stat(ce, &st); close(fd); if (changed) { mode2 = st.st_mode; @@ -158,7 +158,7 @@ return 0; } -static int diff_cache(void *tree, unsigned long size, struct cache_entry **ac, int entries, const char *base) +static int diff_cache(void *tree, unsigned long size, struct cache *cache, int pos, const char *base) { int baselen = strlen(base); @@ -167,15 +167,16 @@ unsigned int mode; const char *path; const unsigned char *sha1; - int left; /* * No entries in the cache (with this base)? * Output the tree contents. */ - if (!entries || ce_namelen(ce = *ac) < baselen || memcmp(ce->name, base, baselen)) { + if ((pos == get_num_cache_entries(cache)) || + ce_namelen(ce = get_cache_entry(cache, pos)) < baselen || + memcmp(ce->name, base, baselen)) { if (!size) - return entries; + return pos; sha1 = extract(tree, size, &path, &mode); show_file("-", path, mode, sha1, base); update_tree_entry(&tree, &size); @@ -187,27 +188,20 @@ */ if (!size) { show_file("+", ce->name, ntohl(ce->ce_mode), ce->sha1, ""); - ac++; - entries--; + pos++; continue; } sha1 = extract(tree, size, &path, &mode); - left = entries; - switch (compare_tree_entry(path, mode, sha1, ac, &left, base)) { + switch (compare_tree_entry(path, mode, sha1, cache, &pos, base)) { case -1: update_tree_entry(&tree, &size); - if (left < entries) { - ac += (entries - left); - entries = left; - } continue; case 0: update_tree_entry(&tree, &size); /* Fallthrough */ case 1: - ac++; - entries--; + pos++; continue; } die("diff-cache: internal error"); @@ -221,8 +215,8 @@ void *tree; unsigned long size; char type[20]; + struct cache *cache = read_cache(); - read_cache(); while (argc > 2) { char *arg = argv[1]; argv++; @@ -263,5 +257,5 @@ if (strcmp(type, "tree")) die("bad tree object %s (%s)", sha1_to_hex(tree_sha1), type); - return diff_cache(tree, size, active_cache, active_nr, ""); + return diff_cache(tree, size, cache, 0, ""); } Index: merge-cache.c =================================================================== --- c0260bfb82da04aeff4e598ced5295d6ae2e262d/merge-cache.c (mode:100644 sha1:35a0d588178aa5371399458b1a15519cffd645b8) +++ 38adb888a4c1adfe083f24d4ec51018e0b5a8335/merge-cache.c (mode:100644 sha1:440d4d6e98d1387c5055ba5539b829e7557d9d4a) @@ -26,11 +26,11 @@ err = 1; } -static int merge_entry(int pos, const char *path) +static int merge_entry(struct cache *cache, int pos, const char *path) { int found; - if (pos >= active_nr) + if (pos >= get_num_cache_entries(cache)) die("merge-cache: %s not in the cache", path); arguments[0] = pgm; arguments[1] = ""; @@ -40,7 +40,7 @@ found = 0; do { static char hexbuf[4][60]; - struct cache_entry *ce = active_cache[pos]; + struct cache_entry *ce = get_cache_entry(cache, pos); int stage = ce_stage(ce); if (strcmp(ce->name, path)) @@ -48,44 +48,45 @@ found++; strcpy(hexbuf[stage], sha1_to_hex(ce->sha1)); arguments[stage] = hexbuf[stage]; - } while (++pos < active_nr); + } while (++pos < get_num_cache_entries(cache)); if (!found) die("merge-cache: %s not in the cache", path); run_program(); return found; } -static void merge_file(const char *path) +static void merge_file(struct cache *cache, const char *path) { - int pos = cache_name_pos(path, strlen(path)); + int pos = cache_name_pos(cache, path, strlen(path)); /* * If it already exists in the cache as stage0, it's * already merged and there is nothing to do. */ if (pos < 0) - merge_entry(-pos-1, path); + merge_entry(cache, -pos-1, path); } -static void merge_all(void) +static void merge_all(struct cache *cache) { int i; - for (i = 0; i < active_nr; i++) { - struct cache_entry *ce = active_cache[i]; + for (i = 0; i < get_num_cache_entries(cache); i++) { + struct cache_entry *ce = get_cache_entry(cache, i); if (!ce_stage(ce)) continue; - i += merge_entry(i, ce->name)-1; + i += merge_entry(cache, i, ce->name)-1; } } int main(int argc, char **argv) { int i, force_file = 0; + struct cache *cache; if (argc < 3) usage("merge-cache <merge-program> (-a | <filename>*)"); - read_cache(); + cache = read_cache(); pgm = argv[1]; for (i = 2; i < argc; i++) { @@ -96,12 +97,12 @@ continue; } if (!strcmp(arg, "-a")) { - merge_all(); + merge_all(cache); continue; } die("merge-cache: unknown option %s", arg); } - merge_file(arg); + merge_file(cache, arg); } if (err) die("merge program failed"); Index: read-cache.c =================================================================== --- c0260bfb82da04aeff4e598ced5295d6ae2e262d/read-cache.c (mode:100644 sha1:2f6a4aa18d48865db80459a3459ac4384b0b16c8) +++ 38adb888a4c1adfe083f24d4ec51018e0b5a8335/read-cache.c (mode:100644 sha1:7084fcdf771ddc5bfac38b8778a5904d779de3a4) @@ -6,10 +6,42 @@ #include <stdarg.h> #include "cache.h" -struct cache_entry **active_cache = NULL; -unsigned int active_nr = 0, active_alloc = 0; +/* + * Basic data structures for the directory cache + */ -int cache_match_stat(struct cache_entry *ce, struct stat *st) +#define CACHE_SIGNATURE 0x44495243 /* "DIRC" */ +struct cache_header { + unsigned int hdr_signature; + unsigned int hdr_version; + unsigned int hdr_entries; +}; + +struct mmap_holder { + void * ptr; + size_t size; +}; + +struct cache { + struct mmap_holder map; + struct cache_header *header; + struct cache_entry **entries; + unsigned int num_entries; + unsigned int allocated_entries; +}; + +struct cache * new_cache() +{ + return (struct cache*)calloc(1, sizeof(struct cache)); +} + +void free_cache(struct cache *cache) +{ + munmap(cache->map.ptr, cache->map.size); + free(cache); +} + +int ce_match_stat(struct cache_entry *ce, struct stat *st) { unsigned int changed = 0; @@ -65,15 +97,15 @@ return 0; } -int cache_name_pos(const char *name, int namelen) +int cache_name_pos(struct cache *cache, const char *name, int namelen) { int first, last; first = 0; - last = active_nr; + last = cache->num_entries; while (last > first) { int next = (last + first) >> 1; - struct cache_entry *ce = active_cache[next]; + struct cache_entry *ce = cache->entries[next]; int cmp = cache_name_compare(name, namelen, ce->name, htons(ce->ce_flags)); if (!cmp) return next; @@ -87,20 +119,20 @@ } /* Remove entry, return true if there are more entries to go.. */ -static int remove_entry_at(int pos) +int remove_cache_entry_at(struct cache *cache, int pos) { - active_nr--; - if (pos >= active_nr) + cache->num_entries--; + if (pos >= cache->num_entries) return 0; - memmove(active_cache + pos, active_cache + pos + 1, (active_nr - pos) * sizeof(struct cache_entry *)); + memmove(cache->entries + pos, cache->entries + pos + 1, (cache->num_entries - pos) * sizeof(struct cache_entry *)); return 1; } -int remove_file_from_cache(char *path) +int remove_file_from_cache(struct cache *cache, char *path) { - int pos = cache_name_pos(path, strlen(path)); + int pos = cache_name_pos(cache, path, strlen(path)); if (pos >= 0) - remove_entry_at(pos); + remove_cache_entry_at(cache, pos); return 0; } @@ -110,15 +142,33 @@ return ce_namelen(b) == len && !memcmp(a->name, b->name, len); } -int add_cache_entry(struct cache_entry *ce, int ok_to_add) +int get_num_cache_entries(struct cache *cache) +{ + return cache->num_entries; +} + +struct cache_entry * get_cache_entry(struct cache *cache, int pos) +{ + return cache->entries[pos]; +} + +void set_cache_entry(struct cache *cache, struct cache_entry *ce, int pos) +{ + /* You can NOT just free cache->entries[i] here, since it + * might not be necessarily malloc()ed but can also come + * from mmap(). */ + cache->entries[pos] = ce; +} + +int add_cache_entry(struct cache *cache, struct cache_entry *ce, int ok_to_add) { int pos; - pos = cache_name_pos(ce->name, htons(ce->ce_flags)); + pos = cache_name_pos(cache, ce->name, htons(ce->ce_flags)); /* existing match? Just replace it */ if (pos >= 0) { - active_cache[pos] = ce; + cache->entries[pos] = ce; return 0; } pos = -pos-1; @@ -127,10 +177,10 @@ * Inserting a merged entry ("stage 0") into the index * will always replace all non-merged entries.. */ - if (pos < active_nr && ce_stage(ce) == 0) { - while (same_name(active_cache[pos], ce)) { + if (pos < cache->num_entries && ce_stage(ce) == 0) { + while (same_name(cache->entries[pos], ce)) { ok_to_add = 1; - if (!remove_entry_at(pos)) + if (!remove_cache_entry_at(cache, pos)) break; } } @@ -139,16 +189,16 @@ return -1; /* Make sure the array is big enough .. */ - if (active_nr == active_alloc) { - active_alloc = alloc_nr(active_alloc); - active_cache = realloc(active_cache, active_alloc * sizeof(struct cache_entry *)); + if (cache->num_entries == cache->allocated_entries) { + cache->allocated_entries = alloc_nr(cache->allocated_entries); + cache->entries = realloc(cache->entries, cache->allocated_entries * sizeof(struct cache_entry *)); } /* Add it in.. */ - active_nr++; - if (active_nr > pos) - memmove(active_cache + pos + 1, active_cache + pos, (active_nr - pos - 1) * sizeof(ce)); - active_cache[pos] = ce; + cache->num_entries++; + if (cache->num_entries > pos) + memmove(cache->entries + pos + 1, cache->entries + pos, (cache->num_entries - pos - 1) * sizeof(ce)); + cache->entries[pos] = ce; return 0; } @@ -169,59 +219,75 @@ return 0; } -int read_cache(void) +struct cache *read_cache(void) { int fd, i; struct stat st; - unsigned long size, offset; - void *map; - struct cache_header *hdr; - - errno = EBUSY; - if (active_cache) - return error("more than one cachefile"); + unsigned long offset; + struct cache *cache; + + cache = new_cache(); + if (!cache) { + errno = ENOMEM; + error("unable to allocate cache"); + return NULL; + } + errno = ENOENT; sha1_file_directory = getenv(DB_ENVIRONMENT); if (!sha1_file_directory) sha1_file_directory = DEFAULT_DB_ENVIRONMENT; - if (access(sha1_file_directory, X_OK) < 0) - return error("no access to SHA1 file directory"); + if (access(sha1_file_directory, X_OK) < 0) { + error("no access to SHA1 file directory"); + free(cache); + return NULL; + } fd = open(".git/index", O_RDONLY); - if (fd < 0) - return (errno == ENOENT) ? 0 : error("open failed"); + if (fd < 0) { + /* TODO: Why special case this? If we can't get to the data, what's the point? */ + if (errno == ENOENT) + return cache; + else { + error("open failed"); + free(cache); + return NULL; + } + } - size = 0; /* avoid gcc warning */ - map = (void *)-1; + cache->map.size = 0; /* avoid gcc warning */ + cache->map.ptr = (void *)-1; if (!fstat(fd, &st)) { - size = st.st_size; + cache->map.size = st.st_size; errno = EINVAL; - if (size >= sizeof(struct cache_header) + 20) - map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); + if (cache->map.size >= sizeof(struct cache_header) + 20) + cache->map.ptr = mmap(NULL, cache->map.size, PROT_READ, MAP_PRIVATE, fd, 0); } close(fd); - if (-1 == (int)(long)map) - return error("mmap failed"); + if (-1 == (int)(long)cache->map.ptr) { + error("mmap failed"); + free(cache); + return NULL; + } - hdr = map; - if (verify_hdr(hdr, size) < 0) - goto unmap; - - active_nr = ntohl(hdr->hdr_entries); - active_alloc = alloc_nr(active_nr); - active_cache = calloc(active_alloc, sizeof(struct cache_entry *)); - - offset = sizeof(*hdr); - for (i = 0; i < active_nr; i++) { - struct cache_entry *ce = map + offset; - offset = offset + ce_size(ce); - active_cache[i] = ce; + cache->header = cache->map.ptr; + if (verify_hdr(cache->header, cache->map.size) < 0) { + free_cache(cache); + errno = EINVAL; + error("verify header failed"); + return NULL; } - return active_nr; -unmap: - munmap(map, size); - errno = EINVAL; - return error("verify header failed"); + cache->num_entries = ntohl(cache->header->hdr_entries); + cache->allocated_entries = alloc_nr(cache->num_entries); + cache->entries = calloc(cache->allocated_entries, sizeof(struct cache_entry *)); + + offset = sizeof(*cache->header); + for (i = 0; i < cache->num_entries; i++) { + struct cache_entry *ce = cache->map.ptr + offset; + offset = offset + ce_size(ce); + cache->entries[i] = ce; + } + return cache; } #define WRITE_BUFFER_SIZE 8192 @@ -267,7 +333,7 @@ return 0; } -int write_cache(int newfd, struct cache_entry **cache, int entries) +int write_cache(struct cache *cache, int newfd) { SHA_CTX c; struct cache_header hdr; @@ -275,14 +341,14 @@ hdr.hdr_signature = htonl(CACHE_SIGNATURE); hdr.hdr_version = htonl(2); - hdr.hdr_entries = htonl(entries); + hdr.hdr_entries = htonl(cache->num_entries); SHA1_Init(&c); if (ce_write(&c, newfd, &hdr, sizeof(hdr)) < 0) return -1; - for (i = 0; i < entries; i++) { - struct cache_entry *ce = cache[i]; + for (i = 0; i < cache->num_entries; i++) { + struct cache_entry *ce = cache->entries[i]; if (ce_write(&c, newfd, ce, ce_size(ce)) < 0) return -1; } Index: read-tree.c =================================================================== --- c0260bfb82da04aeff4e598ced5295d6ae2e262d/read-tree.c (mode:100644 sha1:620f3f74eb56366fca8be4d28d7b04875c0fa90c) +++ 38adb888a4c1adfe083f24d4ec51018e0b5a8335/read-tree.c (mode:100644 sha1:a683b7f60e58514d36218a7b2c2ace2d3ec9f984) @@ -7,7 +7,7 @@ static int stage = 0; -static int read_one_entry(unsigned char *sha1, const char *base, int baselen, const char *pathname, unsigned mode) +static int read_one_entry(struct cache *cache, unsigned char *sha1, const char *base, int baselen, const char *pathname, unsigned mode) { int len = strlen(pathname); unsigned int size = cache_entry_size(baselen + len); @@ -20,10 +20,10 @@ memcpy(ce->name, base, baselen); memcpy(ce->name + baselen, pathname, len+1); memcpy(ce->sha1, sha1, 20); - return add_cache_entry(ce, 1); + return add_cache_entry(cache, ce, 1); } -static int read_tree(unsigned char *sha1, const char *base, int baselen) +static int read_tree(struct cache *cache, unsigned char *sha1, const char *base, int baselen) { void *buffer, *bufptr; unsigned long size; @@ -57,7 +57,7 @@ memcpy(newbase, base, baselen); memcpy(newbase + baselen, path, pathlen); newbase[baselen + pathlen] = '/'; - retval = read_tree(sha1, newbase, baselen + pathlen + 1); + retval = read_tree(cache, sha1, newbase, baselen + pathlen + 1); free(newbase); if (retval) { free(buffer); @@ -65,7 +65,7 @@ } continue; } - if (read_one_entry(sha1, base, baselen, path, mode) < 0) { + if (read_one_entry(cache, sha1, base, baselen, path, mode) < 0) { free(buffer); return -1; } @@ -146,26 +146,30 @@ return NULL; } -static void trivially_merge_cache(struct cache_entry **src, int nr) +/* rather than doing the 'right' thing of deleting entries as we merge, + * walk dst through the cache, overwriting entries as we go and at the + * end truncate the size of the cache */ +static void trivially_merge_cache(struct cache *cache) { static struct cache_entry null_entry; - struct cache_entry **dst = src; struct cache_entry *old = &null_entry; + int src = 0, dst = 0, nr = get_num_cache_entries(cache); - while (nr) { + while (src < nr) { struct cache_entry *ce, *result; - ce = src[0]; + ce = get_cache_entry(cache, src); /* We throw away original cache entries except for the stat information */ if (!ce_stage(ce)) { old = ce; src++; - nr--; - active_nr--; continue; } - if (nr > 2 && (result = merge_entries(ce, src[1], src[2])) != NULL) { + if ((src < (nr - 2)) && + (result = merge_entries(ce, + get_cache_entry(cache, src + 1), + get_cache_entry(cache, src + 2))) != NULL) { /* * See if we can re-use the old CE directly? * That way we get the uptodate stat info. @@ -175,40 +179,46 @@ ce = result; ce->ce_flags &= ~htons(CE_STAGEMASK); src += 2; - nr -= 2; - active_nr -= 2; } - *dst++ = ce; + set_cache_entry(cache, ce, dst); + dst++; src++; + } + /* this could be replaced by a truncate api */ + while (nr > dst) { nr--; + remove_cache_entry_at(cache, nr); } } -static void merge_stat_info(struct cache_entry **src, int nr) +static void merge_stat_info(struct cache *cache) { static struct cache_entry null_entry; - struct cache_entry **dst = src; struct cache_entry *old = &null_entry; + int src = 0, dst = 0, nr = get_num_cache_entries(cache); - while (nr) { + while (src < nr) { struct cache_entry *ce; - ce = src[0]; + ce = get_cache_entry(cache, src); /* We throw away original cache entries except for the stat information */ if (!ce_stage(ce)) { old = ce; src++; - nr--; - active_nr--; continue; } if (path_matches(ce, old) && same(ce, old)) *ce = *old; ce->ce_flags &= ~htons(CE_STAGEMASK); - *dst++ = ce; + set_cache_entry(cache, ce, dst); + dst++; src++; + } + /* this could be replaced by a truncate api */ + while (nr > dst) { nr--; + remove_cache_entry_at(cache, nr); } } @@ -216,6 +226,7 @@ { int i, newfd, merge; unsigned char sha1[20]; + struct cache *cache = NULL; newfd = open(".git/index.lock", O_RDWR | O_CREAT | O_EXCL, 0600); if (newfd < 0) @@ -232,9 +243,9 @@ int i; if (stage) usage("-m needs to come first"); - read_cache(); - for (i = 0; i < active_nr; i++) { - if (ce_stage(active_cache[i])) + cache = read_cache(); + for (i = 0; i < get_num_cache_entries(cache); i++) { + if (ce_stage(get_cache_entry(cache, i))) usage("you need to resolve your current index first"); } stage = 1; @@ -245,23 +256,25 @@ usage("read-tree [-m] <sha1>"); if (stage > 3) usage("can't merge more than two trees"); - if (read_tree(sha1, "", 0) < 0) + if (!cache) + cache = new_cache(); + if (read_tree(cache, sha1, "", 0) < 0) die("failed to unpack tree object %s", arg); stage++; } if (merge) { switch (stage) { case 4: /* Three-way merge */ - trivially_merge_cache(active_cache, active_nr); + trivially_merge_cache(cache); break; case 2: /* Just read a tree, merge with old cache contents */ - merge_stat_info(active_cache, active_nr); + merge_stat_info(cache); break; default: die("just how do you expect me to merge %d trees?", stage-1); } } - if (write_cache(newfd, active_cache, active_nr) || + if (write_cache(cache, newfd) || rename(".git/index.lock", ".git/index")) die("unable to write new index file"); remove_lock = 0; Index: show-diff.c =================================================================== --- c0260bfb82da04aeff4e598ced5295d6ae2e262d/show-diff.c (mode:100644 sha1:da364e26e28823f951a6be1b686a458575f28ea1) +++ 38adb888a4c1adfe083f24d4ec51018e0b5a8335/show-diff.c (mode:100644 sha1:d61bf6dea8106599c25ac5071743b351f6e000ce) @@ -126,9 +126,16 @@ int silent_on_nonexisting_files = 0; int machine_readable = 0; int reverse = 0; - int entries = read_cache(); + int entries; int matched = 0; int i; + struct cache *cache = read_cache(); + + entries = get_num_cache_entries(cache); + if (entries < 0) { + perror("read_cache"); + exit(1); + } while (1 < argc && argv[1][0] == '-') { if (!strcmp(argv[1], "-R")) @@ -147,14 +154,10 @@ /* At this point, if argc == 1, then we are doing everything. * Otherwise argv[1] .. argv[argc-1] have the explicit paths. */ - if (entries < 0) { - perror("read_cache"); - exit(1); - } prepare_diff_cmd(); for (i = 0; i < entries; i++) { struct stat st; - struct cache_entry *ce = active_cache[i]; + struct cache_entry *ce = get_cache_entry(cache, i); int changed; unsigned long size; char type[20]; @@ -172,7 +175,7 @@ printf("%s: Unmerged\n", ce->name); while (i < entries && - !strcmp(ce->name, active_cache[i]->name)) + !strcmp(ce->name, get_cache_entry(cache, i)->name)) i++; i--; /* compensate for loop control increments */ continue; @@ -190,7 +193,7 @@ } continue; } - changed = cache_match_stat(ce, &st); + changed = ce_match_stat(ce, &st); if (!changed) continue; if (!machine_readable) Index: show-files.c =================================================================== --- c0260bfb82da04aeff4e598ced5295d6ae2e262d/show-files.c (mode:100644 sha1:0b49ca051de413e7182445dd8fb9144125716974) +++ 38adb888a4c1adfe083f24d4ec51018e0b5a8335/show-files.c (mode:100644 sha1:c8dc21d0dd3f5db3f7016323859c58449968d800) @@ -27,11 +27,11 @@ static int nr_dir; static int dir_alloc; -static void add_name(const char *pathname, int len) +static void add_name(struct cache *cache, const char *pathname, int len) { char *name; - if (cache_name_pos(pathname, len) >= 0) + if (cache_name_pos(cache, pathname, len) >= 0) return; if (nr_dir == dir_alloc) { @@ -51,7 +51,7 @@ * Also, we currently ignore all names starting with a dot. * That likely will not change. */ -static void read_directory(const char *path, const char *base, int baselen) +static void read_directory(struct cache *cache, const char *path, const char *base, int baselen) { DIR *dir = opendir(path); @@ -82,12 +82,12 @@ /* fallthrough */ case DT_DIR: memcpy(fullname + baselen + len, "/", 2); - read_directory(fullname, fullname, baselen + len + 1); + read_directory(cache, fullname, fullname, baselen + len + 1); continue; case DT_REG: break; } - add_name(fullname, baselen + len); + add_name(cache, fullname, baselen + len); } closedir(dir); } @@ -102,13 +102,13 @@ return cache_name_compare(n1, l1, n2, l2); } -static void show_files(void) +static void show_files(struct cache *cache) { int i; /* For cached/deleted files we don't need to even do the readdir */ if (show_others | show_ignored) { - read_directory(".", "", 0); + read_directory(cache, ".", "", 0); qsort(dir, nr_dir, sizeof(char *), cmp_name); } if (show_others) { @@ -116,8 +116,8 @@ printf("%s%s%c", tag_other, dir[i], line_terminator); } if (show_cached | show_stage) { - for (i = 0; i < active_nr; i++) { - struct cache_entry *ce = active_cache[i]; + for (i = 0; i < get_num_cache_entries(cache); i++) { + struct cache_entry *ce = get_cache_entry(cache, i); if (show_unmerged && !ce_stage(ce)) continue; if (!show_stage) @@ -136,8 +136,8 @@ } } if (show_deleted) { - for (i = 0; i < active_nr; i++) { - struct cache_entry *ce = active_cache[i]; + for (i = 0; i < get_num_cache_entries(cache); i++) { + struct cache_entry *ce = get_cache_entry(cache, i); struct stat st; if (!stat(ce->name, &st)) continue; @@ -152,6 +152,7 @@ int main(int argc, char **argv) { int i; + struct cache *cache; for (i = 1; i < argc; i++) { char *arg = argv[i]; @@ -202,7 +203,7 @@ if (!(show_stage | show_deleted | show_others | show_ignored | show_unmerged)) show_cached = 1; - read_cache(); - show_files(); + cache = read_cache(); + show_files(cache); return 0; } Index: update-cache.c =================================================================== --- c0260bfb82da04aeff4e598ced5295d6ae2e262d/update-cache.c (mode:100644 sha1:a09883541c745c76413c62109a80f40df4b7a7fb) +++ 38adb888a4c1adfe083f24d4ec51018e0b5a8335/update-cache.c (mode:100644 sha1:565638acd2380023ea69e82316a7ab77d95d8ee7) @@ -85,7 +85,7 @@ ce->ce_size = htonl(st->st_size); } -static int add_file_to_cache(char *path) +static int add_file_to_cache(struct cache *cache, char *path) { int size, namelen; struct cache_entry *ce; @@ -96,7 +96,7 @@ if (fd < 0) { if (errno == ENOENT) { if (allow_remove) - return remove_file_from_cache(path); + return remove_file_from_cache(cache, path); } return -1; } @@ -117,7 +117,7 @@ free(ce); return -1; } - if (add_cache_entry(ce, allow_add)) { + if (add_cache_entry(cache, ce, allow_add)) { free(ce); return -1; } @@ -179,7 +179,7 @@ if (stat(ce->name, &st) < 0) return NULL; - changed = cache_match_stat(ce, &st); + changed = ce_match_stat(ce, &st); if (!changed) return ce; @@ -200,17 +200,17 @@ return updated; } -static void refresh_cache(void) +static void refresh_cache(struct cache *cache) { int i; - for (i = 0; i < active_nr; i++) { + for (i = 0; i < get_num_cache_entries(cache); i++) { struct cache_entry *ce, *new; - ce = active_cache[i]; + ce = get_cache_entry(cache, i); if (ce_stage(ce)) { printf("%s: needs merge\n", ce->name); - while ((i < active_nr) && - ! strcmp(active_cache[i]->name, ce->name)) + while ((i < get_num_cache_entries(cache)) && + ! strcmp(get_cache_entry(cache, i)->name, ce->name)) i++; i--; continue; @@ -221,10 +221,7 @@ printf("%s: needs update\n", ce->name); continue; } - /* You can NOT just free active_cache[i] here, since it - * might not be necessarily malloc()ed but can also come - * from mmap(). */ - active_cache[i] = new; + set_cache_entry(cache, new, i); } } @@ -256,7 +253,7 @@ } } -static int add_cacheinfo(char *arg1, char *arg2, char *arg3) +static int add_cacheinfo(struct cache *cache, char *arg1, char *arg2, char *arg3) { int size, len; unsigned int mode; @@ -279,7 +276,7 @@ memcpy(ce->name, arg3, len); ce->ce_flags = htons(len); ce->ce_mode = create_ce_mode(mode); - return add_cache_entry(ce, allow_add); + return add_cache_entry(cache, ce, allow_add); } static int remove_lock = 0; @@ -294,6 +291,7 @@ { int i, newfd, entries; int allow_options = 1; + struct cache *cache = NULL; newfd = open(".git/index.lock", O_RDWR | O_CREAT | O_EXCL, 0600); if (newfd < 0) @@ -302,7 +300,8 @@ atexit(remove_lock_file); remove_lock = 1; - entries = read_cache(); + cache = read_cache(); + entries = get_num_cache_entries(cache); if (entries < 0) die("cache corrupted"); @@ -323,11 +322,11 @@ continue; } if (!strcmp(path, "--refresh")) { - refresh_cache(); + refresh_cache(cache); continue; } if (!strcmp(path, "--cacheinfo")) { - if (i+3 >= argc || add_cacheinfo(argv[i+1], argv[i+2], argv[i+3])) + if (i+3 >= argc || add_cacheinfo(cache, argv[i+1], argv[i+2], argv[i+3])) die("update-cache: --cacheinfo <mode> <sha1> <path>"); i += 3; continue; @@ -338,10 +337,10 @@ fprintf(stderr, "Ignoring path %s\n", argv[i]); continue; } - if (add_file_to_cache(path)) + if (add_file_to_cache(cache, path)) die("Unable to add %s to database", path); } - if (write_cache(newfd, active_cache, active_nr) || + if (write_cache(cache, newfd) || rename(".git/index.lock", ".git/index")) die("Unable to write new cachefile"); Index: write-tree.c =================================================================== --- c0260bfb82da04aeff4e598ced5295d6ae2e262d/write-tree.c (mode:100644 sha1:827809dbddbff6dd8cf842641f6db5ad2f3ae07a) +++ 38adb888a4c1adfe083f24d4ec51018e0b5a8335/write-tree.c (mode:100644 sha1:ad148b422ffa85d7ecf515e55538c1afa13f17d6) @@ -29,7 +29,7 @@ #define ORIG_OFFSET (40) /* Enough space to add the header of "tree <size>\0" */ -static int write_tree(struct cache_entry **cachep, int maxentries, const char *base, int baselen, unsigned char *returnsha1) +static int write_tree(struct cache *cache, int start_pos, const char *base, int baselen, unsigned char *returnsha1) { unsigned char subdir_sha1[20]; unsigned long size, offset; @@ -43,7 +43,7 @@ nr = 0; do { - struct cache_entry *ce = cachep[nr]; + struct cache_entry *ce = get_cache_entry(cache, start_pos + nr); const char *pathname = ce->name, *filename, *dirname; int pathlen = ce_namelen(ce), entrylen; unsigned char *sha1; @@ -53,16 +53,13 @@ if (baselen >= pathlen || memcmp(base, pathname, baselen)) break; - sha1 = ce->sha1; - mode = ntohl(ce->ce_mode); - /* Do we have _further_ subdirectories? */ filename = pathname + baselen; dirname = strchr(filename, '/'); if (dirname) { int subdir_written; - subdir_written = write_tree(cachep + nr, maxentries - nr, pathname, dirname-pathname+1, subdir_sha1); + subdir_written = write_tree(cache, start_pos + nr, pathname, dirname-pathname+1, subdir_sha1); nr += subdir_written; /* Now we need to write out the directory entry into this tree.. */ @@ -72,6 +69,9 @@ /* ..but the directory entry doesn't count towards the total count */ nr--; sha1 = subdir_sha1; + } else { + sha1 = ce->sha1; + mode = ntohl(ce->ce_mode); } if (check_valid_sha1(sha1) < 0) @@ -87,7 +87,7 @@ memcpy(buffer + offset, sha1, 20); offset += 20; nr++; - } while (nr < maxentries); + } while ((start_pos + nr) < get_num_cache_entries(cache)); i = prepend_integer(buffer, offset - ORIG_OFFSET, ORIG_OFFSET); i -= 5; @@ -101,16 +101,18 @@ int main(int argc, char **argv) { int i, unmerged; - int entries = read_cache(); unsigned char sha1[20]; + struct cache *cache = read_cache(); + int entries; - if (entries <= 0) + if (!cache) die("write-tree: no cache contents to write"); + entries = get_num_cache_entries(cache); /* Verify that the tree is merged */ unmerged = 0; for (i = 0; i < entries; i++) { - struct cache_entry *ce = active_cache[i]; + struct cache_entry *ce = get_cache_entry(cache, i); if (ntohs(ce->ce_flags) & ~CE_NAMEMASK) { if (++unmerged > 10) { fprintf(stderr, "...\n"); @@ -123,7 +125,7 @@ die("write-tree: not able to write tree"); /* Ok, write it out */ - if (write_tree(active_cache, entries, "", 0, sha1) != entries) + if (write_tree(cache, 0, "", 0, sha1) != entries) die("write-tree: internal error"); printf("%s\n", sha1_to_hex(sha1)); return 0; - To unsubscribe from this list: send the line "unsubscribe git" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.htmlReceived on Fri Apr 22 04:52:35 2005
This archive was generated by hypermail 2.1.8 : 2005-04-22 04:52:35 EST