Merge branch 'jc/tag' into next
[git] / git.c
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
15 #include "cache.h"
16 #include "commit.h"
17 #include "revision.h"
18
19 #ifndef PATH_MAX
20 # define PATH_MAX 4096
21 #endif
22
23 static const char git_usage[] =
24         "Usage: git [--version] [--exec-path[=GIT_EXEC_PATH]] [--help] COMMAND [ ARGS ]";
25
26 /* most gui terms set COLUMNS (although some don't export it) */
27 static int term_columns(void)
28 {
29         char *col_string = getenv("COLUMNS");
30         int n_cols = 0;
31
32         if (col_string && (n_cols = atoi(col_string)) > 0)
33                 return n_cols;
34
35 #ifdef TIOCGWINSZ
36         {
37                 struct winsize ws;
38                 if (!ioctl(1, TIOCGWINSZ, &ws)) {
39                         if (ws.ws_col)
40                                 return ws.ws_col;
41                 }
42         }
43 #endif
44
45         return 80;
46 }
47
48 static void oom(void)
49 {
50         fprintf(stderr, "git: out of memory\n");
51         exit(1);
52 }
53
54 static inline void mput_char(char c, unsigned int num)
55 {
56         while(num--)
57                 putchar(c);
58 }
59
60 static struct cmdname {
61         size_t len;
62         char name[1];
63 } **cmdname;
64 static int cmdname_alloc, cmdname_cnt;
65
66 static void add_cmdname(const char *name, int len)
67 {
68         struct cmdname *ent;
69         if (cmdname_alloc <= cmdname_cnt) {
70                 cmdname_alloc = cmdname_alloc + 200;
71                 cmdname = realloc(cmdname, cmdname_alloc * sizeof(*cmdname));
72                 if (!cmdname)
73                         oom();
74         }
75         ent = malloc(sizeof(*ent) + len);
76         if (!ent)
77                 oom();
78         ent->len = len;
79         memcpy(ent->name, name, len);
80         ent->name[len] = 0;
81         cmdname[cmdname_cnt++] = ent;
82 }
83
84 static int cmdname_compare(const void *a_, const void *b_)
85 {
86         struct cmdname *a = *(struct cmdname **)a_;
87         struct cmdname *b = *(struct cmdname **)b_;
88         return strcmp(a->name, b->name);
89 }
90
91 static void pretty_print_string_list(struct cmdname **cmdname, int longest)
92 {
93         int cols = 1, rows;
94         int space = longest + 1; /* min 1 SP between words */
95         int max_cols = term_columns() - 1; /* don't print *on* the edge */
96         int i, j;
97
98         if (space < max_cols)
99                 cols = max_cols / space;
100         rows = (cmdname_cnt + cols - 1) / cols;
101
102         qsort(cmdname, cmdname_cnt, sizeof(*cmdname), cmdname_compare);
103
104         for (i = 0; i < rows; i++) {
105                 printf("  ");
106
107                 for (j = 0; j < cols; j++) {
108                         int n = j * rows + i;
109                         int size = space;
110                         if (n >= cmdname_cnt)
111                                 break;
112                         if (j == cols-1 || n + rows >= cmdname_cnt)
113                                 size = 1;
114                         printf("%-*s", size, cmdname[n]->name);
115                 }
116                 putchar('\n');
117         }
118 }
119
120 static void list_commands(const char *exec_path, const char *pattern)
121 {
122         unsigned int longest = 0;
123         char path[PATH_MAX];
124         int dirlen;
125         DIR *dir = opendir(exec_path);
126         struct dirent *de;
127
128         if (!dir) {
129                 fprintf(stderr, "git: '%s': %s\n", exec_path, strerror(errno));
130                 exit(1);
131         }
132
133         dirlen = strlen(exec_path);
134         if (PATH_MAX - 20 < dirlen) {
135                 fprintf(stderr, "git: insanely long exec-path '%s'\n",
136                         exec_path);
137                 exit(1);
138         }
139
140         memcpy(path, exec_path, dirlen);
141         path[dirlen++] = '/';
142
143         while ((de = readdir(dir)) != NULL) {
144                 struct stat st;
145                 int entlen;
146
147                 if (strncmp(de->d_name, "git-", 4))
148                         continue;
149                 strcpy(path+dirlen, de->d_name);
150                 if (stat(path, &st) || /* stat, not lstat */
151                     !S_ISREG(st.st_mode) ||
152                     !(st.st_mode & S_IXUSR))
153                         continue;
154
155                 entlen = strlen(de->d_name);
156                 if (4 < entlen && !strcmp(de->d_name + entlen - 4, ".exe"))
157                         entlen -= 4;
158
159                 if (longest < entlen)
160                         longest = entlen;
161
162                 add_cmdname(de->d_name + 4, entlen-4);
163         }
164         closedir(dir);
165
166         printf("git commands available in '%s'\n", exec_path);
167         printf("----------------------------");
168         mput_char('-', strlen(exec_path));
169         putchar('\n');
170         pretty_print_string_list(cmdname, longest - 4);
171         putchar('\n');
172 }
173
174 #ifdef __GNUC__
175 static void cmd_usage(const char *exec_path, const char *fmt, ...)
176         __attribute__((__format__(__printf__, 2, 3), __noreturn__));
177 #endif
178 static void cmd_usage(const char *exec_path, const char *fmt, ...)
179 {
180         if (fmt) {
181                 va_list ap;
182
183                 va_start(ap, fmt);
184                 printf("git: ");
185                 vprintf(fmt, ap);
186                 va_end(ap);
187                 putchar('\n');
188         }
189         else
190                 puts(git_usage);
191
192         putchar('\n');
193
194         if(exec_path)
195                 list_commands(exec_path, "git-*");
196
197         exit(1);
198 }
199
200 static void prepend_to_path(const char *dir, int len)
201 {
202         char *path, *old_path = getenv("PATH");
203         int path_len = len;
204
205         if (!old_path)
206                 old_path = "/usr/local/bin:/usr/bin:/bin";
207
208         path_len = len + strlen(old_path) + 1;
209
210         path = malloc(path_len + 1);
211
212         memcpy(path, dir, len);
213         path[len] = ':';
214         memcpy(path + len + 1, old_path, path_len - len);
215
216         setenv("PATH", path, 1);
217 }
218
219 static void show_man_page(char *git_cmd)
220 {
221         char *page;
222
223         if (!strncmp(git_cmd, "git", 3))
224                 page = git_cmd;
225         else {
226                 int page_len = strlen(git_cmd) + 4;
227
228                 page = malloc(page_len + 1);
229                 strcpy(page, "git-");
230                 strcpy(page + 4, git_cmd);
231                 page[page_len] = 0;
232         }
233
234         execlp("man", "man", page, NULL);
235 }
236
237 static int cmd_version(int argc, char **argv, char **envp)
238 {
239         printf("git version %s\n", GIT_VERSION);
240         return 0;
241 }
242
243 static int cmd_help(int argc, char **argv, char **envp)
244 {
245         char *help_cmd = argv[1];
246         if (!help_cmd)
247                 cmd_usage(git_exec_path(), NULL);
248         show_man_page(help_cmd);
249         return 0;
250 }
251
252 #define LOGSIZE (65536)
253
254 static int cmd_log(int argc, char **argv, char **envp)
255 {
256         struct rev_info rev;
257         struct commit *commit;
258         char *buf = xmalloc(LOGSIZE);
259         static enum cmit_fmt commit_format = CMIT_FMT_DEFAULT;
260         int abbrev = DEFAULT_ABBREV;
261         int show_parents = 0;
262         const char *commit_prefix = "commit ";
263
264         argc = setup_revisions(argc, argv, &rev, "HEAD");
265         while (1 < argc) {
266                 char *arg = argv[1];
267                 /* accept -<digit>, like traditilnal "head" */
268                 if ((*arg == '-') && isdigit(arg[1])) {
269                         rev.max_count = atoi(arg + 1);
270                 }
271                 else if (!strcmp(arg, "-n")) {
272                         if (argc < 2)
273                                 die("-n requires an argument");
274                         rev.max_count = atoi(argv[2]);
275                         argc--; argv++;
276                 }
277                 else if (!strncmp(arg,"-n",2)) {
278                         rev.max_count = atoi(arg + 2);
279                 }
280                 else if (!strncmp(arg, "--pretty", 8)) {
281                         commit_format = get_commit_format(arg + 8);
282                         if (commit_format == CMIT_FMT_ONELINE)
283                                 commit_prefix = "";
284                 }
285                 else if (!strcmp(arg, "--parents")) {
286                         show_parents = 1;
287                 }
288                 else if (!strcmp(arg, "--no-abbrev")) {
289                         abbrev = 0;
290                 }
291                 else if (!strncmp(arg, "--abbrev=", 9)) {
292                         abbrev = strtoul(arg + 9, NULL, 10);
293                         if (abbrev && abbrev < MINIMUM_ABBREV)
294                                 abbrev = MINIMUM_ABBREV;
295                         else if (40 < abbrev)
296                                 abbrev = 40;
297                 }
298                 else
299                         die("unrecognized argument: %s", arg);
300                 argc--; argv++;
301         }
302
303         prepare_revision_walk(&rev);
304         setup_pager();
305         while ((commit = get_revision(&rev)) != NULL) {
306                 printf("%s%s", commit_prefix,
307                        sha1_to_hex(commit->object.sha1));
308                 if (show_parents) {
309                         struct commit_list *parents = commit->parents;
310                         while (parents) {
311                                 struct object *o = &(parents->item->object);
312                                 parents = parents->next;
313                                 if (o->flags & TMP_MARK)
314                                         continue;
315                                 printf(" %s", sha1_to_hex(o->sha1));
316                                 o->flags |= TMP_MARK;
317                         }
318                         /* TMP_MARK is a general purpose flag that can
319                          * be used locally, but the user should clean
320                          * things up after it is done with them.
321                          */
322                         for (parents = commit->parents;
323                              parents;
324                              parents = parents->next)
325                                 parents->item->object.flags &= ~TMP_MARK;
326                 }
327                 if (commit_format == CMIT_FMT_ONELINE)
328                         putchar(' ');
329                 else
330                         putchar('\n');
331                 pretty_print_commit(commit_format, commit, ~0, buf,
332                                     LOGSIZE, abbrev);
333                 printf("%s\n", buf);
334         }
335         free(buf);
336         return 0;
337 }
338
339 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
340
341 static void handle_internal_command(int argc, char **argv, char **envp)
342 {
343         const char *cmd = argv[0];
344         static struct cmd_struct {
345                 const char *cmd;
346                 int (*fn)(int, char **, char **);
347         } commands[] = {
348                 { "version", cmd_version },
349                 { "help", cmd_help },
350                 { "log", cmd_log },
351         };
352         int i;
353
354         for (i = 0; i < ARRAY_SIZE(commands); i++) {
355                 struct cmd_struct *p = commands+i;
356                 if (strcmp(p->cmd, cmd))
357                         continue;
358                 exit(p->fn(argc, argv, envp));
359         }
360 }
361
362 int main(int argc, char **argv, char **envp)
363 {
364         char *cmd = argv[0];
365         char *slash = strrchr(cmd, '/');
366         char git_command[PATH_MAX + 1];
367         const char *exec_path = NULL;
368
369         /*
370          * Take the basename of argv[0] as the command
371          * name, and the dirname as the default exec_path
372          * if it's an absolute path and we don't have
373          * anything better.
374          */
375         if (slash) {
376                 *slash++ = 0;
377                 if (*cmd == '/')
378                         exec_path = cmd;
379                 cmd = slash;
380         }
381
382         /*
383          * "git-xxxx" is the same as "git xxxx", but we obviously:
384          *
385          *  - cannot take flags in between the "git" and the "xxxx".
386          *  - cannot execute it externally (since it would just do
387          *    the same thing over again)
388          *
389          * So we just directly call the internal command handler, and
390          * die if that one cannot handle it.
391          */
392         if (!strncmp(cmd, "git-", 4)) {
393                 cmd += 4;
394                 argv[0] = cmd;
395                 handle_internal_command(argc, argv, envp);
396                 die("cannot handle %s internally", cmd);
397         }
398
399         /* Default command: "help" */
400         cmd = "help";
401
402         /* Look for flags.. */
403         while (argc > 1) {
404                 cmd = *++argv;
405                 argc--;
406
407                 if (strncmp(cmd, "--", 2))
408                         break;
409
410                 cmd += 2;
411
412                 /*
413                  * For legacy reasons, the "version" and "help"
414                  * commands can be written with "--" prepended
415                  * to make them look like flags.
416                  */
417                 if (!strcmp(cmd, "help"))
418                         break;
419                 if (!strcmp(cmd, "version"))
420                         break;
421
422                 /*
423                  * Check remaining flags (which by now must be
424                  * "--exec-path", but maybe we will accept
425                  * other arguments some day)
426                  */
427                 if (!strncmp(cmd, "exec-path", 9)) {
428                         cmd += 9;
429                         if (*cmd == '=') {
430                                 git_set_exec_path(cmd + 1);
431                                 continue;
432                         }
433                         puts(git_exec_path());
434                         exit(0);
435                 }
436                 cmd_usage(NULL, NULL);
437         }
438         argv[0] = cmd;
439
440         /*
441          * We search for git commands in the following order:
442          *  - git_exec_path()
443          *  - the path of the "git" command if we could find it
444          *    in $0
445          *  - the regular PATH.
446          */
447         if (exec_path)
448                 prepend_to_path(exec_path, strlen(exec_path));
449         exec_path = git_exec_path();
450         prepend_to_path(exec_path, strlen(exec_path));
451
452         /* See if it's an internal command */
453         handle_internal_command(argc, argv, envp);
454
455         /* .. then try the external ones */
456         execv_git_cmd(argv);
457
458         if (errno == ENOENT)
459                 cmd_usage(exec_path, "'%s' is not a git-command", cmd);
460
461         fprintf(stderr, "Failed to run command '%s': %s\n",
462                 git_command, strerror(errno));
463
464         return 1;
465 }