c0data 0.3.1 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/c0-c/c0_diff.c ADDED
@@ -0,0 +1,551 @@
1
+ #include "c0_diff.h"
2
+
3
+ /* ===== Parse ===== */
4
+
5
+ static void *xdup(const uint8_t *p, size_t n) {
6
+ void *out = malloc(n ? n : 1);
7
+ if (out && n) memcpy(out, p, n);
8
+ return out;
9
+ }
10
+
11
+ static int push(void **arr, size_t *n, size_t elem, const void *item) {
12
+ void *nv = realloc(*arr, (*n + 1) * elem);
13
+ if (!nv) return 0;
14
+ *arr = nv;
15
+ memcpy((char *)nv + *n * elem, item, elem);
16
+ (*n)++;
17
+ return 1;
18
+ }
19
+
20
+ static void free_record(c0_diff_record *r) {
21
+ size_t i;
22
+ for (i = 0; i < r->nunits; i++) {
23
+ free(r->units[i].old);
24
+ free(r->units[i].new_);
25
+ }
26
+ free(r->units);
27
+ memset(r, 0, sizeof(*r));
28
+ }
29
+
30
+ static void free_file(c0_diff_file *f) {
31
+ size_t i;
32
+ free(f->path);
33
+ for (i = 0; i < f->nrecords; i++) free_record(&f->records[i]);
34
+ free(f->records);
35
+ memset(f, 0, sizeof(*f));
36
+ }
37
+
38
+ void c0_diff_free(c0_diff *d) {
39
+ size_t i;
40
+ if (!d) return;
41
+ for (i = 0; i < d->nfiles; i++) free_file(&d->files[i]);
42
+ free(d->files);
43
+ d->files = NULL;
44
+ d->nfiles = 0;
45
+ }
46
+
47
+ /* Refuse: record the first reason. */
48
+ static void refuse(c0_diff *d, c0_diff_status st, size_t pos, const char *msg) {
49
+ if (d->status == C0_DIFF_OK) {
50
+ d->status = st;
51
+ d->err.code = st == C0_DIFF_OOM ? C0_ERR_OOM : C0_ERR_SYNTAX;
52
+ d->err.pos = pos;
53
+ d->err.msg = msg;
54
+ }
55
+ }
56
+
57
+ /* The decoded value of a raw unit into a fresh buffer. */
58
+ static int dvalue(c0_diff *d, c0_bytes raw, uint8_t **out, size_t *out_len) {
59
+ uint8_t *scratch = (uint8_t *)malloc(raw.len ? raw.len : 1);
60
+ c0_bytes v;
61
+ c0_status st;
62
+ *out = NULL;
63
+ *out_len = 0;
64
+ if (!scratch) {
65
+ refuse(d, C0_DIFF_OOM, 0, "out of memory");
66
+ return 0;
67
+ }
68
+ st = c0_value(raw, scratch, &v);
69
+ if (st != C0_OK) {
70
+ free(scratch);
71
+ refuse(d, C0_DIFF_SYNTAX, 0, "a diff unit is a value");
72
+ return 0;
73
+ }
74
+ *out = (uint8_t *)xdup(v.ptr, v.len);
75
+ *out_len = v.len;
76
+ free(scratch);
77
+ if (!*out) {
78
+ refuse(d, C0_DIFF_OOM, 0, "out of memory");
79
+ return 0;
80
+ }
81
+ return 1;
82
+ }
83
+
84
+ /* A unit of a diff record (an anchor, an old or a new) as a decoded value:
85
+ * plain or text, never a level or a reference. */
86
+ static int diff_value(c0_diff *d, c0_bytes raw, size_t at, uint8_t **out, size_t *out_len) {
87
+ c0_unit_kind k = c0_unit_type(raw);
88
+ if (k == C0_UNIT_LEVEL) {
89
+ refuse(d, C0_DIFF_CONSTRAINT, at, "a nested level in a diff record");
90
+ return 0;
91
+ }
92
+ if (k == C0_UNIT_REF) {
93
+ refuse(d, C0_DIFF_CONSTRAINT, at, "a reference in a diff record");
94
+ return 0;
95
+ }
96
+ return dvalue(d, raw, out, out_len);
97
+ }
98
+
99
+ /* One record as an anchored pattern (DIFF.md "Records"): a unit with no
100
+ * sub-unit is an anchor; with one sub-unit (`old␚␟new`) a substitution. */
101
+ static int pattern_of(c0_diff *d, c0_record rec, size_t at, c0_diff_record *out) {
102
+ c0_unit_iter ui;
103
+ c0_unit u;
104
+ memset(out, 0, sizeof(*out));
105
+ if (c0_record_keyed(rec)) {
106
+ refuse(d, C0_DIFF_CONSTRAINT, at, "a keyed unit in a diff record");
107
+ return 0;
108
+ }
109
+ ui = c0_record_units(rec);
110
+ while (c0_next_unit_with_subs(&ui, &u)) {
111
+ c0_diff_unit du;
112
+ size_t nsubs = c0_unit_sub_count(u);
113
+ memset(&du, 0, sizeof(du));
114
+ if (nsubs > 1) {
115
+ refuse(d, C0_DIFF_CONSTRAINT, at, "two sub-units on one unit: one old has one new");
116
+ goto fail;
117
+ }
118
+ if (!diff_value(d, u.raw, at, &du.old, &du.old_len)) goto fail;
119
+ if (nsubs == 1) {
120
+ c0_sub_iter si = c0_unit_subs(u);
121
+ c0_unit s;
122
+ c0_next_sub(&si, &s);
123
+ if (c0_unit_sub_count(s) > 0) {
124
+ free(du.old);
125
+ refuse(d, C0_DIFF_CONSTRAINT, at, "a sub-unit of a sub-unit in a diff record");
126
+ goto fail;
127
+ }
128
+ if (!diff_value(d, s.raw, at, &du.new_, &du.new_len)) {
129
+ free(du.old);
130
+ goto fail;
131
+ }
132
+ if (du.old_len == 0 && du.new_len == 0) {
133
+ free(du.old);
134
+ free(du.new_);
135
+ refuse(d, C0_DIFF_CONSTRAINT, at, "a substitution of nothing by nothing");
136
+ goto fail;
137
+ }
138
+ du.is_sub = 1;
139
+ }
140
+ if (!push((void **)&out->units, &out->nunits, sizeof(du), &du)) {
141
+ free(du.old);
142
+ free(du.new_);
143
+ refuse(d, C0_DIFF_OOM, 0, "out of memory");
144
+ goto fail;
145
+ }
146
+ }
147
+ if (ui.err.code) {
148
+ refuse(d, C0_DIFF_SYNTAX, ui.err.pos, ui.err.msg);
149
+ goto fail;
150
+ }
151
+ return 1;
152
+ fail:
153
+ free_record(out);
154
+ return 0;
155
+ }
156
+
157
+ c0_diff c0_diff_parse(const uint8_t *buf, size_t len) {
158
+ c0_diff d;
159
+ c0_doc_iter di = c0_documents(buf, len);
160
+ c0_document doc, more;
161
+ c0_bytes shape;
162
+ c0_file_iter fi;
163
+ c0_file f;
164
+ memset(&d, 0, sizeof(d));
165
+ d.err.msg = "";
166
+ if (!c0_next_document(&di, &doc)) {
167
+ if (di.err.code) refuse(&d, C0_DIFF_SYNTAX, di.err.pos, di.err.msg);
168
+ else refuse(&d, C0_DIFF_CONSTRAINT, 0, "a diff is one document");
169
+ return d;
170
+ }
171
+ if (c0_next_document(&di, &more)) {
172
+ refuse(&d, C0_DIFF_CONSTRAINT, more.start, "a diff is one document");
173
+ return d;
174
+ }
175
+ if (di.err.code) {
176
+ refuse(&d, C0_DIFF_SYNTAX, di.err.pos, di.err.msg);
177
+ return d;
178
+ }
179
+ shape = c0_heading_shape(&doc);
180
+ if (shape.len && !(shape.len == 4 && memcmp(shape.ptr, "diff", 4) == 0)) {
181
+ refuse(&d, C0_DIFF_WRONG_SHAPE, doc.heading_start, "heading declares a shape that is not diff");
182
+ return d;
183
+ }
184
+ if (doc.dead_elements > 0) {
185
+ refuse(&d, C0_DIFF_CONSTRAINT, doc.body.start, "a dead element in a diff: a hunk is kept without applying by writing it in a note");
186
+ return d;
187
+ }
188
+ fi = c0_body_files(doc.body);
189
+ while (c0_next_file(&fi, &f)) {
190
+ c0_diff_file cur;
191
+ c0_group_iter gi = c0_file_groups(f);
192
+ c0_group g;
193
+ c0_bytes name = c0_file_name(f);
194
+ size_t i;
195
+ memset(&cur, 0, sizeof(cur));
196
+ if (f.leading) {
197
+ if (c0_next_group(&gi, &g)) {
198
+ refuse(&d, C0_DIFF_CONSTRAINT, g.start, "a record before the first FS");
199
+ goto fail;
200
+ }
201
+ continue;
202
+ }
203
+ if (name.len == 0) {
204
+ refuse(&d, C0_DIFF_CONSTRAINT, f.name_start, "empty path");
205
+ goto fail;
206
+ }
207
+ for (i = 0; i < d.nfiles; i++) {
208
+ if (d.files[i].path_len == name.len && memcmp(d.files[i].path, name.ptr, name.len) == 0) {
209
+ refuse(&d, C0_DIFF_DUPLICATE_PATH, f.name_start, "the same path twice");
210
+ goto fail;
211
+ }
212
+ }
213
+ cur.path = (uint8_t *)xdup(name.ptr, name.len);
214
+ cur.path_len = name.len;
215
+ if (!cur.path) {
216
+ refuse(&d, C0_DIFF_OOM, 0, "out of memory");
217
+ goto fail;
218
+ }
219
+ while (c0_next_group(&gi, &g)) {
220
+ c0_record_iter ri;
221
+ c0_record rec, h;
222
+ if (g.depth > 0) {
223
+ refuse(&d, C0_DIFF_CONSTRAINT, g.name_start, "GS in a diff");
224
+ free_file(&cur);
225
+ goto fail;
226
+ }
227
+ if (c0_group_header(g, &h)) {
228
+ refuse(&d, C0_DIFF_CONSTRAINT, h.start, "a header row in a diff");
229
+ free_file(&cur);
230
+ goto fail;
231
+ }
232
+ ri = c0_group_records(g);
233
+ while (c0_next_record(&ri, &rec)) {
234
+ c0_diff_record r;
235
+ if (!pattern_of(&d, rec, rec.start, &r)) {
236
+ free_file(&cur);
237
+ goto fail;
238
+ }
239
+ if (!push((void **)&cur.records, &cur.nrecords, sizeof(r), &r)) {
240
+ free_record(&r);
241
+ free_file(&cur);
242
+ refuse(&d, C0_DIFF_OOM, 0, "out of memory");
243
+ goto fail;
244
+ }
245
+ }
246
+ if (ri.err.code) {
247
+ refuse(&d, C0_DIFF_SYNTAX, ri.err.pos, ri.err.msg);
248
+ free_file(&cur);
249
+ goto fail;
250
+ }
251
+ }
252
+ if (gi.err.code) {
253
+ refuse(&d, C0_DIFF_SYNTAX, gi.err.pos, gi.err.msg);
254
+ free_file(&cur);
255
+ goto fail;
256
+ }
257
+ if (!push((void **)&d.files, &d.nfiles, sizeof(cur), &cur)) {
258
+ free_file(&cur);
259
+ refuse(&d, C0_DIFF_OOM, 0, "out of memory");
260
+ goto fail;
261
+ }
262
+ }
263
+ if (fi.err.code) {
264
+ refuse(&d, C0_DIFF_SYNTAX, fi.err.pos, fi.err.msg);
265
+ goto fail;
266
+ }
267
+ return d;
268
+ fail:
269
+ c0_diff_free(&d);
270
+ return d;
271
+ }
272
+
273
+ static uint8_t *record_concat(const c0_diff_record *r, int replacement, size_t *out_len) {
274
+ c0_strbuf sb = {0, 0, 0, 0};
275
+ size_t i;
276
+ for (i = 0; i < r->nunits; i++) {
277
+ const c0_diff_unit *u = &r->units[i];
278
+ if (replacement && u->is_sub) c0_sb_raw(&sb, u->new_, u->new_len);
279
+ else c0_sb_raw(&sb, u->old, u->old_len);
280
+ }
281
+ if (sb.oom) { free(sb.d); return NULL; }
282
+ if (!sb.d) sb.d = (uint8_t *)malloc(1);
283
+ if (!sb.d) return NULL;
284
+ if (out_len) *out_len = sb.n;
285
+ return sb.d;
286
+ }
287
+
288
+ uint8_t *c0_diff_record_search(const c0_diff_record *r, size_t *out_len) { return record_concat(r, 0, out_len); }
289
+ uint8_t *c0_diff_record_replacement(const c0_diff_record *r, size_t *out_len) { return record_concat(r, 1, out_len); }
290
+
291
+ /* ===== Apply ===== */
292
+
293
+ static long find(const uint8_t *hay, size_t hlen, const uint8_t *needle, size_t nlen, size_t from) {
294
+ size_t i;
295
+ if (nlen == 0 || nlen > hlen) return -1;
296
+ for (i = from; i + nlen <= hlen; i++) {
297
+ if (hay[i] == needle[0] && memcmp(hay + i, needle, nlen) == 0) return (long)i;
298
+ }
299
+ return -1;
300
+ }
301
+
302
+ static void set_err(c0_diff_error *err, c0_diff_status st, const uint8_t *path, size_t plen, size_t record) {
303
+ if (!err) return;
304
+ err->status = st;
305
+ if (path) {
306
+ size_t n = plen < sizeof(err->path) - 1 ? plen : sizeof(err->path) - 1;
307
+ memcpy(err->path, path, n);
308
+ err->path[n] = 0;
309
+ }
310
+ err->record = record;
311
+ }
312
+
313
+ typedef struct { size_t s, e; uint8_t *repl; size_t rlen; } match;
314
+
315
+ /* Apply one file's records (DIFF.md "Records"): each search text matches
316
+ * once from the cursor to the end of the file. */
317
+ static c0_diff_status apply_file(const uint8_t *data, size_t dlen, const c0_diff_file *f,
318
+ uint8_t **out, size_t *out_len, size_t *bad_record) {
319
+ match *m;
320
+ size_t cursor = 0, i, pos = 0;
321
+ c0_strbuf o = {0, 0, 0, 0};
322
+ c0_diff_status st = C0_DIFF_OK;
323
+ m = (match *)calloc(f->nrecords ? f->nrecords : 1, sizeof(match));
324
+ if (!m) return C0_DIFF_OOM;
325
+ for (i = 0; i < f->nrecords; i++) {
326
+ size_t slen;
327
+ uint8_t *search = c0_diff_record_search(&f->records[i], &slen);
328
+ long first;
329
+ *bad_record = i;
330
+ if (!search) { st = C0_DIFF_OOM; goto done; }
331
+ if (slen == 0) { free(search); st = C0_DIFF_EMPTY_SEARCH; goto done; }
332
+ first = find(data, dlen, search, slen, cursor);
333
+ if (first < 0) { free(search); st = C0_DIFF_PATTERN_NOT_FOUND; goto done; }
334
+ if (find(data, dlen, search, slen, (size_t)first + 1) >= 0) { free(search); st = C0_DIFF_PATTERN_AMBIGUOUS; goto done; }
335
+ free(search);
336
+ m[i].s = (size_t)first;
337
+ m[i].e = (size_t)first + slen;
338
+ m[i].repl = c0_diff_record_replacement(&f->records[i], &m[i].rlen);
339
+ if (!m[i].repl) { st = C0_DIFF_OOM; goto done; }
340
+ cursor = m[i].e;
341
+ }
342
+ for (i = 0; i < f->nrecords; i++) {
343
+ c0_sb_raw(&o, data + pos, m[i].s - pos);
344
+ c0_sb_raw(&o, m[i].repl, m[i].rlen);
345
+ pos = m[i].e;
346
+ }
347
+ c0_sb_raw(&o, data + pos, dlen - pos);
348
+ if (o.oom) st = C0_DIFF_OOM;
349
+ done:
350
+ for (i = 0; i < f->nrecords; i++) free(m[i].repl);
351
+ free(m);
352
+ if (st) {
353
+ free(o.d);
354
+ return st;
355
+ }
356
+ if (!o.d) o.d = (uint8_t *)malloc(1);
357
+ if (!o.d) return C0_DIFF_OOM;
358
+ *out = o.d;
359
+ *out_len = o.n;
360
+ return C0_DIFF_OK;
361
+ }
362
+
363
+ static long find_input(const c0_diff_file_input *files, size_t nfiles, const uint8_t *path, size_t plen) {
364
+ size_t i;
365
+ for (i = 0; i < nfiles; i++) {
366
+ if (files[i].path.len == plen && (plen == 0 || memcmp(files[i].path.ptr, path, plen) == 0)) return (long)i;
367
+ }
368
+ return -1;
369
+ }
370
+
371
+ void c0_diff_free_outputs(c0_diff_file_output *out, size_t count) {
372
+ size_t i;
373
+ if (!out) return;
374
+ for (i = 0; i < count; i++) {
375
+ free(out[i].path);
376
+ free(out[i].content);
377
+ }
378
+ free(out);
379
+ }
380
+
381
+ int c0_diff_apply(const uint8_t *diff_buf, size_t diff_len,
382
+ const c0_diff_file_input *files, size_t nfiles,
383
+ c0_diff_file_output **out, size_t *out_count,
384
+ c0_diff_error *err) {
385
+ c0_diff d = c0_diff_parse(diff_buf, diff_len);
386
+ c0_diff_file_output *res = NULL;
387
+ size_t i;
388
+ int ok = 0;
389
+
390
+ if (err) {
391
+ memset(err, 0, sizeof(*err));
392
+ err->msg = "";
393
+ }
394
+ if (d.status != C0_DIFF_OK) {
395
+ if (err) {
396
+ err->status = d.status;
397
+ err->pos = d.err.pos;
398
+ err->msg = d.err.msg ? d.err.msg : "";
399
+ }
400
+ return 0;
401
+ }
402
+
403
+ res = (c0_diff_file_output *)calloc(nfiles ? nfiles : 1, sizeof(c0_diff_file_output));
404
+ if (!res) { set_err(err, C0_DIFF_OOM, NULL, 0, 0); goto done; }
405
+
406
+ /* Validate and compute every edit first; nothing is handed out on error. */
407
+ for (i = 0; i < d.nfiles; i++) {
408
+ const c0_diff_file *f = &d.files[i];
409
+ long idx = find_input(files, nfiles, f->path, f->path_len);
410
+ size_t record = 0;
411
+ c0_diff_status st;
412
+ if (idx < 0) { set_err(err, C0_DIFF_FILE_NOT_FOUND, f->path, f->path_len, 0); goto done; }
413
+ st = apply_file(files[idx].content.ptr, files[idx].content.len, f, &res[idx].content, &res[idx].content_len, &record);
414
+ if (st) { set_err(err, st, f->path, f->path_len, record); goto done; }
415
+ }
416
+ for (i = 0; i < nfiles; i++) {
417
+ res[i].path = (uint8_t *)xdup(files[i].path.ptr, files[i].path.len);
418
+ res[i].path_len = files[i].path.len;
419
+ if (!res[i].path) { set_err(err, C0_DIFF_OOM, NULL, 0, 0); goto done; }
420
+ if (!res[i].content) {
421
+ res[i].content = (uint8_t *)xdup(files[i].content.ptr, files[i].content.len);
422
+ res[i].content_len = files[i].content.len;
423
+ if (!res[i].content) { set_err(err, C0_DIFF_OOM, NULL, 0, 0); goto done; }
424
+ }
425
+ }
426
+ *out = res;
427
+ *out_count = nfiles;
428
+ res = NULL;
429
+ ok = 1;
430
+ done:
431
+ if (res) c0_diff_free_outputs(res, nfiles);
432
+ c0_diff_free(&d);
433
+ return ok;
434
+ }
435
+
436
+ /* ===== Builder ===== */
437
+
438
+ static void dvalue_out(c0_strbuf *sb, const uint8_t *p, size_t n) {
439
+ size_t i;
440
+ if (c0_is_plain(p, n)) {
441
+ c0_sb_raw(sb, p, n);
442
+ return;
443
+ }
444
+ c0_sb_byte(sb, C0_STX);
445
+ for (i = 0; i < n; i++) {
446
+ if (c0_is_text_escaped(p[i])) c0_sb_byte(sb, C0_DLE);
447
+ c0_sb_byte(sb, p[i]);
448
+ }
449
+ c0_sb_byte(sb, C0_ETX);
450
+ }
451
+
452
+ void c0_diff_builder_init(c0_diff_builder *b, int heading) {
453
+ memset(b, 0, sizeof(*b));
454
+ b->unit_first = 1;
455
+ if (heading) {
456
+ c0_sb_byte(&b->buf, C0_SYN);
457
+ c0_sb_byte(&b->buf, C0_SOH);
458
+ c0_sb_cstr(&b->buf, "shape");
459
+ c0_sb_byte(&b->buf, C0_US);
460
+ c0_sb_cstr(&b->buf, "diff");
461
+ }
462
+ }
463
+
464
+ void c0_diff_builder_free(c0_diff_builder *b) {
465
+ free(b->buf.d);
466
+ memset(b, 0, sizeof(*b));
467
+ }
468
+
469
+ void c0_diff_file_begin(c0_diff_builder *b, const uint8_t *path, size_t path_len) {
470
+ c0_sb_byte(&b->buf, C0_FS);
471
+ c0_sb_raw(&b->buf, path, path_len);
472
+ b->unit_first = 1;
473
+ }
474
+
475
+ void c0_diff_record_begin(c0_diff_builder *b) {
476
+ c0_sb_byte(&b->buf, C0_RS);
477
+ b->unit_first = 1;
478
+ }
479
+
480
+ static void sep(c0_diff_builder *b) {
481
+ if (!b->unit_first) c0_sb_byte(&b->buf, C0_US);
482
+ b->unit_first = 0;
483
+ }
484
+
485
+ void c0_diff_anchor(c0_diff_builder *b, const uint8_t *text, size_t len) {
486
+ sep(b);
487
+ dvalue_out(&b->buf, text, len);
488
+ }
489
+
490
+ void c0_diff_sub(c0_diff_builder *b, const uint8_t *old, size_t old_len, const uint8_t *new_, size_t new_len) {
491
+ sep(b);
492
+ dvalue_out(&b->buf, old, old_len);
493
+ c0_sb_byte(&b->buf, C0_SUB);
494
+ c0_sb_byte(&b->buf, C0_US);
495
+ dvalue_out(&b->buf, new_, new_len);
496
+ }
497
+
498
+ void c0_diff_replace(c0_diff_builder *b,
499
+ const uint8_t *before, size_t before_len,
500
+ const uint8_t *old, size_t old_len,
501
+ const uint8_t *new_, size_t new_len,
502
+ const uint8_t *after, size_t after_len) {
503
+ c0_diff_record_begin(b);
504
+ if (before_len) c0_diff_anchor(b, before, before_len);
505
+ c0_diff_sub(b, old, old_len, new_, new_len);
506
+ if (after_len) c0_diff_anchor(b, after, after_len);
507
+ }
508
+
509
+ void c0_diff_insert_after(c0_diff_builder *b, const uint8_t *anchor, size_t anchor_len, const uint8_t *text, size_t len) {
510
+ c0_diff_record_begin(b);
511
+ c0_diff_anchor(b, anchor, anchor_len);
512
+ c0_diff_sub(b, (const uint8_t *)"", 0, text, len);
513
+ }
514
+
515
+ void c0_diff_delete(c0_diff_builder *b, const uint8_t *old, size_t old_len,
516
+ const uint8_t *before, size_t before_len, const uint8_t *after, size_t after_len) {
517
+ c0_diff_replace(b, before, before_len, old, old_len, (const uint8_t *)"", 0, after, after_len);
518
+ }
519
+
520
+ void c0_diff_assert(c0_diff_builder *b, const uint8_t *text, size_t len) {
521
+ c0_diff_record_begin(b);
522
+ c0_diff_anchor(b, text, len);
523
+ }
524
+
525
+ void c0_diff_note(c0_diff_builder *b, const uint8_t *text, size_t len) {
526
+ c0_sb_byte(&b->buf, C0_BEL);
527
+ dvalue_out(&b->buf, text, len);
528
+ }
529
+
530
+ void c0_diff_eot(c0_diff_builder *b) { c0_sb_byte(&b->buf, C0_EOT); }
531
+
532
+ c0_bytes c0_diff_builder_bytes(const c0_diff_builder *b) {
533
+ c0_bytes r;
534
+ r.ptr = b->buf.d;
535
+ r.len = b->buf.n;
536
+ return r;
537
+ }
538
+
539
+ #define U(s) ((const uint8_t *)(s)), strlen(s)
540
+ void c0_diff_file_begin_str(c0_diff_builder *b, const char *path) { c0_diff_file_begin(b, U(path)); }
541
+ void c0_diff_anchor_str(c0_diff_builder *b, const char *text) { c0_diff_anchor(b, U(text)); }
542
+ void c0_diff_sub_str(c0_diff_builder *b, const char *old, const char *new_) { c0_diff_sub(b, U(old), U(new_)); }
543
+ void c0_diff_replace_str(c0_diff_builder *b, const char *before, const char *old, const char *new_, const char *after) {
544
+ c0_diff_replace(b, U(before), U(old), U(new_), U(after));
545
+ }
546
+ void c0_diff_insert_after_str(c0_diff_builder *b, const char *anchor, const char *text) { c0_diff_insert_after(b, U(anchor), U(text)); }
547
+ void c0_diff_delete_str(c0_diff_builder *b, const char *old, const char *before, const char *after) {
548
+ c0_diff_delete(b, U(old), U(before), U(after));
549
+ }
550
+ void c0_diff_assert_str(c0_diff_builder *b, const char *text) { c0_diff_assert(b, U(text)); }
551
+ void c0_diff_note_str(c0_diff_builder *b, const char *text) { c0_diff_note(b, U(text)); }