Browse Source
This commit is what this branch is all about. It records the evil merge needed to adjust built-in git-add and git-rm for the cache-tree extension. * lt/dirwalk: Add builtin "git rm" command Move pathspec matching from builtin-add.c into dir.c Prevent bogus paths from being added to the index. builtin-add: fix unmatched pathspec warnings. Remove old "git-add.sh" remnants builtin-add: warn on unmatched pathspecs Do "git add" as a builtin Clean up git-ls-file directory walking library interface libify git-ls-files directory traversal Conflicts: Makefile builtin.h git.c update-index.cmaint
Junio C Hamano
19 years ago
13 changed files with 899 additions and 550 deletions
@ -0,0 +1,189 @@
@@ -0,0 +1,189 @@
|
||||
/* |
||||
* "git add" builtin command |
||||
* |
||||
* Copyright (C) 2006 Linus Torvalds |
||||
*/ |
||||
#include <fnmatch.h> |
||||
|
||||
#include "cache.h" |
||||
#include "builtin.h" |
||||
#include "dir.h" |
||||
#include "cache-tree.h" |
||||
|
||||
static const char builtin_add_usage[] = |
||||
"git-add [-n] [-v] <filepattern>..."; |
||||
|
||||
static void prune_directory(struct dir_struct *dir, const char **pathspec, int prefix) |
||||
{ |
||||
char *seen; |
||||
int i, specs; |
||||
struct dir_entry **src, **dst; |
||||
|
||||
for (specs = 0; pathspec[specs]; specs++) |
||||
/* nothing */; |
||||
seen = xmalloc(specs); |
||||
memset(seen, 0, specs); |
||||
|
||||
src = dst = dir->entries; |
||||
i = dir->nr; |
||||
while (--i >= 0) { |
||||
struct dir_entry *entry = *src++; |
||||
if (!match_pathspec(pathspec, entry->name, entry->len, prefix, seen)) { |
||||
free(entry); |
||||
continue; |
||||
} |
||||
*dst++ = entry; |
||||
} |
||||
dir->nr = dst - dir->entries; |
||||
|
||||
for (i = 0; i < specs; i++) { |
||||
struct stat st; |
||||
const char *match; |
||||
if (seen[i]) |
||||
continue; |
||||
|
||||
/* Existing file? We must have ignored it */ |
||||
match = pathspec[i]; |
||||
if (!match[0] || !lstat(match, &st)) |
||||
continue; |
||||
die("pathspec '%s' did not match any files", match); |
||||
} |
||||
} |
||||
|
||||
static void fill_directory(struct dir_struct *dir, const char **pathspec) |
||||
{ |
||||
const char *path, *base; |
||||
int baselen; |
||||
|
||||
/* Set up the default git porcelain excludes */ |
||||
memset(dir, 0, sizeof(*dir)); |
||||
dir->exclude_per_dir = ".gitignore"; |
||||
path = git_path("info/exclude"); |
||||
if (!access(path, R_OK)) |
||||
add_excludes_from_file(dir, path); |
||||
|
||||
/* |
||||
* Calculate common prefix for the pathspec, and |
||||
* use that to optimize the directory walk |
||||
*/ |
||||
baselen = common_prefix(pathspec); |
||||
path = "."; |
||||
base = ""; |
||||
if (baselen) { |
||||
char *common = xmalloc(baselen + 1); |
||||
common = xmalloc(baselen + 1); |
||||
memcpy(common, *pathspec, baselen); |
||||
common[baselen] = 0; |
||||
path = base = common; |
||||
} |
||||
|
||||
/* Read the directory and prune it */ |
||||
read_directory(dir, path, base, baselen); |
||||
if (pathspec) |
||||
prune_directory(dir, pathspec, baselen); |
||||
} |
||||
|
||||
static int add_file_to_index(const char *path, int verbose) |
||||
{ |
||||
int size, namelen; |
||||
struct stat st; |
||||
struct cache_entry *ce; |
||||
|
||||
if (lstat(path, &st)) |
||||
die("%s: unable to stat (%s)", path, strerror(errno)); |
||||
|
||||
if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) |
||||
die("%s: can only add regular files or symbolic links", path); |
||||
|
||||
namelen = strlen(path); |
||||
size = cache_entry_size(namelen); |
||||
ce = xcalloc(1, size); |
||||
memcpy(ce->name, path, namelen); |
||||
ce->ce_flags = htons(namelen); |
||||
fill_stat_cache_info(ce, &st); |
||||
|
||||
ce->ce_mode = create_ce_mode(st.st_mode); |
||||
if (!trust_executable_bit) { |
||||
/* If there is an existing entry, pick the mode bits |
||||
* from it. |
||||
*/ |
||||
int pos = cache_name_pos(path, namelen); |
||||
if (pos >= 0) |
||||
ce->ce_mode = active_cache[pos]->ce_mode; |
||||
} |
||||
|
||||
if (index_path(ce->sha1, path, &st, 1)) |
||||
die("unable to index file %s", path); |
||||
if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD)) |
||||
die("unable to add %s to index",path); |
||||
if (verbose) |
||||
printf("add '%s'\n", path); |
||||
cache_tree_invalidate_path(active_cache_tree, path); |
||||
return 0; |
||||
} |
||||
|
||||
static struct cache_file cache_file; |
||||
|
||||
int cmd_add(int argc, const char **argv, char **envp) |
||||
{ |
||||
int i, newfd; |
||||
int verbose = 0, show_only = 0; |
||||
const char *prefix = setup_git_directory(); |
||||
const char **pathspec; |
||||
struct dir_struct dir; |
||||
|
||||
git_config(git_default_config); |
||||
|
||||
newfd = hold_index_file_for_update(&cache_file, get_index_file()); |
||||
if (newfd < 0) |
||||
die("unable to create new cachefile"); |
||||
|
||||
if (read_cache() < 0) |
||||
die("index file corrupt"); |
||||
|
||||
for (i = 1; i < argc; i++) { |
||||
const char *arg = argv[i]; |
||||
|
||||
if (arg[0] != '-') |
||||
break; |
||||
if (!strcmp(arg, "--")) { |
||||
i++; |
||||
break; |
||||
} |
||||
if (!strcmp(arg, "-n")) { |
||||
show_only = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "-v")) { |
||||
verbose = 1; |
||||
continue; |
||||
} |
||||
die(builtin_add_usage); |
||||
} |
||||
git_config(git_default_config); |
||||
pathspec = get_pathspec(prefix, argv + i); |
||||
|
||||
fill_directory(&dir, pathspec); |
||||
|
||||
if (show_only) { |
||||
const char *sep = "", *eof = ""; |
||||
for (i = 0; i < dir.nr; i++) { |
||||
printf("%s%s", sep, dir.entries[i]->name); |
||||
sep = " "; |
||||
eof = "\n"; |
||||
} |
||||
fputs(eof, stdout); |
||||
return 0; |
||||
} |
||||
|
||||
for (i = 0; i < dir.nr; i++) |
||||
add_file_to_index(dir.entries[i]->name, verbose); |
||||
|
||||
if (active_cache_changed) { |
||||
if (write_cache(newfd, active_cache, active_nr) || |
||||
commit_index_file(&cache_file)) |
||||
die("Unable to write new index file"); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,151 @@
@@ -0,0 +1,151 @@
|
||||
/* |
||||
* "git rm" builtin command |
||||
* |
||||
* Copyright (C) Linus Torvalds 2006 |
||||
*/ |
||||
#include "cache.h" |
||||
#include "builtin.h" |
||||
#include "dir.h" |
||||
|
||||
static const char builtin_rm_usage[] = |
||||
"git-rm [-n] [-v] [-f] <filepattern>..."; |
||||
|
||||
static struct { |
||||
int nr, alloc; |
||||
const char **name; |
||||
} list; |
||||
|
||||
static void add_list(const char *name) |
||||
{ |
||||
if (list.nr >= list.alloc) { |
||||
list.alloc = alloc_nr(list.alloc); |
||||
list.name = xrealloc(list.name, list.alloc * sizeof(const char *)); |
||||
} |
||||
list.name[list.nr++] = name; |
||||
} |
||||
|
||||
static int remove_file(const char *name) |
||||
{ |
||||
int ret; |
||||
char *slash; |
||||
|
||||
ret = unlink(name); |
||||
if (!ret && (slash = strrchr(name, '/'))) { |
||||
char *n = strdup(name); |
||||
do { |
||||
n[slash - name] = 0; |
||||
name = n; |
||||
} while (!rmdir(name) && (slash = strrchr(name, '/'))); |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
static struct cache_file cache_file; |
||||
|
||||
int cmd_rm(int argc, const char **argv, char **envp) |
||||
{ |
||||
int i, newfd; |
||||
int verbose = 0, show_only = 0, force = 0; |
||||
const char *prefix = setup_git_directory(); |
||||
const char **pathspec; |
||||
char *seen; |
||||
|
||||
git_config(git_default_config); |
||||
|
||||
newfd = hold_index_file_for_update(&cache_file, get_index_file()); |
||||
if (newfd < 0) |
||||
die("unable to create new index file"); |
||||
|
||||
if (read_cache() < 0) |
||||
die("index file corrupt"); |
||||
|
||||
for (i = 1 ; i < argc ; i++) { |
||||
const char *arg = argv[i]; |
||||
|
||||
if (*arg != '-') |
||||
break; |
||||
if (!strcmp(arg, "--")) { |
||||
i++; |
||||
break; |
||||
} |
||||
if (!strcmp(arg, "-n")) { |
||||
show_only = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "-v")) { |
||||
verbose = 1; |
||||
continue; |
||||
} |
||||
if (!strcmp(arg, "-f")) { |
||||
force = 1; |
||||
continue; |
||||
} |
||||
die(builtin_rm_usage); |
||||
} |
||||
pathspec = get_pathspec(prefix, argv + i); |
||||
|
||||
seen = NULL; |
||||
if (pathspec) { |
||||
for (i = 0; pathspec[i] ; i++) |
||||
/* nothing */; |
||||
seen = xmalloc(i); |
||||
memset(seen, 0, i); |
||||
} |
||||
|
||||
for (i = 0; i < active_nr; i++) { |
||||
struct cache_entry *ce = active_cache[i]; |
||||
if (!match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, seen)) |
||||
continue; |
||||
add_list(ce->name); |
||||
} |
||||
|
||||
if (pathspec) { |
||||
const char *match; |
||||
for (i = 0; (match = pathspec[i]) != NULL ; i++) { |
||||
if (*match && !seen[i]) |
||||
die("pathspec '%s' did not match any files", match); |
||||
} |
||||
} |
||||
|
||||
/* |
||||
* First remove the names from the index: we won't commit |
||||
* the index unless all of them succeed |
||||
*/ |
||||
for (i = 0; i < list.nr; i++) { |
||||
const char *path = list.name[i]; |
||||
printf("rm '%s'\n", path); |
||||
|
||||
if (remove_file_from_cache(path)) |
||||
die("git rm: unable to remove %s", path); |
||||
cache_tree_invalidate_path(active_cache_tree, path); |
||||
} |
||||
|
||||
/* |
||||
* Then, if we used "-f", remove the filenames from the |
||||
* workspace. If we fail to remove the first one, we |
||||
* abort the "git rm" (but once we've successfully removed |
||||
* any file at all, we'll go ahead and commit to it all: |
||||
* by then we've already committed ourself and can't fail |
||||
* in the middle) |
||||
*/ |
||||
if (force) { |
||||
int removed = 0; |
||||
for (i = 0; i < list.nr; i++) { |
||||
const char *path = list.name[i]; |
||||
if (!remove_file(path)) { |
||||
removed = 1; |
||||
continue; |
||||
} |
||||
if (!removed) |
||||
die("git rm: %s: %s", path, strerror(errno)); |
||||
} |
||||
} |
||||
|
||||
if (active_cache_changed) { |
||||
if (write_cache(newfd, active_cache, active_nr) || |
||||
commit_index_file(&cache_file)) |
||||
die("Unable to write new index file"); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,401 @@
@@ -0,0 +1,401 @@
|
||||
/* |
||||
* This handles recursive filename detection with exclude |
||||
* files, index knowledge etc.. |
||||
* |
||||
* Copyright (C) Linus Torvalds, 2005-2006 |
||||
* Junio Hamano, 2005-2006 |
||||
*/ |
||||
#include <dirent.h> |
||||
#include <fnmatch.h> |
||||
|
||||
#include "cache.h" |
||||
#include "dir.h" |
||||
|
||||
int common_prefix(const char **pathspec) |
||||
{ |
||||
const char *path, *slash, *next; |
||||
int prefix; |
||||
|
||||
if (!pathspec) |
||||
return 0; |
||||
|
||||
path = *pathspec; |
||||
slash = strrchr(path, '/'); |
||||
if (!slash) |
||||
return 0; |
||||
|
||||
prefix = slash - path + 1; |
||||
while ((next = *++pathspec) != NULL) { |
||||
int len = strlen(next); |
||||
if (len >= prefix && !memcmp(path, next, len)) |
||||
continue; |
||||
for (;;) { |
||||
if (!len) |
||||
return 0; |
||||
if (next[--len] != '/') |
||||
continue; |
||||
if (memcmp(path, next, len+1)) |
||||
continue; |
||||
prefix = len + 1; |
||||
break; |
||||
} |
||||
} |
||||
return prefix; |
||||
} |
||||
|
||||
static int match_one(const char *match, const char *name, int namelen) |
||||
{ |
||||
int matchlen; |
||||
|
||||
/* If the match was just the prefix, we matched */ |
||||
matchlen = strlen(match); |
||||
if (!matchlen) |
||||
return 1; |
||||
|
||||
/* |
||||
* If we don't match the matchstring exactly, |
||||
* we need to match by fnmatch |
||||
*/ |
||||
if (strncmp(match, name, matchlen)) |
||||
return !fnmatch(match, name, 0); |
||||
|
||||
/* |
||||
* If we did match the string exactly, we still |
||||
* need to make sure that it happened on a path |
||||
* component boundary (ie either the last character |
||||
* of the match was '/', or the next character of |
||||
* the name was '/' or the terminating NUL. |
||||
*/ |
||||
return match[matchlen-1] == '/' || |
||||
name[matchlen] == '/' || |
||||
!name[matchlen]; |
||||
} |
||||
|
||||
int match_pathspec(const char **pathspec, const char *name, int namelen, int prefix, char *seen) |
||||
{ |
||||
int retval; |
||||
const char *match; |
||||
|
||||
name += prefix; |
||||
namelen -= prefix; |
||||
|
||||
for (retval = 0; (match = *pathspec++) != NULL; seen++) { |
||||
if (retval & *seen) |
||||
continue; |
||||
match += prefix; |
||||
if (match_one(match, name, namelen)) { |
||||
retval = 1; |
||||
*seen = 1; |
||||
} |
||||
} |
||||
return retval; |
||||
} |
||||
|
||||
void add_exclude(const char *string, const char *base, |
||||
int baselen, struct exclude_list *which) |
||||
{ |
||||
struct exclude *x = xmalloc(sizeof (*x)); |
||||
|
||||
x->pattern = string; |
||||
x->base = base; |
||||
x->baselen = baselen; |
||||
if (which->nr == which->alloc) { |
||||
which->alloc = alloc_nr(which->alloc); |
||||
which->excludes = realloc(which->excludes, |
||||
which->alloc * sizeof(x)); |
||||
} |
||||
which->excludes[which->nr++] = x; |
||||
} |
||||
|
||||
static int add_excludes_from_file_1(const char *fname, |
||||
const char *base, |
||||
int baselen, |
||||
struct exclude_list *which) |
||||
{ |
||||
int fd, i; |
||||
long size; |
||||
char *buf, *entry; |
||||
|
||||
fd = open(fname, O_RDONLY); |
||||
if (fd < 0) |
||||
goto err; |
||||
size = lseek(fd, 0, SEEK_END); |
||||
if (size < 0) |
||||
goto err; |
||||
lseek(fd, 0, SEEK_SET); |
||||
if (size == 0) { |
||||
close(fd); |
||||
return 0; |
||||
} |
||||
buf = xmalloc(size+1); |
||||
if (read(fd, buf, size) != size) |
||||
goto err; |
||||
close(fd); |
||||
|
||||
buf[size++] = '\n'; |
||||
entry = buf; |
||||
for (i = 0; i < size; i++) { |
||||
if (buf[i] == '\n') { |
||||
if (entry != buf + i && entry[0] != '#') { |
||||
buf[i - (i && buf[i-1] == '\r')] = 0; |
||||
add_exclude(entry, base, baselen, which); |
||||
} |
||||
entry = buf + i + 1; |
||||
} |
||||
} |
||||
return 0; |
||||
|
||||
err: |
||||
if (0 <= fd) |
||||
close(fd); |
||||
return -1; |
||||
} |
||||
|
||||
void add_excludes_from_file(struct dir_struct *dir, const char *fname) |
||||
{ |
||||
if (add_excludes_from_file_1(fname, "", 0, |
||||
&dir->exclude_list[EXC_FILE]) < 0) |
||||
die("cannot use %s as an exclude file", fname); |
||||
} |
||||
|
||||
static int push_exclude_per_directory(struct dir_struct *dir, const char *base, int baselen) |
||||
{ |
||||
char exclude_file[PATH_MAX]; |
||||
struct exclude_list *el = &dir->exclude_list[EXC_DIRS]; |
||||
int current_nr = el->nr; |
||||
|
||||
if (dir->exclude_per_dir) { |
||||
memcpy(exclude_file, base, baselen); |
||||
strcpy(exclude_file + baselen, dir->exclude_per_dir); |
||||
add_excludes_from_file_1(exclude_file, base, baselen, el); |
||||
} |
||||
return current_nr; |
||||
} |
||||
|
||||
static void pop_exclude_per_directory(struct dir_struct *dir, int stk) |
||||
{ |
||||
struct exclude_list *el = &dir->exclude_list[EXC_DIRS]; |
||||
|
||||
while (stk < el->nr) |
||||
free(el->excludes[--el->nr]); |
||||
} |
||||
|
||||
/* Scan the list and let the last match determines the fate. |
||||
* Return 1 for exclude, 0 for include and -1 for undecided. |
||||
*/ |
||||
static int excluded_1(const char *pathname, |
||||
int pathlen, |
||||
struct exclude_list *el) |
||||
{ |
||||
int i; |
||||
|
||||
if (el->nr) { |
||||
for (i = el->nr - 1; 0 <= i; i--) { |
||||
struct exclude *x = el->excludes[i]; |
||||
const char *exclude = x->pattern; |
||||
int to_exclude = 1; |
||||
|
||||
if (*exclude == '!') { |
||||
to_exclude = 0; |
||||
exclude++; |
||||
} |
||||
|
||||
if (!strchr(exclude, '/')) { |
||||
/* match basename */ |
||||
const char *basename = strrchr(pathname, '/'); |
||||
basename = (basename) ? basename+1 : pathname; |
||||
if (fnmatch(exclude, basename, 0) == 0) |
||||
return to_exclude; |
||||
} |
||||
else { |
||||
/* match with FNM_PATHNAME: |
||||
* exclude has base (baselen long) implicitly |
||||
* in front of it. |
||||
*/ |
||||
int baselen = x->baselen; |
||||
if (*exclude == '/') |
||||
exclude++; |
||||
|
||||
if (pathlen < baselen || |
||||
(baselen && pathname[baselen-1] != '/') || |
||||
strncmp(pathname, x->base, baselen)) |
||||
continue; |
||||
|
||||
if (fnmatch(exclude, pathname+baselen, |
||||
FNM_PATHNAME) == 0) |
||||
return to_exclude; |
||||
} |
||||
} |
||||
} |
||||
return -1; /* undecided */ |
||||
} |
||||
|
||||
int excluded(struct dir_struct *dir, const char *pathname) |
||||
{ |
||||
int pathlen = strlen(pathname); |
||||
int st; |
||||
|
||||
for (st = EXC_CMDL; st <= EXC_FILE; st++) { |
||||
switch (excluded_1(pathname, pathlen, &dir->exclude_list[st])) { |
||||
case 0: |
||||
return 0; |
||||
case 1: |
||||
return 1; |
||||
} |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
static void add_name(struct dir_struct *dir, const char *pathname, int len) |
||||
{ |
||||
struct dir_entry *ent; |
||||
|
||||
if (cache_name_pos(pathname, len) >= 0) |
||||
return; |
||||
|
||||
if (dir->nr == dir->alloc) { |
||||
int alloc = alloc_nr(dir->alloc); |
||||
dir->alloc = alloc; |
||||
dir->entries = xrealloc(dir->entries, alloc*sizeof(ent)); |
||||
} |
||||
ent = xmalloc(sizeof(*ent) + len + 1); |
||||
ent->len = len; |
||||
memcpy(ent->name, pathname, len); |
||||
ent->name[len] = 0; |
||||
dir->entries[dir->nr++] = ent; |
||||
} |
||||
|
||||
static int dir_exists(const char *dirname, int len) |
||||
{ |
||||
int pos = cache_name_pos(dirname, len); |
||||
if (pos >= 0) |
||||
return 1; |
||||
pos = -pos-1; |
||||
if (pos >= active_nr) /* can't */ |
||||
return 0; |
||||
return !strncmp(active_cache[pos]->name, dirname, len); |
||||
} |
||||
|
||||
/* |
||||
* Read a directory tree. We currently ignore anything but |
||||
* directories, regular files and symlinks. That's because git |
||||
* doesn't handle them at all yet. Maybe that will change some |
||||
* day. |
||||
* |
||||
* Also, we ignore the name ".git" (even if it is not a directory). |
||||
* That likely will not change. |
||||
*/ |
||||
static int read_directory_recursive(struct dir_struct *dir, const char *path, const char *base, int baselen) |
||||
{ |
||||
DIR *fdir = opendir(path); |
||||
int contents = 0; |
||||
|
||||
if (fdir) { |
||||
int exclude_stk; |
||||
struct dirent *de; |
||||
char fullname[MAXPATHLEN + 1]; |
||||
memcpy(fullname, base, baselen); |
||||
|
||||
exclude_stk = push_exclude_per_directory(dir, base, baselen); |
||||
|
||||
while ((de = readdir(fdir)) != NULL) { |
||||
int len; |
||||
|
||||
if ((de->d_name[0] == '.') && |
||||
(de->d_name[1] == 0 || |
||||
!strcmp(de->d_name + 1, ".") || |
||||
!strcmp(de->d_name + 1, "git"))) |
||||
continue; |
||||
len = strlen(de->d_name); |
||||
memcpy(fullname + baselen, de->d_name, len+1); |
||||
if (excluded(dir, fullname) != dir->show_ignored) { |
||||
if (!dir->show_ignored || DTYPE(de) != DT_DIR) { |
||||
continue; |
||||
} |
||||
} |
||||
|
||||
switch (DTYPE(de)) { |
||||
struct stat st; |
||||
int subdir, rewind_base; |
||||
default: |
||||
continue; |
||||
case DT_UNKNOWN: |
||||
if (lstat(fullname, &st)) |
||||
continue; |
||||
if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) |
||||
break; |
||||
if (!S_ISDIR(st.st_mode)) |
||||
continue; |
||||
/* fallthrough */ |
||||
case DT_DIR: |
||||
memcpy(fullname + baselen + len, "/", 2); |
||||
len++; |
||||
rewind_base = dir->nr; |
||||
subdir = read_directory_recursive(dir, fullname, fullname, |
||||
baselen + len); |
||||
if (dir->show_other_directories && |
||||
(subdir || !dir->hide_empty_directories) && |
||||
!dir_exists(fullname, baselen + len)) { |
||||
// Rewind the read subdirectory |
||||
while (dir->nr > rewind_base) |
||||
free(dir->entries[--dir->nr]); |
||||
break; |
||||
} |
||||
contents += subdir; |
||||
continue; |
||||
case DT_REG: |
||||
case DT_LNK: |
||||
break; |
||||
} |
||||
add_name(dir, fullname, baselen + len); |
||||
contents++; |
||||
} |
||||
closedir(fdir); |
||||
|
||||
pop_exclude_per_directory(dir, exclude_stk); |
||||
} |
||||
|
||||
return contents; |
||||
} |
||||
|
||||
static int cmp_name(const void *p1, const void *p2) |
||||
{ |
||||
const struct dir_entry *e1 = *(const struct dir_entry **)p1; |
||||
const struct dir_entry *e2 = *(const struct dir_entry **)p2; |
||||
|
||||
return cache_name_compare(e1->name, e1->len, |
||||
e2->name, e2->len); |
||||
} |
||||
|
||||
int read_directory(struct dir_struct *dir, const char *path, const char *base, int baselen) |
||||
{ |
||||
/* |
||||
* Make sure to do the per-directory exclude for all the |
||||
* directories leading up to our base. |
||||
*/ |
||||
if (baselen) { |
||||
if (dir->exclude_per_dir) { |
||||
char *p, *pp = xmalloc(baselen+1); |
||||
memcpy(pp, base, baselen+1); |
||||
p = pp; |
||||
while (1) { |
||||
char save = *p; |
||||
*p = 0; |
||||
push_exclude_per_directory(dir, pp, p-pp); |
||||
*p++ = save; |
||||
if (!save) |
||||
break; |
||||
p = strchr(p, '/'); |
||||
if (p) |
||||
p++; |
||||
else |
||||
p = pp + baselen; |
||||
} |
||||
free(pp); |
||||
} |
||||
} |
||||
|
||||
read_directory_recursive(dir, path, base, baselen); |
||||
qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name); |
||||
return dir->nr; |
||||
} |
||||
@ -0,0 +1,51 @@
@@ -0,0 +1,51 @@
|
||||
#ifndef DIR_H |
||||
#define DIR_H |
||||
|
||||
/* |
||||
* We maintain three exclude pattern lists: |
||||
* EXC_CMDL lists patterns explicitly given on the command line. |
||||
* EXC_DIRS lists patterns obtained from per-directory ignore files. |
||||
* EXC_FILE lists patterns from fallback ignore files. |
||||
*/ |
||||
#define EXC_CMDL 0 |
||||
#define EXC_DIRS 1 |
||||
#define EXC_FILE 2 |
||||
|
||||
|
||||
struct dir_entry { |
||||
int len; |
||||
char name[FLEX_ARRAY]; /* more */ |
||||
}; |
||||
|
||||
struct exclude_list { |
||||
int nr; |
||||
int alloc; |
||||
struct exclude { |
||||
const char *pattern; |
||||
const char *base; |
||||
int baselen; |
||||
} **excludes; |
||||
}; |
||||
|
||||
struct dir_struct { |
||||
int nr, alloc; |
||||
unsigned int show_ignored:1, |
||||
show_other_directories:1, |
||||
hide_empty_directories:1; |
||||
struct dir_entry **entries; |
||||
|
||||
/* Exclude info */ |
||||
const char *exclude_per_dir; |
||||
struct exclude_list exclude_list[3]; |
||||
}; |
||||
|
||||
extern int common_prefix(const char **pathspec); |
||||
extern int match_pathspec(const char **pathspec, const char *name, int namelen, int prefix, char *seen); |
||||
|
||||
extern int read_directory(struct dir_struct *, const char *path, const char *base, int baselen); |
||||
extern int excluded(struct dir_struct *, const char *); |
||||
extern void add_excludes_from_file(struct dir_struct *, const char *fname); |
||||
extern void add_exclude(const char *string, const char *base, |
||||
int baselen, struct exclude_list *which); |
||||
|
||||
#endif |
||||
@ -1,56 +0,0 @@
@@ -1,56 +0,0 @@
|
||||
#!/bin/sh |
||||
|
||||
USAGE='[-n] [-v] <file>...' |
||||
SUBDIRECTORY_OK='Yes' |
||||
. git-sh-setup |
||||
|
||||
show_only= |
||||
verbose= |
||||
while : ; do |
||||
case "$1" in |
||||
-n) |
||||
show_only=true |
||||
;; |
||||
-v) |
||||
verbose=--verbose |
||||
;; |
||||
--) |
||||
shift |
||||
break |
||||
;; |
||||
-*) |
||||
usage |
||||
;; |
||||
*) |
||||
break |
||||
;; |
||||
esac |
||||
shift |
||||
done |
||||
|
||||
# Check misspelled pathspec |
||||
case "$#" in |
||||
0) ;; |
||||
*) |
||||
git-ls-files --error-unmatch --others --cached -- "$@" >/dev/null || { |
||||
echo >&2 "Maybe you misspelled it?" |
||||
exit 1 |
||||
} |
||||
;; |
||||
esac |
||||
|
||||
if test -f "$GIT_DIR/info/exclude" |
||||
then |
||||
git-ls-files -z \ |
||||
--exclude-from="$GIT_DIR/info/exclude" \ |
||||
--others --exclude-per-directory=.gitignore -- "$@" |
||||
else |
||||
git-ls-files -z \ |
||||
--others --exclude-per-directory=.gitignore -- "$@" |
||||
fi | |
||||
case "$show_only" in |
||||
true) |
||||
xargs -0 echo ;; |
||||
*) |
||||
git-update-index --add $verbose -z --stdin ;; |
||||
esac |
||||
@ -1,70 +0,0 @@
@@ -1,70 +0,0 @@
|
||||
#!/bin/sh |
||||
|
||||
USAGE='[-f] [-n] [-v] [--] <file>...' |
||||
SUBDIRECTORY_OK='Yes' |
||||
. git-sh-setup |
||||
|
||||
remove_files= |
||||
show_only= |
||||
verbose= |
||||
while : ; do |
||||
case "$1" in |
||||
-f) |
||||
remove_files=true |
||||
;; |
||||
-n) |
||||
show_only=true |
||||
;; |
||||
-v) |
||||
verbose=--verbose |
||||
;; |
||||
--) |
||||
shift; break |
||||
;; |
||||
-*) |
||||
usage |
||||
;; |
||||
*) |
||||
break |
||||
;; |
||||
esac |
||||
shift |
||||
done |
||||
|
||||
# This is typo-proofing. If some paths match and some do not, we want |
||||
# to do nothing. |
||||
case "$#" in |
||||
0) ;; |
||||
*) |
||||
git-ls-files --error-unmatch -- "$@" >/dev/null || { |
||||
echo >&2 "Maybe you misspelled it?" |
||||
exit 1 |
||||
} |
||||
;; |
||||
esac |
||||
|
||||
if test -f "$GIT_DIR/info/exclude" |
||||
then |
||||
git-ls-files -z \ |
||||
--exclude-from="$GIT_DIR/info/exclude" \ |
||||
--exclude-per-directory=.gitignore -- "$@" |
||||
else |
||||
git-ls-files -z \ |
||||
--exclude-per-directory=.gitignore -- "$@" |
||||
fi | |
||||
case "$show_only,$remove_files" in |
||||
true,*) |
||||
xargs -0 echo |
||||
;; |
||||
*,true) |
||||
xargs -0 sh -c " |
||||
while [ \$# -gt 0 ]; do |
||||
file=\$1; shift |
||||
rm -- \"\$file\" && git-update-index --remove $verbose \"\$file\" |
||||
done |
||||
" inline |
||||
;; |
||||
*) |
||||
git-update-index --force-remove $verbose -z --stdin |
||||
;; |
||||
esac |
||||
Loading…
Reference in new issue