1 #define USE_THE_INDEX_COMPATIBILITY_MACROS
4 #include "parse-options.h"
7 #include "cache-tree.h"
8 #include "unpack-trees.h"
9 #include "merge-recursive.h"
11 #include "run-command.h"
19 #define INCLUDE_ALL_FILES 2
21 static const char * const git_stash_usage
[] = {
22 N_("git stash list [<options>]"),
23 N_("git stash show [<options>] [<stash>]"),
24 N_("git stash drop [-q|--quiet] [<stash>]"),
25 N_("git stash ( pop | apply ) [--index] [-q|--quiet] [<stash>]"),
26 N_("git stash branch <branchname> [<stash>]"),
27 N_("git stash clear"),
28 N_("git stash [push [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]\n"
29 " [-u|--include-untracked] [-a|--all] [-m|--message <message>]\n"
30 " [--pathspec-from-file=<file> [--pathspec-file-nul]]\n"
31 " [--] [<pathspec>...]]"),
32 N_("git stash save [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]\n"
33 " [-u|--include-untracked] [-a|--all] [<message>]"),
37 static const char * const git_stash_list_usage
[] = {
38 N_("git stash list [<options>]"),
42 static const char * const git_stash_show_usage
[] = {
43 N_("git stash show [<options>] [<stash>]"),
47 static const char * const git_stash_drop_usage
[] = {
48 N_("git stash drop [-q|--quiet] [<stash>]"),
52 static const char * const git_stash_pop_usage
[] = {
53 N_("git stash pop [--index] [-q|--quiet] [<stash>]"),
57 static const char * const git_stash_apply_usage
[] = {
58 N_("git stash apply [--index] [-q|--quiet] [<stash>]"),
62 static const char * const git_stash_branch_usage
[] = {
63 N_("git stash branch <branchname> [<stash>]"),
67 static const char * const git_stash_clear_usage
[] = {
68 N_("git stash clear"),
72 static const char * const git_stash_store_usage
[] = {
73 N_("git stash store [-m|--message <message>] [-q|--quiet] <commit>"),
77 static const char * const git_stash_push_usage
[] = {
78 N_("git stash [push [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]\n"
79 " [-u|--include-untracked] [-a|--all] [-m|--message <message>]\n"
80 " [--] [<pathspec>...]]"),
84 static const char * const git_stash_save_usage
[] = {
85 N_("git stash save [-p|--patch] [-k|--[no-]keep-index] [-q|--quiet]\n"
86 " [-u|--include-untracked] [-a|--all] [<message>]"),
90 static const char *ref_stash
= "refs/stash";
91 static struct strbuf stash_index_path
= STRBUF_INIT
;
94 * w_commit is set to the commit containing the working tree
95 * b_commit is set to the base commit
96 * i_commit is set to the commit containing the index tree
97 * u_commit is set to the commit containing the untracked files tree
98 * w_tree is set to the working tree
99 * b_tree is set to the base tree
100 * i_tree is set to the index tree
101 * u_tree is set to the untracked files tree
104 struct object_id w_commit
;
105 struct object_id b_commit
;
106 struct object_id i_commit
;
107 struct object_id u_commit
;
108 struct object_id w_tree
;
109 struct object_id b_tree
;
110 struct object_id i_tree
;
111 struct object_id u_tree
;
112 struct strbuf revision
;
117 static void free_stash_info(struct stash_info
*info
)
119 strbuf_release(&info
->revision
);
122 static void assert_stash_like(struct stash_info
*info
, const char *revision
)
124 if (get_oidf(&info
->b_commit
, "%s^1", revision
) ||
125 get_oidf(&info
->w_tree
, "%s:", revision
) ||
126 get_oidf(&info
->b_tree
, "%s^1:", revision
) ||
127 get_oidf(&info
->i_tree
, "%s^2:", revision
))
128 die(_("'%s' is not a stash-like commit"), revision
);
131 static int get_stash_info(struct stash_info
*info
, int argc
, const char **argv
)
136 const char *revision
;
137 const char *commit
= NULL
;
138 struct object_id dummy
;
139 struct strbuf symbolic
= STRBUF_INIT
;
143 struct strbuf refs_msg
= STRBUF_INIT
;
145 for (i
= 0; i
< argc
; i
++)
146 strbuf_addf(&refs_msg
, " '%s'", argv
[i
]);
148 fprintf_ln(stderr
, _("Too many revisions specified:%s"),
150 strbuf_release(&refs_msg
);
158 strbuf_init(&info
->revision
, 0);
160 if (!ref_exists(ref_stash
)) {
161 free_stash_info(info
);
162 fprintf_ln(stderr
, _("No stash entries found."));
166 strbuf_addf(&info
->revision
, "%s@{0}", ref_stash
);
167 } else if (strspn(commit
, "0123456789") == strlen(commit
)) {
168 strbuf_addf(&info
->revision
, "%s@{%s}", ref_stash
, commit
);
170 strbuf_addstr(&info
->revision
, commit
);
173 revision
= info
->revision
.buf
;
175 if (get_oid(revision
, &info
->w_commit
)) {
176 error(_("%s is not a valid reference"), revision
);
177 free_stash_info(info
);
181 assert_stash_like(info
, revision
);
183 info
->has_u
= !get_oidf(&info
->u_tree
, "%s^3:", revision
);
185 end_of_rev
= strchrnul(revision
, '@');
186 strbuf_add(&symbolic
, revision
, end_of_rev
- revision
);
188 ret
= dwim_ref(symbolic
.buf
, symbolic
.len
, &dummy
, &expanded_ref
, 0);
189 strbuf_release(&symbolic
);
191 case 0: /* Not found, but valid ref */
192 info
->is_stash_ref
= 0;
195 info
->is_stash_ref
= !strcmp(expanded_ref
, ref_stash
);
197 default: /* Invalid or ambiguous */
198 free_stash_info(info
);
202 return !(ret
== 0 || ret
== 1);
205 static int do_clear_stash(void)
207 struct object_id obj
;
208 if (get_oid(ref_stash
, &obj
))
211 return delete_ref(NULL
, ref_stash
, &obj
, 0);
214 static int clear_stash(int argc
, const char **argv
, const char *prefix
)
216 struct option options
[] = {
220 argc
= parse_options(argc
, argv
, prefix
, options
,
221 git_stash_clear_usage
,
222 PARSE_OPT_STOP_AT_NON_OPTION
);
225 return error(_("git stash clear with parameters is "
228 return do_clear_stash();
231 static int reset_tree(struct object_id
*i_tree
, int update
, int reset
)
234 struct unpack_trees_options opts
;
235 struct tree_desc t
[MAX_UNPACK_TREES
];
237 struct lock_file lock_file
= LOCK_INIT
;
239 read_cache_preload(NULL
);
240 if (refresh_cache(REFRESH_QUIET
))
243 hold_locked_index(&lock_file
, LOCK_DIE_ON_ERROR
);
245 memset(&opts
, 0, sizeof(opts
));
247 tree
= parse_tree_indirect(i_tree
);
248 if (parse_tree(tree
))
251 init_tree_desc(t
, tree
->buffer
, tree
->size
);
254 opts
.src_index
= &the_index
;
255 opts
.dst_index
= &the_index
;
258 opts
.update
= update
;
259 opts
.fn
= oneway_merge
;
261 if (unpack_trees(nr_trees
, t
, &opts
))
264 if (write_locked_index(&the_index
, &lock_file
, COMMIT_LOCK
))
265 return error(_("unable to write new index file"));
270 static int diff_tree_binary(struct strbuf
*out
, struct object_id
*w_commit
)
272 struct child_process cp
= CHILD_PROCESS_INIT
;
273 const char *w_commit_hex
= oid_to_hex(w_commit
);
276 * Diff-tree would not be very hard to replace with a native function,
277 * however it should be done together with apply_cached.
280 strvec_pushl(&cp
.args
, "diff-tree", "--binary", NULL
);
281 strvec_pushf(&cp
.args
, "%s^2^..%s^2", w_commit_hex
, w_commit_hex
);
283 return pipe_command(&cp
, NULL
, 0, out
, 0, NULL
, 0);
286 static int apply_cached(struct strbuf
*out
)
288 struct child_process cp
= CHILD_PROCESS_INIT
;
291 * Apply currently only reads either from stdin or a file, thus
292 * apply_all_patches would have to be updated to optionally take a
296 strvec_pushl(&cp
.args
, "apply", "--cached", NULL
);
297 return pipe_command(&cp
, out
->buf
, out
->len
, NULL
, 0, NULL
, 0);
300 static int reset_head(void)
302 struct child_process cp
= CHILD_PROCESS_INIT
;
305 * Reset is overall quite simple, however there is no current public
309 strvec_push(&cp
.args
, "reset");
311 return run_command(&cp
);
314 static void add_diff_to_buf(struct diff_queue_struct
*q
,
315 struct diff_options
*options
,
320 for (i
= 0; i
< q
->nr
; i
++) {
321 strbuf_addstr(data
, q
->queue
[i
]->one
->path
);
323 /* NUL-terminate: will be fed to update-index -z */
324 strbuf_addch(data
, '\0');
328 static int get_newly_staged(struct strbuf
*out
, struct object_id
*c_tree
)
330 struct child_process cp
= CHILD_PROCESS_INIT
;
331 const char *c_tree_hex
= oid_to_hex(c_tree
);
334 * diff-index is very similar to diff-tree above, and should be
335 * converted together with update_index.
338 strvec_pushl(&cp
.args
, "diff-index", "--cached", "--name-only",
339 "--diff-filter=A", NULL
);
340 strvec_push(&cp
.args
, c_tree_hex
);
341 return pipe_command(&cp
, NULL
, 0, out
, 0, NULL
, 0);
344 static int update_index(struct strbuf
*out
)
346 struct child_process cp
= CHILD_PROCESS_INIT
;
349 * Update-index is very complicated and may need to have a public
350 * function exposed in order to remove this forking.
353 strvec_pushl(&cp
.args
, "update-index", "--add", "--stdin", NULL
);
354 return pipe_command(&cp
, out
->buf
, out
->len
, NULL
, 0, NULL
, 0);
357 static int restore_untracked(struct object_id
*u_tree
)
360 struct child_process cp
= CHILD_PROCESS_INIT
;
363 * We need to run restore files from a given index, but without
364 * affecting the current index, so we use GIT_INDEX_FILE with
365 * run_command to fork processes that will not interfere.
368 strvec_push(&cp
.args
, "read-tree");
369 strvec_push(&cp
.args
, oid_to_hex(u_tree
));
370 strvec_pushf(&cp
.env_array
, "GIT_INDEX_FILE=%s",
371 stash_index_path
.buf
);
372 if (run_command(&cp
)) {
373 remove_path(stash_index_path
.buf
);
377 child_process_init(&cp
);
379 strvec_pushl(&cp
.args
, "checkout-index", "--all", NULL
);
380 strvec_pushf(&cp
.env_array
, "GIT_INDEX_FILE=%s",
381 stash_index_path
.buf
);
383 res
= run_command(&cp
);
384 remove_path(stash_index_path
.buf
);
388 static int do_apply_stash(const char *prefix
, struct stash_info
*info
,
389 int index
, int quiet
)
392 int has_index
= index
;
393 struct merge_options o
;
394 struct object_id c_tree
;
395 struct object_id index_tree
;
396 struct commit
*result
;
397 const struct object_id
*bases
[1];
399 read_cache_preload(NULL
);
400 if (refresh_and_write_cache(REFRESH_QUIET
, 0, 0))
403 if (write_cache_as_tree(&c_tree
, 0, NULL
))
404 return error(_("cannot apply a stash in the middle of a merge"));
407 if (oideq(&info
->b_tree
, &info
->i_tree
) ||
408 oideq(&c_tree
, &info
->i_tree
)) {
411 struct strbuf out
= STRBUF_INIT
;
413 if (diff_tree_binary(&out
, &info
->w_commit
)) {
414 strbuf_release(&out
);
415 return error(_("could not generate diff %s^!."),
416 oid_to_hex(&info
->w_commit
));
419 ret
= apply_cached(&out
);
420 strbuf_release(&out
);
422 return error(_("conflicts in index."
423 "Try without --index."));
427 if (write_cache_as_tree(&index_tree
, 0, NULL
))
428 return error(_("could not save index tree"));
436 if (info
->has_u
&& restore_untracked(&info
->u_tree
))
437 return error(_("could not restore untracked files from stash"));
439 init_merge_options(&o
, the_repository
);
441 o
.branch1
= "Updated upstream";
442 o
.branch2
= "Stashed changes";
444 if (oideq(&info
->b_tree
, &c_tree
))
445 o
.branch1
= "Version stash was based on";
450 if (o
.verbosity
>= 3)
451 printf_ln(_("Merging %s with %s"), o
.branch1
, o
.branch2
);
453 bases
[0] = &info
->b_tree
;
455 ret
= merge_recursive_generic(&o
, &c_tree
, &info
->w_tree
, 1, bases
,
461 fprintf_ln(stderr
, _("Index was not unstashed."));
467 if (reset_tree(&index_tree
, 0, 0))
470 struct strbuf out
= STRBUF_INIT
;
472 if (get_newly_staged(&out
, &c_tree
)) {
473 strbuf_release(&out
);
477 if (reset_tree(&c_tree
, 0, 1)) {
478 strbuf_release(&out
);
482 ret
= update_index(&out
);
483 strbuf_release(&out
);
487 /* read back the result of update_index() back from the disk */
493 struct child_process cp
= CHILD_PROCESS_INIT
;
496 * Status is quite simple and could be replaced with calls to
497 * wt_status in the future, but it adds complexities which may
498 * require more tests.
502 strvec_pushf(&cp
.env_array
, GIT_WORK_TREE_ENVIRONMENT
"=%s",
503 absolute_path(get_git_work_tree()));
504 strvec_pushf(&cp
.env_array
, GIT_DIR_ENVIRONMENT
"=%s",
505 absolute_path(get_git_dir()));
506 strvec_push(&cp
.args
, "status");
513 static int apply_stash(int argc
, const char **argv
, const char *prefix
)
518 struct stash_info info
;
519 struct option options
[] = {
520 OPT__QUIET(&quiet
, N_("be quiet, only report errors")),
521 OPT_BOOL(0, "index", &index
,
522 N_("attempt to recreate the index")),
526 argc
= parse_options(argc
, argv
, prefix
, options
,
527 git_stash_apply_usage
, 0);
529 if (get_stash_info(&info
, argc
, argv
))
532 ret
= do_apply_stash(prefix
, &info
, index
, quiet
);
533 free_stash_info(&info
);
537 static int do_drop_stash(struct stash_info
*info
, int quiet
)
540 struct child_process cp_reflog
= CHILD_PROCESS_INIT
;
541 struct child_process cp
= CHILD_PROCESS_INIT
;
544 * reflog does not provide a simple function for deleting refs. One will
545 * need to be added to avoid implementing too much reflog code here
548 cp_reflog
.git_cmd
= 1;
549 strvec_pushl(&cp_reflog
.args
, "reflog", "delete", "--updateref",
551 strvec_push(&cp_reflog
.args
, info
->revision
.buf
);
552 ret
= run_command(&cp_reflog
);
555 printf_ln(_("Dropped %s (%s)"), info
->revision
.buf
,
556 oid_to_hex(&info
->w_commit
));
558 return error(_("%s: Could not drop stash entry"),
563 * This could easily be replaced by get_oid, but currently it will throw
564 * a fatal error when a reflog is empty, which we can not recover from.
567 /* Even though --quiet is specified, rev-parse still outputs the hash */
569 strvec_pushl(&cp
.args
, "rev-parse", "--verify", "--quiet", NULL
);
570 strvec_pushf(&cp
.args
, "%s@{0}", ref_stash
);
571 ret
= run_command(&cp
);
573 /* do_clear_stash if we just dropped the last stash entry */
580 static void assert_stash_ref(struct stash_info
*info
)
582 if (!info
->is_stash_ref
) {
583 error(_("'%s' is not a stash reference"), info
->revision
.buf
);
584 free_stash_info(info
);
589 static int drop_stash(int argc
, const char **argv
, const char *prefix
)
593 struct stash_info info
;
594 struct option options
[] = {
595 OPT__QUIET(&quiet
, N_("be quiet, only report errors")),
599 argc
= parse_options(argc
, argv
, prefix
, options
,
600 git_stash_drop_usage
, 0);
602 if (get_stash_info(&info
, argc
, argv
))
605 assert_stash_ref(&info
);
607 ret
= do_drop_stash(&info
, quiet
);
608 free_stash_info(&info
);
612 static int pop_stash(int argc
, const char **argv
, const char *prefix
)
617 struct stash_info info
;
618 struct option options
[] = {
619 OPT__QUIET(&quiet
, N_("be quiet, only report errors")),
620 OPT_BOOL(0, "index", &index
,
621 N_("attempt to recreate the index")),
625 argc
= parse_options(argc
, argv
, prefix
, options
,
626 git_stash_pop_usage
, 0);
628 if (get_stash_info(&info
, argc
, argv
))
631 assert_stash_ref(&info
);
632 if ((ret
= do_apply_stash(prefix
, &info
, index
, quiet
)))
633 printf_ln(_("The stash entry is kept in case "
634 "you need it again."));
636 ret
= do_drop_stash(&info
, quiet
);
638 free_stash_info(&info
);
642 static int branch_stash(int argc
, const char **argv
, const char *prefix
)
645 const char *branch
= NULL
;
646 struct stash_info info
;
647 struct child_process cp
= CHILD_PROCESS_INIT
;
648 struct option options
[] = {
652 argc
= parse_options(argc
, argv
, prefix
, options
,
653 git_stash_branch_usage
, 0);
656 fprintf_ln(stderr
, _("No branch name specified"));
662 if (get_stash_info(&info
, argc
- 1, argv
+ 1))
666 strvec_pushl(&cp
.args
, "checkout", "-b", NULL
);
667 strvec_push(&cp
.args
, branch
);
668 strvec_push(&cp
.args
, oid_to_hex(&info
.b_commit
));
669 ret
= run_command(&cp
);
671 ret
= do_apply_stash(prefix
, &info
, 1, 0);
672 if (!ret
&& info
.is_stash_ref
)
673 ret
= do_drop_stash(&info
, 0);
675 free_stash_info(&info
);
680 static int list_stash(int argc
, const char **argv
, const char *prefix
)
682 struct child_process cp
= CHILD_PROCESS_INIT
;
683 struct option options
[] = {
687 argc
= parse_options(argc
, argv
, prefix
, options
,
688 git_stash_list_usage
,
689 PARSE_OPT_KEEP_UNKNOWN
);
691 if (!ref_exists(ref_stash
))
695 strvec_pushl(&cp
.args
, "log", "--format=%gd: %gs", "-g",
696 "--first-parent", "-m", NULL
);
697 strvec_pushv(&cp
.args
, argv
);
698 strvec_push(&cp
.args
, ref_stash
);
699 strvec_push(&cp
.args
, "--");
700 return run_command(&cp
);
703 static int show_stat
= 1;
704 static int show_patch
;
705 static int use_legacy_stash
;
707 static int git_stash_config(const char *var
, const char *value
, void *cb
)
709 if (!strcmp(var
, "stash.showstat")) {
710 show_stat
= git_config_bool(var
, value
);
713 if (!strcmp(var
, "stash.showpatch")) {
714 show_patch
= git_config_bool(var
, value
);
717 if (!strcmp(var
, "stash.usebuiltin")) {
718 use_legacy_stash
= !git_config_bool(var
, value
);
721 return git_diff_basic_config(var
, value
, cb
);
724 static int show_stash(int argc
, const char **argv
, const char *prefix
)
728 struct stash_info info
;
730 struct strvec stash_args
= STRVEC_INIT
;
731 struct strvec revision_args
= STRVEC_INIT
;
732 struct option options
[] = {
736 init_diff_ui_defaults();
737 git_config(git_diff_ui_config
, NULL
);
738 init_revisions(&rev
, prefix
);
740 strvec_push(&revision_args
, argv
[0]);
741 for (i
= 1; i
< argc
; i
++) {
742 if (argv
[i
][0] != '-')
743 strvec_push(&stash_args
, argv
[i
]);
745 strvec_push(&revision_args
, argv
[i
]);
748 ret
= get_stash_info(&info
, stash_args
.nr
, stash_args
.v
);
749 strvec_clear(&stash_args
);
754 * The config settings are applied only if there are not passed
757 if (revision_args
.nr
== 1) {
759 rev
.diffopt
.output_format
= DIFF_FORMAT_DIFFSTAT
;
762 rev
.diffopt
.output_format
|= DIFF_FORMAT_PATCH
;
764 if (!show_stat
&& !show_patch
) {
765 free_stash_info(&info
);
770 argc
= setup_revisions(revision_args
.nr
, revision_args
.v
, &rev
, NULL
);
772 free_stash_info(&info
);
773 usage_with_options(git_stash_show_usage
, options
);
775 if (!rev
.diffopt
.output_format
) {
776 rev
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
777 diff_setup_done(&rev
.diffopt
);
780 rev
.diffopt
.flags
.recursive
= 1;
781 setup_diff_pager(&rev
.diffopt
);
782 diff_tree_oid(&info
.b_commit
, &info
.w_commit
, "", &rev
.diffopt
);
783 log_tree_diff_flush(&rev
);
785 free_stash_info(&info
);
786 return diff_result_code(&rev
.diffopt
, 0);
789 static int do_store_stash(const struct object_id
*w_commit
, const char *stash_msg
,
793 stash_msg
= "Created via \"git stash store\".";
795 if (update_ref(stash_msg
, ref_stash
, w_commit
, NULL
,
796 REF_FORCE_CREATE_REFLOG
,
797 quiet
? UPDATE_REFS_QUIET_ON_ERR
:
798 UPDATE_REFS_MSG_ON_ERR
)) {
800 fprintf_ln(stderr
, _("Cannot update %s with %s"),
801 ref_stash
, oid_to_hex(w_commit
));
809 static int store_stash(int argc
, const char **argv
, const char *prefix
)
812 const char *stash_msg
= NULL
;
813 struct object_id obj
;
814 struct object_context dummy
;
815 struct option options
[] = {
816 OPT__QUIET(&quiet
, N_("be quiet")),
817 OPT_STRING('m', "message", &stash_msg
, "message",
818 N_("stash message")),
822 argc
= parse_options(argc
, argv
, prefix
, options
,
823 git_stash_store_usage
,
824 PARSE_OPT_KEEP_UNKNOWN
);
828 fprintf_ln(stderr
, _("\"git stash store\" requires one "
829 "<commit> argument"));
833 if (get_oid_with_context(the_repository
,
834 argv
[0], quiet
? GET_OID_QUIETLY
: 0, &obj
,
837 fprintf_ln(stderr
, _("Cannot update %s with %s"),
842 return do_store_stash(&obj
, stash_msg
, quiet
);
845 static void add_pathspecs(struct strvec
*args
,
846 const struct pathspec
*ps
) {
849 for (i
= 0; i
< ps
->nr
; i
++)
850 strvec_push(args
, ps
->items
[i
].original
);
854 * `untracked_files` will be filled with the names of untracked files.
855 * The return value is:
857 * = 0 if there are not any untracked files
858 * > 0 if there are untracked files
860 static int get_untracked_files(const struct pathspec
*ps
, int include_untracked
,
861 struct strbuf
*untracked_files
)
865 struct dir_struct dir
;
868 if (include_untracked
!= INCLUDE_ALL_FILES
)
869 setup_standard_excludes(&dir
);
871 fill_directory(&dir
, the_repository
->index
, ps
);
872 for (i
= 0; i
< dir
.nr
; i
++) {
873 struct dir_entry
*ent
= dir
.entries
[i
];
875 strbuf_addstr(untracked_files
, ent
->name
);
876 /* NUL-terminate: will be fed to update-index -z */
877 strbuf_addch(untracked_files
, '\0');
885 * The return value of `check_changes_tracked_files()` can be:
887 * < 0 if there was an error
888 * = 0 if there are no changes.
889 * > 0 if there are changes.
891 static int check_changes_tracked_files(const struct pathspec
*ps
)
895 struct object_id dummy
;
898 /* No initial commit. */
899 if (get_oid("HEAD", &dummy
))
902 if (read_cache() < 0)
905 init_revisions(&rev
, NULL
);
906 copy_pathspec(&rev
.prune_data
, ps
);
908 rev
.diffopt
.flags
.quick
= 1;
909 rev
.diffopt
.flags
.ignore_submodules
= 1;
912 add_head_to_pending(&rev
);
913 diff_setup_done(&rev
.diffopt
);
915 result
= run_diff_index(&rev
, 1);
916 if (diff_result_code(&rev
.diffopt
, result
)) {
921 object_array_clear(&rev
.pending
);
922 result
= run_diff_files(&rev
, 0);
923 if (diff_result_code(&rev
.diffopt
, result
)) {
929 clear_pathspec(&rev
.prune_data
);
934 * The function will fill `untracked_files` with the names of untracked files
935 * It will return 1 if there were any changes and 0 if there were not.
937 static int check_changes(const struct pathspec
*ps
, int include_untracked
,
938 struct strbuf
*untracked_files
)
941 if (check_changes_tracked_files(ps
))
944 if (include_untracked
&& get_untracked_files(ps
, include_untracked
,
951 static int save_untracked_files(struct stash_info
*info
, struct strbuf
*msg
,
955 struct strbuf untracked_msg
= STRBUF_INIT
;
956 struct child_process cp_upd_index
= CHILD_PROCESS_INIT
;
957 struct index_state istate
= { NULL
};
959 cp_upd_index
.git_cmd
= 1;
960 strvec_pushl(&cp_upd_index
.args
, "update-index", "-z", "--add",
961 "--remove", "--stdin", NULL
);
962 strvec_pushf(&cp_upd_index
.env_array
, "GIT_INDEX_FILE=%s",
963 stash_index_path
.buf
);
965 strbuf_addf(&untracked_msg
, "untracked files on %s\n", msg
->buf
);
966 if (pipe_command(&cp_upd_index
, files
.buf
, files
.len
, NULL
, 0,
972 if (write_index_as_tree(&info
->u_tree
, &istate
, stash_index_path
.buf
, 0,
978 if (commit_tree(untracked_msg
.buf
, untracked_msg
.len
,
979 &info
->u_tree
, NULL
, &info
->u_commit
, NULL
, NULL
)) {
985 discard_index(&istate
);
986 strbuf_release(&untracked_msg
);
987 remove_path(stash_index_path
.buf
);
991 static int stash_patch(struct stash_info
*info
, const struct pathspec
*ps
,
992 struct strbuf
*out_patch
, int quiet
)
995 struct child_process cp_read_tree
= CHILD_PROCESS_INIT
;
996 struct child_process cp_diff_tree
= CHILD_PROCESS_INIT
;
997 struct index_state istate
= { NULL
};
998 char *old_index_env
= NULL
, *old_repo_index_file
;
1000 remove_path(stash_index_path
.buf
);
1002 cp_read_tree
.git_cmd
= 1;
1003 strvec_pushl(&cp_read_tree
.args
, "read-tree", "HEAD", NULL
);
1004 strvec_pushf(&cp_read_tree
.env_array
, "GIT_INDEX_FILE=%s",
1005 stash_index_path
.buf
);
1006 if (run_command(&cp_read_tree
)) {
1011 /* Find out what the user wants. */
1012 old_repo_index_file
= the_repository
->index_file
;
1013 the_repository
->index_file
= stash_index_path
.buf
;
1014 old_index_env
= xstrdup_or_null(getenv(INDEX_ENVIRONMENT
));
1015 setenv(INDEX_ENVIRONMENT
, the_repository
->index_file
, 1);
1017 ret
= run_add_interactive(NULL
, "--patch=stash", ps
);
1019 the_repository
->index_file
= old_repo_index_file
;
1020 if (old_index_env
&& *old_index_env
)
1021 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
1023 unsetenv(INDEX_ENVIRONMENT
);
1024 FREE_AND_NULL(old_index_env
);
1026 /* State of the working tree. */
1027 if (write_index_as_tree(&info
->w_tree
, &istate
, stash_index_path
.buf
, 0,
1033 cp_diff_tree
.git_cmd
= 1;
1034 strvec_pushl(&cp_diff_tree
.args
, "diff-tree", "-p", "-U1", "HEAD",
1035 oid_to_hex(&info
->w_tree
), "--", NULL
);
1036 if (pipe_command(&cp_diff_tree
, NULL
, 0, out_patch
, 0, NULL
, 0)) {
1041 if (!out_patch
->len
) {
1043 fprintf_ln(stderr
, _("No changes selected"));
1048 discard_index(&istate
);
1049 remove_path(stash_index_path
.buf
);
1053 static int stash_working_tree(struct stash_info
*info
, const struct pathspec
*ps
)
1056 struct rev_info rev
;
1057 struct child_process cp_upd_index
= CHILD_PROCESS_INIT
;
1058 struct strbuf diff_output
= STRBUF_INIT
;
1059 struct index_state istate
= { NULL
};
1061 init_revisions(&rev
, NULL
);
1062 copy_pathspec(&rev
.prune_data
, ps
);
1064 set_alternate_index_output(stash_index_path
.buf
);
1065 if (reset_tree(&info
->i_tree
, 0, 0)) {
1069 set_alternate_index_output(NULL
);
1071 rev
.diffopt
.output_format
= DIFF_FORMAT_CALLBACK
;
1072 rev
.diffopt
.format_callback
= add_diff_to_buf
;
1073 rev
.diffopt
.format_callback_data
= &diff_output
;
1075 if (read_cache_preload(&rev
.diffopt
.pathspec
) < 0) {
1080 add_pending_object(&rev
, parse_object(the_repository
, &info
->b_commit
),
1082 if (run_diff_index(&rev
, 0)) {
1087 cp_upd_index
.git_cmd
= 1;
1088 strvec_pushl(&cp_upd_index
.args
, "update-index",
1089 "--ignore-skip-worktree-entries",
1090 "-z", "--add", "--remove", "--stdin", NULL
);
1091 strvec_pushf(&cp_upd_index
.env_array
, "GIT_INDEX_FILE=%s",
1092 stash_index_path
.buf
);
1094 if (pipe_command(&cp_upd_index
, diff_output
.buf
, diff_output
.len
,
1095 NULL
, 0, NULL
, 0)) {
1100 if (write_index_as_tree(&info
->w_tree
, &istate
, stash_index_path
.buf
, 0,
1107 discard_index(&istate
);
1109 object_array_clear(&rev
.pending
);
1110 clear_pathspec(&rev
.prune_data
);
1111 strbuf_release(&diff_output
);
1112 remove_path(stash_index_path
.buf
);
1116 static int do_create_stash(const struct pathspec
*ps
, struct strbuf
*stash_msg_buf
,
1117 int include_untracked
, int patch_mode
,
1118 struct stash_info
*info
, struct strbuf
*patch
,
1123 int untracked_commit_option
= 0;
1124 const char *head_short_sha1
= NULL
;
1125 const char *branch_ref
= NULL
;
1126 const char *branch_name
= "(no branch)";
1127 struct commit
*head_commit
= NULL
;
1128 struct commit_list
*parents
= NULL
;
1129 struct strbuf msg
= STRBUF_INIT
;
1130 struct strbuf commit_tree_label
= STRBUF_INIT
;
1131 struct strbuf untracked_files
= STRBUF_INIT
;
1133 prepare_fallback_ident("git stash", "git@stash");
1135 read_cache_preload(NULL
);
1136 if (refresh_and_write_cache(REFRESH_QUIET
, 0, 0) < 0) {
1141 if (get_oid("HEAD", &info
->b_commit
)) {
1143 fprintf_ln(stderr
, _("You do not have "
1144 "the initial commit yet"));
1148 head_commit
= lookup_commit(the_repository
, &info
->b_commit
);
1151 if (!check_changes(ps
, include_untracked
, &untracked_files
)) {
1156 branch_ref
= resolve_ref_unsafe("HEAD", 0, NULL
, &flags
);
1157 if (flags
& REF_ISSYMREF
)
1158 branch_name
= strrchr(branch_ref
, '/') + 1;
1159 head_short_sha1
= find_unique_abbrev(&head_commit
->object
.oid
,
1161 strbuf_addf(&msg
, "%s: %s ", branch_name
, head_short_sha1
);
1162 pp_commit_easy(CMIT_FMT_ONELINE
, head_commit
, &msg
);
1164 strbuf_addf(&commit_tree_label
, "index on %s\n", msg
.buf
);
1165 commit_list_insert(head_commit
, &parents
);
1166 if (write_cache_as_tree(&info
->i_tree
, 0, NULL
) ||
1167 commit_tree(commit_tree_label
.buf
, commit_tree_label
.len
,
1168 &info
->i_tree
, parents
, &info
->i_commit
, NULL
, NULL
)) {
1170 fprintf_ln(stderr
, _("Cannot save the current "
1176 if (include_untracked
) {
1177 if (save_untracked_files(info
, &msg
, untracked_files
)) {
1179 fprintf_ln(stderr
, _("Cannot save "
1180 "the untracked files"));
1184 untracked_commit_option
= 1;
1187 ret
= stash_patch(info
, ps
, patch
, quiet
);
1190 fprintf_ln(stderr
, _("Cannot save the current "
1193 } else if (ret
> 0) {
1197 if (stash_working_tree(info
, ps
)) {
1199 fprintf_ln(stderr
, _("Cannot save the current "
1206 if (!stash_msg_buf
->len
)
1207 strbuf_addf(stash_msg_buf
, "WIP on %s", msg
.buf
);
1209 strbuf_insertf(stash_msg_buf
, 0, "On %s: ", branch_name
);
1212 * `parents` will be empty after calling `commit_tree()`, so there is
1213 * no need to call `free_commit_list()`
1216 if (untracked_commit_option
)
1217 commit_list_insert(lookup_commit(the_repository
,
1220 commit_list_insert(lookup_commit(the_repository
, &info
->i_commit
),
1222 commit_list_insert(head_commit
, &parents
);
1224 if (commit_tree(stash_msg_buf
->buf
, stash_msg_buf
->len
, &info
->w_tree
,
1225 parents
, &info
->w_commit
, NULL
, NULL
)) {
1227 fprintf_ln(stderr
, _("Cannot record "
1228 "working tree state"));
1234 strbuf_release(&commit_tree_label
);
1235 strbuf_release(&msg
);
1236 strbuf_release(&untracked_files
);
1240 static int create_stash(int argc
, const char **argv
, const char *prefix
)
1243 struct strbuf stash_msg_buf
= STRBUF_INIT
;
1244 struct stash_info info
;
1247 /* Starting with argv[1], since argv[0] is "create" */
1248 strbuf_join_argv(&stash_msg_buf
, argc
- 1, ++argv
, ' ');
1250 memset(&ps
, 0, sizeof(ps
));
1251 if (!check_changes_tracked_files(&ps
))
1254 ret
= do_create_stash(&ps
, &stash_msg_buf
, 0, 0, &info
,
1257 printf_ln("%s", oid_to_hex(&info
.w_commit
));
1259 strbuf_release(&stash_msg_buf
);
1263 static int do_push_stash(const struct pathspec
*ps
, const char *stash_msg
, int quiet
,
1264 int keep_index
, int patch_mode
, int include_untracked
)
1267 struct stash_info info
;
1268 struct strbuf patch
= STRBUF_INIT
;
1269 struct strbuf stash_msg_buf
= STRBUF_INIT
;
1270 struct strbuf untracked_files
= STRBUF_INIT
;
1272 if (patch_mode
&& keep_index
== -1)
1275 if (patch_mode
&& include_untracked
) {
1276 fprintf_ln(stderr
, _("Can't use --patch and --include-untracked"
1277 " or --all at the same time"));
1282 read_cache_preload(NULL
);
1283 if (!include_untracked
&& ps
->nr
) {
1285 char *ps_matched
= xcalloc(ps
->nr
, 1);
1287 for (i
= 0; i
< active_nr
; i
++)
1288 ce_path_match(&the_index
, active_cache
[i
], ps
,
1291 if (report_path_error(ps_matched
, ps
)) {
1292 fprintf_ln(stderr
, _("Did you forget to 'git add'?"));
1300 if (refresh_and_write_cache(REFRESH_QUIET
, 0, 0)) {
1305 if (!check_changes(ps
, include_untracked
, &untracked_files
)) {
1307 printf_ln(_("No local changes to save"));
1311 if (!reflog_exists(ref_stash
) && do_clear_stash()) {
1314 fprintf_ln(stderr
, _("Cannot initialize stash"));
1319 strbuf_addstr(&stash_msg_buf
, stash_msg
);
1320 if (do_create_stash(ps
, &stash_msg_buf
, include_untracked
, patch_mode
,
1321 &info
, &patch
, quiet
)) {
1326 if (do_store_stash(&info
.w_commit
, stash_msg_buf
.buf
, 1)) {
1329 fprintf_ln(stderr
, _("Cannot save the current status"));
1334 printf_ln(_("Saved working directory and index state %s"),
1338 if (include_untracked
&& !ps
->nr
) {
1339 struct child_process cp
= CHILD_PROCESS_INIT
;
1342 strvec_pushl(&cp
.args
, "clean", "--force",
1343 "--quiet", "-d", NULL
);
1344 if (include_untracked
== INCLUDE_ALL_FILES
)
1345 strvec_push(&cp
.args
, "-x");
1346 if (run_command(&cp
)) {
1353 struct child_process cp_add
= CHILD_PROCESS_INIT
;
1354 struct child_process cp_diff
= CHILD_PROCESS_INIT
;
1355 struct child_process cp_apply
= CHILD_PROCESS_INIT
;
1356 struct strbuf out
= STRBUF_INIT
;
1359 strvec_push(&cp_add
.args
, "add");
1360 if (!include_untracked
)
1361 strvec_push(&cp_add
.args
, "-u");
1362 if (include_untracked
== INCLUDE_ALL_FILES
)
1363 strvec_push(&cp_add
.args
, "--force");
1364 strvec_push(&cp_add
.args
, "--");
1365 add_pathspecs(&cp_add
.args
, ps
);
1366 if (run_command(&cp_add
)) {
1371 cp_diff
.git_cmd
= 1;
1372 strvec_pushl(&cp_diff
.args
, "diff-index", "-p",
1373 "--cached", "--binary", "HEAD", "--",
1375 add_pathspecs(&cp_diff
.args
, ps
);
1376 if (pipe_command(&cp_diff
, NULL
, 0, &out
, 0, NULL
, 0)) {
1381 cp_apply
.git_cmd
= 1;
1382 strvec_pushl(&cp_apply
.args
, "apply", "--index",
1384 if (pipe_command(&cp_apply
, out
.buf
, out
.len
, NULL
, 0,
1390 struct child_process cp
= CHILD_PROCESS_INIT
;
1392 strvec_pushl(&cp
.args
, "reset", "--hard", "-q",
1393 "--no-recurse-submodules", NULL
);
1394 if (run_command(&cp
)) {
1400 if (keep_index
== 1 && !is_null_oid(&info
.i_tree
)) {
1401 struct child_process cp
= CHILD_PROCESS_INIT
;
1404 strvec_pushl(&cp
.args
, "checkout", "--no-overlay",
1405 oid_to_hex(&info
.i_tree
), "--", NULL
);
1407 strvec_push(&cp
.args
, ":/");
1409 add_pathspecs(&cp
.args
, ps
);
1410 if (run_command(&cp
)) {
1417 struct child_process cp
= CHILD_PROCESS_INIT
;
1420 strvec_pushl(&cp
.args
, "apply", "-R", NULL
);
1422 if (pipe_command(&cp
, patch
.buf
, patch
.len
, NULL
, 0, NULL
, 0)) {
1424 fprintf_ln(stderr
, _("Cannot remove "
1425 "worktree changes"));
1430 if (keep_index
< 1) {
1431 struct child_process cp
= CHILD_PROCESS_INIT
;
1434 strvec_pushl(&cp
.args
, "reset", "-q", "--", NULL
);
1435 add_pathspecs(&cp
.args
, ps
);
1436 if (run_command(&cp
)) {
1445 strbuf_release(&stash_msg_buf
);
1449 static int push_stash(int argc
, const char **argv
, const char *prefix
,
1452 int force_assume
= 0;
1453 int keep_index
= -1;
1455 int include_untracked
= 0;
1457 int pathspec_file_nul
= 0;
1458 const char *stash_msg
= NULL
;
1459 const char *pathspec_from_file
= NULL
;
1461 struct option options
[] = {
1462 OPT_BOOL('k', "keep-index", &keep_index
,
1464 OPT_BOOL('p', "patch", &patch_mode
,
1465 N_("stash in patch mode")),
1466 OPT__QUIET(&quiet
, N_("quiet mode")),
1467 OPT_BOOL('u', "include-untracked", &include_untracked
,
1468 N_("include untracked files in stash")),
1469 OPT_SET_INT('a', "all", &include_untracked
,
1470 N_("include ignore files"), 2),
1471 OPT_STRING('m', "message", &stash_msg
, N_("message"),
1472 N_("stash message")),
1473 OPT_PATHSPEC_FROM_FILE(&pathspec_from_file
),
1474 OPT_PATHSPEC_FILE_NUL(&pathspec_file_nul
),
1479 force_assume
= !strcmp(argv
[0], "-p");
1480 argc
= parse_options(argc
, argv
, prefix
, options
,
1481 git_stash_push_usage
,
1482 PARSE_OPT_KEEP_DASHDASH
);
1486 if (!strcmp(argv
[0], "--")) {
1489 } else if (push_assumed
&& !force_assume
) {
1490 die("subcommand wasn't specified; 'push' can't be assumed due to unexpected token '%s'",
1495 parse_pathspec(&ps
, 0, PATHSPEC_PREFER_FULL
| PATHSPEC_PREFIX_ORIGIN
,
1498 if (pathspec_from_file
) {
1500 die(_("--pathspec-from-file is incompatible with --patch"));
1503 die(_("--pathspec-from-file is incompatible with pathspec arguments"));
1505 parse_pathspec_file(&ps
, 0,
1506 PATHSPEC_PREFER_FULL
| PATHSPEC_PREFIX_ORIGIN
,
1507 prefix
, pathspec_from_file
, pathspec_file_nul
);
1508 } else if (pathspec_file_nul
) {
1509 die(_("--pathspec-file-nul requires --pathspec-from-file"));
1512 return do_push_stash(&ps
, stash_msg
, quiet
, keep_index
, patch_mode
,
1516 static int save_stash(int argc
, const char **argv
, const char *prefix
)
1518 int keep_index
= -1;
1520 int include_untracked
= 0;
1523 const char *stash_msg
= NULL
;
1525 struct strbuf stash_msg_buf
= STRBUF_INIT
;
1526 struct option options
[] = {
1527 OPT_BOOL('k', "keep-index", &keep_index
,
1529 OPT_BOOL('p', "patch", &patch_mode
,
1530 N_("stash in patch mode")),
1531 OPT__QUIET(&quiet
, N_("quiet mode")),
1532 OPT_BOOL('u', "include-untracked", &include_untracked
,
1533 N_("include untracked files in stash")),
1534 OPT_SET_INT('a', "all", &include_untracked
,
1535 N_("include ignore files"), 2),
1536 OPT_STRING('m', "message", &stash_msg
, "message",
1537 N_("stash message")),
1541 argc
= parse_options(argc
, argv
, prefix
, options
,
1542 git_stash_save_usage
,
1543 PARSE_OPT_KEEP_DASHDASH
);
1546 stash_msg
= strbuf_join_argv(&stash_msg_buf
, argc
, argv
, ' ');
1548 memset(&ps
, 0, sizeof(ps
));
1549 ret
= do_push_stash(&ps
, stash_msg
, quiet
, keep_index
,
1550 patch_mode
, include_untracked
);
1552 strbuf_release(&stash_msg_buf
);
1556 int cmd_stash(int argc
, const char **argv
, const char *prefix
)
1558 pid_t pid
= getpid();
1559 const char *index_file
;
1560 struct strvec args
= STRVEC_INIT
;
1562 struct option options
[] = {
1566 git_config(git_stash_config
, NULL
);
1568 if (use_legacy_stash
||
1569 !git_env_bool("GIT_TEST_STASH_USE_BUILTIN", -1))
1570 warning(_("the stash.useBuiltin support has been removed!\n"
1571 "See its entry in 'git help config' for details."));
1573 argc
= parse_options(argc
, argv
, prefix
, options
, git_stash_usage
,
1574 PARSE_OPT_KEEP_UNKNOWN
| PARSE_OPT_KEEP_DASHDASH
);
1576 index_file
= get_index_file();
1577 strbuf_addf(&stash_index_path
, "%s.stash.%" PRIuMAX
, index_file
,
1581 return !!push_stash(0, NULL
, prefix
, 0);
1582 else if (!strcmp(argv
[0], "apply"))
1583 return !!apply_stash(argc
, argv
, prefix
);
1584 else if (!strcmp(argv
[0], "clear"))
1585 return !!clear_stash(argc
, argv
, prefix
);
1586 else if (!strcmp(argv
[0], "drop"))
1587 return !!drop_stash(argc
, argv
, prefix
);
1588 else if (!strcmp(argv
[0], "pop"))
1589 return !!pop_stash(argc
, argv
, prefix
);
1590 else if (!strcmp(argv
[0], "branch"))
1591 return !!branch_stash(argc
, argv
, prefix
);
1592 else if (!strcmp(argv
[0], "list"))
1593 return !!list_stash(argc
, argv
, prefix
);
1594 else if (!strcmp(argv
[0], "show"))
1595 return !!show_stash(argc
, argv
, prefix
);
1596 else if (!strcmp(argv
[0], "store"))
1597 return !!store_stash(argc
, argv
, prefix
);
1598 else if (!strcmp(argv
[0], "create"))
1599 return !!create_stash(argc
, argv
, prefix
);
1600 else if (!strcmp(argv
[0], "push"))
1601 return !!push_stash(argc
, argv
, prefix
, 0);
1602 else if (!strcmp(argv
[0], "save"))
1603 return !!save_stash(argc
, argv
, prefix
);
1604 else if (*argv
[0] != '-')
1605 usage_msg_opt(xstrfmt(_("unknown subcommand: %s"), argv
[0]),
1606 git_stash_usage
, options
);
1608 /* Assume 'stash push' */
1609 strvec_push(&args
, "push");
1610 strvec_pushv(&args
, argv
);
1611 return !!push_stash(args
.nr
, args
.v
, prefix
, 1);