sha1-file.c: remove implicit dependency on the_index

Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/difftool.c b/builtin/difftool.c
index cdd585ca76d51f6d5dcca78a9e1dfa6f8102c476..e7023e3adff0b3f7ab24b055e9234aeaecb6111f 100644 (file)
--- a/builtin/difftool.c
+++ b/builtin/difftool.c
@@ -112,7 +112,7 @@ static int use_wt_file(const char *workdir, const char *name,
                int fd = open(buf.buf, O_RDONLY);
 
                if (fd >= 0 &&
                int fd = open(buf.buf, O_RDONLY);
 
                if (fd >= 0 &&

-                   !index_fd(&wt_oid, fd, &st, OBJ_BLOB, name, 0)) {
+                   !index_fd(&the_index, &wt_oid, fd, &st, OBJ_BLOB, name, 0)) {

                        if (is_null_oid(oid)) {
                                oidcpy(oid, &wt_oid);
                                use = 1;
                        if (is_null_oid(oid)) {
                                oidcpy(oid, &wt_oid);
                                use = 1;

diff --git a/builtin/hash-object.c b/builtin/hash-object.c
index 9ada4f4dfd8747d3888203749f057915f7c9ab46..d6f06ea32f51272efa5ccb3fdd396b5916e98e45 100644 (file)
--- a/builtin/hash-object.c
+++ b/builtin/hash-object.c
@@ -40,7 +40,7 @@ static void hash_fd(int fd, const char *type, const char *path, unsigned flags,
        if (fstat(fd, &st) < 0 ||
            (literally
             ? hash_literally(&oid, fd, type, flags)
        if (fstat(fd, &st) < 0 ||
            (literally
             ? hash_literally(&oid, fd, type, flags)

-            : index_fd(&oid, fd, &st, type_from_string(type), path, flags)))
+            : index_fd(&the_index, &oid, fd, &st, type_from_string(type), path, flags)))

                die((flags & HASH_WRITE_OBJECT)
                    ? "Unable to add %s to database"
                    : "Unable to hash %s", path);
                die((flags & HASH_WRITE_OBJECT)
                    ? "Unable to add %s to database"
                    : "Unable to hash %s", path);

diff --git a/builtin/replace.c b/builtin/replace.c
index 4f05791f3e895f78ba511dd6571bd09abab9269c..e0b16ad44b498dd0b8a6fed68eb7d5093f9b696f 100644 (file)
--- a/builtin/replace.c
+++ b/builtin/replace.c
@@ -295,7 +295,7 @@ static int import_object(struct object_id *oid, enum object_type type,
                        close(fd);
                        return -1;
                }
                        close(fd);
                        return -1;
                }

-               if (index_fd(oid, fd, &st, type, NULL, flags) < 0)
+               if (index_fd(&the_index, oid, fd, &st, type, NULL, flags) < 0)

                        return error(_("unable to write object to database"));
                /* index_fd close()s fd for us */
        }
                        return error(_("unable to write object to database"));
                /* index_fd close()s fd for us */
        }

diff --git a/builtin/update-index.c b/builtin/update-index.c
index fe84003b4fa05c377bb4ab1de04a7cd1c9ae4d5d..3086212fdb8ffbed6ccebedba9cd344d0bc761a7 100644 (file)
--- a/builtin/update-index.c
+++ b/builtin/update-index.c
@@ -282,7 +282,7 @@ static int add_one_path(const struct cache_entry *old, const char *path, int len
        fill_stat_cache_info(ce, st);
        ce->ce_mode = ce_mode_from_stat(old, st->st_mode);
 
        fill_stat_cache_info(ce, st);
        ce->ce_mode = ce_mode_from_stat(old, st->st_mode);
 

-       if (index_path(&ce->oid, path, st,
+       if (index_path(&the_index, &ce->oid, path, st,

                       info_only ? 0 : HASH_WRITE_OBJECT)) {
                discard_cache_entry(ce);
                return -1;
                       info_only ? 0 : HASH_WRITE_OBJECT)) {
                discard_cache_entry(ce);
                return -1;

diff --git a/cache.h b/cache.h
index 49fe83331c876f8c3a2ce5a77e196bf8c00fa842..094652a503b4cf017887176ac404342824c98384 100644 (file)
--- a/cache.h
+++ b/cache.h
@@ -787,8 +787,8 @@ extern int ie_modified(struct index_state *, const struct cache_entry *, struct
 #define HASH_WRITE_OBJECT 1
 #define HASH_FORMAT_CHECK 2
 #define HASH_RENORMALIZE  4
 #define HASH_WRITE_OBJECT 1
 #define HASH_FORMAT_CHECK 2
 #define HASH_RENORMALIZE  4

-extern int index_fd(struct object_id *oid, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags);
-extern int index_path(struct object_id *oid, const char *path, struct stat *st, unsigned flags);
+extern int index_fd(struct index_state *istate, struct object_id *oid, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags);
+extern int index_path(struct index_state *istate, struct object_id *oid, const char *path, struct stat *st, unsigned flags);

 
 /*
  * Record to sd the data from st that we use to check whether a file
 
 /*
  * Record to sd the data from st that we use to check whether a file

diff --git a/diff.c b/diff.c
index a06c3b070c698f4b612124cd07f066461e17f123..140d0e86df04438e6b19972cc1d46996672550db 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -4252,7 +4252,7 @@ static void run_diff_cmd(const char *pgm,
                fprintf(o->file, "* Unmerged path %s\n", name);
 }
 
                fprintf(o->file, "* Unmerged path %s\n", name);
 }
 

-static void diff_fill_oid_info(struct diff_filespec *one)
+static void diff_fill_oid_info(struct diff_filespec *one, struct index_state *istate)

 {
        if (DIFF_FILE_VALID(one)) {
                if (!one->oid_valid) {
 {
        if (DIFF_FILE_VALID(one)) {
                if (!one->oid_valid) {


@@ -4263,7 +4263,7 @@ static void diff_fill_oid_info(struct diff_filespec *one)
                        }
                        if (lstat(one->path, &st) < 0)
                                die_errno("stat '%s'", one->path);
                        }
                        if (lstat(one->path, &st) < 0)
                                die_errno("stat '%s'", one->path);

-                       if (index_path(&one->oid, one->path, &st, 0))
+                       if (index_path(istate, &one->oid, one->path, &st, 0))

                                die("cannot hash %s", one->path);
                }
        }
                                die("cannot hash %s", one->path);
                }
        }


@@ -4311,8 +4311,8 @@ static void run_diff(struct diff_filepair *p, struct diff_options *o)
                return;
        }
 
                return;
        }
 

-       diff_fill_oid_info(one);
-       diff_fill_oid_info(two);
+       diff_fill_oid_info(one, o->repo->index);
+       diff_fill_oid_info(two, o->repo->index);

 
        if (!pgm &&
            DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&
 
        if (!pgm &&
            DIFF_FILE_VALID(one) && DIFF_FILE_VALID(two) &&


@@ -4359,8 +4359,8 @@ static void run_diffstat(struct diff_filepair *p, struct diff_options *o,
        if (o->prefix_length)
                strip_prefix(o->prefix_length, &name, &other);
 
        if (o->prefix_length)
                strip_prefix(o->prefix_length, &name, &other);
 

-       diff_fill_oid_info(p->one);
-       diff_fill_oid_info(p->two);
+       diff_fill_oid_info(p->one, o->repo->index);
+       diff_fill_oid_info(p->two, o->repo->index);

 
        builtin_diffstat(name, other, p->one, p->two,
                         diffstat, o, p);
 
        builtin_diffstat(name, other, p->one, p->two,
                         diffstat, o, p);


@@ -4384,8 +4384,8 @@ static void run_checkdiff(struct diff_filepair *p, struct diff_options *o)
        if (o->prefix_length)
                strip_prefix(o->prefix_length, &name, &other);
 
        if (o->prefix_length)
                strip_prefix(o->prefix_length, &name, &other);
 

-       diff_fill_oid_info(p->one);
-       diff_fill_oid_info(p->two);
+       diff_fill_oid_info(p->one, o->repo->index);
+       diff_fill_oid_info(p->two, o->repo->index);

 
        builtin_checkdiff(name, other, attr_path, p->one, p->two, o);
 }
 
        builtin_checkdiff(name, other, attr_path, p->one, p->two, o);
 }


@@ -5685,8 +5685,8 @@ static int diff_get_patch_id(struct diff_options *options, struct object_id *oid
                if (DIFF_PAIR_UNMERGED(p))
                        continue;
 
                if (DIFF_PAIR_UNMERGED(p))
                        continue;
 

-               diff_fill_oid_info(p->one);
-               diff_fill_oid_info(p->two);
+               diff_fill_oid_info(p->one, options->repo->index);
+               diff_fill_oid_info(p->two, options->repo->index);

 
                len1 = remove_space(p->one->path, strlen(p->one->path));
                len2 = remove_space(p->two->path, strlen(p->two->path));
 
                len1 = remove_space(p->one->path, strlen(p->one->path));
                len2 = remove_space(p->two->path, strlen(p->two->path));

diff --git a/notes-merge.c b/notes-merge.c
index 432edfb89afb29b992dbbd103a6eeecc52c5db8f..13dd9ba1582b68c2a8e6083fab4b4ee86f9026c6 100644 (file)
--- a/notes-merge.c
+++ b/notes-merge.c
@@ -710,7 +710,7 @@ int notes_merge_commit(struct notes_merge_options *o,
                /* write file as blob, and add to partial_tree */
                if (stat(path.buf, &st))
                        die_errno("Failed to stat '%s'", path.buf);
                /* write file as blob, and add to partial_tree */
                if (stat(path.buf, &st))
                        die_errno("Failed to stat '%s'", path.buf);

-               if (index_path(&blob_oid, path.buf, &st, HASH_WRITE_OBJECT))
+               if (index_path(&the_index, &blob_oid, path.buf, &st, HASH_WRITE_OBJECT))

                        die("Failed to write blob object from '%s'", path.buf);
                if (add_note(partial_tree, &obj_oid, &blob_oid, NULL))
                        die("Failed to add resolved note '%s' to notes tree",
                        die("Failed to write blob object from '%s'", path.buf);
                if (add_note(partial_tree, &obj_oid, &blob_oid, NULL))
                        die("Failed to add resolved note '%s' to notes tree",

diff --git a/read-cache.c b/read-cache.c
index 563500fe987b22c79280fe2e198411ce30fec69f..b707edd044d7234ec5a2569ba227b01c5a3290eb 100644 (file)
--- a/read-cache.c
+++ b/read-cache.c
@@ -205,14 +205,16 @@ void fill_stat_cache_info(struct cache_entry *ce, struct stat *st)
        }
 }
 
        }
 }
 

-static int ce_compare_data(const struct cache_entry *ce, struct stat *st)
+static int ce_compare_data(struct index_state *istate,
+                          const struct cache_entry *ce,
+                          struct stat *st)

 {
        int match = -1;
        int fd = git_open_cloexec(ce->name, O_RDONLY);
 
        if (fd >= 0) {
                struct object_id oid;
 {
        int match = -1;
        int fd = git_open_cloexec(ce->name, O_RDONLY);
 
        if (fd >= 0) {
                struct object_id oid;

-               if (!index_fd(&oid, fd, st, OBJ_BLOB, ce->name, 0))
+               if (!index_fd(istate, &oid, fd, st, OBJ_BLOB, ce->name, 0))

                        match = oidcmp(&oid, &ce->oid);
                /* index_fd() closed the file descriptor already */
        }
                        match = oidcmp(&oid, &ce->oid);
                /* index_fd() closed the file descriptor already */
        }


@@ -257,11 +259,13 @@ static int ce_compare_gitlink(const struct cache_entry *ce)
        return oidcmp(&oid, &ce->oid);
 }
 
        return oidcmp(&oid, &ce->oid);
 }
 

-static int ce_modified_check_fs(const struct cache_entry *ce, struct stat *st)
+static int ce_modified_check_fs(struct index_state *istate,
+                               const struct cache_entry *ce,
+                               struct stat *st)

 {
        switch (st->st_mode & S_IFMT) {
        case S_IFREG:
 {
        switch (st->st_mode & S_IFMT) {
        case S_IFREG:

-               if (ce_compare_data(ce, st))
+               if (ce_compare_data(istate, ce, st))

                        return DATA_CHANGED;
                break;
        case S_IFLNK:
                        return DATA_CHANGED;
                break;
        case S_IFLNK:


@@ -407,7 +411,7 @@ int ie_match_stat(struct index_state *istate,
                if (assume_racy_is_modified)
                        changed |= DATA_CHANGED;
                else
                if (assume_racy_is_modified)
                        changed |= DATA_CHANGED;
                else

-                       changed |= ce_modified_check_fs(ce, st);
+                       changed |= ce_modified_check_fs(istate, ce, st);

        }
 
        return changed;
        }
 
        return changed;


@@ -447,7 +451,7 @@ int ie_modified(struct index_state *istate,
            (S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size != 0))
                return changed;
 
            (S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size != 0))
                return changed;
 

-       changed_fs = ce_modified_check_fs(ce, st);
+       changed_fs = ce_modified_check_fs(istate, ce, st);

        if (changed_fs)
                return changed | changed_fs;
        return 0;
        if (changed_fs)
                return changed | changed_fs;
        return 0;


@@ -753,7 +757,7 @@ int add_to_index(struct index_state *istate, const char *path, struct stat *st,
                }
        }
        if (!intent_only) {
                }
        }
        if (!intent_only) {

-               if (index_path(&ce->oid, path, st, newflags)) {
+               if (index_path(istate, &ce->oid, path, st, newflags)) {

                        discard_cache_entry(ce);
                        return error("unable to index file %s", path);
                }
                        discard_cache_entry(ce);
                        return error("unable to index file %s", path);
                }


@@ -2230,7 +2234,8 @@ static int ce_flush(git_hash_ctx *context, int fd, unsigned char *hash)
        return (write_in_full(fd, write_buffer, left) < 0) ? -1 : 0;
 }
 
        return (write_in_full(fd, write_buffer, left) < 0) ? -1 : 0;
 }
 

-static void ce_smudge_racily_clean_entry(struct cache_entry *ce)
+static void ce_smudge_racily_clean_entry(struct index_state *istate,
+                                        struct cache_entry *ce)

 {
        /*
         * The only thing we care about in this function is to smudge the
 {
        /*
         * The only thing we care about in this function is to smudge the


@@ -2249,7 +2254,7 @@ static void ce_smudge_racily_clean_entry(struct cache_entry *ce)
                return;
        if (ce_match_stat_basic(ce, &st))
                return;
                return;
        if (ce_match_stat_basic(ce, &st))
                return;

-       if (ce_modified_check_fs(ce, &st)) {
+       if (ce_modified_check_fs(istate, ce, &st)) {

                /* This is "racily clean"; smudge it.  Note that this
                 * is a tricky code.  At first glance, it may appear
                 * that it can break with this sequence:
                /* This is "racily clean"; smudge it.  Note that this
                 * is a tricky code.  At first glance, it may appear
                 * that it can break with this sequence:


@@ -2494,7 +2499,7 @@ static int do_write_index(struct index_state *istate, struct tempfile *tempfile,
                if (ce->ce_flags & CE_REMOVE)
                        continue;
                if (!ce_uptodate(ce) && is_racy_timestamp(istate, ce))
                if (ce->ce_flags & CE_REMOVE)
                        continue;
                if (!ce_uptodate(ce) && is_racy_timestamp(istate, ce))

-                       ce_smudge_racily_clean_entry(ce);
+                       ce_smudge_racily_clean_entry(istate, ce);

                if (is_null_oid(&ce->oid)) {
                        static const char msg[] = "cache entry has null sha1: %s";
                        static int allow = -1;
                if (is_null_oid(&ce->oid)) {
                        static const char msg[] = "cache entry has null sha1: %s";
                        static int allow = -1;

diff --git a/sha1-file.c b/sha1-file.c
index 97b74238483e00c3f07bd5ab0879eb84bf5c8dfa..308d5e20e2c6483fde64641a00f7c0b5b2f721ea 100644 (file)
--- a/sha1-file.c
+++ b/sha1-file.c
@@ -1813,7 +1813,8 @@ static void check_tag(const void *buf, size_t size)
                die(_("corrupt tag"));
 }
 
                die(_("corrupt tag"));
 }
 

-static int index_mem(struct object_id *oid, void *buf, size_t size,
+static int index_mem(struct index_state *istate,
+                    struct object_id *oid, void *buf, size_t size,

                     enum object_type type,
                     const char *path, unsigned flags)
 {
                     enum object_type type,
                     const char *path, unsigned flags)
 {


@@ -1828,7 +1829,7 @@ static int index_mem(struct object_id *oid, void *buf, size_t size,
         */
        if ((type == OBJ_BLOB) && path) {
                struct strbuf nbuf = STRBUF_INIT;
         */
        if ((type == OBJ_BLOB) && path) {
                struct strbuf nbuf = STRBUF_INIT;

-               if (convert_to_git(&the_index, path, buf, size, &nbuf,
+               if (convert_to_git(istate, path, buf, size, &nbuf,

                                   get_conv_flags(flags))) {
                        buf = strbuf_detach(&nbuf, &size);
                        re_allocated = 1;
                                   get_conv_flags(flags))) {
                        buf = strbuf_detach(&nbuf, &size);
                        re_allocated = 1;


@@ -1852,17 +1853,20 @@ static int index_mem(struct object_id *oid, void *buf, size_t size,
        return ret;
 }
 
        return ret;
 }
 

-static int index_stream_convert_blob(struct object_id *oid, int fd,
-                                    const char *path, unsigned flags)
+static int index_stream_convert_blob(struct index_state *istate,
+                                    struct object_id *oid,
+                                    int fd,
+                                    const char *path,
+                                    unsigned flags)

 {
        int ret;
        const int write_object = flags & HASH_WRITE_OBJECT;
        struct strbuf sbuf = STRBUF_INIT;
 
        assert(path);
 {
        int ret;
        const int write_object = flags & HASH_WRITE_OBJECT;
        struct strbuf sbuf = STRBUF_INIT;
 
        assert(path);

-       assert(would_convert_to_git_filter_fd(&the_index, path));
+       assert(would_convert_to_git_filter_fd(istate, path));

 
 

-       convert_to_git_filter_fd(&the_index, path, fd, &sbuf,
+       convert_to_git_filter_fd(istate, path, fd, &sbuf,

                                 get_conv_flags(flags));
 
        if (write_object)
                                 get_conv_flags(flags));
 
        if (write_object)


@@ -1875,14 +1879,15 @@ static int index_stream_convert_blob(struct object_id *oid, int fd,
        return ret;
 }
 
        return ret;
 }
 

-static int index_pipe(struct object_id *oid, int fd, enum object_type type,
+static int index_pipe(struct index_state *istate, struct object_id *oid,
+                     int fd, enum object_type type,

                      const char *path, unsigned flags)
 {
        struct strbuf sbuf = STRBUF_INIT;
        int ret;
 
        if (strbuf_read(&sbuf, fd, 4096) >= 0)
                      const char *path, unsigned flags)
 {
        struct strbuf sbuf = STRBUF_INIT;
        int ret;
 
        if (strbuf_read(&sbuf, fd, 4096) >= 0)

-               ret = index_mem(oid, sbuf.buf, sbuf.len, type, path, flags);
+               ret = index_mem(istate, oid, sbuf.buf, sbuf.len, type, path, flags);

        else
                ret = -1;
        strbuf_release(&sbuf);
        else
                ret = -1;
        strbuf_release(&sbuf);


@@ -1891,14 +1896,15 @@ static int index_pipe(struct object_id *oid, int fd, enum object_type type,
 
 #define SMALL_FILE_SIZE (32*1024)
 
 
 #define SMALL_FILE_SIZE (32*1024)
 

-static int index_core(struct object_id *oid, int fd, size_t size,
+static int index_core(struct index_state *istate,
+                     struct object_id *oid, int fd, size_t size,

                      enum object_type type, const char *path,
                      unsigned flags)
 {
        int ret;
 
        if (!size) {
                      enum object_type type, const char *path,
                      unsigned flags)
 {
        int ret;
 
        if (!size) {

-               ret = index_mem(oid, "", size, type, path, flags);
+               ret = index_mem(istate, oid, "", size, type, path, flags);

        } else if (size <= SMALL_FILE_SIZE) {
                char *buf = xmalloc(size);
                ssize_t read_result = read_in_full(fd, buf, size);
        } else if (size <= SMALL_FILE_SIZE) {
                char *buf = xmalloc(size);
                ssize_t read_result = read_in_full(fd, buf, size);


@@ -1909,11 +1915,11 @@ static int index_core(struct object_id *oid, int fd, size_t size,
                        ret = error(_("short read while indexing %s"),
                                    path ? path : "<unknown>");
                else
                        ret = error(_("short read while indexing %s"),
                                    path ? path : "<unknown>");
                else

-                       ret = index_mem(oid, buf, size, type, path, flags);
+                       ret = index_mem(istate, oid, buf, size, type, path, flags);

                free(buf);
        } else {
                void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
                free(buf);
        } else {
                void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);

-               ret = index_mem(oid, buf, size, type, path, flags);
+               ret = index_mem(istate, oid, buf, size, type, path, flags);

                munmap(buf, size);
        }
        return ret;
                munmap(buf, size);
        }
        return ret;


@@ -1941,7 +1947,8 @@ static int index_stream(struct object_id *oid, int fd, size_t size,
        return index_bulk_checkin(oid, fd, size, type, path, flags);
 }
 
        return index_bulk_checkin(oid, fd, size, type, path, flags);
 }
 

-int index_fd(struct object_id *oid, int fd, struct stat *st,
+int index_fd(struct index_state *istate, struct object_id *oid,
+            int fd, struct stat *st,

             enum object_type type, const char *path, unsigned flags)
 {
        int ret;
             enum object_type type, const char *path, unsigned flags)
 {
        int ret;


@@ -1950,14 +1957,14 @@ int index_fd(struct object_id *oid, int fd, struct stat *st,
         * Call xsize_t() only when needed to avoid potentially unnecessary
         * die() for large files.
         */
         * Call xsize_t() only when needed to avoid potentially unnecessary
         * die() for large files.
         */

-       if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(&the_index, path))
-               ret = index_stream_convert_blob(oid, fd, path, flags);
+       if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(istate, path))
+               ret = index_stream_convert_blob(istate, oid, fd, path, flags);

        else if (!S_ISREG(st->st_mode))
        else if (!S_ISREG(st->st_mode))

-               ret = index_pipe(oid, fd, type, path, flags);
+               ret = index_pipe(istate, oid, fd, type, path, flags);

        else if (st->st_size <= big_file_threshold || type != OBJ_BLOB ||
        else if (st->st_size <= big_file_threshold || type != OBJ_BLOB ||

-                (path && would_convert_to_git(&the_index, path)))
-               ret = index_core(oid, fd, xsize_t(st->st_size), type, path,
-                                flags);
+                (path && would_convert_to_git(istate, path)))
+               ret = index_core(istate, oid, fd, xsize_t(st->st_size),
+                                type, path, flags);

        else
                ret = index_stream(oid, fd, xsize_t(st->st_size), type, path,
                                   flags);
        else
                ret = index_stream(oid, fd, xsize_t(st->st_size), type, path,
                                   flags);


@@ -1965,7 +1972,8 @@ int index_fd(struct object_id *oid, int fd, struct stat *st,
        return ret;
 }
 
        return ret;
 }
 

-int index_path(struct object_id *oid, const char *path, struct stat *st, unsigned flags)
+int index_path(struct index_state *istate, struct object_id *oid,
+              const char *path, struct stat *st, unsigned flags)

 {
        int fd;
        struct strbuf sb = STRBUF_INIT;
 {
        int fd;
        struct strbuf sb = STRBUF_INIT;


@@ -1976,7 +1984,7 @@ int index_path(struct object_id *oid, const char *path, struct stat *st, unsigne
                fd = open(path, O_RDONLY);
                if (fd < 0)
                        return error_errno("open(\"%s\")", path);
                fd = open(path, O_RDONLY);
                if (fd < 0)
                        return error_errno("open(\"%s\")", path);

-               if (index_fd(oid, fd, st, OBJ_BLOB, path, flags) < 0)
+               if (index_fd(istate, oid, fd, st, OBJ_BLOB, path, flags) < 0)

                        return error(_("%s: failed to insert into database"),
                                     path);
                break;
                        return error(_("%s: failed to insert into database"),
                                     path);
                break;