ls-files: Don't require exclude files to end with a newline.
[alt-git.git] / git.c
blob0b40e3060d8d95a6da7c8603317c6e2cb6c5ec46
1 #include <stdio.h>
2 #include <sys/types.h>
3 #include <sys/stat.h>
4 #include <dirent.h>
5 #include <unistd.h>
6 #include <stdlib.h>
7 #include <string.h>
8 #include <errno.h>
9 #include <limits.h>
10 #include <stdarg.h>
11 #include <sys/ioctl.h>
12 #include "git-compat-util.h"
13 #include "exec_cmd.h"
14 #include "common-cmds.h"
16 #include "cache.h"
17 #include "commit.h"
18 #include "revision.h"
20 #ifndef PATH_MAX
21 # define PATH_MAX 4096
22 #endif
24 static const char git_usage[] =
25 "Usage: git [--version] [--exec-path[=GIT_EXEC_PATH]] [--help] COMMAND [ ARGS ]";
27 /* most gui terms set COLUMNS (although some don't export it) */
28 static int term_columns(void)
30 char *col_string = getenv("COLUMNS");
31 int n_cols = 0;
33 if (col_string && (n_cols = atoi(col_string)) > 0)
34 return n_cols;
36 #ifdef TIOCGWINSZ
38 struct winsize ws;
39 if (!ioctl(1, TIOCGWINSZ, &ws)) {
40 if (ws.ws_col)
41 return ws.ws_col;
44 #endif
46 return 80;
49 static void oom(void)
51 fprintf(stderr, "git: out of memory\n");
52 exit(1);
55 static inline void mput_char(char c, unsigned int num)
57 while(num--)
58 putchar(c);
61 static struct cmdname {
62 size_t len;
63 char name[1];
64 } **cmdname;
65 static int cmdname_alloc, cmdname_cnt;
67 static void add_cmdname(const char *name, int len)
69 struct cmdname *ent;
70 if (cmdname_alloc <= cmdname_cnt) {
71 cmdname_alloc = cmdname_alloc + 200;
72 cmdname = realloc(cmdname, cmdname_alloc * sizeof(*cmdname));
73 if (!cmdname)
74 oom();
76 ent = malloc(sizeof(*ent) + len);
77 if (!ent)
78 oom();
79 ent->len = len;
80 memcpy(ent->name, name, len);
81 ent->name[len] = 0;
82 cmdname[cmdname_cnt++] = ent;
85 static int cmdname_compare(const void *a_, const void *b_)
87 struct cmdname *a = *(struct cmdname **)a_;
88 struct cmdname *b = *(struct cmdname **)b_;
89 return strcmp(a->name, b->name);
92 static void pretty_print_string_list(struct cmdname **cmdname, int longest)
94 int cols = 1, rows;
95 int space = longest + 1; /* min 1 SP between words */
96 int max_cols = term_columns() - 1; /* don't print *on* the edge */
97 int i, j;
99 if (space < max_cols)
100 cols = max_cols / space;
101 rows = (cmdname_cnt + cols - 1) / cols;
103 qsort(cmdname, cmdname_cnt, sizeof(*cmdname), cmdname_compare);
105 for (i = 0; i < rows; i++) {
106 printf(" ");
108 for (j = 0; j < cols; j++) {
109 int n = j * rows + i;
110 int size = space;
111 if (n >= cmdname_cnt)
112 break;
113 if (j == cols-1 || n + rows >= cmdname_cnt)
114 size = 1;
115 printf("%-*s", size, cmdname[n]->name);
117 putchar('\n');
121 static void list_commands(const char *exec_path, const char *pattern)
123 unsigned int longest = 0;
124 char path[PATH_MAX];
125 int dirlen;
126 DIR *dir = opendir(exec_path);
127 struct dirent *de;
129 if (!dir) {
130 fprintf(stderr, "git: '%s': %s\n", exec_path, strerror(errno));
131 exit(1);
134 dirlen = strlen(exec_path);
135 if (PATH_MAX - 20 < dirlen) {
136 fprintf(stderr, "git: insanely long exec-path '%s'\n",
137 exec_path);
138 exit(1);
141 memcpy(path, exec_path, dirlen);
142 path[dirlen++] = '/';
144 while ((de = readdir(dir)) != NULL) {
145 struct stat st;
146 int entlen;
148 if (strncmp(de->d_name, "git-", 4))
149 continue;
150 strcpy(path+dirlen, de->d_name);
151 if (stat(path, &st) || /* stat, not lstat */
152 !S_ISREG(st.st_mode) ||
153 !(st.st_mode & S_IXUSR))
154 continue;
156 entlen = strlen(de->d_name);
157 if (4 < entlen && !strcmp(de->d_name + entlen - 4, ".exe"))
158 entlen -= 4;
160 if (longest < entlen)
161 longest = entlen;
163 add_cmdname(de->d_name + 4, entlen-4);
165 closedir(dir);
167 printf("git commands available in '%s'\n", exec_path);
168 printf("----------------------------");
169 mput_char('-', strlen(exec_path));
170 putchar('\n');
171 pretty_print_string_list(cmdname, longest - 4);
172 putchar('\n');
175 static void list_common_cmds_help()
177 int i, longest = 0;
179 for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
180 if (longest < strlen(common_cmds[i].name))
181 longest = strlen(common_cmds[i].name);
184 puts("The most commonly used git commands are:");
185 for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
186 printf(" %s", common_cmds[i].name);
187 mput_char(' ', longest - strlen(common_cmds[i].name) + 4);
188 puts(common_cmds[i].help);
190 puts("(use 'git help -a' to get a list of all installed git commands)");
193 #ifdef __GNUC__
194 static void cmd_usage(int show_all, const char *exec_path, const char *fmt, ...)
195 __attribute__((__format__(__printf__, 3, 4), __noreturn__));
196 #endif
197 static void cmd_usage(int show_all, const char *exec_path, const char *fmt, ...)
199 if (fmt) {
200 va_list ap;
202 va_start(ap, fmt);
203 printf("git: ");
204 vprintf(fmt, ap);
205 va_end(ap);
206 putchar('\n');
208 else
209 puts(git_usage);
211 if (exec_path) {
212 putchar('\n');
213 if (show_all)
214 list_commands(exec_path, "git-*");
215 else
216 list_common_cmds_help();
219 exit(1);
222 static void prepend_to_path(const char *dir, int len)
224 char *path, *old_path = getenv("PATH");
225 int path_len = len;
227 if (!old_path)
228 old_path = "/usr/local/bin:/usr/bin:/bin";
230 path_len = len + strlen(old_path) + 1;
232 path = malloc(path_len + 1);
234 memcpy(path, dir, len);
235 path[len] = ':';
236 memcpy(path + len + 1, old_path, path_len - len);
238 setenv("PATH", path, 1);
241 static void show_man_page(const char *git_cmd)
243 const char *page;
245 if (!strncmp(git_cmd, "git", 3))
246 page = git_cmd;
247 else {
248 int page_len = strlen(git_cmd) + 4;
249 char *p = malloc(page_len + 1);
250 strcpy(p, "git-");
251 strcpy(p + 4, git_cmd);
252 p[page_len] = 0;
253 page = p;
256 execlp("man", "man", page, NULL);
259 static int cmd_version(int argc, const char **argv, char **envp)
261 printf("git version %s\n", GIT_VERSION);
262 return 0;
265 static int cmd_help(int argc, const char **argv, char **envp)
267 const char *help_cmd = argv[1];
268 if (!help_cmd)
269 cmd_usage(0, git_exec_path(), NULL);
270 else if (!strcmp(help_cmd, "--all") || !strcmp(help_cmd, "-a"))
271 cmd_usage(1, git_exec_path(), NULL);
272 else
273 show_man_page(help_cmd);
274 return 0;
277 #define LOGSIZE (65536)
279 static int cmd_log(int argc, const char **argv, char **envp)
281 struct rev_info rev;
282 struct commit *commit;
283 char *buf = xmalloc(LOGSIZE);
284 static enum cmit_fmt commit_format = CMIT_FMT_DEFAULT;
285 int abbrev = DEFAULT_ABBREV;
286 int show_parents = 0;
287 const char *commit_prefix = "commit ";
289 argc = setup_revisions(argc, argv, &rev, "HEAD");
290 while (1 < argc) {
291 const char *arg = argv[1];
292 if (!strncmp(arg, "--pretty", 8)) {
293 commit_format = get_commit_format(arg + 8);
294 if (commit_format == CMIT_FMT_ONELINE)
295 commit_prefix = "";
297 else if (!strcmp(arg, "--parents")) {
298 show_parents = 1;
300 else if (!strcmp(arg, "--no-abbrev")) {
301 abbrev = 0;
303 else if (!strncmp(arg, "--abbrev=", 9)) {
304 abbrev = strtoul(arg + 9, NULL, 10);
305 if (abbrev && abbrev < MINIMUM_ABBREV)
306 abbrev = MINIMUM_ABBREV;
307 else if (40 < abbrev)
308 abbrev = 40;
310 else
311 die("unrecognized argument: %s", arg);
312 argc--; argv++;
315 prepare_revision_walk(&rev);
316 setup_pager();
317 while ((commit = get_revision(&rev)) != NULL) {
318 printf("%s%s", commit_prefix,
319 sha1_to_hex(commit->object.sha1));
320 if (show_parents) {
321 struct commit_list *parents = commit->parents;
322 while (parents) {
323 struct object *o = &(parents->item->object);
324 parents = parents->next;
325 if (o->flags & TMP_MARK)
326 continue;
327 printf(" %s", sha1_to_hex(o->sha1));
328 o->flags |= TMP_MARK;
330 /* TMP_MARK is a general purpose flag that can
331 * be used locally, but the user should clean
332 * things up after it is done with them.
334 for (parents = commit->parents;
335 parents;
336 parents = parents->next)
337 parents->item->object.flags &= ~TMP_MARK;
339 if (commit_format == CMIT_FMT_ONELINE)
340 putchar(' ');
341 else
342 putchar('\n');
343 pretty_print_commit(commit_format, commit, ~0, buf,
344 LOGSIZE, abbrev);
345 printf("%s\n", buf);
347 free(buf);
348 return 0;
351 static void handle_internal_command(int argc, const char **argv, char **envp)
353 const char *cmd = argv[0];
354 static struct cmd_struct {
355 const char *cmd;
356 int (*fn)(int, const char **, char **);
357 } commands[] = {
358 { "version", cmd_version },
359 { "help", cmd_help },
360 { "log", cmd_log },
362 int i;
364 for (i = 0; i < ARRAY_SIZE(commands); i++) {
365 struct cmd_struct *p = commands+i;
366 if (strcmp(p->cmd, cmd))
367 continue;
368 exit(p->fn(argc, argv, envp));
372 int main(int argc, const char **argv, char **envp)
374 const char *cmd = argv[0];
375 char *slash = strrchr(cmd, '/');
376 char git_command[PATH_MAX + 1];
377 const char *exec_path = NULL;
380 * Take the basename of argv[0] as the command
381 * name, and the dirname as the default exec_path
382 * if it's an absolute path and we don't have
383 * anything better.
385 if (slash) {
386 *slash++ = 0;
387 if (*cmd == '/')
388 exec_path = cmd;
389 cmd = slash;
393 * "git-xxxx" is the same as "git xxxx", but we obviously:
395 * - cannot take flags in between the "git" and the "xxxx".
396 * - cannot execute it externally (since it would just do
397 * the same thing over again)
399 * So we just directly call the internal command handler, and
400 * die if that one cannot handle it.
402 if (!strncmp(cmd, "git-", 4)) {
403 cmd += 4;
404 argv[0] = cmd;
405 handle_internal_command(argc, argv, envp);
406 die("cannot handle %s internally", cmd);
409 /* Default command: "help" */
410 cmd = "help";
412 /* Look for flags.. */
413 while (argc > 1) {
414 cmd = *++argv;
415 argc--;
417 if (strncmp(cmd, "--", 2))
418 break;
420 cmd += 2;
423 * For legacy reasons, the "version" and "help"
424 * commands can be written with "--" prepended
425 * to make them look like flags.
427 if (!strcmp(cmd, "help"))
428 break;
429 if (!strcmp(cmd, "version"))
430 break;
433 * Check remaining flags (which by now must be
434 * "--exec-path", but maybe we will accept
435 * other arguments some day)
437 if (!strncmp(cmd, "exec-path", 9)) {
438 cmd += 9;
439 if (*cmd == '=') {
440 git_set_exec_path(cmd + 1);
441 continue;
443 puts(git_exec_path());
444 exit(0);
446 cmd_usage(0, NULL, NULL);
448 argv[0] = cmd;
451 * We search for git commands in the following order:
452 * - git_exec_path()
453 * - the path of the "git" command if we could find it
454 * in $0
455 * - the regular PATH.
457 if (exec_path)
458 prepend_to_path(exec_path, strlen(exec_path));
459 exec_path = git_exec_path();
460 prepend_to_path(exec_path, strlen(exec_path));
462 /* See if it's an internal command */
463 handle_internal_command(argc, argv, envp);
465 /* .. then try the external ones */
466 execv_git_cmd(argv);
468 if (errno == ENOENT)
469 cmd_usage(0, exec_path, "'%s' is not a git-command", cmd);
471 fprintf(stderr, "Failed to run command '%s': %s\n",
472 git_command, strerror(errno));
474 return 1;