count-delta: match get_delta_hdr_size() changes.
[gitweb.git] / checkout-index.c
index 97845324beb9002a0fed0dd1184988716faa9ed2..53dd8cba6f0c56125545acd46f1091366949f89b 100644 (file)
  */
 #include "cache.h"
 
+static const char *prefix;
+static int prefix_length;
+static int checkout_stage; /* default to checkout stage0 */
+
 static struct checkout state = {
        .base_dir = "",
        .base_dir_len = 0,
@@ -45,20 +49,36 @@ static struct checkout state = {
 
 static int checkout_file(const char *name)
 {
-       int pos = cache_name_pos(name, strlen(name));
-       if (pos < 0) {
-               if (!state.quiet) {
-                       pos = -pos - 1;
-                       fprintf(stderr,
-                               "git-checkout-index: %s is %s.\n",
-                               name,
-                               (pos < active_nr &&
-                                !strcmp(active_cache[pos]->name, name)) ?
-                               "unmerged" : "not in the cache");
-               }
-               return -1;
+       int namelen = strlen(name);
+       int pos = cache_name_pos(name, namelen);
+       int has_same_name = 0;
+
+       if (pos < 0)
+               pos = -pos - 1;
+
+       while (pos < active_nr) {
+               struct cache_entry *ce = active_cache[pos];
+               if (ce_namelen(ce) != namelen ||
+                   memcmp(ce->name, name, namelen))
+                       break;
+               has_same_name = 1;
+               if (checkout_stage == ce_stage(ce))
+                       return checkout_entry(ce, &state);
+               pos++;
        }
-       return checkout_entry(active_cache[pos], &state);
+
+       if (!state.quiet) {
+               fprintf(stderr, "git-checkout-index: %s ", name);
+               if (!has_same_name)
+                       fprintf(stderr, "is not in the cache");
+               else if (checkout_stage)
+                       fprintf(stderr, "does not exist at stage %d",
+                               checkout_stage);
+               else
+                       fprintf(stderr, "is unmerged");
+               fputc('\n', stderr);
+       }
+       return -1;
 }
 
 static int checkout_all(void)
@@ -67,7 +87,11 @@ static int checkout_all(void)
 
        for (i = 0; i < active_nr ; i++) {
                struct cache_entry *ce = active_cache[i];
-               if (ce_stage(ce))
+               if (ce_stage(ce) != checkout_stage)
+                       continue;
+               if (prefix && *prefix &&
+                   (ce_namelen(ce) <= prefix_length ||
+                    memcmp(prefix, ce->name, prefix_length)))
                        continue;
                if (checkout_entry(ce, &state) < 0)
                        errs++;
@@ -81,14 +105,18 @@ static int checkout_all(void)
 }
 
 static const char checkout_cache_usage[] =
-"git-checkout-index [-u] [-q] [-a] [-f] [-n] [--prefix=<string>] [--] <file>...";
+"git-checkout-index [-u] [-q] [-a] [-f] [-n] [--stage=[123]] [--prefix=<string>] [--] <file>...";
 
 static struct cache_file cache_file;
 
 int main(int argc, char **argv)
 {
-       int i, force_filename = 0;
+       int i;
        int newfd = -1;
+       int all = 0;
+
+       prefix = setup_git_directory();
+       prefix_length = prefix ? strlen(prefix) : 0;
 
        if (read_cache() < 0) {
                die("invalid cache");
@@ -96,58 +124,78 @@ int main(int argc, char **argv)
 
        for (i = 1; i < argc; i++) {
                const char *arg = argv[i];
-               if (!force_filename) {
-                       if (!strcmp(arg, "-a")) {
-                               checkout_all();
-                               continue;
-                       }
-                       if (!strcmp(arg, "--")) {
-                               force_filename = 1;
-                               continue;
-                       }
-                       if (!strcmp(arg, "-f")) {
-                               state.force = 1;
-                               continue;
-                       }
-                       if (!strcmp(arg, "-q")) {
-                               state.quiet = 1;
-                               continue;
-                       }
-                       if (!strcmp(arg, "-n")) {
-                               state.not_new = 1;
-                               continue;
-                       }
-                       if (!strcmp(arg, "-u")) {
-                               state.refresh_cache = 1;
-                               if (newfd < 0)
-                                       newfd = hold_index_file_for_update
-                                               (&cache_file,
-                                                get_index_file());
-                               if (newfd < 0)
-                                       die("cannot open index.lock file.");
-                               continue;
-                       }
-                       if (!memcmp(arg, "--prefix=", 9)) {
-                               state.base_dir = arg+9;
-                               state.base_dir_len = strlen(state.base_dir);
-                               continue;
-                       }
-                       if (arg[0] == '-')
-                               usage(checkout_cache_usage);
+
+               if (!strcmp(arg, "--")) {
+                       i++;
+                       break;
+               }
+               if (!strcmp(arg, "-a") || !strcmp(arg, "--all")) {
+                       all = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "-f") || !strcmp(arg, "--force")) {
+                       state.force = 1;
+                       continue;
+               }
+               if (!strcmp(arg, "-q") || !strcmp(arg, "--quiet")) {
+                       state.quiet = 1;
+                       continue;
                }
-               if (state.base_dir_len) {
-                       /* when --prefix is specified we do not
-                        * want to update cache.
-                        */
-                       if (state.refresh_cache) {
-                               close(newfd); newfd = -1;
-                               rollback_index_file(&cache_file);
-                       }
-                       state.refresh_cache = 0;
+               if (!strcmp(arg, "-n") || !strcmp(arg, "--no-create")) {
+                       state.not_new = 1;
+                       continue;
                }
-               checkout_file(arg);
+               if (!strcmp(arg, "-u") || !strcmp(arg, "--index")) {
+                       state.refresh_cache = 1;
+                       if (newfd < 0)
+                               newfd = hold_index_file_for_update
+                                       (&cache_file,
+                                        get_index_file());
+                       if (newfd < 0)
+                               die("cannot open index.lock file.");
+                       continue;
+               }
+               if (!strncmp(arg, "--prefix=", 9)) {
+                       state.base_dir = arg+9;
+                       state.base_dir_len = strlen(state.base_dir);
+                       continue;
+               }
+               if (!strncmp(arg, "--stage=", 8)) {
+                       int ch = arg[8];
+                       if ('1' <= ch && ch <= '3')
+                               checkout_stage = arg[8] - '0';
+                       else
+                               die("stage should be between 1 and 3");
+                       continue;
+               }
+               if (arg[0] == '-')
+                       usage(checkout_cache_usage);
+               break;
        }
 
+       if (state.base_dir_len) {
+               /* when --prefix is specified we do not
+                * want to update cache.
+                */
+               if (state.refresh_cache) {
+                       close(newfd); newfd = -1;
+                       rollback_index_file(&cache_file);
+               }
+               state.refresh_cache = 0;
+       }
+
+       /* Check out named files first */
+       for ( ; i < argc; i++) {
+               const char *arg = argv[i];
+
+               if (all)
+                       die("git-checkout-index: don't mix '--all' and explicit filenames");
+               checkout_file(prefix_path(prefix, prefix_length, arg));
+       }
+
+       if (all)
+               checkout_all();
+
        if (0 <= newfd &&
            (write_cache(newfd, active_cache, active_nr) ||
             commit_index_file(&cache_file)))