8 void free_worktrees(struct worktree
**worktrees
)
12 for (i
= 0; worktrees
[i
]; i
++) {
13 free(worktrees
[i
]->path
);
14 free(worktrees
[i
]->id
);
15 free(worktrees
[i
]->head_ref
);
22 * read 'path_to_ref' into 'ref'. Also if is_detached is not NULL,
23 * set is_detached to 1 (0) if the ref is detatched (is not detached).
25 * $GIT_COMMON_DIR/$symref (e.g. HEAD) is practically outside $GIT_DIR so
26 * for linked worktrees, `resolve_ref_unsafe()` won't work (it uses
27 * git_path). Parse the ref ourselves.
29 * return -1 if the ref is not a proper ref, 0 otherwise (success)
31 static int parse_ref(char *path_to_ref
, struct strbuf
*ref
, int *is_detached
)
35 if (!strbuf_readlink(ref
, path_to_ref
, 0)) {
36 /* HEAD is symbolic link */
37 if (!starts_with(ref
->buf
, "refs/") ||
38 check_refname_format(ref
->buf
, 0))
40 } else if (strbuf_read_file(ref
, path_to_ref
, 0) >= 0) {
41 /* textual symref or detached */
42 if (!starts_with(ref
->buf
, "ref:")) {
46 strbuf_remove(ref
, 0, strlen("ref:"));
48 if (check_refname_format(ref
->buf
, 0))
57 * Add the head_sha1 and head_ref (if not detached) to the given worktree
59 static void add_head_info(struct strbuf
*head_ref
, struct worktree
*worktree
)
62 if (worktree
->is_detached
) {
63 get_sha1_hex(head_ref
->buf
, worktree
->head_sha1
);
65 resolve_ref_unsafe(head_ref
->buf
, 0, worktree
->head_sha1
, NULL
);
66 worktree
->head_ref
= strbuf_detach(head_ref
, NULL
);
72 * get the main worktree
74 static struct worktree
*get_main_worktree(void)
76 struct worktree
*worktree
= NULL
;
77 struct strbuf path
= STRBUF_INIT
;
78 struct strbuf worktree_path
= STRBUF_INIT
;
79 struct strbuf head_ref
= STRBUF_INIT
;
83 strbuf_addstr(&worktree_path
, absolute_path(get_git_common_dir()));
84 is_bare
= !strbuf_strip_suffix(&worktree_path
, "/.git");
86 strbuf_strip_suffix(&worktree_path
, "/.");
88 strbuf_addf(&path
, "%s/HEAD", get_git_common_dir());
90 if (parse_ref(path
.buf
, &head_ref
, &is_detached
) < 0)
93 worktree
= xmalloc(sizeof(struct worktree
));
94 worktree
->path
= strbuf_detach(&worktree_path
, NULL
);
96 worktree
->is_bare
= is_bare
;
97 worktree
->head_ref
= NULL
;
98 worktree
->is_detached
= is_detached
;
99 worktree
->is_current
= 0;
100 add_head_info(&head_ref
, worktree
);
103 strbuf_release(&path
);
104 strbuf_release(&worktree_path
);
105 strbuf_release(&head_ref
);
109 static struct worktree
*get_linked_worktree(const char *id
)
111 struct worktree
*worktree
= NULL
;
112 struct strbuf path
= STRBUF_INIT
;
113 struct strbuf worktree_path
= STRBUF_INIT
;
114 struct strbuf head_ref
= STRBUF_INIT
;
118 die("Missing linked worktree name");
120 strbuf_git_common_path(&path
, "worktrees/%s/gitdir", id
);
121 if (strbuf_read_file(&worktree_path
, path
.buf
, 0) <= 0)
122 /* invalid gitdir file */
125 strbuf_rtrim(&worktree_path
);
126 if (!strbuf_strip_suffix(&worktree_path
, "/.git")) {
127 strbuf_reset(&worktree_path
);
128 strbuf_addstr(&worktree_path
, absolute_path("."));
129 strbuf_strip_suffix(&worktree_path
, "/.");
133 strbuf_addf(&path
, "%s/worktrees/%s/HEAD", get_git_common_dir(), id
);
135 if (parse_ref(path
.buf
, &head_ref
, &is_detached
) < 0)
138 worktree
= xmalloc(sizeof(struct worktree
));
139 worktree
->path
= strbuf_detach(&worktree_path
, NULL
);
140 worktree
->id
= xstrdup(id
);
141 worktree
->is_bare
= 0;
142 worktree
->head_ref
= NULL
;
143 worktree
->is_detached
= is_detached
;
144 worktree
->is_current
= 0;
145 add_head_info(&head_ref
, worktree
);
148 strbuf_release(&path
);
149 strbuf_release(&worktree_path
);
150 strbuf_release(&head_ref
);
154 static void mark_current_worktree(struct worktree
**worktrees
)
156 char *git_dir
= xstrdup(absolute_path(get_git_dir()));
159 for (i
= 0; worktrees
[i
]; i
++) {
160 struct worktree
*wt
= worktrees
[i
];
161 const char *wt_git_dir
= get_worktree_git_dir(wt
);
163 if (!fspathcmp(git_dir
, absolute_path(wt_git_dir
))) {
171 struct worktree
**get_worktrees(void)
173 struct worktree
**list
= NULL
;
174 struct strbuf path
= STRBUF_INIT
;
177 int counter
= 0, alloc
= 2;
179 list
= xmalloc(alloc
* sizeof(struct worktree
*));
181 if ((list
[counter
] = get_main_worktree()))
184 strbuf_addf(&path
, "%s/worktrees", get_git_common_dir());
185 dir
= opendir(path
.buf
);
186 strbuf_release(&path
);
188 while ((d
= readdir(dir
)) != NULL
) {
189 struct worktree
*linked
= NULL
;
190 if (is_dot_or_dotdot(d
->d_name
))
193 if ((linked
= get_linked_worktree(d
->d_name
))) {
194 ALLOC_GROW(list
, counter
+ 1, alloc
);
195 list
[counter
++] = linked
;
200 ALLOC_GROW(list
, counter
+ 1, alloc
);
201 list
[counter
] = NULL
;
203 mark_current_worktree(list
);
207 const char *get_worktree_git_dir(const struct worktree
*wt
)
210 return get_git_dir();
212 return get_git_common_dir();
214 return git_common_path("worktrees/%s", wt
->id
);
217 struct worktree
*find_worktree(struct worktree
**list
,
223 arg
= prefix_filename(prefix
, strlen(prefix
), arg
);
224 path
= xstrdup(real_path(arg
));
225 for (; *list
; list
++)
226 if (!fspathcmp(path
, real_path((*list
)->path
)))
232 int is_main_worktree(const struct worktree
*wt
)
237 int is_worktree_being_rebased(const struct worktree
*wt
,
240 struct wt_status_state state
;
243 memset(&state
, 0, sizeof(state
));
244 found_rebase
= wt_status_check_rebase(wt
, &state
) &&
245 ((state
.rebase_in_progress
||
246 state
.rebase_interactive_in_progress
) &&
248 starts_with(target
, "refs/heads/") &&
249 !strcmp(state
.branch
, target
+ strlen("refs/heads/")));
255 int is_worktree_being_bisected(const struct worktree
*wt
,
258 struct wt_status_state state
;
261 memset(&state
, 0, sizeof(state
));
262 found_rebase
= wt_status_check_bisect(wt
, &state
) &&
264 starts_with(target
, "refs/heads/") &&
265 !strcmp(state
.branch
, target
+ strlen("refs/heads/"));
271 * note: this function should be able to detect shared symref even if
272 * HEAD is temporarily detached (e.g. in the middle of rebase or
273 * bisect). New commands that do similar things should update this
276 const struct worktree
*find_shared_symref(const char *symref
,
279 const struct worktree
*existing
= NULL
;
280 struct strbuf path
= STRBUF_INIT
;
281 struct strbuf sb
= STRBUF_INIT
;
282 static struct worktree
**worktrees
;
286 free_worktrees(worktrees
);
287 worktrees
= get_worktrees();
289 for (i
= 0; worktrees
[i
]; i
++) {
290 struct worktree
*wt
= worktrees
[i
];
292 if (wt
->is_detached
&& !strcmp(symref
, "HEAD")) {
293 if (is_worktree_being_rebased(wt
, target
)) {
297 if (is_worktree_being_bisected(wt
, target
)) {
305 strbuf_addf(&path
, "%s/%s",
306 get_worktree_git_dir(wt
),
309 if (parse_ref(path
.buf
, &sb
, NULL
)) {
313 if (!strcmp(sb
.buf
, target
)) {
319 strbuf_release(&path
);