11 #include <sys/ioctl.h>
12 #include "git-compat-util.h"
14 #include "common-cmds.h"
23 # define PATH_MAX 4096
26 static const char git_usage
[] =
27 "Usage: git [--version] [--exec-path[=GIT_EXEC_PATH]] [--help] COMMAND [ ARGS ]";
29 /* most gui terms set COLUMNS (although some don't export it) */
30 static int term_columns(void)
32 char *col_string
= getenv("COLUMNS");
35 if (col_string
&& (n_cols
= atoi(col_string
)) > 0)
41 if (!ioctl(1, TIOCGWINSZ
, &ws
)) {
53 fprintf(stderr
, "git: out of memory\n");
57 static inline void mput_char(char c
, unsigned int num
)
63 static struct cmdname
{
67 static int cmdname_alloc
, cmdname_cnt
;
69 static void add_cmdname(const char *name
, int len
)
72 if (cmdname_alloc
<= cmdname_cnt
) {
73 cmdname_alloc
= cmdname_alloc
+ 200;
74 cmdname
= realloc(cmdname
, cmdname_alloc
* sizeof(*cmdname
));
78 ent
= malloc(sizeof(*ent
) + len
);
82 memcpy(ent
->name
, name
, len
);
84 cmdname
[cmdname_cnt
++] = ent
;
87 static int cmdname_compare(const void *a_
, const void *b_
)
89 struct cmdname
*a
= *(struct cmdname
**)a_
;
90 struct cmdname
*b
= *(struct cmdname
**)b_
;
91 return strcmp(a
->name
, b
->name
);
94 static void pretty_print_string_list(struct cmdname
**cmdname
, int longest
)
97 int space
= longest
+ 1; /* min 1 SP between words */
98 int max_cols
= term_columns() - 1; /* don't print *on* the edge */
101 if (space
< max_cols
)
102 cols
= max_cols
/ space
;
103 rows
= (cmdname_cnt
+ cols
- 1) / cols
;
105 qsort(cmdname
, cmdname_cnt
, sizeof(*cmdname
), cmdname_compare
);
107 for (i
= 0; i
< rows
; i
++) {
110 for (j
= 0; j
< cols
; j
++) {
111 int n
= j
* rows
+ i
;
113 if (n
>= cmdname_cnt
)
115 if (j
== cols
-1 || n
+ rows
>= cmdname_cnt
)
117 printf("%-*s", size
, cmdname
[n
]->name
);
123 static void list_commands(const char *exec_path
, const char *pattern
)
125 unsigned int longest
= 0;
128 DIR *dir
= opendir(exec_path
);
132 fprintf(stderr
, "git: '%s': %s\n", exec_path
, strerror(errno
));
136 dirlen
= strlen(exec_path
);
137 if (PATH_MAX
- 20 < dirlen
) {
138 fprintf(stderr
, "git: insanely long exec-path '%s'\n",
143 memcpy(path
, exec_path
, dirlen
);
144 path
[dirlen
++] = '/';
146 while ((de
= readdir(dir
)) != NULL
) {
150 if (strncmp(de
->d_name
, "git-", 4))
152 strcpy(path
+dirlen
, de
->d_name
);
153 if (stat(path
, &st
) || /* stat, not lstat */
154 !S_ISREG(st
.st_mode
) ||
155 !(st
.st_mode
& S_IXUSR
))
158 entlen
= strlen(de
->d_name
);
159 if (4 < entlen
&& !strcmp(de
->d_name
+ entlen
- 4, ".exe"))
162 if (longest
< entlen
)
165 add_cmdname(de
->d_name
+ 4, entlen
-4);
169 printf("git commands available in '%s'\n", exec_path
);
170 printf("----------------------------");
171 mput_char('-', strlen(exec_path
));
173 pretty_print_string_list(cmdname
, longest
- 4);
177 static void list_common_cmds_help(void)
181 for (i
= 0; i
< ARRAY_SIZE(common_cmds
); i
++) {
182 if (longest
< strlen(common_cmds
[i
].name
))
183 longest
= strlen(common_cmds
[i
].name
);
186 puts("The most commonly used git commands are:");
187 for (i
= 0; i
< ARRAY_SIZE(common_cmds
); i
++) {
188 printf(" %s", common_cmds
[i
].name
);
189 mput_char(' ', longest
- strlen(common_cmds
[i
].name
) + 4);
190 puts(common_cmds
[i
].help
);
192 puts("(use 'git help -a' to get a list of all installed git commands)");
196 static void cmd_usage(int show_all
, const char *exec_path
, const char *fmt
, ...)
197 __attribute__((__format__(__printf__
, 3, 4), __noreturn__
));
199 static void cmd_usage(int show_all
, const char *exec_path
, const char *fmt
, ...)
216 list_commands(exec_path
, "git-*");
218 list_common_cmds_help();
224 static void prepend_to_path(const char *dir
, int len
)
226 char *path
, *old_path
= getenv("PATH");
230 old_path
= "/usr/local/bin:/usr/bin:/bin";
232 path_len
= len
+ strlen(old_path
) + 1;
234 path
= malloc(path_len
+ 1);
236 memcpy(path
, dir
, len
);
238 memcpy(path
+ len
+ 1, old_path
, path_len
- len
);
240 setenv("PATH", path
, 1);
243 static void show_man_page(const char *git_cmd
)
247 if (!strncmp(git_cmd
, "git", 3))
250 int page_len
= strlen(git_cmd
) + 4;
251 char *p
= malloc(page_len
+ 1);
253 strcpy(p
+ 4, git_cmd
);
258 execlp("man", "man", page
, NULL
);
261 static int cmd_version(int argc
, const char **argv
, char **envp
)
263 printf("git version %s\n", GIT_VERSION
);
267 static int cmd_help(int argc
, const char **argv
, char **envp
)
269 const char *help_cmd
= argv
[1];
271 cmd_usage(0, git_exec_path(), NULL
);
272 else if (!strcmp(help_cmd
, "--all") || !strcmp(help_cmd
, "-a"))
273 cmd_usage(1, git_exec_path(), NULL
);
275 show_man_page(help_cmd
);
279 #define LOGSIZE (65536)
281 static int cmd_log_wc(int argc
, const char **argv
, char **envp
,
282 struct whatchanged_opt
*wcopt
)
284 struct commit
*commit
;
285 char *buf
= xmalloc(LOGSIZE
);
286 const char *commit_prefix
= "commit ";
288 struct rev_info
*rev
= &wcopt
->revopt
;
289 struct log_tree_opt
*opt
= &wcopt
->logopt
;
291 opt
->commit_format
= CMIT_FMT_DEFAULT
;
292 wcopt
->abbrev
= DEFAULT_ABBREV
;
293 argc
= parse_whatchanged_opt(argc
, argv
, wcopt
);
295 if (opt
->commit_format
== CMIT_FMT_ONELINE
)
298 prepare_revision_walk(rev
);
300 while ((commit
= get_revision(rev
)) != NULL
) {
301 if (shown
&& wcopt
->do_diff
&&
302 opt
->commit_format
!= CMIT_FMT_ONELINE
)
304 fputs(commit_prefix
, stdout
);
305 if (wcopt
->abbrev_commit
&& wcopt
->abbrev
)
306 fputs(find_unique_abbrev(commit
->object
.sha1
, wcopt
->abbrev
),
309 fputs(sha1_to_hex(commit
->object
.sha1
), stdout
);
311 struct commit_list
*parents
= commit
->parents
;
313 struct object
*o
= &(parents
->item
->object
);
314 parents
= parents
->next
;
315 if (o
->flags
& TMP_MARK
)
317 printf(" %s", sha1_to_hex(o
->sha1
));
318 o
->flags
|= TMP_MARK
;
320 /* TMP_MARK is a general purpose flag that can
321 * be used locally, but the user should clean
322 * things up after it is done with them.
324 for (parents
= commit
->parents
;
326 parents
= parents
->next
)
327 parents
->item
->object
.flags
&= ~TMP_MARK
;
329 if (opt
->commit_format
== CMIT_FMT_ONELINE
)
333 pretty_print_commit(opt
->commit_format
, commit
, ~0, buf
,
334 LOGSIZE
, wcopt
->abbrev
);
337 log_tree_commit(opt
, commit
);
339 free(commit
->buffer
);
340 commit
->buffer
= NULL
;
346 static int cmd_log(int ac
, const char **av
, char **ep
)
348 struct whatchanged_opt wcopt
;
350 memset(&wcopt
, 0, sizeof(wcopt
));
351 init_log_tree_opt(&wcopt
.logopt
);
352 return cmd_log_wc(ac
, av
, ep
, &wcopt
);
355 static int cmd_whatchanged(int ac
, const char **av
, char **ep
)
357 struct whatchanged_opt wcopt
;
359 memset(&wcopt
, 0, sizeof(wcopt
));
361 init_log_tree_opt(&wcopt
.logopt
);
362 wcopt
.logopt
.diffopt
.recursive
= 1;
363 return cmd_log_wc(ac
, av
, ep
, &wcopt
);
366 static int cmd_show(int ac
, const char **av
, char **ep
)
368 struct whatchanged_opt wcopt
;
370 memset(&wcopt
, 0, sizeof(wcopt
));
372 init_log_tree_opt(&wcopt
.logopt
);
373 wcopt
.logopt
.ignore_merges
= 0;
374 wcopt
.logopt
.combine_merges
= 1;
375 wcopt
.logopt
.dense_combined_merges
= 1;
376 wcopt
.logopt
.diffopt
.recursive
= 1;
377 return cmd_log_wc(ac
, av
, ep
, &wcopt
);
380 static void handle_internal_command(int argc
, const char **argv
, char **envp
)
382 const char *cmd
= argv
[0];
383 static struct cmd_struct
{
385 int (*fn
)(int, const char **, char **);
387 { "version", cmd_version
},
388 { "help", cmd_help
},
390 { "show", cmd_show
},
391 { "whatchanged", cmd_whatchanged
},
395 for (i
= 0; i
< ARRAY_SIZE(commands
); i
++) {
396 struct cmd_struct
*p
= commands
+i
;
397 if (strcmp(p
->cmd
, cmd
))
399 exit(p
->fn(argc
, argv
, envp
));
403 int main(int argc
, const char **argv
, char **envp
)
405 const char *cmd
= argv
[0];
406 char *slash
= strrchr(cmd
, '/');
407 char git_command
[PATH_MAX
+ 1];
408 const char *exec_path
= NULL
;
411 * Take the basename of argv[0] as the command
412 * name, and the dirname as the default exec_path
413 * if it's an absolute path and we don't have
424 * "git-xxxx" is the same as "git xxxx", but we obviously:
426 * - cannot take flags in between the "git" and the "xxxx".
427 * - cannot execute it externally (since it would just do
428 * the same thing over again)
430 * So we just directly call the internal command handler, and
431 * die if that one cannot handle it.
433 if (!strncmp(cmd
, "git-", 4)) {
436 handle_internal_command(argc
, argv
, envp
);
437 die("cannot handle %s internally", cmd
);
440 /* Default command: "help" */
443 /* Look for flags.. */
448 if (strncmp(cmd
, "--", 2))
454 * For legacy reasons, the "version" and "help"
455 * commands can be written with "--" prepended
456 * to make them look like flags.
458 if (!strcmp(cmd
, "help"))
460 if (!strcmp(cmd
, "version"))
464 * Check remaining flags (which by now must be
465 * "--exec-path", but maybe we will accept
466 * other arguments some day)
468 if (!strncmp(cmd
, "exec-path", 9)) {
471 git_set_exec_path(cmd
+ 1);
474 puts(git_exec_path());
477 cmd_usage(0, NULL
, NULL
);
482 * We search for git commands in the following order:
484 * - the path of the "git" command if we could find it
486 * - the regular PATH.
489 prepend_to_path(exec_path
, strlen(exec_path
));
490 exec_path
= git_exec_path();
491 prepend_to_path(exec_path
, strlen(exec_path
));
493 /* See if it's an internal command */
494 handle_internal_command(argc
, argv
, envp
);
496 /* .. then try the external ones */
500 cmd_usage(0, exec_path
, "'%s' is not a git-command", cmd
);
502 fprintf(stderr
, "Failed to run command '%s': %s\n",
503 git_command
, strerror(errno
));