mirror of
https://github.com/git/git
synced 2024-08-25 10:45:59 +00:00
![Ramsay Jones](/assets/img/avatar_default.png)
Test t7606-merge-custom.sh fails on cygwin when git-merge fails with an "Could not find merge strategy 'theirs'" error, despite the test correctly preparing an (executable) git-merge-theirs script. The cause of the failure is the mis-detection of the executable status of the script, by the is_executable() function, while the load_command_list() function is searching the path for additional merge strategy programs. Note that the l/stat() "functions" on cygwin are somewhat schizophrenic (see commitsadbc0b6
,7faee6b
and7974843
), and their behaviour depends on the timing of various git setup and config function calls. In particular, until the "git_dir" has been set (have_git_dir() returns true), the real cygwin (POSIX emulating) l/stat() functions are called. Once "git_dir" has been set, the "native Win32 API" implementations of l/stat() may, or may not, be called depending on the setting of the core.filemode and core.ignorecygwinfstricks config variables. We also note that, since commitc869753
, core.filemode is forced to false, even on NTFS, by git-init and git-clone. A user (or a test) can, of course, reset core.filemode to true explicitly if the filesystem supports it (and he doesn't use any problematic windows software). The test-suite currently runs all tests on cygwin with core.filemode set to false. Given the above, we see that the built-in merge strategies are correctly detected as executable, since they are checked for before "git_dir" is set, whereas all custom merge strategies are not, since they are checked for after "git_dir" is set. In order to fix the mis-detection problem, we change the code in is_executable() to re-use the conditional WIN32 code section, which actually looks at the content of the file to determine if the file is executable. On cygwin we also make the additional code conditional on the executable bit of the file mode returned by the initial stat() call. (only the real cygwin function would set the executable bit in the file mode.) Signed-off-by: Ramsay Jones <ramsay@ramsay1.demon.co.uk> Signed-off-by: Junio C Hamano <gitster@pobox.com>
405 lines
9.5 KiB
C
405 lines
9.5 KiB
C
#include "cache.h"
|
|
#include "builtin.h"
|
|
#include "exec_cmd.h"
|
|
#include "levenshtein.h"
|
|
#include "help.h"
|
|
#include "common-cmds.h"
|
|
|
|
/* most GUI terminals set COLUMNS (although some don't export it) */
|
|
static int term_columns(void)
|
|
{
|
|
char *col_string = getenv("COLUMNS");
|
|
int n_cols;
|
|
|
|
if (col_string && (n_cols = atoi(col_string)) > 0)
|
|
return n_cols;
|
|
|
|
#ifdef TIOCGWINSZ
|
|
{
|
|
struct winsize ws;
|
|
if (!ioctl(1, TIOCGWINSZ, &ws)) {
|
|
if (ws.ws_col)
|
|
return ws.ws_col;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return 80;
|
|
}
|
|
|
|
void add_cmdname(struct cmdnames *cmds, const char *name, int len)
|
|
{
|
|
struct cmdname *ent = xmalloc(sizeof(*ent) + len + 1);
|
|
|
|
ent->len = len;
|
|
memcpy(ent->name, name, len);
|
|
ent->name[len] = 0;
|
|
|
|
ALLOC_GROW(cmds->names, cmds->cnt + 1, cmds->alloc);
|
|
cmds->names[cmds->cnt++] = ent;
|
|
}
|
|
|
|
static void clean_cmdnames(struct cmdnames *cmds)
|
|
{
|
|
int i;
|
|
for (i = 0; i < cmds->cnt; ++i)
|
|
free(cmds->names[i]);
|
|
free(cmds->names);
|
|
cmds->cnt = 0;
|
|
cmds->alloc = 0;
|
|
}
|
|
|
|
static int cmdname_compare(const void *a_, const void *b_)
|
|
{
|
|
struct cmdname *a = *(struct cmdname **)a_;
|
|
struct cmdname *b = *(struct cmdname **)b_;
|
|
return strcmp(a->name, b->name);
|
|
}
|
|
|
|
static void uniq(struct cmdnames *cmds)
|
|
{
|
|
int i, j;
|
|
|
|
if (!cmds->cnt)
|
|
return;
|
|
|
|
for (i = j = 1; i < cmds->cnt; i++)
|
|
if (strcmp(cmds->names[i]->name, cmds->names[i-1]->name))
|
|
cmds->names[j++] = cmds->names[i];
|
|
|
|
cmds->cnt = j;
|
|
}
|
|
|
|
void exclude_cmds(struct cmdnames *cmds, struct cmdnames *excludes)
|
|
{
|
|
int ci, cj, ei;
|
|
int cmp;
|
|
|
|
ci = cj = ei = 0;
|
|
while (ci < cmds->cnt && ei < excludes->cnt) {
|
|
cmp = strcmp(cmds->names[ci]->name, excludes->names[ei]->name);
|
|
if (cmp < 0)
|
|
cmds->names[cj++] = cmds->names[ci++];
|
|
else if (cmp == 0)
|
|
ci++, ei++;
|
|
else if (cmp > 0)
|
|
ei++;
|
|
}
|
|
|
|
while (ci < cmds->cnt)
|
|
cmds->names[cj++] = cmds->names[ci++];
|
|
|
|
cmds->cnt = cj;
|
|
}
|
|
|
|
static void pretty_print_string_list(struct cmdnames *cmds, int longest)
|
|
{
|
|
int cols = 1, rows;
|
|
int space = longest + 1; /* min 1 SP between words */
|
|
int max_cols = term_columns() - 1; /* don't print *on* the edge */
|
|
int i, j;
|
|
|
|
if (space < max_cols)
|
|
cols = max_cols / space;
|
|
rows = DIV_ROUND_UP(cmds->cnt, cols);
|
|
|
|
for (i = 0; i < rows; i++) {
|
|
printf(" ");
|
|
|
|
for (j = 0; j < cols; j++) {
|
|
int n = j * rows + i;
|
|
int size = space;
|
|
if (n >= cmds->cnt)
|
|
break;
|
|
if (j == cols-1 || n + rows >= cmds->cnt)
|
|
size = 1;
|
|
printf("%-*s", size, cmds->names[n]->name);
|
|
}
|
|
putchar('\n');
|
|
}
|
|
}
|
|
|
|
static int is_executable(const char *name)
|
|
{
|
|
struct stat st;
|
|
|
|
if (stat(name, &st) || /* stat, not lstat */
|
|
!S_ISREG(st.st_mode))
|
|
return 0;
|
|
|
|
#if defined(WIN32) || defined(__CYGWIN__)
|
|
#if defined(__CYGWIN__)
|
|
if ((st.st_mode & S_IXUSR) == 0)
|
|
#endif
|
|
{ /* cannot trust the executable bit, peek into the file instead */
|
|
char buf[3] = { 0 };
|
|
int n;
|
|
int fd = open(name, O_RDONLY);
|
|
st.st_mode &= ~S_IXUSR;
|
|
if (fd >= 0) {
|
|
n = read(fd, buf, 2);
|
|
if (n == 2)
|
|
/* DOS executables start with "MZ" */
|
|
if (!strcmp(buf, "#!") || !strcmp(buf, "MZ"))
|
|
st.st_mode |= S_IXUSR;
|
|
close(fd);
|
|
}
|
|
}
|
|
#endif
|
|
return st.st_mode & S_IXUSR;
|
|
}
|
|
|
|
static void list_commands_in_dir(struct cmdnames *cmds,
|
|
const char *path,
|
|
const char *prefix)
|
|
{
|
|
int prefix_len;
|
|
DIR *dir = opendir(path);
|
|
struct dirent *de;
|
|
struct strbuf buf = STRBUF_INIT;
|
|
int len;
|
|
|
|
if (!dir)
|
|
return;
|
|
if (!prefix)
|
|
prefix = "git-";
|
|
prefix_len = strlen(prefix);
|
|
|
|
strbuf_addf(&buf, "%s/", path);
|
|
len = buf.len;
|
|
|
|
while ((de = readdir(dir)) != NULL) {
|
|
int entlen;
|
|
|
|
if (prefixcmp(de->d_name, prefix))
|
|
continue;
|
|
|
|
strbuf_setlen(&buf, len);
|
|
strbuf_addstr(&buf, de->d_name);
|
|
if (!is_executable(buf.buf))
|
|
continue;
|
|
|
|
entlen = strlen(de->d_name) - prefix_len;
|
|
if (has_extension(de->d_name, ".exe"))
|
|
entlen -= 4;
|
|
|
|
add_cmdname(cmds, de->d_name + prefix_len, entlen);
|
|
}
|
|
closedir(dir);
|
|
strbuf_release(&buf);
|
|
}
|
|
|
|
void load_command_list(const char *prefix,
|
|
struct cmdnames *main_cmds,
|
|
struct cmdnames *other_cmds)
|
|
{
|
|
const char *env_path = getenv("PATH");
|
|
const char *exec_path = git_exec_path();
|
|
|
|
if (exec_path) {
|
|
list_commands_in_dir(main_cmds, exec_path, prefix);
|
|
qsort(main_cmds->names, main_cmds->cnt,
|
|
sizeof(*main_cmds->names), cmdname_compare);
|
|
uniq(main_cmds);
|
|
}
|
|
|
|
if (env_path) {
|
|
char *paths, *path, *colon;
|
|
path = paths = xstrdup(env_path);
|
|
while (1) {
|
|
if ((colon = strchr(path, PATH_SEP)))
|
|
*colon = 0;
|
|
if (!exec_path || strcmp(path, exec_path))
|
|
list_commands_in_dir(other_cmds, path, prefix);
|
|
|
|
if (!colon)
|
|
break;
|
|
path = colon + 1;
|
|
}
|
|
free(paths);
|
|
|
|
qsort(other_cmds->names, other_cmds->cnt,
|
|
sizeof(*other_cmds->names), cmdname_compare);
|
|
uniq(other_cmds);
|
|
}
|
|
exclude_cmds(other_cmds, main_cmds);
|
|
}
|
|
|
|
void list_commands(const char *title, struct cmdnames *main_cmds,
|
|
struct cmdnames *other_cmds)
|
|
{
|
|
int i, longest = 0;
|
|
|
|
for (i = 0; i < main_cmds->cnt; i++)
|
|
if (longest < main_cmds->names[i]->len)
|
|
longest = main_cmds->names[i]->len;
|
|
for (i = 0; i < other_cmds->cnt; i++)
|
|
if (longest < other_cmds->names[i]->len)
|
|
longest = other_cmds->names[i]->len;
|
|
|
|
if (main_cmds->cnt) {
|
|
const char *exec_path = git_exec_path();
|
|
printf("available %s in '%s'\n", title, exec_path);
|
|
printf("----------------");
|
|
mput_char('-', strlen(title) + strlen(exec_path));
|
|
putchar('\n');
|
|
pretty_print_string_list(main_cmds, longest);
|
|
putchar('\n');
|
|
}
|
|
|
|
if (other_cmds->cnt) {
|
|
printf("%s available from elsewhere on your $PATH\n", title);
|
|
printf("---------------------------------------");
|
|
mput_char('-', strlen(title));
|
|
putchar('\n');
|
|
pretty_print_string_list(other_cmds, longest);
|
|
putchar('\n');
|
|
}
|
|
}
|
|
|
|
int is_in_cmdlist(struct cmdnames *c, const char *s)
|
|
{
|
|
int i;
|
|
for (i = 0; i < c->cnt; i++)
|
|
if (!strcmp(s, c->names[i]->name))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int autocorrect;
|
|
static struct cmdnames aliases;
|
|
|
|
static int git_unknown_cmd_config(const char *var, const char *value, void *cb)
|
|
{
|
|
if (!strcmp(var, "help.autocorrect"))
|
|
autocorrect = git_config_int(var,value);
|
|
/* Also use aliases for command lookup */
|
|
if (!prefixcmp(var, "alias."))
|
|
add_cmdname(&aliases, var + 6, strlen(var + 6));
|
|
|
|
return git_default_config(var, value, cb);
|
|
}
|
|
|
|
static int levenshtein_compare(const void *p1, const void *p2)
|
|
{
|
|
const struct cmdname *const *c1 = p1, *const *c2 = p2;
|
|
const char *s1 = (*c1)->name, *s2 = (*c2)->name;
|
|
int l1 = (*c1)->len;
|
|
int l2 = (*c2)->len;
|
|
return l1 != l2 ? l1 - l2 : strcmp(s1, s2);
|
|
}
|
|
|
|
static void add_cmd_list(struct cmdnames *cmds, struct cmdnames *old)
|
|
{
|
|
int i;
|
|
ALLOC_GROW(cmds->names, cmds->cnt + old->cnt, cmds->alloc);
|
|
|
|
for (i = 0; i < old->cnt; i++)
|
|
cmds->names[cmds->cnt++] = old->names[i];
|
|
free(old->names);
|
|
old->cnt = 0;
|
|
old->names = NULL;
|
|
}
|
|
|
|
/* An empirically derived magic number */
|
|
#define SIMILARITY_FLOOR 7
|
|
#define SIMILAR_ENOUGH(x) ((x) < SIMILARITY_FLOOR)
|
|
|
|
const char *help_unknown_cmd(const char *cmd)
|
|
{
|
|
int i, n, best_similarity = 0;
|
|
struct cmdnames main_cmds, other_cmds;
|
|
|
|
memset(&main_cmds, 0, sizeof(main_cmds));
|
|
memset(&other_cmds, 0, sizeof(other_cmds));
|
|
memset(&aliases, 0, sizeof(aliases));
|
|
|
|
git_config(git_unknown_cmd_config, NULL);
|
|
|
|
load_command_list("git-", &main_cmds, &other_cmds);
|
|
|
|
add_cmd_list(&main_cmds, &aliases);
|
|
add_cmd_list(&main_cmds, &other_cmds);
|
|
qsort(main_cmds.names, main_cmds.cnt,
|
|
sizeof(main_cmds.names), cmdname_compare);
|
|
uniq(&main_cmds);
|
|
|
|
/* This abuses cmdname->len for levenshtein distance */
|
|
for (i = 0, n = 0; i < main_cmds.cnt; i++) {
|
|
int cmp = 0; /* avoid compiler stupidity */
|
|
const char *candidate = main_cmds.names[i]->name;
|
|
|
|
/* Does the candidate appear in common_cmds list? */
|
|
while (n < ARRAY_SIZE(common_cmds) &&
|
|
(cmp = strcmp(common_cmds[n].name, candidate)) < 0)
|
|
n++;
|
|
if ((n < ARRAY_SIZE(common_cmds)) && !cmp) {
|
|
/* Yes, this is one of the common commands */
|
|
n++; /* use the entry from common_cmds[] */
|
|
if (!prefixcmp(candidate, cmd)) {
|
|
/* Give prefix match a very good score */
|
|
main_cmds.names[i]->len = 0;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
main_cmds.names[i]->len =
|
|
levenshtein(cmd, candidate, 0, 2, 1, 4) + 1;
|
|
}
|
|
|
|
qsort(main_cmds.names, main_cmds.cnt,
|
|
sizeof(*main_cmds.names), levenshtein_compare);
|
|
|
|
if (!main_cmds.cnt)
|
|
die ("Uh oh. Your system reports no Git commands at all.");
|
|
|
|
/* skip and count prefix matches */
|
|
for (n = 0; n < main_cmds.cnt && !main_cmds.names[n]->len; n++)
|
|
; /* still counting */
|
|
|
|
if (main_cmds.cnt <= n) {
|
|
/* prefix matches with everything? that is too ambiguous */
|
|
best_similarity = SIMILARITY_FLOOR + 1;
|
|
} else {
|
|
/* count all the most similar ones */
|
|
for (best_similarity = main_cmds.names[n++]->len;
|
|
(n < main_cmds.cnt &&
|
|
best_similarity == main_cmds.names[n]->len);
|
|
n++)
|
|
; /* still counting */
|
|
}
|
|
if (autocorrect && n == 1 && SIMILAR_ENOUGH(best_similarity)) {
|
|
const char *assumed = main_cmds.names[0]->name;
|
|
main_cmds.names[0] = NULL;
|
|
clean_cmdnames(&main_cmds);
|
|
fprintf(stderr, "WARNING: You called a Git command named '%s', "
|
|
"which does not exist.\n"
|
|
"Continuing under the assumption that you meant '%s'\n",
|
|
cmd, assumed);
|
|
if (autocorrect > 0) {
|
|
fprintf(stderr, "in %0.1f seconds automatically...\n",
|
|
(float)autocorrect/10.0);
|
|
poll(NULL, 0, autocorrect * 100);
|
|
}
|
|
return assumed;
|
|
}
|
|
|
|
fprintf(stderr, "git: '%s' is not a git command. See 'git --help'.\n", cmd);
|
|
|
|
if (SIMILAR_ENOUGH(best_similarity)) {
|
|
fprintf(stderr, "\nDid you mean %s?\n",
|
|
n < 2 ? "this": "one of these");
|
|
|
|
for (i = 0; i < n; i++)
|
|
fprintf(stderr, "\t%s\n", main_cmds.names[i]->name);
|
|
}
|
|
|
|
exit(1);
|
|
}
|
|
|
|
int cmd_version(int argc, const char **argv, const char *prefix)
|
|
{
|
|
printf("git version %s\n", git_version_string);
|
|
return 0;
|
|
}
|