#include "cache.h"
#include "commit.h"
#include "tree.h"
+#include "tree-walk.h"
#include "tag.h"
#include "blob.h"
#include "refs.h"
const char *write_ref = NULL;
-
-const unsigned char *current_ref = NULL;
+const char *write_ref_log_details = NULL;
int get_tree = 0;
int get_history = 0;
int get_all = 0;
int get_verbosely = 0;
+int get_recover = 0;
static unsigned char current_commit_sha1[20];
void pull_say(const char *fmt, const char *hex)
static int process_tree(struct tree *tree)
{
- struct tree_entry_list *entry;
+ struct tree_desc desc;
+ struct name_entry entry;
if (parse_tree(tree))
return -1;
- entry = tree->entries;
- tree->entries = NULL;
- while (entry) {
- struct tree_entry_list *next = entry->next;
- if (process(entry->item.any))
+ desc.buf = tree->buffer;
+ desc.size = tree->size;
+ while (tree_entry(&desc, &entry)) {
+ struct object *obj = NULL;
+
+ if (S_ISDIR(entry.mode)) {
+ struct tree *tree = lookup_tree(entry.sha1);
+ if (tree)
+ obj = &tree->object;
+ }
+ else {
+ struct blob *blob = lookup_blob(entry.sha1);
+ if (blob)
+ obj = &blob->object;
+ }
+ if (!obj || process(obj))
return -1;
- free(entry);
- entry = next;
}
+ free(tree->buffer);
+ tree->buffer = NULL;
+ tree->size = 0;
return 0;
}
-#define COMPLETE 1U
-#define TO_FETCH 2U
-#define TO_SCAN 4U
-#define SEEN 16U
+#define COMPLETE (1U << 0)
+#define SEEN (1U << 1)
+#define TO_SCAN (1U << 2)
static struct commit_list *complete = NULL;
static int process_object(struct object *obj)
{
- if (obj->type == commit_type) {
+ if (obj->type == TYPE_COMMIT) {
if (process_commit((struct commit *)obj))
return -1;
return 0;
}
- if (obj->type == tree_type) {
+ if (obj->type == TYPE_TREE) {
if (process_tree((struct tree *)obj))
return -1;
return 0;
}
- if (obj->type == blob_type) {
+ if (obj->type == TYPE_BLOB) {
return 0;
}
- if (obj->type == tag_type) {
+ if (obj->type == TYPE_TAG) {
if (process_tag((struct tag *)obj))
return -1;
return 0;
}
return error("Unable to determine requirements "
"of type %s for %s",
- obj->type, sha1_to_hex(obj->sha1));
+ typename(obj->type), sha1_to_hex(obj->sha1));
}
static int process(struct object *obj)
obj->flags |= SEEN;
if (has_sha1_file(obj->sha1)) {
- parse_object(obj->sha1);
/* We already have it, so we should scan it now. */
- if (obj->flags & TO_SCAN)
- return 0;
- object_list_insert(obj, process_queue_end);
- process_queue_end = &(*process_queue_end)->next;
obj->flags |= TO_SCAN;
- return 0;
}
- if (obj->flags & (COMPLETE | TO_FETCH))
- return 0;
+ else {
+ if (obj->flags & COMPLETE)
+ return 0;
+ prefetch(obj->sha1);
+ }
+
object_list_insert(obj, process_queue_end);
process_queue_end = &(*process_queue_end)->next;
- obj->flags |= TO_FETCH;
-
- prefetch(obj->sha1);
-
return 0;
}
* the queue because we needed to fetch it first.
*/
if (! (obj->flags & TO_SCAN)) {
- if (!has_sha1_file(obj->sha1) && fetch(obj->sha1)) {
- report_missing(obj->type
- ? obj->type
- : "object", obj->sha1);
+ if (fetch(obj->sha1)) {
+ report_missing(typename(obj->type), obj->sha1);
return -1;
}
}
int pull(char *target)
{
+ struct ref_lock *lock = NULL;
unsigned char sha1[20];
- int fd = -1;
+ char *msg;
+ int ret;
save_commit_buffer = 0;
- if (write_ref && current_ref) {
- fd = lock_ref_sha1(write_ref, current_ref);
- if (fd < 0)
+ track_object_refs = 0;
+ if (write_ref) {
+ lock = lock_ref_sha1(write_ref, NULL, 0);
+ if (!lock) {
+ error("Can't lock ref %s", write_ref);
return -1;
+ }
}
- for_each_ref(mark_complete);
+ if (!get_recover)
+ for_each_ref(mark_complete);
- if (interpret_target(target, sha1))
- return error("Could not interpret %s as something to pull",
- target);
- if (process(lookup_unknown_object(sha1)))
+ if (interpret_target(target, sha1)) {
+ error("Could not interpret %s as something to pull", target);
+ if (lock)
+ unlock_ref(lock);
return -1;
- if (loop())
+ }
+ if (process(lookup_unknown_object(sha1))) {
+ if (lock)
+ unlock_ref(lock);
return -1;
-
+ }
+ if (loop()) {
+ if (lock)
+ unlock_ref(lock);
+ return -1;
+ }
+
if (write_ref) {
- if (current_ref) {
- write_ref_sha1(write_ref, fd, sha1);
- } else {
- write_ref_sha1_unlocked(write_ref, sha1);
+ if (write_ref_log_details) {
+ msg = xmalloc(strlen(write_ref_log_details) + 12);
+ sprintf(msg, "fetch from %s", write_ref_log_details);
}
+ else
+ msg = NULL;
+ ret = write_ref_sha1(lock, sha1, msg ? msg : "fetch (unknown)");
+ if (msg)
+ free(msg);
+ return ret;
}
return 0;
}