Merge branch 'gl/cleanup'
[git] / builtin-read-tree.c
1 /*
2  * GIT - The information manager from hell
3  *
4  * Copyright (C) Linus Torvalds, 2005
5  */
6
7 #include "cache.h"
8 #include "object.h"
9 #include "tree.h"
10 #include "tree-walk.h"
11 #include "cache-tree.h"
12 #include "unpack-trees.h"
13 #include "builtin.h"
14
15 static struct object_list *trees;
16
17 static int list_tree(unsigned char *sha1)
18 {
19         struct tree *tree = parse_tree_indirect(sha1);
20         if (!tree)
21                 return -1;
22         object_list_append(&tree->object, &trees);
23         return 0;
24 }
25
26 static int read_cache_unmerged(void)
27 {
28         int i;
29         struct cache_entry **dst;
30         struct cache_entry *last = NULL;
31
32         read_cache();
33         dst = active_cache;
34         for (i = 0; i < active_nr; i++) {
35                 struct cache_entry *ce = active_cache[i];
36                 if (ce_stage(ce)) {
37                         if (last && !strcmp(ce->name, last->name))
38                                 continue;
39                         cache_tree_invalidate_path(active_cache_tree, ce->name);
40                         last = ce;
41                         ce->ce_mode = 0;
42                         ce->ce_flags &= ~htons(CE_STAGEMASK);
43                 }
44                 *dst++ = ce;
45         }
46         active_nr = dst - active_cache;
47         return !!last;
48 }
49
50 static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
51 {
52         struct tree_desc desc;
53         struct name_entry entry;
54         int cnt;
55
56         hashcpy(it->sha1, tree->object.sha1);
57         desc.buf = tree->buffer;
58         desc.size = tree->size;
59         cnt = 0;
60         while (tree_entry(&desc, &entry)) {
61                 if (!S_ISDIR(entry.mode))
62                         cnt++;
63                 else {
64                         struct cache_tree_sub *sub;
65                         struct tree *subtree = lookup_tree(entry.sha1);
66                         if (!subtree->object.parsed)
67                                 parse_tree(subtree);
68                         sub = cache_tree_sub(it, entry.path);
69                         sub->cache_tree = cache_tree();
70                         prime_cache_tree_rec(sub->cache_tree, subtree);
71                         cnt += sub->cache_tree->entry_count;
72                 }
73         }
74         it->entry_count = cnt;
75 }
76
77 static void prime_cache_tree(void)
78 {
79         struct tree *tree = (struct tree *)trees->item;
80         if (!tree)
81                 return;
82         active_cache_tree = cache_tree();
83         prime_cache_tree_rec(active_cache_tree, tree);
84
85 }
86
87 static const char read_tree_usage[] = "git-read-tree (<sha> | [[-m [--aggressive] | --reset | --prefix=<prefix>] [-u | -i]] <sha1> [<sha2> [<sha3>]])";
88
89 static struct lock_file lock_file;
90
91 int cmd_read_tree(int argc, const char **argv, const char *unused_prefix)
92 {
93         int i, newfd, stage = 0;
94         unsigned char sha1[20];
95         struct unpack_trees_options opts;
96
97         memset(&opts, 0, sizeof(opts));
98         opts.head_idx = -1;
99
100         setup_git_directory();
101         git_config(git_default_config);
102
103         newfd = hold_lock_file_for_update(&lock_file, get_index_file(), 1);
104
105         git_config(git_default_config);
106
107         for (i = 1; i < argc; i++) {
108                 const char *arg = argv[i];
109
110                 /* "-u" means "update", meaning that a merge will update
111                  * the working tree.
112                  */
113                 if (!strcmp(arg, "-u")) {
114                         opts.update = 1;
115                         continue;
116                 }
117
118                 if (!strcmp(arg, "-v")) {
119                         opts.verbose_update = 1;
120                         continue;
121                 }
122
123                 /* "-i" means "index only", meaning that a merge will
124                  * not even look at the working tree.
125                  */
126                 if (!strcmp(arg, "-i")) {
127                         opts.index_only = 1;
128                         continue;
129                 }
130
131                 /* "--prefix=<subdirectory>/" means keep the current index
132                  *  entries and put the entries from the tree under the
133                  * given subdirectory.
134                  */
135                 if (!strncmp(arg, "--prefix=", 9)) {
136                         if (stage || opts.merge || opts.prefix)
137                                 usage(read_tree_usage);
138                         opts.prefix = arg + 9;
139                         opts.merge = 1;
140                         stage = 1;
141                         if (read_cache_unmerged())
142                                 die("you need to resolve your current index first");
143                         continue;
144                 }
145
146                 /* This differs from "-m" in that we'll silently ignore
147                  * unmerged entries and overwrite working tree files that
148                  * correspond to them.
149                  */
150                 if (!strcmp(arg, "--reset")) {
151                         if (stage || opts.merge || opts.prefix)
152                                 usage(read_tree_usage);
153                         opts.reset = 1;
154                         opts.merge = 1;
155                         stage = 1;
156                         read_cache_unmerged();
157                         continue;
158                 }
159
160                 if (!strcmp(arg, "--trivial")) {
161                         opts.trivial_merges_only = 1;
162                         continue;
163                 }
164
165                 if (!strcmp(arg, "--aggressive")) {
166                         opts.aggressive = 1;
167                         continue;
168                 }
169
170                 /* "-m" stands for "merge", meaning we start in stage 1 */
171                 if (!strcmp(arg, "-m")) {
172                         if (stage || opts.merge || opts.prefix)
173                                 usage(read_tree_usage);
174                         if (read_cache_unmerged())
175                                 die("you need to resolve your current index first");
176                         stage = 1;
177                         opts.merge = 1;
178                         continue;
179                 }
180
181                 /* using -u and -i at the same time makes no sense */
182                 if (1 < opts.index_only + opts.update)
183                         usage(read_tree_usage);
184
185                 if (get_sha1(arg, sha1))
186                         die("Not a valid object name %s", arg);
187                 if (list_tree(sha1) < 0)
188                         die("failed to unpack tree object %s", arg);
189                 stage++;
190         }
191         if ((opts.update||opts.index_only) && !opts.merge)
192                 usage(read_tree_usage);
193
194         if (opts.prefix) {
195                 int pfxlen = strlen(opts.prefix);
196                 int pos;
197                 if (opts.prefix[pfxlen-1] != '/')
198                         die("prefix must end with /");
199                 if (stage != 2)
200                         die("binding merge takes only one tree");
201                 pos = cache_name_pos(opts.prefix, pfxlen);
202                 if (0 <= pos)
203                         die("corrupt index file");
204                 pos = -pos-1;
205                 if (pos < active_nr &&
206                     !strncmp(active_cache[pos]->name, opts.prefix, pfxlen))
207                         die("subdirectory '%s' already exists.", opts.prefix);
208                 pos = cache_name_pos(opts.prefix, pfxlen-1);
209                 if (0 <= pos)
210                         die("file '%.*s' already exists.",
211                                         pfxlen-1, opts.prefix);
212         }
213
214         if (opts.merge) {
215                 if (stage < 2)
216                         die("just how do you expect me to merge %d trees?", stage-1);
217                 switch (stage - 1) {
218                 case 1:
219                         opts.fn = opts.prefix ? bind_merge : oneway_merge;
220                         break;
221                 case 2:
222                         opts.fn = twoway_merge;
223                         break;
224                 case 3:
225                 default:
226                         opts.fn = threeway_merge;
227                         cache_tree_free(&active_cache_tree);
228                         break;
229                 }
230
231                 if (stage - 1 >= 3)
232                         opts.head_idx = stage - 2;
233                 else
234                         opts.head_idx = 1;
235         }
236
237         unpack_trees(trees, &opts);
238
239         /*
240          * When reading only one tree (either the most basic form,
241          * "-m ent" or "--reset ent" form), we can obtain a fully
242          * valid cache-tree because the index must match exactly
243          * what came from the tree.
244          */
245         if (trees && trees->item && !opts.prefix && (!opts.merge || (stage == 2))) {
246                 cache_tree_free(&active_cache_tree);
247                 prime_cache_tree();
248         }
249
250         if (write_cache(newfd, active_cache, active_nr) ||
251             close(newfd) || commit_lock_file(&lock_file))
252                 die("unable to write new index file");
253         return 0;
254 }