remote: rewrite functions to take object_id arguments
[git/git.git] / replace_object.c
CommitLineData
68095570
CC
1#include "cache.h"
2#include "sha1-lookup.h"
3#include "refs.h"
c2e86add 4#include "commit.h"
68095570 5
ce375864
MH
6/*
7 * An array of replacements. The array is kept sorted by the original
8 * sha1.
9 */
68095570 10static struct replace_object {
ce375864
MH
11 unsigned char original[20];
12 unsigned char replacement[20];
68095570
CC
13} **replace_object;
14
15static int replace_object_alloc, replace_object_nr;
16
17static const unsigned char *replace_sha1_access(size_t index, void *table)
18{
19 struct replace_object **replace = table;
ce375864 20 return replace[index]->original;
68095570
CC
21}
22
23static int replace_object_pos(const unsigned char *sha1)
24{
25 return sha1_pos(sha1, replace_object, replace_object_nr,
26 replace_sha1_access);
27}
28
29static int register_replace_object(struct replace_object *replace,
30 int ignore_dups)
31{
ce375864 32 int pos = replace_object_pos(replace->original);
68095570
CC
33
34 if (0 <= pos) {
35 if (ignore_dups)
36 free(replace);
37 else {
38 free(replace_object[pos]);
39 replace_object[pos] = replace;
40 }
41 return 1;
42 }
43 pos = -pos - 1;
72004b43
DD
44 ALLOC_GROW(replace_object, replace_object_nr + 1, replace_object_alloc);
45 replace_object_nr++;
68095570
CC
46 if (pos < replace_object_nr)
47 memmove(replace_object + pos + 1,
48 replace_object + pos,
49 (replace_object_nr - pos - 1) *
50 sizeof(*replace_object));
51 replace_object[pos] = replace;
52 return 0;
53}
54
55static int register_replace_ref(const char *refname,
56 const unsigned char *sha1,
57 int flag, void *cb_data)
58{
59 /* Get sha1 from refname */
60 const char *slash = strrchr(refname, '/');
61 const char *hash = slash ? slash + 1 : refname;
62 struct replace_object *repl_obj = xmalloc(sizeof(*repl_obj));
63
ce375864 64 if (strlen(hash) != 40 || get_sha1_hex(hash, repl_obj->original)) {
68095570
CC
65 free(repl_obj);
66 warning("bad replace ref name: %s", refname);
67 return 0;
68 }
69
70 /* Copy sha1 from the read ref */
ce375864 71 hashcpy(repl_obj->replacement, sha1);
68095570
CC
72
73 /* Register new object */
74 if (register_replace_object(repl_obj, 1))
75 die("duplicate replace ref: %s", refname);
76
77 return 0;
78}
79
80static void prepare_replace_object(void)
81{
82 static int replace_object_prepared;
2b2a5be3
MH
83 struct each_ref_fn_sha1_adapter wrapped_register_replace_ref =
84 {register_replace_ref, NULL};
68095570
CC
85
86 if (replace_object_prepared)
87 return;
88
2b2a5be3 89 for_each_replace_ref(each_ref_fn_adapter, &wrapped_register_replace_ref);
68095570 90 replace_object_prepared = 1;
e1111cef 91 if (!replace_object_nr)
afc711b8 92 check_replace_refs = 0;
68095570
CC
93}
94
95/* We allow "recursive" replacement. Only within reason, though */
96#define MAXREPLACEDEPTH 5
97
1f91e79c
MH
98/*
99 * If a replacement for object sha1 has been set up, return the
100 * replacement object's name (replaced recursively, if necessary).
101 * The return value is either sha1 or a pointer to a
102 * permanently-allocated value. This function always respects replace
103 * references, regardless of the value of check_replace_refs.
104 */
e1111cef 105const unsigned char *do_lookup_replace_object(const unsigned char *sha1)
68095570
CC
106{
107 int pos, depth = MAXREPLACEDEPTH;
108 const unsigned char *cur = sha1;
109
110 prepare_replace_object();
111
112 /* Try to recursively replace the object */
113 do {
114 if (--depth < 0)
115 die("replace depth too high for object %s",
116 sha1_to_hex(sha1));
117
118 pos = replace_object_pos(cur);
119 if (0 <= pos)
ce375864 120 cur = replace_object[pos]->replacement;
68095570
CC
121 } while (0 <= pos);
122
123 return cur;
124}