2005-11-15 23:31:25 +00:00
|
|
|
#include <stdio.h>
|
2005-11-16 07:13:30 +00:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <dirent.h>
|
2005-11-15 23:31:25 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <limits.h>
|
|
|
|
#include <stdarg.h>
|
2005-12-05 19:54:29 +00:00
|
|
|
#include "git-compat-util.h"
|
2006-01-11 02:12:17 +00:00
|
|
|
#include "exec_cmd.h"
|
2005-11-15 23:31:25 +00:00
|
|
|
|
2006-04-21 17:27:34 +00:00
|
|
|
#include "builtin.h"
|
2005-11-15 23:31:25 +00:00
|
|
|
|
|
|
|
static void prepend_to_path(const char *dir, int len)
|
|
|
|
{
|
|
|
|
char *path, *old_path = getenv("PATH");
|
|
|
|
int path_len = len;
|
|
|
|
|
|
|
|
if (!old_path)
|
2005-11-16 07:13:30 +00:00
|
|
|
old_path = "/usr/local/bin:/usr/bin:/bin";
|
2005-11-15 23:31:25 +00:00
|
|
|
|
|
|
|
path_len = len + strlen(old_path) + 1;
|
|
|
|
|
|
|
|
path = malloc(path_len + 1);
|
|
|
|
|
|
|
|
memcpy(path, dir, len);
|
|
|
|
path[len] = ':';
|
|
|
|
memcpy(path + len + 1, old_path, path_len - len);
|
|
|
|
|
|
|
|
setenv("PATH", path, 1);
|
|
|
|
}
|
|
|
|
|
2006-04-21 17:27:34 +00:00
|
|
|
const char git_version_string[] = GIT_VERSION;
|
2006-04-16 07:07:41 +00:00
|
|
|
|
2006-03-05 10:47:29 +00:00
|
|
|
static void handle_internal_command(int argc, const char **argv, char **envp)
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
{
|
|
|
|
const char *cmd = argv[0];
|
|
|
|
static struct cmd_struct {
|
|
|
|
const char *cmd;
|
2006-03-05 10:47:29 +00:00
|
|
|
int (*fn)(int, const char **, char **);
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
} commands[] = {
|
|
|
|
{ "version", cmd_version },
|
|
|
|
{ "help", cmd_help },
|
2006-02-28 19:30:19 +00:00
|
|
|
{ "log", cmd_log },
|
2006-04-21 17:27:34 +00:00
|
|
|
{ "whatchanged", cmd_whatchanged },
|
2006-04-15 19:09:56 +00:00
|
|
|
{ "show", cmd_show },
|
git builtin "push"
This adds a builtin "push" command, which is largely just a C'ification of
the "git-push.sh" script.
Now, the reason I did it as a built-in is partly because it's yet another
step on relying less on shell, but it's actually mostly because I've
wanted to be able to push to _multiple_ repositories, and the most obvious
and simplest interface for that would seem be to just have a "remotes"
file that has multiple URL entries.
(For "pull", having multiple entries should either just select the first
one, or you could fall back on the others on failure - your choice).
And quite frankly, it just became too damn messy to do that in shell.
Besides, we actually have a fair amount of infrastructure in C, so it just
wasn't that hard to do.
Of course, this is almost totally untested. It probably doesn't work for
anything but the one trial I threw at it. "Simple" doesn't necessarily
mean "obviously correct".
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-04-30 04:22:49 +00:00
|
|
|
{ "push", cmd_push },
|
2006-05-21 09:48:21 +00:00
|
|
|
{ "format-patch", cmd_format_patch },
|
2006-04-27 22:37:18 +00:00
|
|
|
{ "count-objects", cmd_count_objects },
|
2006-05-02 05:58:18 +00:00
|
|
|
{ "diff", cmd_diff },
|
2006-05-01 06:28:15 +00:00
|
|
|
{ "grep", cmd_grep },
|
Add builtin "git rm" command
This changes semantics very subtly, because it adds a new atomicity
guarantee.
In particular, if you "git rm" several files, it will now do all or
nothing. The old shell-script really looped over the removed files one by
one, and would basically randomly fail in the middle if "-f" was used and
one of the files didn't exist in the working directory.
This C builtin one will not re-write the index after each remove, but
instead remove all files at once. However, that means that if "-f" is used
(to also force removal of the file from the working directory), and some
files have already been removed from the workspace, it won't stop in the
middle in some half-way state like the old one did.
So what happens is that if the _first_ file fails to be removed with "-f",
we abort the whole "git rm". But once we've started removing, we don't
leave anything half done. If some of the other files don't exist, we'll
just ignore errors of removal from the working tree.
This is only an issue with "-f", of course.
I think the new behaviour is strictly an improvement, but perhaps more
importantly, it is _different_. As a special case, the semantics are
identical for the single-file case (which is the only one our test-suite
seems to test).
The other question is what to do with leading directories. The old "git
rm" script didn't do anything, which is somewhat inconsistent. This one
will actually clean up directories that have become empty as a result of
removing the last file, but maybe we want to have a flag to decide the
behaviour?
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-19 23:19:34 +00:00
|
|
|
{ "rm", cmd_rm },
|
2006-05-17 16:33:32 +00:00
|
|
|
{ "add", cmd_add },
|
2006-05-18 21:19:20 +00:00
|
|
|
{ "rev-list", cmd_rev_list },
|
2006-05-19 10:03:57 +00:00
|
|
|
{ "init-db", cmd_init_db },
|
2006-05-19 01:46:44 +00:00
|
|
|
{ "tar-tree", cmd_tar_tree },
|
|
|
|
{ "upload-tar", cmd_upload_tar },
|
2006-05-23 12:15:29 +00:00
|
|
|
{ "check-ref-format", cmd_check_ref_format },
|
2006-05-23 12:15:30 +00:00
|
|
|
{ "ls-files", cmd_ls_files },
|
2006-05-23 12:15:31 +00:00
|
|
|
{ "ls-tree", cmd_ls_tree },
|
2006-05-23 12:15:32 +00:00
|
|
|
{ "tar-tree", cmd_tar_tree },
|
2006-05-23 12:15:33 +00:00
|
|
|
{ "read-tree", cmd_read_tree },
|
2006-05-23 12:15:34 +00:00
|
|
|
{ "commit-tree", cmd_commit_tree },
|
2006-05-23 12:15:35 +00:00
|
|
|
{ "apply", cmd_apply },
|
2006-05-23 12:15:36 +00:00
|
|
|
{ "show-branch", cmd_show_branch },
|
|
|
|
{ "diff-files", cmd_diff_files },
|
|
|
|
{ "diff-index", cmd_diff_index },
|
|
|
|
{ "diff-stages", cmd_diff_stages },
|
2006-05-24 11:08:46 +00:00
|
|
|
{ "diff-tree", cmd_diff_tree },
|
2006-06-03 16:45:43 +00:00
|
|
|
{ "cat-file", cmd_cat_file },
|
|
|
|
{ "rev-parse", cmd_rev_parse }
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
};
|
|
|
|
int i;
|
|
|
|
|
2006-04-15 18:13:49 +00:00
|
|
|
/* Turn "git cmd --help" into "git help cmd" */
|
|
|
|
if (argc > 1 && !strcmp(argv[1], "--help")) {
|
|
|
|
argv[1] = argv[0];
|
|
|
|
argv[0] = cmd = "help";
|
|
|
|
}
|
|
|
|
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(commands); i++) {
|
|
|
|
struct cmd_struct *p = commands+i;
|
|
|
|
if (strcmp(p->cmd, cmd))
|
|
|
|
continue;
|
|
|
|
exit(p->fn(argc, argv, envp));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-05 10:47:29 +00:00
|
|
|
int main(int argc, const char **argv, char **envp)
|
2005-11-15 23:31:25 +00:00
|
|
|
{
|
2006-03-05 10:47:29 +00:00
|
|
|
const char *cmd = argv[0];
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
char *slash = strrchr(cmd, '/');
|
2005-11-15 23:31:25 +00:00
|
|
|
char git_command[PATH_MAX + 1];
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
const char *exec_path = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Take the basename of argv[0] as the command
|
|
|
|
* name, and the dirname as the default exec_path
|
|
|
|
* if it's an absolute path and we don't have
|
|
|
|
* anything better.
|
|
|
|
*/
|
|
|
|
if (slash) {
|
|
|
|
*slash++ = 0;
|
|
|
|
if (*cmd == '/')
|
|
|
|
exec_path = cmd;
|
|
|
|
cmd = slash;
|
|
|
|
}
|
2005-11-15 23:31:25 +00:00
|
|
|
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
/*
|
|
|
|
* "git-xxxx" is the same as "git xxxx", but we obviously:
|
|
|
|
*
|
|
|
|
* - cannot take flags in between the "git" and the "xxxx".
|
|
|
|
* - cannot execute it externally (since it would just do
|
|
|
|
* the same thing over again)
|
|
|
|
*
|
|
|
|
* So we just directly call the internal command handler, and
|
|
|
|
* die if that one cannot handle it.
|
|
|
|
*/
|
|
|
|
if (!strncmp(cmd, "git-", 4)) {
|
|
|
|
cmd += 4;
|
|
|
|
argv[0] = cmd;
|
|
|
|
handle_internal_command(argc, argv, envp);
|
|
|
|
die("cannot handle %s internally", cmd);
|
|
|
|
}
|
2005-11-15 23:31:25 +00:00
|
|
|
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
/* Default command: "help" */
|
|
|
|
cmd = "help";
|
2005-11-15 23:31:25 +00:00
|
|
|
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
/* Look for flags.. */
|
|
|
|
while (argc > 1) {
|
|
|
|
cmd = *++argv;
|
|
|
|
argc--;
|
2006-01-03 09:53:54 +00:00
|
|
|
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
if (strncmp(cmd, "--", 2))
|
2005-11-15 23:31:25 +00:00
|
|
|
break;
|
|
|
|
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
cmd += 2;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For legacy reasons, the "version" and "help"
|
|
|
|
* commands can be written with "--" prepended
|
|
|
|
* to make them look like flags.
|
|
|
|
*/
|
|
|
|
if (!strcmp(cmd, "help"))
|
|
|
|
break;
|
|
|
|
if (!strcmp(cmd, "version"))
|
|
|
|
break;
|
2005-11-15 23:31:25 +00:00
|
|
|
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
/*
|
|
|
|
* Check remaining flags (which by now must be
|
|
|
|
* "--exec-path", but maybe we will accept
|
|
|
|
* other arguments some day)
|
|
|
|
*/
|
|
|
|
if (!strncmp(cmd, "exec-path", 9)) {
|
|
|
|
cmd += 9;
|
|
|
|
if (*cmd == '=') {
|
|
|
|
git_set_exec_path(cmd + 1);
|
|
|
|
continue;
|
2005-11-15 23:31:25 +00:00
|
|
|
}
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
puts(git_exec_path());
|
2005-11-15 23:31:25 +00:00
|
|
|
exit(0);
|
|
|
|
}
|
2006-03-09 16:24:19 +00:00
|
|
|
cmd_usage(0, NULL, NULL);
|
2005-11-15 23:31:25 +00:00
|
|
|
}
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
argv[0] = cmd;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We search for git commands in the following order:
|
|
|
|
* - git_exec_path()
|
|
|
|
* - the path of the "git" command if we could find it
|
|
|
|
* in $0
|
|
|
|
* - the regular PATH.
|
|
|
|
*/
|
|
|
|
if (exec_path)
|
|
|
|
prepend_to_path(exec_path, strlen(exec_path));
|
2006-01-11 02:12:17 +00:00
|
|
|
exec_path = git_exec_path();
|
|
|
|
prepend_to_path(exec_path, strlen(exec_path));
|
2005-11-15 23:31:25 +00:00
|
|
|
|
Teach the "git" command to handle some commands internally
This is another patch in the "prepare to do more in C" series, where the
git wrapper command is taught about the notion of handling some
functionality internally.
Right now, the only internal commands are "version" and "help", but the
point being that we can now easily extend it to handle some of the trivial
scripts internally. Things like "git log" and "git diff" wouldn't need
separate external scripts any more.
This also implies that to support the old "git-log" and "git-diff" syntax,
the "git" wrapper now automatically looks at the name it was executed as,
and if it is "git-xxxx", it will assume that it is to internally do what
"git xxxx" would do.
In other words, you can (once you implement an internal command) soft- or
hard-link that command to the "git" wrapper command, and it will do the
right thing, whether you use the "git xxxx" or the "git-xxxx" format.
There's one other change: the search order for external programs is
modified slightly, so that the first entry remains GIT_EXEC_DIR, but the
second entry is the same directory as the git wrapper itself was executed
out of - if we can figure it out from argv[0], of course.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-02-26 20:34:51 +00:00
|
|
|
/* See if it's an internal command */
|
|
|
|
handle_internal_command(argc, argv, envp);
|
|
|
|
|
|
|
|
/* .. then try the external ones */
|
|
|
|
execv_git_cmd(argv);
|
2005-12-01 12:48:35 +00:00
|
|
|
|
|
|
|
if (errno == ENOENT)
|
2006-03-09 16:24:19 +00:00
|
|
|
cmd_usage(0, exec_path, "'%s' is not a git-command", cmd);
|
2005-12-01 12:48:35 +00:00
|
|
|
|
|
|
|
fprintf(stderr, "Failed to run command '%s': %s\n",
|
|
|
|
git_command, strerror(errno));
|
2005-11-15 23:31:25 +00:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|