🌐 AI搜索 & 代理 主页
Google Git
Sign in
chromium / external / github.com / git / git / refs/tags/v1.6.1 / . / cache.h
blob: 231c06d7726b575f6e522d5b0c0fe43557e8c651 [file] [log] [blame]
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]1#ifndef CACHE_H
2#define CACHE_H
3
Junio C Hamano4050c0d2005-12-05 19:54:29[diff] [blame]4#include "git-compat-util.h"
Pierre Habouzit5ecd2932007-09-16 13:51:04[diff] [blame]5#include "strbuf.h"
Linus Torvaldscf558702008-01-23 02:41:14[diff] [blame]6#include "hash.h"
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]7
Linus Torvaldscef661f2005-04-21 19:33:22[diff] [blame]8#include SHA1_HEADER
Nicolas Pitre9126f002008-10-01 18:05:20[diff] [blame]9#ifndef git_SHA_CTX
10#define git_SHA_CTX SHA_CTX
11#define git_SHA1_Init SHA1_Init
12#define git_SHA1_Update SHA1_Update
13#define git_SHA1_Final SHA1_Final
14#endif
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]15
Nicolas Pitre9126f002008-10-01 18:05:20[diff] [blame]16#include <zlib.h>
David Symonds609a2282007-11-07 03:24:28[diff] [blame]17#if defined(NO_DEFLATE_BOUND) || ZLIB_VERNUM < 0x1200
Edgar Toernig9da3acf2005-04-30 16:51:03[diff] [blame]18#define deflateBound(c,s) ((s) + (((s) + 7) >> 3) + (((s) + 63) >> 6) + 11)
19#endif
20
Timo Hirvonen962554c2006-02-26 15:13:46[diff] [blame]21#if defined(DT_UNKNOWN) && !defined(NO_D_TYPE_IN_DIRENT)
Edgar Toernigb6829692005-04-30 16:51:03[diff] [blame]22#define DTYPE(de) ((de)->d_type)
23#else
Junio C Hamano0bdd79a2006-01-20 21:33:20[diff] [blame]24#undef DT_UNKNOWN
25#undef DT_DIR
26#undef DT_REG
27#undef DT_LNK
Edgar Toernigb6829692005-04-30 16:51:03[diff] [blame]28#define DT_UNKNOWN 0
29#define DT_DIR 1
30#define DT_REG 2
Junio C Hamanoa15c1c62005-05-13 00:16:04[diff] [blame]31#define DT_LNK 3
Edgar Toernigb6829692005-04-30 16:51:03[diff] [blame]32#define DTYPE(de) DT_UNKNOWN
33#endif
34
Martin Koegler40689ae2007-04-22 16:43:56[diff] [blame]35/* unknown mode (impossible combination S_IFIFO|S_IFCHR) */
36#define S_IFINVALID 0030000
37
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]38/*
Linus Torvalds9eec4792007-04-10 04:14:58[diff] [blame]39 * A "directory link" is a link to another git directory.
40 *
41 * The value 0160000 is not normally a valid mode, and
42 * also just happens to be S_IFDIR + S_IFLNK
43 *
44 * NOTE! We *really* shouldn't depend on the S_IFxxx macros
45 * always having the same values everywhere. We should use
46 * our internal git values for these things, and then we can
47 * translate that to the OS-specific value. It just so
48 * happens that everybody shares the same bit representation
49 * in the UNIX world (and apparently wider too..)
50 */
Martin Waitz302b9282007-05-21 20:08:28[diff] [blame]51#define S_IFGITLINK 0160000
52#define S_ISGITLINK(m) (((m) & S_IFMT) == S_IFGITLINK)
Linus Torvalds9eec4792007-04-10 04:14:58[diff] [blame]53
54/*
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]55 * Intensive research over the course of many years has shown that
56 * port 9418 is totally unused by anything else. Or
57 *
58 * Your search - "port 9418" - did not match any documents.
59 *
60 * as www.google.com puts it.
Linus Torvaldsba8a4972005-09-12 18:23:00[diff] [blame]61 *
62 * This port has been properly assigned for git use by IANA:
63 * git (Assigned-9418) [I06-050728-0001].
64 *
65 * git 9418/tcp git pack transfer service
66 * git 9418/udp git pack transfer service
67 *
68 * with Linus Torvalds <torvalds@osdl.org> as the point of
69 * contact. September 2005.
70 *
71 * See http://www.iana.org/assignments/port-numbers
Linus Torvalds2386d652005-07-14 01:46:20[diff] [blame]72 */
73#define DEFAULT_GIT_PORT 9418
74
75/*
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]76 * Basic data structures for the directory cache
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]77 */
78
79#define CACHE_SIGNATURE 0x44495243 /* "DIRC" */
80struct cache_header {
Linus Torvaldsccc4feb2005-04-15 17:44:27[diff] [blame]81 unsigned int hdr_signature;
82 unsigned int hdr_version;
83 unsigned int hdr_entries;
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]84};
85
86/*
87 * The "cache_time" is just the low 32 bits of the
88 * time. It doesn't matter if it overflows - we only
89 * check it for equality in the 32 bits we save.
90 */
91struct cache_time {
92 unsigned int sec;
93 unsigned int nsec;
94};
95
96/*
97 * dev/ino/uid/gid/size are also just tracked to the low 32 bits
98 * Again - this is just a (very strong in practice) heuristic that
99 * the inode hasn't changed.
Linus Torvaldsccc4feb2005-04-15 17:44:27[diff] [blame]100 *
101 * We save the fields in big-endian order to allow using the
102 * index file over NFS transparently.
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]103 */
Linus Torvalds7a51ed62008-01-15 00:03:17[diff] [blame]104struct ondisk_cache_entry {
105 struct cache_time ctime;
106 struct cache_time mtime;
107 unsigned int dev;
108 unsigned int ino;
109 unsigned int mode;
110 unsigned int uid;
111 unsigned int gid;
112 unsigned int size;
113 unsigned char sha1[20];
114 unsigned short flags;
115 char name[FLEX_ARRAY]; /* more */
116};
117
Nguyễn Thái Ngọc Duy06aaaa02008-10-01 04:04:01[diff] [blame]118/*
119 * This struct is used when CE_EXTENDED bit is 1
120 * The struct must match ondisk_cache_entry exactly from
121 * ctime till flags
122 */
123struct ondisk_cache_entry_extended {
124 struct cache_time ctime;
125 struct cache_time mtime;
126 unsigned int dev;
127 unsigned int ino;
128 unsigned int mode;
129 unsigned int uid;
130 unsigned int gid;
131 unsigned int size;
132 unsigned char sha1[20];
133 unsigned short flags;
134 unsigned short flags2;
135 char name[FLEX_ARRAY]; /* more */
136};
137
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]138struct cache_entry {
Linus Torvalds7a51ed62008-01-15 00:03:17[diff] [blame]139 unsigned int ce_ctime;
140 unsigned int ce_mtime;
Linus Torvaldsccc4feb2005-04-15 17:44:27[diff] [blame]141 unsigned int ce_dev;
142 unsigned int ce_ino;
143 unsigned int ce_mode;
144 unsigned int ce_uid;
145 unsigned int ce_gid;
146 unsigned int ce_size;
Linus Torvalds7a51ed62008-01-15 00:03:17[diff] [blame]147 unsigned int ce_flags;
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]148 unsigned char sha1[20];
Linus Torvaldseb7a2f12008-02-23 04:41:17[diff] [blame]149 struct cache_entry *next;
Junio C Hamano8f1d2e62006-01-07 09:33:54[diff] [blame]150 char name[FLEX_ARRAY]; /* more */
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]151};
152
Linus Torvalds95fd5bf2005-04-16 05:51:44[diff] [blame]153#define CE_NAMEMASK (0x0fff)
154#define CE_STAGEMASK (0x3000)
Junio C Hamano16ce2e4c2008-08-17 06:02:08[diff] [blame]155#define CE_EXTENDED (0x4000)
Junio C Hamano5f730762006-02-09 05:15:24[diff] [blame]156#define CE_VALID (0x8000)
Junio C Hamanoaee46192005-04-16 15:33:23[diff] [blame]157#define CE_STAGESHIFT 12
Linus Torvalds95fd5bf2005-04-16 05:51:44[diff] [blame]158
Nguyễn Thái Ngọc Duy06aaaa02008-10-01 04:04:01[diff] [blame]159/*
160 * Range 0xFFFF0000 in ce_flags is divided into
161 * two parts: in-memory flags and on-disk ones.
162 * Flags in CE_EXTENDED_FLAGS will get saved on-disk
163 * if you want to save a new flag, add it in
164 * CE_EXTENDED_FLAGS
165 *
166 * In-memory only flags
167 */
Linus Torvalds7a51ed62008-01-15 00:03:17[diff] [blame]168#define CE_UPDATE (0x10000)
169#define CE_REMOVE (0x20000)
Junio C Hamanoeadb5832008-01-19 07:45:24[diff] [blame]170#define CE_UPTODATE (0x40000)
Linus Torvalds11029522008-03-22 21:22:44[diff] [blame]171#define CE_ADDED (0x80000)
Linus Torvaldsa22c6372008-02-23 04:37:40[diff] [blame]172
173#define CE_HASHED (0x100000)
174#define CE_UNHASHED (0x200000)
Linus Torvalds7a51ed62008-01-15 00:03:17[diff] [blame]175
Linus Torvaldsd070e3a2008-02-23 04:39:21[diff] [blame]176/*
Nguyễn Thái Ngọc Duy06aaaa02008-10-01 04:04:01[diff] [blame]177 * Extended on-disk flags
178 */
Junio C Hamano388b2ac2008-11-29 03:55:25[diff] [blame]179#define CE_INTENT_TO_ADD 0x20000000
Nguyễn Thái Ngọc Duy06aaaa02008-10-01 04:04:01[diff] [blame]180/* CE_EXTENDED2 is for future extension */
181#define CE_EXTENDED2 0x80000000
182
Junio C Hamano388b2ac2008-11-29 03:55:25[diff] [blame]183#define CE_EXTENDED_FLAGS (CE_INTENT_TO_ADD)
Nguyễn Thái Ngọc Duy06aaaa02008-10-01 04:04:01[diff] [blame]184
185/*
186 * Safeguard to avoid saving wrong flags:
187 * - CE_EXTENDED2 won't get saved until its semantic is known
188 * - Bits in 0x0000FFFF have been saved in ce_flags already
189 * - Bits in 0x003F0000 are currently in-memory flags
190 */
191#if CE_EXTENDED_FLAGS & 0x803FFFFF
192#error "CE_EXTENDED_FLAGS out of range"
193#endif
194
195/*
Linus Torvaldseb7a2f12008-02-23 04:41:17[diff] [blame]196 * Copy the sha1 and stat state of a cache entry from one to
197 * another. But we never change the name, or the hash state!
198 */
199#define CE_STATE_MASK (CE_HASHED | CE_UNHASHED)
200static inline void copy_cache_entry(struct cache_entry *dst, struct cache_entry *src)
201{
202 unsigned int state = dst->ce_flags & CE_STATE_MASK;
203
204 /* Don't copy hash chain and name */
205 memcpy(dst, src, offsetof(struct cache_entry, next));
206
207 /* Restore the hash state */
208 dst->ce_flags = (dst->ce_flags & ~CE_STATE_MASK) | state;
209}
210
Junio C Hamano7fec10b2008-01-19 07:42:00[diff] [blame]211static inline unsigned create_ce_flags(size_t len, unsigned stage)
212{
213 if (len >= CE_NAMEMASK)
214 len = CE_NAMEMASK;
215 return (len | (stage << CE_STAGESHIFT));
216}
217
218static inline size_t ce_namelen(const struct cache_entry *ce)
219{
220 size_t len = ce->ce_flags & CE_NAMEMASK;
221 if (len < CE_NAMEMASK)
222 return len;
223 return strlen(ce->name + CE_NAMEMASK) + CE_NAMEMASK;
224}
225
Junio C Hamanoaee46192005-04-16 15:33:23[diff] [blame]226#define ce_size(ce) cache_entry_size(ce_namelen(ce))
Nguyễn Thái Ngọc Duy06aaaa02008-10-01 04:04:01[diff] [blame]227#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \
228 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \
229 ondisk_cache_entry_size(ce_namelen(ce)))
Linus Torvalds7a51ed62008-01-15 00:03:17[diff] [blame]230#define ce_stage(ce) ((CE_STAGEMASK & (ce)->ce_flags) >> CE_STAGESHIFT)
Junio C Hamanoeadb5832008-01-19 07:45:24[diff] [blame]231#define ce_uptodate(ce) ((ce)->ce_flags & CE_UPTODATE)
232#define ce_mark_uptodate(ce) ((ce)->ce_flags |= CE_UPTODATE)
Junio C Hamanoaee46192005-04-16 15:33:23[diff] [blame]233
Linus Torvaldse4479472005-04-17 05:26:31[diff] [blame]234#define ce_permissions(mode) (((mode) & 0100) ? 0755 : 0644)
Kay Sievers8ae0a8c2005-05-05 12:38:25[diff] [blame]235static inline unsigned int create_ce_mode(unsigned int mode)
236{
Kay Sievers8ae0a8c2005-05-05 12:38:25[diff] [blame]237 if (S_ISLNK(mode))
Linus Torvalds7a51ed62008-01-15 00:03:17[diff] [blame]238 return S_IFLNK;
Martin Waitz302b9282007-05-21 20:08:28[diff] [blame]239 if (S_ISDIR(mode) || S_ISGITLINK(mode))
Linus Torvalds7a51ed62008-01-15 00:03:17[diff] [blame]240 return S_IFGITLINK;
241 return S_IFREG | ce_permissions(mode);
Kay Sievers8ae0a8c2005-05-05 12:38:25[diff] [blame]242}
Junio C Hamano185c9752007-02-17 06:43:48[diff] [blame]243static inline unsigned int ce_mode_from_stat(struct cache_entry *ce, unsigned int mode)
244{
Johannes Sixt78a8d642007-03-02 21:11:30[diff] [blame]245 extern int trust_executable_bit, has_symlinks;
246 if (!has_symlinks && S_ISREG(mode) &&
Linus Torvalds7a51ed62008-01-15 00:03:17[diff] [blame]247 ce && S_ISLNK(ce->ce_mode))
Johannes Sixt78a8d642007-03-02 21:11:30[diff] [blame]248 return ce->ce_mode;
Junio C Hamano185c9752007-02-17 06:43:48[diff] [blame]249 if (!trust_executable_bit && S_ISREG(mode)) {
Linus Torvalds7a51ed62008-01-15 00:03:17[diff] [blame]250 if (ce && S_ISREG(ce->ce_mode))
Junio C Hamano185c9752007-02-17 06:43:48[diff] [blame]251 return ce->ce_mode;
252 return create_ce_mode(0666);
253 }
254 return create_ce_mode(mode);
255}
Junio C Hamanod6b8fc32008-01-31 09:17:48[diff] [blame]256static inline int ce_to_dtype(const struct cache_entry *ce)
257{
258 unsigned ce_mode = ntohl(ce->ce_mode);
259 if (S_ISREG(ce_mode))
260 return DT_REG;
261 else if (S_ISDIR(ce_mode) || S_ISGITLINK(ce_mode))
262 return DT_DIR;
263 else if (S_ISLNK(ce_mode))
264 return DT_LNK;
265 else
266 return DT_UNKNOWN;
267}
Junio C Hamano1b0c7172006-03-30 06:55:43[diff] [blame]268#define canon_mode(mode) \
269 (S_ISREG(mode) ? (S_IFREG | ce_permissions(mode)) : \
Martin Waitz302b9282007-05-21 20:08:28[diff] [blame]270 S_ISLNK(mode) ? S_IFLNK : S_ISDIR(mode) ? S_IFDIR : S_IFGITLINK)
Linus Torvaldse4479472005-04-17 05:26:31[diff] [blame]271
Nguyễn Thái Ngọc Duy06aaaa02008-10-01 04:04:01[diff] [blame]272#define flexible_size(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)
273#define cache_entry_size(len) flexible_size(cache_entry,len)
274#define ondisk_cache_entry_size(len) flexible_size(ondisk_cache_entry,len)
275#define ondisk_cache_entry_extended_size(len) flexible_size(ondisk_cache_entry_extended,len)
Linus Torvaldsf5cabd12005-04-16 04:45:38[diff] [blame]276
Junio C Hamano228e94f2007-04-02 01:14:06[diff] [blame]277struct index_state {
278 struct cache_entry **cache;
279 unsigned int cache_nr, cache_alloc, cache_changed;
280 struct cache_tree *cache_tree;
281 time_t timestamp;
Linus Torvalds7a51ed62008-01-15 00:03:17[diff] [blame]282 void *alloc;
Junio C Hamano913e0e92008-08-23 19:57:30[diff] [blame]283 unsigned name_hash_initialized : 1,
284 initialized : 1;
Linus Torvaldscf558702008-01-23 02:41:14[diff] [blame]285 struct hash_table name_hash;
Junio C Hamano228e94f2007-04-02 01:14:06[diff] [blame]286};
287
288extern struct index_state the_index;
289
Linus Torvalds96872bc2008-03-21 20:16:24[diff] [blame]290/* Name hashing */
291extern void add_name_hash(struct index_state *istate, struct cache_entry *ce);
292/*
293 * We don't actually *remove* it, we can just mark it invalid so that
294 * we won't find it in lookups.
295 *
296 * Not only would we have to search the lists (simple enough), but
297 * we'd also have to rehash other hash buckets in case this makes the
298 * hash bucket empty (common). So it's much better to just mark
299 * it.
300 */
301static inline void remove_name_hash(struct cache_entry *ce)
302{
303 ce->ce_flags |= CE_UNHASHED;
304}
305
306
Junio C Hamano4aab5b42007-04-02 06:26:07[diff] [blame]307#ifndef NO_THE_INDEX_COMPATIBILITY_MACROS
Junio C Hamano228e94f2007-04-02 01:14:06[diff] [blame]308#define active_cache (the_index.cache)
309#define active_nr (the_index.cache_nr)
310#define active_alloc (the_index.cache_alloc)
311#define active_cache_changed (the_index.cache_changed)
312#define active_cache_tree (the_index.cache_tree)
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]313
Junio C Hamano4aab5b42007-04-02 06:26:07[diff] [blame]314#define read_cache() read_index(&the_index)
315#define read_cache_from(path) read_index_from(&the_index, (path))
Linus Torvalds671c9b72008-11-14 00:36:30[diff] [blame]316#define read_cache_preload(pathspec) read_index_preload(&the_index, (pathspec))
Junio C Hamanofa7b3c22008-11-12 19:52:35[diff] [blame]317#define is_cache_unborn() is_index_unborn(&the_index)
Miklos Vajnae46bbcf2008-06-27 16:21:58[diff] [blame]318#define read_cache_unmerged() read_index_unmerged(&the_index)
Junio C Hamano4aab5b42007-04-02 06:26:07[diff] [blame]319#define write_cache(newfd, cache, entries) write_index(&the_index, (newfd))
320#define discard_cache() discard_index(&the_index)
Daniel Barkalow94a57282008-02-07 16:40:13[diff] [blame]321#define unmerged_cache() unmerged_index(&the_index)
Junio C Hamano4aab5b42007-04-02 06:26:07[diff] [blame]322#define cache_name_pos(name, namelen) index_name_pos(&the_index,(name),(namelen))
323#define add_cache_entry(ce, option) add_index_entry(&the_index, (ce), (option))
Petr Baudis81dc2302008-07-21 00:25:56[diff] [blame]324#define rename_cache_entry_at(pos, new_name) rename_index_entry_at(&the_index, (pos), (new_name))
Junio C Hamano4aab5b42007-04-02 06:26:07[diff] [blame]325#define remove_cache_entry_at(pos) remove_index_entry_at(&the_index, (pos))
326#define remove_file_from_cache(path) remove_file_from_index(&the_index, (path))
Junio C Hamano38ed1d82008-05-21 19:04:34[diff] [blame]327#define add_to_cache(path, st, flags) add_to_index(&the_index, (path), (st), (flags))
328#define add_file_to_cache(path, flags) add_file_to_index(&the_index, (path), (flags))
Alexandre Julliardd6168132007-08-11 21:59:01[diff] [blame]329#define refresh_cache(flags) refresh_index(&the_index, (flags), NULL, NULL)
Junio C Hamano4bd5b7d2007-11-10 08:15:03[diff] [blame]330#define ce_match_stat(ce, st, options) ie_match_stat(&the_index, (ce), (st), (options))
331#define ce_modified(ce, st, options) ie_modified(&the_index, (ce), (st), (options))
Linus Torvaldscd2fef52008-03-21 22:55:19[diff] [blame]332#define cache_name_exists(name, namelen, igncase) index_name_exists(&the_index, (name), (namelen), (igncase))
Jeff King98fa4732008-10-16 15:07:26[diff] [blame]333#define cache_name_is_other(name, namelen) index_name_is_other(&the_index, (name), (namelen))
Junio C Hamano4aab5b42007-04-02 06:26:07[diff] [blame]334#endif
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]335
Junio C Hamanoedaec3f2007-02-28 19:45:56[diff] [blame]336enum object_type {
337 OBJ_BAD = -1,
338 OBJ_NONE = 0,
339 OBJ_COMMIT = 1,
340 OBJ_TREE = 2,
341 OBJ_BLOB = 3,
342 OBJ_TAG = 4,
343 /* 5 for future expansion */
344 OBJ_OFS_DELTA = 6,
345 OBJ_REF_DELTA = 7,
Martin Koegler355885d2008-02-25 21:46:04[diff] [blame]346 OBJ_ANY,
Junio C Hamanoedaec3f2007-02-28 19:45:56[diff] [blame]347 OBJ_MAX,
348};
349
Junio C Hamanob45563a2007-12-01 06:22:38[diff] [blame]350static inline enum object_type object_type(unsigned int mode)
351{
352 return S_ISDIR(mode) ? OBJ_TREE :
353 S_ISGITLINK(mode) ? OBJ_COMMIT :
354 OBJ_BLOB;
355}
356
Junio C Hamano8ac069a2005-05-10 05:57:58[diff] [blame]357#define GIT_DIR_ENVIRONMENT "GIT_DIR"
Matthias Lederhofer892c41b2007-06-06 07:10:42[diff] [blame]358#define GIT_WORK_TREE_ENVIRONMENT "GIT_WORK_TREE"
Junio C Hamano8ac069a2005-05-10 05:57:58[diff] [blame]359#define DEFAULT_GIT_DIR_ENVIRONMENT ".git"
Junio C Hamanod19938a2005-05-10 00:57:56[diff] [blame]360#define DB_ENVIRONMENT "GIT_OBJECT_DIRECTORY"
Linus Torvaldsbb233d62005-04-21 17:55:18[diff] [blame]361#define INDEX_ENVIRONMENT "GIT_INDEX_FILE"
Junio C Hamano5da5c8f2005-07-30 07:58:28[diff] [blame]362#define GRAFT_ENVIRONMENT "GIT_GRAFT_FILE"
Junio C Hamanod4ebc362006-12-19 09:28:15[diff] [blame]363#define TEMPLATE_DIR_ENVIRONMENT "GIT_TEMPLATE_DIR"
364#define CONFIG_ENVIRONMENT "GIT_CONFIG"
Junio C Hamanod4ebc362006-12-19 09:28:15[diff] [blame]365#define EXEC_PATH_ENVIRONMENT "GIT_EXEC_PATH"
David Reiss0454dd92008-05-20 06:49:26[diff] [blame]366#define CEILING_DIRECTORIES_ENVIRONMENT "GIT_CEILING_DIRECTORIES"
Junio C Hamanod0bfd022007-04-12 08:07:32[diff] [blame]367#define GITATTRIBUTES_FILE ".gitattributes"
368#define INFOATTRIBUTES_FILE "info/attributes"
Junio C Hamanof48fd682007-04-14 15:54:37[diff] [blame]369#define ATTRIBUTE_MACRO_PREFIX "[attr]"
Linus Torvaldsbb233d62005-04-21 17:55:18[diff] [blame]370
Junio C Hamano7d1864c2007-01-07 10:00:28[diff] [blame]371extern int is_bare_repository_cfg;
372extern int is_bare_repository(void);
Johannes Schindelin68025632007-01-20 02:09:34[diff] [blame]373extern int is_inside_git_dir(void);
Johannes Schindeline90fdc32007-08-01 00:30:14[diff] [blame]374extern char *git_work_tree_cfg;
Matthias Lederhofer892c41b2007-06-06 07:10:42[diff] [blame]375extern int is_inside_work_tree(void);
Dmitry Potapovd2b07082008-09-27 08:41:50[diff] [blame]376extern int have_git_dir(void);
Pierre Habouzitc5fba162006-08-23 10:39:11[diff] [blame]377extern const char *get_git_dir(void);
Junio C Hamano8ac069a2005-05-10 05:57:58[diff] [blame]378extern char *get_object_directory(void);
Junio C Hamano8ac069a2005-05-10 05:57:58[diff] [blame]379extern char *get_index_file(void);
Junio C Hamano5da5c8f2005-07-30 07:58:28[diff] [blame]380extern char *get_graft_file(void);
Johannes Schindelind7ac12b2007-08-01 00:29:38[diff] [blame]381extern int set_git_dir(const char *path);
Johannes Schindeline90fdc32007-08-01 00:30:14[diff] [blame]382extern const char *get_git_work_tree(void);
Lars Hjemlib44ebb12008-02-20 22:13:13[diff] [blame]383extern const char *read_gitfile_gently(const char *path);
Daniel Barkalow19757d82008-04-27 17:39:21[diff] [blame]384extern void set_git_work_tree(const char *tree);
Junio C Hamano8ac069a2005-05-10 05:57:58[diff] [blame]385
386#define ALTERNATE_DB_ENVIRONMENT "GIT_ALTERNATE_OBJECT_DIRECTORIES"
Linus Torvaldsbb233d62005-04-21 17:55:18[diff] [blame]387
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]388extern const char **get_pathspec(const char *prefix, const char **pathspec);
Mike Hommey59f0f2f2007-11-03 11:23:11[diff] [blame]389extern void setup_work_tree(void);
Junio C Hamano4ca06602005-11-26 07:14:15[diff] [blame]390extern const char *setup_git_directory_gently(int *);
Linus Torvaldsd288a702005-08-17 01:06:34[diff] [blame]391extern const char *setup_git_directory(void);
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]392extern const char *prefix_path(const char *prefix, int len, const char *path);
Junio C Hamano4ca06602005-11-26 07:14:15[diff] [blame]393extern const char *prefix_filename(const char *prefix, int len, const char *path);
Linus Torvaldse23d0b42006-04-26 17:15:54[diff] [blame]394extern void verify_filename(const char *prefix, const char *name);
Junio C Hamanoea92f412006-04-26 22:09:27[diff] [blame]395extern void verify_non_filename(const char *prefix, const char *name);
Linus Torvaldsd288a702005-08-17 01:06:34[diff] [blame]396
Daniel Barkalowf225aeb2008-04-27 17:39:27[diff] [blame]397#define INIT_DB_QUIET 0x0001
398
399extern int init_db(const char *template_dir, unsigned int flags);
400
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]401#define alloc_nr(x) (((x)+16)*3/2)
402
Jeff King6815e562007-06-11 13:39:44[diff] [blame]403/*
404 * Realloc the buffer pointed at by variable 'x' so that it can hold
405 * at least 'nr' entries; the number of entries currently allocated
406 * is 'alloc', using the standard growing factor alloc_nr() macro.
407 *
408 * DO NOT USE any expression with side-effect for 'x' or 'alloc'.
409 */
410#define ALLOC_GROW(x, nr, alloc) \
411 do { \
Jeff Kingc927e6c2007-06-16 22:37:39[diff] [blame]412 if ((nr) > alloc) { \
Junio C Hamano4234a762007-06-12 05:10:55[diff] [blame]413 if (alloc_nr(alloc) < (nr)) \
414 alloc = (nr); \
415 else \
416 alloc = alloc_nr(alloc); \
Jeff King6815e562007-06-11 13:39:44[diff] [blame]417 x = xrealloc((x), alloc * sizeof(*(x))); \
418 } \
419 } while(0)
420
Linus Torvalds734aab72005-04-09 16:48:20[diff] [blame]421/* Initialize and use the cache information */
Junio C Hamano4aab5b42007-04-02 06:26:07[diff] [blame]422extern int read_index(struct index_state *);
Linus Torvalds671c9b72008-11-14 00:36:30[diff] [blame]423extern int read_index_preload(struct index_state *, const char **pathspec);
Junio C Hamano4aab5b42007-04-02 06:26:07[diff] [blame]424extern int read_index_from(struct index_state *, const char *path);
Junio C Hamanofa7b3c22008-11-12 19:52:35[diff] [blame]425extern int is_index_unborn(struct index_state *);
Miklos Vajnae46bbcf2008-06-27 16:21:58[diff] [blame]426extern int read_index_unmerged(struct index_state *);
Linus Torvaldsd1f128b2008-03-06 20:46:09[diff] [blame]427extern int write_index(const struct index_state *, int newfd);
Junio C Hamano4aab5b42007-04-02 06:26:07[diff] [blame]428extern int discard_index(struct index_state *);
Linus Torvaldsd1f128b2008-03-06 20:46:09[diff] [blame]429extern int unmerged_index(const struct index_state *);
Linus Torvalds8dcf39c2006-05-18 19:07:31[diff] [blame]430extern int verify_path(const char *path);
Linus Torvaldscd2fef52008-03-21 22:55:19[diff] [blame]431extern struct cache_entry *index_name_exists(struct index_state *istate, const char *name, int namelen, int igncase);
Linus Torvaldsd1f128b2008-03-06 20:46:09[diff] [blame]432extern int index_name_pos(const struct index_state *, const char *name, int namelen);
Junio C Hamano192268c2005-05-08 04:55:21[diff] [blame]433#define ADD_CACHE_OK_TO_ADD 1 /* Ok to add */
434#define ADD_CACHE_OK_TO_REPLACE 2 /* Ok to replace file/directory */
Junio C Hamanob1557252005-06-25 09:25:29[diff] [blame]435#define ADD_CACHE_SKIP_DFCHECK 4 /* Ok to skip DF conflict checks */
Junio C Hamanoaf3785d2007-08-09 20:42:50[diff] [blame]436#define ADD_CACHE_JUST_APPEND 8 /* Append only; tree.c::read_tree() */
Junio C Hamano39425812008-08-21 08:44:53[diff] [blame]437#define ADD_CACHE_NEW_ONLY 16 /* Do not replace existing ones */
Junio C Hamano4aab5b42007-04-02 06:26:07[diff] [blame]438extern int add_index_entry(struct index_state *, struct cache_entry *ce, int option);
Johannes Schindelin8fd2cb42006-07-26 04:32:18[diff] [blame]439extern struct cache_entry *refresh_cache_entry(struct cache_entry *ce, int really);
Petr Baudis81dc2302008-07-21 00:25:56[diff] [blame]440extern void rename_index_entry_at(struct index_state *, int pos, const char *new_name);
Junio C Hamano4aab5b42007-04-02 06:26:07[diff] [blame]441extern int remove_index_entry_at(struct index_state *, int pos);
442extern int remove_file_from_index(struct index_state *, const char *path);
Junio C Hamano38ed1d82008-05-21 19:04:34[diff] [blame]443#define ADD_CACHE_VERBOSE 1
444#define ADD_CACHE_PRETEND 2
Junio C Hamano01665922008-05-25 21:03:50[diff] [blame]445#define ADD_CACHE_IGNORE_ERRORS 4
Junio C Hamano041aee32008-07-21 08:24:17[diff] [blame]446#define ADD_CACHE_IGNORE_REMOVAL 8
Junio C Hamano39425812008-08-21 08:44:53[diff] [blame]447#define ADD_CACHE_INTENT 16
Junio C Hamano38ed1d82008-05-21 19:04:34[diff] [blame]448extern int add_to_index(struct index_state *, const char *path, struct stat *, int flags);
449extern int add_file_to_index(struct index_state *, const char *path, int flags);
Carlos Rica6640f882007-09-11 03:17:28[diff] [blame]450extern struct cache_entry *make_cache_entry(unsigned int mode, const unsigned char *sha1, const char *path, int stage, int refresh);
Brad Robertsdbbce552005-05-15 02:04:25[diff] [blame]451extern int ce_same_name(struct cache_entry *a, struct cache_entry *b);
Jeff King98fa4732008-10-16 15:07:26[diff] [blame]452extern int index_name_is_other(const struct index_state *, const char *, int);
Junio C Hamano4bd5b7d2007-11-10 08:15:03[diff] [blame]453
454/* do stat comparison even if CE_VALID is true */
455#define CE_MATCH_IGNORE_VALID 01
456/* do not check the contents but report dirty on racily-clean entries */
457#define CE_MATCH_RACY_IS_DIRTY 02
Linus Torvaldsd1f128b2008-03-06 20:46:09[diff] [blame]458extern int ie_match_stat(const struct index_state *, struct cache_entry *, struct stat *, unsigned int);
459extern int ie_modified(const struct index_state *, struct cache_entry *, struct stat *, unsigned int);
Junio C Hamano4bd5b7d2007-11-10 08:15:03[diff] [blame]460
Linus Torvaldsc0fd1f52005-07-14 23:55:06[diff] [blame]461extern int ce_path_match(const struct cache_entry *ce, const char **pathspec);
Junio C Hamano53bca912007-02-28 19:52:04[diff] [blame]462extern int index_fd(unsigned char *sha1, int fd, struct stat *st, int write_object, enum object_type type, const char *path);
Junio C Hamanoec1fcc12005-10-07 10:42:00[diff] [blame]463extern int index_path(unsigned char *sha1, const char *path, struct stat *st, int write_object);
Junio C Hamano415e96c2005-05-15 21:23:12[diff] [blame]464extern void fill_stat_cache_info(struct cache_entry *ce, struct stat *st);
465
Linus Torvalds405e5b22006-05-19 16:56:35[diff] [blame]466#define REFRESH_REALLY 0x0001 /* ignore_valid */
467#define REFRESH_UNMERGED 0x0002 /* allow unmerged */
468#define REFRESH_QUIET 0x0004 /* be quiet about it */
469#define REFRESH_IGNORE_MISSING 0x0008 /* ignore non-existent */
Junio C Hamano3f1b7b62008-07-20 06:25:00[diff] [blame]470#define REFRESH_IGNORE_SUBMODULES 0x0010 /* ignore submodules */
Junio C Hamanod14e7402008-07-20 07:21:38[diff] [blame]471#define REFRESH_SAY_CHANGED 0x0020 /* say "changed" not "needs update" */
Alexandre Julliardd6168132007-08-11 21:59:01[diff] [blame]472extern int refresh_index(struct index_state *, unsigned int flags, const char **pathspec, char *seen);
Linus Torvalds405e5b22006-05-19 16:56:35[diff] [blame]473
Junio C Hamano021b6e42006-06-06 19:51:49[diff] [blame]474struct lock_file {
475 struct lock_file *next;
Johannes Schindelin4723ee92007-11-13 20:05:03[diff] [blame]476 int fd;
Junio C Hamano5e635e32007-04-21 10:11:10[diff] [blame]477 pid_t owner;
Junio C Hamano1084b842007-01-02 19:19:05[diff] [blame]478 char on_list;
Junio C Hamano021b6e42006-06-06 19:51:49[diff] [blame]479 char filename[PATH_MAX];
Junio C Hamano415e96c2005-05-15 21:23:12[diff] [blame]480};
Junio C Hamanoacd3b9e2008-10-17 22:44:39[diff] [blame]481#define LOCK_DIE_ON_ERROR 1
482#define LOCK_NODEREF 2
Junio C Hamano40aaae82006-08-12 08:03:47[diff] [blame]483extern int hold_lock_file_for_update(struct lock_file *, const char *path, int);
Daniel Barkalowea3cd5c2008-04-17 23:32:26[diff] [blame]484extern int hold_lock_file_for_append(struct lock_file *, const char *path, int);
Junio C Hamano021b6e42006-06-06 19:51:49[diff] [blame]485extern int commit_lock_file(struct lock_file *);
Junio C Hamano30ca07a2007-04-01 06:09:02[diff] [blame]486
487extern int hold_locked_index(struct lock_file *, int);
488extern int commit_locked_index(struct lock_file *);
Junio C Hamano5e7f56a2007-04-01 06:27:41[diff] [blame]489extern void set_alternate_index_output(const char *);
Brandon Caseyd6cf61b2008-01-16 19:05:32[diff] [blame]490extern int close_lock_file(struct lock_file *);
Junio C Hamano021b6e42006-06-06 19:51:49[diff] [blame]491extern void rollback_lock_file(struct lock_file *);
Miklos Vajnaeca35a22008-10-26 02:33:56[diff] [blame]492extern int delete_ref(const char *, const unsigned char *sha1, int delopt);
Linus Torvalds734aab72005-04-09 16:48:20[diff] [blame]493
Junio C Hamano2ae1c532006-02-27 22:47:45[diff] [blame]494/* Environment bits from configuration mechanism */
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]495extern int trust_executable_bit;
Alex Riesen1ce47902008-07-28 06:31:28[diff] [blame]496extern int trust_ctime;
Junio C Hamano9378c162007-06-24 22:11:24[diff] [blame]497extern int quote_path_fully;
Johannes Sixt78a8d642007-03-02 21:11:30[diff] [blame]498extern int has_symlinks;
Linus Torvalds0a9b88b2008-03-21 23:52:46[diff] [blame]499extern int ignore_case;
Junio C Hamano5f730762006-02-09 05:15:24[diff] [blame]500extern int assume_unchanged;
Junio C Hamano9f0bb902006-05-02 07:40:24[diff] [blame]501extern int prefer_symlink_refs;
Shawn Pearce6de08ae2006-05-17 09:55:40[diff] [blame]502extern int log_all_ref_updates;
Junio C Hamano2f8acdb2006-03-21 02:45:47[diff] [blame]503extern int warn_ambiguous_refs;
Johannes Schindelin457f06d2005-12-22 22:13:56[diff] [blame]504extern int shared_repository;
Junio C Hamano2ae1c532006-02-27 22:47:45[diff] [blame]505extern const char *apply_default_whitespace;
Joachim B Haga12f6c302006-07-03 20:11:47[diff] [blame]506extern int zlib_compression_level;
Dana How960ccca2007-05-09 20:56:50[diff] [blame]507extern int core_compression_level;
508extern int core_compression_seen;
Shawn O. Pearce60bb8b12006-12-23 07:34:28[diff] [blame]509extern size_t packed_git_window_size;
Shawn O. Pearce77ccc5b2006-12-23 07:33:35[diff] [blame]510extern size_t packed_git_limit;
Shawn O. Pearce18bdec12007-03-19 05:14:37[diff] [blame]511extern size_t delta_base_cache_limit;
Linus Torvalds6c510be2007-02-13 19:07:23[diff] [blame]512extern int auto_crlf;
Linus Torvaldsaafe9fb2008-06-18 22:18:44[diff] [blame]513extern int fsync_object_files;
Linus Torvalds671c9b72008-11-14 00:36:30[diff] [blame]514extern int core_preload_index;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]515
Steffen Prohaska21e5ad52008-02-06 11:25:58[diff] [blame]516enum safe_crlf {
517 SAFE_CRLF_FALSE = 0,
518 SAFE_CRLF_FAIL = 1,
519 SAFE_CRLF_WARN = 2,
520};
521
522extern enum safe_crlf safe_crlf;
523
Jay Soffian9ed36cf2008-02-19 16:24:37[diff] [blame]524enum branch_track {
Alex Riesen9188ed82008-08-21 17:23:20[diff] [blame]525 BRANCH_TRACK_UNSPECIFIED = -1,
Jay Soffian9ed36cf2008-02-19 16:24:37[diff] [blame]526 BRANCH_TRACK_NEVER = 0,
527 BRANCH_TRACK_REMOTE,
528 BRANCH_TRACK_ALWAYS,
529 BRANCH_TRACK_EXPLICIT,
530};
531
Dustin Sallingsc998ae92008-05-10 22:36:29[diff] [blame]532enum rebase_setup_type {
533 AUTOREBASE_NEVER = 0,
534 AUTOREBASE_LOCAL,
535 AUTOREBASE_REMOTE,
536 AUTOREBASE_ALWAYS,
537};
538
Jay Soffian9ed36cf2008-02-19 16:24:37[diff] [blame]539extern enum branch_track git_branch_track;
Dustin Sallingsc998ae92008-05-10 22:36:29[diff] [blame]540extern enum rebase_setup_type autorebase;
Jay Soffian9ed36cf2008-02-19 16:24:37[diff] [blame]541
Junio C Hamanoab9cb762005-11-25 23:59:09[diff] [blame]542#define GIT_REPO_VERSION 0
543extern int repository_format_version;
544extern int check_repository_format(void);
545
Linus Torvalds734aab72005-04-09 16:48:20[diff] [blame]546#define MTIME_CHANGED 0x0001
547#define CTIME_CHANGED 0x0002
548#define OWNER_CHANGED 0x0004
549#define MODE_CHANGED 0x0008
550#define INODE_CHANGED 0x0010
551#define DATA_CHANGED 0x0020
Kay Sievers8ae0a8c2005-05-05 12:38:25[diff] [blame]552#define TYPE_CHANGED 0x0040
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]553
Alex Riesen108bebe2008-10-26 21:59:13[diff] [blame]554extern char *mksnpath(char *buf, size_t n, const char *fmt, ...)
555 __attribute__((format (printf, 3, 4)));
Alex Riesenfe2d7772008-10-27 09:22:21[diff] [blame]556extern char *git_snpath(char *buf, size_t n, const char *fmt, ...)
557 __attribute__((format (printf, 3, 4)));
Alex Riesenaba13e72008-10-27 10:17:51[diff] [blame]558extern char *git_pathdup(const char *fmt, ...)
559 __attribute__((format (printf, 1, 2)));
Alex Riesen108bebe2008-10-26 21:59:13[diff] [blame]560
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]561/* Return a statically allocated filename matching the sha1 signature */
Timo Sirainen4ec99bf2005-08-09 15:30:22[diff] [blame]562extern char *mkpath(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
563extern char *git_path(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
Linus Torvalds73134b62005-04-10 21:03:58[diff] [blame]564extern char *sha1_file_name(const unsigned char *sha1);
barkalow@iabervon.orgbf592c52005-08-01 00:53:44[diff] [blame]565extern char *sha1_pack_name(const unsigned char *sha1);
566extern char *sha1_pack_index_name(const unsigned char *sha1);
Junio C Hamano013f2762005-10-11 22:22:48[diff] [blame]567extern const char *find_unique_abbrev(const unsigned char *sha1, int);
Junio C Hamano88cd6212005-09-30 21:02:47[diff] [blame]568extern const unsigned char null_sha1[20];
David Rientjes0bef57e2006-08-15 20:37:19[diff] [blame]569static inline int is_null_sha1(const unsigned char *sha1)
570{
571 return !memcmp(sha1, null_sha1, 20);
572}
David Rientjesa89fccd2006-08-17 18:54:57[diff] [blame]573static inline int hashcmp(const unsigned char *sha1, const unsigned char *sha2)
574{
575 return memcmp(sha1, sha2, 20);
576}
Shawn Pearcee7024962006-08-23 06:49:00[diff] [blame]577static inline void hashcpy(unsigned char *sha_dst, const unsigned char *sha_src)
578{
579 memcpy(sha_dst, sha_src, 20);
580}
Junio C Hamanoa8e0d162006-08-23 20:57:23[diff] [blame]581static inline void hashclr(unsigned char *hash)
582{
583 memset(hash, 0, 20);
584}
Jeff Kingf55527f2008-10-21 13:54:19[diff] [blame]585extern int is_empty_blob_sha1(const unsigned char *sha1);
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]586
Jeff King14d9c572008-11-12 08:17:52[diff] [blame]587#define EMPTY_TREE_SHA1_HEX \
588 "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
589#define EMPTY_TREE_SHA1_BIN \
590 "\x4b\x82\x5d\xc6\x42\xcb\x6e\xb9\xa0\x60" \
591 "\xe5\x4b\xf8\xd6\x92\x88\xfb\xee\x49\x04"
592
Holger Eitzenbergerf2db68e2005-08-04 20:43:03[diff] [blame]593int git_mkstemp(char *path, size_t n, const char *template);
594
Heikki Orsila06cbe852008-04-16 08:34:24[diff] [blame]595/*
596 * NOTE NOTE NOTE!!
597 *
598 * PERM_UMASK, OLD_PERM_GROUP and OLD_PERM_EVERYBODY enumerations must
599 * not be changed. Old repositories have core.sharedrepository written in
600 * numeric format, and therefore these values are preserved for compatibility
601 * reasons.
602 */
Junio C Hamano94df2502006-06-10 06:09:49[diff] [blame]603enum sharedrepo {
Heikki Orsila06cbe852008-04-16 08:34:24[diff] [blame]604 PERM_UMASK = 0,
605 OLD_PERM_GROUP = 1,
606 OLD_PERM_EVERYBODY = 2,
607 PERM_GROUP = 0660,
608 PERM_EVERYBODY = 0664,
Junio C Hamano94df2502006-06-10 06:09:49[diff] [blame]609};
610int git_config_perm(const char *var, const char *value);
Johannes Schindelin457f06d2005-12-22 22:13:56[diff] [blame]611int adjust_shared_perm(const char *path);
Junio C Hamanob2cb9422005-07-06 08:11:52[diff] [blame]612int safe_create_leading_directories(char *path);
Jeff King8e21d632008-06-25 05:41:34[diff] [blame]613int safe_create_leading_directories_const(const char *path);
Timo Hirvonenbd22c902005-11-21 00:52:52[diff] [blame]614char *enter_repo(char *path, int strict);
Johannes Schindeline5392c52007-08-01 00:28:59[diff] [blame]615static inline int is_absolute_path(const char *path)
616{
Johannes Sixt25fe2172008-03-05 20:51:27[diff] [blame]617 return path[0] == '/' || has_dos_drive_prefix(path);
Johannes Schindeline5392c52007-08-01 00:28:59[diff] [blame]618}
Junio C Hamano90b4a712008-09-09 08:27:07[diff] [blame]619int is_directory(const char *);
Johannes Schindeline5392c52007-08-01 00:28:59[diff] [blame]620const char *make_absolute_path(const char *path);
Daniel Barkalow1b9a9462008-06-06 03:15:19[diff] [blame]621const char *make_nonrelative_path(const char *path);
Linus Torvalds044bbbc2008-06-19 19:34:06[diff] [blame]622const char *make_relative_path(const char *abs, const char *base);
David Reissae299be2008-05-20 06:48:54[diff] [blame]623int normalize_absolute_path(char *buf, const char *path);
David Reiss0454dd92008-05-20 06:49:26[diff] [blame]624int longest_ancestor_length(const char *path, const char *prefix_list);
Junio C Hamanob2cb9422005-07-06 08:11:52[diff] [blame]625
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]626/* Read and unpack a sha1 file into memory, write memory to a sha1 file */
Nicolas Pitre21666f12007-02-26 19:55:59[diff] [blame]627extern int sha1_object_info(const unsigned char *, unsigned long *);
Nicolas Pitre21666f12007-02-26 19:55:59[diff] [blame]628extern void * read_sha1_file(const unsigned char *sha1, enum object_type *type, unsigned long *size);
Nicolas Pitrece9fbf12007-03-20 20:02:09[diff] [blame]629extern int hash_sha1_file(const void *buf, unsigned long len, const char *type, unsigned char *sha1);
Brian Gerstbf0f9102005-05-18 12:14:09[diff] [blame]630extern int write_sha1_file(void *buf, unsigned long len, const char *type, unsigned char *return_sha1);
Nicolas Pitre21666f12007-02-26 19:55:59[diff] [blame]631extern int pretend_sha1_file(void *, unsigned long, enum object_type, unsigned char *);
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]632extern int force_object_loose(const unsigned char *sha1, time_t mtime);
Daniel Barkalow8237b182005-04-24 01:47:23[diff] [blame]633
Nicolas Pitreac939102008-07-15 01:46:48[diff] [blame]634/* just like read_sha1_file(), but non fatal in presence of bad objects */
635extern void *read_object(const unsigned char *sha1, enum object_type *type, unsigned long *size);
636
Nicolas Pitre0e8189e2008-10-31 15:31:08[diff] [blame]637/* global flag to enable extra checks when accessing packed objects */
638extern int do_check_packed_object_crc;
639
Jason McMullan5d6ccf52005-06-03 15:05:39[diff] [blame]640extern int check_sha1_signature(const unsigned char *sha1, void *buf, unsigned long size, const char *type);
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]641
Junio C Hamano839837b2006-09-01 07:17:47[diff] [blame]642extern int move_temp_to_file(const char *tmpfile, const char *filename);
Daniel Barkalow8237b182005-04-24 01:47:23[diff] [blame]643
Junio C Hamano106d7102006-09-06 09:12:09[diff] [blame]644extern int has_sha1_pack(const unsigned char *sha1, const char **ignore);
Daniel Barkalow8237b182005-04-24 01:47:23[diff] [blame]645extern int has_sha1_file(const unsigned char *sha1);
Brandon Casey0f4dc142008-11-10 05:59:57[diff] [blame]646extern int has_loose_object_nonlocal(const unsigned char *sha1);
Daniel Barkalow8237b182005-04-24 01:47:23[diff] [blame]647
barkalow@iabervon.orgbf592c52005-08-01 00:53:44[diff] [blame]648extern int has_pack_file(const unsigned char *sha1);
649extern int has_pack_index(const unsigned char *sha1);
650
Linus Torvalds192a6be2007-05-30 17:32:19[diff] [blame]651extern const signed char hexval_table[256];
652static inline unsigned int hexval(unsigned char c)
Junio C Hamanoe49521b2006-09-20 23:04:46[diff] [blame]653{
654 return hexval_table[c];
655}
656
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]657/* Convert to/from hex/sha1 representation */
Junio C Hamano46a6c262006-01-25 09:03:18[diff] [blame]658#define MINIMUM_ABBREV 4
659#define DEFAULT_ABBREV 7
660
Linus Torvalds3c249c92005-05-01 23:36:56[diff] [blame]661extern int get_sha1(const char *str, unsigned char *sha1);
Martin Koeglera0cd87a2007-04-23 20:55:05[diff] [blame]662extern int get_sha1_with_mode(const char *str, unsigned char *sha1, unsigned *mode);
Linus Torvalds197ee8c2005-04-09 19:09:27[diff] [blame]663extern int get_sha1_hex(const char *hex, unsigned char *sha1);
664extern char *sha1_to_hex(const unsigned char *sha1); /* static buffer result! */
Linus Torvaldsca8db142005-09-25 16:59:37[diff] [blame]665extern int read_ref(const char *filename, unsigned char *sha1);
Junio C Hamano8da19772006-09-21 05:02:01[diff] [blame]666extern const char *resolve_ref(const char *path, unsigned char *sha1, int, int *);
Junio C Hamanoe86eb662007-01-19 09:15:15[diff] [blame]667extern int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref);
Johannes Schindelineb3a4822007-02-09 00:28:23[diff] [blame]668extern int dwim_log(const char *str, int len, unsigned char *sha1, char **ref);
Junio C Hamanoe86eb662007-01-19 09:15:15[diff] [blame]669
Steffen Prohaska79803322007-11-11 14:01:46[diff] [blame]670extern int refname_match(const char *abbrev_name, const char *full_name, const char **rules);
671extern const char *ref_rev_parse_rules[];
Steffen Prohaska605b4972007-11-11 14:01:48[diff] [blame]672extern const char *ref_fetch_rules[];
Steffen Prohaska79803322007-11-11 14:01:46[diff] [blame]673
Nicolas Pitre8b5157e2007-01-26 22:26:10[diff] [blame]674extern int create_symref(const char *ref, const char *refs_heads_master, const char *logmsg);
Junio C Hamanoc847f532007-01-02 07:31:08[diff] [blame]675extern int validate_headref(const char *ref);
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]676
Linus Torvalds958ba6c2005-05-20 16:09:18[diff] [blame]677extern int base_name_compare(const char *name1, int len1, int mode1, const char *name2, int len2, int mode2);
Linus Torvalds0ab9e1e2008-03-06 02:25:10[diff] [blame]678extern int df_name_compare(const char *name1, int len1, int mode1, const char *name2, int len2, int mode2);
Linus Torvalds79517a02005-04-09 19:59:11[diff] [blame]679extern int cache_name_compare(const char *name1, int len1, const char *name2, int len2);
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]680
Junio C Hamano40469ee2005-04-28 23:42:27[diff] [blame]681extern void *read_object_with_reference(const unsigned char *sha1,
Brian Gerstbf0f9102005-05-18 12:14:09[diff] [blame]682 const char *required_type,
Junio C Hamano40469ee2005-04-28 23:42:27[diff] [blame]683 unsigned long *size,
684 unsigned char *sha1_ret);
Junio C Hamanof4913f92005-04-21 01:06:49[diff] [blame]685
Junio C Hamano81776312007-12-24 08:51:01[diff] [blame]686extern struct object *peel_to_type(const char *name, int namelen,
687 struct object *o, enum object_type);
688
Junio C Hamano73013af2007-07-14 06:14:52[diff] [blame]689enum date_mode {
690 DATE_NORMAL = 0,
691 DATE_RELATIVE,
692 DATE_SHORT,
693 DATE_LOCAL,
694 DATE_ISO8601,
695 DATE_RFC2822
696};
697
Johannes Schindelinf8493ec2007-02-27 15:21:04[diff] [blame]698const char *show_date(unsigned long time, int timezone, enum date_mode mode);
Linus Torvalds2a390642005-09-19 22:53:50[diff] [blame]699int parse_date(const char *date, char *buf, int bufsize);
Edgar Toernigecee9d92005-04-30 16:46:49[diff] [blame]700void datestamp(char *buf, int bufsize);
Linus Torvalds3c07b1d2005-11-15 03:29:06[diff] [blame]701unsigned long approxidate(const char *);
Andy Parkins856665f2007-09-28 14:17:31[diff] [blame]702enum date_mode parse_date_format(const char *format);
Edgar Toernigecee9d92005-04-30 16:46:49[diff] [blame]703
Junio C Hamano774751a2007-12-09 01:32:08[diff] [blame]704#define IDENT_WARN_ON_NO_NAME 1
705#define IDENT_ERROR_ON_NO_NAME 2
706#define IDENT_NO_DATE 4
Junio C Hamano749be722006-02-19 04:31:05[diff] [blame]707extern const char *git_author_info(int);
708extern const char *git_committer_info(int);
Junio C Hamano798123a2007-02-05 01:50:14[diff] [blame]709extern const char *fmt_ident(const char *name, const char *email, const char *date_str, int);
Junio C Hamanod9ccfe72007-12-02 21:43:34[diff] [blame]710extern const char *fmt_name(const char *name, const char *email);
Linus Torvalds6aa33f42005-07-12 18:49:27[diff] [blame]711
Linus Torvalds12dccc12005-06-06 04:59:54[diff] [blame]712struct checkout {
713 const char *base_dir;
714 int base_dir_len;
715 unsigned force:1,
716 quiet:1,
717 not_new:1,
718 refresh_cache:1;
719};
720
Luiz Fernando N. Capitulinoefbc5832007-04-25 14:18:08[diff] [blame]721extern int checkout_entry(struct cache_entry *ce, const struct checkout *state, char *topath);
Linus Torvaldsc40641b2008-05-09 16:21:07[diff] [blame]722extern int has_symlink_leading_path(int len, const char *name);
Linus Torvalds12dccc12005-06-06 04:59:54[diff] [blame]723
Junio C Hamano9a217f22005-06-28 21:56:57[diff] [blame]724extern struct alternate_object_database {
Junio C Hamanod5a63b92005-08-15 00:25:57[diff] [blame]725 struct alternate_object_database *next;
Junio C Hamano9a217f22005-06-28 21:56:57[diff] [blame]726 char *name;
Junio C Hamano8f1d2e62006-01-07 09:33:54[diff] [blame]727 char base[FLEX_ARRAY]; /* more */
Junio C Hamanod5a63b92005-08-15 00:25:57[diff] [blame]728} *alt_odb_list;
Junio C Hamano9a217f22005-06-28 21:56:57[diff] [blame]729extern void prepare_alt_odb(void);
Daniel Barkalowbef70b22008-04-17 23:32:30[diff] [blame]730extern void add_to_alternates_file(const char *reference);
Junio C Hamanod79796b2008-09-09 08:27:10[diff] [blame]731typedef int alt_odb_fn(struct alternate_object_database *, void *);
732extern void foreach_alt_odb(alt_odb_fn, void*);
Junio C Hamano9a217f22005-06-28 21:56:57[diff] [blame]733
Shawn O. Pearcec41ee582006-12-23 07:33:44[diff] [blame]734struct pack_window {
735 struct pack_window *next;
736 unsigned char *base;
737 off_t offset;
738 size_t len;
739 unsigned int last_used;
740 unsigned int inuse_cnt;
741};
742
Junio C Hamano9a217f22005-06-28 21:56:57[diff] [blame]743extern struct packed_git {
744 struct packed_git *next;
Shawn O. Pearcec41ee582006-12-23 07:33:44[diff] [blame]745 struct pack_window *windows;
Shawn O. Pearce2dc3a232006-12-23 07:33:47[diff] [blame]746 off_t pack_size;
Nicolas Pitre57059092007-04-09 05:06:28[diff] [blame]747 const void *index_data;
748 size_t index_size;
749 uint32_t num_objects;
Nicolas Pitre8eca0b42008-06-24 01:23:39[diff] [blame]750 uint32_t num_bad_objects;
751 unsigned char *bad_object_sha1;
Nicolas Pitre42873072007-03-16 20:42:50[diff] [blame]752 int index_version;
Nicolas Pitre57059092007-04-09 05:06:28[diff] [blame]753 time_t mtime;
Shawn O. Pearce9bc879c2006-12-23 07:34:01[diff] [blame]754 int pack_fd;
Brandon Casey8d259312008-11-12 17:59:03[diff] [blame]755 unsigned pack_local:1,
756 pack_keep:1;
barkalow@iabervon.orgbf592c52005-08-01 00:53:44[diff] [blame]757 unsigned char sha1[20];
Junio C Hamano8f1d2e62006-01-07 09:33:54[diff] [blame]758 /* something like ".git/objects/pack/xxxxx.pack" */
759 char pack_name[FLEX_ARRAY]; /* more */
Junio C Hamano9a217f22005-06-28 21:56:57[diff] [blame]760} *packed_git;
Junio C Hamanof3bf9222005-07-01 00:15:39[diff] [blame]761
762struct pack_entry {
Shawn O. Pearcec4001d92007-03-07 01:44:30[diff] [blame]763 off_t offset;
Junio C Hamanof3bf9222005-07-01 00:15:39[diff] [blame]764 unsigned char sha1[20];
765 struct packed_git *p;
766};
767
Linus Torvaldsd1c133f2005-07-16 20:55:50[diff] [blame]768struct ref {
769 struct ref *next;
770 unsigned char old_sha1[20];
771 unsigned char new_sha1[20];
Daniel Barkalowbe885d92008-04-26 19:53:12[diff] [blame]772 char *symref;
Shawn O. Pearce9f8a15c2007-11-18 09:31:37[diff] [blame]773 unsigned int force:1,
774 merge:1,
775 nonfastforward:1,
776 deletion:1;
Jeff King8736a842007-11-17 12:54:27[diff] [blame]777 enum {
778 REF_STATUS_NONE = 0,
779 REF_STATUS_OK,
780 REF_STATUS_REJECT_NONFASTFORWARD,
781 REF_STATUS_REJECT_NODELETE,
782 REF_STATUS_UPTODATE,
Jeff Kingca74c452007-11-17 12:56:03[diff] [blame]783 REF_STATUS_REMOTE_REJECT,
Jeff King2a0fe892007-11-18 07:16:52[diff] [blame]784 REF_STATUS_EXPECTING_REPORT,
Jeff King8736a842007-11-17 12:54:27[diff] [blame]785 } status;
Jeff King2a0fe892007-11-18 07:16:52[diff] [blame]786 char *remote_status;
Junio C Hamanof88395a2005-08-03 23:35:29[diff] [blame]787 struct ref *peer_ref; /* when renaming */
Junio C Hamano8f1d2e62006-01-07 09:33:54[diff] [blame]788 char name[FLEX_ARRAY]; /* more */
Linus Torvaldsd1c133f2005-07-16 20:55:50[diff] [blame]789};
790
Linus Torvalds2718ff02006-07-04 19:29:10[diff] [blame]791#define REF_NORMAL (1u << 0)
792#define REF_HEADS (1u << 1)
793#define REF_TAGS (1u << 2)
794
Jeff Kingcda69f42007-11-18 07:13:10[diff] [blame]795extern struct ref *find_ref_by_name(struct ref *list, const char *name);
796
Michael S. Tsirkin7841ce72007-05-16 17:09:41[diff] [blame]797#define CONNECT_VERBOSE (1u << 0)
Daniel Barkalow45773702007-10-30 01:05:40[diff] [blame]798extern struct child_process *git_connect(int fd[2], const char *url, const char *prog, int flags);
Johannes Sixt98158e92007-10-19 19:47:53[diff] [blame]799extern int finish_connect(struct child_process *conn);
Linus Torvalds013e7c72005-07-04 20:24:30[diff] [blame]800extern int path_match(const char *path, int nr, char **match);
Linus Torvalds41cb7482005-07-05 22:44:09[diff] [blame]801extern int get_ack(int fd, unsigned char *result_sha1);
Junio C Hamano40c155f2008-09-09 08:27:09[diff] [blame]802struct extra_have_objects {
803 int nr, alloc;
804 unsigned char (*array)[20];
805};
806extern struct ref **get_remote_heads(int in, struct ref **list, int nr_match, char **match, unsigned int flags, struct extra_have_objects *);
Johannes Schindelin211b5f92005-10-28 02:48:54[diff] [blame]807extern int server_supports(const char *feature);
Linus Torvaldsf7192592005-07-04 18:57:58[diff] [blame]808
barkalow@iabervon.orgbf592c52005-08-01 00:53:44[diff] [blame]809extern struct packed_git *parse_pack_index(unsigned char *sha1);
barkalow@iabervon.orgbf592c52005-08-01 00:53:44[diff] [blame]810
Junio C Hamano9a217f22005-06-28 21:56:57[diff] [blame]811extern void prepare_packed_git(void);
Shawn Pearcefc04c412006-11-01 22:06:21[diff] [blame]812extern void reprepare_packed_git(void);
barkalow@iabervon.orgbf592c52005-08-01 00:53:44[diff] [blame]813extern void install_packed_git(struct packed_git *pack);
814
Junio C Hamanoa6080a02007-06-07 07:04:01[diff] [blame]815extern struct packed_git *find_sha1_pack(const unsigned char *sha1,
barkalow@iabervon.orgbf592c52005-08-01 00:53:44[diff] [blame]816 struct packed_git *packs);
817
Chris Wedgwood276bc2c2007-01-17 06:28:02[diff] [blame]818extern void pack_report(void);
Shawn O. Pearced0798372007-05-26 05:24:19[diff] [blame]819extern int open_pack_index(struct packed_git *);
Shawn O. Pearcec4001d92007-03-07 01:44:30[diff] [blame]820extern unsigned char* use_pack(struct packed_git *, struct pack_window **, off_t, unsigned int *);
Shawn O. Pearcec9ced052008-01-18 03:57:00[diff] [blame]821extern void close_pack_windows(struct packed_git *);
Shawn O. Pearce03e79c82006-12-23 07:34:08[diff] [blame]822extern void unuse_pack(struct pack_window **);
Nicolas Pitrec74faea2008-12-09 19:26:52[diff] [blame]823extern void free_pack_by_name(const char *);
Nicolas Pitre42873072007-03-16 20:42:50[diff] [blame]824extern struct packed_git *add_packed_git(const char *, int, int);
Shawn O. Pearced0798372007-05-26 05:24:19[diff] [blame]825extern const unsigned char *nth_packed_object_sha1(struct packed_git *, uint32_t);
Nicolas Pitre99093232008-06-25 03:17:12[diff] [blame]826extern off_t nth_packed_object_offset(const struct packed_git *, uint32_t);
Shawn O. Pearcec4001d92007-03-07 01:44:30[diff] [blame]827extern off_t find_pack_entry_one(const unsigned char *, struct packed_git *);
828extern void *unpack_entry(struct packed_git *, off_t, enum object_type *, unsigned long *);
Nicolas Pitre09ded042008-10-29 23:02:46[diff] [blame]829extern unsigned long unpack_object_header_buffer(const unsigned char *buf, unsigned long len, enum object_type *type, unsigned long *sizep);
Nicolas Pitre54dab522007-04-16 16:31:56[diff] [blame]830extern unsigned long get_size_from_delta(struct packed_git *, struct pack_window **, off_t);
Shawn O. Pearcec4001d92007-03-07 01:44:30[diff] [blame]831extern const char *packed_object_info_detail(struct packed_git *, off_t, unsigned long *, unsigned long *, unsigned int *, unsigned char *);
Junio C Hamano000dfd32007-09-17 06:15:19[diff] [blame]832extern int matches_pack_name(struct packed_git *p, const char *name);
Junio C Hamano9a217f22005-06-28 21:56:57[diff] [blame]833
Junio C Hamano8f3f9b02005-07-24 00:54:41[diff] [blame]834/* Dumb servers support */
835extern int update_server_info(int);
836
Johannes Schindelinef90d6d2008-05-14 17:46:53[diff] [blame]837typedef int (*config_fn_t)(const char *, const char *, void *);
838extern int git_default_config(const char *, const char *, void *);
839extern int git_config_from_file(config_fn_t fn, const char *, void *);
840extern int git_config(config_fn_t fn, void *);
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]841extern int git_parse_ulong(const char *, unsigned long *);
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]842extern int git_config_int(const char *, const char *);
Brian Downing0b87b6e2007-07-12 13:32:26[diff] [blame]843extern unsigned long git_config_ulong(const char *, const char *);
Junio C Hamanoa53f2ec2008-04-13 01:33:31[diff] [blame]844extern int git_config_bool_or_int(const char *, const char *, int *);
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]845extern int git_config_bool(const char *, const char *);
Christian Couderea5105a2008-02-16 05:00:24[diff] [blame]846extern int git_config_string(const char **, const char *, const char *);
Johannes Schindelin10bea152005-11-17 21:32:36[diff] [blame]847extern int git_config_set(const char *, const char *);
Johannes Schindelin4ddba792005-11-20 05:52:22[diff] [blame]848extern int git_config_set_multivar(const char *, const char *, const char *, int);
Johannes Schindelin0667fcf2006-12-16 14:14:14[diff] [blame]849extern int git_config_rename_section(const char *, const char *);
Johannes Sixt506b17b2007-11-13 20:05:05[diff] [blame]850extern const char *git_etc_gitconfig(void);
Johannes Schindelinef90d6d2008-05-14 17:46:53[diff] [blame]851extern int check_repository_format_version(const char *var, const char *value, void *cb);
Jeff Kingab88c362008-02-06 10:11:18[diff] [blame]852extern int git_config_system(void);
853extern int git_config_global(void);
Junio C Hamano40ea4ed2008-02-11 18:41:18[diff] [blame]854extern int config_error_nonbool(const char *);
Daniel Barkalowdc871832008-06-30 07:37:47[diff] [blame]855extern const char *config_exclusive_filename;
Linus Torvalds17712992005-10-10 23:31:08[diff] [blame]856
Linus Torvaldse1b10392005-10-12 01:47:34[diff] [blame]857#define MAX_GITNAME (1000)
858extern char git_default_email[MAX_GITNAME];
859extern char git_default_name[MAX_GITNAME];
Santi Béjarbb1ae3f2008-05-04 16:04:51[diff] [blame]860extern int user_ident_explicitly_given;
Linus Torvaldse1b10392005-10-12 01:47:34[diff] [blame]861
Shawn O. Pearce1a8f2742007-03-12 19:33:18[diff] [blame]862extern const char *git_commit_encoding;
Shawn O. Pearce3a556022007-03-07 01:44:17[diff] [blame]863extern const char *git_log_output_encoding;
Junio C Hamano4e72dce2005-11-28 00:09:40[diff] [blame]864
Theodore Ts'o06f59e92007-06-29 17:40:46[diff] [blame]865/* IO helper functions */
866extern void maybe_flush_or_die(FILE *, const char *);
Junio C Hamanof3123c42005-10-22 08:28:13[diff] [blame]867extern int copy_fd(int ifd, int ofd);
Daniel Barkalow1468bd42008-02-25 19:24:48[diff] [blame]868extern int copy_file(const char *dst, const char *src, int mode);
Heikki Orsila0104ca02008-04-27 18:21:58[diff] [blame]869extern ssize_t read_in_full(int fd, void *buf, size_t count);
870extern ssize_t write_in_full(int fd, const void *buf, size_t count);
Rene Scharfe7230e6d2006-08-21 18:43:43[diff] [blame]871extern void write_or_die(int fd, const void *buf, size_t count);
Christian Couder6ce4e612006-09-02 16:23:48[diff] [blame]872extern int write_or_whine(int fd, const void *buf, size_t count, const char *msg);
Andy Whitcrofte0814052007-01-08 15:57:52[diff] [blame]873extern int write_or_whine_pipe(int fd, const void *buf, size_t count, const char *msg);
Linus Torvalds4c81b032008-05-30 15:42:16[diff] [blame]874extern void fsync_or_die(int fd, const char *);
Junio C Hamanoad897212005-12-15 06:17:38[diff] [blame]875
Linus Torvaldsf67b45f2006-02-28 19:26:21[diff] [blame]876/* pager.c */
877extern void setup_pager(void);
Christian Couder872da322008-02-16 05:01:11[diff] [blame]878extern const char *pager_program;
Jeff King6e9af862007-12-11 06:27:33[diff] [blame]879extern int pager_in_use(void);
Matthias Lederhoferaa086eb2006-07-29 22:27:43[diff] [blame]880extern int pager_use_color;
Linus Torvaldsf67b45f2006-02-28 19:26:21[diff] [blame]881
Christian Couderee9601e2008-02-16 05:01:41[diff] [blame]882extern const char *editor_program;
Christian Couderdfb068b2008-02-16 05:01:59[diff] [blame]883extern const char *excludes_file;
Johannes Schindelin4d87b9c2007-07-20 12:06:09[diff] [blame]884
Junio C Hamano051308f2006-05-04 23:51:44[diff] [blame]885/* base85 */
Jim Meyeringf9815772007-04-09 22:56:33[diff] [blame]886int decode_85(char *dst, const char *line, int linelen);
887void encode_85(char *buf, const unsigned char *data, int bytes);
Junio C Hamano051308f2006-05-04 23:51:44[diff] [blame]888
Linus Torvalds855419f2006-06-19 17:44:15[diff] [blame]889/* alloc.c */
Linus Torvalds100c5f32007-04-17 05:11:43[diff] [blame]890extern void *alloc_blob_node(void);
891extern void *alloc_tree_node(void);
892extern void *alloc_commit_node(void);
893extern void *alloc_tag_node(void);
894extern void *alloc_object_node(void);
Linus Torvalds855419f2006-06-19 17:44:15[diff] [blame]895extern void alloc_report(void);
896
Christian Couder6ce4e612006-09-02 16:23:48[diff] [blame]897/* trace.c */
Christian Couder6ce4e612006-09-02 16:23:48[diff] [blame]898extern void trace_printf(const char *format, ...);
Christian Couderb319ce42007-12-03 04:51:50[diff] [blame]899extern void trace_argv_printf(const char **argv, const char *format, ...);
Christian Couder6ce4e612006-09-02 16:23:48[diff] [blame]900
Linus Torvalds6c510be2007-02-13 19:07:23[diff] [blame]901/* convert.c */
Pierre Habouzit5ecd2932007-09-16 13:51:04[diff] [blame]902/* returns 1 if *dst was used */
Steffen Prohaska21e5ad52008-02-06 11:25:58[diff] [blame]903extern int convert_to_git(const char *path, const char *src, size_t len,
904 struct strbuf *dst, enum safe_crlf checksafe);
Pierre Habouzit5ecd2932007-09-16 13:51:04[diff] [blame]905extern int convert_to_working_tree(const char *path, const char *src, size_t len, struct strbuf *dst);
Linus Torvalds6c510be2007-02-13 19:07:23[diff] [blame]906
Junio C Hamanob6ec1d62007-11-18 09:12:04[diff] [blame]907/* add */
Alex Riesen7ae02a32008-05-12 17:58:10[diff] [blame]908/*
909 * return 0 if success, 1 - if addition of a file failed and
910 * ADD_FILES_IGNORE_ERRORS was specified in flags
911 */
912int add_files_to_cache(const char *prefix, const char **pathspec, int flags);
Junio C Hamanob6ec1d62007-11-18 09:12:04[diff] [blame]913
Junio C Hamanoaecbf912007-08-31 20:13:42[diff] [blame]914/* diff.c */
915extern int diff_auto_refresh_index;
916
Junio C Hamano68faf682007-02-16 00:32:45[diff] [blame]917/* match-trees.c */
918void shift_tree(const unsigned char *, const unsigned char *, unsigned char *, int);
919
Junio C Hamanoa9cc8572007-11-02 07:24:27[diff] [blame]920/*
921 * whitespace rules.
922 * used by both diff and apply
923 */
924#define WS_TRAILING_SPACE 01
925#define WS_SPACE_BEFORE_TAB 02
Junio C Hamano459fa6d2007-10-03 01:00:27[diff] [blame]926#define WS_INDENT_WITH_NON_TAB 04
Junio C Hamanob2979ff2008-01-15 08:59:05[diff] [blame]927#define WS_CR_AT_EOL 010
Junio C Hamanoa9cc8572007-11-02 07:24:27[diff] [blame]928#define WS_DEFAULT_RULE (WS_TRAILING_SPACE|WS_SPACE_BEFORE_TAB)
Junio C Hamanocf1b7862007-12-06 08:14:14[diff] [blame]929extern unsigned whitespace_rule_cfg;
930extern unsigned whitespace_rule(const char *);
931extern unsigned parse_whitespace_rule(const char *);
Junio C Hamano8f8841e2008-06-26 22:35:21[diff] [blame]932extern unsigned ws_check(const char *line, int len, unsigned ws_rule);
933extern void ws_check_emit(const char *line, int len, unsigned ws_rule, FILE *stream, const char *set, const char *reset, const char *ws);
Wincent Colaiutac1795bb2007-12-13 13:32:29[diff] [blame]934extern char *whitespace_error_string(unsigned ws);
Junio C Hamanofe3403c2008-02-24 00:59:16[diff] [blame]935extern int ws_fix_copy(char *, const char *, int, unsigned, int *);
Junio C Hamano877f23c2008-06-26 22:36:59[diff] [blame]936extern int ws_blank_line(const char *line, int len, unsigned ws_rule);
Junio C Hamanoa9cc8572007-11-02 07:24:27[diff] [blame]937
Junio C Hamanoee425e42007-11-18 09:13:32[diff] [blame]938/* ls-files */
939int pathspec_match(const char **spec, char *matched, const char *filename, int skiplen);
940int report_path_error(const char *ps_matched, const char **pathspec, int prefix_offset);
941void overlay_tree_on_cache(const char *tree_name, const char *prefix);
942
Jeff King94351112008-02-24 22:17:14[diff] [blame]943char *alias_lookup(const char *alias);
Miklos Vajna0989fe92008-06-27 16:21:54[diff] [blame]944int split_cmdline(char *cmdline, const char ***argv);
Jeff King94351112008-02-24 22:17:14[diff] [blame]945
Linus Torvaldse83c5162005-04-07 22:13:13[diff] [blame]946#endif /* CACHE_H */