Merge branch 'jk/show-branch-lift-name-len-limit' into maint
[git] / commit.h
1 #ifndef COMMIT_H
2 #define COMMIT_H
3
4 #include "object.h"
5 #include "tree.h"
6 #include "strbuf.h"
7 #include "decorate.h"
8 #include "gpg-interface.h"
9 #include "string-list.h"
10
11 struct commit_list {
12         struct commit *item;
13         struct commit_list *next;
14 };
15
16 struct commit {
17         struct object object;
18         void *util;
19         unsigned int index;
20         unsigned long date;
21         struct commit_list *parents;
22         struct tree *tree;
23 };
24
25 extern int save_commit_buffer;
26 extern const char *commit_type;
27
28 /* While we can decorate any object with a name, it's only used for commits.. */
29 struct name_decoration {
30         struct name_decoration *next;
31         int type;
32         char name[FLEX_ARRAY];
33 };
34
35 enum decoration_type {
36         DECORATION_NONE = 0,
37         DECORATION_REF_LOCAL,
38         DECORATION_REF_REMOTE,
39         DECORATION_REF_TAG,
40         DECORATION_REF_STASH,
41         DECORATION_REF_HEAD,
42         DECORATION_GRAFTED,
43 };
44
45 void add_name_decoration(enum decoration_type type, const char *name, struct object *obj);
46 const struct name_decoration *get_name_decoration(const struct object *obj);
47
48 struct commit *lookup_commit(const unsigned char *sha1);
49 struct commit *lookup_commit_reference(const unsigned char *sha1);
50 struct commit *lookup_commit_reference_gently(const unsigned char *sha1,
51                                               int quiet);
52 struct commit *lookup_commit_reference_by_name(const char *name);
53
54 /*
55  * Look up object named by "sha1", dereference tag as necessary,
56  * get a commit and return it. If "sha1" does not dereference to
57  * a commit, use ref_name to report an error and die.
58  */
59 struct commit *lookup_commit_or_die(const unsigned char *sha1, const char *ref_name);
60
61 int parse_commit_buffer(struct commit *item, const void *buffer, unsigned long size);
62 int parse_commit_gently(struct commit *item, int quiet_on_missing);
63 static inline int parse_commit(struct commit *item)
64 {
65         return parse_commit_gently(item, 0);
66 }
67 void parse_commit_or_die(struct commit *item);
68
69 /*
70  * Associate an object buffer with the commit. The ownership of the
71  * memory is handed over to the commit, and must be free()-able.
72  */
73 void set_commit_buffer(struct commit *, void *buffer, unsigned long size);
74
75 /*
76  * Get any cached object buffer associated with the commit. Returns NULL
77  * if none. The resulting memory should not be freed.
78  */
79 const void *get_cached_commit_buffer(const struct commit *, unsigned long *size);
80
81 /*
82  * Get the commit's object contents, either from cache or by reading the object
83  * from disk. The resulting memory should not be modified, and must be given
84  * to unuse_commit_buffer when the caller is done.
85  */
86 const void *get_commit_buffer(const struct commit *, unsigned long *size);
87
88 /*
89  * Tell the commit subsytem that we are done with a particular commit buffer.
90  * The commit and buffer should be the input and return value, respectively,
91  * from an earlier call to get_commit_buffer.  The buffer may or may not be
92  * freed by this call; callers should not access the memory afterwards.
93  */
94 void unuse_commit_buffer(const struct commit *, const void *buffer);
95
96 /*
97  * Free any cached object buffer associated with the commit.
98  */
99 void free_commit_buffer(struct commit *);
100
101 /*
102  * Disassociate any cached object buffer from the commit, but do not free it.
103  * The buffer (or NULL, if none) is returned.
104  */
105 const void *detach_commit_buffer(struct commit *, unsigned long *sizep);
106
107 /* Find beginning and length of commit subject. */
108 int find_commit_subject(const char *commit_buffer, const char **subject);
109
110 struct commit_list *commit_list_insert(struct commit *item,
111                                         struct commit_list **list);
112 struct commit_list **commit_list_append(struct commit *commit,
113                                         struct commit_list **next);
114 unsigned commit_list_count(const struct commit_list *l);
115 struct commit_list *commit_list_insert_by_date(struct commit *item,
116                                     struct commit_list **list);
117 void commit_list_sort_by_date(struct commit_list **list);
118
119 /* Shallow copy of the input list */
120 struct commit_list *copy_commit_list(struct commit_list *list);
121
122 void free_commit_list(struct commit_list *list);
123
124 /* Commit formats */
125 enum cmit_fmt {
126         CMIT_FMT_RAW,
127         CMIT_FMT_MEDIUM,
128         CMIT_FMT_DEFAULT = CMIT_FMT_MEDIUM,
129         CMIT_FMT_SHORT,
130         CMIT_FMT_FULL,
131         CMIT_FMT_FULLER,
132         CMIT_FMT_ONELINE,
133         CMIT_FMT_EMAIL,
134         CMIT_FMT_MBOXRD,
135         CMIT_FMT_USERFORMAT,
136
137         CMIT_FMT_UNSPECIFIED
138 };
139
140 static inline int cmit_fmt_is_mail(enum cmit_fmt fmt)
141 {
142         return (fmt == CMIT_FMT_EMAIL || fmt == CMIT_FMT_MBOXRD);
143 }
144
145 struct pretty_print_context {
146         /*
147          * Callers should tweak these to change the behavior of pp_* functions.
148          */
149         enum cmit_fmt fmt;
150         int abbrev;
151         const char *subject;
152         const char *after_subject;
153         int preserve_subject;
154         struct date_mode date_mode;
155         unsigned date_mode_explicit:1;
156         int expand_tabs_in_log;
157         int need_8bit_cte;
158         char *notes_message;
159         struct reflog_walk_info *reflog_info;
160         const char *output_encoding;
161         struct string_list *mailmap;
162         int color;
163         struct ident_split *from_ident;
164
165         /*
166          * Fields below here are manipulated internally by pp_* functions and
167          * should not be counted on by callers.
168          */
169         struct string_list in_body_headers;
170         int graph_width;
171 };
172
173 struct userformat_want {
174         unsigned notes:1;
175 };
176
177 extern int has_non_ascii(const char *text);
178 struct rev_info; /* in revision.h, it circularly uses enum cmit_fmt */
179 extern const char *logmsg_reencode(const struct commit *commit,
180                                    char **commit_encoding,
181                                    const char *output_encoding);
182 extern void get_commit_format(const char *arg, struct rev_info *);
183 extern const char *format_subject(struct strbuf *sb, const char *msg,
184                                   const char *line_separator);
185 extern void userformat_find_requirements(const char *fmt, struct userformat_want *w);
186 extern int commit_format_is_empty(enum cmit_fmt);
187 extern const char *skip_blank_lines(const char *msg);
188 extern void format_commit_message(const struct commit *commit,
189                                   const char *format, struct strbuf *sb,
190                                   const struct pretty_print_context *context);
191 extern void pretty_print_commit(struct pretty_print_context *pp,
192                                 const struct commit *commit,
193                                 struct strbuf *sb);
194 extern void pp_commit_easy(enum cmit_fmt fmt, const struct commit *commit,
195                            struct strbuf *sb);
196 void pp_user_info(struct pretty_print_context *pp,
197                   const char *what, struct strbuf *sb,
198                   const char *line, const char *encoding);
199 void pp_title_line(struct pretty_print_context *pp,
200                    const char **msg_p,
201                    struct strbuf *sb,
202                    const char *encoding,
203                    int need_8bit_cte);
204 void pp_remainder(struct pretty_print_context *pp,
205                   const char **msg_p,
206                   struct strbuf *sb,
207                   int indent);
208
209
210 /** Removes the first commit from a list sorted by date, and adds all
211  * of its parents.
212  **/
213 struct commit *pop_most_recent_commit(struct commit_list **list,
214                                       unsigned int mark);
215
216 struct commit *pop_commit(struct commit_list **stack);
217
218 void clear_commit_marks(struct commit *commit, unsigned int mark);
219 void clear_commit_marks_many(int nr, struct commit **commit, unsigned int mark);
220 void clear_commit_marks_for_object_array(struct object_array *a, unsigned mark);
221
222
223 enum rev_sort_order {
224         REV_SORT_IN_GRAPH_ORDER = 0,
225         REV_SORT_BY_COMMIT_DATE,
226         REV_SORT_BY_AUTHOR_DATE
227 };
228
229 /*
230  * Performs an in-place topological sort of list supplied.
231  *
232  *   invariant of resulting list is:
233  *      a reachable from b => ord(b) < ord(a)
234  *   sort_order further specifies:
235  *   REV_SORT_IN_GRAPH_ORDER: try to show a commit on a single-parent
236  *                            chain together.
237  *   REV_SORT_BY_COMMIT_DATE: show eligible commits in committer-date order.
238  */
239 void sort_in_topological_order(struct commit_list **, enum rev_sort_order);
240
241 struct commit_graft {
242         struct object_id oid;
243         int nr_parent; /* < 0 if shallow commit */
244         struct object_id parent[FLEX_ARRAY]; /* more */
245 };
246 typedef int (*each_commit_graft_fn)(const struct commit_graft *, void *);
247
248 struct commit_graft *read_graft_line(char *buf, int len);
249 int register_commit_graft(struct commit_graft *, int);
250 struct commit_graft *lookup_commit_graft(const unsigned char *sha1);
251
252 extern struct commit_list *get_merge_bases(struct commit *rev1, struct commit *rev2);
253 extern struct commit_list *get_merge_bases_many(struct commit *one, int n, struct commit **twos);
254 extern struct commit_list *get_octopus_merge_bases(struct commit_list *in);
255
256 /* To be used only when object flags after this call no longer matter */
257 extern struct commit_list *get_merge_bases_many_dirty(struct commit *one, int n, struct commit **twos);
258
259 /* largest positive number a signed 32-bit integer can contain */
260 #define INFINITE_DEPTH 0x7fffffff
261
262 struct sha1_array;
263 struct ref;
264 extern int register_shallow(const unsigned char *sha1);
265 extern int unregister_shallow(const unsigned char *sha1);
266 extern int for_each_commit_graft(each_commit_graft_fn, void *);
267 extern int is_repository_shallow(void);
268 extern struct commit_list *get_shallow_commits(struct object_array *heads,
269                 int depth, int shallow_flag, int not_shallow_flag);
270 extern struct commit_list *get_shallow_commits_by_rev_list(
271                 int ac, const char **av, int shallow_flag, int not_shallow_flag);
272 extern void set_alternate_shallow_file(const char *path, int override);
273 extern int write_shallow_commits(struct strbuf *out, int use_pack_protocol,
274                                  const struct sha1_array *extra);
275 extern void setup_alternate_shallow(struct lock_file *shallow_lock,
276                                     const char **alternate_shallow_file,
277                                     const struct sha1_array *extra);
278 extern const char *setup_temporary_shallow(const struct sha1_array *extra);
279 extern void advertise_shallow_grafts(int);
280
281 struct shallow_info {
282         struct sha1_array *shallow;
283         int *ours, nr_ours;
284         int *theirs, nr_theirs;
285         struct sha1_array *ref;
286
287         /* for receive-pack */
288         uint32_t **used_shallow;
289         int *need_reachability_test;
290         int *reachable;
291         int *shallow_ref;
292         struct commit **commits;
293         int nr_commits;
294 };
295
296 extern void prepare_shallow_info(struct shallow_info *, struct sha1_array *);
297 extern void clear_shallow_info(struct shallow_info *);
298 extern void remove_nonexistent_theirs_shallow(struct shallow_info *);
299 extern void assign_shallow_commits_to_refs(struct shallow_info *info,
300                                            uint32_t **used,
301                                            int *ref_status);
302 extern int delayed_reachability_test(struct shallow_info *si, int c);
303 extern void prune_shallow(int show_only);
304 extern struct trace_key trace_shallow;
305
306 int is_descendant_of(struct commit *, struct commit_list *);
307 int in_merge_bases(struct commit *, struct commit *);
308 int in_merge_bases_many(struct commit *, int, struct commit **);
309
310 extern int interactive_add(int argc, const char **argv, const char *prefix, int patch);
311 extern int run_add_interactive(const char *revision, const char *patch_mode,
312                                const struct pathspec *pathspec);
313
314 static inline int single_parent(struct commit *commit)
315 {
316         return commit->parents && !commit->parents->next;
317 }
318
319 struct commit_list *reduce_heads(struct commit_list *heads);
320
321 struct commit_extra_header {
322         struct commit_extra_header *next;
323         char *key;
324         char *value;
325         size_t len;
326 };
327
328 extern void append_merge_tag_headers(struct commit_list *parents,
329                                      struct commit_extra_header ***tail);
330
331 extern int commit_tree(const char *msg, size_t msg_len,
332                        const unsigned char *tree,
333                        struct commit_list *parents, unsigned char *ret,
334                        const char *author, const char *sign_commit);
335
336 extern int commit_tree_extended(const char *msg, size_t msg_len,
337                                 const unsigned char *tree,
338                                 struct commit_list *parents, unsigned char *ret,
339                                 const char *author, const char *sign_commit,
340                                 struct commit_extra_header *);
341
342 extern struct commit_extra_header *read_commit_extra_headers(struct commit *, const char **);
343
344 extern void free_commit_extra_headers(struct commit_extra_header *extra);
345
346 /*
347  * Search the commit object contents given by "msg" for the header "key".
348  * Returns a pointer to the start of the header contents, or NULL. The length
349  * of the header, up to the first newline, is returned via out_len.
350  *
351  * Note that some headers (like mergetag) may be multi-line. It is the caller's
352  * responsibility to parse further in this case!
353  */
354 extern const char *find_commit_header(const char *msg, const char *key,
355                                       size_t *out_len);
356
357 /* Find the end of the log message, the right place for a new trailer. */
358 extern int ignore_non_trailer(const char *buf, size_t len);
359
360 typedef void (*each_mergetag_fn)(struct commit *commit, struct commit_extra_header *extra,
361                                  void *cb_data);
362
363 extern void for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data);
364
365 struct merge_remote_desc {
366         struct object *obj; /* the named object, could be a tag */
367         char name[FLEX_ARRAY];
368 };
369 #define merge_remote_util(commit) ((struct merge_remote_desc *)((commit)->util))
370 extern void set_merge_remote_desc(struct commit *commit,
371                                   const char *name, struct object *obj);
372
373 /*
374  * Given "name" from the command line to merge, find the commit object
375  * and return it, while storing merge_remote_desc in its ->util field,
376  * to allow callers to tell if we are told to merge a tag.
377  */
378 struct commit *get_merge_parent(const char *name);
379
380 extern int parse_signed_commit(const struct commit *commit,
381                                struct strbuf *message, struct strbuf *signature);
382 extern int remove_signature(struct strbuf *buf);
383
384 /*
385  * Check the signature of the given commit. The result of the check is stored
386  * in sig->check_result, 'G' for a good signature, 'U' for a good signature
387  * from an untrusted signer, 'B' for a bad signature and 'N' for no signature
388  * at all.  This may allocate memory for sig->gpg_output, sig->gpg_status,
389  * sig->signer and sig->key.
390  */
391 extern int check_commit_signature(const struct commit *commit, struct signature_check *sigc);
392
393 int compare_commits_by_commit_date(const void *a_, const void *b_, void *unused);
394
395 LAST_ARG_MUST_BE_NULL
396 extern int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...);
397
398 #endif /* COMMIT_H */