int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, xdfenv_t *xe) { long ndiags; long *kvd, *kvdf, *kvdb; xdalgoenv_t xenv; diffdata_t dd1, dd2; if (XDF_DIFF_ALG(xpp->flags) == XDF_PATIENCE_DIFF) return xdl_do_patience_diff(mf1, mf2, xpp, xe); if (XDF_DIFF_ALG(xpp->flags) == XDF_HISTOGRAM_DIFF) return xdl_do_histogram_diff(mf1, mf2, xpp, xe); if (xdl_prepare_env(mf1, mf2, xpp, xe) < 0) { return -1; } /* * Allocate and setup K vectors to be used by the differential algorithm. * One is to store the forward path and one to store the backward path. */ ndiags = xe->xdf1.nreff + xe->xdf2.nreff + 3; if (!(kvd = (long *) xdl_malloc((2 * ndiags + 2) * sizeof(long)))) { xdl_free_env(xe); return -1; } kvdf = kvd; kvdb = kvdf + ndiags; kvdf += xe->xdf2.nreff + 1; kvdb += xe->xdf2.nreff + 1; xenv.mxcost = xdl_bogosqrt(ndiags); if (xenv.mxcost < XDL_MAX_COST_MIN) xenv.mxcost = XDL_MAX_COST_MIN; xenv.snake_cnt = XDL_SNAKE_CNT; xenv.heur_min = XDL_HEUR_MIN_COST; dd1.nrec = xe->xdf1.nreff; dd1.ha = xe->xdf1.ha; dd1.rchg = xe->xdf1.rchg; dd1.rindex = xe->xdf1.rindex; dd2.nrec = xe->xdf2.nreff; dd2.ha = xe->xdf2.ha; dd2.rchg = xe->xdf2.rchg; dd2.rindex = xe->xdf2.rindex; if (xdl_recs_cmp(&dd1, 0, dd1.nrec, &dd2, 0, dd2.nrec, kvdf, kvdb, (xpp->flags & XDF_NEED_MINIMAL) != 0, &xenv) < 0) { xdl_free(kvd); xdl_free_env(xe); return -1; } xdl_free(kvd); return 0; }
int xdl_bpatch_multi(mmbuffer_t *base, mmbuffer_t *mbpch, int n, xdemitcb_t *ecb) { int i, nobf, fnobf; mmoffbuffer_t *obf, *fobf; nobf = 1; if ((obf = (mmoffbuffer_t *) xdl_malloc(nobf * sizeof(mmoffbuffer_t))) == NULL) { return -1; } obf->off = 0; obf->ptr = base->ptr; obf->size = base->size; for (i = 0; i < n; i++) { if (xdl_bmerge(obf, nobf, &mbpch[i], &fobf, &fnobf) < 0) { xdl_free(obf); return -1; } xdl_free(obf); obf = fobf; nobf = fnobf; } if (xdl_bmerge_synt(obf, nobf, ecb) < 0) { xdl_free(obf); return -1; } xdl_free(obf); return 0; }
static inline void free_index(struct histindex *index) { xdl_free(index->records); xdl_free(index->line_map); xdl_free(index->next_ptrs); xdl_cha_free(&index->rcha); }
/* * The idea is to start with the list of common unique lines sorted by * the order in file1. For each of these pairs, the longest (partial) * sequence whose last element's line2 is smaller is determined. * * For efficiency, the sequences are kept in a list containing exactly one * item per sequence length: the sequence with the smallest last * element (in terms of line2). */ static struct entry *find_longest_common_sequence(struct hashmap *map) { struct entry **sequence = xdl_malloc(map->nr * sizeof(struct entry *)); int longest = 0, i; struct entry *entry; for (entry = map->first; entry; entry = entry->next) { if (!entry->line2 || entry->line2 == NON_UNIQUE) continue; i = binary_search(sequence, longest, entry); entry->previous = i < 0 ? NULL : sequence[i]; sequence[++i] = entry; if (i == longest) longest++; } /* No common unique lines were found */ if (!longest) { xdl_free(sequence); return NULL; } /* Iterate starting at the last element, adjusting the "next" members */ entry = sequence[longest - 1]; entry->next = NULL; while (entry->previous) { entry->previous->next = entry; entry = entry->previous; } xdl_free(sequence); return entry; }
int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, xdfenv_t *xe) { long ndiags; long *kvd, *kvdf, *kvdb; xdalgoenv_t xenv; diffdata_t dd1, dd2; if (xdl_prepare_env(mf1, mf2, xpp, xe) < 0) { return -1; } /* * Allocate and setup K vectors to be used by the differential algorithm. * One is to store the forward path and one to store the backward path. */ ndiags = xe->xdf1.nreff + xe->xdf2.nreff + 3; if (!(kvd = (long *) xdl_malloc((2 * ndiags + 2) * sizeof(long)))) { xdl_free_env(xe); return -1; } kvdf = kvd; kvdb = kvdf + ndiags; kvdf += xe->xdf2.nreff + 1; kvdb += xe->xdf2.nreff + 1; /* * Classical integer square root approximation using shifts. */ xenv.mxcost = 1; for (; ndiags; ndiags >>= 2) xenv.mxcost <<= 1; if (xenv.mxcost < XDL_MAX_COST_MIN) xenv.mxcost = XDL_MAX_COST_MIN; xenv.snake_cnt = XDL_SNAKE_CNT; xenv.heur_min = XDL_HEUR_MIN_COST; dd1.nrec = xe->xdf1.nreff; dd1.ha = xe->xdf1.ha; dd1.rchg = xe->xdf1.rchg; dd1.rindex = xe->xdf1.rindex; dd2.nrec = xe->xdf2.nreff; dd2.ha = xe->xdf2.ha; dd2.rchg = xe->xdf2.rchg; dd2.rindex = xe->xdf2.rindex; if (xdl_recs_cmp(&dd1, 0, dd1.nrec, &dd2, 0, dd2.nrec, kvdf, kvdb, (xpp->flags & XDF_NEED_MINIMAL) != 0, &xenv) < 0) { xdl_free(kvd); xdl_free_env(xe); return -1; } xdl_free(kvd); return 0; }
static void xdl_free_ctx(xdfile_t *xdf) { xdl_free(xdf->rhash); xdl_free(xdf->rindex); xdl_free(xdf->rchg - 1); xdl_free(xdf->ha); xdl_free(xdf->recs); xdl_cha_free(&xdf->rcha); }
/* * The idea is to start with the list of common unique lines sorted by * the order in file1. For each of these pairs, the longest (partial) * sequence whose last element's line2 is smaller is determined. * * For efficiency, the sequences are kept in a list containing exactly one * item per sequence length: the sequence with the smallest last * element (in terms of line2). */ static struct entry *find_longest_common_sequence(struct hashmap *map) { struct entry **sequence = (struct entry **)xdl_malloc(map->nr * sizeof(struct entry *)); int longest = 0, i; struct entry *entry; /* * If not -1, this entry in sequence must never be overridden. * Therefore, overriding entries before this has no effect, so * do not do that either. */ int anchor_i = -1; /* Added to silence Coverity. */ if (sequence == NULL) return map->first; for (entry = map->first; entry; entry = entry->next) { if (!entry->line2 || entry->line2 == NON_UNIQUE) continue; i = binary_search(sequence, longest, entry); entry->previous = i < 0 ? NULL : sequence[i]; ++i; if (i <= anchor_i) continue; sequence[i] = entry; if (entry->anchor) { anchor_i = i; longest = anchor_i + 1; } else if (i == longest) { longest++; } } /* No common unique lines were found */ if (!longest) { xdl_free(sequence); return NULL; } /* Iterate starting at the last element, adjusting the "next" members */ entry = sequence[longest - 1]; entry->next = NULL; while (entry->previous) { entry->previous->next = entry; entry = entry->previous; } xdl_free(sequence); return entry; }
void xdl_free_script(xdchange_t *xscr) { xdchange_t *xch; while ((xch = xscr) != NULL) { xscr = xscr->next; xdl_free(xch); } }
void xdl_cha_free(chastore_t *cha) { chanode_t *cur, *tmp; for (cur = cha->head; (tmp = cur) != NULL;) { cur = cur->next; xdl_free(tmp); } }
void xdl_free_mmfile(mmfile_t *mmf) { mmblock_t *cur, *tmp; for (cur = mmf->head; (tmp = cur) != NULL;) { cur = cur->next; xdl_free(tmp); } }
/* * Recursively find the longest common sequence of unique lines, * and if none was found, ask xdl_do_diff() to do the job. * * This function assumes that env was prepared with xdl_prepare_env(). */ static int patience_diff(mmfile_t *file1, mmfile_t *file2, xpparam_t const *xpp, xdfenv_t *env, int line1, int count1, int line2, int count2) { struct hashmap map; struct entry *first; int result = 0; /* trivial case: one side is empty */ if (!count1) { while(count2--) env->xdf2.rchg[line2++ - 1] = 1; return 0; } else if (!count2) { while(count1--) env->xdf1.rchg[line1++ - 1] = 1; return 0; } memset(&map, 0, sizeof(map)); if (fill_hashmap(file1, file2, xpp, env, &map, line1, count1, line2, count2)) return -1; /* are there any matching lines at all? */ if (!map.has_matches) { while(count1--) env->xdf1.rchg[line1++ - 1] = 1; while(count2--) env->xdf2.rchg[line2++ - 1] = 1; xdl_free(map.entries); return 0; } first = find_longest_common_sequence(&map); if (first) result = walk_common_sequence(&map, first, line1, count1, line2, count2); else result = fall_back_to_classic_diff(&map, line1, count1, line2, count2); xdl_free(map.entries); return result; }
static int xdl_bmerge_synt(mmoffbuffer_t *obf, int n, xdemitcb_t *ecb) { int i; mmbuffer_t *mb; if ((mb = (mmbuffer_t *) xdl_malloc(n * sizeof(mmbuffer_t))) == NULL) { return -1; } for (i = 0; i < n; i++) { mb[i].ptr = obf[i].ptr; mb[i].size = obf[i].size; } if (ecb->outf(ecb->priv, mb, n) < 0) { xdl_free(mb); return -1; } xdl_free(mb); return 0; }
static int xdl_init_recfile(mmfile_t *mf, int ispatch, recfile_t *rf) { long narec, nrec, bsize; recinfo_t *recs, *rrecs; char const *blk, *cur, *top, *eol; narec = xdl_guess_lines(mf); if (!(recs = (recinfo_t *) xdl_malloc(narec * sizeof(recinfo_t)))) { return -1; } nrec = 0; if ((cur = blk = (char const *)xdl_mmfile_first(mf, &bsize)) != NULL) { for (top = blk + bsize;;) { if (cur >= top) { if (!(cur = blk = (char const *)xdl_mmfile_next(mf, &bsize))) break; top = blk + bsize; } if (nrec >= narec) { narec *= 2; if (!(rrecs = (recinfo_t *) xdl_realloc(recs, narec * sizeof(recinfo_t)))) { xdl_free(recs); return -1; } recs = rrecs; } recs[nrec].ptr = cur; if (!(eol = (char*)memchr(cur, '\n', top - cur))) eol = top - 1; recs[nrec].size = (long) (eol - cur) + 1; if (ispatch && *cur == '\\' && nrec > 0 && recs[nrec - 1].size > 0 && recs[nrec - 1].ptr[recs[nrec - 1].size - 1] == '\n') recs[nrec - 1].size--; else nrec++; cur = eol + 1; } } rf->mf = mf; rf->nrec = nrec; rf->recs = recs; return 0; }
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; }
static int xdl_prepare_ctx(mmfile_t *mf, long narec, xpparam_t const *xpp, xdlclassifier_t *cf, xdfile_t *xdf) { unsigned int hbits; long i, nrec, hsize, bsize; unsigned long hav; char const *blk, *cur, *top, *prev; xrecord_t *crec; xrecord_t **recs, **rrecs; xrecord_t **rhash; unsigned long *ha; char *rchg; long *rindex; if (xdl_cha_init(&xdf->rcha, sizeof(xrecord_t), narec / 4 + 1) < 0) { return -1; } if (!(recs = (xrecord_t **) xdl_malloc(narec * sizeof(xrecord_t *)))) { xdl_cha_free(&xdf->rcha); return -1; } hbits = xdl_hashbits((unsigned int) narec); hsize = 1 << hbits; if (!(rhash = (xrecord_t **) xdl_malloc(hsize * sizeof(xrecord_t *)))) { xdl_free(recs); xdl_cha_free(&xdf->rcha); return -1; } for (i = 0; i < hsize; i++) rhash[i] = NULL; nrec = 0; if ((cur = blk = xdl_mmfile_first(mf, &bsize)) != NULL) { for (top = blk + bsize;;) { if (cur >= top) { if (!(cur = blk = xdl_mmfile_next(mf, &bsize))) break; top = blk + bsize; } prev = cur; hav = xdl_hash_record(&cur, top, xpp->flags); if (nrec >= narec) { narec *= 2; if (!(rrecs = (xrecord_t **) xdl_realloc(recs, narec * sizeof(xrecord_t *)))) { xdl_free(rhash); xdl_free(recs); xdl_cha_free(&xdf->rcha); return -1; } recs = rrecs; } if (!(crec = xdl_cha_alloc(&xdf->rcha))) { xdl_free(rhash); xdl_free(recs); xdl_cha_free(&xdf->rcha); return -1; } crec->ptr = prev; crec->size = (long) (cur - prev); crec->ha = hav; recs[nrec++] = crec; if (xdl_classify_record(cf, rhash, hbits, crec) < 0) { xdl_free(rhash); xdl_free(recs); xdl_cha_free(&xdf->rcha); return -1; } } } if (!(rchg = (char *) xdl_malloc((nrec + 2) * sizeof(char)))) { xdl_free(rhash); xdl_free(recs); xdl_cha_free(&xdf->rcha); return -1; } memset(rchg, 0, (nrec + 2) * sizeof(char)); if (!(rindex = (long *) xdl_malloc((nrec + 1) * sizeof(long)))) { xdl_free(rchg); xdl_free(rhash); xdl_free(recs); xdl_cha_free(&xdf->rcha); return -1; } if (!(ha = (unsigned long *) xdl_malloc((nrec + 1) * sizeof(unsigned long)))) { xdl_free(rindex); xdl_free(rchg); xdl_free(rhash); xdl_free(recs); xdl_cha_free(&xdf->rcha); return -1; } xdf->nrec = nrec; xdf->recs = recs; xdf->hbits = hbits; xdf->rhash = rhash; xdf->rchg = rchg + 1; xdf->rindex = rindex; xdf->nreff = 0; xdf->ha = ha; xdf->dstart = 0; xdf->dend = nrec - 1; return 0; }
static int xdl_bmerge(mmoffbuffer_t *obf, int n, mmbuffer_t *mbfp, mmoffbuffer_t **probf, int *pnobf) { int i, aobf, nobf; long ooff, off, csize; unsigned long fp, ofp; unsigned char const *data, *top; mmoffbuffer_t *robf, *cobf; if (mbfp->size < XDL_BPATCH_HDR_SIZE) { return -1; } data = (unsigned char const *) mbfp->ptr; top = data + mbfp->size; ofp = xdl_mmob_adler32(obf, n); XDL_LE32_GET(data, fp); data += 4; XDL_LE32_GET(data, csize); data += 4; if (fp != ofp || csize != xdl_mmob_size(obf, n)) { return -1; } aobf = XDL_MOBF_MINALLOC; nobf = 0; if ((robf = (mmoffbuffer_t *) xdl_malloc(aobf * sizeof(mmoffbuffer_t))) == NULL) { return -1; } for (ooff = 0; data < top;) { if (*data == XDL_BDOP_INS) { data++; if ((cobf = xdl_mmob_new(&robf, &nobf, &aobf)) == NULL) { xdl_free(robf); return -1; } cobf->off = ooff; cobf->size = (long) *data++; cobf->ptr = (char *) data; data += cobf->size; ooff += cobf->size; } else if (*data == XDL_BDOP_INSB) { data++; XDL_LE32_GET(data, csize); data += 4; if ((cobf = xdl_mmob_new(&robf, &nobf, &aobf)) == NULL) { xdl_free(robf); return -1; } cobf->off = ooff; cobf->size = csize; cobf->ptr = (char *) data; data += cobf->size; ooff += cobf->size; } else if (*data == XDL_BDOP_CPY) { data++; XDL_LE32_GET(data, off); data += 4; XDL_LE32_GET(data, csize); data += 4; if ((i = xdl_mmob_find_cntr(obf, n, off)) < 0) { xdl_free(robf); return -1; } off -= obf[i].off; for (; i < n && csize > 0; i++, off = 0) { if ((cobf = xdl_mmob_new(&robf, &nobf, &aobf)) == NULL) { xdl_free(robf); return -1; } cobf->off = ooff; cobf->size = XDL_MIN(csize, obf[i].size - off); cobf->ptr = obf[i].ptr + off; ooff += cobf->size; csize -= cobf->size; } if (csize > 0) { xdl_free(robf); return -1; } } else { xdl_free(robf); return -1; } } *probf = robf; *pnobf = nobf; return 0; }
static int histogram_diff(xpparam_t const *xpp, xdfenv_t *env, int line1, int count1, int line2, int count2) { struct histindex index; struct region lcs; int sz; int result = -1; if (count1 <= 0 && count2 <= 0) return 0; if (LINE_END(1) >= MAX_PTR) return -1; if (!count1) { while(count2--) env->xdf2.rchg[line2++ - 1] = 1; return 0; } else if (!count2) { while(count1--) env->xdf1.rchg[line1++ - 1] = 1; return 0; } memset(&index, 0, sizeof(index)); index.env = env; index.xpp = xpp; index.records = NULL; index.line_map = NULL; /* in case of early xdl_cha_free() */ index.rcha.head = NULL; index.table_bits = xdl_hashbits(count1); sz = index.records_size = 1 << index.table_bits; sz *= sizeof(struct record *); if (!(index.records = (struct record **) xdl_malloc(sz))) goto cleanup; memset(index.records, 0, sz); sz = index.line_map_size = count1; sz *= sizeof(struct record *); if (!(index.line_map = (struct record **) xdl_malloc(sz))) goto cleanup; memset(index.line_map, 0, sz); sz = index.line_map_size; sz *= sizeof(unsigned int); if (!(index.next_ptrs = (unsigned int *) xdl_malloc(sz))) goto cleanup; memset(index.next_ptrs, 0, sz); /* lines / 4 + 1 comes from xprepare.c:xdl_prepare_ctx() */ if (xdl_cha_init(&index.rcha, sizeof(struct record), count1 / 4 + 1) < 0) goto cleanup; index.ptr_shift = line1; index.max_chain_length = 64; memset(&lcs, 0, sizeof(lcs)); if (find_lcs(&index, &lcs, line1, count1, line2, count2)) result = fall_back_to_classic_diff(&index, line1, count1, line2, count2); else { if (lcs.begin1 == 0 && lcs.begin2 == 0) { while (count1--) env->xdf1.rchg[line1++ - 1] = 1; while (count2--) env->xdf2.rchg[line2++ - 1] = 1; result = 0; } else { result = histogram_diff(xpp, env, line1, lcs.begin1 - line1, line2, lcs.begin2 - line2); if (result) goto cleanup; result = histogram_diff(xpp, env, lcs.end1 + 1, LINE_END(1) - lcs.end1, lcs.end2 + 1, LINE_END(2) - lcs.end2); if (result) goto cleanup; } } cleanup: xdl_free(index.records); xdl_free(index.line_map); xdl_free(index.next_ptrs); xdl_cha_free(&index.rcha); return result; }
static void xdl_free_recfile(recfile_t *rf) { xdl_free(rf->recs); }
/* * Try to reduce the problem complexity, discard records that have no * matches on the other file. Also, lines that have multiple matches * might be potentially discarded if they happear in a run of discardable. */ static int xdl_cleanup_records(xdfile_t *xdf1, xdfile_t *xdf2) { long i, nm, rhi, nreff, mlim; unsigned long hav; xrecord_t **recs; xrecord_t *rec; char *dis, *dis1, *dis2; if (!(dis = (char *) xdl_malloc(xdf1->nrec + xdf2->nrec + 2))) { return -1; } memset(dis, 0, xdf1->nrec + xdf2->nrec + 2); dis1 = dis; dis2 = dis1 + xdf1->nrec + 1; if ((mlim = xdl_bogosqrt(xdf1->nrec)) > XDL_MAX_EQLIMIT) mlim = XDL_MAX_EQLIMIT; for (i = xdf1->dstart, recs = &xdf1->recs[xdf1->dstart]; i <= xdf1->dend; i++, recs++) { hav = (*recs)->ha; rhi = (long) XDL_HASHLONG(hav, xdf2->hbits); for (nm = 0, rec = xdf2->rhash[rhi]; rec; rec = rec->next) if (rec->ha == hav && ++nm == mlim) break; dis1[i] = (nm == 0) ? 0: (nm >= mlim) ? 2: 1; } if ((mlim = xdl_bogosqrt(xdf2->nrec)) > XDL_MAX_EQLIMIT) mlim = XDL_MAX_EQLIMIT; for (i = xdf2->dstart, recs = &xdf2->recs[xdf2->dstart]; i <= xdf2->dend; i++, recs++) { hav = (*recs)->ha; rhi = (long) XDL_HASHLONG(hav, xdf1->hbits); for (nm = 0, rec = xdf1->rhash[rhi]; rec; rec = rec->next) if (rec->ha == hav && ++nm == mlim) break; dis2[i] = (nm == 0) ? 0: (nm >= mlim) ? 2: 1; } for (nreff = 0, i = xdf1->dstart, recs = &xdf1->recs[xdf1->dstart]; i <= xdf1->dend; i++, recs++) { if (dis1[i] == 1 || (dis1[i] == 2 && !xdl_clean_mmatch(dis1, i, xdf1->dstart, xdf1->dend))) { xdf1->rindex[nreff] = i; xdf1->ha[nreff] = (*recs)->ha; nreff++; } else xdf1->rchg[i] = 1; } xdf1->nreff = nreff; for (nreff = 0, i = xdf2->dstart, recs = &xdf2->recs[xdf2->dstart]; i <= xdf2->dend; i++, recs++) { if (dis2[i] == 1 || (dis2[i] == 2 && !xdl_clean_mmatch(dis2, i, xdf2->dstart, xdf2->dend))) { xdf2->rindex[nreff] = i; xdf2->ha[nreff] = (*recs)->ha; nreff++; } else xdf2->rchg[i] = 1; } xdf2->nreff = nreff; xdl_free(dis); return 0; }
static void xdl_free_classifier(xdlclassifier_t *cf) { xdl_free(cf->rchash); xdl_cha_free(&cf->ncha); }