2005-04-07 22:16:10 +00:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
2005-04-07 22:13:13 +00:00
|
|
|
#include "cache.h"
|
2005-09-27 01:13:08 +00:00
|
|
|
#include "strbuf.h"
|
2005-10-16 07:39:07 +00:00
|
|
|
#include "quote.h"
|
2006-04-24 07:23:54 +00:00
|
|
|
#include "cache-tree.h"
|
2006-04-20 06:52:05 +00:00
|
|
|
#include "tree-walk.h"
|
2006-06-13 20:21:57 +00:00
|
|
|
#include "builtin.h"
|
2005-04-07 22:13:13 +00:00
|
|
|
|
2005-04-10 18:32:54 +00:00
|
|
|
/*
|
|
|
|
* Default to not allowing changes to the list of files. The
|
|
|
|
* tool doesn't actually care, but this makes it harder to add
|
|
|
|
* files to the revision control by mistake by doing something
|
2005-09-08 00:26:23 +00:00
|
|
|
* like "git-update-index *" and suddenly having all the object
|
2005-04-10 18:32:54 +00:00
|
|
|
* files be revision controlled.
|
|
|
|
*/
|
2005-10-15 04:56:46 +00:00
|
|
|
static int allow_add;
|
|
|
|
static int allow_remove;
|
|
|
|
static int allow_replace;
|
|
|
|
static int info_only;
|
2005-05-31 16:52:43 +00:00
|
|
|
static int force_remove;
|
2005-10-15 04:56:46 +00:00
|
|
|
static int verbose;
|
2006-08-15 17:23:48 +00:00
|
|
|
static int mark_valid_only;
|
2006-02-09 05:15:24 +00:00
|
|
|
#define MARK_VALID 1
|
|
|
|
#define UNMARK_VALID 2
|
|
|
|
|
2005-10-15 04:56:46 +00:00
|
|
|
static void report(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list vp;
|
|
|
|
|
|
|
|
if (!verbose)
|
|
|
|
return;
|
|
|
|
|
|
|
|
va_start(vp, fmt);
|
|
|
|
vprintf(fmt, vp);
|
|
|
|
putchar('\n');
|
|
|
|
va_end(vp);
|
|
|
|
}
|
|
|
|
|
2006-02-09 05:15:24 +00:00
|
|
|
static int mark_valid(const char *path)
|
|
|
|
{
|
|
|
|
int namelen = strlen(path);
|
|
|
|
int pos = cache_name_pos(path, namelen);
|
|
|
|
if (0 <= pos) {
|
|
|
|
switch (mark_valid_only) {
|
|
|
|
case MARK_VALID:
|
|
|
|
active_cache[pos]->ce_flags |= htons(CE_VALID);
|
|
|
|
break;
|
|
|
|
case UNMARK_VALID:
|
|
|
|
active_cache[pos]->ce_flags &= ~htons(CE_VALID);
|
|
|
|
break;
|
|
|
|
}
|
2006-04-24 07:23:54 +00:00
|
|
|
cache_tree_invalidate_path(active_cache_tree, path);
|
2006-02-09 05:15:24 +00:00
|
|
|
active_cache_changed = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-04-02 05:07:26 +00:00
|
|
|
static int process_file(const char *path)
|
2005-04-07 22:13:13 +00:00
|
|
|
{
|
2005-05-08 07:05:18 +00:00
|
|
|
int size, namelen, option, status;
|
2005-04-07 22:13:13 +00:00
|
|
|
struct cache_entry *ce;
|
|
|
|
struct stat st;
|
|
|
|
|
2005-05-08 07:05:18 +00:00
|
|
|
status = lstat(path, &st);
|
2006-04-24 07:23:54 +00:00
|
|
|
|
|
|
|
/* We probably want to do this in remove_file_from_cache() and
|
|
|
|
* add_cache_entry() instead...
|
|
|
|
*/
|
|
|
|
cache_tree_invalidate_path(active_cache_tree, path);
|
|
|
|
|
2005-05-08 07:05:18 +00:00
|
|
|
if (status < 0 || S_ISDIR(st.st_mode)) {
|
|
|
|
/* When we used to have "path" and now we want to add
|
|
|
|
* "path/file", we need a way to remove "path" before
|
|
|
|
* being able to add "path/file". However,
|
2005-09-08 00:26:23 +00:00
|
|
|
* "git-update-index --remove path" would not work.
|
2005-05-08 07:05:18 +00:00
|
|
|
* --force-remove can be used but this is more user
|
|
|
|
* friendly, especially since we can do the opposite
|
|
|
|
* case just fine without --force-remove.
|
|
|
|
*/
|
|
|
|
if (status == 0 || (errno == ENOENT || errno == ENOTDIR)) {
|
2005-09-18 19:09:22 +00:00
|
|
|
if (allow_remove) {
|
|
|
|
if (remove_file_from_cache(path))
|
|
|
|
return error("%s: cannot remove from the index",
|
|
|
|
path);
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
} else if (status < 0) {
|
|
|
|
return error("%s: does not exist and --remove not passed",
|
|
|
|
path);
|
|
|
|
}
|
2005-04-10 18:32:54 +00:00
|
|
|
}
|
2005-09-01 14:13:50 +00:00
|
|
|
if (0 == status)
|
2005-09-18 19:09:22 +00:00
|
|
|
return error("%s: is a directory - add files inside instead",
|
|
|
|
path);
|
2005-09-01 14:13:50 +00:00
|
|
|
else
|
|
|
|
return error("lstat(\"%s\"): %s", path,
|
|
|
|
strerror(errno));
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|
2005-10-12 01:45:33 +00:00
|
|
|
|
2005-04-07 22:13:13 +00:00
|
|
|
namelen = strlen(path);
|
|
|
|
size = cache_entry_size(namelen);
|
2006-04-03 18:30:46 +00:00
|
|
|
ce = xcalloc(1, size);
|
2005-04-07 22:13:13 +00:00
|
|
|
memcpy(ce->name, path, namelen);
|
2006-02-09 05:15:24 +00:00
|
|
|
ce->ce_flags = htons(namelen);
|
2005-04-11 16:39:21 +00:00
|
|
|
fill_stat_cache_info(ce, &st);
|
2005-10-12 01:45:33 +00:00
|
|
|
|
2007-03-02 21:11:30 +00:00
|
|
|
if (trust_executable_bit && has_symlinks)
|
2007-02-17 06:43:48 +00:00
|
|
|
ce->ce_mode = create_ce_mode(st.st_mode);
|
|
|
|
else {
|
2007-03-02 21:11:30 +00:00
|
|
|
/* If there is an existing entry, pick the mode bits and type
|
|
|
|
* from it, otherwise assume unexecutable regular file.
|
2005-10-12 01:45:33 +00:00
|
|
|
*/
|
2007-02-17 06:43:48 +00:00
|
|
|
struct cache_entry *ent;
|
2005-10-12 01:45:33 +00:00
|
|
|
int pos = cache_name_pos(path, namelen);
|
2007-02-17 06:43:48 +00:00
|
|
|
|
|
|
|
ent = (0 <= pos) ? active_cache[pos] : NULL;
|
|
|
|
ce->ce_mode = ce_mode_from_stat(ent, st.st_mode);
|
2005-10-12 01:45:33 +00:00
|
|
|
}
|
2005-10-07 10:42:00 +00:00
|
|
|
|
|
|
|
if (index_path(ce->sha1, path, &st, !info_only))
|
|
|
|
return -1;
|
2005-05-08 04:55:21 +00:00
|
|
|
option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
|
|
|
|
option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
|
2005-09-18 19:09:22 +00:00
|
|
|
if (add_cache_entry(ce, option))
|
|
|
|
return error("%s: cannot add to the index - missing --add option?",
|
|
|
|
path);
|
|
|
|
return 0;
|
2005-04-10 18:32:54 +00:00
|
|
|
}
|
|
|
|
|
2005-12-07 09:45:38 +00:00
|
|
|
static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,
|
|
|
|
const char *path, int stage)
|
2005-04-15 18:08:33 +00:00
|
|
|
{
|
2005-05-08 04:55:21 +00:00
|
|
|
int size, len, option;
|
2005-04-15 18:08:33 +00:00
|
|
|
struct cache_entry *ce;
|
|
|
|
|
2005-12-07 09:45:38 +00:00
|
|
|
if (!verify_path(path))
|
2005-04-15 18:08:33 +00:00
|
|
|
return -1;
|
|
|
|
|
2005-12-07 09:45:38 +00:00
|
|
|
len = strlen(path);
|
2005-04-15 18:08:33 +00:00
|
|
|
size = cache_entry_size(len);
|
2006-04-03 18:30:46 +00:00
|
|
|
ce = xcalloc(1, size);
|
2005-04-15 18:08:33 +00:00
|
|
|
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(ce->sha1, sha1);
|
2005-12-07 09:45:38 +00:00
|
|
|
memcpy(ce->name, path, len);
|
|
|
|
ce->ce_flags = create_ce_flags(len, stage);
|
2005-04-17 05:26:31 +00:00
|
|
|
ce->ce_mode = create_ce_mode(mode);
|
2006-02-09 05:15:24 +00:00
|
|
|
if (assume_unchanged)
|
|
|
|
ce->ce_flags |= htons(CE_VALID);
|
2005-05-08 04:55:21 +00:00
|
|
|
option = allow_add ? ADD_CACHE_OK_TO_ADD : 0;
|
|
|
|
option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE : 0;
|
2005-10-15 04:56:46 +00:00
|
|
|
if (add_cache_entry(ce, option))
|
|
|
|
return error("%s: cannot add to the index - missing --add option?",
|
2005-12-07 09:45:38 +00:00
|
|
|
path);
|
|
|
|
report("add '%s'", path);
|
2006-04-24 07:23:54 +00:00
|
|
|
cache_tree_invalidate_path(active_cache_tree, path);
|
2005-10-15 04:56:46 +00:00
|
|
|
return 0;
|
2005-04-15 18:08:33 +00:00
|
|
|
}
|
|
|
|
|
2006-04-23 07:01:29 +00:00
|
|
|
static void chmod_path(int flip, const char *path)
|
2005-10-12 01:45:33 +00:00
|
|
|
{
|
|
|
|
int pos;
|
|
|
|
struct cache_entry *ce;
|
|
|
|
unsigned int mode;
|
2005-04-26 18:55:42 +00:00
|
|
|
|
2005-10-12 01:45:33 +00:00
|
|
|
pos = cache_name_pos(path, strlen(path));
|
|
|
|
if (pos < 0)
|
2006-04-23 07:01:29 +00:00
|
|
|
goto fail;
|
2005-10-12 01:45:33 +00:00
|
|
|
ce = active_cache[pos];
|
|
|
|
mode = ntohl(ce->ce_mode);
|
|
|
|
if (!S_ISREG(mode))
|
2006-04-23 07:01:29 +00:00
|
|
|
goto fail;
|
2005-10-12 01:45:33 +00:00
|
|
|
switch (flip) {
|
|
|
|
case '+':
|
|
|
|
ce->ce_mode |= htonl(0111); break;
|
|
|
|
case '-':
|
|
|
|
ce->ce_mode &= htonl(~0111); break;
|
|
|
|
default:
|
2006-04-23 07:01:29 +00:00
|
|
|
goto fail;
|
2005-10-12 01:45:33 +00:00
|
|
|
}
|
2006-04-24 07:23:54 +00:00
|
|
|
cache_tree_invalidate_path(active_cache_tree, path);
|
2005-10-12 01:45:33 +00:00
|
|
|
active_cache_changed = 1;
|
2006-04-23 07:01:29 +00:00
|
|
|
report("chmod %cx '%s'", flip, path);
|
|
|
|
return;
|
|
|
|
fail:
|
|
|
|
die("git-update-index: cannot chmod %cx '%s'", flip, path);
|
2005-10-12 01:45:33 +00:00
|
|
|
}
|
|
|
|
|
2005-09-27 01:13:08 +00:00
|
|
|
static void update_one(const char *path, const char *prefix, int prefix_length)
|
|
|
|
{
|
|
|
|
const char *p = prefix_path(prefix, prefix_length, path);
|
|
|
|
if (!verify_path(p)) {
|
|
|
|
fprintf(stderr, "Ignoring path %s\n", path);
|
2006-05-06 05:53:56 +00:00
|
|
|
goto free_return;
|
2005-09-27 01:13:08 +00:00
|
|
|
}
|
2006-02-09 05:15:24 +00:00
|
|
|
if (mark_valid_only) {
|
|
|
|
if (mark_valid(p))
|
|
|
|
die("Unable to mark file %s", path);
|
2006-05-06 05:53:56 +00:00
|
|
|
goto free_return;
|
2006-02-09 05:15:24 +00:00
|
|
|
}
|
2006-04-24 07:23:54 +00:00
|
|
|
cache_tree_invalidate_path(active_cache_tree, path);
|
2006-02-09 05:15:24 +00:00
|
|
|
|
2005-09-27 01:13:08 +00:00
|
|
|
if (force_remove) {
|
|
|
|
if (remove_file_from_cache(p))
|
|
|
|
die("git-update-index: unable to remove %s", path);
|
2005-10-15 04:56:46 +00:00
|
|
|
report("remove '%s'", path);
|
2006-05-06 05:53:56 +00:00
|
|
|
goto free_return;
|
2005-09-27 01:13:08 +00:00
|
|
|
}
|
2007-04-02 05:07:26 +00:00
|
|
|
if (process_file(p))
|
2005-09-27 01:13:08 +00:00
|
|
|
die("Unable to process file %s", path);
|
2005-10-15 04:56:46 +00:00
|
|
|
report("add '%s'", path);
|
2006-05-06 05:53:56 +00:00
|
|
|
free_return:
|
2006-05-06 22:02:53 +00:00
|
|
|
if (p < path || p > path + strlen(path))
|
2006-05-06 05:53:56 +00:00
|
|
|
free((char*)p);
|
2005-09-27 01:13:08 +00:00
|
|
|
}
|
|
|
|
|
2005-10-07 10:42:00 +00:00
|
|
|
static void read_index_info(int line_termination)
|
|
|
|
{
|
|
|
|
struct strbuf buf;
|
|
|
|
strbuf_init(&buf);
|
|
|
|
while (1) {
|
2005-11-22 05:46:57 +00:00
|
|
|
char *ptr, *tab;
|
2005-10-16 07:39:07 +00:00
|
|
|
char *path_name;
|
2005-10-07 10:42:00 +00:00
|
|
|
unsigned char sha1[20];
|
|
|
|
unsigned int mode;
|
2005-12-07 09:45:38 +00:00
|
|
|
int stage;
|
|
|
|
|
|
|
|
/* This reads lines formatted in one of three formats:
|
|
|
|
*
|
|
|
|
* (1) mode SP sha1 TAB path
|
|
|
|
* The first format is what "git-apply --index-info"
|
|
|
|
* reports, and used to reconstruct a partial tree
|
|
|
|
* that is used for phony merge base tree when falling
|
|
|
|
* back on 3-way merge.
|
|
|
|
*
|
|
|
|
* (2) mode SP type SP sha1 TAB path
|
|
|
|
* The second format is to stuff git-ls-tree output
|
|
|
|
* into the index file.
|
2006-06-13 20:21:57 +00:00
|
|
|
*
|
2005-12-07 09:45:38 +00:00
|
|
|
* (3) mode SP sha1 SP stage TAB path
|
|
|
|
* This format is to put higher order stages into the
|
|
|
|
* index file and matches git-ls-files --stage output.
|
|
|
|
*/
|
2005-10-07 10:42:00 +00:00
|
|
|
read_line(&buf, stdin, line_termination);
|
|
|
|
if (buf.eof)
|
|
|
|
break;
|
|
|
|
|
|
|
|
mode = strtoul(buf.buf, &ptr, 8);
|
2005-11-22 05:46:57 +00:00
|
|
|
if (ptr == buf.buf || *ptr != ' ')
|
2005-10-07 10:42:00 +00:00
|
|
|
goto bad_line;
|
|
|
|
|
2005-11-22 05:46:57 +00:00
|
|
|
tab = strchr(ptr, '\t');
|
|
|
|
if (!tab || tab - ptr < 41)
|
|
|
|
goto bad_line;
|
2005-12-07 09:45:38 +00:00
|
|
|
|
2006-02-01 02:03:37 +00:00
|
|
|
if (tab[-2] == ' ' && '0' <= tab[-1] && tab[-1] <= '3') {
|
2005-12-07 09:45:38 +00:00
|
|
|
stage = tab[-1] - '0';
|
|
|
|
ptr = tab + 1; /* point at the head of path */
|
|
|
|
tab = tab - 2; /* point at tail of sha1 */
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
stage = 0;
|
|
|
|
ptr = tab + 1; /* point at the head of path */
|
|
|
|
}
|
|
|
|
|
2005-11-22 05:46:57 +00:00
|
|
|
if (get_sha1_hex(tab - 40, sha1) || tab[-41] != ' ')
|
|
|
|
goto bad_line;
|
2005-10-16 07:39:07 +00:00
|
|
|
|
|
|
|
if (line_termination && ptr[0] == '"')
|
|
|
|
path_name = unquote_c_style(ptr, NULL);
|
|
|
|
else
|
|
|
|
path_name = ptr;
|
|
|
|
|
|
|
|
if (!verify_path(path_name)) {
|
|
|
|
fprintf(stderr, "Ignoring path %s\n", path_name);
|
|
|
|
if (path_name != ptr)
|
|
|
|
free(path_name);
|
2005-10-07 10:42:00 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-04-24 07:23:54 +00:00
|
|
|
cache_tree_invalidate_path(active_cache_tree, path_name);
|
2005-10-07 10:42:00 +00:00
|
|
|
|
|
|
|
if (!mode) {
|
|
|
|
/* mode == 0 means there is no such path -- remove */
|
2005-10-16 07:39:07 +00:00
|
|
|
if (remove_file_from_cache(path_name))
|
2005-10-07 10:42:00 +00:00
|
|
|
die("git-update-index: unable to remove %s",
|
|
|
|
ptr);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* mode ' ' sha1 '\t' name
|
|
|
|
* ptr[-1] points at tab,
|
|
|
|
* ptr[-41] is at the beginning of sha1
|
|
|
|
*/
|
|
|
|
ptr[-42] = ptr[-1] = 0;
|
2005-12-07 09:45:38 +00:00
|
|
|
if (add_cacheinfo(mode, sha1, path_name, stage))
|
2005-10-07 10:42:00 +00:00
|
|
|
die("git-update-index: unable to update %s",
|
2005-10-16 07:39:07 +00:00
|
|
|
path_name);
|
2005-10-07 10:42:00 +00:00
|
|
|
}
|
2005-10-16 07:39:07 +00:00
|
|
|
if (path_name != ptr)
|
|
|
|
free(path_name);
|
2005-10-07 10:42:00 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
bad_line:
|
|
|
|
die("malformed index info %s", buf.buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-25 15:26:25 +00:00
|
|
|
static const char update_index_usage[] =
|
2006-08-24 04:24:47 +00:00
|
|
|
"git-update-index [-q] [--add] [--replace] [--remove] [--unmerged] [--refresh] [--really-refresh] [--cacheinfo] [--chmod=(+|-)x] [--assume-unchanged] [--info-only] [--force-remove] [--stdin] [--index-info] [--unresolve] [--again | -g] [--ignore-missing] [-z] [--verbose] [--] <file>...";
|
2005-10-25 15:26:25 +00:00
|
|
|
|
2006-04-20 06:52:05 +00:00
|
|
|
static unsigned char head_sha1[20];
|
|
|
|
static unsigned char merge_head_sha1[20];
|
|
|
|
|
|
|
|
static struct cache_entry *read_one_ent(const char *which,
|
|
|
|
unsigned char *ent, const char *path,
|
|
|
|
int namelen, int stage)
|
|
|
|
{
|
|
|
|
unsigned mode;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
int size;
|
|
|
|
struct cache_entry *ce;
|
|
|
|
|
|
|
|
if (get_tree_entry(ent, path, sha1, &mode)) {
|
2006-05-06 00:40:47 +00:00
|
|
|
if (which)
|
|
|
|
error("%s: not in %s branch.", path, which);
|
2006-04-20 06:52:05 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (mode == S_IFDIR) {
|
2006-05-06 00:40:47 +00:00
|
|
|
if (which)
|
|
|
|
error("%s: not a blob in %s branch.", path, which);
|
2006-04-20 06:52:05 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
size = cache_entry_size(namelen);
|
|
|
|
ce = xcalloc(1, size);
|
|
|
|
|
2006-08-23 06:49:00 +00:00
|
|
|
hashcpy(ce->sha1, sha1);
|
2006-04-20 06:52:05 +00:00
|
|
|
memcpy(ce->name, path, namelen);
|
|
|
|
ce->ce_flags = create_ce_flags(namelen, stage);
|
|
|
|
ce->ce_mode = create_ce_mode(mode);
|
|
|
|
return ce;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unresolve_one(const char *path)
|
|
|
|
{
|
|
|
|
int namelen = strlen(path);
|
|
|
|
int pos;
|
|
|
|
int ret = 0;
|
|
|
|
struct cache_entry *ce_2 = NULL, *ce_3 = NULL;
|
|
|
|
|
|
|
|
/* See if there is such entry in the index. */
|
|
|
|
pos = cache_name_pos(path, namelen);
|
|
|
|
if (pos < 0) {
|
|
|
|
/* If there isn't, either it is unmerged, or
|
|
|
|
* resolved as "removed" by mistake. We do not
|
|
|
|
* want to do anything in the former case.
|
|
|
|
*/
|
|
|
|
pos = -pos-1;
|
|
|
|
if (pos < active_nr) {
|
|
|
|
struct cache_entry *ce = active_cache[pos];
|
|
|
|
if (ce_namelen(ce) == namelen &&
|
|
|
|
!memcmp(ce->name, path, namelen)) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"%s: skipping still unmerged path.\n",
|
|
|
|
path);
|
|
|
|
goto free_return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Grab blobs from given path from HEAD and MERGE_HEAD,
|
|
|
|
* stuff HEAD version in stage #2,
|
|
|
|
* stuff MERGE_HEAD version in stage #3.
|
|
|
|
*/
|
|
|
|
ce_2 = read_one_ent("our", head_sha1, path, namelen, 2);
|
|
|
|
ce_3 = read_one_ent("their", merge_head_sha1, path, namelen, 3);
|
|
|
|
|
|
|
|
if (!ce_2 || !ce_3) {
|
|
|
|
ret = -1;
|
|
|
|
goto free_return;
|
|
|
|
}
|
2006-08-17 18:54:57 +00:00
|
|
|
if (!hashcmp(ce_2->sha1, ce_3->sha1) &&
|
2006-04-20 06:52:05 +00:00
|
|
|
ce_2->ce_mode == ce_3->ce_mode) {
|
|
|
|
fprintf(stderr, "%s: identical in both, skipping.\n",
|
|
|
|
path);
|
|
|
|
goto free_return;
|
|
|
|
}
|
|
|
|
|
2006-04-27 05:05:05 +00:00
|
|
|
cache_tree_invalidate_path(active_cache_tree, path);
|
2006-04-20 06:52:05 +00:00
|
|
|
remove_file_from_cache(path);
|
|
|
|
if (add_cache_entry(ce_2, ADD_CACHE_OK_TO_ADD)) {
|
|
|
|
error("%s: cannot add our version to the index.", path);
|
|
|
|
ret = -1;
|
|
|
|
goto free_return;
|
|
|
|
}
|
|
|
|
if (!add_cache_entry(ce_3, ADD_CACHE_OK_TO_ADD))
|
|
|
|
return 0;
|
|
|
|
error("%s: cannot add their version to the index.", path);
|
|
|
|
ret = -1;
|
|
|
|
free_return:
|
|
|
|
free(ce_2);
|
|
|
|
free(ce_3);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void read_head_pointers(void)
|
|
|
|
{
|
2006-09-21 21:29:59 +00:00
|
|
|
if (read_ref("HEAD", head_sha1))
|
2006-04-20 06:52:05 +00:00
|
|
|
die("No HEAD -- no initial commit yet?\n");
|
2006-09-21 21:29:59 +00:00
|
|
|
if (read_ref("MERGE_HEAD", merge_head_sha1)) {
|
2006-04-20 06:52:05 +00:00
|
|
|
fprintf(stderr, "Not in the middle of a merge.\n");
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-06 00:50:06 +00:00
|
|
|
static int do_unresolve(int ac, const char **av,
|
|
|
|
const char *prefix, int prefix_length)
|
2006-04-20 06:52:05 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
/* Read HEAD and MERGE_HEAD; if MERGE_HEAD does not exist, we
|
|
|
|
* are not doing a merge, so exit with success status.
|
|
|
|
*/
|
|
|
|
read_head_pointers();
|
|
|
|
|
|
|
|
for (i = 1; i < ac; i++) {
|
|
|
|
const char *arg = av[i];
|
2006-05-06 00:50:06 +00:00
|
|
|
const char *p = prefix_path(prefix, prefix_length, arg);
|
|
|
|
err |= unresolve_one(p);
|
2006-05-06 22:02:53 +00:00
|
|
|
if (p < arg || p > arg + strlen(arg))
|
2006-05-06 00:50:06 +00:00
|
|
|
free((char*)p);
|
2006-04-20 06:52:05 +00:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2006-05-06 00:40:47 +00:00
|
|
|
static int do_reupdate(int ac, const char **av,
|
|
|
|
const char *prefix, int prefix_length)
|
|
|
|
{
|
|
|
|
/* Read HEAD and run update-index on paths that are
|
|
|
|
* merged and already different between index and HEAD.
|
|
|
|
*/
|
|
|
|
int pos;
|
|
|
|
int has_head = 1;
|
2006-05-06 22:02:53 +00:00
|
|
|
const char **pathspec = get_pathspec(prefix, av + 1);
|
2006-05-06 00:40:47 +00:00
|
|
|
|
2006-09-21 21:29:59 +00:00
|
|
|
if (read_ref("HEAD", head_sha1))
|
2006-05-06 00:40:47 +00:00
|
|
|
/* If there is no HEAD, that means it is an initial
|
|
|
|
* commit. Update everything in the index.
|
|
|
|
*/
|
|
|
|
has_head = 0;
|
|
|
|
redo:
|
|
|
|
for (pos = 0; pos < active_nr; pos++) {
|
|
|
|
struct cache_entry *ce = active_cache[pos];
|
|
|
|
struct cache_entry *old = NULL;
|
|
|
|
int save_nr;
|
2006-05-06 06:09:05 +00:00
|
|
|
|
|
|
|
if (ce_stage(ce) || !ce_path_match(ce, pathspec))
|
2006-05-06 00:40:47 +00:00
|
|
|
continue;
|
|
|
|
if (has_head)
|
|
|
|
old = read_one_ent(NULL, head_sha1,
|
|
|
|
ce->name, ce_namelen(ce), 0);
|
|
|
|
if (old && ce->ce_mode == old->ce_mode &&
|
2006-08-17 18:54:57 +00:00
|
|
|
!hashcmp(ce->sha1, old->sha1)) {
|
2006-05-06 00:40:47 +00:00
|
|
|
free(old);
|
|
|
|
continue; /* unchanged */
|
|
|
|
}
|
|
|
|
/* Be careful. The working tree may not have the
|
|
|
|
* path anymore, in which case, under 'allow_remove',
|
|
|
|
* or worse yet 'allow_replace', active_nr may decrease.
|
|
|
|
*/
|
|
|
|
save_nr = active_nr;
|
|
|
|
update_one(ce->name + prefix_length, prefix, prefix_length);
|
|
|
|
if (save_nr != active_nr)
|
|
|
|
goto redo;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-29 05:44:25 +00:00
|
|
|
int cmd_update_index(int argc, const char **argv, const char *prefix)
|
2005-04-07 22:13:13 +00:00
|
|
|
{
|
2005-09-27 01:13:08 +00:00
|
|
|
int i, newfd, entries, has_errors = 0, line_termination = '\n';
|
2005-04-10 18:32:54 +00:00
|
|
|
int allow_options = 1;
|
2005-09-27 01:13:08 +00:00
|
|
|
int read_from_stdin = 0;
|
|
|
|
int prefix_length = prefix ? strlen(prefix) : 0;
|
2006-04-23 07:01:29 +00:00
|
|
|
char set_executable_bit = 0;
|
2006-05-19 16:56:35 +00:00
|
|
|
unsigned int refresh_flags = 0;
|
2007-02-22 08:30:45 +00:00
|
|
|
int lock_error = 0;
|
2006-06-13 20:21:57 +00:00
|
|
|
struct lock_file *lock_file;
|
2005-04-21 17:55:18 +00:00
|
|
|
|
2005-10-12 01:45:33 +00:00
|
|
|
git_config(git_default_config);
|
|
|
|
|
2006-06-13 20:21:57 +00:00
|
|
|
/* We can't free this memory, it becomes part of a linked list parsed atexit() */
|
2006-06-19 22:55:20 +00:00
|
|
|
lock_file = xcalloc(1, sizeof(struct lock_file));
|
2006-06-13 20:21:57 +00:00
|
|
|
|
_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, 0);
|
2007-02-22 08:30:45 +00:00
|
|
|
if (newfd < 0)
|
|
|
|
lock_error = errno;
|
2005-04-11 22:39:26 +00:00
|
|
|
|
2005-04-07 22:13:13 +00:00
|
|
|
entries = read_cache();
|
2005-04-11 22:39:26 +00:00
|
|
|
if (entries < 0)
|
2005-04-13 09:28:48 +00:00
|
|
|
die("cache corrupted");
|
2005-04-07 22:13:13 +00:00
|
|
|
|
|
|
|
for (i = 1 ; i < argc; i++) {
|
2005-09-21 07:00:47 +00:00
|
|
|
const char *path = argv[i];
|
2007-01-31 13:34:17 +00:00
|
|
|
const char *p;
|
2005-04-10 18:32:54 +00:00
|
|
|
|
|
|
|
if (allow_options && *path == '-') {
|
|
|
|
if (!strcmp(path, "--")) {
|
|
|
|
allow_options = 0;
|
|
|
|
continue;
|
|
|
|
}
|
2005-06-21 04:18:54 +00:00
|
|
|
if (!strcmp(path, "-q")) {
|
2006-05-19 16:56:35 +00:00
|
|
|
refresh_flags |= REFRESH_QUIET;
|
2005-06-21 04:18:54 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-04-10 18:32:54 +00:00
|
|
|
if (!strcmp(path, "--add")) {
|
|
|
|
allow_add = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-05-08 04:55:21 +00:00
|
|
|
if (!strcmp(path, "--replace")) {
|
|
|
|
allow_replace = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-04-10 18:32:54 +00:00
|
|
|
if (!strcmp(path, "--remove")) {
|
|
|
|
allow_remove = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-10-01 20:24:27 +00:00
|
|
|
if (!strcmp(path, "--unmerged")) {
|
2006-05-19 16:56:35 +00:00
|
|
|
refresh_flags |= REFRESH_UNMERGED;
|
2005-10-01 20:24:27 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-04-10 18:32:54 +00:00
|
|
|
if (!strcmp(path, "--refresh")) {
|
2006-05-19 16:56:35 +00:00
|
|
|
has_errors |= refresh_cache(refresh_flags);
|
2006-02-09 05:15:24 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(path, "--really-refresh")) {
|
2006-05-19 16:56:35 +00:00
|
|
|
has_errors |= refresh_cache(REFRESH_REALLY | refresh_flags);
|
2005-04-10 18:32:54 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-04-15 18:08:33 +00:00
|
|
|
if (!strcmp(path, "--cacheinfo")) {
|
2005-12-07 09:45:38 +00:00
|
|
|
unsigned char sha1[20];
|
|
|
|
unsigned int mode;
|
|
|
|
|
2005-05-08 22:31:33 +00:00
|
|
|
if (i+3 >= argc)
|
2005-09-08 00:26:23 +00:00
|
|
|
die("git-update-index: --cacheinfo <mode> <sha1> <path>");
|
2005-12-07 09:45:38 +00:00
|
|
|
|
|
|
|
if ((sscanf(argv[i+1], "%o", &mode) != 1) ||
|
|
|
|
get_sha1_hex(argv[i+2], sha1) ||
|
|
|
|
add_cacheinfo(mode, sha1, argv[i+3], 0))
|
|
|
|
die("git-update-index: --cacheinfo"
|
|
|
|
" cannot add %s", argv[i+3]);
|
2005-04-15 18:08:33 +00:00
|
|
|
i += 3;
|
|
|
|
continue;
|
|
|
|
}
|
2005-10-12 01:45:33 +00:00
|
|
|
if (!strcmp(path, "--chmod=-x") ||
|
|
|
|
!strcmp(path, "--chmod=+x")) {
|
|
|
|
if (argc <= i+1)
|
|
|
|
die("git-update-index: %s <path>", path);
|
2006-04-23 07:01:29 +00:00
|
|
|
set_executable_bit = path[8];
|
2005-10-12 01:45:33 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-02-09 05:15:24 +00:00
|
|
|
if (!strcmp(path, "--assume-unchanged")) {
|
|
|
|
mark_valid_only = MARK_VALID;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(path, "--no-assume-unchanged")) {
|
|
|
|
mark_valid_only = UNMARK_VALID;
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-08 23:52:12 +00:00
|
|
|
if (!strcmp(path, "--info-only")) {
|
|
|
|
info_only = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-05-02 06:50:51 +00:00
|
|
|
if (!strcmp(path, "--force-remove")) {
|
2005-05-31 16:52:43 +00:00
|
|
|
force_remove = 1;
|
2005-05-02 06:50:51 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-09-27 01:13:08 +00:00
|
|
|
if (!strcmp(path, "-z")) {
|
|
|
|
line_termination = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!strcmp(path, "--stdin")) {
|
|
|
|
if (i != argc - 1)
|
|
|
|
die("--stdin must be at the end");
|
|
|
|
read_from_stdin = 1;
|
|
|
|
break;
|
|
|
|
}
|
2005-10-07 10:42:00 +00:00
|
|
|
if (!strcmp(path, "--index-info")) {
|
2006-03-02 17:21:33 +00:00
|
|
|
if (i != argc - 1)
|
|
|
|
die("--index-info must be at the end");
|
2005-10-07 10:42:00 +00:00
|
|
|
allow_add = allow_replace = allow_remove = 1;
|
|
|
|
read_index_info(line_termination);
|
2006-03-02 17:21:33 +00:00
|
|
|
break;
|
2005-10-07 10:42:00 +00:00
|
|
|
}
|
2006-04-20 06:52:05 +00:00
|
|
|
if (!strcmp(path, "--unresolve")) {
|
2006-05-06 00:50:06 +00:00
|
|
|
has_errors = do_unresolve(argc - i, argv + i,
|
|
|
|
prefix, prefix_length);
|
2006-04-20 06:52:05 +00:00
|
|
|
if (has_errors)
|
|
|
|
active_cache_changed = 0;
|
|
|
|
goto finish;
|
|
|
|
}
|
2006-08-24 04:24:47 +00:00
|
|
|
if (!strcmp(path, "--again") || !strcmp(path, "-g")) {
|
2006-05-06 00:40:47 +00:00
|
|
|
has_errors = do_reupdate(argc - i, argv + i,
|
|
|
|
prefix, prefix_length);
|
|
|
|
if (has_errors)
|
|
|
|
active_cache_changed = 0;
|
|
|
|
goto finish;
|
|
|
|
}
|
2005-04-24 22:14:16 +00:00
|
|
|
if (!strcmp(path, "--ignore-missing")) {
|
2006-05-19 16:56:35 +00:00
|
|
|
refresh_flags |= REFRESH_IGNORE_MISSING;
|
2005-04-24 22:14:16 +00:00
|
|
|
continue;
|
|
|
|
}
|
2005-10-15 04:56:46 +00:00
|
|
|
if (!strcmp(path, "--verbose")) {
|
|
|
|
verbose = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2005-10-25 15:26:25 +00:00
|
|
|
if (!strcmp(path, "-h") || !strcmp(path, "--help"))
|
|
|
|
usage(update_index_usage);
|
2005-04-13 09:28:48 +00:00
|
|
|
die("unknown option %s", path);
|
2005-04-10 18:32:54 +00:00
|
|
|
}
|
2007-01-31 13:34:17 +00:00
|
|
|
p = prefix_path(prefix, prefix_length, path);
|
|
|
|
update_one(p, NULL, 0);
|
2006-04-23 07:01:29 +00:00
|
|
|
if (set_executable_bit)
|
2007-01-31 13:34:17 +00:00
|
|
|
chmod_path(set_executable_bit, p);
|
|
|
|
if (p < path || p > path + strlen(path))
|
|
|
|
free((char*)p);
|
2005-09-27 01:13:08 +00:00
|
|
|
}
|
|
|
|
if (read_from_stdin) {
|
|
|
|
struct strbuf buf;
|
|
|
|
strbuf_init(&buf);
|
|
|
|
while (1) {
|
2006-01-11 21:36:45 +00:00
|
|
|
char *path_name;
|
2006-05-06 05:53:56 +00:00
|
|
|
const char *p;
|
2005-09-27 01:13:08 +00:00
|
|
|
read_line(&buf, stdin, line_termination);
|
|
|
|
if (buf.eof)
|
|
|
|
break;
|
2006-01-11 21:36:45 +00:00
|
|
|
if (line_termination && buf.buf[0] == '"')
|
|
|
|
path_name = unquote_c_style(buf.buf, NULL);
|
|
|
|
else
|
|
|
|
path_name = buf.buf;
|
2006-05-06 05:53:56 +00:00
|
|
|
p = prefix_path(prefix, prefix_length, path_name);
|
|
|
|
update_one(p, NULL, 0);
|
|
|
|
if (set_executable_bit)
|
2006-04-23 07:01:29 +00:00
|
|
|
chmod_path(set_executable_bit, p);
|
2006-05-06 22:02:53 +00:00
|
|
|
if (p < path_name || p > path_name + strlen(path_name))
|
2006-05-06 05:53:56 +00:00
|
|
|
free((char*) p);
|
2006-01-11 21:36:45 +00:00
|
|
|
if (path_name != buf.buf)
|
|
|
|
free(path_name);
|
2005-05-31 16:52:43 +00:00
|
|
|
}
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|
2006-04-20 06:52:05 +00:00
|
|
|
|
|
|
|
finish:
|
2005-10-01 20:39:47 +00:00
|
|
|
if (active_cache_changed) {
|
2007-02-22 08:30:45 +00:00
|
|
|
if (newfd < 0) {
|
|
|
|
if (refresh_flags & REFRESH_QUIET)
|
|
|
|
exit(128);
|
|
|
|
die("unable to create '%s.lock': %s",
|
|
|
|
get_index_file(), strerror(lock_error));
|
|
|
|
}
|
2005-10-01 20:39:47 +00:00
|
|
|
if (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-10-01 20:39:47 +00:00
|
|
|
}
|
2005-04-11 22:39:26 +00:00
|
|
|
|
2006-06-13 20:21:57 +00:00
|
|
|
rollback_lock_file(lock_file);
|
|
|
|
|
2005-05-05 22:29:06 +00:00
|
|
|
return has_errors ? 1 : 0;
|
2005-04-07 22:13:13 +00:00
|
|
|
}
|