git.oblomov.eu Git - git/blob - 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 "dir.h"
  14 #include "builtin.h"
  15
  16 static int nr_trees;
  17 static struct tree *trees[MAX_UNPACK_TREES];
  18
  19 static 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
  32 static 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
  34 static struct lock_file lock_file;
  35
  36 int 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 }