git/commit.h at master · sqlcode/git · GitHub

History

357 lines (295 loc) · 12.6 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

#ifndef COMMIT_H

#define COMMIT_H

#include "object.h"

#include "tree.h"

#include "strbuf.h"

#include "decorate.h"

#include "gpg-interface.h"

#include "string-list.h"

#include "pretty.h"

#include "commit-slab.h"

#define COMMIT_NOT_FROM_GRAPH 0xFFFFFFFF

#define GENERATION_NUMBER_INFINITY 0xFFFFFFFF

#define GENERATION_NUMBER_MAX 0x3FFFFFFF

#define GENERATION_NUMBER_ZERO 0

struct commit_list {

struct commit *item;

struct commit_list *next;

};

* The size of this struct matters in full repo walk operations like

* 'git clone' or 'git gc'. Consider using commit-slab to attach data

* to a commit instead of adding new fields here.

struct commit {

struct object object;

timestamp_t date;

struct commit_list *parents;

* If the commit is loaded from the commit-graph file, then this

* member may be NULL. Only access it through get_commit_tree()

* or get_commit_tree_oid().

struct tree *maybe_tree;

uint32_t graph_pos;

uint32_t generation;

unsigned int index;

};

extern int save_commit_buffer;

extern const char *commit_type;

/* While we can decorate any object with a name, it's only used for commits.. */

struct name_decoration {

struct name_decoration *next;

int type;

char name[FLEX_ARRAY];

};

enum decoration_type {

DECORATION_NONE = 0,

DECORATION_REF_LOCAL,

DECORATION_REF_REMOTE,

DECORATION_REF_TAG,

DECORATION_REF_STASH,

DECORATION_REF_HEAD,

DECORATION_GRAFTED,

};

void add_name_decoration(enum decoration_type type, const char *name, struct object *obj);

const struct name_decoration *get_name_decoration(const struct object *obj);

struct commit *lookup_commit(struct repository *r, const struct object_id *oid);

struct commit *lookup_commit_reference(struct repository *r,

const struct object_id *oid);

struct commit *lookup_commit_reference_gently(struct repository *r,

const struct object_id *oid,

int quiet);

struct commit *lookup_commit_reference_by_name(const char *name);

* Look up object named by "oid", dereference tag as necessary,

* get a commit and return it. If "oid" does not dereference to

* a commit, use ref_name to report an error and die.

struct commit *lookup_commit_or_die(const struct object_id *oid, const char *ref_name);

int parse_commit_buffer(struct repository *r, struct commit *item, const void *buffer, unsigned long size, int check_graph);

int parse_commit_internal(struct commit *item, int quiet_on_missing, int use_commit_graph);

int parse_commit_gently(struct commit *item, int quiet_on_missing);

static inline int parse_commit(struct commit *item)

{

return parse_commit_gently(item, 0);

}

void parse_commit_or_die(struct commit *item);

struct buffer_slab;

struct buffer_slab *allocate_commit_buffer_slab(void);

void free_commit_buffer_slab(struct buffer_slab *bs);

* Associate an object buffer with the commit. The ownership of the

* memory is handed over to the commit, and must be free()-able.

void set_commit_buffer(struct repository *r, struct commit *, void *buffer, unsigned long size);

* Get any cached object buffer associated with the commit. Returns NULL

* if none. The resulting memory should not be freed.

const void *get_cached_commit_buffer(struct repository *, const struct commit *, unsigned long *size);

* Get the commit's object contents, either from cache or by reading the object

* from disk. The resulting memory should not be modified, and must be given

* to unuse_commit_buffer when the caller is done.

const void *get_commit_buffer(const struct commit *, unsigned long *size);

* Tell the commit subsytem that we are done with a particular commit buffer.

* The commit and buffer should be the input and return value, respectively,

* from an earlier call to get_commit_buffer. The buffer may or may not be

* freed by this call; callers should not access the memory afterwards.

void unuse_commit_buffer(const struct commit *, const void *buffer);

* Free any cached object buffer associated with the commit.

void free_commit_buffer(struct commit *);

struct tree *get_commit_tree(const struct commit *);

struct object_id *get_commit_tree_oid(const struct commit *);

* Release memory related to a commit, including the parent list and

* any cached object buffer.

void release_commit_memory(struct commit *c);

* Disassociate any cached object buffer from the commit, but do not free it.

* The buffer (or NULL, if none) is returned.

const void *detach_commit_buffer(struct commit *, unsigned long *sizep);

/* Find beginning and length of commit subject. */

int find_commit_subject(const char *commit_buffer, const char **subject);

struct commit_list *commit_list_insert(struct commit *item,

struct commit_list **list);

struct commit_list **commit_list_append(struct commit *commit,

struct commit_list **next);

unsigned commit_list_count(const struct commit_list *l);

struct commit_list *commit_list_insert_by_date(struct commit *item,

struct commit_list **list);

void commit_list_sort_by_date(struct commit_list **list);

/* Shallow copy of the input list */

struct commit_list *copy_commit_list(struct commit_list *list);

void free_commit_list(struct commit_list *list);

struct rev_info; /* in revision.h, it circularly uses enum cmit_fmt */

extern int has_non_ascii(const char *text);

extern const char *logmsg_reencode(const struct commit *commit,

char **commit_encoding,

const char *output_encoding);

extern const char *skip_blank_lines(const char *msg);

/** Removes the first commit from a list sorted by date, and adds all

* of its parents.

**/

struct commit *pop_most_recent_commit(struct commit_list **list,

unsigned int mark);

struct commit *pop_commit(struct commit_list **stack);

void clear_commit_marks(struct commit *commit, unsigned int mark);

void clear_commit_marks_many(int nr, struct commit **commit, unsigned int mark);

enum rev_sort_order {

REV_SORT_IN_GRAPH_ORDER = 0,

REV_SORT_BY_COMMIT_DATE,

REV_SORT_BY_AUTHOR_DATE

};

* Performs an in-place topological sort of list supplied.

* invariant of resulting list is:

* a reachable from b => ord(b) < ord(a)

* sort_order further specifies:

* REV_SORT_IN_GRAPH_ORDER: try to show a commit on a single-parent

* chain together.

* REV_SORT_BY_COMMIT_DATE: show eligible commits in committer-date order.

void sort_in_topological_order(struct commit_list **, enum rev_sort_order);

struct commit_graft {

struct object_id oid;

int nr_parent; /* < 0 if shallow commit */

struct object_id parent[FLEX_ARRAY]; /* more */

};

typedef int (*each_commit_graft_fn)(const struct commit_graft *, void *);

struct commit_graft *read_graft_line(struct strbuf *line);

int register_commit_graft(struct repository *r, struct commit_graft *, int);

void prepare_commit_graft(struct repository *r);

struct commit_graft *lookup_commit_graft(struct repository *r, const struct object_id *oid);

struct commit *get_fork_point(const char *refname, struct commit *commit);

/* largest positive number a signed 32-bit integer can contain */

#define INFINITE_DEPTH 0x7fffffff

struct oid_array;

struct ref;

extern int register_shallow(struct repository *r, const struct object_id *oid);

extern int unregister_shallow(const struct object_id *oid);

extern int for_each_commit_graft(each_commit_graft_fn, void *);

extern int is_repository_shallow(struct repository *r);

extern struct commit_list *get_shallow_commits(struct object_array *heads,

int depth, int shallow_flag, int not_shallow_flag);

extern struct commit_list *get_shallow_commits_by_rev_list(

int ac, const char **av, int shallow_flag, int not_shallow_flag);

extern void set_alternate_shallow_file(struct repository *r, const char *path, int override);

extern int write_shallow_commits(struct strbuf *out, int use_pack_protocol,

const struct oid_array *extra);

extern void setup_alternate_shallow(struct lock_file *shallow_lock,

const char **alternate_shallow_file,

const struct oid_array *extra);

extern const char *setup_temporary_shallow(const struct oid_array *extra);

extern void advertise_shallow_grafts(int);

struct shallow_info {

struct oid_array *shallow;

int *ours, nr_ours;

int *theirs, nr_theirs;

struct oid_array *ref;

/* for receive-pack */

uint32_t **used_shallow;

int *need_reachability_test;

int *reachable;

int *shallow_ref;

struct commit **commits;

int nr_commits;

};

extern void prepare_shallow_info(struct shallow_info *, struct oid_array *);

extern void clear_shallow_info(struct shallow_info *);

extern void remove_nonexistent_theirs_shallow(struct shallow_info *);

extern void assign_shallow_commits_to_refs(struct shallow_info *info,

uint32_t **used,

int *ref_status);

extern int delayed_reachability_test(struct shallow_info *si, int c);

#define PRUNE_SHOW_ONLY 1

#define PRUNE_QUICK 2

extern void prune_shallow(unsigned options);

extern struct trace_key trace_shallow;

extern int interactive_add(int argc, const char **argv, const char *prefix, int patch);

extern int run_add_interactive(const char *revision, const char *patch_mode,

const struct pathspec *pathspec);

struct commit_extra_header {

struct commit_extra_header *next;

char *key;

char *value;

size_t len;

};

extern void append_merge_tag_headers(struct commit_list *parents,

struct commit_extra_header ***tail);

extern int commit_tree(const char *msg, size_t msg_len,

const struct object_id *tree,

struct commit_list *parents, struct object_id *ret,

const char *author, const char *sign_commit);

extern int commit_tree_extended(const char *msg, size_t msg_len,

const struct object_id *tree,

struct commit_list *parents,

struct object_id *ret, const char *author,

const char *sign_commit,

struct commit_extra_header *);

extern struct commit_extra_header *read_commit_extra_headers(struct commit *, const char **);

extern void free_commit_extra_headers(struct commit_extra_header *extra);

* Search the commit object contents given by "msg" for the header "key".

* Returns a pointer to the start of the header contents, or NULL. The length

* of the header, up to the first newline, is returned via out_len.

* Note that some headers (like mergetag) may be multi-line. It is the caller's

* responsibility to parse further in this case!

extern const char *find_commit_header(const char *msg, const char *key,

size_t *out_len);

/* Find the end of the log message, the right place for a new trailer. */

extern size_t ignore_non_trailer(const char *buf, size_t len);

typedef int (*each_mergetag_fn)(struct commit *commit, struct commit_extra_header *extra,

void *cb_data);

extern int for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data);

struct merge_remote_desc {

struct object *obj; /* the named object, could be a tag */

char name[FLEX_ARRAY];

};

extern struct merge_remote_desc *merge_remote_util(struct commit *);

extern void set_merge_remote_desc(struct commit *commit,

const char *name, struct object *obj);

* Given "name" from the command line to merge, find the commit object

* and return it, while storing merge_remote_desc in its ->util field,

* to allow callers to tell if we are told to merge a tag.

struct commit *get_merge_parent(const char *name);

extern int parse_signed_commit(const struct commit *commit,

struct strbuf *message, struct strbuf *signature);

extern int remove_signature(struct strbuf *buf);

* Check the signature of the given commit. The result of the check is stored

* in sig->check_result, 'G' for a good signature, 'U' for a good signature

* from an untrusted signer, 'B' for a bad signature and 'N' for no signature

* at all. This may allocate memory for sig->gpg_output, sig->gpg_status,

* sig->signer and sig->key.

extern int check_commit_signature(const struct commit *commit, struct signature_check *sigc);

/* record author-date for each commit object */

struct author_date_slab;

void record_author_date(struct author_date_slab *author_date,

struct commit *commit);

int compare_commits_by_author_date(const void *a_, const void *b_, void *unused);

* Verify a single commit with check_commit_signature() and die() if it is not

* a good signature. This isn't really suitable for general use, but is a

* helper to implement consistent logic for pull/merge --verify-signatures.

void verify_merge_signature(struct commit *commit, int verbose);

int compare_commits_by_commit_date(const void *a_, const void *b_, void *unused);

int compare_commits_by_gen_then_commit_date(const void *a_, const void *b_, void *unused);

LAST_ARG_MUST_BE_NULL

extern int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...);

#endif /* COMMIT_H */

git/commit.h at master · sqlcode/git · GitHub

Expand file tree

Breadcrumbs

commit.h

Latest commit

History

Breadcrumbs

commit.h

File metadata and controls