laumann/ani - Change 5D2IYPL75HEP6JUEILEADSZRRSV72NECT6UQR3PORNDR35I2P5GQC

change: introduce changestore, print deleted lines

Introduce a changestore structure for keeping track of multiple changes.

The changestore is primarily needed to allow fetching contents from a change's dependencies (so we can print deleted lines). A changecontents() function is able to extract content bytes from dependent change files.

This change also begins the introduction of a lot of facilities for freeing resources in a more structured way. Using the changestore as an anchor point for all the allocated resources, we can navigate its structure and free everything that's been allocated at once.

Created by laumann on July 13, 2023

5D2IYPL75HEP6JUEILEADSZRRSV72NECT6UQR3PORNDR35I2P5GQC

Dependencies

In channels

main

Change contents

Deletion in zstdseek.c at line 36 [3.260]
B:BD[3.1012] → [3.1012:1057]
```
	printf("decompress result: %lu\n", result);
```
Insertion in scaffold.h at line 7 [8.35]
[8.164]
[9.0]
```
void *xrealloc(void *ptr, size_t size);
```
Insertion in scaffold.c at line 50 [8.208]
[8.459]
[8.459]
```
	memset(ret, 0, size);
```

Insertion in scaffold.c at line 53 [8.208]

[8.506]


	return ret;
}
void *
xrealloc(void *ptr, size_t size)
{
	void *ret;

Insertion in scaffold.c at line 62 [8.208]

[8.507]

	ret = realloc(ptr, size);
	if (!ret)
		die("Unable to allocate memory");

Insertion in hunk.h at line 138 [11.664]
[10.1276]
[11.1332]
```
void hunk_hunklistfree(struct hunklist *);
```

Insertion in hunk.c at line 51 [11.1372]

[10.1449]

[12.44]

}
void
hunk_hunklistfree(struct hunklist *hunklist)
{
	size_t i;
	for (i = 0; i < hunklist->len; i++) {
		struct basehunk *b = &hunklist->entries[i];
		switch (b->hunktype) {
		case FILE_MOVE:
			/* TBD */
			break;
		case FILE_DEL:
			/* TBD */
			break;
		default:
			break;
		}
	}

Insertion in hash.h at line 11 [13.31]

[13.195]

	/* FIXME(laumann): this should be a union { uint8_t blake3[BLAKE3_BYTES] } */

Insertion in hash.h at line 22 [13.31]

[10.1579]

[14.40]


/* Return 1 when hashes are equal, 0 otherwise */
int hasheq(struct hash *, struct hash *);

Insertion in hash.c at line 8 [13.360]
[12.69]
[13.421]
```
#include "blake3.h"
```

Insertion in hash.c at line 37 [13.360]

[14.77]


int
hasheq(struct hash *h1, struct hash *h2)
{
	size_t i;

Insertion in hash.c at line 43 [13.360]

[14.78]

	if (h1->variant != h2->variant)
		return 0;
	switch (h1->variant) {
	case HASH_NONE:
		return 1;
	case HASH_BLAKE3:
		for (i = 0; i < BLAKE3_LEN; i++)
			if (h1->bytes[i] != h2->bytes[i])
				return 0;
		return 1;
	default:
		die("unknown hash variant: %u", h1->variant);
	}
}

Insertion in change.h at line 77 [16.80]
[10.2349]
[15.664]
```
void hashedfree(struct hashed *);
```

Insertion in change.h at line 87 [16.80]

[10.2396]

[16.1005]


struct change {
	struct offsets offsets;
	struct hashed hashed;
	uint8_t *contents;
};
struct changeentry {
	size_t num;
	struct hash hash;
	struct change change;
};
/**
 * structure for keeping track of multiple changes
 */
struct changestore {
	size_t len;
	size_t cap;
	struct changeentry *entries;
};
void changestoreinit(struct changestore *, size_t cap);
void changestorefree(struct changestore *);
/**
 * either fetch a change that's already loaded, or load a change into
 * the changestore.
 */
struct change *changestoreget(struct changestore *, struct hash *);

Insertion in change.c at line 550 [16.1047]

[17.2024]

[18.0]

}
/**
 * Given an atom from a given change (by hash), extract the contents to return.
 *
 * Returns a malloc()'ed buffer that must be free()'d, if there were
 * any contents to available. Returns NULL otherwise. The size of the
 * returned buffer is provided in the "n" parameter.
 */
static uint8_t *
changecontents(
	struct changestore *changes, struct atom *change, uint8_t *contents,
	size_t *n
)
{
	struct newvertex *v;
	struct edgemap *e;
	struct change *ch;
	uint8_t *buf = NULL;
	size_t sz = 0;
	switch (change->atomtype) {
	case NEW_VERTEX:
		v = &change->newvertex;
		sz = v->end - v->start;
		buf = xmalloc(sizeof(uint8_t) * sz);
		memcpy(buf, &contents[v->start], sz);
		break;
	case EDGE_MAP:
		e = &change->edgemap;
		if (e->edges.len == 0) {
			/* Technically an error */
			break;
		}
		if (!(e->edges.entries[0].flag & EDGE_FLAG_DELETED))
			break;
		for (size_t i = 0; i < e->edges.len; i++) {
			struct edge *edge = &e->edges.entries[i];
			// FIXME: need to keep track of current! see
			// /home/t/sources/pijul/pijul/libpijul/src/changestore/filesystem.rs (get_contents_ext)
			size_t z = edge->to.end - edge->to.start;
			/* TODO loop over the edges, extract relevant contents from the changestore */
			// keep track of current vertex
			ch = changestoreget(changes, &edge->to.change);
			/* printf("changestoreget("); */
			/* hashprint(&edge->to.change); */
			/* printf(")"); */
			/* printf(" - %s\n", ch ? "ok" : "fail :-("); */
			// We find a change with some contents, and we
			// need to extract contents[start; end] we
			// then need to either xmalloc() buf, or
			// extend it to include more bytes
			if (ch) {
				if (buf) {
					buf = xrealloc(
						buf, sz + sizeof(uint8_t) * z
					);
				} else {
					buf = xmalloc(sizeof(uint8_t) * z);
				}
				memcpy(&buf[sz], &ch->contents[edge->to.start],
				       z);
				sz += z;
			}
		}
		break;
	}
	*n = sz;
	return buf;

Insertion in change.c at line 647 [16.1047]

[19.570]

}
void
printcontents(uint8_t *buf, size_t len, char prefix)
{
	int waseol = 1;
	size_t i;
	uint8_t x;
	for (i = 0; i < len; i++) {
		if (waseol) {
			printf("%c ", prefix);
			waseol = 0;
		}
		x = buf[i];
		putchar(x);
		if (x == '\n')
			waseol = 1;
	}
	if (!waseol)
		printf("\n");

Replacement in change.c at line 675 [16.1047]

B:BD[18.348] → [10.4060:4106]

print_atom(struct atom *a, uint8_t *contents)

[18.348]

[18.387]

print_atom(struct changestore *changes, struct atom *a, uint8_t *contents)

Replacement in change.c at line 679 [16.1047]
∅:D[10.4149] → [20.130:142]
B:BD[18.417] → [20.130:142]
∅:D[20.142] → [21.569:593]
B:BD[14.246] → [21.569:593]
```
	uint8_t x;
	size_t i;
	int waseol;
```
[10.4149]
[18.446]
```
	size_t n;
	uint8_t *res;
```

Replacement in change.c at line 685 [16.1047]

B:BD[18.510] → [18.510:581]

		printf("up: ");
		print_positionlist(&v->upcontext);
		printf(", ");

[18.510]

[18.581]

		/* printf("up: "); */
		/* print_positionlist(&v->upcontext); */
		/* printf(", "); */

Replacement in change.c at line 689 [16.1047]

B:BD[18.582] → [18.582:634]

		printf("new: %lu:%lu, down: ", v->start, v->end);

[18.582]

[18.634]

		/* printf("new: %lu:%lu, down: ", v->start, v->end); */

Replacement in change.c at line 691 [16.1047]

B:BD[18.635] → [18.635:690]

		print_positionlist(&v->downcontext);
		printf("\n");

[18.635]

[18.690]

		/* print_positionlist(&v->downcontext); */
		/* printf("\n"); */

Replacement in change.c at line 694 [16.1047]

B:BD[18.691] → [18.691:890]

		waseol = 1;
		for (i = v->start; i < v->end; i++) {
			if (waseol) {
				printf("+ ");
				waseol = 0;
			}
			x = contents[i];
			putchar(x);
			if (x == '\n')
				waseol = 1;
		}
		printf("\n");

[18.691]

[18.890]

		printcontents(&contents[v->start], v->end - v->start, '+');

Replacement in change.c at line 699 [16.1047]

B:BD[18.935] → [19.574:949]

		printf("edgemap {\n  edges: [\n");
		for (i = 0; i < m->edges.len; i++) {
			struct edge *e = &m->edges.entries[i];
			printf("    edge { previous = %u, flag = ",
			       e->previous);
			print_edgeflags(e->flag);
			printf(", from = Position { .. }, to = vertex { .. }, introducedby = "
			);
			hashprint(&e->introducedby);
			printf(" }\n");
		}
		printf("  ]\n}\n");

[18.935]

[18.962]

		/* edgemap debugging */
		/* printf("edgemap {\n  edges: [\n"); */
		/* for (i = 0; i < m->edges.len; i++) { */
		/* 	struct edge *e = &m->edges.entries[i]; */
		/* 	printf("    edge { previous = %u, flag = ", */
		/* 	       e->previous); */
		/* 	print_edgeflags(e->flag); */
		/* 	printf(", from = position { change = "); */
		/* 	hashprint(&e->from.change); */
		/* 	printf(", pos = %lu }", e->from.pos); */
		/* 	printf(", to = vertex { change = "); */
		/* 	hashprint(&e->to.change); */
		/* 	printf(", start = %lu, end = %lu }, introducedby = ", */
		/* 	       e->to.start, e->to.end); */
		/* 	hashprint(&e->introducedby); */
		/* 	printf(" }\n"); */
		/* } */
		/* printf("  ]\n}\n"); */
		res = changecontents(changes, a, contents, &n);
		if (res)
			printcontents(res, n, '-');

Replacement in change.c at line 740 [16.1047]

B:BD[22.875] → [22.875:976]

	if (bincode_getu8(&bc)) {
		len = bincode_getu64(&bc);
		m->encoding = bincode_getstr(&bc, len);
	}

[22.875]

[22.976]

	change_decode_encoding(&bc, &m->encoding);

Replacement in change.c at line 744 [16.1047]

B:BD[14.258] → [10.4150:4205]

print_change(struct hashed *hashed, uint8_t *contents)

[14.258]

[14.306]

print_change(
	struct changestore *changes, struct hashed *hashed, uint8_t *contents
)

Replacement in change.c at line 775 [16.1047]
B:BD[14.1092] → [21.619:645]
∅:D[21.645] → [14.1117:1205]
B:BD[14.1117] → [14.1117:1205]
```
	printf("\n# Hunks\n\n");
	/* FIXME: Put all the hashes of dependencies in a big list, and number them from 2 */
```
[14.1092]
[14.1205]
```
	printf("\n# Hunks\n");
```
Replacement in change.c at line 779 [16.1047]
∅:D[10.4259] → [23.215:242]
B:BD[14.1295] → [23.215:242]
```
		printf("%lu. %s", i + 1,
```
[10.4259]
[23.242]
```
		printf("\n%lu. %s", i + 1,
```
Replacement in change.c at line 789 [16.1047]
B:BD[14.1554] → [14.1554:1582]
```
			print_atom(c, contents);
```
[14.1554]
[14.1582]
```
			print_atom(changes, c, contents);
```

Replacement in change.c at line 801 [16.1047]

B:BD[14.1779] → [24.102:133]

			print_atom(ratm, contents);

[14.1779]


			print_atom(changes, c, contents);
			print_atom(changes, replacement, contents);

Replacement in change.c at line 829 [16.1047]
∅:D[6.551] → [19.1140:1179]
B:BD[19.1140] → [19.1140:1179]
```
			print_atom(&f->contents, contents);
```
[6.551]
[6.552]
```
			print_atom(changes, &f->contents, contents);
```
Replacement in change.c at line 903 [16.1047]
B:BD[7.1206] → [7.1206:1241]
```
			print_atom(&r->name, contents);
```
[7.1206]
[7.1241]
```
			print_atom(changes, &r->name, contents);
```
Replacement in change.c at line 905 [16.1047]
B:BD[7.1263] → [7.1263:1299]
```
			print_atom(&r->inode, contents);
```
[7.1263]
[7.1299]
```
			print_atom(changes, &r->inode, contents);
```

Insertion in change.c at line 912 [16.1047]

[14.1853]

[18.992]

	}
}
struct change *
changestoreget(struct changestore *store, struct hash *hash)
{
	size_t i;
	for (i = 0; i < store->len; i++) {
		if (hasheq(hash, &store->entries[i].hash))
			return &store->entries[i].change;
	}
	return NULL;
}
void
changestoreinit(struct changestore *s, size_t cap)
{
	s->entries = xmalloc(sizeof(struct changeentry) * cap);
	s->cap = cap;
	s->len = 0;
}
void
changestorefree(struct changestore *s)
{
	size_t i;
	struct changeentry *e;
	struct change *c;
	/* Free all the entries first */
	for (i = 0; i < s->len; i++) {
		e = &s->entries[i];
		c = &e->change;
		hashedfree(&c->hashed);
		if (c->contents)
			free(c->contents);

Insertion in change.c at line 950 [16.1047]

[18.995]

}
void
hashedfree(struct hashed *h)
{
	hashlist_free(&h->dependencies);
	hashlist_free(&h->extraknown);
	if (h->metadata)
		free(h->metadata);

Replacement in change.c at line 962 [16.1047]

∅:D[18.1002] → [25.4:82]

∅:D[26.2599] → [25.4:82]

B:BD[25.4] → [25.4:82]

 * Takes an input hash, and tries to find a change file to open and read out.

[18.1002]

[25.82]

 * Format a path to a change file, given the input repo dir and a
 * hash. The result is placed in dst.

Replacement in change.c at line 965 [16.1047]
∅:D[25.86] → [16.2199:2203]
B:BD[16.2199] → [16.2199:2203]
B:BD[16.2203] → [4.119:178]
```
int
change(const char *hash, int verbose, const char *repodir)
```
[25.86]
[16.2212]
```
static void
formatchangepath(char *dst, const char *repodir, const char *hashstr)
```
Deletion in change.c at line 968 [16.1047]
B:BD[16.2214] → [16.2214:2233]
B:BD[16.2233] → [10.4527:4548]
∅:D[27.3285] → [26.2600:2620]
∅:D[10.4548] → [26.2600:2620]
B:BD[16.2254] → [26.2600:2620]
B:BD[26.2620] → [15.1401:1429]
B:BD[15.1429] → [28.103:117]
B:BD[28.117] → [29.0:32]
B:BD[29.32] → [10.4549:4572]
∅:D[25.231] → [16.2254:2255]
∅:D[30.918] → [16.2254:2255]
∅:D[17.2126] → [16.2254:2255]
∅:D[27.3302] → [16.2254:2255]
∅:D[10.4572] → [16.2254:2255]
B:BD[16.2254] → [16.2254:2255]
B:BD[16.2255] → [28.148:188]
```
	int fd;
	int err;
	struct offsets off;
	uint8_t *contents;
	uint8_t contents_hash[32];
	char *h, *p;
	char chfile[PATH_MAX] = { 0 };
	struct hashed hashed;
	/* FIXME - make this a lot nicer... */
```

Replacement in change.c at line 969 [16.1047]

B:BD[28.282] → [28.282:323]

	p = stpncpy(chfile, repodir, PATH_MAX);

[28.282]

[28.323]

	char *p;
	p = stpncpy(dst, repodir, PATH_MAX);

Replacement in change.c at line 977 [16.1047]
∅:D[28.412] → [25.232:251]
B:BD[16.2255] → [25.232:251]
B:BD[25.251] → [28.413:441]
```
	h = (char *)hash;
	*p++ = *h++;
	*p++ = *h++;
```
[28.412]
[28.441]
```
	*p++ = hashstr[0];
	*p++ = hashstr[1];
```
Replacement in change.c at line 981 [16.1047]
B:BD[25.292] → [28.455:479]
```
	p = stpncpy(p, h, 51);
```
[25.292]
[28.479]
```
	p = stpncpy(p, &hashstr[2], 51);
```
Insertion in change.c at line 983 [16.1047]
[28.506]
[25.339]
```
}
```

Replacement in change.c at line 985 [16.1047]

B:BD[25.340] → [25.340:374]

	printf("Opening: %s\n", chfile);

[25.340]

[2.0]

static int
loadchange(
	struct change *c, struct hash *hash, const char *repodir,
	const char *hashstr, int verbose
)
{
	int fd, err;
	char chfile[PATH_MAX] = { 0 };
	struct offsets *off;
	struct hashed *hashed;
	uint8_t contents_hash[32];
	off = &c->offsets;
	hashed = &c->hashed;
	err = 0;
	printf("loading change %s\n", hashstr);
	formatchangepath(chfile, repodir, hashstr);

Replacement in change.c at line 1010 [16.1047]

B:BD[16.2474] → [27.3303:3344]

	base32_hashdecode(contents_hash, hash);

[16.2474]

	// FIXME: hash decoding should result in a "struct hash" not
	// just raw bytes
	base32_hashdecode(contents_hash, hashstr);
	memcpy(hash->bytes, contents_hash, BLAKE3_BYTES);
	hash->variant = HASH_BLAKE3;

Replacement in change.c at line 1016 [16.1047]
B:BD[16.2475] → [31.103:143]
```
	err = change_decode_offsets(fd, &off);
```
[16.2475]
[16.2508]
```
	err = change_decode_offsets(fd, off);
```

Replacement in change.c at line 1022 [16.1047]

B:BD[32.1874] → [5.266:335]

	if (off.version != VERSION) {
		if (off.version == VERSION_NOENC) {

[32.1874]

[5.335]

	if (off->version != VERSION) {
		if (off->version == VERSION_NOENC) {

Replacement in change.c at line 1025 [16.1047]
B:BD[5.421] → [5.421:445]
```
			       off.version);
```
[5.421]
[5.445]
```
			       off->version);
```
Replacement in change.c at line 1028 [16.1047]
B:BD[5.512] → [5.512:536]
```
			       off.version);
```
[5.512]
[5.536]
```
			       off->version);
```

Replacement in change.c at line 1034 [16.1047]

B:BD[17.2156] → [17.2156:2211]

B:BD[17.2211] → [30.919:944]

		fd, off.unhashed_off - OFFSETS_SIZE, off.hashed_len,
		contents_hash, &hashed

[17.2156]

[17.2227]

		fd, off->unhashed_off - OFFSETS_SIZE, off->hashed_len,
		contents_hash, hashed

Replacement in change.c at line 1046 [16.1047]

B:BD[18.1116] → [20.263:322]

	if (lseek(fd, (off_t)off.contents_off, SEEK_SET) == -1) {

[18.1116]

[18.1168]

	if (lseek(fd, (off_t)off->contents_off, SEEK_SET) == -1) {

Replacement in change.c at line 1050 [16.1047]
B:BD[18.1202] → [18.1202:1246]
```
	contents = change_read_contents(fd, &off);
```
[18.1202]
[18.1246]
```
	c->contents = change_read_contents(fd, off);
```

Replacement in change.c at line 1052 [16.1047]

B:BD[18.1260] → [18.1260:1312]

		dump_buf("contents", contents, off.contents_len);

[18.1260]

[18.1312]

		dump_buf("contents", c->contents, off->contents_len);
out:
	return err;
}

Replacement in change.c at line 1057 [16.1047]

B:BD[18.1313] → [14.1856:1890]

	print_change(&hashed, contents);

[18.1313]

[30.1674]

/**
 * Same as loadchange() but takes a "struct hash" as input instead of a string
 */
static int
loadchangeh(
	struct change *c, struct hash *h, const char *repodir,
	struct hash *hash, int verbose
)
{
	char hashstr[54];

Replacement in change.c at line 1068 [16.1047]

∅:D[33.184] → [31.239:256]

∅:D[34.904] → [31.239:256]

B:BD[31.239] → [31.239:256]

B:BD[16.2966] → [16.2966:2983]

	free(contents);
out:
	close(fd);

[30.1675]

[16.2983]

	/* FIXME consider that it might not only be blake3 bytes */
	base32_hashencode(hashstr, hash->bytes);
	return loadchange(c, h, repodir, hashstr, verbose);
}
/**
 * Takes an input hash, and tries to find a change file to open and read out.
 */
int
change(const char *hash, int verbose, const char *repodir)
{
	int err;
	struct changestore changestore = { 0 };
	struct changeentry *ch;
	size_t i, x;
	changestoreinit(&changestore, 32);
	ch = &changestore.entries[0];
	err = loadchange(&ch->change, &ch->hash, repodir, hash, verbose);
	if (err)
		return err;
	x = 1;
	changestore.len = 1;
	changestore.entries[0].num = 1;
	for (i = 0; i < ch->change.hashed.dependencies.len; i++) {
		err = loadchangeh(
			&changestore.entries[x].change,
			&changestore.entries[x].hash, repodir,
			&ch->change.hashed.dependencies.entries[i], verbose
		);
		if (err)
			goto changeout;
		changestore.len++;
		changestore.entries[x].num = ++x;
	}
	for (i = 0; i < ch->change.hashed.extraknown.len; i++) {
		err = loadchangeh(
			&changestore.entries[x].change,
			&changestore.entries[x].hash, repodir,
			&ch->change.hashed.extraknown.entries[i], verbose
		);
		if (err)
			goto changeout;
		changestore.len++;
		changestore.entries[x].num = ++x;
	}
	printf("x = %lu\n", x);
	print_change(&changestore, &ch->change.hashed, ch->change.contents);
changeout:
	changestorefree(&changestore);

change: introduce changestore, print deleted lines

Dependencies

In channels

Change contents

Deletion in zstdseek.c at line 36 [3.260]

Insertion in scaffold.h at line 7 [8.35]

Insertion in scaffold.c at line 50 [8.208]

Insertion in scaffold.c at line 53 [8.208]

Insertion in scaffold.c at line 62 [8.208]

Insertion in hunk.h at line 138 [11.664]

Insertion in hunk.c at line 51 [11.1372]

Insertion in hash.h at line 11 [13.31]

Insertion in hash.h at line 22 [13.31]

Insertion in hash.c at line 8 [13.360]

Insertion in hash.c at line 37 [13.360]

Insertion in hash.c at line 43 [13.360]

Insertion in change.h at line 77 [16.80]

Insertion in change.h at line 87 [16.80]

Insertion in change.c at line 550 [16.1047]

Insertion in change.c at line 647 [16.1047]

Replacement in change.c at line 675 [16.1047]

Replacement in change.c at line 679 [16.1047]

Replacement in change.c at line 685 [16.1047]

Replacement in change.c at line 689 [16.1047]

Replacement in change.c at line 691 [16.1047]

Replacement in change.c at line 694 [16.1047]

Replacement in change.c at line 699 [16.1047]

Replacement in change.c at line 740 [16.1047]

Replacement in change.c at line 744 [16.1047]

Replacement in change.c at line 775 [16.1047]

Replacement in change.c at line 779 [16.1047]

Replacement in change.c at line 789 [16.1047]

Replacement in change.c at line 801 [16.1047]

Replacement in change.c at line 829 [16.1047]

Replacement in change.c at line 903 [16.1047]

Replacement in change.c at line 905 [16.1047]

Insertion in change.c at line 912 [16.1047]

Insertion in change.c at line 950 [16.1047]

Replacement in change.c at line 962 [16.1047]

Replacement in change.c at line 965 [16.1047]

Deletion in change.c at line 968 [16.1047]

Replacement in change.c at line 969 [16.1047]

Replacement in change.c at line 977 [16.1047]

Replacement in change.c at line 981 [16.1047]

Insertion in change.c at line 983 [16.1047]

Replacement in change.c at line 985 [16.1047]

Replacement in change.c at line 1010 [16.1047]

Replacement in change.c at line 1016 [16.1047]

Replacement in change.c at line 1022 [16.1047]

Replacement in change.c at line 1025 [16.1047]

Replacement in change.c at line 1028 [16.1047]

Replacement in change.c at line 1034 [16.1047]

Replacement in change.c at line 1046 [16.1047]

Replacement in change.c at line 1050 [16.1047]

Replacement in change.c at line 1052 [16.1047]

Replacement in change.c at line 1057 [16.1047]

Replacement in change.c at line 1068 [16.1047]