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 "dir.h" 14#include "builtin.h" 15 16static int nr_trees; 17static struct tree *trees[MAX_UNPACK_TREES]; 18 19static int list_tree(unsigned char *sha1) 20{ 21 struct tree *tree; 22 23 if (nr_trees >= MAX_UNPACK_TREES) 24 die("I cannot read more than %d trees", MAX_UNPACK_TREES); 25 tree = parse_tree_indirect(sha1); 26 if (!tree) 27 return -1; 28 trees[nr_trees++] = tree; 29 return 0; 30} 31 32static const char read_tree_usage[] = "git read-tree (<sha> | [[-m [--trivial] [--aggressive] | --reset | --prefix=<prefix>] [-u | -i]] [--exclude-per-directory=<gitignore>] [--index-output=<file>] <sha1> [<sha2> [<sha3>]])"; 33 34static struct lock_file lock_file; 35 36int cmd_read_tree(int argc, const char **argv, const char *unused_prefix) 37{ 38 int i, newfd, stage = 0; 39 unsigned char sha1[20]; 40 struct tree_desc t[MAX_UNPACK_TREES]; 41 struct unpack_trees_options opts; 42 43 memset(&opts, 0, sizeof(opts)); 44 opts.head_idx = -1; 45 opts.src_index = &the_index; 46 opts.dst_index = &the_index; 47 48 git_config(git_default_config, NULL); 49 50 newfd = hold_locked_index(&lock_file, 1); 51 52 for (i = 1; i < argc; i++) { 53 const char *arg = argv[i]; 54 55 /* "-u" means "update", meaning that a merge will update 56 * the working tree. 57 */ 58 if (!strcmp(arg, "-u")) { 59 opts.update = 1; 60 continue; 61 } 62 63 if (!strcmp(arg, "-v")) { 64 opts.verbose_update = 1; 65 continue; 66 } 67 68 /* "-i" means "index only", meaning that a merge will 69 * not even look at the working tree. 70 */ 71 if (!strcmp(arg, "-i")) { 72 opts.index_only = 1; 73 continue; 74 } 75 76 if (!prefixcmp(arg, "--index-output=")) { 77 set_alternate_index_output(arg + 15); 78 continue; 79 } 80 81 /* "--prefix=<subdirectory>/" means keep the current index 82 * entries and put the entries from the tree under the 83 * given subdirectory. 84 */ 85 if (!prefixcmp(arg, "--prefix=")) { 86 if (stage || opts.merge || opts.prefix) 87 usage(read_tree_usage); 88 opts.prefix = arg + 9; 89 opts.merge = 1; 90 stage = 1; 91 if (read_cache_unmerged()) 92 die("you need to resolve your current index first"); 93 continue; 94 } 95 96 /* This differs from "-m" in that we'll silently ignore 97 * unmerged entries and overwrite working tree files that 98 * correspond to them. 99 */ 100 if (!strcmp(arg, "--reset")) { 101 if (stage || opts.merge || opts.prefix) 102 usage(read_tree_usage); 103 opts.reset = 1; 104 opts.merge = 1; 105 stage = 1; 106 read_cache_unmerged(); 107 continue; 108 } 109 110 if (!strcmp(arg, "--trivial")) { 111 opts.trivial_merges_only = 1; 112 continue; 113 } 114 115 if (!strcmp(arg, "--aggressive")) { 116 opts.aggressive = 1; 117 continue; 118 } 119 120 /* "-m" stands for "merge", meaning we start in stage 1 */ 121 if (!strcmp(arg, "-m")) { 122 if (stage || opts.merge || opts.prefix) 123 usage(read_tree_usage); 124 if (read_cache_unmerged()) 125 die("you need to resolve your current index first"); 126 stage = 1; 127 opts.merge = 1; 128 continue; 129 } 130 131 if (!prefixcmp(arg, "--exclude-per-directory=")) { 132 struct dir_struct *dir; 133 134 if (opts.dir) 135 die("more than one --exclude-per-directory are given."); 136 137 dir = xcalloc(1, sizeof(*opts.dir)); 138 dir->flags |= DIR_SHOW_IGNORED; 139 dir->exclude_per_dir = arg + 24; 140 opts.dir = dir; 141 /* We do not need to nor want to do read-directory 142 * here; we are merely interested in reusing the 143 * per directory ignore stack mechanism. 144 */ 145 continue; 146 } 147 148 /* using -u and -i at the same time makes no sense */ 149 if (1 < opts.index_only + opts.update) 150 usage(read_tree_usage); 151 152 if (get_sha1(arg, sha1)) 153 die("Not a valid object name %s", arg); 154 if (list_tree(sha1) < 0) 155 die("failed to unpack tree object %s", arg); 156 stage++; 157 } 158 if ((opts.update||opts.index_only) && !opts.merge) 159 usage(read_tree_usage); 160 if ((opts.dir && !opts.update)) 161 die("--exclude-per-directory is meaningless unless -u"); 162 if (opts.merge && !opts.index_only) 163 setup_work_tree(); 164 165 if (opts.merge) { 166 if (stage < 2) 167 die("just how do you expect me to merge %d trees?", stage-1); 168 switch (stage - 1) { 169 case 1: 170 opts.fn = opts.prefix ? bind_merge : oneway_merge; 171 break; 172 case 2: 173 opts.fn = twoway_merge; 174 opts.initial_checkout = is_cache_unborn(); 175 break; 176 case 3: 177 default: 178 opts.fn = threeway_merge; 179 break; 180 } 181 182 if (stage - 1 >= 3) 183 opts.head_idx = stage - 2; 184 else 185 opts.head_idx = 1; 186 } 187 188 cache_tree_free(&active_cache_tree); 189 for (i = 0; i < nr_trees; i++) { 190 struct tree *tree = trees[i]; 191 parse_tree(tree); 192 init_tree_desc(t+i, tree->buffer, tree->size); 193 } 194 if (unpack_trees(nr_trees, t, &opts)) 195 return 128; 196 197 /* 198 * When reading only one tree (either the most basic form, 199 * "-m ent" or "--reset ent" form), we can obtain a fully 200 * valid cache-tree because the index must match exactly 201 * what came from the tree. 202 * 203 * The same holds true if we are switching between two trees 204 * using read-tree -m A B. The index must match B after that. 205 */ 206 if (nr_trees == 1 && !opts.prefix) 207 prime_cache_tree(&active_cache_tree, trees[0]); 208 else if (nr_trees == 2 && opts.merge) 209 prime_cache_tree(&active_cache_tree, trees[1]); 210 211 if (write_cache(newfd, active_cache, active_nr) || 212 commit_locked_index(&lock_file)) 213 die("unable to write new index file"); 214 return 0; 215}