int xdlt_load_mmfile(char const *fname, mmfile_t *mf, int binmode) {
char cc;
int fd;
long size;
char *blk;
if (xdl_init_mmfile(mf, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
return -1;
}
if ((fd = open(fname, O_RDONLY)) == -1) {
perror(fname);
xdl_free_mmfile(mf);
return -1;
}
size = lseek(fd, 0, SEEK_END);
lseek(fd, 0, SEEK_SET);
if (!(blk = (char *) xdl_mmfile_writeallocate(mf, size))) {
xdl_free_mmfile(mf);
close(fd);
return -1;
}
if (read(fd, blk, (size_t) size) != (size_t) size) {
perror(fname);
xdl_free_mmfile(mf);
close(fd);
return -1;
}
close(fd);
return 0;
}
int xdlt_change_file(mmfile_t *mfo, mmfile_t *mfr, double rmod,
int chmax) {
long skipln, lnsize, bsize;
char const *blk, *cur, *top, *eol;
char lnbuf[XDLT_MAX_LINE_SIZE + 1];
if (xdl_init_mmfile(mfr, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
return -1;
}
if ((blk = xdl_mmfile_first(mfo, &bsize)) != NULL) {
for (cur = blk, top = blk + bsize, skipln = 0;;) {
if (cur >= top) {
if ((blk = xdl_mmfile_next(mfo, &bsize)) == NULL)
break;
cur = blk;
top = blk + bsize;
}
if (!(eol = memchr(cur, '\n', top - cur)))
eol = top;
if (!skipln) {
if (DBL_RAND() < rmod) {
skipln = rand() % chmax;
if (rand() & 1) {
for (; skipln > 0; skipln--) {
lnsize = xdlt_gen_line(lnbuf, XDLT_MAX_LINE_SIZE);
if (xdl_write_mmfile(mfr, lnbuf, lnsize) != lnsize) {
xdl_free_mmfile(mfr);
return -1;
}
}
}
} else {
lnsize = (eol - cur) + 1;
if (xdl_write_mmfile(mfr, cur, lnsize) != lnsize) {
xdl_free_mmfile(mfr);
return -1;
}
}
} else
skipln--;
cur = eol + 1;
}
}
return 0;
}
int xdlt_auto_rabinregress(long size, double rmod, int chmax) {
mmfile_t mf1, mf2, mf2c;
if (xdlt_create_file(&mf1, size) < 0) {
return -1;
}
if (xdlt_change_file(&mf1, &mf2, rmod, chmax) < 0) {
xdl_free_mmfile(&mf1);
return -1;
}
if (xdl_mmfile_compact(&mf2, &mf2c, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
xdl_free_mmfile(&mf2);
xdl_free_mmfile(&mf1);
return -1;
}
xdl_free_mmfile(&mf2);
if (xdlt_do_rabinregress(&mf1, &mf2c) < 0) {
xdl_free_mmfile(&mf2c);
xdl_free_mmfile(&mf1);
return -1;
}
xdl_free_mmfile(&mf2c);
xdl_free_mmfile(&mf1);
return 0;
}
int xdlt_do_rabinregress(mmfile_t *mf1, mmfile_t *mf2) {
mmfile_t mfp, mfr;
if (xdlt_do_rabdiff(mf1, mf2, &mfp) < 0) {
return -1;
}
if (xdlt_do_binpatch(mf1, &mfp, &mfr) < 0) {
xdl_free_mmfile(&mfp);
return -1;
}
if (xdl_mmfile_cmp(&mfr, mf2)) {
xdl_free_mmfile(&mfr);
xdl_free_mmfile(&mfp);
return -1;
}
xdl_free_mmfile(&mfr);
xdl_free_mmfile(&mfp);
return 0;
}
int xdlt_auto_regress(xpparam_t const *xpp, xdemitconf_t const *xecfg, long size,
double rmod, int chmax) {
mmfile_t mf1, mf2;
if (xdlt_create_file(&mf1, size) < 0) {
return -1;
}
if (xdlt_change_file(&mf1, &mf2, rmod, chmax) < 0) {
xdl_free_mmfile(&mf1);
return -1;
}
if (xdlt_do_regress(&mf1, &mf2, xpp, xecfg) < 0) {
xdl_free_mmfile(&mf2);
xdl_free_mmfile(&mf1);
return -1;
}
xdl_free_mmfile(&mf2);
xdl_free_mmfile(&mf1);
return 0;
}
int xdlt_do_binpatch(mmfile_t *mf, mmfile_t *mfp, mmfile_t *mfr) {
xdemitcb_t ecb;
if (xdl_init_mmfile(mfr, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
return -1;
}
ecb.priv = mfr;
ecb.outf = xdlt_mmfile_outf;
if (xdl_bpatch(mf, mfp, &ecb) < 0) {
xdl_free_mmfile(mfr);
return -1;
}
return 0;
}
int xdlt_do_rabdiff(mmfile_t *mf1, mmfile_t *mf2, mmfile_t *mfp) {
xdemitcb_t ecb;
if (xdl_init_mmfile(mfp, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
return -1;
}
ecb.priv = mfp;
ecb.outf = xdlt_mmfile_outf;
if (xdl_rabdiff(mf1, mf2, &ecb) < 0) {
xdl_free_mmfile(mfp);
return -1;
}
return 0;
}
int xdlt_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
xdemitconf_t const *xecfg, mmfile_t *mfp) {
xdemitcb_t ecb;
if (xdl_init_mmfile(mfp, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
return -1;
}
ecb.priv = mfp;
ecb.outf = xdlt_mmfile_outf;
if (xdl_diff(mf1, mf2, xpp, xecfg, &ecb) < 0) {
xdl_free_mmfile(mfp);
return -1;
}
return 0;
}
int xdlt_do_regress(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
xdemitconf_t const *xecfg) {
mmfile_t mfp, mfr;
if (xdlt_do_diff(mf1, mf2, xpp, xecfg, &mfp) < 0) {
return -1;
}
if (xdlt_do_patch(mf1, &mfp, XDL_PATCH_NORMAL, &mfr) < 0) {
xdl_free_mmfile(&mfp);
return -1;
}
if (xdl_mmfile_cmp(&mfr, mf2)) {
xdl_free_mmfile(&mfr);
xdl_free_mmfile(&mfp);
return -1;
}
xdl_free_mmfile(&mfr);
if (xdlt_do_patch(mf2, &mfp, XDL_PATCH_REVERSE, &mfr) < 0) {
xdl_free_mmfile(&mfp);
return -1;
}
if (xdl_mmfile_cmp(&mfr, mf1)) {
xdl_free_mmfile(&mfr);
xdl_free_mmfile(&mfp);
return -1;
}
xdl_free_mmfile(&mfr);
xdl_free_mmfile(&mfp);
return 0;
}
int xdlt_create_file(mmfile_t *mf, long size) {
long lnsize, csize;
char *data;
if (xdl_init_mmfile(mf, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
return -1;
}
if (!(data = xdl_mmfile_writeallocate(mf, size))) {
xdl_free_mmfile(mf);
return -1;
}
for (csize = 0; size - csize > XDLT_MAX_LINE_SIZE;) {
lnsize = xdlt_gen_line(data, XDLT_MAX_LINE_SIZE);
data += lnsize;
csize += lnsize;
}
if (csize < size)
xdlt_gen_line(data, -(size - csize));
return 0;
}
int xdl_mmfile_compact(mmfile_t *mmfo, mmfile_t *mmfc, long bsize, unsigned long flags) {
long fsize = xdl_mmfile_size(mmfo), size;
char *data;
char const *blk;
if (xdl_init_mmfile(mmfc, bsize, flags) < 0) {
return -1;
}
if (!(data = (char *) xdl_mmfile_writeallocate(mmfc, fsize))) {
xdl_free_mmfile(mmfc);
return -1;
}
if ((blk = (char const *) xdl_mmfile_first(mmfo, &size)) != NULL) {
do {
memcpy(data, blk, size);
data += size;
} while ((blk = (char const *) xdl_mmfile_next(mmfo, &size)) != NULL);
}
return 0;
}
int xdlt_do_patch(mmfile_t *mfo, mmfile_t *mfp, int mode, mmfile_t *mfr) {
xdemitcb_t ecb, rjecb;
mmfile_t mmfrj;
if (xdl_init_mmfile(mfr, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
return -1;
}
if (xdl_init_mmfile(&mmfrj, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
xdl_free_mmfile(mfr);
return -1;
}
ecb.priv = mfr;
ecb.outf = xdlt_mmfile_outf;
rjecb.priv = &mmfrj;
rjecb.outf = xdlt_mmfile_outf;
if (xdl_patch(mfo, mfp, mode, &ecb, &rjecb) < 0) {
xdl_free_mmfile(&mmfrj);
xdl_free_mmfile(mfr);
return -1;
}
if (mmfrj.fsize > 0) {
#if 1
xdlt_dump_mmfile("xregr.orig", mfo);
xdlt_dump_mmfile("xregr.patch", mfp);
xdlt_dump_mmfile("xregr.rej", &mmfrj);
#endif
xdl_free_mmfile(&mmfrj);
xdl_free_mmfile(mfr);
return -1;
}
xdl_free_mmfile(&mmfrj);
return 0;
}
value xdiff_diff( value old_data, value new_data, value ctxlen )
{
CAMLparam3 (old_data, new_data, ctxlen);
CAMLlocal1(dif_data);
mmfile_t mf1, mf2, mf3;
xdemitcb_t ecb;
xpparam_t xpp;
xdemitconf_t xecfg;
long dif_size;
if (xdlt_store_mmfile(String_val(old_data), string_length(old_data), &mf1) < 0) {
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
if (xdlt_store_mmfile(String_val(new_data), string_length(new_data), &mf2) < 0) {
xdl_free_mmfile(&mf1);
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
if (xdl_init_mmfile(&mf3, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
xdl_free_mmfile(&mf1);
xdl_free_mmfile(&mf2);
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
ecb.priv = &mf3;
ecb.outf = xdlt_outf;
xpp.flags = 0;
xecfg.ctxlen = Int_val(ctxlen);
if (xdl_diff(&mf1, &mf2, &xpp, &xecfg, &ecb) < 0) {
xdl_free_mmfile(&mf1);
xdl_free_mmfile(&mf2);
xdl_free_mmfile(&mf3);
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
dif_size = xdlt_mmfile_size(&mf3);
dif_data = alloc_string(dif_size);
if (xdlt_read_mmfile(String_val(dif_data), &mf3) < 0) {
xdl_free_mmfile(&mf1);
xdl_free_mmfile(&mf2);
xdl_free_mmfile(&mf3);
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
xdl_free_mmfile(&mf1);
xdl_free_mmfile(&mf2);
xdl_free_mmfile(&mf3);
CAMLreturn(dif_data);
}
value xdiff_revpatch( value old_data, value patch)
{
CAMLparam2 (old_data, patch);
CAMLlocal1(res);
mmfile_t mf1, mf2, mf3, mf4;
xdemitcb_t ecb, rjecb;
long new_size, rej_size;
res = alloc_tuple(2);
if (xdlt_store_mmfile(String_val(old_data), string_length(old_data), &mf1) < 0) {
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
if (xdlt_store_mmfile(String_val(patch), string_length(patch), &mf2) < 0) {
xdl_free_mmfile(&mf1);
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
if (xdl_init_mmfile(&mf3, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
xdl_free_mmfile(&mf1);
xdl_free_mmfile(&mf2);
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
if (xdl_init_mmfile(&mf4, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
xdl_free_mmfile(&mf1);
xdl_free_mmfile(&mf2);
xdl_free_mmfile(&mf3);
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
ecb.priv = &mf3;
ecb.outf = xdlt_outf;
rjecb.priv = &mf4;
rjecb.outf = xdlt_outf;
if (xdl_patch(&mf1, &mf2, XDL_PATCH_REVERSE, &ecb, &rjecb) < 0) {
xdl_free_mmfile(&mf1);
xdl_free_mmfile(&mf2);
xdl_free_mmfile(&mf3);
xdl_free_mmfile(&mf4);
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
new_size = xdlt_mmfile_size(&mf3);
rej_size = xdlt_mmfile_size(&mf4);
Field(res, 0) = alloc_string(new_size);
Field(res, 1) = alloc_string(rej_size);
if (xdlt_read_mmfile(String_val(Field(res, 0)), &mf3) < 0) {
xdl_free_mmfile(&mf1);
xdl_free_mmfile(&mf2);
xdl_free_mmfile(&mf3);
xdl_free_mmfile(&mf4);
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
if (xdlt_read_mmfile(String_val(Field(res, 1)), &mf4) < 0) {
xdl_free_mmfile(&mf1);
xdl_free_mmfile(&mf2);
xdl_free_mmfile(&mf3);
xdl_free_mmfile(&mf4);
sprintf(ELINE, "%s:%d failed", __FILE__, __LINE__);
failwith(ELINE);
}
xdl_free_mmfile(&mf1);
xdl_free_mmfile(&mf2);
xdl_free_mmfile(&mf3);
xdl_free_mmfile(&mf4);
CAMLreturn(res);
}
int xdlt_auto_mbinregress(bdiffparam_t const *bdp, long size,
double rmod, int chmax, int n) {
int i, res;
mmbuffer_t *mbb;
mmfile_t *mf, *mfc, *mfx;
mmfile_t mfn, mff, mfd, mfb;
xdemitcb_t ecb;
if ((mbb = (mmbuffer_t *) xdl_malloc((n + 2) * sizeof(mmbuffer_t))) == NULL) {
return -1;
}
if ((mf = mfc = (mmfile_t *) xdl_malloc((n + 2) * sizeof(mmfile_t))) == NULL) {
xdl_free(mbb);
return -1;
}
if (xdlt_create_file(mfc, size) < 0) {
xdl_free(mf);
xdl_free(mbb);
return -1;
}
mbb[0].ptr = (char *) xdl_mmfile_first(mfc, &mbb[0].size);
mfc++;
mfx = mf;
for (i = 0; i < n; i++) {
if (xdlt_change_file(mfx, &mfn, rmod, chmax) < 0) {
if (mfx != mf) xdl_free_mmfile(mfx);
for (; i >= 0; i--)
xdl_free_mmfile(mf + i);
xdl_free(mf);
xdl_free(mbb);
return -1;
}
if (xdl_mmfile_compact(&mfn, &mff, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
xdl_free_mmfile(&mfn);
if (mfx != mf) xdl_free_mmfile(mfx);
for (; i >= 0; i--)
xdl_free_mmfile(mf + i);
xdl_free(mf);
xdl_free(mbb);
return -1;
}
xdl_free_mmfile(&mfn);
if (xdlt_do_bindiff(mfx, &mff, bdp, &mfd) < 0) {
xdl_free_mmfile(&mff);
if (mfx != mf) xdl_free_mmfile(mfx);
for (; i >= 0; i--)
xdl_free_mmfile(mf + i);
xdl_free(mf);
xdl_free(mbb);
return -1;
}
if (mfx != mf) xdl_free_mmfile(mfx);
mfx = &mfb;
*mfx = mff;
if (xdl_mmfile_compact(&mfd, mfc, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
xdl_free_mmfile(&mfd);
xdl_free_mmfile(mfx);
for (; i >= 0; i--)
xdl_free_mmfile(mf + i);
xdl_free(mf);
xdl_free(mbb);
return -1;
}
mbb[i + 1].ptr = (char *) xdl_mmfile_first(mfc, &mbb[i + 1].size);
mfc++;
xdl_free_mmfile(&mfd);
}
if (xdl_init_mmfile(mfc, XDLT_STD_BLKSIZE, XDL_MMF_ATOMIC) < 0) {
xdl_free_mmfile(mfx);
for (i = n; i >= 0; i--)
xdl_free_mmfile(mf + i);
xdl_free(mf);
xdl_free(mbb);
return -1;
}
ecb.priv = mfc;
ecb.outf = xdlt_mmfile_outf;
if ((res = xdl_bpatch_multi(&mbb[0], &mbb[1], n, &ecb)) == 0)
res = xdl_mmfile_cmp(mfx, mfc);
xdl_free_mmfile(mfx);
for (i = n + 1; i >= 0; i--)
xdl_free_mmfile(mf + i);
xdl_free(mf);
xdl_free(mbb);
return res;
}
