laumann/ani - Change SMB3M6ESOIR2LMFII2VFQJSPFIUYXHD7CXYARIGOKPB2QF2ORFLAC

change: rework to make more testable

This is a big overhaul: Change files are new mmap()ed when they are opened, allowing to change most operations to work on byte buffers (instead of file descriptors).

This in turn makes the change deserialization much more testable as we can just feed it arrays of bytes w/o requiring anything on disk.

An error type is introduced and parsing functions should return variants of this error type instead of having the whole program die when a parsing error occurs.

A separate change that unfortunately got worked into this one is the introduction of change_readstr() which can take care of fetching a string length, xmalloc()ing the right amount of space, and copying the string data into it.

Created by laumann on November 27, 2023

SMB3M6ESOIR2LMFII2VFQJSPFIUYXHD7CXYARIGOKPB2QF2ORFLAC

Dependencies

In channels

main

In discussions

#14 Testing strategy

Change contents

File addition: test (d--x------)
[6.1]

File addition: test_change.c (----------)

[0.16]

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#undef NDEBUG
#include <assert.h>
#include "NETL2.h"
#include "../common.h"
#include "../zstdseek.h"
#include "../types.h"
#include "../scaffold.h"
#include "../hash.h"
#include "../vertex.h"
#include "../atom.h"
#include "../hunk.h"
#include "../mbuf.h"
#include "../change.h"
static void
test_changefileoffsets()
{
	struct mbuf ch = {
		.len = NETL2LEN,
		.buf = NETL2,
	};
	struct offsets off = { 0 };
	int err;
	err = changefileoffsets(&ch, &off);
	assert(err == CHANGEFILE_OK);
	assert(off.version == VERSION);
	assert(off.hashed_len == 985);
	assert(off.unhashed_off = 803);
	assert(off.unhashed_len == 104);
	assert(off.contents_off == 945);
	assert(off.contents_len == 120);
}
static void
test_changefileoffsetsbad()
{
	struct mbuf ch = { .len = 55, .buf = NULL };
	int err;
	struct offsets off = { 0 };
	err = changefileoffsets(&ch, &off);
	assert(err == CHANGEFILE_TOOSHORT);
}
static void
test_changefileoffsetsversion()
{
	struct mbuf ch = {
		.len = NETL2LEN,
		.buf = NETL2,
	};
	struct offsets off = { 0 };
	int err;
	ch.buf[0] = 5;
	err = changefileoffsets(&ch, &off);
	assert(err == CHANGEFILE_UNSUPPORTEDVERSION);
}
static void
test_decodehashed()
{
	struct hashed hashed = { 0 };
	struct changeheader *header;
	struct author *author;
	usize datalen = 747;
	usize hashedlen = 985;
	u8 buf[hashedlen];
	enum error ret;
	usize err;
	u8 expectedhash[32] = { 0x69, 0x26, 0xbd, 0x37, 0xbb, 0x93, 0xa2, 0x5a,
				0xae, 0x27, 0x9e, 0x8c, 0xaf, 0x13, 0x08, 0x32,
				0xbd, 0xca, 0x78, 0x9c, 0x84, 0xc4, 0x49, 0x79,
				0xa6, 0x83, 0xc3, 0x8a, 0x3d, 0x0e, 0xa9, 0x10 };
	err = zstdseek_decompress(buf, hashedlen, NETL2 + 56, datalen);
	assert(err > 0);
	ret = change_decodehashed(buf, hashedlen, expectedhash, &hashed);
	assert(ret == CHANGEFILE_OK);
	assert(hashed.version == VERSION);
	header = &hashed.header;
	assert(strcmp(header->message, "Makefile: add check target") == 0);
	assert(header->description == NULL);
	assert(strcmp(header->timestamp, "2022-10-31T12:34:27.238139355Z") == 0
	);
	assert(header->authors.len == 1);
	author = &header->authors.map[0];
	assert(author->len == 1);
	assert(strcmp(author->entries[0].key, "key") == 0);
	assert(strcmp(author->entries[0].value,
		      "AFgzZkD8ARgC21gkkCvxPV5HbL7YDVzgYEhbAxQG7UQY") == 0);
	assert(hashed.dependencies.len == 1);
	assert(hashed.extraknown.len == 4);
	/* assert hunks as expected */
	assert(hashed.hunks.len == 2);
	hashedfree(&hashed);
}
int
main()
{
	test_changefileoffsets();
	test_changefileoffsetsbad();
	test_changefileoffsetsversion();
	test_decodehashed();
}

File addition: meson.build (----------)

[0.16]


cases = [
  'change',
]
foreach testcase : cases
  srcs = files('test_@0@.c'.format(testcase))
  exe = executable('test_@0@'.format(testcase), srcs, link_with : lib) 
  test(testcase, exe, suite : 'unit', timeout : 120)
endforeach

File addition: NETL2.h (----------)

[0.16]

/**
 * A fairly simple change that has just two hunks: an edit and a replacement.
 */
unsigned char NETL2[] = {
	0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd9, 0x03, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x23, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x03, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x4f, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xb5, 0x2f, 0xfd,
	0x00, 0x60, 0x95, 0x06, 0x00, 0x84, 0x0b, 0x06, 0x00, 0x1a, 0x4d, 0x61,
	0x6b, 0x65, 0x66, 0x69, 0x6c, 0x65, 0x3a, 0x20, 0x61, 0x64, 0x64, 0x20,
	0x63, 0x68, 0x65, 0x63, 0x6b, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74,
	0x00, 0x1e, 0x32, 0x30, 0x32, 0x32, 0x2d, 0x31, 0x30, 0x2d, 0x33, 0x31,
	0x54, 0x31, 0x32, 0x3a, 0x33, 0x34, 0x3a, 0x32, 0x37, 0x2e, 0x32, 0x33,
	0x38, 0x31, 0x33, 0x39, 0x33, 0x35, 0x35, 0x5a, 0x01, 0x03, 0x6b, 0x65,
	0x79, 0x2c, 0x41, 0x46, 0x67, 0x7a, 0x5a, 0x6b, 0x44, 0x38, 0x41, 0x52,
	0x67, 0x43, 0x32, 0x31, 0x67, 0x6b, 0x6b, 0x43, 0x76, 0x78, 0x50, 0x56,
	0x35, 0x48, 0x62, 0x4c, 0x37, 0x59, 0x44, 0x56, 0x7a, 0x67, 0x59, 0x45,
	0x68, 0x62, 0x41, 0x78, 0x51, 0x47, 0x37, 0x55, 0x51, 0x59, 0xce, 0x1c,
	0x40, 0xeb, 0x89, 0x5a, 0xef, 0xf0, 0x24, 0xdc, 0x57, 0x1d, 0x3d, 0x8a,
	0x0a, 0xb3, 0x7c, 0x7b, 0x1c, 0x8d, 0x23, 0x74, 0xbe, 0xc1, 0x54, 0x69,
	0x68, 0x57, 0xf6, 0x52, 0xcb, 0x16, 0x04, 0x0e, 0xee, 0xba, 0xbd, 0xa2,
	0xe0, 0x9c, 0xb5, 0x8b, 0x65, 0xa1, 0x37, 0xcc, 0x7c, 0xe8, 0x54, 0xd8,
	0x5f, 0x09, 0x39, 0xa0, 0x25, 0x97, 0x53, 0x78, 0x66, 0xb0, 0x67, 0xe5,
	0x49, 0xcb, 0xff, 0x01, 0x00, 0x00, 0x00, 0xd0, 0xb4, 0x42, 0xe8, 0x09,
	0x00, 0x79, 0x6a, 0x3c, 0x4a, 0x81, 0x17, 0x97, 0x9c, 0x20, 0xf3, 0x0a,
	0xb1, 0x27, 0x95, 0x1d, 0x46, 0x65, 0x5f, 0xc9, 0x77, 0x00, 0x58, 0x28,
	0xb5, 0x2f, 0xfd, 0x00, 0x60, 0x85, 0x05, 0x00, 0x04, 0x0a, 0xca, 0x9b,
	0x81, 0x3f, 0xc1, 0x1d, 0xf2, 0x94, 0x32, 0x9a, 0x26, 0x91, 0x73, 0x11,
	0xbd, 0x54, 0x04, 0x9b, 0x02, 0x87, 0xd7, 0x80, 0xe2, 0xe0, 0x11, 0xef,
	0xcd, 0xb8, 0x01, 0x00, 0x00, 0x00, 0xc3, 0x2d, 0x16, 0x4a, 0x1e, 0xad,
	0x06, 0x63, 0x03, 0xd2, 0xed, 0x42, 0x93, 0xeb, 0x6f, 0xcc, 0xb9, 0xc0,
	0xc8, 0xc5, 0x7b, 0xcf, 0xa0, 0xfa, 0x41, 0x82, 0x73, 0x12, 0xdc, 0x84,
	0x32, 0x86, 0x01, 0x00, 0x00, 0x00, 0x62, 0xfb, 0x76, 0x64, 0x94, 0xbb,
	0x24, 0x60, 0x76, 0xd2, 0xde, 0x5e, 0xd5, 0x3a, 0x34, 0xeb, 0x46, 0x0a,
	0x6a, 0xf8, 0x57, 0xbf, 0xe1, 0xdb, 0xd0, 0x35, 0xcf, 0x00, 0x39, 0x62,
	0x77, 0xc8, 0x00, 0x02, 0x06, 0x01, 0x01, 0x00, 0x00, 0x00, 0x0e, 0xee,
	0xba, 0xbd, 0xa2, 0xe0, 0x9c, 0xb5, 0x8b, 0x65, 0xa1, 0x37, 0xcc, 0x7c,
	0xe8, 0x54, 0xd8, 0x5f, 0x09, 0x39, 0xa0, 0x25, 0x97, 0x53, 0x78, 0x66,
	0xb0, 0x67, 0xe5, 0x49, 0xcb, 0xff, 0xa5, 0x02, 0x00, 0x52, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x0e, 0xee,
	0xba, 0xbd, 0x05, 0x00, 0x06, 0xac, 0xd0, 0x83, 0x77, 0xc0, 0xb1, 0x15,
	0x27, 0xa5, 0x0b, 0xcc, 0x28, 0xb5, 0x2f, 0xfd, 0x00, 0x60, 0x35, 0x04,
	0x00, 0x64, 0x06, 0xa2, 0xe0, 0x9c, 0xb5, 0x8b, 0x65, 0xa1, 0x37, 0xcc,
	0x7c, 0xe8, 0x54, 0xd8, 0x5f, 0x09, 0x39, 0xa0, 0x25, 0x97, 0x53, 0x78,
	0x66, 0xb0, 0x67, 0xe5, 0x49, 0xcb, 0xff, 0xca, 0x01, 0x00, 0x08, 0x00,
	0x4d, 0x61, 0x6b, 0x65, 0x66, 0x69, 0x6c, 0x65, 0x2f, 0x01, 0x05, 0x55,
	0x54, 0x46, 0x2d, 0x38, 0x07, 0x00, 0x00, 0x00, 0x01, 0x81, 0x01, 0x01,
	0x00, 0x00, 0x00, 0x0e, 0xee, 0xba, 0xbd, 0xfe, 0x02, 0xce, 0x1c, 0x40,
	0xeb, 0x89, 0x5a, 0xef, 0xf0, 0x24, 0xdc, 0x57, 0x1d, 0x3d, 0x8a, 0x0a,
	0xb3, 0x7c, 0x7b, 0x1c, 0x8d, 0x23, 0x74, 0xbe, 0xc1, 0x54, 0x69, 0x68,
	0x57, 0xf6, 0x52, 0xcb, 0x16, 0x15, 0x06, 0x33, 0x06, 0x0c, 0x00, 0x0a,
	0x73, 0x03, 0xb0, 0x32, 0x58, 0x00, 0x1f, 0xaa, 0x06, 0x00, 0xc3, 0x68,
	0x60, 0x0c, 0xea, 0x82, 0x5d, 0x46, 0x2c, 0x19, 0xcf, 0xcc, 0x07, 0x0c,
	0xfe, 0x02, 0x4e, 0x28, 0xb5, 0x2f, 0xfd, 0x00, 0x60, 0xf5, 0x03, 0x00,
	0x24, 0x06, 0x78, 0x66, 0xb0, 0x67, 0xe5, 0x49, 0xcb, 0xff, 0xca, 0x01,
	0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x0e, 0xee, 0xba, 0xbd, 0xa2, 0xe0,
	0x9c, 0xb5, 0x8b, 0x65, 0xa1, 0x37, 0xcc, 0x7c, 0xe8, 0x54, 0xd8, 0x5f,
	0x09, 0x39, 0xa0, 0x25, 0x97, 0x53, 0xfe, 0x02, 0x00, 0x01, 0x53, 0x77,
	0x08, 0x4d, 0x61, 0x6b, 0x65, 0x66, 0x69, 0x6c, 0x65, 0x37, 0x05, 0x55,
	0x54, 0x46, 0x2d, 0x38, 0x01, 0x00, 0x00, 0x00, 0x2b, 0xec, 0x22, 0x87,
	0xe4, 0xa3, 0x3f, 0x21, 0x88, 0x9a, 0x3e, 0x30, 0x84, 0xe3, 0xf1, 0xcb,
	0x56, 0xc1, 0x0f, 0x17, 0xf3, 0x09, 0x01, 0x7d, 0x56, 0x5d, 0xba, 0x1a,
	0xf8, 0x91, 0x99, 0xc3, 0x0a, 0x00, 0xac, 0x2c, 0x90, 0x40, 0x0e, 0x6b,
	0x3e, 0x81, 0x11, 0x51, 0x12, 0xcc, 0x65, 0x71, 0x31, 0xee, 0x8c, 0xb8,
	0x22, 0xee, 0x42, 0x40, 0x01, 0xbc, 0x5e, 0x2a, 0x4d, 0x18, 0x39, 0x00,
	0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xf0, 0xe1,
	0xe4, 0xb8, 0xb9, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x86, 0xdf,
	0x60, 0x45, 0x8f, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x88, 0x6d,
	0x55, 0x04, 0x87, 0x00, 0x00, 0x00, 0xd9, 0x00, 0x00, 0x00, 0x42, 0x33,
	0x02, 0x89, 0x04, 0x00, 0x00, 0x00, 0x80, 0xb1, 0xea, 0x92, 0x8f, 0x28,
	0xb5, 0x2f, 0xfd, 0x00, 0x60, 0x41, 0x03, 0x00, 0x7b, 0x22, 0x73, 0x69,
	0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x3a, 0x22, 0x35, 0x46,
	0x57, 0x4d, 0x47, 0x79, 0x53, 0x46, 0x33, 0x32, 0x6f, 0x58, 0x6d, 0x73,
	0x6a, 0x48, 0x64, 0x61, 0x67, 0x5a, 0x65, 0x6e, 0x4b, 0x57, 0x45, 0x35,
	0x67, 0x79, 0x78, 0x50, 0x51, 0x65, 0x52, 0x4d, 0x43, 0x48, 0x41, 0x50,
	0x51, 0x41, 0x59, 0x6d, 0x65, 0x46, 0x59, 0x7a, 0x63, 0x64, 0x6b, 0x5a,
	0x73, 0x42, 0x6e, 0x31, 0x43, 0x43, 0x4d, 0x52, 0x67, 0x66, 0x72, 0x53,
	0x42, 0x51, 0x36, 0x77, 0x61, 0x63, 0x50, 0x51, 0x79, 0x79, 0x67, 0x62,
	0x4e, 0x50, 0x31, 0x67, 0x78, 0x7a, 0x4d, 0x52, 0x61, 0x6b, 0x34, 0x45,
	0x32, 0x73, 0x22, 0x7d, 0x5e, 0x2a, 0x4d, 0x18, 0x15, 0x00, 0x00, 0x00,
	0x71, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x6a, 0xa6, 0x03, 0x07,
	0x01, 0x00, 0x00, 0x00, 0x80, 0xb1, 0xea, 0x92, 0x8f, 0x28, 0xb5, 0x2f,
	0xfd, 0x00, 0x60, 0xc1, 0x03, 0x00, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x3a,
	0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x0a, 0x09, 0x2e, 0x2f, 0x61, 0x6e,
	0x69, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x41, 0x47, 0x42,
	0x4c, 0x51, 0x4f, 0x51, 0x49, 0x42, 0x36, 0x44, 0x53, 0x44, 0x32, 0x41,
	0x50, 0x4f, 0x36, 0x4c, 0x32, 0x50, 0x4c, 0x46, 0x58, 0x46, 0x37, 0x43,
	0x52, 0x57, 0x4b, 0x41, 0x44, 0x36, 0x56, 0x41, 0x57, 0x49, 0x41, 0x44,
	0x36, 0x46, 0x32, 0x44, 0x54, 0x48, 0x34, 0x45, 0x49, 0x52, 0x59, 0x52,
	0x51, 0x43, 0x0a, 0x0a, 0x00, 0x2e, 0x50, 0x48, 0x4f, 0x4e, 0x59, 0x3a,
	0x20, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x20, 0x66, 0x6d, 0x74, 0x20, 0x62,
	0x75, 0x69, 0x6c, 0x64, 0x20, 0x67, 0x72, 0x61, 0x70, 0x68, 0x20, 0x63,
	0x68, 0x65, 0x63, 0x6b, 0x0a, 0x00, 0x5e, 0x2a, 0x4d, 0x18, 0x15, 0x00,
	0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x41, 0x5a,
	0x84, 0x0b, 0x01, 0x00, 0x00, 0x00, 0x80, 0xb1, 0xea, 0x92, 0x8f
};
unsigned int NETL2LEN = 1103;

Replacement in meson.build at line 6 [8.36]

B:BD[7.80] → [7.80:375]

	'-g3',
	'-D_POSIX_C_SOURCE=200809L',
	# Extra flags from https://nullprogram.com/blog/2023/04/29/
	'-Wdouble-promotion',
	'-Wconversion',
	#'-fsanitize-undefined-trap-on-error',
	#'-fsanitize=address', # can't have this one because of the assembly :-(
	'-fno-diagnostics-color',
	language: 'c'

[7.80]

[7.375]

  '-g3',
  '-D_POSIX_C_SOURCE=200809L',
  # Extra flags from https://nullprogram.com/blog/2023/04/29/
  '-Wdouble-promotion',
  '-Wconversion',
  #'-fsanitize-undefined-trap-on-error',
  #'-fsanitize=address', # can't have this one because of the assembly :-(
  '-fno-diagnostics-color',
  language: 'c'

Insertion in meson.build at line 30 [8.36]
[9.1411]
[9.1411]
```
  'mbuf.c',
```
Insertion in meson.build at line 33 [8.36]
[10.14]
[8.357]
```
  'change.c'
```
Deletion in meson.build at line 46 [8.36]
B:BD[4.124] → [4.124:137]
```
  'change.c'
```
Replacement in meson.build at line 48 [8.36]
∅:D[4.193] → [11.117:118]
B:BD[11.117] → [11.117:118]
[4.193]
```
subdir('test')
```

File addition: mbuf.h (----------)

[6.1]

#ifndef ANI_CHANGEFILE_H
#define ANI_CHANGEFILE_H
struct mbuf {
	size len;
	u8 *buf;
};
/**
 * Populate a changefile from a file descriptor - returns a negative
 * number to indicate some kind of failure.
 */
int mkmbuf(int fd, struct mbuf *);
/**
 * Free an mbuf
 */
void freembuf(struct mbuf *b);
#endif

File addition: mbuf.c (----------)

[6.1]

#include <stdint.h>
#include <stddef.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include "common.h"
#include "scaffold.h"
#include "types.h"
#include "mbuf.h"
// https://nullprogram.com/blog/2023/09/27/
// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1428r0.pdf
// mmap()
int
mkmbuf(int fd, struct mbuf *ch)
{
	struct stat sb = { 0 };
	u8 *addr;
	if (fstat(fd, &sb) == -1)
		return -1;
	addr = mmap(NULL, (size_t)sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	if (addr == MAP_FAILED)
		return -1;
	ch->buf = addr;
	ch->len = sb.st_size;
	return 0;
}
void
freembuf(struct mbuf *b)
{
	/* FIXME check return code of munmap() */
	munmap(b->buf, (usize)b->len);
}

Deletion in change.h at line 26 [12.80]
B:BD[12.638] → [12.638:692]
```
/* sizeof(struct offsets) */
#define OFFSETS_SIZE 56
```

Replacement in change.h at line 27 [12.80]

B:BD[12.696] → [12.696:766]

 * The possible errors that can arise when working with change files.

[12.696]

[12.766]

 * Errors that can arise when working with change files

Replacement in change.h at line 29 [12.80]

B:BD[12.770] → [12.770:806]

enum change_err {
	VERMISMATCH = -1

[12.770]

[12.806]

enum error {
	/* all good */
	CHANGEFILE_OK,
	/* .change file is too short */
	CHANGEFILE_TOOSHORT,
	/* .change file length mismatch */
	CHANGEFILE_LENGTHMISMATCH,
	/* version specified in file is not supported */
	CHANGEFILE_UNSUPPORTEDVERSION,
	/* hash mismatch */
	CHANGEFILE_HASHMISMATCH,

Insertion in change.h at line 46 [12.80]

[12.810]

[13.1740]

enum error changefileoffsets(struct mbuf *, struct offsets *);
/* sizeof(struct offsets) */
#define OFFSETS_SIZE 56

Insertion in change.h at line 104 [12.80]

[13.2396]

[14.1114]


/**
 * Decompress and decode the hashed parts of a .change file. The
 * struct hashed pointer argument is populated with the result.
 * 
 */
enum error change_decodehashed(u8 *, usize, u8 *, struct hashed *);

Insertion in change.c at line 11 [12.1047]
[15.2445]
[16.574]
```
#include "types.h"
```
Insertion in change.c at line 20 [12.1047]
[17.962]
[12.1192]
```
#include "mbuf.h"
```
Replacement in change.c at line 25 [12.1047]
B:BD[18.1] → [17.963:975]
∅:D[17.975] → [18.6:59]
B:BD[18.6] → [18.6:59]
```
static void
dump_buf(const char *name, uint8_t *buf, size_t len)
```
[18.1]
[18.59]
```
enum error
changefileoffsets(struct mbuf *ch, struct offsets *off)
```
Deletion in change.c at line 28 [12.1047]
B:BD[18.61] → [7.378:389]
∅:D[18.69] → [12.1488:1489]
∅:D[7.389] → [12.1488:1489]
B:BD[12.1488] → [12.1488:1489]
B:BD[12.1489] → [18.70:130]
B:BD[18.130] → [19.712:747]
∅:D[19.747] → [18.167:194]
B:BD[18.167] → [18.167:194]
B:BD[18.194] → [19.748:774]
∅:D[19.774] → [18.222:238]
B:BD[18.222] → [18.222:238]
B:BD[18.238] → [20.0:3]
∅:D[18.241] → [12.1489:1493]
B:BD[12.1489] → [12.1489:1493]
B:BD[12.1493] → [13.2397:2448]
∅:D[21.51] → [12.1537:1539]
∅:D[13.2448] → [12.1537:1539]
∅:D[15.2490] → [12.1537:1539]
B:BD[12.1537] → [12.1537:1539]
B:BD[12.1547] → [12.1547:1587]
```
	size_t i;
	if (len == 0) {
		printf("%s = []\n", name);
		return;
	}
	printf("%s = [%u", name, buf[0]);
	for (i = 1; i < len; i++)
		printf(", %u", buf[i]);
	printf("]\n");
}
int
change_decode_offsets(int fd, struct offsets *off)
{
	ssize_t r;
	uint8_t buf[OFFSETS_SIZE];
```

Replacement in change.c at line 30 [12.1047]

B:BD[12.1604] → [12.1604:1848]

	if ((r = read(fd, buf, OFFSETS_SIZE)) < OFFSETS_SIZE) {
		int err;
		if (r >= 0) {
			printf("error: not enough was read: %ld\n", r);
			err = -2;
		} else {
			printf("error: not enough was read: %ld\n", r);
			err = -1;
		}
		return err;
	}

[12.1604]

[22.32]

	if (ch->len < OFFSETS_SIZE)
		return CHANGEFILE_TOOSHORT;

Replacement in change.c at line 33 [12.1047]
B:BD[22.33] → [23.21:36]
```
	bc.buf = buf;
```
[22.33]
[23.36]
```
	bc.buf = ch->buf;
```

Replacement in change.c at line 44 [12.1047]

B:BD[12.2184] → [12.2184:2195]

	return 0;

[12.2184]

[12.2195]

	if (off->total != (u64)ch->len)
		return CHANGEFILE_LENGTHMISMATCH;
	switch (off->version) {
	case VERSION:
	case VERSION_NOENC:
		return CHANGEFILE_OK;
	default:
		return CHANGEFILE_UNSUPPORTEDVERSION;
	}

Replacement in change.c at line 56 [12.1047]

B:BD[12.2198] → [24.0:4]

B:BD[24.4] → [18.242:417]

∅:D[18.417] → [25.608:612]

B:BD[25.608] → [25.608:612]

B:BD[25.612] → [18.418:435]

B:BD[18.435] → [26.729:802]

/**
 * Read in an expected amount of bytes (or die failing), and decompress with
 * zstd-seekable. Return a malloc()'ed byte buffer that the caller is in charge
 * of free()'ing.
 */
static uint8_t *
decompress_segment(int fd, size_t compressed_len, uint64_t expected_len)

[12.2198]

[25.665]

static char *
change_strerror(enum error err)

Replacement in change.c at line 59 [12.1047]

B:BD[25.813] → [25.813:850]

B:BD[25.878] → [25.878:904]

B:BD[25.924] → [25.924:940]

B:BD[25.940] → [25.940:941]

B:BD[18.585] → [18.585:640]

∅:D[18.640] → [25.1129:1198]

B:BD[25.1129] → [25.1129:1198]

	uint8_t *compressed;
	uint8_t *buf;
	ssize_t compressed_read;
	size_t result;
	compressed = calloc(sizeof(uint8_t), compressed_len);
	if (compressed == NULL) {
		perror("malloc compressed");
		exit(1);

[25.667]

[25.1198]

	switch (err) {
	case CHANGEFILE_OK:
		return "ok";
	case CHANGEFILE_TOOSHORT:
		return ".change file is too short";
	case CHANGEFILE_LENGTHMISMATCH:
		return "length in .change file mismatch with actual length";
	case CHANGEFILE_UNSUPPORTEDVERSION:
		return ".change file version not supported";
	case CHANGEFILE_HASHMISMATCH:
		return "hash mismatch";

Replacement in change.c at line 71 [12.1047]
B:BD[25.1201] → [18.641:687]
∅:D[18.687] → [25.1252:1307]
B:BD[25.1252] → [25.1252:1307]
B:BD[25.1307] → [25.1307:1310]
B:BD[25.1310] → [25.1310:1311]
B:BD[25.1311] → [25.1311:1344]
B:BD[25.1344] → [18.688:745]
B:BD[18.745] → [7.390:441]
∅:D[7.441] → [25.1451:1517]
∅:D[18.787] → [25.1451:1517]
B:BD[25.1451] → [25.1451:1517]
B:BD[25.1517] → [26.803:840]
∅:D[18.826] → [25.1559:1574]
∅:D[26.840] → [25.1559:1574]
B:BD[25.1559] → [25.1559:1574]
B:BD[25.1574] → [25.1574:1577]
∅:D[27.207] → [25.1631:1632]
B:BD[25.1631] → [25.1631:1632]
B:BD[25.1632] → [9.1451:1559]
∅:D[9.1559] → [25.1751:1752]
B:BD[25.1751] → [25.1751:1752]
B:BD[25.2521] → [25.2521:2591]
```
	buf = calloc(sizeof(uint8_t), expected_len);
	if (buf == NULL) {
		perror("malloc buf");
		exit(1);
	}
	/* Read data into compressed */
	compressed_read = read(fd, compressed, compressed_len);
	if (compressed_read != (ssize_t)compressed_len) {
		fprintf(stderr, "error: Expected to read %lu bytes, got %lu\n",
			compressed_len, compressed_read);
		goto errout;
	}
	result = zstdseek_decompress(
		buf, expected_len, compressed, compressed_len
	);
	if (result)
		goto out;
errout:
	free(buf);
	buf = NULL;
out:
	free(compressed);
	return buf;
```
[25.1201]
[28.0]
```
	die("unhandled error variant: %d\n", err);
```

Insertion in change.c at line 222 [12.1047]

[17.4355]

}
static u64
change_readstr(char **dest, struct bincode *bc)
{
	u64 len;
	len = bincode_getu64(bc);
	*dest = xmalloc(len + 1);
	bincode_getstr(bc, *dest, len);
	return len;

Replacement in change.c at line 237 [12.1047]
B:BD[17.4424] → [17.4424:4440]
B:BD[17.4440] → [23.2704:2731]
B:BD[23.2731] → [29.0:72]
```
	uint64_t len;
	len = bincode_getu64(bc);
	local->path = xmalloc(len + 1);
	bincode_getstr(bc, local->path, len);
```
[17.4424]
[23.2771]
```
	change_readstr(&local->path, bc);
```

Replacement in change.c at line 246 [12.1047]

B:BD[23.2894] → [23.2894:2931]

B:BD[23.2931] → [29.73:143]

		uint64_t len = bincode_getu64(bc);
		*encoding = xmalloc(len + 1);
		bincode_getstr(bc, *encoding, len);

[23.2894]

[30.3751]

		change_readstr(encoding, bc);

Replacement in change.c at line 300 [12.1047]

B:BD[23.3653] → [23.3653:3683]

B:BD[23.3683] → [29.144:238]

			slen = bincode_getu64(bc);
			bhunk->fileadd.path = xmalloc(slen + 1);
			bincode_getstr(bc, bhunk->fileadd.path, slen);

[23.3653]

[3.476]

			change_readstr(&bhunk->fileadd.path, bc);

Deletion in change.c at line 394 [12.1047]

B:BD[3.905] → [3.905:1067]


	for (i = 0; i < author->len; i++) {
		len = bincode_getu64(bc);
		author->entries[i].key = xmalloc(len + 1);
		bincode_getstr(bc, author->entries[i].key, len);

Replacement in change.c at line 395 [12.1047]

B:BD[3.1068] → [3.1068:1196]

		len = bincode_getu64(bc);
		author->entries[i].value = xmalloc(len + 1);
		bincode_getstr(bc, author->entries[i].value, len);

[3.1068]

[3.1196]

	for (i = 0; i < len; i++) {
		change_readstr(&author->entries[i].key, bc);
		change_readstr(&author->entries[i].value, bc);

Replacement in change.c at line 404 [12.1047]
B:BD[3.1279] → [3.1279:1295]
```
	size_t len, i;
```
[3.1279]
[3.1295]
```
	usize i;
```

Replacement in change.c at line 410 [12.1047]

B:BD[3.1365] → [3.1365:1450]

	len = bincode_getu64(bc);
	name = xmalloc(len + 1);
	bincode_getstr(bc, name, len);

[3.1365]

[3.1450]

	change_readstr(&name, bc);

Replacement in change.c at line 414 [12.1047]

B:BD[3.1484] → [3.1484:1582]

		len = bincode_getu64(bc);
		full_name = xmalloc(len + 1);
		bincode_getstr(bc, full_name, len);

[3.1484]

[3.1582]

		change_readstr(&full_name, bc);

Replacement in change.c at line 419 [12.1047]

B:BD[3.1619] → [3.1619:1709]

		len = bincode_getu64(bc);
		email = xmalloc(len + 1);
		bincode_getstr(bc, email, len);

[3.1619]

[3.1709]

		change_readstr(&email, bc);

Replacement in change.c at line 441 [12.1047]
∅:D[31.626] → [18.1068:1079]
B:BD[18.1068] → [18.1068:1079]
B:BD[18.1079] → [17.5533:5544]
∅:D[17.5544] → [26.985:1059]
B:BD[18.1083] → [26.985:1059]
B:BD[26.1059] → [13.3754:3801]
```
/**
 *
 */
static int
change_decode_hashed(
	int fd, size_t comp_hashed_len, size_t hashed_len,
	uint8_t *expected_hash, struct hashed *hashed
```
[31.626]
[26.1083]
```
enum error
change_decodehashed(
	u8 *data, usize datalen, u8 *expectedhash, struct hashed *hashed
```
Replacement in change.c at line 446 [12.1047]
B:BD[18.1157] → [18.1157:1172]
B:BD[18.1172] → [10.36:72]
∅:D[10.72] → [19.950:961]
∅:D[27.347] → [19.950:961]
B:BD[19.950] → [19.950:961]
B:BD[19.961] → [27.348:362]
B:BD[27.362] → [16.633:648]
```
	uint8_t *buf;
	uint8_t computed_hash[BLAKE3_LEN];
	size_t i;
	int err = 0;
	uint64_t len;
```
[18.1157]
[23.5284]
```
	u8 computedhash[BLAKE3_LEN];
```
Insertion in change.c at line 448 [12.1047]
[23.5304]
[3.2099]
```
	u64 len;
	usize i;
```

Replacement in change.c at line 452 [12.1047]

B:BD[25.2592] → [18.1173:1332]

	buf = decompress_segment(fd, comp_hashed_len, hashed_len);
	if (buf == NULL) {
		fprintf(stderr, "error: failed to decompress hashed segment\n");
		return 1;

[25.2592]

[18.1332]

	/*Step 1. Compute the hash */
	if (expectedhash != NULL) {
		blake3_hash(computedhash, data, datalen);
		if (blake3_cmp(computedhash, expectedhash))
			return CHANGEFILE_HASHMISMATCH;

Replacement in change.c at line 459 [12.1047]
B:BD[19.1004] → [19.1004:1055]
B:BD[19.1055] → [10.73:119]
∅:D[10.119] → [19.1055:1056]
B:BD[19.1055] → [19.1055:1056]
B:BD[19.1274] → [19.1274:1304]
B:BD[19.1304] → [10.120:170]
∅:D[10.170] → [27.476:489]
B:BD[27.476] → [27.476:489]
B:BD[27.489] → [26.1086:1153]
B:BD[26.1153] → [10.171:207]
∅:D[10.207] → [27.592:674]
B:BD[27.592] → [27.592:674]
B:BD[27.674] → [10.208:244]
∅:D[10.244] → [27.714:791]
B:BD[27.714] → [27.714:791]
∅:D[27.791] → [19.1396:1399]
B:BD[19.1396] → [19.1396:1399]
```
	/* Step 1. Compute the hash of the result buf! */
	blake3_hash(computed_hash, buf, hashed_len);
	if (expected_hash != NULL) {
		err = blake3_cmp(computed_hash, expected_hash);
		if (err) {
			fprintf(stderr,
				"error: change hash mismatch, claimed \n");
			for (i = 0; i < BLAKE3_LEN; i++)
				fprintf(stderr, "%02x", expected_hash[i]);
			fprintf(stderr, ", computed ");
			for (i = 0; i < BLAKE3_LEN; i++)
				fprintf(stderr, "%02x", expected_hash[i]);
			fprintf(stderr, "\n");
		}
	}
```
[19.963]
[16.649]
```
	bc.avail = datalen;
	bc.buf = data;
```
Deletion in change.c at line 462 [12.1047]
B:BD[16.650] → [23.5305:5344]
∅:D[32.92] → [16.696:697]
∅:D[33.119] → [16.696:697]
∅:D[23.5344] → [16.696:697]
B:BD[16.696] → [16.696:697]
```
	bc.avail = hashed_len;
	bc.buf = buf;
```
Replacement in change.c at line 463 [12.1047]
∅:D[32.138] → [16.802:803]
∅:D[23.5385] → [16.802:803]
B:BD[16.802] → [16.802:803]
B:BD[16.803] → [23.5386:5414]
B:BD[23.5414] → [29.773:868]
```
	len = bincode_getu64(&bc);
	hashed->header.message = xmalloc(len + 1);
	bincode_getstr(&bc, hashed->header.message, len);
```
[23.5385]
[16.853]
```
	change_readstr(&hashed->header.message, &bc);
```

Deletion in change.c at line 465 [12.1047]

B:BD[16.967] → [16.967:1130]

	/**
	 * Description! This is like the commit "body", and is optional, so we
	 * have a byte indicating its presence, '0' = None, '1' =
	 * Some(description)
	 */

Replacement in change.c at line 467 [12.1047]

B:BD[23.5494] → [23.5494:5523]

B:BD[23.5523] → [29.869:974]

		len = bincode_getu64(&bc);
		hashed->header.description = xmalloc(len + 1);
		bincode_getstr(&bc, hashed->header.description, len);

[23.5494]

[32.259]

		change_readstr(&hashed->header.description, &bc);

Replacement in change.c at line 470 [12.1047]
B:BD[16.1368] → [23.5581:5609]
∅:D[34.251] → [19.1399:1400]
∅:D[33.417] → [19.1399:1400]
∅:D[27.832] → [19.1399:1400]
∅:D[16.1418] → [19.1399:1400]
∅:D[23.5609] → [19.1399:1400]
B:BD[19.1399] → [19.1399:1400]
```
	len = bincode_getu64(&bc);
```
[16.1368]
[16.1419]
```
	len = change_readstr(&hashed->header.timestamp, &bc);
```

Replacement in change.c at line 472 [12.1047]

B:BD[16.1435] → [26.1154:1248]

B:BD[26.1248] → [29.975:1074]

		printf("warning: timestamp field has unexpected length %lu (expected 30)\n",
		       len);
	hashed->header.timestamp = xmalloc(len + 1);
	bincode_getstr(&bc, hashed->header.timestamp, len);

[16.1435]

[35.354]

		fprintf(stderr,
			"warning: timestamp field has unexpected length %lu\n",
			len);

Replacement in change.c at line 476 [12.1047]
B:BD[35.355] → [23.5665:5717]
```
	len = bincode_getu64(&bc); /* arrays of authors */
```
[35.355]
[32.323]
```
	len = bincode_getu64(&bc);
```
Deletion in change.c at line 504 [12.1047]
∅:D[30.4708] → [36.278:279]
∅:D[17.5674] → [36.278:279]
∅:D[23.6090] → [36.278:279]
B:BD[36.278] → [36.278:279]
B:BD[36.279] → [36.279:303]
∅:D[36.303] → [18.1373:1385]
∅:D[19.1400] → [18.1373:1385]
∅:D[16.1641] → [18.1373:1385]
∅:D[37.2220] → [18.1373:1385]
B:BD[18.1373] → [18.1373:1385]
```
	/* Hash of contents */
	free(buf);
```
Replacement in change.c at line 505 [12.1047]
B:BD[18.1386] → [27.833:846]
```
	return err;
```
[18.1386]
[18.1397]
```
	return CHANGEFILE_OK;
```

Deletion in change.c at line 509 [12.1047]

B:BD[18.1404] → [18.1404:1722]

B:BD[18.1722] → [13.3939:3989]

∅:D[15.3270] → [18.1772:1774]

∅:D[13.3989] → [18.1772:1774]

B:BD[18.1772] → [18.1772:1774]

B:BD[18.1774] → [26.1936:2024]

B:BD[26.2024] → [14.1691:1698]

 * Read the contents section of the open change file, decompress it and return
 * the raw bytes.
 *
 * Returns a malloc()'ed byte buffer that the caller is responsible for
 * deallocating. Returns NULL if the full contents could not be read, or the
 * decompression failed, or some other error occurred.
 */
uint8_t *
change_read_contents(int fd, struct offsets *off)
{
	return decompress_segment(
		fd, off->total - off->contents_off, off->contents_len
	);
}
/**

Replacement in change.c at line 937 [12.1047]
B:BD[14.6729] → [14.6729:6763]
```
	const char *hashstr, int verbose
```
[14.6729]
[14.6763]
```
	const char *hashstr
```
Insertion in change.c at line 941 [12.1047]
[14.6781]
[14.6781]
```
	enum error cherr;
```
Insertion in change.c at line 943 [12.1047]
[14.6813]
[14.6813]
```
	struct mbuf buf = { 0 };
```
Replacement in change.c at line 946 [12.1047]
B:BD[14.6859] → [14.6859:6887]
```
	uint8_t contents_hash[32];
```
[14.6859]
[14.6887]
```
	u8 contents_hash[32];
	u8 *scratch;
	usize r;
```

Insertion in change.c at line 960 [12.1047]

[12.2471]

	}
	err = mkmbuf(fd, &buf);
	if (err) {
		printf("error: %s\n", strerror(errno));
		goto out2;

Replacement in change.c at line 973 [12.1047]

B:BD[12.2475] → [14.7237:7276]

∅:D[21.143] → [12.2508:2572]

∅:D[14.7276] → [12.2508:2572]

B:BD[12.2508] → [12.2508:2572]

	err = change_decode_offsets(fd, off);
	if (err != 0) {
		printf("error: failed to decode offsets\n");

[12.2475]

[18.1858]

	cherr = changefileoffsets(&buf, off);
	if (cherr != CHANGEFILE_OK) {
		printf("error: %s\n", change_strerror(cherr));
		err = (int)cherr;

Replacement in change.c at line 980 [12.1047]

B:BD[18.1874] → [3.3378:3544]

	if (off->version != VERSION && off->version != VERSION_NOENC) {
		printf("Version %lu is not yet supported, sorry.\n",
		       off->version);
		err = off->version;

[18.1874]

[38.540]

	scratch = xmalloc(sizeof(u8) * off->hashed_len);
	r = zstdseek_decompress(
		scratch, off->hashed_len, buf.buf + OFFSETS_SIZE,
		off->unhashed_off - OFFSETS_SIZE
	);
	if (!r) {
		err = 1;
		free(scratch);

Replacement in change.c at line 990 [12.1047]

B:BD[38.555] → [38.555:556]

∅:D[38.556] → [26.2127:2156]

B:BD[18.1874] → [26.2127:2156]

B:BD[26.2156] → [14.7401:7482]


	err = change_decode_hashed(
		fd, off->unhashed_off - OFFSETS_SIZE, off->hashed_len,
		contents_hash, hashed

[38.555]

[26.2227]

	err = change_decodehashed(
		scratch, off->hashed_len, contents_hash, hashed

Insertion in change.c at line 993 [12.1047]
[26.2231]
[18.1956]
```
	free(scratch);
```

Replacement in change.c at line 1000 [12.1047]

B:BD[32.949] → [39.1003:1116]

B:BD[39.1116] → [14.7483:7543]

∅:D[40.322] → [39.1168:1199]

∅:D[14.7543] → [39.1168:1199]

B:BD[39.1168] → [39.1168:1199]

	/**
	 * Seek to the point in the file where contents begin. Keep in mind,
	 * we've already read 56 bytes.
	 */
	if (lseek(fd, (off_t)off->contents_off, SEEK_SET) == -1) {
		perror("lseek");
		goto out;

[32.949]

[39.1199]

	c->contents = xmalloc(sizeof(u8) * off->contents_len);
	r = zstdseek_decompress(
		c->contents, off->contents_len, buf.buf + off->contents_off,
		off->total - off->contents_off
	);
	if (!r) {
		err = 1;
		free(c->contents);

Replacement in change.c at line 1009 [12.1047]
B:BD[39.1202] → [14.7544:7590]
```
	c->contents = change_read_contents(fd, off);
```
[39.1202]
[14.7647]
```
	err = 0;
```
Insertion in change.c at line 1011 [12.1047]
[14.7652]
[2.0]
```
	freembuf(&buf);
out2:
```

Replacement in change.c at line 1022 [12.1047]

B:BD[14.7779] → [14.7779:7867]

	struct change *c, struct hash *h, const char *repodir,
	struct hash *hash, int verbose

[14.7779]

[14.7867]

	struct change *c, struct hash *h, const char *repodir, struct hash *hash

Replacement in change.c at line 1030 [12.1047]

B:BD[14.7995] → [14.7995:8048]

	return loadchange(c, h, repodir, hashstr, verbose);

[14.7995]

[41.430]

	return loadchange(c, h, repodir, hashstr);

Replacement in change.c at line 1068 [12.1047]

B:BD[41.1194] → [41.1194:1263]

	err = loadchangeh(&ch->change, &ch->hash, store->repodir, hash, 0);

[41.1194]

[41.1263]

	err = loadchangeh(&ch->change, &ch->hash, store->repodir, hash);

Replacement in change.c at line 1149 [12.1047]

B:BD[14.8361] → [5.561:631]

	err = loadchange(&ch->change, &ch->hash, repo->path, hash, verbose);

[14.8361]

[14.8428]

	err = loadchange(&ch->change, &ch->hash, repo->path, hash);

Replacement in change.c at line 1151 [12.1047]
B:BD[14.8438] → [14.8438:8452]
```
		return err;
```
[14.8438]
[42.0]
```
		goto changeout;
```

Replacement in Makefile at line 25 [43.458]

B:BD[43.677] → [44.0:13]

B:BD[44.13] → [45.139:211]

check: build
	build/ani change NETL2N53SORFVLRHT2GK6EYIGK64U6E4QTCES6NGQPBYUPIOVEIAC

[43.677]

[44.81]

check:
	@$(MESON) test -C build

change: rework to make more testable

Dependencies

In channels

In discussions

Change contents

File addition: test (d--x------)

File addition: test_change.c (----------)

File addition: meson.build (----------)

File addition: NETL2.h (----------)

Replacement in meson.build at line 6 [8.36]

Insertion in meson.build at line 30 [8.36]

Insertion in meson.build at line 33 [8.36]

Deletion in meson.build at line 46 [8.36]

Replacement in meson.build at line 48 [8.36]

File addition: mbuf.h (----------)

File addition: mbuf.c (----------)

Deletion in change.h at line 26 [12.80]

Replacement in change.h at line 27 [12.80]

Replacement in change.h at line 29 [12.80]

Insertion in change.h at line 46 [12.80]

Insertion in change.h at line 104 [12.80]

Insertion in change.c at line 11 [12.1047]

Insertion in change.c at line 20 [12.1047]

Replacement in change.c at line 25 [12.1047]

Deletion in change.c at line 28 [12.1047]

Replacement in change.c at line 30 [12.1047]

Replacement in change.c at line 33 [12.1047]

Replacement in change.c at line 44 [12.1047]

Replacement in change.c at line 56 [12.1047]

Replacement in change.c at line 59 [12.1047]

Replacement in change.c at line 71 [12.1047]

Insertion in change.c at line 222 [12.1047]

Replacement in change.c at line 237 [12.1047]

Replacement in change.c at line 246 [12.1047]

Replacement in change.c at line 300 [12.1047]

Deletion in change.c at line 394 [12.1047]

Replacement in change.c at line 395 [12.1047]

Replacement in change.c at line 404 [12.1047]

Replacement in change.c at line 410 [12.1047]

Replacement in change.c at line 414 [12.1047]

Replacement in change.c at line 419 [12.1047]

Replacement in change.c at line 441 [12.1047]

Replacement in change.c at line 446 [12.1047]

Insertion in change.c at line 448 [12.1047]

Replacement in change.c at line 452 [12.1047]

Replacement in change.c at line 459 [12.1047]

Deletion in change.c at line 462 [12.1047]

Replacement in change.c at line 463 [12.1047]

Deletion in change.c at line 465 [12.1047]

Replacement in change.c at line 467 [12.1047]

Replacement in change.c at line 470 [12.1047]

Replacement in change.c at line 472 [12.1047]

Replacement in change.c at line 476 [12.1047]

Deletion in change.c at line 504 [12.1047]

Replacement in change.c at line 505 [12.1047]

Deletion in change.c at line 509 [12.1047]

Replacement in change.c at line 937 [12.1047]

Insertion in change.c at line 941 [12.1047]

Insertion in change.c at line 943 [12.1047]

Replacement in change.c at line 946 [12.1047]

Insertion in change.c at line 960 [12.1047]

Replacement in change.c at line 973 [12.1047]

Replacement in change.c at line 980 [12.1047]

Replacement in change.c at line 990 [12.1047]

Insertion in change.c at line 993 [12.1047]

Replacement in change.c at line 1000 [12.1047]

Replacement in change.c at line 1009 [12.1047]

Insertion in change.c at line 1011 [12.1047]

Replacement in change.c at line 1022 [12.1047]

Replacement in change.c at line 1030 [12.1047]

Replacement in change.c at line 1068 [12.1047]

Replacement in change.c at line 1149 [12.1047]

Replacement in change.c at line 1151 [12.1047]

Replacement in Makefile at line 25 [43.458]