10 #include "run-command.h"
11 #include "argv-array.h"
14 #include "submodule.h"
20 static const char cut_line
[] =
21 "------------------------ >8 ------------------------\n";
23 static char default_wt_status_colors
[][COLOR_MAXLEN
] = {
24 GIT_COLOR_NORMAL
, /* WT_STATUS_HEADER */
25 GIT_COLOR_GREEN
, /* WT_STATUS_UPDATED */
26 GIT_COLOR_RED
, /* WT_STATUS_CHANGED */
27 GIT_COLOR_RED
, /* WT_STATUS_UNTRACKED */
28 GIT_COLOR_RED
, /* WT_STATUS_NOBRANCH */
29 GIT_COLOR_RED
, /* WT_STATUS_UNMERGED */
30 GIT_COLOR_GREEN
, /* WT_STATUS_LOCAL_BRANCH */
31 GIT_COLOR_RED
, /* WT_STATUS_REMOTE_BRANCH */
32 GIT_COLOR_NIL
, /* WT_STATUS_ONBRANCH */
35 static const char *color(int slot
, struct wt_status
*s
)
38 if (want_color(s
->use_color
))
39 c
= s
->color_palette
[slot
];
40 if (slot
== WT_STATUS_ONBRANCH
&& color_is_nil(c
))
41 c
= s
->color_palette
[WT_STATUS_HEADER
];
45 static void status_vprintf(struct wt_status
*s
, int at_bol
, const char *color
,
46 const char *fmt
, va_list ap
, const char *trail
)
48 struct strbuf sb
= STRBUF_INIT
;
49 struct strbuf linebuf
= STRBUF_INIT
;
50 const char *line
, *eol
;
52 strbuf_vaddf(&sb
, fmt
, ap
);
54 if (s
->display_comment_prefix
) {
55 strbuf_addch(&sb
, comment_line_char
);
57 strbuf_addch(&sb
, ' ');
59 color_print_strbuf(s
->fp
, color
, &sb
);
61 fprintf(s
->fp
, "%s", trail
);
65 for (line
= sb
.buf
; *line
; line
= eol
+ 1) {
66 eol
= strchr(line
, '\n');
68 strbuf_reset(&linebuf
);
69 if (at_bol
&& s
->display_comment_prefix
) {
70 strbuf_addch(&linebuf
, comment_line_char
);
71 if (*line
!= '\n' && *line
!= '\t')
72 strbuf_addch(&linebuf
, ' ');
75 strbuf_add(&linebuf
, line
, eol
- line
);
77 strbuf_addstr(&linebuf
, line
);
78 color_print_strbuf(s
->fp
, color
, &linebuf
);
86 fprintf(s
->fp
, "%s", trail
);
87 strbuf_release(&linebuf
);
91 void status_printf_ln(struct wt_status
*s
, const char *color
,
97 status_vprintf(s
, 1, color
, fmt
, ap
, "\n");
101 void status_printf(struct wt_status
*s
, const char *color
,
102 const char *fmt
, ...)
107 status_vprintf(s
, 1, color
, fmt
, ap
, NULL
);
111 static void status_printf_more(struct wt_status
*s
, const char *color
,
112 const char *fmt
, ...)
117 status_vprintf(s
, 0, color
, fmt
, ap
, NULL
);
121 void wt_status_prepare(struct wt_status
*s
)
123 unsigned char sha1
[20];
125 memset(s
, 0, sizeof(*s
));
126 memcpy(s
->color_palette
, default_wt_status_colors
,
127 sizeof(default_wt_status_colors
));
128 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
130 s
->relative_paths
= 1;
131 s
->branch
= resolve_refdup("HEAD", 0, sha1
, NULL
);
132 s
->reference
= "HEAD";
134 s
->index_file
= get_index_file();
135 s
->change
.strdup_strings
= 1;
136 s
->untracked
.strdup_strings
= 1;
137 s
->ignored
.strdup_strings
= 1;
138 s
->show_branch
= -1; /* unspecified */
139 s
->display_comment_prefix
= 0;
142 static void wt_status_print_unmerged_header(struct wt_status
*s
)
145 int del_mod_conflict
= 0;
146 int both_deleted
= 0;
148 const char *c
= color(WT_STATUS_HEADER
, s
);
150 status_printf_ln(s
, c
, _("Unmerged paths:"));
152 for (i
= 0; i
< s
->change
.nr
; i
++) {
153 struct string_list_item
*it
= &(s
->change
.items
[i
]);
154 struct wt_status_change_data
*d
= it
->util
;
156 switch (d
->stagemask
) {
164 del_mod_conflict
= 1;
174 if (s
->whence
!= FROM_COMMIT
)
176 else if (!s
->is_initial
)
177 status_printf_ln(s
, c
, _(" (use \"git reset %s <file>...\" to unstage)"), s
->reference
);
179 status_printf_ln(s
, c
, _(" (use \"git rm --cached <file>...\" to unstage)"));
182 if (!del_mod_conflict
)
183 status_printf_ln(s
, c
, _(" (use \"git add <file>...\" to mark resolution)"));
185 status_printf_ln(s
, c
, _(" (use \"git add/rm <file>...\" as appropriate to mark resolution)"));
186 } else if (!del_mod_conflict
&& !not_deleted
) {
187 status_printf_ln(s
, c
, _(" (use \"git rm <file>...\" to mark resolution)"));
189 status_printf_ln(s
, c
, _(" (use \"git add/rm <file>...\" as appropriate to mark resolution)"));
191 status_printf_ln(s
, c
, "%s", "");
194 static void wt_status_print_cached_header(struct wt_status
*s
)
196 const char *c
= color(WT_STATUS_HEADER
, s
);
198 status_printf_ln(s
, c
, _("Changes to be committed:"));
201 if (s
->whence
!= FROM_COMMIT
)
202 ; /* NEEDSWORK: use "git reset --unresolve"??? */
203 else if (!s
->is_initial
)
204 status_printf_ln(s
, c
, _(" (use \"git reset %s <file>...\" to unstage)"), s
->reference
);
206 status_printf_ln(s
, c
, _(" (use \"git rm --cached <file>...\" to unstage)"));
207 status_printf_ln(s
, c
, "%s", "");
210 static void wt_status_print_dirty_header(struct wt_status
*s
,
212 int has_dirty_submodules
)
214 const char *c
= color(WT_STATUS_HEADER
, s
);
216 status_printf_ln(s
, c
, _("Changes not staged for commit:"));
220 status_printf_ln(s
, c
, _(" (use \"git add <file>...\" to update what will be committed)"));
222 status_printf_ln(s
, c
, _(" (use \"git add/rm <file>...\" to update what will be committed)"));
223 status_printf_ln(s
, c
, _(" (use \"git checkout -- <file>...\" to discard changes in working directory)"));
224 if (has_dirty_submodules
)
225 status_printf_ln(s
, c
, _(" (commit or discard the untracked or modified content in submodules)"));
226 status_printf_ln(s
, c
, "%s", "");
229 static void wt_status_print_other_header(struct wt_status
*s
,
233 const char *c
= color(WT_STATUS_HEADER
, s
);
234 status_printf_ln(s
, c
, "%s:", what
);
237 status_printf_ln(s
, c
, _(" (use \"git %s <file>...\" to include in what will be committed)"), how
);
238 status_printf_ln(s
, c
, "%s", "");
241 static void wt_status_print_trailer(struct wt_status
*s
)
243 status_printf_ln(s
, color(WT_STATUS_HEADER
, s
), "%s", "");
246 #define quote_path quote_path_relative
248 static const char *wt_status_unmerged_status_string(int stagemask
)
252 return _("both deleted:");
254 return _("added by us:");
256 return _("deleted by them:");
258 return _("added by them:");
260 return _("deleted by us:");
262 return _("both added:");
264 return _("both modified:");
266 die(_("bug: unhandled unmerged status %x"), stagemask
);
270 static const char *wt_status_diff_status_string(int status
)
273 case DIFF_STATUS_ADDED
:
274 return _("new file:");
275 case DIFF_STATUS_COPIED
:
277 case DIFF_STATUS_DELETED
:
278 return _("deleted:");
279 case DIFF_STATUS_MODIFIED
:
280 return _("modified:");
281 case DIFF_STATUS_RENAMED
:
282 return _("renamed:");
283 case DIFF_STATUS_TYPE_CHANGED
:
284 return _("typechange:");
285 case DIFF_STATUS_UNKNOWN
:
286 return _("unknown:");
287 case DIFF_STATUS_UNMERGED
:
288 return _("unmerged:");
294 static int maxwidth(const char *(*label
)(int), int minval
, int maxval
)
298 for (i
= minval
; i
<= maxval
; i
++) {
299 const char *s
= label(i
);
300 int len
= s
? utf8_strwidth(s
) : 0;
307 static void wt_status_print_unmerged_data(struct wt_status
*s
,
308 struct string_list_item
*it
)
310 const char *c
= color(WT_STATUS_UNMERGED
, s
);
311 struct wt_status_change_data
*d
= it
->util
;
312 struct strbuf onebuf
= STRBUF_INIT
;
313 static char *padding
;
314 static int label_width
;
315 const char *one
, *how
;
319 label_width
= maxwidth(wt_status_unmerged_status_string
, 1, 7);
320 label_width
+= strlen(" ");
321 padding
= xmallocz(label_width
);
322 memset(padding
, ' ', label_width
);
325 one
= quote_path(it
->string
, s
->prefix
, &onebuf
);
326 status_printf(s
, color(WT_STATUS_HEADER
, s
), "\t");
328 how
= wt_status_unmerged_status_string(d
->stagemask
);
329 len
= label_width
- utf8_strwidth(how
);
330 status_printf_more(s
, c
, "%s%.*s%s\n", how
, len
, padding
, one
);
331 strbuf_release(&onebuf
);
334 static void wt_status_print_change_data(struct wt_status
*s
,
336 struct string_list_item
*it
)
338 struct wt_status_change_data
*d
= it
->util
;
339 const char *c
= color(change_type
, s
);
343 const char *one
, *two
;
344 struct strbuf onebuf
= STRBUF_INIT
, twobuf
= STRBUF_INIT
;
345 struct strbuf extra
= STRBUF_INIT
;
346 static char *padding
;
347 static int label_width
;
352 /* If DIFF_STATUS_* uses outside the range [A..Z], we're in trouble */
353 label_width
= maxwidth(wt_status_diff_status_string
, 'A', 'Z');
354 label_width
+= strlen(" ");
355 padding
= xmallocz(label_width
);
356 memset(padding
, ' ', label_width
);
359 one_name
= two_name
= it
->string
;
360 switch (change_type
) {
361 case WT_STATUS_UPDATED
:
362 status
= d
->index_status
;
364 one_name
= d
->head_path
;
366 case WT_STATUS_CHANGED
:
367 if (d
->new_submodule_commits
|| d
->dirty_submodule
) {
368 strbuf_addstr(&extra
, " (");
369 if (d
->new_submodule_commits
)
370 strbuf_addf(&extra
, _("new commits, "));
371 if (d
->dirty_submodule
& DIRTY_SUBMODULE_MODIFIED
)
372 strbuf_addf(&extra
, _("modified content, "));
373 if (d
->dirty_submodule
& DIRTY_SUBMODULE_UNTRACKED
)
374 strbuf_addf(&extra
, _("untracked content, "));
375 strbuf_setlen(&extra
, extra
.len
- 2);
376 strbuf_addch(&extra
, ')');
378 status
= d
->worktree_status
;
381 die("BUG: unhandled change_type %d in wt_status_print_change_data",
385 one
= quote_path(one_name
, s
->prefix
, &onebuf
);
386 two
= quote_path(two_name
, s
->prefix
, &twobuf
);
388 status_printf(s
, color(WT_STATUS_HEADER
, s
), "\t");
389 what
= wt_status_diff_status_string(status
);
391 die(_("bug: unhandled diff status %c"), status
);
392 len
= label_width
- utf8_strwidth(what
);
394 if (status
== DIFF_STATUS_COPIED
|| status
== DIFF_STATUS_RENAMED
)
395 status_printf_more(s
, c
, "%s%.*s%s -> %s",
396 what
, len
, padding
, one
, two
);
398 status_printf_more(s
, c
, "%s%.*s%s",
399 what
, len
, padding
, one
);
401 status_printf_more(s
, color(WT_STATUS_HEADER
, s
), "%s", extra
.buf
);
402 strbuf_release(&extra
);
404 status_printf_more(s
, GIT_COLOR_NORMAL
, "\n");
405 strbuf_release(&onebuf
);
406 strbuf_release(&twobuf
);
409 static void wt_status_collect_changed_cb(struct diff_queue_struct
*q
,
410 struct diff_options
*options
,
413 struct wt_status
*s
= data
;
418 s
->workdir_dirty
= 1;
419 for (i
= 0; i
< q
->nr
; i
++) {
420 struct diff_filepair
*p
;
421 struct string_list_item
*it
;
422 struct wt_status_change_data
*d
;
425 it
= string_list_insert(&s
->change
, p
->one
->path
);
428 d
= xcalloc(1, sizeof(*d
));
431 if (!d
->worktree_status
)
432 d
->worktree_status
= p
->status
;
433 d
->dirty_submodule
= p
->two
->dirty_submodule
;
434 if (S_ISGITLINK(p
->two
->mode
))
435 d
->new_submodule_commits
= !!oidcmp(&p
->one
->oid
,
440 static int unmerged_mask(const char *path
)
443 const struct cache_entry
*ce
;
445 pos
= cache_name_pos(path
, strlen(path
));
451 while (pos
< active_nr
) {
452 ce
= active_cache
[pos
++];
453 if (strcmp(ce
->name
, path
) || !ce_stage(ce
))
455 mask
|= (1 << (ce_stage(ce
) - 1));
460 static void wt_status_collect_updated_cb(struct diff_queue_struct
*q
,
461 struct diff_options
*options
,
464 struct wt_status
*s
= data
;
467 for (i
= 0; i
< q
->nr
; i
++) {
468 struct diff_filepair
*p
;
469 struct string_list_item
*it
;
470 struct wt_status_change_data
*d
;
473 it
= string_list_insert(&s
->change
, p
->two
->path
);
476 d
= xcalloc(1, sizeof(*d
));
479 if (!d
->index_status
)
480 d
->index_status
= p
->status
;
482 case DIFF_STATUS_COPIED
:
483 case DIFF_STATUS_RENAMED
:
484 d
->head_path
= xstrdup(p
->one
->path
);
486 case DIFF_STATUS_UNMERGED
:
487 d
->stagemask
= unmerged_mask(p
->two
->path
);
493 static void wt_status_collect_changes_worktree(struct wt_status
*s
)
497 init_revisions(&rev
, NULL
);
498 setup_revisions(0, NULL
, &rev
, NULL
);
499 rev
.diffopt
.output_format
|= DIFF_FORMAT_CALLBACK
;
500 DIFF_OPT_SET(&rev
.diffopt
, DIRTY_SUBMODULES
);
501 if (!s
->show_untracked_files
)
502 DIFF_OPT_SET(&rev
.diffopt
, IGNORE_UNTRACKED_IN_SUBMODULES
);
503 if (s
->ignore_submodule_arg
) {
504 DIFF_OPT_SET(&rev
.diffopt
, OVERRIDE_SUBMODULE_CONFIG
);
505 handle_ignore_submodules_arg(&rev
.diffopt
, s
->ignore_submodule_arg
);
507 rev
.diffopt
.format_callback
= wt_status_collect_changed_cb
;
508 rev
.diffopt
.format_callback_data
= s
;
509 copy_pathspec(&rev
.prune_data
, &s
->pathspec
);
510 run_diff_files(&rev
, 0);
513 static void wt_status_collect_changes_index(struct wt_status
*s
)
516 struct setup_revision_opt opt
;
518 init_revisions(&rev
, NULL
);
519 memset(&opt
, 0, sizeof(opt
));
520 opt
.def
= s
->is_initial
? EMPTY_TREE_SHA1_HEX
: s
->reference
;
521 setup_revisions(0, NULL
, &rev
, &opt
);
523 DIFF_OPT_SET(&rev
.diffopt
, OVERRIDE_SUBMODULE_CONFIG
);
524 if (s
->ignore_submodule_arg
) {
525 handle_ignore_submodules_arg(&rev
.diffopt
, s
->ignore_submodule_arg
);
528 * Unless the user did explicitly request a submodule ignore
529 * mode by passing a command line option we do not ignore any
530 * changed submodule SHA-1s when comparing index and HEAD, no
531 * matter what is configured. Otherwise the user won't be
532 * shown any submodules she manually added (and which are
533 * staged to be committed), which would be really confusing.
535 handle_ignore_submodules_arg(&rev
.diffopt
, "dirty");
538 rev
.diffopt
.output_format
|= DIFF_FORMAT_CALLBACK
;
539 rev
.diffopt
.format_callback
= wt_status_collect_updated_cb
;
540 rev
.diffopt
.format_callback_data
= s
;
541 rev
.diffopt
.detect_rename
= 1;
542 rev
.diffopt
.rename_limit
= 200;
543 rev
.diffopt
.break_opt
= 0;
544 copy_pathspec(&rev
.prune_data
, &s
->pathspec
);
545 run_diff_index(&rev
, 1);
548 static void wt_status_collect_changes_initial(struct wt_status
*s
)
552 for (i
= 0; i
< active_nr
; i
++) {
553 struct string_list_item
*it
;
554 struct wt_status_change_data
*d
;
555 const struct cache_entry
*ce
= active_cache
[i
];
557 if (!ce_path_match(ce
, &s
->pathspec
, NULL
))
559 it
= string_list_insert(&s
->change
, ce
->name
);
562 d
= xcalloc(1, sizeof(*d
));
566 d
->index_status
= DIFF_STATUS_UNMERGED
;
567 d
->stagemask
|= (1 << (ce_stage(ce
) - 1));
570 d
->index_status
= DIFF_STATUS_ADDED
;
574 static void wt_status_collect_untracked(struct wt_status
*s
)
577 struct dir_struct dir
;
578 uint64_t t_begin
= getnanotime();
580 if (!s
->show_untracked_files
)
583 memset(&dir
, 0, sizeof(dir
));
584 if (s
->show_untracked_files
!= SHOW_ALL_UNTRACKED_FILES
)
586 DIR_SHOW_OTHER_DIRECTORIES
| DIR_HIDE_EMPTY_DIRECTORIES
;
587 if (s
->show_ignored_files
)
588 dir
.flags
|= DIR_SHOW_IGNORED_TOO
;
590 dir
.untracked
= the_index
.untracked
;
591 setup_standard_excludes(&dir
);
593 fill_directory(&dir
, &s
->pathspec
);
595 for (i
= 0; i
< dir
.nr
; i
++) {
596 struct dir_entry
*ent
= dir
.entries
[i
];
597 if (cache_name_is_other(ent
->name
, ent
->len
) &&
598 dir_path_match(ent
, &s
->pathspec
, 0, NULL
))
599 string_list_insert(&s
->untracked
, ent
->name
);
603 for (i
= 0; i
< dir
.ignored_nr
; i
++) {
604 struct dir_entry
*ent
= dir
.ignored
[i
];
605 if (cache_name_is_other(ent
->name
, ent
->len
) &&
606 dir_path_match(ent
, &s
->pathspec
, 0, NULL
))
607 string_list_insert(&s
->ignored
, ent
->name
);
613 clear_directory(&dir
);
615 if (advice_status_u_option
)
616 s
->untracked_in_ms
= (getnanotime() - t_begin
) / 1000000;
619 void wt_status_collect(struct wt_status
*s
)
621 wt_status_collect_changes_worktree(s
);
624 wt_status_collect_changes_initial(s
);
626 wt_status_collect_changes_index(s
);
627 wt_status_collect_untracked(s
);
630 static void wt_status_print_unmerged(struct wt_status
*s
)
632 int shown_header
= 0;
635 for (i
= 0; i
< s
->change
.nr
; i
++) {
636 struct wt_status_change_data
*d
;
637 struct string_list_item
*it
;
638 it
= &(s
->change
.items
[i
]);
643 wt_status_print_unmerged_header(s
);
646 wt_status_print_unmerged_data(s
, it
);
649 wt_status_print_trailer(s
);
653 static void wt_status_print_updated(struct wt_status
*s
)
655 int shown_header
= 0;
658 for (i
= 0; i
< s
->change
.nr
; i
++) {
659 struct wt_status_change_data
*d
;
660 struct string_list_item
*it
;
661 it
= &(s
->change
.items
[i
]);
663 if (!d
->index_status
||
664 d
->index_status
== DIFF_STATUS_UNMERGED
)
667 wt_status_print_cached_header(s
);
671 wt_status_print_change_data(s
, WT_STATUS_UPDATED
, it
);
674 wt_status_print_trailer(s
);
680 * 1 : some change but no delete
682 static int wt_status_check_worktree_changes(struct wt_status
*s
,
683 int *dirty_submodules
)
688 *dirty_submodules
= 0;
690 for (i
= 0; i
< s
->change
.nr
; i
++) {
691 struct wt_status_change_data
*d
;
692 d
= s
->change
.items
[i
].util
;
693 if (!d
->worktree_status
||
694 d
->worktree_status
== DIFF_STATUS_UNMERGED
)
698 if (d
->dirty_submodule
)
699 *dirty_submodules
= 1;
700 if (d
->worktree_status
== DIFF_STATUS_DELETED
)
706 static void wt_status_print_changed(struct wt_status
*s
)
708 int i
, dirty_submodules
;
709 int worktree_changes
= wt_status_check_worktree_changes(s
, &dirty_submodules
);
711 if (!worktree_changes
)
714 wt_status_print_dirty_header(s
, worktree_changes
< 0, dirty_submodules
);
716 for (i
= 0; i
< s
->change
.nr
; i
++) {
717 struct wt_status_change_data
*d
;
718 struct string_list_item
*it
;
719 it
= &(s
->change
.items
[i
]);
721 if (!d
->worktree_status
||
722 d
->worktree_status
== DIFF_STATUS_UNMERGED
)
724 wt_status_print_change_data(s
, WT_STATUS_CHANGED
, it
);
726 wt_status_print_trailer(s
);
729 static void wt_status_print_submodule_summary(struct wt_status
*s
, int uncommitted
)
731 struct child_process sm_summary
= CHILD_PROCESS_INIT
;
732 struct strbuf cmd_stdout
= STRBUF_INIT
;
733 struct strbuf summary
= STRBUF_INIT
;
734 char *summary_content
;
736 argv_array_pushf(&sm_summary
.env_array
, "GIT_INDEX_FILE=%s",
739 argv_array_push(&sm_summary
.args
, "submodule");
740 argv_array_push(&sm_summary
.args
, "summary");
741 argv_array_push(&sm_summary
.args
, uncommitted
? "--files" : "--cached");
742 argv_array_push(&sm_summary
.args
, "--for-status");
743 argv_array_push(&sm_summary
.args
, "--summary-limit");
744 argv_array_pushf(&sm_summary
.args
, "%d", s
->submodule_summary
);
746 argv_array_push(&sm_summary
.args
, s
->amend
? "HEAD^" : "HEAD");
748 sm_summary
.git_cmd
= 1;
749 sm_summary
.no_stdin
= 1;
751 capture_command(&sm_summary
, &cmd_stdout
, 1024);
753 /* prepend header, only if there's an actual output */
754 if (cmd_stdout
.len
) {
756 strbuf_addstr(&summary
, _("Submodules changed but not updated:"));
758 strbuf_addstr(&summary
, _("Submodule changes to be committed:"));
759 strbuf_addstr(&summary
, "\n\n");
761 strbuf_addbuf(&summary
, &cmd_stdout
);
762 strbuf_release(&cmd_stdout
);
764 if (s
->display_comment_prefix
) {
766 summary_content
= strbuf_detach(&summary
, &len
);
767 strbuf_add_commented_lines(&summary
, summary_content
, len
);
768 free(summary_content
);
771 fputs(summary
.buf
, s
->fp
);
772 strbuf_release(&summary
);
775 static void wt_status_print_other(struct wt_status
*s
,
776 struct string_list
*l
,
781 struct strbuf buf
= STRBUF_INIT
;
782 static struct string_list output
= STRING_LIST_INIT_DUP
;
783 struct column_options copts
;
788 wt_status_print_other_header(s
, what
, how
);
790 for (i
= 0; i
< l
->nr
; i
++) {
791 struct string_list_item
*it
;
794 path
= quote_path(it
->string
, s
->prefix
, &buf
);
795 if (column_active(s
->colopts
)) {
796 string_list_append(&output
, path
);
799 status_printf(s
, color(WT_STATUS_HEADER
, s
), "\t");
800 status_printf_more(s
, color(WT_STATUS_UNTRACKED
, s
),
804 strbuf_release(&buf
);
805 if (!column_active(s
->colopts
))
808 strbuf_addf(&buf
, "%s%s\t%s",
809 color(WT_STATUS_HEADER
, s
),
810 s
->display_comment_prefix
? "#" : "",
811 color(WT_STATUS_UNTRACKED
, s
));
812 memset(&copts
, 0, sizeof(copts
));
814 copts
.indent
= buf
.buf
;
815 if (want_color(s
->use_color
))
816 copts
.nl
= GIT_COLOR_RESET
"\n";
817 print_columns(&output
, s
->colopts
, &copts
);
818 string_list_clear(&output
, 0);
819 strbuf_release(&buf
);
821 status_printf_ln(s
, GIT_COLOR_NORMAL
, "%s", "");
824 void wt_status_truncate_message_at_cut_line(struct strbuf
*buf
)
827 struct strbuf pattern
= STRBUF_INIT
;
829 strbuf_addf(&pattern
, "\n%c %s", comment_line_char
, cut_line
);
830 if (starts_with(buf
->buf
, pattern
.buf
+ 1))
831 strbuf_setlen(buf
, 0);
832 else if ((p
= strstr(buf
->buf
, pattern
.buf
)))
833 strbuf_setlen(buf
, p
- buf
->buf
+ 1);
834 strbuf_release(&pattern
);
837 void wt_status_add_cut_line(FILE *fp
)
839 const char *explanation
= _("Do not touch the line above.\nEverything below will be removed.");
840 struct strbuf buf
= STRBUF_INIT
;
842 fprintf(fp
, "%c %s", comment_line_char
, cut_line
);
843 strbuf_add_commented_lines(&buf
, explanation
, strlen(explanation
));
845 strbuf_release(&buf
);
848 static void wt_status_print_verbose(struct wt_status
*s
)
851 struct setup_revision_opt opt
;
852 int dirty_submodules
;
853 const char *c
= color(WT_STATUS_HEADER
, s
);
855 init_revisions(&rev
, NULL
);
856 DIFF_OPT_SET(&rev
.diffopt
, ALLOW_TEXTCONV
);
858 memset(&opt
, 0, sizeof(opt
));
859 opt
.def
= s
->is_initial
? EMPTY_TREE_SHA1_HEX
: s
->reference
;
860 setup_revisions(0, NULL
, &rev
, &opt
);
862 rev
.diffopt
.output_format
|= DIFF_FORMAT_PATCH
;
863 rev
.diffopt
.detect_rename
= 1;
864 rev
.diffopt
.file
= s
->fp
;
865 rev
.diffopt
.close_file
= 0;
867 * If we're not going to stdout, then we definitely don't
868 * want color, since we are going to the commit message
869 * file (and even the "auto" setting won't work, since it
870 * will have checked isatty on stdout). But we then do want
871 * to insert the scissor line here to reliably remove the
872 * diff before committing.
874 if (s
->fp
!= stdout
) {
875 rev
.diffopt
.use_color
= 0;
876 wt_status_add_cut_line(s
->fp
);
878 if (s
->verbose
> 1 && s
->commitable
) {
879 /* print_updated() printed a header, so do we */
881 wt_status_print_trailer(s
);
882 status_printf_ln(s
, c
, _("Changes to be committed:"));
883 rev
.diffopt
.a_prefix
= "c/";
884 rev
.diffopt
.b_prefix
= "i/";
885 } /* else use prefix as per user config */
886 run_diff_index(&rev
, 1);
887 if (s
->verbose
> 1 &&
888 wt_status_check_worktree_changes(s
, &dirty_submodules
)) {
889 status_printf_ln(s
, c
,
890 "--------------------------------------------------");
891 status_printf_ln(s
, c
, _("Changes not staged for commit:"));
893 rev
.diffopt
.a_prefix
= "i/";
894 rev
.diffopt
.b_prefix
= "w/";
895 run_diff_files(&rev
, 0);
899 static void wt_status_print_tracking(struct wt_status
*s
)
901 struct strbuf sb
= STRBUF_INIT
;
902 const char *cp
, *ep
, *branch_name
;
903 struct branch
*branch
;
904 char comment_line_string
[3];
907 assert(s
->branch
&& !s
->is_initial
);
908 if (!skip_prefix(s
->branch
, "refs/heads/", &branch_name
))
910 branch
= branch_get(branch_name
);
911 if (!format_tracking_info(branch
, &sb
))
915 if (s
->display_comment_prefix
) {
916 comment_line_string
[i
++] = comment_line_char
;
917 comment_line_string
[i
++] = ' ';
919 comment_line_string
[i
] = '\0';
921 for (cp
= sb
.buf
; (ep
= strchr(cp
, '\n')) != NULL
; cp
= ep
+ 1)
922 color_fprintf_ln(s
->fp
, color(WT_STATUS_HEADER
, s
),
923 "%s%.*s", comment_line_string
,
925 if (s
->display_comment_prefix
)
926 color_fprintf_ln(s
->fp
, color(WT_STATUS_HEADER
, s
), "%c",
932 static int has_unmerged(struct wt_status
*s
)
936 for (i
= 0; i
< s
->change
.nr
; i
++) {
937 struct wt_status_change_data
*d
;
938 d
= s
->change
.items
[i
].util
;
945 static void show_merge_in_progress(struct wt_status
*s
,
946 struct wt_status_state
*state
,
949 if (has_unmerged(s
)) {
950 status_printf_ln(s
, color
, _("You have unmerged paths."));
952 status_printf_ln(s
, color
,
953 _(" (fix conflicts and run \"git commit\")"));
956 status_printf_ln(s
, color
,
957 _("All conflicts fixed but you are still merging."));
959 status_printf_ln(s
, color
,
960 _(" (use \"git commit\" to conclude merge)"));
962 wt_status_print_trailer(s
);
965 static void show_am_in_progress(struct wt_status
*s
,
966 struct wt_status_state
*state
,
969 status_printf_ln(s
, color
,
970 _("You are in the middle of an am session."));
971 if (state
->am_empty_patch
)
972 status_printf_ln(s
, color
,
973 _("The current patch is empty."));
975 if (!state
->am_empty_patch
)
976 status_printf_ln(s
, color
,
977 _(" (fix conflicts and then run \"git am --continue\")"));
978 status_printf_ln(s
, color
,
979 _(" (use \"git am --skip\" to skip this patch)"));
980 status_printf_ln(s
, color
,
981 _(" (use \"git am --abort\" to restore the original branch)"));
983 wt_status_print_trailer(s
);
986 static char *read_line_from_git_path(const char *filename
)
988 struct strbuf buf
= STRBUF_INIT
;
989 FILE *fp
= fopen(git_path("%s", filename
), "r");
991 strbuf_release(&buf
);
994 strbuf_getline_lf(&buf
, fp
);
996 return strbuf_detach(&buf
, NULL
);
998 strbuf_release(&buf
);
1003 static int split_commit_in_progress(struct wt_status
*s
)
1005 int split_in_progress
= 0;
1006 char *head
= read_line_from_git_path("HEAD");
1007 char *orig_head
= read_line_from_git_path("ORIG_HEAD");
1008 char *rebase_amend
= read_line_from_git_path("rebase-merge/amend");
1009 char *rebase_orig_head
= read_line_from_git_path("rebase-merge/orig-head");
1011 if (!head
|| !orig_head
|| !rebase_amend
|| !rebase_orig_head
||
1012 !s
->branch
|| strcmp(s
->branch
, "HEAD"))
1013 return split_in_progress
;
1015 if (!strcmp(rebase_amend
, rebase_orig_head
)) {
1016 if (strcmp(head
, rebase_amend
))
1017 split_in_progress
= 1;
1018 } else if (strcmp(orig_head
, rebase_orig_head
)) {
1019 split_in_progress
= 1;
1022 if (!s
->amend
&& !s
->nowarn
&& !s
->workdir_dirty
)
1023 split_in_progress
= 0;
1028 free(rebase_orig_head
);
1029 return split_in_progress
;
1034 * "pick d6a2f0303e897ec257dd0e0a39a5ccb709bc2047 some message"
1036 * "pick d6a2f03 some message"
1038 * The function assumes that the line does not contain useless spaces
1039 * before or after the command.
1041 static void abbrev_sha1_in_line(struct strbuf
*line
)
1043 struct strbuf
**split
;
1046 if (starts_with(line
->buf
, "exec ") ||
1047 starts_with(line
->buf
, "x "))
1050 split
= strbuf_split_max(line
, ' ', 3);
1051 if (split
[0] && split
[1]) {
1052 unsigned char sha1
[20];
1056 * strbuf_split_max left a space. Trim it and re-add
1057 * it after abbreviation.
1059 strbuf_trim(split
[1]);
1060 if (!get_sha1(split
[1]->buf
, sha1
)) {
1061 abbrev
= find_unique_abbrev(sha1
, DEFAULT_ABBREV
);
1062 strbuf_reset(split
[1]);
1063 strbuf_addf(split
[1], "%s ", abbrev
);
1065 for (i
= 0; split
[i
]; i
++)
1066 strbuf_addf(line
, "%s", split
[i
]->buf
);
1069 strbuf_list_free(split
);
1072 static void read_rebase_todolist(const char *fname
, struct string_list
*lines
)
1074 struct strbuf line
= STRBUF_INIT
;
1075 FILE *f
= fopen(git_path("%s", fname
), "r");
1078 die_errno("Could not open file %s for reading",
1079 git_path("%s", fname
));
1080 while (!strbuf_getline_lf(&line
, f
)) {
1081 if (line
.len
&& line
.buf
[0] == comment_line_char
)
1086 abbrev_sha1_in_line(&line
);
1087 string_list_append(lines
, line
.buf
);
1091 static void show_rebase_information(struct wt_status
*s
,
1092 struct wt_status_state
*state
,
1095 if (state
->rebase_interactive_in_progress
) {
1097 int nr_lines_to_show
= 2;
1099 struct string_list have_done
= STRING_LIST_INIT_DUP
;
1100 struct string_list yet_to_do
= STRING_LIST_INIT_DUP
;
1102 read_rebase_todolist("rebase-merge/done", &have_done
);
1103 read_rebase_todolist("rebase-merge/git-rebase-todo", &yet_to_do
);
1105 if (have_done
.nr
== 0)
1106 status_printf_ln(s
, color
, _("No commands done."));
1108 status_printf_ln(s
, color
,
1109 Q_("Last command done (%d command done):",
1110 "Last commands done (%d commands done):",
1113 for (i
= (have_done
.nr
> nr_lines_to_show
)
1114 ? have_done
.nr
- nr_lines_to_show
: 0;
1117 status_printf_ln(s
, color
, " %s", have_done
.items
[i
].string
);
1118 if (have_done
.nr
> nr_lines_to_show
&& s
->hints
)
1119 status_printf_ln(s
, color
,
1120 _(" (see more in file %s)"), git_path("rebase-merge/done"));
1123 if (yet_to_do
.nr
== 0)
1124 status_printf_ln(s
, color
,
1125 _("No commands remaining."));
1127 status_printf_ln(s
, color
,
1128 Q_("Next command to do (%d remaining command):",
1129 "Next commands to do (%d remaining commands):",
1132 for (i
= 0; i
< nr_lines_to_show
&& i
< yet_to_do
.nr
; i
++)
1133 status_printf_ln(s
, color
, " %s", yet_to_do
.items
[i
].string
);
1135 status_printf_ln(s
, color
,
1136 _(" (use \"git rebase --edit-todo\" to view and edit)"));
1138 string_list_clear(&yet_to_do
, 0);
1139 string_list_clear(&have_done
, 0);
1143 static void print_rebase_state(struct wt_status
*s
,
1144 struct wt_status_state
*state
,
1148 status_printf_ln(s
, color
,
1149 _("You are currently rebasing branch '%s' on '%s'."),
1153 status_printf_ln(s
, color
,
1154 _("You are currently rebasing."));
1157 static void show_rebase_in_progress(struct wt_status
*s
,
1158 struct wt_status_state
*state
,
1163 show_rebase_information(s
, state
, color
);
1164 if (has_unmerged(s
)) {
1165 print_rebase_state(s
, state
, color
);
1167 status_printf_ln(s
, color
,
1168 _(" (fix conflicts and then run \"git rebase --continue\")"));
1169 status_printf_ln(s
, color
,
1170 _(" (use \"git rebase --skip\" to skip this patch)"));
1171 status_printf_ln(s
, color
,
1172 _(" (use \"git rebase --abort\" to check out the original branch)"));
1174 } else if (state
->rebase_in_progress
|| !stat(git_path_merge_msg(), &st
)) {
1175 print_rebase_state(s
, state
, color
);
1177 status_printf_ln(s
, color
,
1178 _(" (all conflicts fixed: run \"git rebase --continue\")"));
1179 } else if (split_commit_in_progress(s
)) {
1181 status_printf_ln(s
, color
,
1182 _("You are currently splitting a commit while rebasing branch '%s' on '%s'."),
1186 status_printf_ln(s
, color
,
1187 _("You are currently splitting a commit during a rebase."));
1189 status_printf_ln(s
, color
,
1190 _(" (Once your working directory is clean, run \"git rebase --continue\")"));
1193 status_printf_ln(s
, color
,
1194 _("You are currently editing a commit while rebasing branch '%s' on '%s'."),
1198 status_printf_ln(s
, color
,
1199 _("You are currently editing a commit during a rebase."));
1200 if (s
->hints
&& !s
->amend
) {
1201 status_printf_ln(s
, color
,
1202 _(" (use \"git commit --amend\" to amend the current commit)"));
1203 status_printf_ln(s
, color
,
1204 _(" (use \"git rebase --continue\" once you are satisfied with your changes)"));
1207 wt_status_print_trailer(s
);
1210 static void show_cherry_pick_in_progress(struct wt_status
*s
,
1211 struct wt_status_state
*state
,
1214 status_printf_ln(s
, color
, _("You are currently cherry-picking commit %s."),
1215 find_unique_abbrev(state
->cherry_pick_head_sha1
, DEFAULT_ABBREV
));
1217 if (has_unmerged(s
))
1218 status_printf_ln(s
, color
,
1219 _(" (fix conflicts and run \"git cherry-pick --continue\")"));
1221 status_printf_ln(s
, color
,
1222 _(" (all conflicts fixed: run \"git cherry-pick --continue\")"));
1223 status_printf_ln(s
, color
,
1224 _(" (use \"git cherry-pick --abort\" to cancel the cherry-pick operation)"));
1226 wt_status_print_trailer(s
);
1229 static void show_revert_in_progress(struct wt_status
*s
,
1230 struct wt_status_state
*state
,
1233 status_printf_ln(s
, color
, _("You are currently reverting commit %s."),
1234 find_unique_abbrev(state
->revert_head_sha1
, DEFAULT_ABBREV
));
1236 if (has_unmerged(s
))
1237 status_printf_ln(s
, color
,
1238 _(" (fix conflicts and run \"git revert --continue\")"));
1240 status_printf_ln(s
, color
,
1241 _(" (all conflicts fixed: run \"git revert --continue\")"));
1242 status_printf_ln(s
, color
,
1243 _(" (use \"git revert --abort\" to cancel the revert operation)"));
1245 wt_status_print_trailer(s
);
1248 static void show_bisect_in_progress(struct wt_status
*s
,
1249 struct wt_status_state
*state
,
1253 status_printf_ln(s
, color
,
1254 _("You are currently bisecting, started from branch '%s'."),
1257 status_printf_ln(s
, color
,
1258 _("You are currently bisecting."));
1260 status_printf_ln(s
, color
,
1261 _(" (use \"git bisect reset\" to get back to the original branch)"));
1262 wt_status_print_trailer(s
);
1266 * Extract branch information from rebase/bisect
1268 static char *get_branch(const struct worktree
*wt
, const char *path
)
1270 struct strbuf sb
= STRBUF_INIT
;
1271 unsigned char sha1
[20];
1272 const char *branch_name
;
1274 if (strbuf_read_file(&sb
, worktree_git_path(wt
, "%s", path
), 0) <= 0)
1277 while (sb
.len
&& sb
.buf
[sb
.len
- 1] == '\n')
1278 strbuf_setlen(&sb
, sb
.len
- 1);
1281 if (skip_prefix(sb
.buf
, "refs/heads/", &branch_name
))
1282 strbuf_remove(&sb
, 0, branch_name
- sb
.buf
);
1283 else if (starts_with(sb
.buf
, "refs/"))
1285 else if (!get_sha1_hex(sb
.buf
, sha1
)) {
1287 abbrev
= find_unique_abbrev(sha1
, DEFAULT_ABBREV
);
1289 strbuf_addstr(&sb
, abbrev
);
1290 } else if (!strcmp(sb
.buf
, "detached HEAD")) /* rebase */
1294 return strbuf_detach(&sb
, NULL
);
1297 strbuf_release(&sb
);
1301 struct grab_1st_switch_cbdata
{
1303 unsigned char nsha1
[20];
1306 static int grab_1st_switch(unsigned char *osha1
, unsigned char *nsha1
,
1307 const char *email
, unsigned long timestamp
, int tz
,
1308 const char *message
, void *cb_data
)
1310 struct grab_1st_switch_cbdata
*cb
= cb_data
;
1311 const char *target
= NULL
, *end
;
1313 if (!skip_prefix(message
, "checkout: moving from ", &message
))
1315 target
= strstr(message
, " to ");
1318 target
+= strlen(" to ");
1319 strbuf_reset(&cb
->buf
);
1320 hashcpy(cb
->nsha1
, nsha1
);
1321 end
= strchrnul(target
, '\n');
1322 strbuf_add(&cb
->buf
, target
, end
- target
);
1323 if (!strcmp(cb
->buf
.buf
, "HEAD")) {
1324 /* HEAD is relative. Resolve it to the right reflog entry. */
1325 strbuf_reset(&cb
->buf
);
1326 strbuf_addstr(&cb
->buf
,
1327 find_unique_abbrev(nsha1
, DEFAULT_ABBREV
));
1332 static void wt_status_get_detached_from(struct wt_status_state
*state
)
1334 struct grab_1st_switch_cbdata cb
;
1335 struct commit
*commit
;
1336 unsigned char sha1
[20];
1339 strbuf_init(&cb
.buf
, 0);
1340 if (for_each_reflog_ent_reverse("HEAD", grab_1st_switch
, &cb
) <= 0) {
1341 strbuf_release(&cb
.buf
);
1345 if (dwim_ref(cb
.buf
.buf
, cb
.buf
.len
, sha1
, &ref
) == 1 &&
1346 /* sha1 is a commit? match without further lookup */
1347 (!hashcmp(cb
.nsha1
, sha1
) ||
1348 /* perhaps sha1 is a tag, try to dereference to a commit */
1349 ((commit
= lookup_commit_reference_gently(sha1
, 1)) != NULL
&&
1350 !hashcmp(cb
.nsha1
, commit
->object
.oid
.hash
)))) {
1351 const char *from
= ref
;
1352 if (!skip_prefix(from
, "refs/tags/", &from
))
1353 skip_prefix(from
, "refs/remotes/", &from
);
1354 state
->detached_from
= xstrdup(from
);
1356 state
->detached_from
=
1357 xstrdup(find_unique_abbrev(cb
.nsha1
, DEFAULT_ABBREV
));
1358 hashcpy(state
->detached_sha1
, cb
.nsha1
);
1359 state
->detached_at
= !get_sha1("HEAD", sha1
) &&
1360 !hashcmp(sha1
, state
->detached_sha1
);
1363 strbuf_release(&cb
.buf
);
1366 int wt_status_check_rebase(const struct worktree
*wt
,
1367 struct wt_status_state
*state
)
1371 if (!stat(worktree_git_path(wt
, "rebase-apply"), &st
)) {
1372 if (!stat(worktree_git_path(wt
, "rebase-apply/applying"), &st
)) {
1373 state
->am_in_progress
= 1;
1374 if (!stat(worktree_git_path(wt
, "rebase-apply/patch"), &st
) && !st
.st_size
)
1375 state
->am_empty_patch
= 1;
1377 state
->rebase_in_progress
= 1;
1378 state
->branch
= get_branch(wt
, "rebase-apply/head-name");
1379 state
->onto
= get_branch(wt
, "rebase-apply/onto");
1381 } else if (!stat(worktree_git_path(wt
, "rebase-merge"), &st
)) {
1382 if (!stat(worktree_git_path(wt
, "rebase-merge/interactive"), &st
))
1383 state
->rebase_interactive_in_progress
= 1;
1385 state
->rebase_in_progress
= 1;
1386 state
->branch
= get_branch(wt
, "rebase-merge/head-name");
1387 state
->onto
= get_branch(wt
, "rebase-merge/onto");
1393 int wt_status_check_bisect(const struct worktree
*wt
,
1394 struct wt_status_state
*state
)
1398 if (!stat(worktree_git_path(wt
, "BISECT_LOG"), &st
)) {
1399 state
->bisect_in_progress
= 1;
1400 state
->branch
= get_branch(wt
, "BISECT_START");
1406 void wt_status_get_state(struct wt_status_state
*state
,
1407 int get_detached_from
)
1410 unsigned char sha1
[20];
1412 if (!stat(git_path_merge_head(), &st
)) {
1413 state
->merge_in_progress
= 1;
1414 } else if (wt_status_check_rebase(NULL
, state
)) {
1416 } else if (!stat(git_path_cherry_pick_head(), &st
) &&
1417 !get_sha1("CHERRY_PICK_HEAD", sha1
)) {
1418 state
->cherry_pick_in_progress
= 1;
1419 hashcpy(state
->cherry_pick_head_sha1
, sha1
);
1421 wt_status_check_bisect(NULL
, state
);
1422 if (!stat(git_path_revert_head(), &st
) &&
1423 !get_sha1("REVERT_HEAD", sha1
)) {
1424 state
->revert_in_progress
= 1;
1425 hashcpy(state
->revert_head_sha1
, sha1
);
1428 if (get_detached_from
)
1429 wt_status_get_detached_from(state
);
1432 static void wt_status_print_state(struct wt_status
*s
,
1433 struct wt_status_state
*state
)
1435 const char *state_color
= color(WT_STATUS_HEADER
, s
);
1436 if (state
->merge_in_progress
)
1437 show_merge_in_progress(s
, state
, state_color
);
1438 else if (state
->am_in_progress
)
1439 show_am_in_progress(s
, state
, state_color
);
1440 else if (state
->rebase_in_progress
|| state
->rebase_interactive_in_progress
)
1441 show_rebase_in_progress(s
, state
, state_color
);
1442 else if (state
->cherry_pick_in_progress
)
1443 show_cherry_pick_in_progress(s
, state
, state_color
);
1444 else if (state
->revert_in_progress
)
1445 show_revert_in_progress(s
, state
, state_color
);
1446 if (state
->bisect_in_progress
)
1447 show_bisect_in_progress(s
, state
, state_color
);
1450 void wt_status_print(struct wt_status
*s
)
1452 const char *branch_color
= color(WT_STATUS_ONBRANCH
, s
);
1453 const char *branch_status_color
= color(WT_STATUS_HEADER
, s
);
1454 struct wt_status_state state
;
1456 memset(&state
, 0, sizeof(state
));
1457 wt_status_get_state(&state
,
1458 s
->branch
&& !strcmp(s
->branch
, "HEAD"));
1461 const char *on_what
= _("On branch ");
1462 const char *branch_name
= s
->branch
;
1463 if (!strcmp(branch_name
, "HEAD")) {
1464 branch_status_color
= color(WT_STATUS_NOBRANCH
, s
);
1465 if (state
.rebase_in_progress
|| state
.rebase_interactive_in_progress
) {
1466 if (state
.rebase_interactive_in_progress
)
1467 on_what
= _("interactive rebase in progress; onto ");
1469 on_what
= _("rebase in progress; onto ");
1470 branch_name
= state
.onto
;
1471 } else if (state
.detached_from
) {
1472 branch_name
= state
.detached_from
;
1473 if (state
.detached_at
)
1474 on_what
= _("HEAD detached at ");
1476 on_what
= _("HEAD detached from ");
1479 on_what
= _("Not currently on any branch.");
1482 skip_prefix(branch_name
, "refs/heads/", &branch_name
);
1483 status_printf(s
, color(WT_STATUS_HEADER
, s
), "%s", "");
1484 status_printf_more(s
, branch_status_color
, "%s", on_what
);
1485 status_printf_more(s
, branch_color
, "%s\n", branch_name
);
1487 wt_status_print_tracking(s
);
1490 wt_status_print_state(s
, &state
);
1493 free(state
.detached_from
);
1495 if (s
->is_initial
) {
1496 status_printf_ln(s
, color(WT_STATUS_HEADER
, s
), "%s", "");
1497 status_printf_ln(s
, color(WT_STATUS_HEADER
, s
), _("Initial commit"));
1498 status_printf_ln(s
, color(WT_STATUS_HEADER
, s
), "%s", "");
1501 wt_status_print_updated(s
);
1502 wt_status_print_unmerged(s
);
1503 wt_status_print_changed(s
);
1504 if (s
->submodule_summary
&&
1505 (!s
->ignore_submodule_arg
||
1506 strcmp(s
->ignore_submodule_arg
, "all"))) {
1507 wt_status_print_submodule_summary(s
, 0); /* staged */
1508 wt_status_print_submodule_summary(s
, 1); /* unstaged */
1510 if (s
->show_untracked_files
) {
1511 wt_status_print_other(s
, &s
->untracked
, _("Untracked files"), "add");
1512 if (s
->show_ignored_files
)
1513 wt_status_print_other(s
, &s
->ignored
, _("Ignored files"), "add -f");
1514 if (advice_status_u_option
&& 2000 < s
->untracked_in_ms
) {
1515 status_printf_ln(s
, GIT_COLOR_NORMAL
, "%s", "");
1516 status_printf_ln(s
, GIT_COLOR_NORMAL
,
1517 _("It took %.2f seconds to enumerate untracked files. 'status -uno'\n"
1518 "may speed it up, but you have to be careful not to forget to add\n"
1519 "new files yourself (see 'git help status')."),
1520 s
->untracked_in_ms
/ 1000.0);
1522 } else if (s
->commitable
)
1523 status_printf_ln(s
, GIT_COLOR_NORMAL
, _("Untracked files not listed%s"),
1525 ? _(" (use -u option to show untracked files)") : "");
1528 wt_status_print_verbose(s
);
1529 if (!s
->commitable
) {
1531 status_printf_ln(s
, GIT_COLOR_NORMAL
, _("No changes"));
1534 else if (s
->workdir_dirty
) {
1536 printf(_("no changes added to commit "
1537 "(use \"git add\" and/or \"git commit -a\")\n"));
1539 printf(_("no changes added to commit\n"));
1540 } else if (s
->untracked
.nr
) {
1542 printf(_("nothing added to commit but untracked files "
1543 "present (use \"git add\" to track)\n"));
1545 printf(_("nothing added to commit but untracked files present\n"));
1546 } else if (s
->is_initial
) {
1548 printf(_("nothing to commit (create/copy files "
1549 "and use \"git add\" to track)\n"));
1551 printf(_("nothing to commit\n"));
1552 } else if (!s
->show_untracked_files
) {
1554 printf(_("nothing to commit (use -u to show untracked files)\n"));
1556 printf(_("nothing to commit\n"));
1558 printf(_("nothing to commit, working directory clean\n"));
1562 static void wt_shortstatus_unmerged(struct string_list_item
*it
,
1563 struct wt_status
*s
)
1565 struct wt_status_change_data
*d
= it
->util
;
1566 const char *how
= "??";
1568 switch (d
->stagemask
) {
1569 case 1: how
= "DD"; break; /* both deleted */
1570 case 2: how
= "AU"; break; /* added by us */
1571 case 3: how
= "UD"; break; /* deleted by them */
1572 case 4: how
= "UA"; break; /* added by them */
1573 case 5: how
= "DU"; break; /* deleted by us */
1574 case 6: how
= "AA"; break; /* both added */
1575 case 7: how
= "UU"; break; /* both modified */
1577 color_fprintf(s
->fp
, color(WT_STATUS_UNMERGED
, s
), "%s", how
);
1578 if (s
->null_termination
) {
1579 fprintf(stdout
, " %s%c", it
->string
, 0);
1581 struct strbuf onebuf
= STRBUF_INIT
;
1583 one
= quote_path(it
->string
, s
->prefix
, &onebuf
);
1584 printf(" %s\n", one
);
1585 strbuf_release(&onebuf
);
1589 static void wt_shortstatus_status(struct string_list_item
*it
,
1590 struct wt_status
*s
)
1592 struct wt_status_change_data
*d
= it
->util
;
1594 if (d
->index_status
)
1595 color_fprintf(s
->fp
, color(WT_STATUS_UPDATED
, s
), "%c", d
->index_status
);
1598 if (d
->worktree_status
)
1599 color_fprintf(s
->fp
, color(WT_STATUS_CHANGED
, s
), "%c", d
->worktree_status
);
1603 if (s
->null_termination
) {
1604 fprintf(stdout
, "%s%c", it
->string
, 0);
1606 fprintf(stdout
, "%s%c", d
->head_path
, 0);
1608 struct strbuf onebuf
= STRBUF_INIT
;
1611 one
= quote_path(d
->head_path
, s
->prefix
, &onebuf
);
1612 if (*one
!= '"' && strchr(one
, ' ') != NULL
) {
1614 strbuf_addch(&onebuf
, '"');
1617 printf("%s -> ", one
);
1618 strbuf_release(&onebuf
);
1620 one
= quote_path(it
->string
, s
->prefix
, &onebuf
);
1621 if (*one
!= '"' && strchr(one
, ' ') != NULL
) {
1623 strbuf_addch(&onebuf
, '"');
1626 printf("%s\n", one
);
1627 strbuf_release(&onebuf
);
1631 static void wt_shortstatus_other(struct string_list_item
*it
,
1632 struct wt_status
*s
, const char *sign
)
1634 if (s
->null_termination
) {
1635 fprintf(stdout
, "%s %s%c", sign
, it
->string
, 0);
1637 struct strbuf onebuf
= STRBUF_INIT
;
1639 one
= quote_path(it
->string
, s
->prefix
, &onebuf
);
1640 color_fprintf(s
->fp
, color(WT_STATUS_UNTRACKED
, s
), "%s", sign
);
1641 printf(" %s\n", one
);
1642 strbuf_release(&onebuf
);
1646 static void wt_shortstatus_print_tracking(struct wt_status
*s
)
1648 struct branch
*branch
;
1649 const char *header_color
= color(WT_STATUS_HEADER
, s
);
1650 const char *branch_color_local
= color(WT_STATUS_LOCAL_BRANCH
, s
);
1651 const char *branch_color_remote
= color(WT_STATUS_REMOTE_BRANCH
, s
);
1654 const char *branch_name
;
1655 int num_ours
, num_theirs
;
1656 int upstream_is_gone
= 0;
1658 color_fprintf(s
->fp
, color(WT_STATUS_HEADER
, s
), "## ");
1662 branch_name
= s
->branch
;
1665 color_fprintf(s
->fp
, header_color
, _("Initial commit on "));
1667 if (!strcmp(s
->branch
, "HEAD")) {
1668 color_fprintf(s
->fp
, color(WT_STATUS_NOBRANCH
, s
), "%s",
1669 _("HEAD (no branch)"));
1673 skip_prefix(branch_name
, "refs/heads/", &branch_name
);
1675 branch
= branch_get(branch_name
);
1677 color_fprintf(s
->fp
, branch_color_local
, "%s", branch_name
);
1679 if (stat_tracking_info(branch
, &num_ours
, &num_theirs
, &base
) < 0) {
1683 upstream_is_gone
= 1;
1686 base
= shorten_unambiguous_ref(base
, 0);
1687 color_fprintf(s
->fp
, header_color
, "...");
1688 color_fprintf(s
->fp
, branch_color_remote
, "%s", base
);
1691 if (!upstream_is_gone
&& !num_ours
&& !num_theirs
)
1694 #define LABEL(string) (s->no_gettext ? (string) : _(string))
1696 color_fprintf(s
->fp
, header_color
, " [");
1697 if (upstream_is_gone
) {
1698 color_fprintf(s
->fp
, header_color
, LABEL(N_("gone")));
1699 } else if (!num_ours
) {
1700 color_fprintf(s
->fp
, header_color
, LABEL(N_("behind ")));
1701 color_fprintf(s
->fp
, branch_color_remote
, "%d", num_theirs
);
1702 } else if (!num_theirs
) {
1703 color_fprintf(s
->fp
, header_color
, LABEL(N_("ahead ")));
1704 color_fprintf(s
->fp
, branch_color_local
, "%d", num_ours
);
1706 color_fprintf(s
->fp
, header_color
, LABEL(N_("ahead ")));
1707 color_fprintf(s
->fp
, branch_color_local
, "%d", num_ours
);
1708 color_fprintf(s
->fp
, header_color
, ", %s", LABEL(N_("behind ")));
1709 color_fprintf(s
->fp
, branch_color_remote
, "%d", num_theirs
);
1712 color_fprintf(s
->fp
, header_color
, "]");
1714 fputc(s
->null_termination
? '\0' : '\n', s
->fp
);
1717 void wt_shortstatus_print(struct wt_status
*s
)
1722 wt_shortstatus_print_tracking(s
);
1724 for (i
= 0; i
< s
->change
.nr
; i
++) {
1725 struct wt_status_change_data
*d
;
1726 struct string_list_item
*it
;
1728 it
= &(s
->change
.items
[i
]);
1731 wt_shortstatus_unmerged(it
, s
);
1733 wt_shortstatus_status(it
, s
);
1735 for (i
= 0; i
< s
->untracked
.nr
; i
++) {
1736 struct string_list_item
*it
;
1738 it
= &(s
->untracked
.items
[i
]);
1739 wt_shortstatus_other(it
, s
, "??");
1741 for (i
= 0; i
< s
->ignored
.nr
; i
++) {
1742 struct string_list_item
*it
;
1744 it
= &(s
->ignored
.items
[i
]);
1745 wt_shortstatus_other(it
, s
, "!!");
1749 void wt_porcelain_print(struct wt_status
*s
)
1752 s
->relative_paths
= 0;
1755 wt_shortstatus_print(s
);