if (pos >= 0) {

if (S_ISGITLINK(istate->cache[pos]->ce_mode))

mode = istate->cache[pos]->ce_mode;

mode = S_IFGITLINK;

}

}

} else if (remote_head) {

our_head_points_at = NULL;

} else {

const char *branch;

if (!mapped_refs) {

"refs/heads/", &branch)) {

unborn_head = xstrdup(transport_ls_refs_options.unborn_head_target);

} else {

unborn_head = xstrfmt("refs/heads/%s", branch);

}

* a match.

*/

our_head_points_at = find_remote_branch(mapped_refs, branch);

}

write_refspec_config(src_ref_prefix, our_head_points_at,

}

/* Is it annotated? */

is_annotated = !oideq(oid, &peeled);

} else {

oidcpy(&peeled, oid);

_("(none)"), ref->name,

&ref->new_oid, &ref->old_oid,

summary_width);

}

}

struct commit_list *stack = NULL;

struct commit *commit;

oid = &peeled;

if (oid_object_info(the_repository, oid, NULL) != OBJ_COMMIT)

return 0;

if (entry)

entry->tagged = 1;

entry = packlist_find(&to_pack, &peeled);

if (entry)

entry->tagged = 1;

{

struct object_id peeled;

add_tag_chain(oid);

return 0;

}

struct object_id peeled;

struct object *object;

oid = &peeled;

object = parse_object_or_die(oid, refname);

char *ref;

struct expire_reflog_policy_cb cb = { .cmd = cmd };

status |= error(_("%s points nowhere!"), argv[i]);

continue;

}

abbrev_ref(refname, "refs/remotes/"));

}

string_list_clear(&refs_to_prune, 0);

free_remote_ref_states(&states);

struct midx_snapshot_ref_data *data = _data;

struct object_id peeled;

oid = &peeled;

if (oidset_insert(&data->seen, oid))

};

struct show_data {

const char *pattern;

enum replace_format format;

};

const struct object_id *oid,

int flag UNUSED, void *cb_data)

{

struct object_id object;

enum object_type obj_type, repl_type;

return error(_("failed to resolve '%s' as a valid ref"), refname);

printf("%s (%s) -> %s (%s)\n", refname, type_name(obj_type),

oid_to_hex(oid), type_name(repl_type));

{

struct show_data data;

if (!pattern)

pattern = "*";

data.pattern = pattern;

"valid formats are 'short', 'medium' and 'long'"),

format);

return 0;

}

if (!opts->deref_tags)

return;

hex = repo_find_unique_abbrev(the_repository, &peeled, opts->abbrev);

printf("%s %s^{}\n", hex, refname);

}

displaypath);

} else if (!(flags & OPT_CACHED)) {

struct object_id oid;

if (!refs) {

print_status(flags, '-', path, ce_oid, displaypath);

if (!info->cached && oideq(&p->oid_dst, null_oid())) {

if (S_ISGITLINK(p->mod_dst)) {

if (refs)

refs_head_ref(refs, handle_submodule_head_ref, &p->oid_dst);

if (update_data->just_cloned)

oidcpy(&update_data->suboid, null_oid());

return die_message(_("Unable to find current revision in submodule path '%s'"),

update_data->displaypath);

update_data->sm_path);

}

return die_message(_("Unable to find %s revision in submodule path '%s'"),

remote_ref, update_data->sm_path);

strbuf_addstr(&sb, path);

if (is_nonbare_repository_dir(&sb)) {

struct object_id oid;

die(_("'%s' does not have a commit checked out"), path);

}

strbuf_release(&sb);

if (S_ISGITLINK(ce->ce_mode)) {

/* Do nothing to the index if there is no HEAD! */

return 0;

return add_one_path(ce, path, len, st);

}

/* No match - should we add it as a gitlink? */

return add_one_path(NULL, path, len, st);

/* Error out. */

static char *default_branch(int ident_flag UNUSED)

{

}

static char *shell_path(int ident_flag UNUSED)

}

wt_refs = get_worktree_ref_store(wt);

if (ret)

goto done;

elem->mode = canon_mode(st.st_mode);

} else if (S_ISDIR(st.st_mode)) {

struct object_id oid;

result = grab_blob(opt->repo, &elem->oid,

elem->mode, &result_size,

NULL, NULL);

struct object_id peeled;

struct refs_cb_data *data = (struct refs_cb_data *)cb_data;

oid = &peeled;

if (oid_object_info(the_repository, oid, NULL) == OBJ_COMMIT)

oidset_insert(data->commits, oid);

* a directory --- the blob was removed!

*/

if (!S_ISGITLINK(ce->ce_mode) &&

return 1;

}

return 0;

struct object_id submodule_head;

if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&

/* Do not descend and nuke a nested git work tree. */

if (kept_up)

*kept_up = 1;

if (data->peel && oid) {

struct object_id peeled;

strbuf_addf(&data->buf, " peeled:%s", oid_to_hex(&peeled));

}

return 0;

}

oid = &peeled;

object = parse_object_or_die(oid, refname);

strbuf_release(&sb);

break;

case S_IFDIR:

default:

return error(_("%s: unsupported file type"), path);

}

}

}

struct object *parse_object_buffer(struct repository *r, const struct object_id *oid, enum object_type type, unsigned long size, void *buffer, int *eaten_p)

{

struct object *obj;

struct object *lookup_object_by_type(struct repository *r, const struct object_id *oid,

enum object_type type);

struct object_list *object_list_insert(struct object *item,

struct object_list **list_p);

*

* If so, we consider it always to match.

*/

return 0;

return !oideq(&oid, &ce->oid);

}

namelen = strlen(path);

if (S_ISDIR(st_mode)) {

return error(_("'%s' does not have a commit checked out"), path);

while (namelen && path[namelen-1] == '/')

namelen--;

* If it is a tag object, see if we use the peeled value. If we do,

* grab the peeled OID.

*/

die("bad tag");

return get_object(ref, 1, &obj, &oi_deref, err);

reflogs = read_complete_reflog(branch);

if (!reflogs || reflogs->nr == 0) {

char *b;

if (ret > 1)

free(b);

else if (ret == 1) {

if (!spec)

return error(_("not a reflog: %s"), rev);

status |= error(_("no reflog for '%s'"), rev);

goto cleanup;

}

#include "advice.h"

#include "config.h"

#include "environment.h"

#include "gettext.h"

#include "hex.h"

#include "lockfile.h"

#include "object-store-ll.h"

#include "object.h"

#include "path.h"

#include "submodule.h"

#include "worktree.h"

#include "strvec.h"

return filter->fn(refname, oid, flags, filter->cb_data);

}

struct warn_if_dangling_data {

FILE *fp;

const char *refname;

const struct string_list *refnames;

if (!(flags & REF_ISSYMREF))

return 0;

if (!resolves_to

|| (d->refname

? strcmp(resolves_to, d->refname)

return 0;

}

{

}

{

}

int refs_for_each_tag_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)

return ret;

}

/*

* *string and *len will only be substituted, and *string returned (for

* later free()ing) if the string passed in is a magic short-hand form

return logs_found;

}

int is_per_worktree_ref(const char *refname)

{

return starts_with(refname, "refs/worktree/") ||

return iter;

}

static int do_for_each_ref(struct ref_store *refs, const char *prefix,

const char **exclude_patterns,

each_ref_fn fn, int trim,

enum do_for_each_ref_flags flags, void *cb_data)

{

struct ref_iterator *iter;

if (!refs)

return 0;

iter = refs_ref_iterator_begin(refs, prefix, exclude_patterns, trim,

flags);

}

int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)

return do_for_each_ref(refs, prefix, exclude_patterns, fn, 0, 0, cb_data);

}

{

const char *git_replace_ref_base = ref_namespace[NAMESPACE_REPLACE].ref;

}

int refs_for_each_namespaced_ref(struct ref_store *refs,

}

/* backend functions */

{

}

{

struct ref_store *refs;

int flags;

if (!refs)

return -1;

return 0;

}

/*

* Look up a ref store by name. If that ref_store hasn't been

* registered yet, return NULL.

*/

const char *name)

{

/* It's initialized on demand in register_ref_store(). */

return NULL;

}

/*

return refs;

}

struct ref_store *get_main_ref_store(struct repository *r)

{

if (r->refs_private)

* Associate a ref store with a name. It is a fatal error to call this

* function twice for the same name.

*/

const char *type,

struct ref_store *refs,

const char *name)

{

BUG("%s ref_store '%s' initialized twice", type, name);

}

{

struct strbuf submodule_sb = STRBUF_INIT;

struct ref_store *refs;

/* We need to strip off one or more trailing slashes */

submodule = to_free = xmemdupz(submodule, len);

if (refs)

goto done;

goto done;

subrepo = xmalloc(sizeof(*subrepo));

null_oid())) {

free(subrepo);

goto done;

}

refs = ref_store_init(subrepo, submodule_sb.buf,

REF_STORE_READ | REF_STORE_ODB);

refs, submodule);

done:

const char *id;

if (wt->is_current)

id = wt->id ? wt->id : "/";

if (refs)

return refs;

REF_STORE_ALL_CAPS);

REF_STORE_ALL_CAPS);

if (refs)

return refs;

}

return refs->be->pack_refs(refs, opts);

}

{

if (current_ref_iter &&

(current_ref_iter->oid == base ||

oideq(current_ref_iter->oid, base)))

return ref_iterator_peel(current_ref_iter, peeled);

}

int refs_update_symref(struct ref_store *refs, const char *ref,

void *cb_data;

};

const struct object_id *oid UNUSED,

int flags,

void *cb_data)

iter = refs->be->reflog_iterator_begin(refs);

}

int refs_for_each_reflog_ent_reverse(struct ref_store *refs,

int is_branch(const char *refname);

/*

* Return the peeled value of the oid currently being iterated via

* for_each_ref(), etc. This is equivalent to calling:

*

*

* with the "oid" value given to the each_ref_fn callback, except

* that some ref storage may be able to answer the query without

* actually loading the object in memory.

*/

/**

* Resolve refname in the nested "gitlink" repository in the specified

* successful, return 0 and set oid to the name of the object;

* otherwise, return a non-zero value.

*/

/*

* Return true iff abbrev_name is a possible abbreviation for

int repo_dwim_ref(struct repository *r, const char *str, int len,

struct object_id *oid, char **ref, int nonfatal_dangling_mark);

int repo_dwim_log(struct repository *r, const char *str, int len, struct object_id *oid, char **ref);

/*

* Retrieves the default branch name for newly-initialized repositories.

*

*/

char *repo_default_branch_name(struct repository *r, int quiet);

/*

const struct object_id *oid, int flags, void *cb_data);

/*

* The following functions invoke the specified callback function for

* each reference indicated. If the function ever returns a nonzero

* value, stop the iteration and return that value. Please note that

each_ref_fn fn, void *cb_data);

int refs_for_each_remote_ref(struct ref_store *refs,

each_ref_fn fn, void *cb_data);

/*

* references matching any pattern in "exclude_patterns" are omitted from the

const char **exclude_patterns,

each_ref_fn fn, void *cb_data);

/* iterates all refs that match the specified glob pattern. */

int refs_for_each_glob_ref(struct ref_store *refs, each_ref_fn fn,

const char *pattern, void *cb_data);

return strpbrk(pattern, "?*[");

}

/*

* Flags for controlling behaviour of pack_refs()

* For backwards compatibility, submodule=="" is treated the same as

* submodule==NULL.

*/

struct ref_store *get_worktree_ref_store(const struct worktree *wt);

/*

return (struct ref_store *)res;

}

{

struct debug_ref_store *drefs = (struct debug_ref_store *)refs;

return res;

}

struct ref_storage_be refs_be_debug = {

.name = "debug",

.init = NULL,

/*

* None of these should be NULL. If the "files" backend (in

* Create a new submodule ref cache and add it to the internal

* set of caches.

*/

{

struct files_ref_store *refs = xcalloc(1, sizeof(*refs));

struct ref_store *ref_store = (struct ref_store *)refs;

get_common_dir_noenv(&sb, gitdir);

refs->gitcommondir = strbuf_detach(&sb, NULL);

refs->packed_ref_store =

chdir_notify_reparent("files-backend $GIT_DIR", &refs->base.gitdir);

chdir_notify_reparent("files-backend $GIT_COMMONDIR",

return refs;

}

static void files_reflog_path(struct files_ref_store *refs,

struct strbuf *sb,

const char *refname)

/*

* Return true if the specified reference should be packed.

*/

const struct object_id *oid, unsigned int ref_flags,

struct pack_refs_opts *opts)

{

return 0;

/* Do not pack broken refs: */

return 0;

if (ref_excluded(opts->exclusions, refname))

packed_refs_lock(refs->packed_ref_store, LOCK_DIE_ON_ERROR, &err);

iter = cache_ref_iterator_begin(get_loose_ref_cache(refs, 0), NULL,

while ((ok = ref_iterator_advance(iter)) == ITER_OK) {

/*

* If the loose reference can be packed, add an entry

* in the packed ref cache. If the reference should be

* pruned, also add it to refs_to_prune.

*/

continue;

/*

return ret;

}

const struct object_id *oid,

int skip_oid_verification, struct strbuf *err);

static int commit_ref_update(struct files_ref_store *refs,

}

oidcpy(&lock->old_oid, &orig_oid);

commit_ref_update(refs, lock, &orig_oid, logmsg, &err)) {

error("unable to write current sha1 into %s: %s", newrefname, err.buf);

strbuf_release(&err);

flag = log_all_ref_updates;

log_all_ref_updates = LOG_REFS_NONE;

commit_ref_update(refs, lock, &orig_oid, NULL, &err)) {

error("unable to write current sha1 into %s: %s", oldrefname, err.buf);

strbuf_release(&err);

* Write oid into the open lockfile, then close the lockfile. On

* errors, rollback the lockfile, fill in *err and return -1.

*/

const struct object_id *oid,

int skip_oid_verification, struct strbuf *err)

{

int fd;

if (!skip_oid_verification) {

if (!o) {

strbuf_addf(

err,

}

}

fd = get_lock_file_fd(&lock->lk);

write_in_full(fd, &term, 1) < 0 ||

fsync_component(FSYNC_COMPONENT_REFERENCE, get_lock_file_fd(&lock->lk)) < 0 ||

close_ref_gently(lock) < 0) {

* value, so we don't need to write it.

*/

} else if (write_ref_to_lockfile(

update->flags & REF_SKIP_OID_VERIFICATION,

err)) {

char *write_err = strbuf_detach(err, NULL);

rollback_lock_file(&reflog_lock);

} else if (update &&

(write_in_full(get_lock_file_fd(&lock->lk),

write_str_in_full(get_lock_file_fd(&lock->lk), "\n") < 0 ||

close_ref_gently(lock) < 0)) {

status |= error("couldn't write %s",

return -1;

}

{

struct files_ref_store *refs =

struct strbuf sb = STRBUF_INIT;

/*

* There is no need to create directories for common refs when creating

* a worktree ref store.

*/

/*

* Create .git/refs/{heads,tags}

*/

struct ref_storage_be refs_be_files = {

.name = "files",

.transaction_prepare = files_transaction_prepare,

.transaction_finish = files_transaction_finish,

.transaction_abort = files_transaction_abort,

struct ref_iterator *current_ref_iter = NULL;

{

int retval = 0, ok;

struct ref_iterator *old_ref_iter = current_ref_iter;

current_ref_iter = iter;

while ((ok = ref_iterator_advance(iter)) == ITER_OK) {

if (retval) {

/*

* If ref_iterator_abort() returns ITER_ERROR,

}

}

{

struct packed_ref_store *refs = xcalloc(1, sizeof(*refs));

struct ref_store *ref_store = (struct ref_store *)refs;

}

}

static NORETURN void die_unterminated_line(const char *path,

const char *p, size_t len)

{

size_t len;

};

{

const struct snapshot_record *e1 = v1, *e2 = v2;

while (1) {

if (*r1 == '\n')

* refname.

*/

static int cmp_record_to_refname(const char *rec, const char *refname,

{

const char *r2 = refname;

while (1) {

if (!eol)

/* The safety check should prevent this. */

BUG("unterminated line found in packed-refs");

die_invalid_line(snapshot->refs->path,

pos, eof - pos);

eol++;

if (sorted &&

nr > 1 &&

cmp_packed_ref_records(&records[nr - 2],

sorted = 0;

pos = eol;

goto cleanup;

/* We need to sort the memory. First we sort the records array: */

/*

* Allocate a new chunk of memory, and copy the old memory to

return;

last_line = find_start_of_record(start, eof - 1);

die_invalid_line(snapshot->refs->path,

last_line, eof - last_line);

}

mid = lo + (hi - lo) / 2;

rec = find_start_of_record(lo, mid);

if (cmp < 0) {

lo = find_end_of_record(mid, hi);

} else if (cmp > 0) {

iter->base.flags = REF_ISPACKED;

p = iter->pos;

parse_oid_hex(p, &iter->oid, &p) ||

!isspace(*p++))

die_invalid_line(iter->snapshot->refs->path,

if (iter->pos < iter->eof && *iter->pos == '^') {

p = iter->pos + 1;

parse_oid_hex(p, &iter->peeled, &p) ||

*p++ != '\n')

die_invalid_line(iter->snapshot->refs->path,

struct packed_ref_iterator *iter =

(struct packed_ref_iterator *)ref_iterator;

if ((iter->base.flags & REF_KNOWS_PEELED)) {

oidcpy(peeled, &iter->peeled);

return is_null_oid(&iter->peeled) ? -1 : 0;

} else if ((iter->base.flags & (REF_ISBROKEN | REF_ISSYMREF))) {

return -1;

} else {

}

}

static const char PACKED_REFS_HEADER[] =

"# pack-refs with: peeled fully-peeled sorted \n";

{

/* Nothing to do. */

return 0;

i++;

} else {

struct object_id peeled;

&peeled);

if (write_packed_entry(out, update->refname,

struct ref_storage_be refs_be_packed = {

.name = "packed",

.transaction_prepare = packed_transaction_prepare,

.transaction_finish = packed_transaction_finish,

.transaction_abort = packed_transaction_abort,

* even among packed refs.

*/

/*

* Lock the packed-refs file for writing. Flags is passed to

{

struct cache_ref_iterator *iter =

(struct cache_ref_iterator *)ref_iterator;

}

static int cache_ref_iterator_abort(struct ref_iterator *ref_iterator)

const struct object_id *oid,

unsigned int flags);

/**

* Information needed for a single ref update. Set new_oid to the new

* value or to null_oid to delete the ref. To check the old value

* adapter between the callback style of reference iteration and the

* iterator style.

*/

struct ref_store;

typedef struct ref_store *ref_store_init_fn(struct repository *repo,

const char *gitdir,

unsigned int flags);

typedef int ref_transaction_prepare_fn(struct ref_store *refs,

struct ref_transaction *transaction,

struct ref_storage_be {

const char *name;

ref_store_init_fn *init;

ref_transaction_prepare_fn *transaction_prepare;

ref_transaction_finish_fn *transaction_finish;

/*

* A representation of the reference store for the main repository or

* a submodule. The ref_store instances for submodules are kept in a

*/

struct ref_store {

/* The backend describing this ref_store's storage scheme: */

return &refs->base;

}

{

struct reftable_ref_store *refs =

struct strbuf sb = STRBUF_INIT;

strbuf_addf(&sb, "%s/reftable", refs->base.gitdir);

ref.refname = (char *)u->refname;

ref.update_index = ts;

if (!peel_error) {

ref.value_type = REFTABLE_REF_VAL2;

memcpy(ref.value.val2.target_value, peeled.hash, GIT_MAX_RAWSZ);

}

struct reflog_expiry_arg {

struct reftable_stack *stack;

struct reftable_log_record *records;

struct object_id update_oid;

ref.refname = (char *)arg->refname;

ref.update_index = ts;

ref.value_type = REFTABLE_REF_VAL2;

memcpy(ref.value.val2.target_value, peeled.hash, GIT_MAX_RAWSZ);

memcpy(ref.value.val2.value, arg->update_oid.hash, GIT_MAX_RAWSZ);

reftable_ref_record_val1(&ref_record))

oidread(&arg.update_oid, last_hash);

arg.records = rewritten;

arg.len = logs_nr;

arg.stack = stack,

struct ref_storage_be refs_be_reftable = {

.name = "reftable",

.init = reftable_be_init,

.transaction_prepare = reftable_be_transaction_prepare,

.transaction_finish = reftable_be_transaction_finish,

.transaction_abort = reftable_be_transaction_abort,

static void read_branches_file(struct remote_state *remote_state,

struct remote *remote)

{

struct strbuf buf = STRBUF_INIT;

FILE *f = fopen_or_warn(git_path("branches/%s", remote->name), "r");

if (frag)

*(frag++) = '\0';

else

add_url_alias(remote_state, remote, strbuf_detach(&buf, NULL));

refspec_appendf(&remote->fetch, "refs/heads/%s:refs/heads/%s",

*/

refspec_appendf(&remote->push, "HEAD:refs/heads/%s", frag);

remote->fetch_tags = 1; /* always auto-follow */

}

static int handle_config(const char *key, const char *value,

/* If a remote branch exists with the default branch name, let's use it. */

if (!all) {

r = find_ref_by_name(refs, ref);

free(ref);

if (r && oideq(&r->old_oid, &head->old_oid))

return copy_ref(r);

#include "repository.h"

#include "commit.h"

const struct object_id *oid,

int flag UNUSED,

{

/* Get sha1 from refname */

const char *slash = strrchr(refname, '/');

const char *hash = slash ? slash + 1 : refname;

xmalloc(sizeof(*r->objects->replace_map));

oidmap_init(r->objects->replace_map, 0);

r->objects->replace_map_initialized = 1;

pthread_mutex_unlock(&r->objects->replace_mutex);

#include "sparse-index.h"

#include "trace2.h"

#include "promisor-remote.h"

/* The main repository */

static struct repository the_repo;

void repo_clear(struct repository *repo)

{

FREE_AND_NULL(repo->gitdir);

FREE_AND_NULL(repo->commondir);

FREE_AND_NULL(repo->graft_file);

FREE_AND_NULL(repo->remote_state);

}

repo_clear_path_cache(&repo->cached_paths);

}

#ifndef REPOSITORY_H

#define REPOSITORY_H

struct config_set;

struct fsmonitor_settings;

struct git_hash_algo;

struct ref_store *refs_private;

/*

* Contains path to often used file names.

*/

struct repo_path_cache cached_paths;

const char *initial_branch, int quiet)

{

struct strbuf err = STRBUF_INIT;

int reinit = is_reinit();

repo_set_ref_storage_format(the_repository, ref_storage_format);

die("failed to set up refs db: %s", err.buf);

/*

char *ref;

if (!initial_branch)

ref = xstrfmt("refs/heads/%s", initial_branch);

if (check_refname_format(ref, 0) < 0)

initial_branch);

strbuf_release(&err);

}

static int create_default_files(const char *template_path,

static int for_each_remote_ref_submodule(const char *submodule,

each_ref_fn fn, void *cb_data)

{

fn, cb_data);

}

die("failed to resolve %s", buf.buf + 2);

orig = parse_object(r, &oid);

if (!peeled)

die("failed to load commit for input %s resulting in oid %s\n",

add_to_alternates_memory(sb.buf);

strbuf_release(&sb);

} else if (skip_prefix(argv[0], "worktree:", &gitdir)) {

struct worktree **p, **worktrees = get_worktrees();

return o;

}

{

while (o && o->type == OBJ_TAG) {

if (o && o->type == OBJ_TAG && ((struct tag *)o)->tagged)

o = ((struct tag *)o)->tagged;

else

int parse_tag(struct tag *item);

void release_tag_memory(struct tag *t);

struct object *deref_tag(struct repository *r, struct object *, const char *, int);

int gpg_verify_tag(const struct object_id *oid,

const char *name_to_report, unsigned flags);

struct object_id *get_tagged_oid(struct tag *tag);

if (S_ISGITLINK(ce->ce_mode)) {

struct object_id oid;

/*

* If we are not going to update the submodule, then

* we don't care.

packet_fwrite_fmt(stdout, "%s %s\n", oid_to_hex(oid), refname_nons);

}

capabilities = NULL;

packet_fwrite_fmt(stdout, "%s %s^{}\n", oid_to_hex(&peeled), refname_nons);

return;

}

strbuf_strip_suffix(&worktree_path, "/.git");

CALLOC_ARRAY(worktree, 1);

worktree->path = strbuf_detach(&worktree_path, NULL);

/*

* NEEDSWORK: If this function is called from a secondary worktree and

strbuf_strip_suffix(&worktree_path, "/.git");

CALLOC_ARRAY(worktree, 1);

worktree->path = strbuf_detach(&worktree_path, NULL);

worktree->id = xstrdup(id);

if (!skip_reading_head)

struct strbuf;

struct worktree {

char *path;

char *id;

char *head_ref; /* NULL if HEAD is broken or detached */