| 1 | #ifndef OBJECT_H |
| 2 | #define OBJECT_H |
| 3 | |
| 4 | #include "hash.h" |
| 5 | |
| 6 | struct buffer_slab; |
| 7 | struct repository; |
| 8 | |
| 9 | struct parsed_object_pool { |
| 10 | struct repository *repo; |
| 11 | struct object **obj_hash; |
| 12 | int nr_objs, obj_hash_size; |
| 13 | |
| 14 | /* TODO: migrate alloc_states to mem-pool? */ |
| 15 | struct alloc_state *blob_state; |
| 16 | struct alloc_state *tree_state; |
| 17 | struct alloc_state *commit_state; |
| 18 | struct alloc_state *tag_state; |
| 19 | struct alloc_state *object_state; |
| 20 | |
| 21 | /* parent substitutions from .git/info/grafts and .git/shallow */ |
| 22 | struct commit_graft **grafts; |
| 23 | int grafts_alloc, grafts_nr; |
| 24 | |
| 25 | int is_shallow; |
| 26 | struct stat_validity *shallow_stat; |
| 27 | char *alternate_shallow_file; |
| 28 | |
| 29 | int commit_graft_prepared; |
| 30 | int substituted_parent; |
| 31 | |
| 32 | struct buffer_slab *buffer_slab; |
| 33 | }; |
| 34 | |
| 35 | struct parsed_object_pool *parsed_object_pool_new(struct repository *repo); |
| 36 | void parsed_object_pool_clear(struct parsed_object_pool *o); |
| 37 | void parsed_object_pool_reset_commit_grafts(struct parsed_object_pool *o); |
| 38 | |
| 39 | struct object_list { |
| 40 | struct object *item; |
| 41 | struct object_list *next; |
| 42 | }; |
| 43 | |
| 44 | struct object_array { |
| 45 | unsigned int nr; |
| 46 | unsigned int alloc; |
| 47 | struct object_array_entry { |
| 48 | struct object *item; |
| 49 | /* |
| 50 | * name or NULL. If non-NULL, the memory pointed to |
| 51 | * is owned by this object *except* if it points at |
| 52 | * object_array_slopbuf, which is a static copy of the |
| 53 | * empty string. |
| 54 | */ |
| 55 | char *name; |
| 56 | char *path; |
| 57 | unsigned mode; |
| 58 | } *objects; |
| 59 | }; |
| 60 | |
| 61 | #define OBJECT_ARRAY_INIT { 0 } |
| 62 | |
| 63 | void object_array_init(struct object_array *array); |
| 64 | |
| 65 | /* |
| 66 | * object flag allocation: |
| 67 | * revision.h: 0---------10 15 23--------28 |
| 68 | * fetch-pack.c: 01 67 |
| 69 | * negotiator/default.c: 2--5 |
| 70 | * negotiator/skipping.c: 2--5 |
| 71 | * walker.c: 0-2 |
| 72 | * upload-pack.c: 4 11-----14 16-----19 |
| 73 | * builtin/blame.c: 12-13 |
| 74 | * bisect.c: 16 |
| 75 | * bundle.c: 16 |
| 76 | * http-push.c: 11-----14 |
| 77 | * commit-graph.c: 15 |
| 78 | * commit-reach.c: 16-------20 |
| 79 | * builtin/last-modified.c: 1617 |
| 80 | * object-name.c: 20 |
| 81 | * list-objects-filter.c: 21 |
| 82 | * bloom.c: 2122 |
| 83 | * builtin/fsck.c: 0--3 |
| 84 | * builtin/index-pack.c: 2021 |
| 85 | * reflog.c: 10--12 |
| 86 | * builtin/show-branch.c: 0-----------------------------------------------28 |
| 87 | * builtin/unpack-objects.c: 2021 |
| 88 | * pack-bitmap.h: 2122 |
| 89 | */ |
| 90 | #define FLAG_BITS 29 |
| 91 | |
| 92 | #define TYPE_BITS 3 |
| 93 | |
| 94 | /* |
| 95 | * Values in this enum (except those outside the 3 bit range) are part |
| 96 | * of pack file format. See gitformat-pack(5) for more information. |
| 97 | */ |
| 98 | enum object_type { |
| 99 | OBJ_BAD = -1, |
| 100 | OBJ_NONE = 0, |
| 101 | OBJ_COMMIT = 1, |
| 102 | OBJ_TREE = 2, |
| 103 | OBJ_BLOB = 3, |
| 104 | OBJ_TAG = 4, |
| 105 | /* 5 for future expansion */ |
| 106 | OBJ_OFS_DELTA = 6, |
| 107 | OBJ_REF_DELTA = 7, |
| 108 | OBJ_ANY, |
| 109 | OBJ_MAX |
| 110 | }; |
| 111 | |
| 112 | /* unknown mode (impossible combination S_IFIFO|S_IFCHR) */ |
| 113 | #define S_IFINVALID 0030000 |
| 114 | |
| 115 | /* |
| 116 | * A "directory link" is a link to another git directory. |
| 117 | * |
| 118 | * The value 0160000 is not normally a valid mode, and |
| 119 | * also just happens to be S_IFDIR + S_IFLNK |
| 120 | */ |
| 121 | #define S_IFGITLINK 0160000 |
| 122 | #define S_ISGITLINK(m) (((m) & S_IFMT) == S_IFGITLINK) |
| 123 | |
| 124 | #define S_ISSPARSEDIR(m) ((m) == S_IFDIR) |
| 125 | |
| 126 | static inline enum object_type object_type(unsigned int mode) |
| 127 | { |
| 128 | return S_ISDIR(mode) ? OBJ_TREE : |
| 129 | S_ISGITLINK(mode) ? OBJ_COMMIT : |
| 130 | OBJ_BLOB; |
| 131 | } |
| 132 | |
| 133 | #define ce_permissions(mode) (((mode) & 0100) ? 0755 : 0644) |
| 134 | static inline unsigned int create_ce_mode(unsigned int mode) |
| 135 | { |
| 136 | if (S_ISLNK(mode)) |
| 137 | return S_IFLNK; |
| 138 | if (S_ISSPARSEDIR(mode)) |
| 139 | return S_IFDIR; |
| 140 | if (S_ISDIR(mode) || S_ISGITLINK(mode)) |
| 141 | return S_IFGITLINK; |
| 142 | return S_IFREG | ce_permissions(mode); |
| 143 | } |
| 144 | |
| 145 | static inline unsigned int canon_mode(unsigned int mode) |
| 146 | { |
| 147 | if (S_ISREG(mode)) |
| 148 | return S_IFREG | ce_permissions(mode); |
| 149 | if (S_ISLNK(mode)) |
| 150 | return S_IFLNK; |
| 151 | if (S_ISDIR(mode)) |
| 152 | return S_IFDIR; |
| 153 | return S_IFGITLINK; |
| 154 | } |
| 155 | |
| 156 | /* |
| 157 | * The object type is stored in 3 bits. |
| 158 | */ |
| 159 | struct object { |
| 160 | unsigned parsed : 1; |
| 161 | unsigned type : TYPE_BITS; |
| 162 | unsigned flags : FLAG_BITS; |
| 163 | struct object_id oid; |
| 164 | }; |
| 165 | |
| 166 | const char *type_name(unsigned int type); |
| 167 | int type_from_string_gently(const char *str, ssize_t, int gentle); |
| 168 | #define type_from_string(str) type_from_string_gently(str, -1, 0) |
| 169 | |
| 170 | /* |
| 171 | * Return the current number of buckets in the object hashmap. |
| 172 | */ |
| 173 | unsigned int get_max_object_index(const struct repository *repo); |
| 174 | |
| 175 | /* |
| 176 | * Return the object from the specified bucket in the object hashmap. |
| 177 | */ |
| 178 | struct object *get_indexed_object(const struct repository *repo, |
| 179 | unsigned int); |
| 180 | |
| 181 | /* |
| 182 | * This can be used to see if we have heard of the object before, but |
| 183 | * it can return "yes we have, and here is a half-initialised object" |
| 184 | * for an object that we haven't loaded/parsed yet. |
| 185 | * |
| 186 | * When parsing a commit to create an in-core commit object, its |
| 187 | * parents list holds commit objects that represent its parents, but |
| 188 | * they are expected to be lazily initialized and do not know what |
| 189 | * their trees or parents are yet. When this function returns such a |
| 190 | * half-initialised objects, the caller is expected to initialize them |
| 191 | * by calling parse_object() on them. |
| 192 | */ |
| 193 | struct object *lookup_object(struct repository *r, const struct object_id *oid); |
| 194 | |
| 195 | void *create_object(struct repository *r, const struct object_id *oid, void *obj); |
| 196 | |
| 197 | void *object_as_type(struct object *obj, enum object_type type, int quiet); |
| 198 | |
| 199 | |
| 200 | static inline const char *parse_mode(const char *str, uint16_t *modep) |
| 201 | { |
| 202 | unsigned char c; |
| 203 | unsigned int mode = 0; |
| 204 | |
| 205 | if (*str == ' ') |
| 206 | return NULL; |
| 207 | |
| 208 | while ((c = *str++) != ' ') { |
| 209 | if (c < '0' || c > '7') |
| 210 | return NULL; |
| 211 | mode = (mode << 3) + (c - '0'); |
| 212 | } |
| 213 | *modep = mode; |
| 214 | return str; |
| 215 | } |
| 216 | |
| 217 | /* |
| 218 | * Returns the object, having parsed it to find out what it is. |
| 219 | * |
| 220 | * Returns NULL if the object is missing or corrupt. |
| 221 | */ |
| 222 | enum parse_object_flags { |
| 223 | PARSE_OBJECT_SKIP_HASH_CHECK = 1 << 0, |
| 224 | PARSE_OBJECT_DISCARD_TREE = 1 << 1, |
| 225 | }; |
| 226 | struct object *parse_object(struct repository *r, const struct object_id *oid); |
| 227 | struct object *parse_object_with_flags(struct repository *r, |
| 228 | const struct object_id *oid, |
| 229 | enum parse_object_flags flags); |
| 230 | |
| 231 | /* |
| 232 | * Like parse_object, but will die() instead of returning NULL. If the |
| 233 | * "name" parameter is not NULL, it is included in the error message |
| 234 | * (otherwise, the hex object ID is given). |
| 235 | */ |
| 236 | struct object *parse_object_or_die(struct repository *repo, const struct object_id *oid, |
| 237 | const char *name); |
| 238 | |
| 239 | /* Given the result of read_sha1_file(), returns the object after |
| 240 | * parsing it. eaten_p indicates if the object has a borrowed copy |
| 241 | * of buffer and the caller should not free() it. |
| 242 | */ |
| 243 | struct object *parse_object_buffer(struct repository *r, const struct object_id *oid, enum object_type type, unsigned long size, void *buffer, int *eaten_p); |
| 244 | |
| 245 | /* |
| 246 | * Allocate and return an object struct, even if you do not know the type of |
| 247 | * the object. The returned object may have its "type" field set to a real type |
| 248 | * (if somebody previously called lookup_blob(), etc), or it may be set to |
| 249 | * OBJ_NONE. In the latter case, subsequent calls to lookup_blob(), etc, will |
| 250 | * set the type field as appropriate. |
| 251 | * |
| 252 | * Use this when you do not know the expected type of an object and want to |
| 253 | * avoid parsing it for efficiency reasons. Try to avoid it otherwise; it |
| 254 | * may allocate excess memory, since the returned object must be as large as |
| 255 | * the maximum struct of any type. |
| 256 | */ |
| 257 | struct object *lookup_unknown_object(struct repository *r, const struct object_id *oid); |
| 258 | |
| 259 | /* |
| 260 | * Dispatch to the appropriate lookup_blob(), lookup_commit(), etc, based on |
| 261 | * "type". |
| 262 | */ |
| 263 | struct object *lookup_object_by_type(struct repository *r, const struct object_id *oid, |
| 264 | enum object_type type); |
| 265 | |
| 266 | enum peel_status { |
| 267 | /* object was peeled successfully: */ |
| 268 | PEEL_PEELED = 0, |
| 269 | |
| 270 | /* |
| 271 | * object cannot be peeled because the named object (or an |
| 272 | * object referred to by a tag in the peel chain), does not |
| 273 | * exist. |
| 274 | */ |
| 275 | PEEL_INVALID = -1, |
| 276 | |
| 277 | /* object cannot be peeled because it is not a tag: */ |
| 278 | PEEL_NON_TAG = -2, |
| 279 | |
| 280 | /* ref_entry contains no peeled value because it is a symref: */ |
| 281 | PEEL_IS_SYMREF = -3, |
| 282 | |
| 283 | /* |
| 284 | * ref_entry cannot be peeled because it is broken (i.e., the |
| 285 | * symbolic reference cannot even be resolved to an object |
| 286 | * name): |
| 287 | */ |
| 288 | PEEL_BROKEN = -4 |
| 289 | }; |
| 290 | |
| 291 | enum peel_object_flags { |
| 292 | /* |
| 293 | * Always verify the object type of the tagged object, even in the case |
| 294 | * where the looked-up object already has an object type. This can be |
| 295 | * useful when the tagged object type may be invalid. One such case is |
| 296 | * when looking up objects via tags, where we blindly trust the object |
| 297 | * type declared by the tag. |
| 298 | */ |
| 299 | PEEL_OBJECT_VERIFY_TAGGED_OBJECT_TYPE = (1 << 0), |
| 300 | }; |
| 301 | |
| 302 | /* |
| 303 | * Peel the named object; i.e., if the object is a tag, resolve the |
| 304 | * tag recursively until a non-tag is found. If successful, store the |
| 305 | * result to oid and return PEEL_PEELED. If the object is not a tag |
| 306 | * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively, |
| 307 | * and leave oid unchanged. |
| 308 | */ |
| 309 | enum peel_status peel_object(struct repository *r, |
| 310 | const struct object_id *name, |
| 311 | struct object_id *oid, |
| 312 | unsigned flags); |
| 313 | enum peel_status peel_object_ext(struct repository *r, |
| 314 | const struct object_id *name, |
| 315 | struct object_id *oid, |
| 316 | unsigned flags, |
| 317 | enum object_type *typep); |
| 318 | |
| 319 | struct object_list *object_list_insert(struct object *item, |
| 320 | struct object_list **list_p); |
| 321 | |
| 322 | int object_list_contains(struct object_list *list, struct object *obj); |
| 323 | |
| 324 | void object_list_free(struct object_list **list); |
| 325 | |
| 326 | /* Object array handling .. */ |
| 327 | void add_object_array(struct object *obj, const char *name, struct object_array *array); |
| 328 | void add_object_array_with_path(struct object *obj, const char *name, struct object_array *array, unsigned mode, const char *path); |
| 329 | |
| 330 | /* |
| 331 | * Returns NULL if the array is empty. Otherwise, returns the last object |
| 332 | * after removing its entry from the array. Other resources associated |
| 333 | * with that object are left in an unspecified state and should not be |
| 334 | * examined. |
| 335 | */ |
| 336 | struct object *object_array_pop(struct object_array *array); |
| 337 | |
| 338 | typedef int (*object_array_each_func_t)(struct object_array_entry *, void *); |
| 339 | |
| 340 | /* |
| 341 | * Apply want to each entry in array, retaining only the entries for |
| 342 | * which the function returns true. Preserve the order of the entries |
| 343 | * that are retained. |
| 344 | */ |
| 345 | void object_array_filter(struct object_array *array, |
| 346 | object_array_each_func_t want, void *cb_data); |
| 347 | |
| 348 | /* |
| 349 | * Remove any objects from the array, freeing all used memory; afterwards |
| 350 | * the array is ready to store more objects with add_object_array(). |
| 351 | */ |
| 352 | void object_array_clear(struct object_array *array); |
| 353 | |
| 354 | void clear_object_flags(struct repository *repo, unsigned flags); |
| 355 | |
| 356 | /* |
| 357 | * Clear the specified object flags from all in-core commit objects from |
| 358 | * the specified repository. |
| 359 | */ |
| 360 | void repo_clear_commit_marks(struct repository *r, unsigned int flags); |
| 361 | |
| 362 | #endif /* OBJECT_H */ |