3 #include "repository.h"
4 #include "object-store.h"
12 static struct object_id current_commit_oid
;
14 void walker_say(struct walker
*walker
, const char *fmt
, ...)
16 if (walker
->get_verbosely
) {
19 vfprintf(stderr
, fmt
, ap
);
24 static void report_missing(const struct object
*obj
)
26 fprintf(stderr
, "Cannot obtain needed %s %s\n",
27 obj
->type
? type_name(obj
->type
): "object",
28 oid_to_hex(&obj
->oid
));
29 if (!is_null_oid(¤t_commit_oid
))
30 fprintf(stderr
, "while processing commit %s.\n",
31 oid_to_hex(¤t_commit_oid
));
34 static int process(struct walker
*walker
, struct object
*obj
);
36 static int process_tree(struct walker
*walker
, struct tree
*tree
)
38 struct tree_desc desc
;
39 struct name_entry entry
;
44 init_tree_desc(&desc
, tree
->buffer
, tree
->size
);
45 while (tree_entry(&desc
, &entry
)) {
46 struct object
*obj
= NULL
;
48 /* submodule commits are not stored in the superproject */
49 if (S_ISGITLINK(entry
.mode
))
51 if (S_ISDIR(entry
.mode
)) {
52 struct tree
*tree
= lookup_tree(entry
.oid
);
57 struct blob
*blob
= lookup_blob(entry
.oid
);
61 if (!obj
|| process(walker
, obj
))
64 free_tree_buffer(tree
);
68 /* Remember to update object flag allocation in object.h */
69 #define COMPLETE (1U << 0)
70 #define SEEN (1U << 1)
71 #define TO_SCAN (1U << 2)
73 static struct commit_list
*complete
= NULL
;
75 static int process_commit(struct walker
*walker
, struct commit
*commit
)
77 struct commit_list
*parents
;
79 if (parse_commit(commit
))
82 while (complete
&& complete
->item
->date
>= commit
->date
) {
83 pop_most_recent_commit(&complete
, COMPLETE
);
86 if (commit
->object
.flags
& COMPLETE
)
89 oidcpy(¤t_commit_oid
, &commit
->object
.oid
);
91 walker_say(walker
, "walk %s\n", oid_to_hex(&commit
->object
.oid
));
93 if (process(walker
, &get_commit_tree(commit
)->object
))
96 for (parents
= commit
->parents
; parents
; parents
= parents
->next
) {
97 if (process(walker
, &parents
->item
->object
))
104 static int process_tag(struct walker
*walker
, struct tag
*tag
)
108 return process(walker
, tag
->tagged
);
111 static struct object_list
*process_queue
= NULL
;
112 static struct object_list
**process_queue_end
= &process_queue
;
114 static int process_object(struct walker
*walker
, struct object
*obj
)
116 if (obj
->type
== OBJ_COMMIT
) {
117 if (process_commit(walker
, (struct commit
*)obj
))
121 if (obj
->type
== OBJ_TREE
) {
122 if (process_tree(walker
, (struct tree
*)obj
))
126 if (obj
->type
== OBJ_BLOB
) {
129 if (obj
->type
== OBJ_TAG
) {
130 if (process_tag(walker
, (struct tag
*)obj
))
134 return error("Unable to determine requirements "
136 type_name(obj
->type
), oid_to_hex(&obj
->oid
));
139 static int process(struct walker
*walker
, struct object
*obj
)
141 if (obj
->flags
& SEEN
)
145 if (has_object_file(&obj
->oid
)) {
146 /* We already have it, so we should scan it now. */
147 obj
->flags
|= TO_SCAN
;
150 if (obj
->flags
& COMPLETE
)
152 walker
->prefetch(walker
, obj
->oid
.hash
);
155 object_list_insert(obj
, process_queue_end
);
156 process_queue_end
= &(*process_queue_end
)->next
;
160 static int loop(struct walker
*walker
)
162 struct object_list
*elem
;
164 while (process_queue
) {
165 struct object
*obj
= process_queue
->item
;
166 elem
= process_queue
;
167 process_queue
= elem
->next
;
170 process_queue_end
= &process_queue
;
172 /* If we are not scanning this object, we placed it in
173 * the queue because we needed to fetch it first.
175 if (! (obj
->flags
& TO_SCAN
)) {
176 if (walker
->fetch(walker
, obj
->oid
.hash
)) {
182 parse_object(the_repository
, &obj
->oid
);
183 if (process_object(walker
, obj
))
189 static int interpret_target(struct walker
*walker
, char *target
, struct object_id
*oid
)
191 if (!get_oid_hex(target
, oid
))
193 if (!check_refname_format(target
, 0)) {
194 struct ref
*ref
= alloc_ref(target
);
195 if (!walker
->fetch_ref(walker
, ref
)) {
196 oidcpy(oid
, &ref
->old_oid
);
205 static int mark_complete(const char *path
, const struct object_id
*oid
,
206 int flag
, void *cb_data
)
208 struct commit
*commit
= lookup_commit_reference_gently(oid
, 1);
211 commit
->object
.flags
|= COMPLETE
;
212 commit_list_insert(commit
, &complete
);
217 int walker_targets_stdin(char ***target
, const char ***write_ref
)
219 int targets
= 0, targets_alloc
= 0;
220 struct strbuf buf
= STRBUF_INIT
;
221 *target
= NULL
; *write_ref
= NULL
;
226 if (strbuf_getline_lf(&buf
, stdin
) == EOF
)
229 rf_one
= strchr(tg_one
, '\t');
233 if (targets
>= targets_alloc
) {
234 targets_alloc
= targets_alloc
? targets_alloc
* 2 : 64;
235 REALLOC_ARRAY(*target
, targets_alloc
);
236 REALLOC_ARRAY(*write_ref
, targets_alloc
);
238 (*target
)[targets
] = xstrdup(tg_one
);
239 (*write_ref
)[targets
] = xstrdup_or_null(rf_one
);
242 strbuf_release(&buf
);
246 void walker_targets_free(int targets
, char **target
, const char **write_ref
)
249 free(target
[targets
]);
251 free((char *) write_ref
[targets
]);
255 int walker_fetch(struct walker
*walker
, int targets
, char **target
,
256 const char **write_ref
, const char *write_ref_log_details
)
258 struct strbuf refname
= STRBUF_INIT
;
259 struct strbuf err
= STRBUF_INIT
;
260 struct ref_transaction
*transaction
= NULL
;
261 struct object_id
*oids
= xmalloc(targets
* sizeof(struct object_id
));
265 save_commit_buffer
= 0;
268 transaction
= ref_transaction_begin(&err
);
270 error("%s", err
.buf
);
275 if (!walker
->get_recover
) {
276 for_each_ref(mark_complete
, NULL
);
277 commit_list_sort_by_date(&complete
);
280 for (i
= 0; i
< targets
; i
++) {
281 if (interpret_target(walker
, target
[i
], oids
+ i
)) {
282 error("Could not interpret response from server '%s' as something to pull", target
[i
]);
285 if (process(walker
, lookup_unknown_object(oids
[i
].hash
)))
295 if (write_ref_log_details
) {
296 msg
= xstrfmt("fetch from %s", write_ref_log_details
);
300 for (i
= 0; i
< targets
; i
++) {
303 strbuf_reset(&refname
);
304 strbuf_addf(&refname
, "refs/%s", write_ref
[i
]);
305 if (ref_transaction_update(transaction
, refname
.buf
,
307 msg
? msg
: "fetch (unknown)",
309 error("%s", err
.buf
);
313 if (ref_transaction_commit(transaction
, &err
)) {
314 error("%s", err
.buf
);
321 ref_transaction_free(transaction
);
324 strbuf_release(&err
);
325 strbuf_release(&refname
);
329 void walker_free(struct walker
*walker
)
331 walker
->cleanup(walker
);