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(int argc
, const char **argv
, char **envp
)
284 struct commit
*commit
;
285 char *buf
= xmalloc(LOGSIZE
);
286 static enum cmit_fmt commit_format
= CMIT_FMT_DEFAULT
;
287 int abbrev
= DEFAULT_ABBREV
;
288 int abbrev_commit
= 0;
289 const char *commit_prefix
= "commit ";
290 struct log_tree_opt opt
;
295 init_log_tree_opt(&opt
);
296 argc
= setup_revisions(argc
, argv
, &rev
, "HEAD");
298 const char *arg
= argv
[1];
299 if (!strncmp(arg
, "--pretty", 8)) {
300 commit_format
= get_commit_format(arg
+ 8);
301 if (commit_format
== CMIT_FMT_ONELINE
)
304 else if (!strcmp(arg
, "--no-abbrev")) {
307 else if (!strcmp(arg
, "--abbrev")) {
308 abbrev
= DEFAULT_ABBREV
;
310 else if (!strcmp(arg
, "--abbrev-commit")) {
313 else if (!strncmp(arg
, "--abbrev=", 9)) {
314 abbrev
= strtoul(arg
+ 9, NULL
, 10);
315 if (abbrev
&& abbrev
< MINIMUM_ABBREV
)
316 abbrev
= MINIMUM_ABBREV
;
317 else if (40 < abbrev
)
320 else if (!strcmp(arg
, "--full-diff")) {
325 int cnt
= log_tree_opt_parse(&opt
, argv
+1, argc
-1);
332 die("unrecognized argument: %s", arg
);
339 opt
.diffopt
.abbrev
= abbrev
;
340 opt
.verbose_header
= 0;
341 opt
.always_show_header
= 0;
342 opt
.no_commit_id
= 1;
343 if (opt
.combine_merges
)
344 opt
.ignore_merges
= 0;
345 if (opt
.dense_combined_merges
)
346 opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
347 if (!full_diff
&& rev
.prune_data
)
348 diff_tree_setup_paths(rev
.prune_data
, &opt
.diffopt
);
349 diff_setup_done(&opt
.diffopt
);
352 prepare_revision_walk(&rev
);
354 while ((commit
= get_revision(&rev
)) != NULL
) {
355 if (shown
&& do_diff
&& commit_format
!= CMIT_FMT_ONELINE
)
357 fputs(commit_prefix
, stdout
);
358 if (abbrev_commit
&& abbrev
)
359 fputs(find_unique_abbrev(commit
->object
.sha1
, abbrev
),
362 fputs(sha1_to_hex(commit
->object
.sha1
), stdout
);
364 struct commit_list
*parents
= commit
->parents
;
366 struct object
*o
= &(parents
->item
->object
);
367 parents
= parents
->next
;
368 if (o
->flags
& TMP_MARK
)
370 printf(" %s", sha1_to_hex(o
->sha1
));
371 o
->flags
|= TMP_MARK
;
373 /* TMP_MARK is a general purpose flag that can
374 * be used locally, but the user should clean
375 * things up after it is done with them.
377 for (parents
= commit
->parents
;
379 parents
= parents
->next
)
380 parents
->item
->object
.flags
&= ~TMP_MARK
;
382 if (commit_format
== CMIT_FMT_ONELINE
)
386 pretty_print_commit(commit_format
, commit
, ~0, buf
,
391 log_tree_commit(&opt
, commit
);
394 free(commit
->buffer
);
395 commit
->buffer
= NULL
;
401 static void handle_internal_command(int argc
, const char **argv
, char **envp
)
403 const char *cmd
= argv
[0];
404 static struct cmd_struct
{
406 int (*fn
)(int, const char **, char **);
408 { "version", cmd_version
},
409 { "help", cmd_help
},
414 /* Turn "git cmd --help" into "git help cmd" */
415 if (argc
> 1 && !strcmp(argv
[1], "--help")) {
417 argv
[0] = cmd
= "help";
420 for (i
= 0; i
< ARRAY_SIZE(commands
); i
++) {
421 struct cmd_struct
*p
= commands
+i
;
422 if (strcmp(p
->cmd
, cmd
))
424 exit(p
->fn(argc
, argv
, envp
));
428 int main(int argc
, const char **argv
, char **envp
)
430 const char *cmd
= argv
[0];
431 char *slash
= strrchr(cmd
, '/');
432 char git_command
[PATH_MAX
+ 1];
433 const char *exec_path
= NULL
;
436 * Take the basename of argv[0] as the command
437 * name, and the dirname as the default exec_path
438 * if it's an absolute path and we don't have
449 * "git-xxxx" is the same as "git xxxx", but we obviously:
451 * - cannot take flags in between the "git" and the "xxxx".
452 * - cannot execute it externally (since it would just do
453 * the same thing over again)
455 * So we just directly call the internal command handler, and
456 * die if that one cannot handle it.
458 if (!strncmp(cmd
, "git-", 4)) {
461 handle_internal_command(argc
, argv
, envp
);
462 die("cannot handle %s internally", cmd
);
465 /* Default command: "help" */
468 /* Look for flags.. */
473 if (strncmp(cmd
, "--", 2))
479 * For legacy reasons, the "version" and "help"
480 * commands can be written with "--" prepended
481 * to make them look like flags.
483 if (!strcmp(cmd
, "help"))
485 if (!strcmp(cmd
, "version"))
489 * Check remaining flags (which by now must be
490 * "--exec-path", but maybe we will accept
491 * other arguments some day)
493 if (!strncmp(cmd
, "exec-path", 9)) {
496 git_set_exec_path(cmd
+ 1);
499 puts(git_exec_path());
502 cmd_usage(0, NULL
, NULL
);
507 * We search for git commands in the following order:
509 * - the path of the "git" command if we could find it
511 * - the regular PATH.
514 prepend_to_path(exec_path
, strlen(exec_path
));
515 exec_path
= git_exec_path();
516 prepend_to_path(exec_path
, strlen(exec_path
));
518 /* See if it's an internal command */
519 handle_internal_command(argc
, argv
, envp
);
521 /* .. then try the external ones */
525 cmd_usage(0, exec_path
, "'%s' is not a git-command", cmd
);
527 fprintf(stderr
, "Failed to run command '%s': %s\n",
528 git_command
, strerror(errno
));