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_addstr(&extra
, _("new commits, "));
371 if (d
->dirty_submodule
& DIRTY_SUBMODULE_MODIFIED
)
372 strbuf_addstr(&extra
, _("modified content, "));
373 if (d
->dirty_submodule
& DIRTY_SUBMODULE_UNTRACKED
)
374 strbuf_addstr(&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\")"));
954 status_printf_ln(s
, color
,
955 _(" (use \"git merge --abort\" to abort the merge)"));
959 status_printf_ln(s
, color
,
960 _("All conflicts fixed but you are still merging."));
962 status_printf_ln(s
, color
,
963 _(" (use \"git commit\" to conclude merge)"));
965 wt_status_print_trailer(s
);
968 static void show_am_in_progress(struct wt_status
*s
,
969 struct wt_status_state
*state
,
972 status_printf_ln(s
, color
,
973 _("You are in the middle of an am session."));
974 if (state
->am_empty_patch
)
975 status_printf_ln(s
, color
,
976 _("The current patch is empty."));
978 if (!state
->am_empty_patch
)
979 status_printf_ln(s
, color
,
980 _(" (fix conflicts and then run \"git am --continue\")"));
981 status_printf_ln(s
, color
,
982 _(" (use \"git am --skip\" to skip this patch)"));
983 status_printf_ln(s
, color
,
984 _(" (use \"git am --abort\" to restore the original branch)"));
986 wt_status_print_trailer(s
);
989 static char *read_line_from_git_path(const char *filename
)
991 struct strbuf buf
= STRBUF_INIT
;
992 FILE *fp
= fopen(git_path("%s", filename
), "r");
994 strbuf_release(&buf
);
997 strbuf_getline_lf(&buf
, fp
);
999 return strbuf_detach(&buf
, NULL
);
1001 strbuf_release(&buf
);
1006 static int split_commit_in_progress(struct wt_status
*s
)
1008 int split_in_progress
= 0;
1009 char *head
= read_line_from_git_path("HEAD");
1010 char *orig_head
= read_line_from_git_path("ORIG_HEAD");
1011 char *rebase_amend
= read_line_from_git_path("rebase-merge/amend");
1012 char *rebase_orig_head
= read_line_from_git_path("rebase-merge/orig-head");
1014 if (!head
|| !orig_head
|| !rebase_amend
|| !rebase_orig_head
||
1015 !s
->branch
|| strcmp(s
->branch
, "HEAD"))
1016 return split_in_progress
;
1018 if (!strcmp(rebase_amend
, rebase_orig_head
)) {
1019 if (strcmp(head
, rebase_amend
))
1020 split_in_progress
= 1;
1021 } else if (strcmp(orig_head
, rebase_orig_head
)) {
1022 split_in_progress
= 1;
1025 if (!s
->amend
&& !s
->nowarn
&& !s
->workdir_dirty
)
1026 split_in_progress
= 0;
1031 free(rebase_orig_head
);
1032 return split_in_progress
;
1037 * "pick d6a2f0303e897ec257dd0e0a39a5ccb709bc2047 some message"
1039 * "pick d6a2f03 some message"
1041 * The function assumes that the line does not contain useless spaces
1042 * before or after the command.
1044 static void abbrev_sha1_in_line(struct strbuf
*line
)
1046 struct strbuf
**split
;
1049 if (starts_with(line
->buf
, "exec ") ||
1050 starts_with(line
->buf
, "x "))
1053 split
= strbuf_split_max(line
, ' ', 3);
1054 if (split
[0] && split
[1]) {
1055 unsigned char sha1
[20];
1058 * strbuf_split_max left a space. Trim it and re-add
1059 * it after abbreviation.
1061 strbuf_trim(split
[1]);
1062 if (!get_sha1(split
[1]->buf
, sha1
)) {
1063 strbuf_reset(split
[1]);
1064 strbuf_add_unique_abbrev(split
[1], sha1
,
1066 strbuf_addch(split
[1], ' ');
1068 for (i
= 0; split
[i
]; i
++)
1069 strbuf_addbuf(line
, split
[i
]);
1072 strbuf_list_free(split
);
1075 static int read_rebase_todolist(const char *fname
, struct string_list
*lines
)
1077 struct strbuf line
= STRBUF_INIT
;
1078 FILE *f
= fopen(git_path("%s", fname
), "r");
1081 if (errno
== ENOENT
)
1083 die_errno("Could not open file %s for reading",
1084 git_path("%s", fname
));
1086 while (!strbuf_getline_lf(&line
, f
)) {
1087 if (line
.len
&& line
.buf
[0] == comment_line_char
)
1092 abbrev_sha1_in_line(&line
);
1093 string_list_append(lines
, line
.buf
);
1098 static void show_rebase_information(struct wt_status
*s
,
1099 struct wt_status_state
*state
,
1102 if (state
->rebase_interactive_in_progress
) {
1104 int nr_lines_to_show
= 2;
1106 struct string_list have_done
= STRING_LIST_INIT_DUP
;
1107 struct string_list yet_to_do
= STRING_LIST_INIT_DUP
;
1109 read_rebase_todolist("rebase-merge/done", &have_done
);
1110 if (read_rebase_todolist("rebase-merge/git-rebase-todo",
1112 status_printf_ln(s
, color
,
1113 _("git-rebase-todo is missing."));
1114 if (have_done
.nr
== 0)
1115 status_printf_ln(s
, color
, _("No commands done."));
1117 status_printf_ln(s
, color
,
1118 Q_("Last command done (%d command done):",
1119 "Last commands done (%d commands done):",
1122 for (i
= (have_done
.nr
> nr_lines_to_show
)
1123 ? have_done
.nr
- nr_lines_to_show
: 0;
1126 status_printf_ln(s
, color
, " %s", have_done
.items
[i
].string
);
1127 if (have_done
.nr
> nr_lines_to_show
&& s
->hints
)
1128 status_printf_ln(s
, color
,
1129 _(" (see more in file %s)"), git_path("rebase-merge/done"));
1132 if (yet_to_do
.nr
== 0)
1133 status_printf_ln(s
, color
,
1134 _("No commands remaining."));
1136 status_printf_ln(s
, color
,
1137 Q_("Next command to do (%d remaining command):",
1138 "Next commands to do (%d remaining commands):",
1141 for (i
= 0; i
< nr_lines_to_show
&& i
< yet_to_do
.nr
; i
++)
1142 status_printf_ln(s
, color
, " %s", yet_to_do
.items
[i
].string
);
1144 status_printf_ln(s
, color
,
1145 _(" (use \"git rebase --edit-todo\" to view and edit)"));
1147 string_list_clear(&yet_to_do
, 0);
1148 string_list_clear(&have_done
, 0);
1152 static void print_rebase_state(struct wt_status
*s
,
1153 struct wt_status_state
*state
,
1157 status_printf_ln(s
, color
,
1158 _("You are currently rebasing branch '%s' on '%s'."),
1162 status_printf_ln(s
, color
,
1163 _("You are currently rebasing."));
1166 static void show_rebase_in_progress(struct wt_status
*s
,
1167 struct wt_status_state
*state
,
1172 show_rebase_information(s
, state
, color
);
1173 if (has_unmerged(s
)) {
1174 print_rebase_state(s
, state
, color
);
1176 status_printf_ln(s
, color
,
1177 _(" (fix conflicts and then run \"git rebase --continue\")"));
1178 status_printf_ln(s
, color
,
1179 _(" (use \"git rebase --skip\" to skip this patch)"));
1180 status_printf_ln(s
, color
,
1181 _(" (use \"git rebase --abort\" to check out the original branch)"));
1183 } else if (state
->rebase_in_progress
|| !stat(git_path_merge_msg(), &st
)) {
1184 print_rebase_state(s
, state
, color
);
1186 status_printf_ln(s
, color
,
1187 _(" (all conflicts fixed: run \"git rebase --continue\")"));
1188 } else if (split_commit_in_progress(s
)) {
1190 status_printf_ln(s
, color
,
1191 _("You are currently splitting a commit while rebasing branch '%s' on '%s'."),
1195 status_printf_ln(s
, color
,
1196 _("You are currently splitting a commit during a rebase."));
1198 status_printf_ln(s
, color
,
1199 _(" (Once your working directory is clean, run \"git rebase --continue\")"));
1202 status_printf_ln(s
, color
,
1203 _("You are currently editing a commit while rebasing branch '%s' on '%s'."),
1207 status_printf_ln(s
, color
,
1208 _("You are currently editing a commit during a rebase."));
1209 if (s
->hints
&& !s
->amend
) {
1210 status_printf_ln(s
, color
,
1211 _(" (use \"git commit --amend\" to amend the current commit)"));
1212 status_printf_ln(s
, color
,
1213 _(" (use \"git rebase --continue\" once you are satisfied with your changes)"));
1216 wt_status_print_trailer(s
);
1219 static void show_cherry_pick_in_progress(struct wt_status
*s
,
1220 struct wt_status_state
*state
,
1223 status_printf_ln(s
, color
, _("You are currently cherry-picking commit %s."),
1224 find_unique_abbrev(state
->cherry_pick_head_sha1
, DEFAULT_ABBREV
));
1226 if (has_unmerged(s
))
1227 status_printf_ln(s
, color
,
1228 _(" (fix conflicts and run \"git cherry-pick --continue\")"));
1230 status_printf_ln(s
, color
,
1231 _(" (all conflicts fixed: run \"git cherry-pick --continue\")"));
1232 status_printf_ln(s
, color
,
1233 _(" (use \"git cherry-pick --abort\" to cancel the cherry-pick operation)"));
1235 wt_status_print_trailer(s
);
1238 static void show_revert_in_progress(struct wt_status
*s
,
1239 struct wt_status_state
*state
,
1242 status_printf_ln(s
, color
, _("You are currently reverting commit %s."),
1243 find_unique_abbrev(state
->revert_head_sha1
, DEFAULT_ABBREV
));
1245 if (has_unmerged(s
))
1246 status_printf_ln(s
, color
,
1247 _(" (fix conflicts and run \"git revert --continue\")"));
1249 status_printf_ln(s
, color
,
1250 _(" (all conflicts fixed: run \"git revert --continue\")"));
1251 status_printf_ln(s
, color
,
1252 _(" (use \"git revert --abort\" to cancel the revert operation)"));
1254 wt_status_print_trailer(s
);
1257 static void show_bisect_in_progress(struct wt_status
*s
,
1258 struct wt_status_state
*state
,
1262 status_printf_ln(s
, color
,
1263 _("You are currently bisecting, started from branch '%s'."),
1266 status_printf_ln(s
, color
,
1267 _("You are currently bisecting."));
1269 status_printf_ln(s
, color
,
1270 _(" (use \"git bisect reset\" to get back to the original branch)"));
1271 wt_status_print_trailer(s
);
1275 * Extract branch information from rebase/bisect
1277 static char *get_branch(const struct worktree
*wt
, const char *path
)
1279 struct strbuf sb
= STRBUF_INIT
;
1280 unsigned char sha1
[20];
1281 const char *branch_name
;
1283 if (strbuf_read_file(&sb
, worktree_git_path(wt
, "%s", path
), 0) <= 0)
1286 while (sb
.len
&& sb
.buf
[sb
.len
- 1] == '\n')
1287 strbuf_setlen(&sb
, sb
.len
- 1);
1290 if (skip_prefix(sb
.buf
, "refs/heads/", &branch_name
))
1291 strbuf_remove(&sb
, 0, branch_name
- sb
.buf
);
1292 else if (starts_with(sb
.buf
, "refs/"))
1294 else if (!get_sha1_hex(sb
.buf
, sha1
)) {
1296 strbuf_add_unique_abbrev(&sb
, sha1
, DEFAULT_ABBREV
);
1297 } else if (!strcmp(sb
.buf
, "detached HEAD")) /* rebase */
1301 return strbuf_detach(&sb
, NULL
);
1304 strbuf_release(&sb
);
1308 struct grab_1st_switch_cbdata
{
1310 unsigned char nsha1
[20];
1313 static int grab_1st_switch(unsigned char *osha1
, unsigned char *nsha1
,
1314 const char *email
, unsigned long timestamp
, int tz
,
1315 const char *message
, void *cb_data
)
1317 struct grab_1st_switch_cbdata
*cb
= cb_data
;
1318 const char *target
= NULL
, *end
;
1320 if (!skip_prefix(message
, "checkout: moving from ", &message
))
1322 target
= strstr(message
, " to ");
1325 target
+= strlen(" to ");
1326 strbuf_reset(&cb
->buf
);
1327 hashcpy(cb
->nsha1
, nsha1
);
1328 end
= strchrnul(target
, '\n');
1329 strbuf_add(&cb
->buf
, target
, end
- target
);
1330 if (!strcmp(cb
->buf
.buf
, "HEAD")) {
1331 /* HEAD is relative. Resolve it to the right reflog entry. */
1332 strbuf_reset(&cb
->buf
);
1333 strbuf_add_unique_abbrev(&cb
->buf
, nsha1
, DEFAULT_ABBREV
);
1338 static void wt_status_get_detached_from(struct wt_status_state
*state
)
1340 struct grab_1st_switch_cbdata cb
;
1341 struct commit
*commit
;
1342 unsigned char sha1
[20];
1345 strbuf_init(&cb
.buf
, 0);
1346 if (for_each_reflog_ent_reverse("HEAD", grab_1st_switch
, &cb
) <= 0) {
1347 strbuf_release(&cb
.buf
);
1351 if (dwim_ref(cb
.buf
.buf
, cb
.buf
.len
, sha1
, &ref
) == 1 &&
1352 /* sha1 is a commit? match without further lookup */
1353 (!hashcmp(cb
.nsha1
, sha1
) ||
1354 /* perhaps sha1 is a tag, try to dereference to a commit */
1355 ((commit
= lookup_commit_reference_gently(sha1
, 1)) != NULL
&&
1356 !hashcmp(cb
.nsha1
, commit
->object
.oid
.hash
)))) {
1357 const char *from
= ref
;
1358 if (!skip_prefix(from
, "refs/tags/", &from
))
1359 skip_prefix(from
, "refs/remotes/", &from
);
1360 state
->detached_from
= xstrdup(from
);
1362 state
->detached_from
=
1363 xstrdup(find_unique_abbrev(cb
.nsha1
, DEFAULT_ABBREV
));
1364 hashcpy(state
->detached_sha1
, cb
.nsha1
);
1365 state
->detached_at
= !get_sha1("HEAD", sha1
) &&
1366 !hashcmp(sha1
, state
->detached_sha1
);
1369 strbuf_release(&cb
.buf
);
1372 int wt_status_check_rebase(const struct worktree
*wt
,
1373 struct wt_status_state
*state
)
1377 if (!stat(worktree_git_path(wt
, "rebase-apply"), &st
)) {
1378 if (!stat(worktree_git_path(wt
, "rebase-apply/applying"), &st
)) {
1379 state
->am_in_progress
= 1;
1380 if (!stat(worktree_git_path(wt
, "rebase-apply/patch"), &st
) && !st
.st_size
)
1381 state
->am_empty_patch
= 1;
1383 state
->rebase_in_progress
= 1;
1384 state
->branch
= get_branch(wt
, "rebase-apply/head-name");
1385 state
->onto
= get_branch(wt
, "rebase-apply/onto");
1387 } else if (!stat(worktree_git_path(wt
, "rebase-merge"), &st
)) {
1388 if (!stat(worktree_git_path(wt
, "rebase-merge/interactive"), &st
))
1389 state
->rebase_interactive_in_progress
= 1;
1391 state
->rebase_in_progress
= 1;
1392 state
->branch
= get_branch(wt
, "rebase-merge/head-name");
1393 state
->onto
= get_branch(wt
, "rebase-merge/onto");
1399 int wt_status_check_bisect(const struct worktree
*wt
,
1400 struct wt_status_state
*state
)
1404 if (!stat(worktree_git_path(wt
, "BISECT_LOG"), &st
)) {
1405 state
->bisect_in_progress
= 1;
1406 state
->branch
= get_branch(wt
, "BISECT_START");
1412 void wt_status_get_state(struct wt_status_state
*state
,
1413 int get_detached_from
)
1416 unsigned char sha1
[20];
1418 if (!stat(git_path_merge_head(), &st
)) {
1419 state
->merge_in_progress
= 1;
1420 } else if (wt_status_check_rebase(NULL
, state
)) {
1422 } else if (!stat(git_path_cherry_pick_head(), &st
) &&
1423 !get_sha1("CHERRY_PICK_HEAD", sha1
)) {
1424 state
->cherry_pick_in_progress
= 1;
1425 hashcpy(state
->cherry_pick_head_sha1
, sha1
);
1427 wt_status_check_bisect(NULL
, state
);
1428 if (!stat(git_path_revert_head(), &st
) &&
1429 !get_sha1("REVERT_HEAD", sha1
)) {
1430 state
->revert_in_progress
= 1;
1431 hashcpy(state
->revert_head_sha1
, sha1
);
1434 if (get_detached_from
)
1435 wt_status_get_detached_from(state
);
1438 static void wt_status_print_state(struct wt_status
*s
,
1439 struct wt_status_state
*state
)
1441 const char *state_color
= color(WT_STATUS_HEADER
, s
);
1442 if (state
->merge_in_progress
)
1443 show_merge_in_progress(s
, state
, state_color
);
1444 else if (state
->am_in_progress
)
1445 show_am_in_progress(s
, state
, state_color
);
1446 else if (state
->rebase_in_progress
|| state
->rebase_interactive_in_progress
)
1447 show_rebase_in_progress(s
, state
, state_color
);
1448 else if (state
->cherry_pick_in_progress
)
1449 show_cherry_pick_in_progress(s
, state
, state_color
);
1450 else if (state
->revert_in_progress
)
1451 show_revert_in_progress(s
, state
, state_color
);
1452 if (state
->bisect_in_progress
)
1453 show_bisect_in_progress(s
, state
, state_color
);
1456 void wt_status_print(struct wt_status
*s
)
1458 const char *branch_color
= color(WT_STATUS_ONBRANCH
, s
);
1459 const char *branch_status_color
= color(WT_STATUS_HEADER
, s
);
1460 struct wt_status_state state
;
1462 memset(&state
, 0, sizeof(state
));
1463 wt_status_get_state(&state
,
1464 s
->branch
&& !strcmp(s
->branch
, "HEAD"));
1467 const char *on_what
= _("On branch ");
1468 const char *branch_name
= s
->branch
;
1469 if (!strcmp(branch_name
, "HEAD")) {
1470 branch_status_color
= color(WT_STATUS_NOBRANCH
, s
);
1471 if (state
.rebase_in_progress
|| state
.rebase_interactive_in_progress
) {
1472 if (state
.rebase_interactive_in_progress
)
1473 on_what
= _("interactive rebase in progress; onto ");
1475 on_what
= _("rebase in progress; onto ");
1476 branch_name
= state
.onto
;
1477 } else if (state
.detached_from
) {
1478 branch_name
= state
.detached_from
;
1479 if (state
.detached_at
)
1480 on_what
= _("HEAD detached at ");
1482 on_what
= _("HEAD detached from ");
1485 on_what
= _("Not currently on any branch.");
1488 skip_prefix(branch_name
, "refs/heads/", &branch_name
);
1489 status_printf(s
, color(WT_STATUS_HEADER
, s
), "%s", "");
1490 status_printf_more(s
, branch_status_color
, "%s", on_what
);
1491 status_printf_more(s
, branch_color
, "%s\n", branch_name
);
1493 wt_status_print_tracking(s
);
1496 wt_status_print_state(s
, &state
);
1499 free(state
.detached_from
);
1501 if (s
->is_initial
) {
1502 status_printf_ln(s
, color(WT_STATUS_HEADER
, s
), "%s", "");
1503 status_printf_ln(s
, color(WT_STATUS_HEADER
, s
), _("Initial commit"));
1504 status_printf_ln(s
, color(WT_STATUS_HEADER
, s
), "%s", "");
1507 wt_status_print_updated(s
);
1508 wt_status_print_unmerged(s
);
1509 wt_status_print_changed(s
);
1510 if (s
->submodule_summary
&&
1511 (!s
->ignore_submodule_arg
||
1512 strcmp(s
->ignore_submodule_arg
, "all"))) {
1513 wt_status_print_submodule_summary(s
, 0); /* staged */
1514 wt_status_print_submodule_summary(s
, 1); /* unstaged */
1516 if (s
->show_untracked_files
) {
1517 wt_status_print_other(s
, &s
->untracked
, _("Untracked files"), "add");
1518 if (s
->show_ignored_files
)
1519 wt_status_print_other(s
, &s
->ignored
, _("Ignored files"), "add -f");
1520 if (advice_status_u_option
&& 2000 < s
->untracked_in_ms
) {
1521 status_printf_ln(s
, GIT_COLOR_NORMAL
, "%s", "");
1522 status_printf_ln(s
, GIT_COLOR_NORMAL
,
1523 _("It took %.2f seconds to enumerate untracked files. 'status -uno'\n"
1524 "may speed it up, but you have to be careful not to forget to add\n"
1525 "new files yourself (see 'git help status')."),
1526 s
->untracked_in_ms
/ 1000.0);
1528 } else if (s
->commitable
)
1529 status_printf_ln(s
, GIT_COLOR_NORMAL
, _("Untracked files not listed%s"),
1531 ? _(" (use -u option to show untracked files)") : "");
1534 wt_status_print_verbose(s
);
1535 if (!s
->commitable
) {
1537 status_printf_ln(s
, GIT_COLOR_NORMAL
, _("No changes"));
1540 else if (s
->workdir_dirty
) {
1542 printf(_("no changes added to commit "
1543 "(use \"git add\" and/or \"git commit -a\")\n"));
1545 printf(_("no changes added to commit\n"));
1546 } else if (s
->untracked
.nr
) {
1548 printf(_("nothing added to commit but untracked files "
1549 "present (use \"git add\" to track)\n"));
1551 printf(_("nothing added to commit but untracked files present\n"));
1552 } else if (s
->is_initial
) {
1554 printf(_("nothing to commit (create/copy files "
1555 "and use \"git add\" to track)\n"));
1557 printf(_("nothing to commit\n"));
1558 } else if (!s
->show_untracked_files
) {
1560 printf(_("nothing to commit (use -u to show untracked files)\n"));
1562 printf(_("nothing to commit\n"));
1564 printf(_("nothing to commit, working tree clean\n"));
1568 static void wt_shortstatus_unmerged(struct string_list_item
*it
,
1569 struct wt_status
*s
)
1571 struct wt_status_change_data
*d
= it
->util
;
1572 const char *how
= "??";
1574 switch (d
->stagemask
) {
1575 case 1: how
= "DD"; break; /* both deleted */
1576 case 2: how
= "AU"; break; /* added by us */
1577 case 3: how
= "UD"; break; /* deleted by them */
1578 case 4: how
= "UA"; break; /* added by them */
1579 case 5: how
= "DU"; break; /* deleted by us */
1580 case 6: how
= "AA"; break; /* both added */
1581 case 7: how
= "UU"; break; /* both modified */
1583 color_fprintf(s
->fp
, color(WT_STATUS_UNMERGED
, s
), "%s", how
);
1584 if (s
->null_termination
) {
1585 fprintf(stdout
, " %s%c", it
->string
, 0);
1587 struct strbuf onebuf
= STRBUF_INIT
;
1589 one
= quote_path(it
->string
, s
->prefix
, &onebuf
);
1590 printf(" %s\n", one
);
1591 strbuf_release(&onebuf
);
1595 static void wt_shortstatus_status(struct string_list_item
*it
,
1596 struct wt_status
*s
)
1598 struct wt_status_change_data
*d
= it
->util
;
1600 if (d
->index_status
)
1601 color_fprintf(s
->fp
, color(WT_STATUS_UPDATED
, s
), "%c", d
->index_status
);
1604 if (d
->worktree_status
)
1605 color_fprintf(s
->fp
, color(WT_STATUS_CHANGED
, s
), "%c", d
->worktree_status
);
1609 if (s
->null_termination
) {
1610 fprintf(stdout
, "%s%c", it
->string
, 0);
1612 fprintf(stdout
, "%s%c", d
->head_path
, 0);
1614 struct strbuf onebuf
= STRBUF_INIT
;
1617 one
= quote_path(d
->head_path
, s
->prefix
, &onebuf
);
1618 if (*one
!= '"' && strchr(one
, ' ') != NULL
) {
1620 strbuf_addch(&onebuf
, '"');
1623 printf("%s -> ", one
);
1624 strbuf_release(&onebuf
);
1626 one
= quote_path(it
->string
, s
->prefix
, &onebuf
);
1627 if (*one
!= '"' && strchr(one
, ' ') != NULL
) {
1629 strbuf_addch(&onebuf
, '"');
1632 printf("%s\n", one
);
1633 strbuf_release(&onebuf
);
1637 static void wt_shortstatus_other(struct string_list_item
*it
,
1638 struct wt_status
*s
, const char *sign
)
1640 if (s
->null_termination
) {
1641 fprintf(stdout
, "%s %s%c", sign
, it
->string
, 0);
1643 struct strbuf onebuf
= STRBUF_INIT
;
1645 one
= quote_path(it
->string
, s
->prefix
, &onebuf
);
1646 color_fprintf(s
->fp
, color(WT_STATUS_UNTRACKED
, s
), "%s", sign
);
1647 printf(" %s\n", one
);
1648 strbuf_release(&onebuf
);
1652 static void wt_shortstatus_print_tracking(struct wt_status
*s
)
1654 struct branch
*branch
;
1655 const char *header_color
= color(WT_STATUS_HEADER
, s
);
1656 const char *branch_color_local
= color(WT_STATUS_LOCAL_BRANCH
, s
);
1657 const char *branch_color_remote
= color(WT_STATUS_REMOTE_BRANCH
, s
);
1660 const char *branch_name
;
1661 int num_ours
, num_theirs
;
1662 int upstream_is_gone
= 0;
1664 color_fprintf(s
->fp
, color(WT_STATUS_HEADER
, s
), "## ");
1668 branch_name
= s
->branch
;
1671 color_fprintf(s
->fp
, header_color
, _("Initial commit on "));
1673 if (!strcmp(s
->branch
, "HEAD")) {
1674 color_fprintf(s
->fp
, color(WT_STATUS_NOBRANCH
, s
), "%s",
1675 _("HEAD (no branch)"));
1679 skip_prefix(branch_name
, "refs/heads/", &branch_name
);
1681 branch
= branch_get(branch_name
);
1683 color_fprintf(s
->fp
, branch_color_local
, "%s", branch_name
);
1685 if (stat_tracking_info(branch
, &num_ours
, &num_theirs
, &base
) < 0) {
1689 upstream_is_gone
= 1;
1692 base
= shorten_unambiguous_ref(base
, 0);
1693 color_fprintf(s
->fp
, header_color
, "...");
1694 color_fprintf(s
->fp
, branch_color_remote
, "%s", base
);
1697 if (!upstream_is_gone
&& !num_ours
&& !num_theirs
)
1700 #define LABEL(string) (s->no_gettext ? (string) : _(string))
1702 color_fprintf(s
->fp
, header_color
, " [");
1703 if (upstream_is_gone
) {
1704 color_fprintf(s
->fp
, header_color
, LABEL(N_("gone")));
1705 } else if (!num_ours
) {
1706 color_fprintf(s
->fp
, header_color
, LABEL(N_("behind ")));
1707 color_fprintf(s
->fp
, branch_color_remote
, "%d", num_theirs
);
1708 } else if (!num_theirs
) {
1709 color_fprintf(s
->fp
, header_color
, LABEL(N_("ahead ")));
1710 color_fprintf(s
->fp
, branch_color_local
, "%d", num_ours
);
1712 color_fprintf(s
->fp
, header_color
, LABEL(N_("ahead ")));
1713 color_fprintf(s
->fp
, branch_color_local
, "%d", num_ours
);
1714 color_fprintf(s
->fp
, header_color
, ", %s", LABEL(N_("behind ")));
1715 color_fprintf(s
->fp
, branch_color_remote
, "%d", num_theirs
);
1718 color_fprintf(s
->fp
, header_color
, "]");
1720 fputc(s
->null_termination
? '\0' : '\n', s
->fp
);
1723 void wt_shortstatus_print(struct wt_status
*s
)
1728 wt_shortstatus_print_tracking(s
);
1730 for (i
= 0; i
< s
->change
.nr
; i
++) {
1731 struct wt_status_change_data
*d
;
1732 struct string_list_item
*it
;
1734 it
= &(s
->change
.items
[i
]);
1737 wt_shortstatus_unmerged(it
, s
);
1739 wt_shortstatus_status(it
, s
);
1741 for (i
= 0; i
< s
->untracked
.nr
; i
++) {
1742 struct string_list_item
*it
;
1744 it
= &(s
->untracked
.items
[i
]);
1745 wt_shortstatus_other(it
, s
, "??");
1747 for (i
= 0; i
< s
->ignored
.nr
; i
++) {
1748 struct string_list_item
*it
;
1750 it
= &(s
->ignored
.items
[i
]);
1751 wt_shortstatus_other(it
, s
, "!!");
1755 void wt_porcelain_print(struct wt_status
*s
)
1758 s
->relative_paths
= 0;
1761 wt_shortstatus_print(s
);