Andrew's git / gitweb.git /
0efbd4fb0d33119aa17fe98a5458be2d3ea7666d
   1#ifndef PATH_H
   2#define PATH_H
   3
   4struct repository;
   5struct strbuf;
   6
   7/*
   8 * The result to all functions which return statically allocated memory may be
   9 * overwritten by another call to _any_ one of these functions. Consider using
  10 * the safer variants which operate on strbufs or return allocated memory.
  11 */
  12
  13/*
  14 * Return a statically allocated path.
  15 */
  16const char *mkpath(const char *fmt, ...)
  17        __attribute__((format (printf, 1, 2)));
  18
  19/*
  20 * Return a path.
  21 */
  22char *mkpathdup(const char *fmt, ...)
  23        __attribute__((format (printf, 1, 2)));
  24
  25/*
  26 * Construct a path and place the result in the provided buffer `buf`.
  27 */
  28char *mksnpath(char *buf, size_t n, const char *fmt, ...)
  29        __attribute__((format (printf, 3, 4)));
  30
  31/*
  32 * The `git_common_path` family of functions will construct a path into a
  33 * repository's common git directory, which is shared by all worktrees.
  34 */
  35
  36/*
  37 * Constructs a path into the common git directory of repository `repo` and
  38 * append it in the provided buffer `sb`.
  39 */
  40void strbuf_git_common_path(struct strbuf *sb,
  41                                   const struct repository *repo,
  42                                   const char *fmt, ...)
  43        __attribute__((format (printf, 3, 4)));
  44
  45/*
  46 * Return a statically allocated path into the main repository's
  47 * (the_repository) common git directory.
  48 */
  49const char *git_common_path(const char *fmt, ...)
  50        __attribute__((format (printf, 1, 2)));
  51
  52
  53/*
  54 * The `git_path` family of functions will construct a path into a repository's
  55 * git directory.
  56 *
  57 * These functions will perform adjustments to the resultant path to account
  58 * for special paths which are either considered common among worktrees (e.g.
  59 * paths into the object directory) or have been explicitly set via an
  60 * environment variable or config (e.g. path to the index file).
  61 *
  62 * For an exhaustive list of the adjustments made look at `common_list` and
  63 * `adjust_git_path` in path.c.
  64 */
  65
  66/*
  67 * Return a path into the git directory of repository `repo`.
  68 */
  69char *repo_git_path(const struct repository *repo,
  70                           const char *fmt, ...)
  71        __attribute__((format (printf, 2, 3)));
  72
  73/*
  74 * Construct a path into the git directory of repository `repo` and append it
  75 * to the provided buffer `sb`.
  76 */
  77void strbuf_repo_git_path(struct strbuf *sb,
  78                                 const struct repository *repo,
  79                                 const char *fmt, ...)
  80        __attribute__((format (printf, 3, 4)));
  81
  82/*
  83 * Return a statically allocated path into the main repository's
  84 * (the_repository) git directory.
  85 */
  86const char *git_path(const char *fmt, ...)
  87        __attribute__((format (printf, 1, 2)));
  88
  89/*
  90 * Return a path into the main repository's (the_repository) git directory.
  91 */
  92char *git_pathdup(const char *fmt, ...)
  93        __attribute__((format (printf, 1, 2)));
  94
  95/*
  96 * Construct a path into the main repository's (the_repository) git directory
  97 * and place it in the provided buffer `buf`, the contents of the buffer will
  98 * be overridden.
  99 */
 100char *git_path_buf(struct strbuf *buf, const char *fmt, ...)
 101        __attribute__((format (printf, 2, 3)));
 102
 103/*
 104 * Construct a path into the main repository's (the_repository) git directory
 105 * and append it to the provided buffer `sb`.
 106 */
 107void strbuf_git_path(struct strbuf *sb, const char *fmt, ...)
 108        __attribute__((format (printf, 2, 3)));
 109
 110/*
 111 * Return a path into the worktree of repository `repo`.
 112 *
 113 * If the repository doesn't have a worktree NULL is returned.
 114 */
 115char *repo_worktree_path(const struct repository *repo,
 116                                const char *fmt, ...)
 117        __attribute__((format (printf, 2, 3)));
 118
 119/*
 120 * Construct a path into the worktree of repository `repo` and append it
 121 * to the provided buffer `sb`.
 122 *
 123 * If the repository doesn't have a worktree nothing will be appended to `sb`.
 124 */
 125void strbuf_repo_worktree_path(struct strbuf *sb,
 126                                      const struct repository *repo,
 127                                      const char *fmt, ...)
 128        __attribute__((format (printf, 3, 4)));
 129
 130/*
 131 * Return a path into a submodule's git directory located at `path`.  `path`
 132 * must only reference a submodule of the main repository (the_repository).
 133 */
 134char *git_pathdup_submodule(const char *path, const char *fmt, ...)
 135        __attribute__((format (printf, 2, 3)));
 136
 137/*
 138 * Construct a path into a submodule's git directory located at `path` and
 139 * append it to the provided buffer `sb`.  `path` must only reference a
 140 * submodule of the main repository (the_repository).
 141 */
 142int strbuf_git_path_submodule(struct strbuf *sb, const char *path,
 143                                     const char *fmt, ...)
 144        __attribute__((format (printf, 3, 4)));
 145
 146void report_linked_checkout_garbage(void);
 147
 148/*
 149 * You can define a static memoized git path like:
 150 *
 151 *    static GIT_PATH_FUNC(git_path_foo, "FOO")
 152 *
 153 * or use one of the global ones below.
 154 */
 155#define GIT_PATH_FUNC(func, filename) \
 156        const char *func(void) \
 157        { \
 158                static char *ret; \
 159                if (!ret) \
 160                        ret = git_pathdup(filename); \
 161                return ret; \
 162        }
 163
 164#define REPO_GIT_PATH_FUNC(var, filename) \
 165        const char *git_path_##var(struct repository *r) \
 166        { \
 167                if (!r->cached_paths.var) \
 168                        r->cached_paths.var = repo_git_path(r, filename); \
 169                return r->cached_paths.var; \
 170        }
 171
 172struct path_cache {
 173        const char *cherry_pick_head;
 174        const char *revert_head;
 175        const char *squash_msg;
 176        const char *merge_msg;
 177        const char *merge_rr;
 178        const char *merge_mode;
 179        const char *merge_head;
 180        const char *fetch_head;
 181        const char *shallow;
 182};
 183
 184#define PATH_CACHE_INIT { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
 185
 186const char *git_path_cherry_pick_head(struct repository *r);
 187const char *git_path_revert_head(struct repository *r);
 188const char *git_path_squash_msg(struct repository *r);
 189const char *git_path_merge_msg(struct repository *r);
 190const char *git_path_merge_rr(struct repository *r);
 191const char *git_path_merge_mode(struct repository *r);
 192const char *git_path_merge_head(struct repository *r);
 193const char *git_path_fetch_head(struct repository *r);
 194const char *git_path_shallow(struct repository *r);
 195
 196#endif /* PATH_H */