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
;
293 init_log_tree_opt(&opt
);
294 argc
= setup_revisions(argc
, argv
, &rev
, "HEAD");
296 const char *arg
= argv
[1];
297 if (!strncmp(arg
, "--pretty", 8)) {
298 commit_format
= get_commit_format(arg
+ 8);
299 if (commit_format
== CMIT_FMT_ONELINE
)
302 else if (!strcmp(arg
, "--no-abbrev")) {
305 else if (!strcmp(arg
, "--abbrev")) {
306 abbrev
= DEFAULT_ABBREV
;
308 else if (!strcmp(arg
, "--abbrev-commit")) {
311 else if (!strncmp(arg
, "--abbrev=", 9)) {
312 abbrev
= strtoul(arg
+ 9, NULL
, 10);
313 if (abbrev
&& abbrev
< MINIMUM_ABBREV
)
314 abbrev
= MINIMUM_ABBREV
;
315 else if (40 < abbrev
)
319 int cnt
= log_tree_opt_parse(&opt
, argv
+1, argc
-1);
326 die("unrecognized argument: %s", arg
);
332 opt
.diffopt
.abbrev
= abbrev
;
333 opt
.verbose_header
= 0;
334 opt
.always_show_header
= 0;
335 opt
.no_commit_id
= 1;
336 if (opt
.combine_merges
)
337 opt
.ignore_merges
= 0;
338 if (opt
.dense_combined_merges
)
339 opt
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
340 if (opt
.diffopt
.output_format
== DIFF_FORMAT_PATCH
)
341 opt
.diffopt
.recursive
= 1;
342 diff_setup_done(&opt
.diffopt
);
345 prepare_revision_walk(&rev
);
347 while ((commit
= get_revision(&rev
)) != NULL
) {
348 fputs(commit_prefix
, stdout
);
349 if (abbrev_commit
&& abbrev
)
350 fputs(find_unique_abbrev(commit
->object
.sha1
, abbrev
),
353 fputs(sha1_to_hex(commit
->object
.sha1
), stdout
);
355 struct commit_list
*parents
= commit
->parents
;
357 struct object
*o
= &(parents
->item
->object
);
358 parents
= parents
->next
;
359 if (o
->flags
& TMP_MARK
)
361 printf(" %s", sha1_to_hex(o
->sha1
));
362 o
->flags
|= TMP_MARK
;
364 /* TMP_MARK is a general purpose flag that can
365 * be used locally, but the user should clean
366 * things up after it is done with them.
368 for (parents
= commit
->parents
;
370 parents
= parents
->next
)
371 parents
->item
->object
.flags
&= ~TMP_MARK
;
373 if (commit_format
== CMIT_FMT_ONELINE
)
377 pretty_print_commit(commit_format
, commit
, ~0, buf
,
382 log_tree_commit(&opt
, commit
);
388 static void handle_internal_command(int argc
, const char **argv
, char **envp
)
390 const char *cmd
= argv
[0];
391 static struct cmd_struct
{
393 int (*fn
)(int, const char **, char **);
395 { "version", cmd_version
},
396 { "help", cmd_help
},
401 for (i
= 0; i
< ARRAY_SIZE(commands
); i
++) {
402 struct cmd_struct
*p
= commands
+i
;
403 if (strcmp(p
->cmd
, cmd
))
405 exit(p
->fn(argc
, argv
, envp
));
409 int main(int argc
, const char **argv
, char **envp
)
411 const char *cmd
= argv
[0];
412 char *slash
= strrchr(cmd
, '/');
413 char git_command
[PATH_MAX
+ 1];
414 const char *exec_path
= NULL
;
417 * Take the basename of argv[0] as the command
418 * name, and the dirname as the default exec_path
419 * if it's an absolute path and we don't have
430 * "git-xxxx" is the same as "git xxxx", but we obviously:
432 * - cannot take flags in between the "git" and the "xxxx".
433 * - cannot execute it externally (since it would just do
434 * the same thing over again)
436 * So we just directly call the internal command handler, and
437 * die if that one cannot handle it.
439 if (!strncmp(cmd
, "git-", 4)) {
442 handle_internal_command(argc
, argv
, envp
);
443 die("cannot handle %s internally", cmd
);
446 /* Default command: "help" */
449 /* Look for flags.. */
454 if (strncmp(cmd
, "--", 2))
460 * For legacy reasons, the "version" and "help"
461 * commands can be written with "--" prepended
462 * to make them look like flags.
464 if (!strcmp(cmd
, "help"))
466 if (!strcmp(cmd
, "version"))
470 * Check remaining flags (which by now must be
471 * "--exec-path", but maybe we will accept
472 * other arguments some day)
474 if (!strncmp(cmd
, "exec-path", 9)) {
477 git_set_exec_path(cmd
+ 1);
480 puts(git_exec_path());
483 cmd_usage(0, NULL
, NULL
);
488 * We search for git commands in the following order:
490 * - the path of the "git" command if we could find it
492 * - the regular PATH.
495 prepend_to_path(exec_path
, strlen(exec_path
));
496 exec_path
= git_exec_path();
497 prepend_to_path(exec_path
, strlen(exec_path
));
499 /* See if it's an internal command */
500 handle_internal_command(argc
, argv
, envp
);
502 /* .. then try the external ones */
506 cmd_usage(0, exec_path
, "'%s' is not a git-command", cmd
);
508 fprintf(stderr
, "Failed to run command '%s': %s\n",
509 git_command
, strerror(errno
));