2005-04-09 16:53:05 +00:00
|
|
|
/*
|
|
|
|
* Check-out files from the "current cache directory"
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005 Linus Torvalds
|
|
|
|
*
|
|
|
|
* Careful: order of argument flags does matter. For example,
|
|
|
|
*
|
2005-09-08 00:26:23 +00:00
|
|
|
* git-checkout-index -a -f file.c
|
2005-04-09 16:53:05 +00:00
|
|
|
*
|
|
|
|
* Will first check out all files listed in the cache (but not
|
|
|
|
* overwrite any old ones), and then force-checkout "file.c" a
|
|
|
|
* second time (ie that one _will_ overwrite any old contents
|
|
|
|
* with the same filename).
|
|
|
|
*
|
2005-09-08 00:26:23 +00:00
|
|
|
* Also, just doing "git-checkout-index" does nothing. You probably
|
|
|
|
* meant "git-checkout-index -a". And if you want to force it, you
|
|
|
|
* want "git-checkout-index -f -a".
|
2005-04-09 16:53:05 +00:00
|
|
|
*
|
|
|
|
* Intuitiveness is not the goal here. Repeatability is. The
|
|
|
|
* reason for the "no arguments means no work" thing is that
|
|
|
|
* from scripts you are supposed to be able to do things like
|
|
|
|
*
|
2005-09-08 00:26:23 +00:00
|
|
|
* find . -name '*.h' -print0 | xargs -0 git-checkout-index -f --
|
2005-04-09 16:53:05 +00:00
|
|
|
*
|
2006-03-01 02:43:33 +00:00
|
|
|
* or:
|
|
|
|
*
|
|
|
|
* find . -name '*.h' -print0 | git-checkout-index -f -z --stdin
|
|
|
|
*
|
2005-04-09 16:53:05 +00:00
|
|
|
* which will force all existing *.h files to be replaced with
|
|
|
|
* their cached copies. If an empty command line implied "all",
|
|
|
|
* then this would force-refresh everything in the cache, which
|
|
|
|
* was not the point.
|
|
|
|
*
|
|
|
|
* Oh, and the "--" is just a good idea when you know the rest
|
|
|
|
* will be filenames. Just so that you wouldn't have a filename
|
|
|
|
* of "-a" causing problems (not possible in the above example,
|
|
|
|
* but get used to it in scripting!).
|
|
|
|
*/
|
2007-07-14 23:14:45 +00:00
|
|
|
#include "builtin.h"
|
2005-04-09 16:53:05 +00:00
|
|
|
#include "cache.h"
|
2006-03-01 02:43:33 +00:00
|
|
|
#include "quote.h"
|
2006-04-25 04:18:58 +00:00
|
|
|
#include "cache-tree.h"
|
2005-04-09 16:53:05 +00:00
|
|
|
|
2006-03-05 08:24:15 +00:00
|
|
|
#define CHECKOUT_ALL 4
|
|
|
|
static int line_termination = '\n';
|
2005-12-07 08:29:51 +00:00
|
|
|
static int checkout_stage; /* default to checkout stage0 */
|
2006-03-05 08:24:15 +00:00
|
|
|
static int to_tempfile;
|
2006-08-26 14:09:17 +00:00
|
|
|
static char topath[4][PATH_MAX + 1];
|
2005-11-26 08:22:48 +00:00
|
|
|
|
2006-07-08 18:34:02 +00:00
|
|
|
static struct checkout state;
|
2005-04-09 16:53:05 +00:00
|
|
|
|
2006-08-04 08:23:19 +00:00
|
|
|
static void write_tempfile_record(const char *name, int prefix_length)
|
2006-03-05 08:24:15 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (CHECKOUT_ALL == checkout_stage) {
|
|
|
|
for (i = 1; i < 4; i++) {
|
|
|
|
if (i > 1)
|
|
|
|
putchar(' ');
|
|
|
|
if (topath[i][0])
|
|
|
|
fputs(topath[i], stdout);
|
|
|
|
else
|
|
|
|
putchar('.');
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
fputs(topath[checkout_stage], stdout);
|
|
|
|
|
|
|
|
putchar('\t');
|
|
|
|
write_name_quoted("", 0, name + prefix_length,
|
|
|
|
line_termination, stdout);
|
|
|
|
putchar(line_termination);
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
topath[i][0] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-04 08:23:19 +00:00
|
|
|
static int checkout_file(const char *name, int prefix_length)
|
2005-04-09 16:53:05 +00:00
|
|
|
{
|
2005-12-07 08:29:51 +00:00
|
|
|
int namelen = strlen(name);
|
|
|
|
int pos = cache_name_pos(name, namelen);
|
|
|
|
int has_same_name = 0;
|
2006-03-05 08:24:15 +00:00
|
|
|
int did_checkout = 0;
|
|
|
|
int errs = 0;
|
2005-12-07 08:29:51 +00:00
|
|
|
|
|
|
|
if (pos < 0)
|
|
|
|
pos = -pos - 1;
|
|
|
|
|
|
|
|
while (pos < active_nr) {
|
|
|
|
struct cache_entry *ce = active_cache[pos];
|
2005-12-14 05:39:56 +00:00
|
|
|
if (ce_namelen(ce) != namelen ||
|
2005-12-07 08:29:51 +00:00
|
|
|
memcmp(ce->name, name, namelen))
|
|
|
|
break;
|
|
|
|
has_same_name = 1;
|
|
|
|
pos++;
|
2006-03-05 08:24:15 +00:00
|
|
|
if (ce_stage(ce) != checkout_stage
|
|
|
|
&& (CHECKOUT_ALL != checkout_stage || !ce_stage(ce)))
|
|
|
|
continue;
|
|
|
|
did_checkout = 1;
|
|
|
|
if (checkout_entry(ce, &state,
|
|
|
|
to_tempfile ? topath[ce_stage(ce)] : NULL) < 0)
|
|
|
|
errs++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (did_checkout) {
|
|
|
|
if (to_tempfile)
|
2006-08-04 08:23:19 +00:00
|
|
|
write_tempfile_record(name, prefix_length);
|
2006-03-05 08:24:15 +00:00
|
|
|
return errs > 0 ? -1 : 0;
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
2005-12-07 08:29:51 +00:00
|
|
|
|
|
|
|
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;
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
|
|
|
|
2006-08-14 20:20:12 +00:00
|
|
|
static void checkout_all(const char *prefix, int prefix_length)
|
2005-04-09 16:53:05 +00:00
|
|
|
{
|
2005-10-03 19:44:48 +00:00
|
|
|
int i, errs = 0;
|
2006-04-02 11:13:01 +00:00
|
|
|
struct cache_entry* last_ce = NULL;
|
2005-04-09 16:53:05 +00:00
|
|
|
|
|
|
|
for (i = 0; i < active_nr ; i++) {
|
|
|
|
struct cache_entry *ce = active_cache[i];
|
2006-03-05 08:24:15 +00:00
|
|
|
if (ce_stage(ce) != checkout_stage
|
|
|
|
&& (CHECKOUT_ALL != checkout_stage || !ce_stage(ce)))
|
2005-04-18 01:39:14 +00:00
|
|
|
continue;
|
2005-11-26 08:22:48 +00:00
|
|
|
if (prefix && *prefix &&
|
2005-12-07 08:29:51 +00:00
|
|
|
(ce_namelen(ce) <= prefix_length ||
|
|
|
|
memcmp(prefix, ce->name, prefix_length)))
|
2005-11-26 08:22:48 +00:00
|
|
|
continue;
|
2006-03-05 08:24:15 +00:00
|
|
|
if (last_ce && to_tempfile) {
|
|
|
|
if (ce_namelen(last_ce) != ce_namelen(ce)
|
|
|
|
|| memcmp(last_ce->name, ce->name, ce_namelen(ce)))
|
2006-08-04 08:23:19 +00:00
|
|
|
write_tempfile_record(last_ce->name, prefix_length);
|
2006-03-05 08:24:15 +00:00
|
|
|
}
|
|
|
|
if (checkout_entry(ce, &state,
|
|
|
|
to_tempfile ? topath[ce_stage(ce)] : NULL) < 0)
|
2005-10-03 19:44:48 +00:00
|
|
|
errs++;
|
2006-03-05 08:24:15 +00:00
|
|
|
last_ce = ce;
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
2006-03-05 08:24:15 +00:00
|
|
|
if (last_ce && to_tempfile)
|
2006-08-04 08:23:19 +00:00
|
|
|
write_tempfile_record(last_ce->name, prefix_length);
|
2005-10-03 19:44:48 +00:00
|
|
|
if (errs)
|
|
|
|
/* we have already done our error reporting.
|
|
|
|
* exit with the same code as die().
|
|
|
|
*/
|
|
|
|
exit(128);
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
|
|
|
|
2005-07-29 09:01:26 +00:00
|
|
|
static const char checkout_cache_usage[] =
|
2006-03-05 08:24:15 +00:00
|
|
|
"git-checkout-index [-u] [-q] [-a] [-f] [-n] [--stage=[123]|all] [--prefix=<string>] [--temp] [--] <file>...";
|
2005-07-14 03:25:07 +00:00
|
|
|
|
2006-06-06 19:51:49 +00:00
|
|
|
static struct lock_file lock_file;
|
2005-08-13 15:29:32 +00:00
|
|
|
|
2006-08-04 08:23:19 +00:00
|
|
|
int cmd_checkout_index(int argc, const char **argv, const char *prefix)
|
2005-04-09 16:53:05 +00:00
|
|
|
{
|
2005-10-18 00:32:12 +00:00
|
|
|
int i;
|
2005-05-15 21:23:12 +00:00
|
|
|
int newfd = -1;
|
2005-10-18 00:32:12 +00:00
|
|
|
int all = 0;
|
2006-03-01 02:43:33 +00:00
|
|
|
int read_from_stdin = 0;
|
2006-08-04 08:23:19 +00:00
|
|
|
int prefix_length;
|
2005-04-09 16:53:05 +00:00
|
|
|
|
2006-02-09 05:15:24 +00:00
|
|
|
git_config(git_default_config);
|
2006-08-04 08:23:19 +00:00
|
|
|
state.base_dir = "";
|
2005-11-26 08:22:48 +00:00
|
|
|
prefix_length = prefix ? strlen(prefix) : 0;
|
|
|
|
|
2005-04-09 16:53:05 +00:00
|
|
|
if (read_cache() < 0) {
|
2005-04-13 09:28:48 +00:00
|
|
|
die("invalid cache");
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
2005-10-18 00:32:12 +00:00
|
|
|
|
|
|
|
if (!strcmp(arg, "--")) {
|
|
|
|
i++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "-a") || !strcmp(arg, "--all")) {
|
|
|
|
all = 1;
|
|
|
|
continue;
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
2005-10-18 00:32:12 +00:00
|
|
|
if (!strcmp(arg, "-f") || !strcmp(arg, "--force")) {
|
|
|
|
state.force = 1;
|
|
|
|
continue;
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
2005-10-18 00:32:12 +00:00
|
|
|
if (!strcmp(arg, "-q") || !strcmp(arg, "--quiet")) {
|
|
|
|
state.quiet = 1;
|
|
|
|
continue;
|
2005-05-15 21:23:12 +00:00
|
|
|
}
|
2005-10-18 00:32:12 +00:00
|
|
|
if (!strcmp(arg, "-n") || !strcmp(arg, "--no-create")) {
|
|
|
|
state.not_new = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "-u") || !strcmp(arg, "--index")) {
|
|
|
|
state.refresh_cache = 1;
|
|
|
|
if (newfd < 0)
|
_GIT_INDEX_OUTPUT: allow plumbing to output to an alternative index file.
When defined, this allows plumbing commands that update the
index (add, apply, checkout-index, merge-recursive, mv,
read-tree, rm, update-index, and write-tree) to write their
resulting index to an alternative index file while holding a
lock to the original index file. With this, git-commit that
jumps the index does not have to make an extra copy of the index
file, and more importantly, it can do the update while holding
the lock on the index.
However, I think the interface to let an environment variable
specify the output is a mistake, as shown in the documentation.
If a curious user has the environment variable set to something
other than the file GIT_INDEX_FILE points at, almost everything
will break. This should instead be a command line parameter to
tell these plumbing commands to write the result in the named
file, to prevent stupid mistakes.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-04-01 06:09:02 +00:00
|
|
|
newfd = hold_locked_index(&lock_file, 1);
|
2005-10-18 00:32:12 +00:00
|
|
|
continue;
|
2005-05-15 21:23:12 +00:00
|
|
|
}
|
2006-03-01 02:43:33 +00:00
|
|
|
if (!strcmp(arg, "-z")) {
|
|
|
|
line_termination = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(arg, "--stdin")) {
|
|
|
|
if (i != argc - 1)
|
|
|
|
die("--stdin must be at the end");
|
|
|
|
read_from_stdin = 1;
|
|
|
|
i++; /* do not consider arg as a file name */
|
|
|
|
break;
|
|
|
|
}
|
2006-03-05 08:24:15 +00:00
|
|
|
if (!strcmp(arg, "--temp")) {
|
|
|
|
to_tempfile = 1;
|
|
|
|
continue;
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(arg, "--prefix=")) {
|
2005-10-18 00:32:12 +00:00
|
|
|
state.base_dir = arg+9;
|
|
|
|
state.base_dir_len = strlen(state.base_dir);
|
|
|
|
continue;
|
|
|
|
}
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(arg, "--stage=")) {
|
2006-03-05 08:24:15 +00:00
|
|
|
if (!strcmp(arg + 8, "all")) {
|
|
|
|
to_tempfile = 1;
|
|
|
|
checkout_stage = CHECKOUT_ALL;
|
|
|
|
} else {
|
|
|
|
int ch = arg[8];
|
|
|
|
if ('1' <= ch && ch <= '3')
|
|
|
|
checkout_stage = arg[8] - '0';
|
|
|
|
else
|
|
|
|
die("stage should be between 1 and 3 or all");
|
|
|
|
}
|
2005-12-07 08:29:51 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-10-18 00:32:12 +00:00
|
|
|
if (arg[0] == '-')
|
|
|
|
usage(checkout_cache_usage);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-03-05 08:24:15 +00:00
|
|
|
if (state.base_dir_len || to_tempfile) {
|
2005-10-18 00:32:12 +00:00
|
|
|
/* when --prefix is specified we do not
|
|
|
|
* want to update cache.
|
|
|
|
*/
|
|
|
|
if (state.refresh_cache) {
|
|
|
|
close(newfd); newfd = -1;
|
2006-06-06 19:51:49 +00:00
|
|
|
rollback_lock_file(&lock_file);
|
2005-10-18 00:32:12 +00:00
|
|
|
}
|
|
|
|
state.refresh_cache = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check out named files first */
|
|
|
|
for ( ; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
2006-05-06 05:38:06 +00:00
|
|
|
const char *p;
|
2005-10-18 00:32:12 +00:00
|
|
|
|
|
|
|
if (all)
|
|
|
|
die("git-checkout-index: don't mix '--all' and explicit filenames");
|
2006-03-01 02:43:33 +00:00
|
|
|
if (read_from_stdin)
|
|
|
|
die("git-checkout-index: don't mix '--stdin' and explicit filenames");
|
2006-05-06 05:38:06 +00:00
|
|
|
p = prefix_path(prefix, prefix_length, arg);
|
2006-08-04 08:23:19 +00:00
|
|
|
checkout_file(p, prefix_length);
|
2006-05-06 22:02:53 +00:00
|
|
|
if (p < arg || p > arg + strlen(arg))
|
2006-05-06 05:38:06 +00:00
|
|
|
free((char*)p);
|
2005-04-09 16:53:05 +00:00
|
|
|
}
|
2005-05-15 21:23:12 +00:00
|
|
|
|
2006-03-01 02:43:33 +00:00
|
|
|
if (read_from_stdin) {
|
|
|
|
struct strbuf buf;
|
|
|
|
if (all)
|
|
|
|
die("git-checkout-index: don't mix '--all' and '--stdin'");
|
2007-09-10 10:35:04 +00:00
|
|
|
strbuf_init(&buf, 0);
|
2006-03-01 02:43:33 +00:00
|
|
|
while (1) {
|
|
|
|
char *path_name;
|
2006-05-06 05:38:06 +00:00
|
|
|
const char *p;
|
2007-09-17 09:19:04 +00:00
|
|
|
if (strbuf_getline(&buf, stdin, line_termination) == EOF)
|
2006-03-01 02:43:33 +00:00
|
|
|
break;
|
|
|
|
if (line_termination && buf.buf[0] == '"')
|
|
|
|
path_name = unquote_c_style(buf.buf, NULL);
|
|
|
|
else
|
|
|
|
path_name = buf.buf;
|
2006-05-06 05:38:06 +00:00
|
|
|
p = prefix_path(prefix, prefix_length, path_name);
|
2006-08-04 08:23:19 +00:00
|
|
|
checkout_file(p, prefix_length);
|
2006-05-06 22:02:53 +00:00
|
|
|
if (p < path_name || p > path_name + strlen(path_name))
|
2006-05-06 05:38:06 +00:00
|
|
|
free((char *)p);
|
2006-03-01 02:43:33 +00:00
|
|
|
if (path_name != buf.buf)
|
|
|
|
free(path_name);
|
|
|
|
}
|
2007-09-17 09:19:04 +00:00
|
|
|
strbuf_release(&buf);
|
2006-03-01 02:43:33 +00:00
|
|
|
}
|
|
|
|
|
2005-10-18 00:32:12 +00:00
|
|
|
if (all)
|
2006-08-04 08:23:19 +00:00
|
|
|
checkout_all(prefix, prefix_length);
|
2005-10-18 00:32:12 +00:00
|
|
|
|
2005-05-15 21:23:12 +00:00
|
|
|
if (0 <= newfd &&
|
|
|
|
(write_cache(newfd, active_cache, active_nr) ||
|
_GIT_INDEX_OUTPUT: allow plumbing to output to an alternative index file.
When defined, this allows plumbing commands that update the
index (add, apply, checkout-index, merge-recursive, mv,
read-tree, rm, update-index, and write-tree) to write their
resulting index to an alternative index file while holding a
lock to the original index file. With this, git-commit that
jumps the index does not have to make an extra copy of the index
file, and more importantly, it can do the update while holding
the lock on the index.
However, I think the interface to let an environment variable
specify the output is a mistake, as shown in the documentation.
If a curious user has the environment variable set to something
other than the file GIT_INDEX_FILE points at, almost everything
will break. This should instead be a command line parameter to
tell these plumbing commands to write the result in the named
file, to prevent stupid mistakes.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-04-01 06:09:02 +00:00
|
|
|
close(newfd) || commit_locked_index(&lock_file)))
|
2006-06-06 19:51:49 +00:00
|
|
|
die("Unable to write new index file");
|
2005-04-09 16:53:05 +00:00
|
|
|
return 0;
|
|
|
|
}
|