tree 38adb888a4c1adfe083f24d4ec51018e0b5a8335
parent 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac
author Brad Roberts <[EMAIL PROTECTED]> 1114093024 -0700
committer Brad Roberts <[EMAIL PROTECTED]> 1114093024 -0700
[PATCH] the end goal of the last dozen or so commits, there's no longer a
global cache variable
Signed-off-by: Brad Roberts <[EMAIL PROTECTED]>
---
cache.h | 21 +++++++-------
check-files.c | 10 +++---
checkout-cache.c | 20 ++++++-------
diff-cache.c | 20 ++++++-------
merge-cache.c | 29 ++++++++++---------
read-cache.c | 82 ++++++++++++++++++++++++++++---------------------------
read-tree.c | 51 ++++++++++++++++++----------------
show-diff.c | 8 ++---
show-files.c | 27 +++++++++---------
update-cache.c | 35 ++++++++++++-----------
write-tree.c | 20 ++++++-------
11 files changed, 167 insertions(+), 156 deletions(-)
Index: cache.h
===================================================================
--- 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac:1/cache.h (mode:100644
sha1:c64969602d80a0e9d7137b2716fb808c912b075c)
+++ 7e396358c12c0129bcb4945e3e35a4fa76890a0c:1/cache.h (mode:100644
sha1:d8ade9f4b9bd9b6045f97b4df5bef8356c767d46)
@@ -72,16 +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);
-extern void free_cache();
-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 get_num_cache_entries();
-extern struct cache_entry * get_cache_entry(int pos);
-extern void set_cache_entry(struct cache_entry *ce, int pos);
-extern int remove_cache_entry_at(int pos);
+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
===================================================================
--- 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac:1/check-files.c (mode:100644
sha1:0973e81fbbc0f9f98031fb249254bd89d8088889)
+++ 7e396358c12c0129bcb4945e3e35a4fa76890a0c:1/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,10 +23,10 @@
}
/* 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 = get_cache_entry(pos);
+ ce = get_cache_entry(cache, pos);
if (fstat(fd, &st) < 0)
die("fstat(%s): %s", path, strerror(errno));
@@ -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
===================================================================
--- 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac:1/checkout-cache.c (mode:100644
sha1:27b559d5bcc5831eda441bcd1fd88d687f2567b8)
+++ 7e396358c12c0129bcb4945e3e35a4fa76890a0c:1/checkout-cache.c (mode:100644
sha1:2e8c61323a72f6052d8c9ef76a4eef05aa5ac0f9)
@@ -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(get_cache_entry(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 < get_num_cache_entries() ; i++) {
- struct cache_entry *ce = get_cache_entry(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
===================================================================
--- 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac:1/diff-cache.c (mode:100644
sha1:5ae6d5de5ed5ad34f72267904ff8eb6288855fc5)
+++ 7e396358c12c0129bcb4945e3e35a4fa76890a0c:1/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, int pos, 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,
- int *pos, const char *base)
+ struct cache *cache, int *pos, const char *base)
{
int baselen = strlen(base);
- struct cache_entry *ce = get_cache_entry(*pos);
+ 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));
- *pos = diff_cache(tree, size, *pos, newbase);
+ *pos = diff_cache(tree, size, cache, *pos, newbase);
free(newbase);
free(tree);
return -1;
@@ -158,7 +158,7 @@
return 0;
}
-static int diff_cache(void *tree, unsigned long size, int pos, const char
*base)
+static int diff_cache(void *tree, unsigned long size, struct cache *cache, int
pos, const char *base)
{
int baselen = strlen(base);
@@ -172,8 +172,8 @@
* No entries in the cache (with this base)?
* Output the tree contents.
*/
- if ((pos == get_num_cache_entries()) ||
- ce_namelen(ce = get_cache_entry(pos)) < 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 pos;
@@ -193,7 +193,7 @@
}
sha1 = extract(tree, size, &path, &mode);
- switch (compare_tree_entry(path, mode, sha1, &pos, base)) {
+ switch (compare_tree_entry(path, mode, sha1, cache, &pos,
base)) {
case -1:
update_tree_entry(&tree, &size);
continue;
@@ -215,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++;
@@ -257,5 +257,5 @@
if (strcmp(type, "tree"))
die("bad tree object %s (%s)", sha1_to_hex(tree_sha1), type);
- return diff_cache(tree, size, 0, "");
+ return diff_cache(tree, size, cache, 0, "");
}
Index: merge-cache.c
===================================================================
--- 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac:1/merge-cache.c (mode:100644
sha1:c2f96e7652a2aea9417c3790bfe9ab14ffcdb12f)
+++ 7e396358c12c0129bcb4945e3e35a4fa76890a0c:1/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 >= get_num_cache_entries())
+ 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 = get_cache_entry(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 < get_num_cache_entries());
+ } 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 < get_num_cache_entries(); i++) {
- struct cache_entry *ce = get_cache_entry(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
===================================================================
--- 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac:1/read-cache.c (mode:100644
sha1:8837d27ab683bf07d38aee33c62a90f5a7221588)
+++ 7e396358c12c0129bcb4945e3e35a4fa76890a0c:1/read-cache.c (mode:100644
sha1:7084fcdf771ddc5bfac38b8778a5904d779de3a4)
@@ -30,18 +30,15 @@
unsigned int allocated_entries;
};
-static struct cache * cache = NULL;
-
struct cache * new_cache()
{
return (struct cache*)calloc(1, sizeof(struct cache));
}
-void free_cache()
+void free_cache(struct cache *cache)
{
munmap(cache->map.ptr, cache->map.size);
free(cache);
- cache = NULL;
}
int ce_match_stat(struct cache_entry *ce, struct stat *st)
@@ -100,7 +97,7 @@
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;
@@ -122,7 +119,7 @@
}
/* Remove entry, return true if there are more entries to go.. */
-int remove_cache_entry_at(int pos)
+int remove_cache_entry_at(struct cache *cache, int pos)
{
cache->num_entries--;
if (pos >= cache->num_entries)
@@ -131,11 +128,11 @@
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_cache_entry_at(pos);
+ remove_cache_entry_at(cache, pos);
return 0;
}
@@ -145,17 +142,17 @@
return ce_namelen(b) == len && !memcmp(a->name, b->name, len);
}
-int get_num_cache_entries()
+int get_num_cache_entries(struct cache *cache)
{
return cache->num_entries;
}
-struct cache_entry * get_cache_entry(int pos)
+struct cache_entry * get_cache_entry(struct cache *cache, int pos)
{
return cache->entries[pos];
}
-void set_cache_entry(struct cache_entry *ce, int 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
@@ -163,16 +160,11 @@
cache->entries[pos] = ce;
}
-int add_cache_entry(struct cache_entry *ce, int ok_to_add)
+int add_cache_entry(struct cache *cache, struct cache_entry *ce, int ok_to_add)
{
int pos;
- /* temporary, read-tree.c expects the cache to always exist, even
- * without a read_cache being called */
- if (!cache)
- cache = new_cache();
-
- 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) {
@@ -188,7 +180,7 @@
if (pos < cache->num_entries && ce_stage(ce) == 0) {
while (same_name(cache->entries[pos], ce)) {
ok_to_add = 1;
- if (!remove_cache_entry_at(pos))
+ if (!remove_cache_entry_at(cache, pos))
break;
}
}
@@ -227,29 +219,40 @@
return 0;
}
-int read_cache(void)
+struct cache *read_cache(void)
{
int fd, i;
struct stat st;
unsigned long offset;
+ struct cache *cache;
+
+ cache = new_cache();
+ if (!cache) {
+ errno = ENOMEM;
+ error("unable to allocate cache");
+ return NULL;
+ }
- errno = EBUSY;
- if (cache)
- return error("more than one cachefile");
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");
-
- errno = ENOMEM;
- cache = new_cache();
- if (!cache)
- return error("unable to allocate cache");
+ 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;
+ }
+ }
cache->map.size = 0; /* avoid gcc warning */
cache->map.ptr = (void *)-1;
@@ -261,16 +264,17 @@
}
close(fd);
if (-1 == (int)(long)cache->map.ptr) {
+ error("mmap failed");
free(cache);
- cache = NULL;
- return error("mmap failed");
+ return NULL;
}
cache->header = cache->map.ptr;
if (verify_hdr(cache->header, cache->map.size) < 0) {
- free_cache();
+ free_cache(cache);
errno = EINVAL;
- return error("verify header failed");
+ error("verify header failed");
+ return NULL;
}
cache->num_entries = ntohl(cache->header->hdr_entries);
@@ -283,7 +287,7 @@
offset = offset + ce_size(ce);
cache->entries[i] = ce;
}
- return cache->num_entries;
+ return cache;
}
#define WRITE_BUFFER_SIZE 8192
@@ -329,7 +333,7 @@
return 0;
}
-int write_cache(int newfd)
+int write_cache(struct cache *cache, int newfd)
{
SHA_CTX c;
struct cache_header hdr;
Index: read-tree.c
===================================================================
--- 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac:1/read-tree.c (mode:100644
sha1:ad9128f26613a82361475516dd0f2b470f4ce4b3)
+++ 7e396358c12c0129bcb4945e3e35a4fa76890a0c:1/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;
}
@@ -149,16 +149,16 @@
/* 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()
+static void trivially_merge_cache(struct cache *cache)
{
static struct cache_entry null_entry;
struct cache_entry *old = &null_entry;
- int src = 0, dst = 0, nr = get_num_cache_entries();
+ int src = 0, dst = 0, nr = get_num_cache_entries(cache);
while (src < nr) {
struct cache_entry *ce, *result;
- ce = get_cache_entry(src);
+ ce = get_cache_entry(cache, src);
/* We throw away original cache entries except for the stat
information */
if (!ce_stage(ce)) {
@@ -168,8 +168,8 @@
}
if ((src < (nr - 2)) &&
(result = merge_entries(ce,
- get_cache_entry(src + 1),
- get_cache_entry(src + 2))) != NULL)
{
+ 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.
@@ -180,27 +180,27 @@
ce->ce_flags &= ~htons(CE_STAGEMASK);
src += 2;
}
- set_cache_entry(ce, dst);
+ set_cache_entry(cache, ce, dst);
dst++;
src++;
}
/* this could be replaced by a truncate api */
while (nr > dst) {
nr--;
- remove_cache_entry_at(nr);
+ remove_cache_entry_at(cache, nr);
}
}
-static void merge_stat_info()
+static void merge_stat_info(struct cache *cache)
{
static struct cache_entry null_entry;
struct cache_entry *old = &null_entry;
- int src = 0, dst = 0, nr = get_num_cache_entries();
+ int src = 0, dst = 0, nr = get_num_cache_entries(cache);
while (src < nr) {
struct cache_entry *ce;
- ce = get_cache_entry(src);
+ ce = get_cache_entry(cache, src);
/* We throw away original cache entries except for the stat
information */
if (!ce_stage(ce)) {
@@ -211,14 +211,14 @@
if (path_matches(ce, old) && same(ce, old))
*ce = *old;
ce->ce_flags &= ~htons(CE_STAGEMASK);
- set_cache_entry(ce, dst);
+ set_cache_entry(cache, ce, dst);
dst++;
src++;
}
/* this could be replaced by a truncate api */
while (nr > dst) {
nr--;
- remove_cache_entry_at(nr);
+ remove_cache_entry_at(cache, nr);
}
}
@@ -226,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)
@@ -242,9 +243,9 @@
int i;
if (stage)
usage("-m needs to come first");
- read_cache();
- for (i = 0; i < get_num_cache_entries(); i++) {
- if (ce_stage(get_cache_entry(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;
@@ -255,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();
+ trivially_merge_cache(cache);
break;
case 2: /* Just read a tree, merge with old cache contents */
- merge_stat_info();
+ merge_stat_info(cache);
break;
default:
die("just how do you expect me to merge %d trees?",
stage-1);
}
}
- if (write_cache(newfd) ||
+ 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
===================================================================
--- 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac:1/show-diff.c (mode:100644
sha1:4a0902f50b3120b7791a4d4627a9a4f729afdcf7)
+++ 7e396358c12c0129bcb4945e3e35a4fa76890a0c:1/show-diff.c (mode:100644
sha1:d61bf6dea8106599c25ac5071743b351f6e000ce)
@@ -129,9 +129,9 @@
int entries;
int matched = 0;
int i;
+ struct cache *cache = read_cache();
- read_cache();
- entries = get_num_cache_entries();
+ entries = get_num_cache_entries(cache);
if (entries < 0) {
perror("read_cache");
exit(1);
@@ -157,7 +157,7 @@
prepare_diff_cmd();
for (i = 0; i < entries; i++) {
struct stat st;
- struct cache_entry *ce = get_cache_entry(i);
+ struct cache_entry *ce = get_cache_entry(cache, i);
int changed;
unsigned long size;
char type[20];
@@ -175,7 +175,7 @@
printf("%s: Unmerged\n",
ce->name);
while (i < entries &&
- !strcmp(ce->name, get_cache_entry(i)->name))
+ !strcmp(ce->name, get_cache_entry(cache,
i)->name))
i++;
i--; /* compensate for loop control increments */
continue;
Index: show-files.c
===================================================================
--- 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac:1/show-files.c (mode:100644
sha1:11fbbccef2df50d528105ceb48b15275f2a5693e)
+++ 7e396358c12c0129bcb4945e3e35a4fa76890a0c:1/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 < get_num_cache_entries(); i++) {
- struct cache_entry *ce = get_cache_entry(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 < get_num_cache_entries(); i++) {
- struct cache_entry *ce = get_cache_entry(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
===================================================================
--- 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac:1/update-cache.c (mode:100644
sha1:3f251552283667c42797835088a4922ef865fe4a)
+++ 7e396358c12c0129bcb4945e3e35a4fa76890a0c:1/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;
}
@@ -200,17 +200,17 @@
return updated;
}
-static void refresh_cache(void)
+static void refresh_cache(struct cache *cache)
{
int i;
- for (i = 0; i < get_num_cache_entries(); i++) {
+ for (i = 0; i < get_num_cache_entries(cache); i++) {
struct cache_entry *ce, *new;
- ce = get_cache_entry(i);
+ ce = get_cache_entry(cache, i);
if (ce_stage(ce)) {
printf("%s: needs merge\n", ce->name);
- while ((i < get_num_cache_entries()) &&
- ! strcmp(get_cache_entry(i)->name, ce->name))
+ while ((i < get_num_cache_entries(cache)) &&
+ ! strcmp(get_cache_entry(cache, i)->name,
ce->name))
i++;
i--;
continue;
@@ -221,7 +221,7 @@
printf("%s: needs update\n", ce->name);
continue;
}
- set_cache_entry(new, i);
+ set_cache_entry(cache, new, i);
}
}
@@ -253,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;
@@ -276,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;
@@ -291,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)
@@ -299,8 +300,8 @@
atexit(remove_lock_file);
remove_lock = 1;
- read_cache();
- entries = get_num_cache_entries();
+ cache = read_cache();
+ entries = get_num_cache_entries(cache);
if (entries < 0)
die("cache corrupted");
@@ -321,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;
@@ -336,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) ||
+ if (write_cache(cache, newfd) ||
rename(".git/index.lock", ".git/index"))
die("Unable to write new cachefile");
Index: write-tree.c
===================================================================
--- 0a556dc01b8e48f684ce6e0c26f8c00b5e39c4ac:1/write-tree.c (mode:100644
sha1:92e707fd4780805da160ce6fa282e75111ea67b9)
+++ 7e396358c12c0129bcb4945e3e35a4fa76890a0c:1/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(int start_pos, 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 = get_cache_entry(start_pos + 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;
@@ -59,7 +59,7 @@
if (dirname) {
int subdir_written;
- subdir_written = write_tree(start_pos + 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.. */
@@ -87,7 +87,7 @@
memcpy(buffer + offset, sha1, 20);
offset += 20;
nr++;
- } while ((start_pos + nr) < get_num_cache_entries());
+ } while ((start_pos + nr) < get_num_cache_entries(cache));
i = prepend_integer(buffer, offset - ORIG_OFFSET, ORIG_OFFSET);
i -= 5;
@@ -101,18 +101,18 @@
int main(int argc, char **argv)
{
int i, unmerged;
- int entries;
unsigned char sha1[20];
+ struct cache *cache = read_cache();
+ int entries;
- read_cache();
- entries = get_num_cache_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 = get_cache_entry(i);
+ struct cache_entry *ce = get_cache_entry(cache, i);
if (ntohs(ce->ce_flags) & ~CE_NAMEMASK) {
if (++unmerged > 10) {
fprintf(stderr, "...\n");
@@ -125,7 +125,7 @@
die("write-tree: not able to write tree");
/* Ok, write it out */
- if (write_tree(0, "", 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 [EMAIL PROTECTED]
More majordomo info at http://vger.kernel.org/majordomo-info.html
