Daniel Barkalow | 6eb8ae0 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 1 | #ifndef COMMIT_H |
| 2 | #define COMMIT_H |
| 3 | |
| 4 | #include "object.h" |
Elijah Newren | d4a4f92 | 2023-04-22 20:17:26 +0000 | [diff] [blame] | 5 | |
| 6 | struct signature_check; |
| 7 | struct strbuf; |
| 8 | struct tree; |
Daniel Barkalow | 6eb8ae0 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 9 | |
Derrick Stolee | 177722b | 2018-04-10 08:56:05 -0400 | [diff] [blame] | 10 | #define COMMIT_NOT_FROM_GRAPH 0xFFFFFFFF |
Abhishek Kumar | d7f9278 | 2021-01-16 18:11:13 +0000 | [diff] [blame] | 11 | #define GENERATION_NUMBER_INFINITY ((1ULL << 63) - 1) |
| 12 | #define GENERATION_NUMBER_V1_MAX 0x3FFFFFFF |
Derrick Stolee | 83073cc | 2018-04-25 14:37:55 +0000 | [diff] [blame] | 13 | #define GENERATION_NUMBER_ZERO 0 |
Abhishek Kumar | e8b6300 | 2021-01-16 18:11:15 +0000 | [diff] [blame] | 14 | #define GENERATION_NUMBER_V2_OFFSET_MAX ((1ULL << 31) - 1) |
Derrick Stolee | 177722b | 2018-04-10 08:56:05 -0400 | [diff] [blame] | 15 | |
Daniel Barkalow | 6eb8ae0 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 16 | struct commit_list { |
| 17 | struct commit *item; |
| 18 | struct commit_list *next; |
| 19 | }; |
| 20 | |
Nguyễn Thái Ngọc Duy | 9d2c970 | 2018-05-19 07:28:31 +0200 | [diff] [blame] | 21 | /* |
| 22 | * The size of this struct matters in full repo walk operations like |
| 23 | * 'git clone' or 'git gc'. Consider using commit-slab to attach data |
| 24 | * to a commit instead of adding new fields here. |
| 25 | */ |
Daniel Barkalow | 6eb8ae0 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 26 | struct commit { |
| 27 | struct object object; |
Johannes Schindelin | dddbad7 | 2017-04-26 21:29:31 +0200 | [diff] [blame] | 28 | timestamp_t date; |
Daniel Barkalow | 6eb8ae0 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 29 | struct commit_list *parents; |
Derrick Stolee | 7b8a21d | 2018-04-06 19:09:46 +0000 | [diff] [blame] | 30 | |
| 31 | /* |
| 32 | * If the commit is loaded from the commit-graph file, then this |
Nguyễn Thái Ngọc Duy | 301b8c7 | 2019-04-16 16:33:19 +0700 | [diff] [blame] | 33 | * member may be NULL. Only access it through repo_get_commit_tree() |
Derrick Stolee | 7b8a21d | 2018-04-06 19:09:46 +0000 | [diff] [blame] | 34 | * or get_commit_tree_oid(). |
| 35 | */ |
Derrick Stolee | 891435d | 2018-04-06 19:09:32 +0000 | [diff] [blame] | 36 | struct tree *maybe_tree; |
Nguyễn Thái Ngọc Duy | 25f859f | 2018-05-11 19:20:54 +0200 | [diff] [blame] | 37 | unsigned int index; |
Daniel Barkalow | 6eb8ae0 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 38 | }; |
| 39 | |
Linus Torvalds | 60ab26d | 2005-09-15 14:43:17 -0700 | [diff] [blame] | 40 | extern int save_commit_buffer; |
Ævar Arnfjörð Bjarmason | ab62858 | 2021-08-23 12:44:02 +0200 | [diff] [blame] | 41 | extern int no_graft_file_deprecated_advice; |
Daniel Barkalow | 6eb8ae0 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 42 | extern const char *commit_type; |
| 43 | |
Linus Torvalds | ca135e7 | 2007-04-16 16:05:10 -0700 | [diff] [blame] | 44 | /* While we can decorate any object with a name, it's only used for commits.. */ |
Linus Torvalds | ca135e7 | 2007-04-16 16:05:10 -0700 | [diff] [blame] | 45 | struct name_decoration { |
| 46 | struct name_decoration *next; |
Nazri Ramliy | eb3005e | 2010-06-19 09:37:33 +0800 | [diff] [blame] | 47 | int type; |
Jeff King | 2e3dfb2 | 2014-08-26 06:24:20 -0400 | [diff] [blame] | 48 | char name[FLEX_ARRAY]; |
Linus Torvalds | ca135e7 | 2007-04-16 16:05:10 -0700 | [diff] [blame] | 49 | }; |
| 50 | |
Jeff King | 662174d | 2014-08-26 06:23:36 -0400 | [diff] [blame] | 51 | enum decoration_type { |
| 52 | DECORATION_NONE = 0, |
| 53 | DECORATION_REF_LOCAL, |
| 54 | DECORATION_REF_REMOTE, |
| 55 | DECORATION_REF_TAG, |
| 56 | DECORATION_REF_STASH, |
| 57 | DECORATION_REF_HEAD, |
| 58 | DECORATION_GRAFTED, |
| 59 | }; |
| 60 | |
| 61 | void add_name_decoration(enum decoration_type type, const char *name, struct object *obj); |
Jeff King | 2608c24 | 2014-08-26 06:23:54 -0400 | [diff] [blame] | 62 | const struct name_decoration *get_name_decoration(const struct object *obj); |
Jeff King | 662174d | 2014-08-26 06:23:36 -0400 | [diff] [blame] | 63 | |
Phillip Wood | b8dbfd0 | 2022-10-17 13:17:40 +0000 | [diff] [blame] | 64 | /* |
| 65 | * Look up commit named by "oid" respecting replacement objects. |
| 66 | * Returns NULL if "oid" is not a commit or does not exist. |
| 67 | */ |
| 68 | struct commit *lookup_commit_object(struct repository *r, const struct object_id *oid); |
| 69 | |
| 70 | /* |
| 71 | * Look up commit named by "oid" without replacement objects or |
| 72 | * checking for object existence. Returns the requested commit if it |
| 73 | * is found in the object cache, NULL if "oid" is in the object cache |
| 74 | * but is not a commit and a newly allocated unparsed commit object if |
| 75 | * "oid" is not in the object cache. |
| 76 | */ |
Stefan Beller | bacf168 | 2018-06-28 18:22:10 -0700 | [diff] [blame] | 77 | struct commit *lookup_commit(struct repository *r, const struct object_id *oid); |
Stefan Beller | 1f6c72f | 2018-06-28 18:22:22 -0700 | [diff] [blame] | 78 | struct commit *lookup_commit_reference(struct repository *r, |
| 79 | const struct object_id *oid); |
Stefan Beller | d9a05e7 | 2018-06-28 18:22:21 -0700 | [diff] [blame] | 80 | struct commit *lookup_commit_reference_gently(struct repository *r, |
Stefan Beller | 21e1ee8 | 2018-06-28 18:21:57 -0700 | [diff] [blame] | 81 | const struct object_id *oid, |
Junio C Hamano | f76412e | 2005-08-21 02:51:10 -0700 | [diff] [blame] | 82 | int quiet); |
Pat Notz | a6fa599 | 2010-11-02 13:59:07 -0600 | [diff] [blame] | 83 | struct commit *lookup_commit_reference_by_name(const char *name); |
Daniel Barkalow | 6eb8ae0 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 84 | |
Nguyễn Thái Ngọc Duy | baf18fc | 2011-09-17 21:57:45 +1000 | [diff] [blame] | 85 | /* |
brian m. carlson | bc83266 | 2017-05-06 22:10:10 +0000 | [diff] [blame] | 86 | * Look up object named by "oid", dereference tag as necessary, |
| 87 | * get a commit and return it. If "oid" does not dereference to |
Nguyễn Thái Ngọc Duy | baf18fc | 2011-09-17 21:57:45 +1000 | [diff] [blame] | 88 | * a commit, use ref_name to report an error and die. |
| 89 | */ |
brian m. carlson | bc83266 | 2017-05-06 22:10:10 +0000 | [diff] [blame] | 90 | struct commit *lookup_commit_or_die(const struct object_id *oid, const char *ref_name); |
Nguyễn Thái Ngọc Duy | baf18fc | 2011-09-17 21:57:45 +1000 | [diff] [blame] | 91 | |
Stefan Beller | fd8030c | 2018-06-28 18:22:13 -0700 | [diff] [blame] | 92 | int parse_commit_buffer(struct repository *r, struct commit *item, const void *buffer, unsigned long size, int check_graph); |
Stefan Beller | 9e5252a | 2018-11-13 16:12:50 -0800 | [diff] [blame] | 93 | int repo_parse_commit_internal(struct repository *r, struct commit *item, |
| 94 | int quiet_on_missing, int use_commit_graph); |
| 95 | int repo_parse_commit_gently(struct repository *r, |
| 96 | struct commit *item, |
| 97 | int quiet_on_missing); |
| 98 | static inline int repo_parse_commit(struct repository *r, struct commit *item) |
Jeff King | 9cc2b07 | 2015-06-01 05:56:26 -0400 | [diff] [blame] | 99 | { |
Stefan Beller | 9e5252a | 2018-11-13 16:12:50 -0800 | [diff] [blame] | 100 | return repo_parse_commit_gently(r, item, 0); |
Jeff King | 9cc2b07 | 2015-06-01 05:56:26 -0400 | [diff] [blame] | 101 | } |
Ævar Arnfjörð Bjarmason | 43d3561 | 2019-03-25 13:08:33 +0100 | [diff] [blame] | 102 | |
Derrick Stolee | c4cc083 | 2021-02-01 17:15:03 +0000 | [diff] [blame] | 103 | static inline int repo_parse_commit_no_graph(struct repository *r, |
| 104 | struct commit *commit) |
Ævar Arnfjörð Bjarmason | 43d3561 | 2019-03-25 13:08:33 +0100 | [diff] [blame] | 105 | { |
Derrick Stolee | c4cc083 | 2021-02-01 17:15:03 +0000 | [diff] [blame] | 106 | return repo_parse_commit_internal(r, commit, 0, 0); |
Ævar Arnfjörð Bjarmason | 43d3561 | 2019-03-25 13:08:33 +0100 | [diff] [blame] | 107 | } |
| 108 | |
Jeff King | 7059dcc | 2013-10-24 04:52:36 -0400 | [diff] [blame] | 109 | void parse_commit_or_die(struct commit *item); |
Daniel Barkalow | 6eb8ae0 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 110 | |
Stefan Beller | 65ea9d4 | 2018-06-28 18:22:15 -0700 | [diff] [blame] | 111 | struct buffer_slab; |
| 112 | struct buffer_slab *allocate_commit_buffer_slab(void); |
| 113 | void free_commit_buffer_slab(struct buffer_slab *bs); |
| 114 | |
Jeff King | 0fb370d | 2014-06-12 18:05:37 -0400 | [diff] [blame] | 115 | /* |
Jeff King | 66c2827 | 2014-06-10 17:40:14 -0400 | [diff] [blame] | 116 | * Associate an object buffer with the commit. The ownership of the |
| 117 | * memory is handed over to the commit, and must be free()-able. |
| 118 | */ |
Stefan Beller | 1a40fc4 | 2018-06-28 18:22:16 -0700 | [diff] [blame] | 119 | void set_commit_buffer(struct repository *r, struct commit *, void *buffer, unsigned long size); |
Jeff King | 66c2827 | 2014-06-10 17:40:14 -0400 | [diff] [blame] | 120 | |
| 121 | /* |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 122 | * Get any cached object buffer associated with the commit. Returns NULL |
| 123 | * if none. The resulting memory should not be freed. |
| 124 | */ |
Stefan Beller | 4ff7e5c | 2018-06-28 18:22:17 -0700 | [diff] [blame] | 125 | const void *get_cached_commit_buffer(struct repository *, const struct commit *, unsigned long *size); |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 126 | |
| 127 | /* |
| 128 | * Get the commit's object contents, either from cache or by reading the object |
| 129 | * from disk. The resulting memory should not be modified, and must be given |
Ævar Arnfjörð Bjarmason | c7c33f5 | 2023-03-28 15:58:57 +0200 | [diff] [blame] | 130 | * to repo_unuse_commit_buffer when the caller is done. |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 131 | */ |
Stefan Beller | 07de3fd | 2018-11-13 16:12:57 -0800 | [diff] [blame] | 132 | const void *repo_get_commit_buffer(struct repository *r, |
| 133 | const struct commit *, |
| 134 | unsigned long *size); |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 135 | |
| 136 | /* |
Elijah Newren | 15beaaa | 2019-11-05 17:07:23 +0000 | [diff] [blame] | 137 | * Tell the commit subsystem that we are done with a particular commit buffer. |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 138 | * The commit and buffer should be the input and return value, respectively, |
Ævar Arnfjörð Bjarmason | c7c33f5 | 2023-03-28 15:58:57 +0200 | [diff] [blame] | 139 | * from an earlier call to repo_get_commit_buffer. The buffer may or may not be |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 140 | * freed by this call; callers should not access the memory afterwards. |
| 141 | */ |
Stefan Beller | 7031537 | 2018-11-13 16:12:58 -0800 | [diff] [blame] | 142 | void repo_unuse_commit_buffer(struct repository *r, |
| 143 | const struct commit *, |
| 144 | const void *buffer); |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 145 | |
| 146 | /* |
Jeff King | 0fb370d | 2014-06-12 18:05:37 -0400 | [diff] [blame] | 147 | * Free any cached object buffer associated with the commit. |
| 148 | */ |
Stefan Beller | 6a7895f | 2018-12-14 16:09:40 -0800 | [diff] [blame] | 149 | void free_commit_buffer(struct parsed_object_pool *pool, struct commit *); |
Jeff King | 0fb370d | 2014-06-12 18:05:37 -0400 | [diff] [blame] | 150 | |
Nguyễn Thái Ngọc Duy | 301b8c7 | 2019-04-16 16:33:19 +0700 | [diff] [blame] | 151 | struct tree *repo_get_commit_tree(struct repository *, const struct commit *); |
Derrick Stolee | 5bb03de | 2018-04-06 19:09:34 +0000 | [diff] [blame] | 152 | struct object_id *get_commit_tree_oid(const struct commit *); |
| 153 | |
Jeff King | 0fb370d | 2014-06-12 18:05:37 -0400 | [diff] [blame] | 154 | /* |
Stefan Beller | 14ba97f | 2018-05-15 14:48:42 -0700 | [diff] [blame] | 155 | * Release memory related to a commit, including the parent list and |
| 156 | * any cached object buffer. |
| 157 | */ |
Stefan Beller | 6a7895f | 2018-12-14 16:09:40 -0800 | [diff] [blame] | 158 | void release_commit_memory(struct parsed_object_pool *pool, struct commit *c); |
Stefan Beller | 14ba97f | 2018-05-15 14:48:42 -0700 | [diff] [blame] | 159 | |
| 160 | /* |
Jeff King | 0fb370d | 2014-06-12 18:05:37 -0400 | [diff] [blame] | 161 | * Disassociate any cached object buffer from the commit, but do not free it. |
| 162 | * The buffer (or NULL, if none) is returned. |
| 163 | */ |
Jeff King | 8597ea3 | 2014-06-10 17:44:13 -0400 | [diff] [blame] | 164 | const void *detach_commit_buffer(struct commit *, unsigned long *sizep); |
Jeff King | 0fb370d | 2014-06-12 18:05:37 -0400 | [diff] [blame] | 165 | |
Christian Couder | 11af2aa | 2010-07-22 15:18:30 +0200 | [diff] [blame] | 166 | /* Find beginning and length of commit subject. */ |
| 167 | int find_commit_subject(const char *commit_buffer, const char **subject); |
| 168 | |
Charvi Mendiratta | 6e0e288 | 2021-03-15 13:24:31 +0530 | [diff] [blame] | 169 | /* Return length of the commit subject from commit log message. */ |
| 170 | size_t commit_subject_length(const char *body); |
| 171 | |
Thiago Farina | 47e44ed | 2010-11-26 23:58:14 -0200 | [diff] [blame] | 172 | struct commit_list *commit_list_insert(struct commit *item, |
| 173 | struct commit_list **list); |
Derrick Stolee | 597b2c3 | 2020-12-08 17:04:13 -0500 | [diff] [blame] | 174 | int commit_list_contains(struct commit *item, |
| 175 | struct commit_list *list); |
René Scharfe | 89b5f1d | 2012-04-25 22:35:27 +0200 | [diff] [blame] | 176 | struct commit_list **commit_list_append(struct commit *commit, |
| 177 | struct commit_list **next); |
Miklos Vajna | 6531947 | 2008-06-27 18:21:55 +0200 | [diff] [blame] | 178 | unsigned commit_list_count(const struct commit_list *l); |
Thiago Farina | 47e44ed | 2010-11-26 23:58:14 -0200 | [diff] [blame] | 179 | struct commit_list *commit_list_insert_by_date(struct commit *item, |
| 180 | struct commit_list **list); |
| 181 | void commit_list_sort_by_date(struct commit_list **list); |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 182 | |
Thomas Rast | 53d00b3 | 2013-07-31 22:13:20 +0200 | [diff] [blame] | 183 | /* Shallow copy of the input list */ |
| 184 | struct commit_list *copy_commit_list(struct commit_list *list); |
| 185 | |
Elijah Newren | b0ca120 | 2020-12-16 22:27:59 +0000 | [diff] [blame] | 186 | /* Modify list in-place to reverse it, returning new head; list will be tail */ |
| 187 | struct commit_list *reverse_commit_list(struct commit_list *list); |
| 188 | |
Daniel Barkalow | 6eb8ae0 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 189 | void free_commit_list(struct commit_list *list); |
| 190 | |
René Scharfe | 6d167fd | 2017-03-01 12:37:07 +0100 | [diff] [blame] | 191 | struct rev_info; /* in revision.h, it circularly uses enum cmit_fmt */ |
| 192 | |
Stefan Beller | 424510e | 2018-11-13 16:12:59 -0800 | [diff] [blame] | 193 | const char *repo_logmsg_reencode(struct repository *r, |
| 194 | const struct commit *commit, |
| 195 | char **commit_encoding, |
| 196 | const char *output_encoding); |
Stefan Beller | 424510e | 2018-11-13 16:12:59 -0800 | [diff] [blame] | 197 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 198 | const char *skip_blank_lines(const char *msg); |
Linus Torvalds | e3bc7a3 | 2005-06-01 08:34:23 -0700 | [diff] [blame] | 199 | |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 200 | /** Removes the first commit from a list sorted by date, and adds all |
| 201 | * of its parents. |
| 202 | **/ |
Junio C Hamano | a6080a0 | 2007-06-07 00:04:01 -0700 | [diff] [blame] | 203 | struct commit *pop_most_recent_commit(struct commit_list **list, |
Daniel Barkalow | 58e28af | 2005-04-23 20:29:22 -0700 | [diff] [blame] | 204 | unsigned int mark); |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 205 | |
jon@blackcubes.dyndns.org | a3437b8 | 2005-06-06 15:39:40 +0000 | [diff] [blame] | 206 | struct commit *pop_commit(struct commit_list **stack); |
| 207 | |
Junio C Hamano | f8f9c73 | 2006-01-07 18:52:42 -0800 | [diff] [blame] | 208 | void clear_commit_marks(struct commit *commit, unsigned int mark); |
Junio C Hamano | e895cb5 | 2013-03-05 11:42:20 -0800 | [diff] [blame] | 209 | void clear_commit_marks_many(int nr, struct commit **commit, unsigned int mark); |
Junio C Hamano | f8f9c73 | 2006-01-07 18:52:42 -0800 | [diff] [blame] | 210 | |
Junio C Hamano | 08f704f | 2013-06-06 16:07:14 -0700 | [diff] [blame] | 211 | |
| 212 | enum rev_sort_order { |
| 213 | REV_SORT_IN_GRAPH_ORDER = 0, |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 214 | REV_SORT_BY_COMMIT_DATE, |
| 215 | REV_SORT_BY_AUTHOR_DATE |
Junio C Hamano | 08f704f | 2013-06-06 16:07:14 -0700 | [diff] [blame] | 216 | }; |
| 217 | |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 218 | /* |
| 219 | * Performs an in-place topological sort of list supplied. |
| 220 | * |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 221 | * invariant of resulting list is: |
| 222 | * a reachable from b => ord(b) < ord(a) |
Junio C Hamano | 08f704f | 2013-06-06 16:07:14 -0700 | [diff] [blame] | 223 | * sort_order further specifies: |
| 224 | * REV_SORT_IN_GRAPH_ORDER: try to show a commit on a single-parent |
| 225 | * chain together. |
| 226 | * REV_SORT_BY_COMMIT_DATE: show eligible commits in committer-date order. |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 227 | */ |
Junio C Hamano | 08f704f | 2013-06-06 16:07:14 -0700 | [diff] [blame] | 228 | void sort_in_topological_order(struct commit_list **, enum rev_sort_order); |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 229 | |
| 230 | struct commit_graft { |
brian m. carlson | 7683e2e | 2015-03-13 23:39:34 +0000 | [diff] [blame] | 231 | struct object_id oid; |
Johannes Schindelin | ed09aef | 2006-10-30 20:09:06 +0100 | [diff] [blame] | 232 | int nr_parent; /* < 0 if shallow commit */ |
brian m. carlson | 7683e2e | 2015-03-13 23:39:34 +0000 | [diff] [blame] | 233 | struct object_id parent[FLEX_ARRAY]; /* more */ |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 234 | }; |
Nguyễn Thái Ngọc Duy | 09d4664 | 2011-08-18 19:29:35 +0700 | [diff] [blame] | 235 | typedef int (*each_commit_graft_fn)(const struct commit_graft *, void *); |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 236 | |
Patryk Obara | 9a93403 | 2017-08-18 20:33:12 +0200 | [diff] [blame] | 237 | struct commit_graft *read_graft_line(struct strbuf *line); |
Taylor Blau | 183df64 | 2020-04-30 15:11:28 -0600 | [diff] [blame] | 238 | /* commit_graft_pos returns an index into r->parsed_objects->grafts. */ |
Jeff King | 98c431b | 2021-01-28 01:12:35 -0500 | [diff] [blame] | 239 | int commit_graft_pos(struct repository *r, const struct object_id *oid); |
Brandon Williams | a3b78e8 | 2018-05-17 15:51:48 -0700 | [diff] [blame] | 240 | int register_commit_graft(struct repository *r, struct commit_graft *, int); |
Derrick Stolee | 20fd6d5 | 2018-08-20 18:24:30 +0000 | [diff] [blame] | 241 | void prepare_commit_graft(struct repository *r); |
Stefan Beller | b9dbddf | 2018-05-17 15:51:54 -0700 | [diff] [blame] | 242 | struct commit_graft *lookup_commit_graft(struct repository *r, const struct object_id *oid); |
Jonathan Tan | 2a69ff0 | 2022-03-17 11:24:47 -0700 | [diff] [blame] | 243 | void reset_commit_grafts(struct repository *r); |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 244 | |
Pratik Karki | 103148a | 2018-09-04 15:00:08 -0700 | [diff] [blame] | 245 | struct commit *get_fork_point(const char *refname, struct commit *commit); |
| 246 | |
Stefano Lattarini | 41ccfdd | 2013-04-12 00:36:10 +0200 | [diff] [blame] | 247 | /* largest positive number a signed 32-bit integer can contain */ |
Nguyễn Thái Ngọc Duy | 4dcb167 | 2013-01-11 16:05:46 +0700 | [diff] [blame] | 248 | #define INFINITE_DEPTH 0x7fffffff |
| 249 | |
brian m. carlson | 910650d | 2017-03-31 01:40:00 +0000 | [diff] [blame] | 250 | struct oid_array; |
Nguyễn Thái Ngọc Duy | 58babff | 2013-12-05 20:02:35 +0700 | [diff] [blame] | 251 | struct ref; |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 252 | int for_each_commit_graft(each_commit_graft_fn, void *); |
Johannes Schindelin | ed09aef | 2006-10-30 20:09:06 +0100 | [diff] [blame] | 253 | |
Jeff King | e885a84 | 2020-09-30 08:28:18 -0400 | [diff] [blame] | 254 | int interactive_add(const char **argv, const char *prefix, int patch); |
Kristian Høgsberg | 5868016 | 2007-09-17 20:06:44 -0400 | [diff] [blame] | 255 | |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 256 | struct commit_extra_header { |
| 257 | struct commit_extra_header *next; |
| 258 | char *key; |
| 259 | char *value; |
| 260 | size_t len; |
| 261 | }; |
| 262 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 263 | void append_merge_tag_headers(struct commit_list *parents, |
Denton Liu | ad6dad0 | 2019-04-29 04:28:23 -0400 | [diff] [blame] | 264 | struct commit_extra_header ***tail); |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 265 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 266 | int commit_tree(const char *msg, size_t msg_len, |
Denton Liu | ad6dad0 | 2019-04-29 04:28:23 -0400 | [diff] [blame] | 267 | const struct object_id *tree, |
| 268 | struct commit_list *parents, struct object_id *ret, |
| 269 | const char *author, const char *sign_commit); |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 270 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 271 | int commit_tree_extended(const char *msg, size_t msg_len, |
Denton Liu | ad6dad0 | 2019-04-29 04:28:23 -0400 | [diff] [blame] | 272 | const struct object_id *tree, |
Phillip Wood | e8cbe21 | 2020-08-17 18:40:01 +0100 | [diff] [blame] | 273 | struct commit_list *parents, struct object_id *ret, |
| 274 | const char *author, const char *committer, |
| 275 | const char *sign_commit, struct commit_extra_header *); |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 276 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 277 | struct commit_extra_header *read_commit_extra_headers(struct commit *, const char **); |
Junio C Hamano | ed7a42a | 2011-11-08 15:38:07 -0800 | [diff] [blame] | 278 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 279 | void free_commit_extra_headers(struct commit_extra_header *extra); |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 280 | |
Jeff King | fe6eb7f | 2014-08-27 03:56:01 -0400 | [diff] [blame] | 281 | /* |
| 282 | * Search the commit object contents given by "msg" for the header "key". |
John Cai | cfc5cf4 | 2022-01-06 20:07:35 +0000 | [diff] [blame] | 283 | * Reads up to "len" bytes of "msg". |
Jeff King | fe6eb7f | 2014-08-27 03:56:01 -0400 | [diff] [blame] | 284 | * Returns a pointer to the start of the header contents, or NULL. The length |
| 285 | * of the header, up to the first newline, is returned via out_len. |
| 286 | * |
| 287 | * Note that some headers (like mergetag) may be multi-line. It is the caller's |
| 288 | * responsibility to parse further in this case! |
| 289 | */ |
John Cai | cfc5cf4 | 2022-01-06 20:07:35 +0000 | [diff] [blame] | 290 | const char *find_header_mem(const char *msg, size_t len, |
| 291 | const char *key, |
| 292 | size_t *out_len); |
| 293 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 294 | const char *find_commit_header(const char *msg, const char *key, |
Denton Liu | ad6dad0 | 2019-04-29 04:28:23 -0400 | [diff] [blame] | 295 | size_t *out_len); |
Jeff King | fe6eb7f | 2014-08-27 03:56:01 -0400 | [diff] [blame] | 296 | |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 297 | /* Find the end of the log message, the right place for a new trailer. */ |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 298 | size_t ignore_non_trailer(const char *buf, size_t len); |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 299 | |
Johannes Schindelin | fef461e | 2018-04-25 11:54:04 +0200 | [diff] [blame] | 300 | typedef int (*each_mergetag_fn)(struct commit *commit, struct commit_extra_header *extra, |
Denton Liu | ad6dad0 | 2019-04-29 04:28:23 -0400 | [diff] [blame] | 301 | void *cb_data); |
Christian Couder | 063da62 | 2014-07-07 08:35:37 +0200 | [diff] [blame] | 302 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 303 | int for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data); |
Christian Couder | 063da62 | 2014-07-07 08:35:37 +0200 | [diff] [blame] | 304 | |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 305 | struct merge_remote_desc { |
| 306 | struct object *obj; /* the named object, could be a tag */ |
René Scharfe | 5447a76 | 2016-08-13 14:21:27 +0200 | [diff] [blame] | 307 | char name[FLEX_ARRAY]; |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 308 | }; |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 309 | struct merge_remote_desc *merge_remote_util(struct commit *); |
| 310 | void set_merge_remote_desc(struct commit *commit, |
Denton Liu | ad6dad0 | 2019-04-29 04:28:23 -0400 | [diff] [blame] | 311 | const char *name, struct object *obj); |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 312 | |
| 313 | /* |
| 314 | * Given "name" from the command line to merge, find the commit object |
| 315 | * and return it, while storing merge_remote_desc in its ->util field, |
| 316 | * to allow callers to tell if we are told to merge a tag. |
| 317 | */ |
| 318 | struct commit *get_merge_parent(const char *name); |
| 319 | |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 320 | int parse_signed_commit(const struct commit *commit, |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 321 | struct strbuf *message, struct strbuf *signature, |
| 322 | const struct git_hash_algo *algop); |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 323 | int remove_signature(struct strbuf *buf); |
Christian Couder | 0b05ab6 | 2014-07-19 17:01:12 +0200 | [diff] [blame] | 324 | |
Sebastian Götte | ffb6d7d | 2013-03-31 18:00:14 +0200 | [diff] [blame] | 325 | /* |
Sebastian Götte | eb307ae | 2013-03-31 18:02:46 +0200 | [diff] [blame] | 326 | * Check the signature of the given commit. The result of the check is stored |
| 327 | * in sig->check_result, 'G' for a good signature, 'U' for a good signature |
| 328 | * from an untrusted signer, 'B' for a bad signature and 'N' for no signature |
| 329 | * at all. This may allocate memory for sig->gpg_output, sig->gpg_status, |
| 330 | * sig->signer and sig->key. |
Sebastian Götte | ffb6d7d | 2013-03-31 18:00:14 +0200 | [diff] [blame] | 331 | */ |
Denton Liu | 5545442 | 2019-04-29 04:28:14 -0400 | [diff] [blame] | 332 | int check_commit_signature(const struct commit *commit, struct signature_check *sigc); |
Sebastian Götte | ffb6d7d | 2013-03-31 18:00:14 +0200 | [diff] [blame] | 333 | |
Derrick Stolee | 5284fc5 | 2018-11-01 13:46:21 +0000 | [diff] [blame] | 334 | /* record author-date for each commit object */ |
| 335 | struct author_date_slab; |
| 336 | void record_author_date(struct author_date_slab *author_date, |
| 337 | struct commit *commit); |
| 338 | |
| 339 | int compare_commits_by_author_date(const void *a_, const void *b_, void *unused); |
Junio C Hamano | 6d2035e | 2018-11-18 18:23:54 +0900 | [diff] [blame] | 340 | |
Jeff King | edc4d47 | 2018-11-06 02:50:17 -0500 | [diff] [blame] | 341 | /* |
| 342 | * Verify a single commit with check_commit_signature() and die() if it is not |
| 343 | * a good signature. This isn't really suitable for general use, but is a |
| 344 | * helper to implement consistent logic for pull/merge --verify-signatures. |
Hans Jerry Illikainen | 54887b4 | 2019-12-27 13:55:57 +0000 | [diff] [blame] | 345 | * |
| 346 | * The check_trust parameter is meant for backward-compatibility. The GPG |
| 347 | * interface verifies key trust with a default trust level that is below the |
| 348 | * default trust level for merge operations. Its value should be non-zero if |
| 349 | * the user hasn't set a minimum trust level explicitly in their configuration. |
| 350 | * |
| 351 | * If the user has set a minimum trust level, then that value should be obeyed |
| 352 | * and check_trust should be zero, even if the configured trust level is below |
| 353 | * the default trust level for merges. |
Jeff King | edc4d47 | 2018-11-06 02:50:17 -0500 | [diff] [blame] | 354 | */ |
Hans Jerry Illikainen | 54887b4 | 2019-12-27 13:55:57 +0000 | [diff] [blame] | 355 | void verify_merge_signature(struct commit *commit, int verbose, |
| 356 | int check_trust); |
Jeff King | edc4d47 | 2018-11-06 02:50:17 -0500 | [diff] [blame] | 357 | |
Jeff King | 727377f | 2013-07-02 02:21:48 -0400 | [diff] [blame] | 358 | int compare_commits_by_commit_date(const void *a_, const void *b_, void *unused); |
Derrick Stolee | 3afc679 | 2018-05-01 12:47:11 +0000 | [diff] [blame] | 359 | int compare_commits_by_gen_then_commit_date(const void *a_, const void *b_, void *unused); |
Jeff King | 727377f | 2013-07-02 02:21:48 -0400 | [diff] [blame] | 360 | |
Benoit Pierre | 15048f8 | 2014-03-18 11:00:53 +0100 | [diff] [blame] | 361 | LAST_ARG_MUST_BE_NULL |
Ævar Arnfjörð Bjarmason | a8cc594 | 2022-03-07 13:33:46 +0100 | [diff] [blame] | 362 | int run_commit_hook(int editor_is_used, const char *index_file, |
| 363 | int *invoked_hook, const char *name, ...); |
Benoit Pierre | 15048f8 | 2014-03-18 11:00:53 +0100 | [diff] [blame] | 364 | |
brian m. carlson | 937032e | 2021-02-11 02:08:04 +0000 | [diff] [blame] | 365 | /* Sign a commit or tag buffer, storing the result in a header. */ |
| 366 | int sign_with_header(struct strbuf *buf, const char *keyid); |
| 367 | /* Parse the signature out of a header. */ |
| 368 | int parse_buffer_signed_by_header(const char *buffer, |
| 369 | unsigned long size, |
| 370 | struct strbuf *payload, |
| 371 | struct strbuf *signature, |
| 372 | const struct git_hash_algo *algop); |
| 373 | |
Daniel Barkalow | 6eb8ae0 | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 374 | #endif /* COMMIT_H */ |