2006-01-07 09:33:54 +00:00
|
|
|
#include "cache.h"
|
2007-08-09 20:42:50 +00:00
|
|
|
#include "cache-tree.h"
|
2005-04-18 18:39:48 +00:00
|
|
|
#include "tree.h"
|
2018-05-15 23:42:15 +00:00
|
|
|
#include "object-store.h"
|
2005-04-18 18:39:48 +00:00
|
|
|
#include "blob.h"
|
2005-09-05 06:03:51 +00:00
|
|
|
#include "commit.h"
|
|
|
|
#include "tag.h"
|
2018-05-15 21:48:42 +00:00
|
|
|
#include "alloc.h"
|
2006-05-29 19:16:12 +00:00
|
|
|
#include "tree-walk.h"
|
2018-06-29 01:21:51 +00:00
|
|
|
#include "repository.h"
|
2005-04-18 18:39:48 +00:00
|
|
|
|
|
|
|
const char *tree_type = "tree";
|
|
|
|
|
2017-06-12 22:13:57 +00:00
|
|
|
static int read_one_entry_opt(struct index_state *istate,
|
2018-03-12 02:27:26 +00:00
|
|
|
const struct object_id *oid,
|
2017-06-12 22:13:57 +00:00
|
|
|
const char *base, int baselen,
|
|
|
|
const char *pathname,
|
|
|
|
unsigned mode, int stage, int opt)
|
2005-04-22 23:42:37 +00:00
|
|
|
{
|
2005-11-26 17:38:20 +00:00
|
|
|
int len;
|
|
|
|
struct cache_entry *ce;
|
|
|
|
|
|
|
|
if (S_ISDIR(mode))
|
|
|
|
return READ_TREE_RECURSIVE;
|
|
|
|
|
|
|
|
len = strlen(pathname);
|
2018-07-02 19:49:31 +00:00
|
|
|
ce = make_empty_cache_entry(istate, baselen + len);
|
2005-04-22 23:42:37 +00:00
|
|
|
|
|
|
|
ce->ce_mode = create_ce_mode(mode);
|
2012-07-11 09:22:37 +00:00
|
|
|
ce->ce_flags = create_ce_flags(stage);
|
|
|
|
ce->ce_namelen = baselen + len;
|
2005-04-22 23:42:37 +00:00
|
|
|
memcpy(ce->name, base, baselen);
|
|
|
|
memcpy(ce->name + baselen, pathname, len+1);
|
2018-03-12 02:27:26 +00:00
|
|
|
oidcpy(&ce->oid, oid);
|
2017-06-12 22:13:57 +00:00
|
|
|
return add_index_entry(istate, ce, opt);
|
2007-08-09 20:42:50 +00:00
|
|
|
}
|
|
|
|
|
2018-03-12 02:27:26 +00:00
|
|
|
static int read_one_entry(const struct object_id *oid, struct strbuf *base,
|
2014-11-30 09:05:00 +00:00
|
|
|
const char *pathname, unsigned mode, int stage,
|
|
|
|
void *context)
|
2007-08-09 20:42:50 +00:00
|
|
|
{
|
2017-06-12 22:13:57 +00:00
|
|
|
struct index_state *istate = context;
|
2018-03-12 02:27:26 +00:00
|
|
|
return read_one_entry_opt(istate, oid, base->buf, base->len, pathname,
|
2014-11-30 09:05:00 +00:00
|
|
|
mode, stage,
|
2007-08-09 20:42:50 +00:00
|
|
|
ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is used when the caller knows there is no existing entries at
|
|
|
|
* the stage that will conflict with the entry being added.
|
|
|
|
*/
|
2018-03-12 02:27:26 +00:00
|
|
|
static int read_one_entry_quick(const struct object_id *oid, struct strbuf *base,
|
2014-11-30 09:05:00 +00:00
|
|
|
const char *pathname, unsigned mode, int stage,
|
|
|
|
void *context)
|
2007-08-09 20:42:50 +00:00
|
|
|
{
|
2017-06-12 22:13:57 +00:00
|
|
|
struct index_state *istate = context;
|
2018-03-12 02:27:26 +00:00
|
|
|
return read_one_entry_opt(istate, oid, base->buf, base->len, pathname,
|
2014-11-30 09:05:00 +00:00
|
|
|
mode, stage,
|
2007-08-09 20:42:50 +00:00
|
|
|
ADD_CACHE_JUST_APPEND);
|
2005-04-22 23:42:37 +00:00
|
|
|
}
|
|
|
|
|
2018-11-18 16:47:56 +00:00
|
|
|
static int read_tree_1(struct repository *r,
|
|
|
|
struct tree *tree, struct strbuf *base,
|
2013-07-14 08:35:52 +00:00
|
|
|
int stage, const struct pathspec *pathspec,
|
2011-03-25 09:34:18 +00:00
|
|
|
read_tree_fn_t fn, void *context)
|
2005-04-22 23:42:37 +00:00
|
|
|
{
|
2006-05-29 19:17:28 +00:00
|
|
|
struct tree_desc desc;
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
struct name_entry entry;
|
2017-05-06 22:10:15 +00:00
|
|
|
struct object_id oid;
|
2011-10-24 06:36:10 +00:00
|
|
|
int len, oldlen = base->len;
|
|
|
|
enum interesting retval = entry_not_interesting;
|
2006-05-29 19:17:28 +00:00
|
|
|
|
2006-01-26 06:13:36 +00:00
|
|
|
if (parse_tree(tree))
|
|
|
|
return -1;
|
2006-05-29 19:17:28 +00:00
|
|
|
|
2007-03-21 17:08:25 +00:00
|
|
|
init_tree_desc(&desc, tree->buffer, tree->size);
|
2006-05-29 19:17:28 +00:00
|
|
|
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
while (tree_entry(&desc, &entry)) {
|
2011-10-24 06:36:10 +00:00
|
|
|
if (retval != all_entries_interesting) {
|
2018-11-18 16:47:57 +00:00
|
|
|
retval = tree_entry_interesting(r->index, &entry,
|
|
|
|
base, 0, pathspec);
|
2011-10-24 06:36:10 +00:00
|
|
|
if (retval == all_entries_not_interesting)
|
2011-03-25 09:34:18 +00:00
|
|
|
break;
|
2011-10-24 06:36:10 +00:00
|
|
|
if (retval == entry_not_interesting)
|
2011-03-25 09:34:18 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-07-14 18:26:31 +00:00
|
|
|
|
2019-01-15 00:39:44 +00:00
|
|
|
switch (fn(&entry.oid, base,
|
2011-03-25 09:34:18 +00:00
|
|
|
entry.path, entry.mode, stage, context)) {
|
2005-11-26 17:38:20 +00:00
|
|
|
case 0:
|
|
|
|
continue;
|
|
|
|
case READ_TREE_RECURSIVE:
|
2009-02-11 01:42:04 +00:00
|
|
|
break;
|
2005-11-26 17:38:20 +00:00
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
2009-01-25 00:52:05 +00:00
|
|
|
|
2011-03-25 09:34:18 +00:00
|
|
|
if (S_ISDIR(entry.mode))
|
2019-01-15 00:39:44 +00:00
|
|
|
oidcpy(&oid, &entry.oid);
|
2011-03-25 09:34:18 +00:00
|
|
|
else if (S_ISGITLINK(entry.mode)) {
|
|
|
|
struct commit *commit;
|
2009-01-25 00:52:05 +00:00
|
|
|
|
2019-01-29 20:47:56 +00:00
|
|
|
commit = lookup_commit(r, &entry.oid);
|
2009-01-25 00:52:05 +00:00
|
|
|
if (!commit)
|
2011-03-25 09:34:18 +00:00
|
|
|
die("Commit %s in submodule path %s%s not found",
|
2019-01-15 00:39:44 +00:00
|
|
|
oid_to_hex(&entry.oid),
|
2011-03-25 09:34:18 +00:00
|
|
|
base->buf, entry.path);
|
2009-01-25 00:52:05 +00:00
|
|
|
|
|
|
|
if (parse_commit(commit))
|
2011-03-25 09:34:18 +00:00
|
|
|
die("Invalid commit %s in submodule path %s%s",
|
2019-01-15 00:39:44 +00:00
|
|
|
oid_to_hex(&entry.oid),
|
2011-03-25 09:34:18 +00:00
|
|
|
base->buf, entry.path);
|
|
|
|
|
2018-04-06 19:09:38 +00:00
|
|
|
oidcpy(&oid, get_commit_tree_oid(commit));
|
2005-04-22 23:42:37 +00:00
|
|
|
}
|
2011-03-25 09:34:18 +00:00
|
|
|
else
|
|
|
|
continue;
|
|
|
|
|
2011-10-24 06:36:09 +00:00
|
|
|
len = tree_entry_len(&entry);
|
2011-03-25 09:34:18 +00:00
|
|
|
strbuf_add(base, entry.path, len);
|
|
|
|
strbuf_addch(base, '/');
|
2018-11-18 16:47:56 +00:00
|
|
|
retval = read_tree_1(r, lookup_tree(r, &oid),
|
2011-03-25 09:34:18 +00:00
|
|
|
base, stage, pathspec,
|
|
|
|
fn, context);
|
|
|
|
strbuf_setlen(base, oldlen);
|
|
|
|
if (retval)
|
|
|
|
return -1;
|
2005-04-22 23:42:37 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-11-18 16:47:56 +00:00
|
|
|
int read_tree_recursive(struct repository *r,
|
|
|
|
struct tree *tree,
|
2011-03-25 09:34:18 +00:00
|
|
|
const char *base, int baselen,
|
2013-07-14 08:35:52 +00:00
|
|
|
int stage, const struct pathspec *pathspec,
|
2011-03-25 09:34:18 +00:00
|
|
|
read_tree_fn_t fn, void *context)
|
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2011-03-25 09:34:19 +00:00
|
|
|
int ret;
|
2011-03-25 09:34:18 +00:00
|
|
|
|
|
|
|
strbuf_add(&sb, base, baselen);
|
2018-11-18 16:47:56 +00:00
|
|
|
ret = read_tree_1(r, tree, &sb, stage, pathspec, fn, context);
|
2011-03-25 09:34:18 +00:00
|
|
|
strbuf_release(&sb);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-08-09 20:42:50 +00:00
|
|
|
static int cmp_cache_name_compare(const void *a_, const void *b_)
|
|
|
|
{
|
|
|
|
const struct cache_entry *ce1, *ce2;
|
|
|
|
|
|
|
|
ce1 = *((const struct cache_entry **)a_);
|
|
|
|
ce2 = *((const struct cache_entry **)b_);
|
2012-07-11 09:22:37 +00:00
|
|
|
return cache_name_stage_compare(ce1->name, ce1->ce_namelen, ce_stage(ce1),
|
|
|
|
ce2->name, ce2->ce_namelen, ce_stage(ce2));
|
2007-08-09 20:42:50 +00:00
|
|
|
}
|
|
|
|
|
2018-11-18 16:47:56 +00:00
|
|
|
int read_tree(struct repository *r, struct tree *tree, int stage,
|
|
|
|
struct pathspec *match, struct index_state *istate)
|
2005-04-22 23:42:37 +00:00
|
|
|
{
|
2007-08-09 20:42:50 +00:00
|
|
|
read_tree_fn_t fn = NULL;
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Currently the only existing callers of this function all
|
|
|
|
* call it with stage=1 and after making sure there is nothing
|
|
|
|
* at that stage; we could always use read_one_entry_quick().
|
|
|
|
*
|
|
|
|
* But when we decide to straighten out git-read-tree not to
|
|
|
|
* use unpack_trees() in some cases, this will probably start
|
|
|
|
* to matter.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if we have cache entry at the stage. If so,
|
|
|
|
* do it the original slow way, otherwise, append and then
|
|
|
|
* sort at the end.
|
|
|
|
*/
|
2017-06-12 22:13:57 +00:00
|
|
|
for (i = 0; !fn && i < istate->cache_nr; i++) {
|
|
|
|
const struct cache_entry *ce = istate->cache[i];
|
2007-08-09 20:42:50 +00:00
|
|
|
if (ce_stage(ce) == stage)
|
|
|
|
fn = read_one_entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!fn)
|
|
|
|
fn = read_one_entry_quick;
|
2018-11-18 16:47:56 +00:00
|
|
|
err = read_tree_recursive(r, tree, "", 0, stage, match, fn, istate);
|
2007-08-09 20:42:50 +00:00
|
|
|
if (fn == read_one_entry || err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sort the cache entry -- we need to nuke the cache tree, though.
|
|
|
|
*/
|
2017-06-12 22:13:57 +00:00
|
|
|
cache_tree_free(&istate->cache_tree);
|
|
|
|
QSORT(istate->cache, istate->cache_nr, cmp_cache_name_compare);
|
2007-08-09 20:42:50 +00:00
|
|
|
return 0;
|
2005-04-22 23:42:37 +00:00
|
|
|
}
|
|
|
|
|
2018-06-29 01:22:09 +00:00
|
|
|
struct tree *lookup_tree(struct repository *r, const struct object_id *oid)
|
2005-04-18 18:39:48 +00:00
|
|
|
{
|
2018-06-29 01:22:09 +00:00
|
|
|
struct object *obj = lookup_object(r, oid->hash);
|
2007-04-17 05:11:43 +00:00
|
|
|
if (!obj)
|
2018-06-29 01:22:09 +00:00
|
|
|
return create_object(r, oid->hash,
|
|
|
|
alloc_tree_node(r));
|
|
|
|
return object_as_type(r, obj, OBJ_TREE, 0);
|
2005-04-18 18:39:48 +00:00
|
|
|
}
|
|
|
|
|
2006-05-29 19:18:33 +00:00
|
|
|
int parse_tree_buffer(struct tree *item, void *buffer, unsigned long size)
|
|
|
|
{
|
2005-04-18 18:39:48 +00:00
|
|
|
if (item->object.parsed)
|
|
|
|
return 0;
|
|
|
|
item->object.parsed = 1;
|
2006-05-29 19:16:12 +00:00
|
|
|
item->buffer = buffer;
|
|
|
|
item->size = size;
|
|
|
|
|
2006-05-29 19:18:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
add quieter versions of parse_{tree,commit}
When we call parse_commit, it will complain to stderr if the
object does not exist or cannot be read. This means that we
may produce useless error messages if this situation is
expected (e.g., because the object is marked UNINTERESTING,
or because revs->ignore_missing_links is set).
We can fix this by adding a new "parse_X_gently" form that
takes a flag to suppress the messages. The existing
"parse_X" form is already gentle in the sense that it
returns an error rather than dying, and we could in theory
just add a "quiet" flag to it (with existing callers passing
"0"). But doing it this way means we do not have to disturb
existing callers.
Note also that the new flag is "quiet_on_missing", and not
just "quiet". We could add a flag to suppress _all_ errors,
but besides being a more invasive change (we would have to
pass the flag down to sub-functions, too), there is a good
reason not to: we would never want to use it. Missing a
linked object is expected in some circumstances, but it is
never expected to have a malformed commit, or to get a tree
when we wanted a commit. We should always complain about
these corruptions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-06-01 09:56:26 +00:00
|
|
|
int parse_tree_gently(struct tree *item, int quiet_on_missing)
|
2005-05-06 17:48:34 +00:00
|
|
|
{
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type;
|
2005-05-06 17:48:34 +00:00
|
|
|
void *buffer;
|
|
|
|
unsigned long size;
|
|
|
|
|
|
|
|
if (item->object.parsed)
|
|
|
|
return 0;
|
sha1_file: convert read_sha1_file to struct object_id
Convert read_sha1_file to take a pointer to struct object_id and rename
it read_object_file. Do the same for read_sha1_file_extended.
Convert one use in grep.c to use the new function without any other code
change, since the pointer being passed is a void pointer that is already
initialized with a pointer to struct object_id. Update the declaration
and definitions of the modified functions, and apply the following
semantic patch to convert the remaining callers:
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1.hash, E2, E3)
+ read_object_file(&E1, E2, E3)
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1->hash, E2, E3)
+ read_object_file(E1, E2, E3)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1.hash, E2, E3, E4)
+ read_object_file_extended(&E1, E2, E3, E4)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1->hash, E2, E3, E4)
+ read_object_file_extended(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:53 +00:00
|
|
|
buffer = read_object_file(&item->object.oid, &type, &size);
|
2005-05-06 17:48:34 +00:00
|
|
|
if (!buffer)
|
add quieter versions of parse_{tree,commit}
When we call parse_commit, it will complain to stderr if the
object does not exist or cannot be read. This means that we
may produce useless error messages if this situation is
expected (e.g., because the object is marked UNINTERESTING,
or because revs->ignore_missing_links is set).
We can fix this by adding a new "parse_X_gently" form that
takes a flag to suppress the messages. The existing
"parse_X" form is already gentle in the sense that it
returns an error rather than dying, and we could in theory
just add a "quiet" flag to it (with existing callers passing
"0"). But doing it this way means we do not have to disturb
existing callers.
Note also that the new flag is "quiet_on_missing", and not
just "quiet". We could add a flag to suppress _all_ errors,
but besides being a more invasive change (we would have to
pass the flag down to sub-functions, too), there is a good
reason not to: we would never want to use it. Missing a
linked object is expected in some circumstances, but it is
never expected to have a malformed commit, or to get a tree
when we wanted a commit. We should always complain about
these corruptions.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-06-01 09:56:26 +00:00
|
|
|
return quiet_on_missing ? -1 :
|
|
|
|
error("Could not read %s",
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&item->object.oid));
|
2007-02-26 19:55:59 +00:00
|
|
|
if (type != OBJ_TREE) {
|
2005-05-06 17:48:34 +00:00
|
|
|
free(buffer);
|
|
|
|
return error("Object %s not a tree",
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&item->object.oid));
|
2005-05-06 17:48:34 +00:00
|
|
|
}
|
2006-05-29 19:16:12 +00:00
|
|
|
return parse_tree_buffer(item, buffer, size);
|
2005-05-06 17:48:34 +00:00
|
|
|
}
|
2005-09-05 06:03:51 +00:00
|
|
|
|
2013-06-05 22:37:39 +00:00
|
|
|
void free_tree_buffer(struct tree *tree)
|
|
|
|
{
|
2017-06-15 23:15:46 +00:00
|
|
|
FREE_AND_NULL(tree->buffer);
|
2013-06-05 22:37:39 +00:00
|
|
|
tree->size = 0;
|
|
|
|
tree->object.parsed = 0;
|
|
|
|
}
|
|
|
|
|
2017-05-06 22:10:37 +00:00
|
|
|
struct tree *parse_tree_indirect(const struct object_id *oid)
|
2005-09-05 06:03:51 +00:00
|
|
|
{
|
2018-06-29 01:21:51 +00:00
|
|
|
struct object *obj = parse_object(the_repository, oid);
|
2005-09-05 06:03:51 +00:00
|
|
|
do {
|
|
|
|
if (!obj)
|
|
|
|
return NULL;
|
2006-07-12 03:45:31 +00:00
|
|
|
if (obj->type == OBJ_TREE)
|
2005-09-05 06:03:51 +00:00
|
|
|
return (struct tree *) obj;
|
2006-07-12 03:45:31 +00:00
|
|
|
else if (obj->type == OBJ_COMMIT)
|
2018-04-06 19:09:38 +00:00
|
|
|
obj = &(get_commit_tree(((struct commit *)obj))->object);
|
2006-07-12 03:45:31 +00:00
|
|
|
else if (obj->type == OBJ_TAG)
|
2005-09-05 06:03:51 +00:00
|
|
|
obj = ((struct tag *) obj)->tagged;
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
if (!obj->parsed)
|
2018-06-29 01:21:51 +00:00
|
|
|
parse_object(the_repository, &obj->oid);
|
2005-09-05 06:03:51 +00:00
|
|
|
} while (1);
|
|
|
|
}
|