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');
|
Full rework of quote_c_style and write_name_quoted.
* quote_c_style works on a strbuf instead of a wild buffer.
* quote_c_style is now clever enough to not add double quotes if not needed.
* write_name_quoted inherits those advantages, but also take a different
set of arguments. Now instead of asking for quotes or not, you pass a
"terminator". If it's \0 then we assume you don't want to escape, else C
escaping is performed. In any case, the terminator is also appended to the
stream. It also no longer takes the prefix/prefix_len arguments, as it's
seldomly used, and makes some optimizations harder.
* write_name_quotedpfx is created to work like write_name_quoted and take
the prefix/prefix_len arguments.
Thanks to those API changes, diff.c has somehow lost weight, thanks to the
removal of functions that were wrappers around the old write_name_quoted
trying to give it a semantics like the new one, but performing a lot of
allocations for this goal. Now we always write directly to the stream, no
intermediate allocation is performed.
As a side effect of the refactor in builtin-apply.c, the length of the bar
graphs in diffstats are not affected anymore by the fact that the path was
clipped.
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
2007-09-19 22:42:15 +00:00
|
|
|
write_name_quoted(name + prefix_length, stdout, line_termination);
|
2006-03-05 08:24:15 +00:00
|
|
|
|
|
|
|
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[] =
|
2008-07-13 13:36: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
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_default_config, NULL);
|
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) {
|
2006-06-06 19:51:49 +00:00
|
|
|
rollback_lock_file(&lock_file);
|
2008-01-16 19:12:46 +00:00
|
|
|
newfd = -1;
|
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) {
|
2007-09-19 22:42:14 +00:00
|
|
|
struct strbuf buf, nbuf;
|
|
|
|
|
2006-03-01 02:43:33 +00:00
|
|
|
if (all)
|
|
|
|
die("git-checkout-index: don't mix '--all' and '--stdin'");
|
2007-09-19 22:42:14 +00:00
|
|
|
|
2007-09-10 10:35:04 +00:00
|
|
|
strbuf_init(&buf, 0);
|
2007-09-19 22:42:14 +00:00
|
|
|
strbuf_init(&nbuf, 0);
|
|
|
|
while (strbuf_getline(&buf, stdin, line_termination) != EOF) {
|
2006-05-06 05:38:06 +00:00
|
|
|
const char *p;
|
2007-09-19 22:42:14 +00:00
|
|
|
if (line_termination && buf.buf[0] == '"') {
|
|
|
|
strbuf_reset(&nbuf);
|
|
|
|
if (unquote_c_style(&nbuf, buf.buf, NULL))
|
|
|
|
die("line is badly quoted");
|
|
|
|
strbuf_swap(&buf, &nbuf);
|
|
|
|
}
|
|
|
|
p = prefix_path(prefix, prefix_length, buf.buf);
|
2006-08-04 08:23:19 +00:00
|
|
|
checkout_file(p, prefix_length);
|
2007-09-19 22:42:14 +00:00
|
|
|
if (p < buf.buf || p > buf.buf + buf.len)
|
2006-05-06 05:38:06 +00:00
|
|
|
free((char *)p);
|
2006-03-01 02:43:33 +00:00
|
|
|
}
|
2007-09-19 22:42:14 +00:00
|
|
|
strbuf_release(&nbuf);
|
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) ||
|
2008-01-16 19:12:46 +00:00
|
|
|
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;
|
|
|
|
}
|