path.h

   1 #ifndef PATH_H
   2 #define PATH_H
   3
   4 struct repository;
   5 struct 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  */
  16 const char *mkpath(const char *fmt, ...)
  17         __attribute__((format (printf, 1, 2)));
  18
  19 /*
  20  * Return a path.
  21  */
  22 char *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  */
  28 char *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  */
  40 void 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  */
  49 const 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  */
  69 char *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  */
  77 void 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  */
  86 const 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  */
  92 char *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  */
 100 char *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  */
 107 void 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  */
 115 char *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  */
 125 void 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  */
 134 char *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  */
 142 int strbuf_git_path_submodule(struct strbuf *sb, const char *path,
 143                                      const char *fmt, ...)
 144         __attribute__((format (printf, 3, 4)));
 145
 146 void 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
 172 struct path_cache {
 173         const char *squash_msg;
 174         const char *merge_msg;
 175         const char *merge_rr;
 176         const char *merge_mode;
 177         const char *merge_head;
 178         const char *merge_autostash;
 179         const char *auto_merge;
 180         const char *fetch_head;
 181         const char *shallow;
 182 };
 183
 184 #define PATH_CACHE_INIT { 0 }
 185
 186 const char *git_path_squash_msg(struct repository *r);
 187 const char *git_path_merge_msg(struct repository *r);
 188 const char *git_path_merge_rr(struct repository *r);
 189 const char *git_path_merge_mode(struct repository *r);
 190 const char *git_path_merge_head(struct repository *r);
 191 const char *git_path_merge_autostash(struct repository *r);
 192 const char *git_path_auto_merge(struct repository *r);
 193 const char *git_path_fetch_head(struct repository *r);
 194 const char *git_path_shallow(struct repository *r);
 195
 196
 197 int ends_with_path_components(const char *path, const char *components);
 198
 199 #endif /* PATH_H */