X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=git.c;h=5209b04de50b23c2410573dae285e156ed25f833;hb=1b9bc5a7b7434d771726011613a00cb202bd9f44;hp=4616df6e62de5fb2f4a22ebb04fb87664579bb84;hpb=d9ad59e7636d98daa6131e9fd2cb2b4f5745a853;p=git.git

diff --git a/git.c b/git.c
index 4616df6e..5209b04d 100644
--- a/git.c
+++ b/git.c
@@ -11,6 +11,13 @@
 #include <sys/ioctl.h>
 #include "git-compat-util.h"
 #include "exec_cmd.h"
+#include "common-cmds.h"
+
+#include "cache.h"
+#include "commit.h"
+#include "diff.h"
+#include "revision.h"
+#include "log-tree.h"
 
 #ifndef PATH_MAX
 # define PATH_MAX 4096
@@ -167,11 +174,29 @@ static void list_commands(const char *exec_path, const char *pattern)
 	putchar('\n');
 }
 
+static void list_common_cmds_help(void)
+{
+	int i, longest = 0;
+
+	for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
+		if (longest < strlen(common_cmds[i].name))
+			longest = strlen(common_cmds[i].name);
+	}
+
+	puts("The most commonly used git commands are:");
+	for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
+		printf("    %s", common_cmds[i].name);
+		mput_char(' ', longest - strlen(common_cmds[i].name) + 4);
+		puts(common_cmds[i].help);
+	}
+	puts("(use 'git help -a' to get a list of all installed git commands)");
+}
+
 #ifdef __GNUC__
-static void cmd_usage(const char *exec_path, const char *fmt, ...)
-	__attribute__((__format__(__printf__, 2, 3), __noreturn__));
+static void cmd_usage(int show_all, const char *exec_path, const char *fmt, ...)
+	__attribute__((__format__(__printf__, 3, 4), __noreturn__));
 #endif
-static void cmd_usage(const char *exec_path, const char *fmt, ...)
+static void cmd_usage(int show_all, const char *exec_path, const char *fmt, ...)
 {
 	if (fmt) {
 		va_list ap;
@@ -185,10 +210,13 @@ static void cmd_usage(const char *exec_path, const char *fmt, ...)
 	else
 		puts(git_usage);
 
-	putchar('\n');
-
-	if(exec_path)
-		list_commands(exec_path, "git-*");
+	if (exec_path) {
+		putchar('\n');
+		if (show_all)
+			list_commands(exec_path, "git-*");
+		else
+			list_common_cmds_help();
+        }
 
 	exit(1);
 }
@@ -212,80 +240,289 @@ static void prepend_to_path(const char *dir, int len)
 	setenv("PATH", path, 1);
 }
 
-static void show_man_page(char *git_cmd)
+static void show_man_page(const char *git_cmd)
 {
-	char *page;
+	const char *page;
 
 	if (!strncmp(git_cmd, "git", 3))
 		page = git_cmd;
 	else {
 		int page_len = strlen(git_cmd) + 4;
-
-		page = malloc(page_len + 1);
-		strcpy(page, "git-");
-		strcpy(page + 4, git_cmd);
-		page[page_len] = 0;
+		char *p = malloc(page_len + 1);
+		strcpy(p, "git-");
+		strcpy(p + 4, git_cmd);
+		p[page_len] = 0;
+		page = p;
 	}
 
 	execlp("man", "man", page, NULL);
 }
 
-int main(int argc, char **argv, char **envp)
+static int cmd_version(int argc, const char **argv, char **envp)
 {
-	char git_command[PATH_MAX + 1];
-	char wd[PATH_MAX + 1];
-	int i, show_help = 0;
-	const char *exec_path;
+	printf("git version %s\n", GIT_VERSION);
+	return 0;
+}
 
-	getcwd(wd, PATH_MAX);
+static int cmd_help(int argc, const char **argv, char **envp)
+{
+	const char *help_cmd = argv[1];
+	if (!help_cmd)
+		cmd_usage(0, git_exec_path(), NULL);
+	else if (!strcmp(help_cmd, "--all") || !strcmp(help_cmd, "-a"))
+		cmd_usage(1, git_exec_path(), NULL);
+	else
+		show_man_page(help_cmd);
+	return 0;
+}
 
-	for (i = 1; i < argc; i++) {
-		char *arg = argv[i];
+#define LOGSIZE (65536)
 
-		if (!strcmp(arg, "help")) {
-			show_help = 1;
-			continue;
+static int cmd_log(int argc, const char **argv, char **envp)
+{
+	struct rev_info rev;
+	struct commit *commit;
+	char *buf = xmalloc(LOGSIZE);
+	static enum cmit_fmt commit_format = CMIT_FMT_DEFAULT;
+	int abbrev = DEFAULT_ABBREV;
+	int abbrev_commit = 0;
+	const char *commit_prefix = "commit ";
+	struct log_tree_opt opt;
+	int shown = 0;
+	int do_diff = 0;
+	int full_diff = 0;
+
+	init_log_tree_opt(&opt);
+	argc = setup_revisions(argc, argv, &rev, "HEAD");
+	while (1 < argc) {
+		const char *arg = argv[1];
+		if (!strncmp(arg, "--pretty", 8)) {
+			commit_format = get_commit_format(arg + 8);
+			if (commit_format == CMIT_FMT_ONELINE)
+				commit_prefix = "";
+		}
+		else if (!strcmp(arg, "--no-abbrev")) {
+			abbrev = 0;
+		}
+		else if (!strcmp(arg, "--abbrev")) {
+			abbrev = DEFAULT_ABBREV;
+		}
+		else if (!strcmp(arg, "--abbrev-commit")) {
+			abbrev_commit = 1;
+		}
+		else if (!strncmp(arg, "--abbrev=", 9)) {
+			abbrev = strtoul(arg + 9, NULL, 10);
+			if (abbrev && abbrev < MINIMUM_ABBREV)
+				abbrev = MINIMUM_ABBREV;
+			else if (40 < abbrev)
+				abbrev = 40;
+		}
+		else if (!strcmp(arg, "--full-diff")) {
+			do_diff = 1;
+			full_diff = 1;
+		}
+		else {
+			int cnt = log_tree_opt_parse(&opt, argv+1, argc-1);
+			if (0 < cnt) {
+				do_diff = 1;
+				argv += cnt;
+				argc -= cnt;
+				continue;
+			}
+			die("unrecognized argument: %s", arg);
 		}
 
-		if (strncmp(arg, "--", 2))
-			break;
+		argc--; argv++;
+	}
 
-		arg += 2;
+	if (do_diff) {
+		opt.diffopt.abbrev = abbrev;
+		opt.verbose_header = 0;
+		opt.always_show_header = 0;
+		opt.no_commit_id = 1;
+		if (opt.combine_merges)
+			opt.ignore_merges = 0;
+		if (opt.dense_combined_merges)
+			opt.diffopt.output_format = DIFF_FORMAT_PATCH;
+		if (!full_diff && rev.prune_data)
+			diff_tree_setup_paths(rev.prune_data, &opt.diffopt);
+		diff_setup_done(&opt.diffopt);
+	}
 
-		if (!strncmp(arg, "exec-path", 9)) {
-			arg += 9;
-			if (*arg == '=') {
-				exec_path = arg + 1;
-				git_set_exec_path(exec_path);
-			} else {
-				puts(git_exec_path());
-				exit(0);
+	prepare_revision_walk(&rev);
+	setup_pager();
+	while ((commit = get_revision(&rev)) != NULL) {
+		if (shown && do_diff && commit_format != CMIT_FMT_ONELINE)
+			putchar('\n');
+		fputs(commit_prefix, stdout);
+		if (abbrev_commit && abbrev)
+			fputs(find_unique_abbrev(commit->object.sha1, abbrev),
+			      stdout);
+		else
+			fputs(sha1_to_hex(commit->object.sha1), stdout);
+		if (rev.parents) {
+			struct commit_list *parents = commit->parents;
+			while (parents) {
+				struct object *o = &(parents->item->object);
+				parents = parents->next;
+				if (o->flags & TMP_MARK)
+					continue;
+				printf(" %s", sha1_to_hex(o->sha1));
+				o->flags |= TMP_MARK;
 			}
+			/* TMP_MARK is a general purpose flag that can
+			 * be used locally, but the user should clean
+			 * things up after it is done with them.
+			 */
+			for (parents = commit->parents;
+			     parents;
+			     parents = parents->next)
+				parents->item->object.flags &= ~TMP_MARK;
 		}
-		else if (!strcmp(arg, "version")) {
-			printf("git version %s\n", GIT_VERSION);
-			exit(0);
+		if (commit_format == CMIT_FMT_ONELINE)
+			putchar(' ');
+		else
+			putchar('\n');
+		pretty_print_commit(commit_format, commit, ~0, buf,
+				    LOGSIZE, abbrev);
+		printf("%s\n", buf);
+		if (do_diff) {
+			printf("---\n");
+			log_tree_commit(&opt, commit);
 		}
-		else if (!strcmp(arg, "help"))
-			show_help = 1;
-		else if (!show_help)
-			cmd_usage(NULL, NULL);
+		shown = 1;
+		free(commit->buffer);
+		commit->buffer = NULL;
+	}
+	free(buf);
+	return 0;
+}
+
+static void handle_internal_command(int argc, const char **argv, char **envp)
+{
+	const char *cmd = argv[0];
+	static struct cmd_struct {
+		const char *cmd;
+		int (*fn)(int, const char **, char **);
+	} commands[] = {
+		{ "version", cmd_version },
+		{ "help", cmd_help },
+		{ "log", cmd_log },
+	};
+	int i;
+
+	/* Turn "git cmd --help" into "git help cmd" */
+	if (argc > 1 && !strcmp(argv[1], "--help")) {
+		argv[1] = argv[0];
+		argv[0] = cmd = "help";
 	}
 
-	if (i >= argc || show_help) {
-		if (i >= argc)
-			cmd_usage(git_exec_path(), NULL);
+	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));
+	}
+}
+
+int main(int argc, const char **argv, char **envp)
+{
+	const char *cmd = argv[0];
+	char *slash = strrchr(cmd, '/');
+	char git_command[PATH_MAX + 1];
+	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;
+	}
 
-		show_man_page(argv[i]);
+	/*
+	 * "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);
 	}
 
+	/* Default command: "help" */
+	cmd = "help";
+
+	/* Look for flags.. */
+	while (argc > 1) {
+		cmd = *++argv;
+		argc--;
+
+		if (strncmp(cmd, "--", 2))
+			break;
+
+		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;
+
+		/*
+		 * 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;
+			}
+			puts(git_exec_path());
+			exit(0);
+		}
+		cmd_usage(0, NULL, NULL);
+	}
+	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));
 	exec_path = git_exec_path();
 	prepend_to_path(exec_path, strlen(exec_path));
 
-	execv_git_cmd(argv + i);
+	/* See if it's an internal command */
+	handle_internal_command(argc, argv, envp);
+
+	/* .. then try the external ones */
+	execv_git_cmd(argv);
 
 	if (errno == ENOENT)
-		cmd_usage(exec_path, "'%s' is not a git-command", argv[i]);
+		cmd_usage(0, exec_path, "'%s' is not a git-command", cmd);
 
 	fprintf(stderr, "Failed to run command '%s': %s\n",
 		git_command, strerror(errno));