Convert object iteration callbacks to struct object_id

bk2204 · gitster · commit 76c1d9a09624 · 2017-02-22T10:12:15.000-08:00
Convert each_loose_object_fn and each_packed_object_fn to take a pointer
to struct object_id.  Update the various callbacks.  Convert several
40-based constants to use GIT_SHA1_HEXSZ.

Signed-off-by: brian m. carlson &lt;sandals@crustytoothpaste.net&gt;
Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
diff --git a/builtin/cat-file.c b/builtin/cat-file.c
@@ -409,20 +409,20 @@ static int batch_object_cb(const unsigned char sha1[20], void *vdata)
 	return 0;
 }
 
-static int batch_loose_object(const unsigned char *sha1,
+static int batch_loose_object(const struct object_id *oid,
 			      const char *path,
 			      void *data)
 {
-	sha1_array_append(data, sha1);
+	sha1_array_append(data, oid->hash);
 	return 0;
 }
 
-static int batch_packed_object(const unsigned char *sha1,
+static int batch_packed_object(const struct object_id *oid,
 			       struct packed_git *pack,
 			       uint32_t pos,
 			       void *data)
 {
-	sha1_array_append(data, sha1);
+	sha1_array_append(data, oid->hash);
 	return 0;
 }
 
diff --git a/builtin/count-objects.c b/builtin/count-objects.c
@@ -53,7 +53,7 @@ static void loose_garbage(const char *path)
 		report_garbage(PACKDIR_FILE_GARBAGE, path);
 }
 
-static int count_loose(const unsigned char *sha1, const char *path, void *data)
+static int count_loose(const struct object_id *oid, const char *path, void *data)
 {
 	struct stat st;
 
@@ -62,7 +62,7 @@ static int count_loose(const unsigned char *sha1, const char *path, void *data)
 	else {
 		loose_size += on_disk_bytes(st);
 		loose++;
-		if (verbose && has_sha1_pack(sha1))
+		if (verbose && has_sha1_pack(oid->hash))
 			packed_loose++;
 	}
 	return 0;
diff --git a/builtin/fsck.c b/builtin/fsck.c
@@ -491,7 +491,7 @@ static void get_default_heads(void)
 	}
 }
 
-static struct object *parse_loose_object(const unsigned char *sha1,
+static struct object *parse_loose_object(const struct object_id *oid,
 					 const char *path)
 {
 	struct object *obj;
@@ -500,27 +500,27 @@ static struct object *parse_loose_object(const unsigned char *sha1,
 	unsigned long size;
 	int eaten;
 
-	if (read_loose_object(path, sha1, &type, &size, &contents) < 0)
+	if (read_loose_object(path, oid->hash, &type, &size, &contents) < 0)
 		return NULL;
 
 	if (!contents && type != OBJ_BLOB)
 		die("BUG: read_loose_object streamed a non-blob");
 
-	obj = parse_object_buffer(sha1, type, size, contents, &eaten);
+	obj = parse_object_buffer(oid->hash, type, size, contents, &eaten);
 
 	if (!eaten)
 		free(contents);
 	return obj;
 }
 
-static int fsck_loose(const unsigned char *sha1, const char *path, void *data)
+static int fsck_loose(const struct object_id *oid, const char *path, void *data)
 {
-	struct object *obj = parse_loose_object(sha1, path);
+	struct object *obj = parse_loose_object(oid, path);
 
 	if (!obj) {
 		errors_found |= ERROR_OBJECT;
 		error("%s: object corrupt or missing: %s",
-		      sha1_to_hex(sha1), path);
+		      oid_to_hex(oid), path);
 		return 0; /* keep checking other objects */
 	}
 
@@ -619,26 +619,26 @@ static int fsck_cache_tree(struct cache_tree *it)
 	return err;
 }
 
-static void mark_object_for_connectivity(const unsigned char *sha1)
+static void mark_object_for_connectivity(const struct object_id *oid)
 {
-	struct object *obj = lookup_unknown_object(sha1);
+	struct object *obj = lookup_unknown_object(oid->hash);
 	obj->flags |= HAS_OBJ;
 }
 
-static int mark_loose_for_connectivity(const unsigned char *sha1,
+static int mark_loose_for_connectivity(const struct object_id *oid,
 				       const char *path,
 				       void *data)
 {
-	mark_object_for_connectivity(sha1);
+	mark_object_for_connectivity(oid);
 	return 0;
 }
 
-static int mark_packed_for_connectivity(const unsigned char *sha1,
+static int mark_packed_for_connectivity(const struct object_id *oid,
 					struct packed_git *pack,
 					uint32_t pos,
 					void *data)
 {
-	mark_object_for_connectivity(sha1);
+	mark_object_for_connectivity(oid);
 	return 0;
 }
 
diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
@@ -2534,17 +2534,17 @@ static void add_objects_in_unpacked_packs(struct rev_info *revs)
 	free(in_pack.array);
 }
 
-static int add_loose_object(const unsigned char *sha1, const char *path,
+static int add_loose_object(const struct object_id *oid, const char *path,
 			    void *data)
 {
-	enum object_type type = sha1_object_info(sha1, NULL);
+	enum object_type type = sha1_object_info(oid->hash, NULL);
 
 	if (type < 0) {
 		warning("loose object at %s could not be examined", path);
 		return 0;
 	}
 
-	add_object_entry(sha1, type, "", 0);
+	add_object_entry(oid->hash, type, "", 0);
 	return 0;
 }
 
diff --git a/builtin/prune-packed.c b/builtin/prune-packed.c
@@ -19,12 +19,12 @@ static int prune_subdir(int nr, const char *path, void *data)
 	return 0;
 }
 
-static int prune_object(const unsigned char *sha1, const char *path,
+static int prune_object(const struct object_id *oid, const char *path,
 			 void *data)
 {
 	int *opts = data;
 
-	if (!has_sha1_pack(sha1))
+	if (!has_sha1_pack(oid->hash))
 		return 0;
 
 	if (*opts & PRUNE_PACKED_DRY_RUN)
diff --git a/builtin/prune.c b/builtin/prune.c
@@ -30,7 +30,7 @@ static int prune_tmp_file(const char *fullpath)
 	return 0;
 }
 
-static int prune_object(const unsigned char *sha1, const char *fullpath,
+static int prune_object(const struct object_id *oid, const char *fullpath,
 			void *data)
 {
 	struct stat st;
@@ -39,7 +39,7 @@ static int prune_object(const unsigned char *sha1, const char *fullpath,
 	 * Do we know about this object?
 	 * It must have been reachable
 	 */
-	if (lookup_object(sha1))
+	if (lookup_object(oid->hash))
 		return 0;
 
 	if (lstat(fullpath, &st)) {
@@ -50,8 +50,8 @@ static int prune_object(const unsigned char *sha1, const char *fullpath,
 	if (st.st_mtime > expire)
 		return 0;
 	if (show_only || verbose) {
-		enum object_type type = sha1_object_info(sha1, NULL);
-		printf("%s %s\n", sha1_to_hex(sha1),
+		enum object_type type = sha1_object_info(oid->hash, NULL);
+		printf("%s %s\n", oid_to_hex(oid),
 		       (type > 0) ? typename(type) : "unknown");
 	}
 	if (!show_only)
diff --git a/cache.h b/cache.h
@@ -1655,7 +1655,7 @@ extern int unpack_object_header(struct packed_git *, struct pack_window **, off_
  * scratch buffer, but restored to its original contents before
  * the function returns.
  */
-typedef int each_loose_object_fn(const unsigned char *sha1,
+typedef int each_loose_object_fn(const struct object_id *oid,
 				 const char *path,
 				 void *data);
 typedef int each_loose_cruft_fn(const char *basename,
@@ -1681,7 +1681,7 @@ int for_each_loose_file_in_objdir_buf(struct strbuf *path,
  * LOCAL_ONLY flag is set).
  */
 #define FOR_EACH_OBJECT_LOCAL_ONLY 0x1
-typedef int each_packed_object_fn(const unsigned char *sha1,
+typedef int each_packed_object_fn(const struct object_id *oid,
 				  struct packed_git *pack,
 				  uint32_t pos,
 				  void *data);
diff --git a/reachable.c b/reachable.c
@@ -58,7 +58,7 @@ struct recent_data {
 	unsigned long timestamp;
 };
 
-static void add_recent_object(const unsigned char *sha1,
+static void add_recent_object(const struct object_id *oid,
 			      unsigned long mtime,
 			      struct recent_data *data)
 {
@@ -75,37 +75,37 @@ static void add_recent_object(const unsigned char *sha1,
 	 * later processing, and the revision machinery expects
 	 * commits and tags to have been parsed.
 	 */
-	type = sha1_object_info(sha1, NULL);
+	type = sha1_object_info(oid->hash, NULL);
 	if (type < 0)
-		die("unable to get object info for %s", sha1_to_hex(sha1));
+		die("unable to get object info for %s", oid_to_hex(oid));
 
 	switch (type) {
 	case OBJ_TAG:
 	case OBJ_COMMIT:
-		obj = parse_object_or_die(sha1, NULL);
+		obj = parse_object_or_die(oid->hash, NULL);
 		break;
 	case OBJ_TREE:
-		obj = (struct object *)lookup_tree(sha1);
+		obj = (struct object *)lookup_tree(oid->hash);
 		break;
 	case OBJ_BLOB:
-		obj = (struct object *)lookup_blob(sha1);
+		obj = (struct object *)lookup_blob(oid->hash);
 		break;
 	default:
 		die("unknown object type for %s: %s",
-		    sha1_to_hex(sha1), typename(type));
+		    oid_to_hex(oid), typename(type));
 	}
 
 	if (!obj)
-		die("unable to lookup %s", sha1_to_hex(sha1));
+		die("unable to lookup %s", oid_to_hex(oid));
 
 	add_pending_object(data->revs, obj, "");
 }
 
-static int add_recent_loose(const unsigned char *sha1,
+static int add_recent_loose(const struct object_id *oid,
 			    const char *path, void *data)
 {
 	struct stat st;
-	struct object *obj = lookup_object(sha1);
+	struct object *obj = lookup_object(oid->hash);
 
 	if (obj && obj->flags & SEEN)
 		return 0;
@@ -119,22 +119,22 @@ static int add_recent_loose(const unsigned char *sha1,
 		 */
 		if (errno == ENOENT)
 			return 0;
-		return error_errno("unable to stat %s", sha1_to_hex(sha1));
+		return error_errno("unable to stat %s", oid_to_hex(oid));
 	}
 
-	add_recent_object(sha1, st.st_mtime, data);
+	add_recent_object(oid, st.st_mtime, data);
 	return 0;
 }
 
-static int add_recent_packed(const unsigned char *sha1,
+static int add_recent_packed(const struct object_id *oid,
 			     struct packed_git *p, uint32_t pos,
 			     void *data)
 {
-	struct object *obj = lookup_object(sha1);
+	struct object *obj = lookup_object(oid->hash);
 
 	if (obj && obj->flags & SEEN)
 		return 0;
-	add_recent_object(sha1, p->mtime, data);
+	add_recent_object(oid, p->mtime, data);
 	return 0;
 }
 
diff --git a/sha1_file.c b/sha1_file.c
@@ -3685,15 +3685,15 @@ static int for_each_file_in_obj_subdir(int subdir_nr,
 		strbuf_setlen(path, baselen);
 		strbuf_addf(path, "/%s", de->d_name);
 
-		if (strlen(de->d_name) == 38)  {
-			char hex[41];
-			unsigned char sha1[20];
+		if (strlen(de->d_name) == GIT_SHA1_HEXSZ - 2)  {
+			char hex[GIT_SHA1_HEXSZ+1];
+			struct object_id oid;
 
 			snprintf(hex, sizeof(hex), "%02x%s",
 				 subdir_nr, de->d_name);
-			if (!get_sha1_hex(hex, sha1)) {
+			if (!get_oid_hex(hex, &oid)) {
 				if (obj_cb) {
-					r = obj_cb(sha1, path->buf, data);
+					r = obj_cb(&oid, path->buf, data);
 					if (r)
 						break;
 				}
@@ -3805,7 +3805,7 @@ static int for_each_object_in_pack(struct packed_git *p, each_packed_object_fn c
 			return error("unable to get sha1 of object %u in %s",
 				     i, p->pack_name);
 
-		r = cb(oid.hash, p, i, data);
+		r = cb(&oid, p, i, data);
 		if (r)
 			break;
 	}

Original file line number	Diff line number	Diff line change
`@@ -409,20 +409,20 @@ static int batch_object_cb(const unsigned char sha1[20], void *vdata)`
`409`	`409`	`return 0;`
`410`	`410`	`}`
`411`	`411`
`412`		`-static int batch_loose_object(const unsigned char *sha1,`
	`412`	`+static int batch_loose_object(const struct object_id *oid,`
`413`	`413`	`const char *path,`
`414`	`414`	`void *data)`
`415`	`415`	`{`
`416`		`- sha1_array_append(data, sha1);`
	`416`	`+ sha1_array_append(data, oid->hash);`
`417`	`417`	`return 0;`
`418`	`418`	`}`
`419`	`419`
`420`		`-static int batch_packed_object(const unsigned char *sha1,`
	`420`	`+static int batch_packed_object(const struct object_id *oid,`
`421`	`421`	`struct packed_git *pack,`
`422`	`422`	`uint32_t pos,`
`423`	`423`	`void *data)`
`424`	`424`	`{`
`425`		`- sha1_array_append(data, sha1);`
	`425`	`+ sha1_array_append(data, oid->hash);`
`426`	`426`	`return 0;`
`427`	`427`	`}`
`428`	`428`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ static void loose_garbage(const char *path)`
`53`	`53`	`report_garbage(PACKDIR_FILE_GARBAGE, path);`
`54`	`54`	`}`
`55`	`55`
`56`		`-static int count_loose(const unsigned char sha1, const char path, void *data)`
	`56`	`+static int count_loose(const struct object_id oid, const char path, void *data)`
`57`	`57`	`{`
`58`	`58`	`struct stat st;`
`59`	`59`
`@@ -62,7 +62,7 @@ static int count_loose(const unsigned char sha1, const char path, void *data)`
`62`	`62`	`else {`
`63`	`63`	`loose_size += on_disk_bytes(st);`
`64`	`64`	`loose++;`
`65`		`- if (verbose && has_sha1_pack(sha1))`
	`65`	`+ if (verbose && has_sha1_pack(oid->hash))`
`66`	`66`	`packed_loose++;`
`67`	`67`	`}`
`68`	`68`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -491,7 +491,7 @@ static void get_default_heads(void)`
`491`	`491`	`}`
`492`	`492`	`}`
`493`	`493`
`494`		`-static struct object parse_loose_object(const unsigned char sha1,`
	`494`	`+static struct object parse_loose_object(const struct object_id oid,`
`495`	`495`	`const char *path)`
`496`	`496`	`{`
`497`	`497`	`struct object *obj;`
`@@ -500,27 +500,27 @@ static struct object parse_loose_object(const unsigned char sha1,`
`500`	`500`	`unsigned long size;`
`501`	`501`	`int eaten;`
`502`	`502`
`503`		`- if (read_loose_object(path, sha1, &type, &size, &contents) < 0)`
	`503`	`+ if (read_loose_object(path, oid->hash, &type, &size, &contents) < 0)`
`504`	`504`	`return NULL;`
`505`	`505`
`506`	`506`	`if (!contents && type != OBJ_BLOB)`
`507`	`507`	`die("BUG: read_loose_object streamed a non-blob");`
`508`	`508`
`509`		`- obj = parse_object_buffer(sha1, type, size, contents, &eaten);`
	`509`	`+ obj = parse_object_buffer(oid->hash, type, size, contents, &eaten);`
`510`	`510`
`511`	`511`	`if (!eaten)`
`512`	`512`	`free(contents);`
`513`	`513`	`return obj;`
`514`	`514`	`}`
`515`	`515`
`516`		`-static int fsck_loose(const unsigned char sha1, const char path, void *data)`
	`516`	`+static int fsck_loose(const struct object_id oid, const char path, void *data)`
`517`	`517`	`{`
`518`		`- struct object *obj = parse_loose_object(sha1, path);`
	`518`	`+ struct object *obj = parse_loose_object(oid, path);`
`519`	`519`
`520`	`520`	`if (!obj) {`
`521`	`521`	`errors_found \|= ERROR_OBJECT;`
`522`	`522`	`error("%s: object corrupt or missing: %s",`
`523`		`- sha1_to_hex(sha1), path);`
	`523`	`+ oid_to_hex(oid), path);`
`524`	`524`	`return 0; /* keep checking other objects */`
`525`	`525`	`}`
`526`	`526`
`@@ -619,26 +619,26 @@ static int fsck_cache_tree(struct cache_tree *it)`
`619`	`619`	`return err;`
`620`	`620`	`}`
`621`	`621`
`622`		`-static void mark_object_for_connectivity(const unsigned char *sha1)`
	`622`	`+static void mark_object_for_connectivity(const struct object_id *oid)`
`623`	`623`	`{`
`624`		`- struct object *obj = lookup_unknown_object(sha1);`
	`624`	`+ struct object *obj = lookup_unknown_object(oid->hash);`
`625`	`625`	`obj->flags \|= HAS_OBJ;`
`626`	`626`	`}`
`627`	`627`
`628`		`-static int mark_loose_for_connectivity(const unsigned char *sha1,`
	`628`	`+static int mark_loose_for_connectivity(const struct object_id *oid,`
`629`	`629`	`const char *path,`
`630`	`630`	`void *data)`
`631`	`631`	`{`
`632`		`- mark_object_for_connectivity(sha1);`
	`632`	`+ mark_object_for_connectivity(oid);`
`633`	`633`	`return 0;`
`634`	`634`	`}`
`635`	`635`
`636`		`-static int mark_packed_for_connectivity(const unsigned char *sha1,`
	`636`	`+static int mark_packed_for_connectivity(const struct object_id *oid,`
`637`	`637`	`struct packed_git *pack,`
`638`	`638`	`uint32_t pos,`
`639`	`639`	`void *data)`
`640`	`640`	`{`
`641`		`- mark_object_for_connectivity(sha1);`
	`641`	`+ mark_object_for_connectivity(oid);`
`642`	`642`	`return 0;`
`643`	`643`	`}`
`644`	`644`
Original file line number	Diff line number	Diff line change
`@@ -2534,17 +2534,17 @@ static void add_objects_in_unpacked_packs(struct rev_info *revs)`
`2534`	`2534`	`free(in_pack.array);`
`2535`	`2535`	`}`
`2536`	`2536`
`2537`		`-static int add_loose_object(const unsigned char sha1, const char path,`
	`2537`	`+static int add_loose_object(const struct object_id oid, const char path,`
`2538`	`2538`	`void *data)`
`2539`	`2539`	`{`
`2540`		`- enum object_type type = sha1_object_info(sha1, NULL);`
	`2540`	`+ enum object_type type = sha1_object_info(oid->hash, NULL);`
`2541`	`2541`
`2542`	`2542`	`if (type < 0) {`
`2543`	`2543`	`warning("loose object at %s could not be examined", path);`
`2544`	`2544`	`return 0;`
`2545`	`2545`	`}`
`2546`	`2546`
`2547`		`- add_object_entry(sha1, type, "", 0);`
	`2547`	`+ add_object_entry(oid->hash, type, "", 0);`
`2548`	`2548`	`return 0;`
`2549`	`2549`	`}`
`2550`	`2550`
Original file line number	Diff line number	Diff line change
`@@ -19,12 +19,12 @@ static int prune_subdir(int nr, const char path, void data)`
`19`	`19`	`return 0;`
`20`	`20`	`}`
`21`	`21`
`22`		`-static int prune_object(const unsigned char sha1, const char path,`
	`22`	`+static int prune_object(const struct object_id oid, const char path,`
`23`	`23`	`void *data)`
`24`	`24`	`{`
`25`	`25`	`int *opts = data;`
`26`	`26`
`27`		`- if (!has_sha1_pack(sha1))`
	`27`	`+ if (!has_sha1_pack(oid->hash))`
`28`	`28`	`return 0;`
`29`	`29`
`30`	`30`	`if (*opts & PRUNE_PACKED_DRY_RUN)`