clearlinux/bsdiff
2
0
Fork 0
mirror of https://github.com/clearlinux/bsdiff.git synced 2026-09-01 02:44:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename oldsize->old_size and newsize->new_size

Browse Source 
To align better with variable renamings in the forthcoming commit,
rename the two variables indicating size of the old and new files first.

Signed-off-by: Patrick McCarty <patrick.mccarty@intel.com>
This commit is contained in:
Patrick McCarty
2018-10-08 18:05:13 -07:00
parent e0e8bcda58
commit e27563e653
3 changed files with 95 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/diff.c
+63 -63
View File
@@ -74,12 +74,12 @@ static int bsdiff_fulldl;
#undef MIN #undef MIN
#define MIN(x, y) (((x) < (y)) ? (x) : (y)) #define MIN(x, y) (((x) < (y)) ? (x) : (y))
static int64_t matchlen(u_char *old, int64_t oldsize, u_char *new, static int64_t matchlen(u_char *old, int64_t old_size, u_char *new,
int64_t newsize) int64_t new_size)
{ {
int64_t i; int64_t i;
for (i = 0; (i < oldsize) && (i < newsize); i++) { for (i = 0; (i < old_size) && (i < new_size); i++) {
if (old[i] != new[i]) { if (old[i] != new[i]) {
break; break;
} }
@@ -96,27 +96,27 @@ static int64_t matchlen(u_char *old, int64_t oldsize, u_char *new,
* updated to the position of the match within OLD, and MAX_LEN is set to the * updated to the position of the match within OLD, and MAX_LEN is set to the
* match length. * match length.
*/ */
static void search(int64_t *I, u_char *old, int64_t oldsize, static void search(int64_t *I, u_char *old, int64_t old_size,
u_char *new, int64_t newsize, int64_t st, int64_t en, u_char *new, int64_t new_size, int64_t st, int64_t en,
int64_t *pos, int64_t *max_len) int64_t *pos, int64_t *max_len)
{ {
int64_t x, y; int64_t x, y;
/* Initialize max_len for the binary search */ /* Initialize max_len for the binary search */
if (st == 0 && en == oldsize) { if (st == 0 && en == old_size) {
*max_len = matchlen(old, oldsize, new, newsize); *max_len = matchlen(old, old_size, new, new_size);
*pos = I[st]; *pos = I[st];
} }
/* The binary search terminates here when "en" and "st" are adjacent /* The binary search terminates here when "en" and "st" are adjacent
* indices in the suffix-sorted array. */ * indices in the suffix-sorted array. */
if (en - st < 2) { if (en - st < 2) {
x = matchlen(old + I[st], oldsize - I[st], new, newsize); x = matchlen(old + I[st], old_size - I[st], new, new_size);
if (x > *max_len) { if (x > *max_len) {
*max_len = x; *max_len = x;
*pos = I[st]; *pos = I[st];
} }
y = matchlen(old + I[en], oldsize - I[en], new, newsize); y = matchlen(old + I[en], old_size - I[en], new, new_size);
if (y > *max_len) { if (y > *max_len) {
*max_len = y; *max_len = y;
*pos = I[en]; *pos = I[en];
@@ -127,7 +127,7 @@ static void search(int64_t *I, u_char *old, int64_t oldsize,
x = st + (en - st) / 2; x = st + (en - st) / 2;
int64_t length = MIN(oldsize - I[x], newsize); int64_t length = MIN(old_size - I[x], new_size);
u_char *oldoffset = old + I[x]; u_char *oldoffset = old + I[x];
/* This match *could* be the longest one, so check for that here */ /* This match *could* be the longest one, so check for that here */
@@ -139,9 +139,9 @@ static void search(int64_t *I, u_char *old, int64_t oldsize,
/* Determine how to continue the binary search */ /* Determine how to continue the binary search */
if (memcmp(oldoffset, new, length) < 0) { if (memcmp(oldoffset, new, length) < 0) {
return search(I, old, oldsize, new, newsize, x, en, pos, max_len); return search(I, old, old_size, new, new_size, x, en, pos, max_len);
} else { } else {
return search(I, old, oldsize, new, newsize, st, x, pos, max_len); return search(I, old, old_size, new, new_size, st, x, pos, max_len);
} }
} }
@@ -386,7 +386,7 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
{ {
int fd, efd; int fd, efd;
u_char *old_data, *new_data; u_char *old_data, *new_data;
int64_t oldsize, newsize; int64_t old_size, new_size;
int64_t *I, *V; int64_t *I, *V;
int64_t scan; int64_t scan;
int64_t pos = 0; int64_t pos = 0;
@@ -439,12 +439,12 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
return -1; return -1;
} }
oldsize = old_stat.st_size; old_size = old_stat.st_size;
/* We may start with an empty file, if so, just mark it for full download /* We may start with an empty file, if so, just mark it for full download
* to throw into the pack. In the case that newfile is <200, it will quit * to throw into the pack. In the case that newfile is <200, it will quit
* and ask for fulldownload, so we only need to check oldsize */ * and ask for fulldownload, so we only need to check old_size */
if (oldsize == 0) { if (old_size == 0) {
memset(&small_header, 0, sizeof(struct header_v21)); memset(&small_header, 0, sizeof(struct header_v21));
memcpy(&small_header.magic, BSDIFF_HDR_FULLDL, 8); memcpy(&small_header.magic, BSDIFF_HDR_FULLDL, 8);
@@ -471,9 +471,9 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
/* TODO: investigate why this needs to be +1 to not overrun; coverity complains /* TODO: investigate why this needs to be +1 to not overrun; coverity complains
* that we overrun old_data when we calculate differences otherwise. Tenatively, * that we overrun old_data when we calculate differences otherwise. Tenatively,
* since this is used in qsufsort, it may need to be +1 like I and V because of * since this is used in qsufsort, it may need to be +1 like I and V because of
* a sentinel byte when sorting. However, newsize does not cause any overruns * a sentinel byte when sorting. However, new_size does not cause any overruns
* when created with the regular file size */ * when created with the regular file size */
old_data = mmap(NULL, oldsize + 1, PROT_READ, MAP_SHARED, fd, 0); old_data = mmap(NULL, old_size + 1, PROT_READ, MAP_SHARED, fd, 0);
close(fd); close(fd);
if (old_data == MAP_FAILED) { if (old_data == MAP_FAILED) {
@@ -483,19 +483,19 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
/* These arrays are size + 1 because suffix sort needs space for the /* These arrays are size + 1 because suffix sort needs space for the
* data + 1 sentinel element to actually do the sorting. Not because * data + 1 sentinel element to actually do the sorting. Not because
* oldsize might be 0. */ * old_size might be 0. */
if ((I = malloc((oldsize + 1) * sizeof(int64_t))) == NULL) { if ((I = malloc((old_size + 1) * sizeof(int64_t))) == NULL) {
munmap(old_data, oldsize); munmap(old_data, old_size);
return -1; return -1;
} }
if ((V = malloc((oldsize + 1) * sizeof(int64_t))) == NULL) { if ((V = malloc((old_size + 1) * sizeof(int64_t))) == NULL) {
munmap(old_data, oldsize); munmap(old_data, old_size);
free(I); free(I);
return -1; return -1;
} }
if (qsufsort(I, V, old_data, oldsize) != 0) { if (qsufsort(I, V, old_data, old_size) != 0) {
munmap(old_data, oldsize); munmap(old_data, old_size);
free(I); free(I);
free(V); free(V);
return -1; return -1;
@@ -504,19 +504,19 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
free(V); free(V);
if ((fd = open(new_filename, O_RDONLY, 0)) < 0) { if ((fd = open(new_filename, O_RDONLY, 0)) < 0) {
munmap(old_data, oldsize); munmap(old_data, old_size);
free(I); free(I);
return -1; return -1;
} }
if (fstat(fd, &new_stat) != 0) { if (fstat(fd, &new_stat) != 0) {
munmap(old_data, oldsize); munmap(old_data, old_size);
free(I); free(I);
close(fd); close(fd);
return -1; return -1;
} }
newsize = new_stat.st_size; new_size = new_stat.st_size;
/* Note: testing this to see how diffs between small files affect /* Note: testing this to see how diffs between small files affect
* updates. Small files seem to cause some problems between certain * updates. Small files seem to cause some problems between certain
@@ -526,76 +526,76 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
* the "is bsdiff < 90% of newfile size" check that would otherwise * the "is bsdiff < 90% of newfile size" check that would otherwise
* be performed later on. * be performed later on.
*/ */
if (newsize < 200) { if (new_size < 200) {
memset(&small_header, 0, sizeof(struct header_v21)); memset(&small_header, 0, sizeof(struct header_v21));
memcpy(&small_header.magic, BSDIFF_HDR_FULLDL, 8); memcpy(&small_header.magic, BSDIFF_HDR_FULLDL, 8);
efd = open(delta_filename, O_CREAT | O_EXCL | O_WRONLY, 00644); efd = open(delta_filename, O_CREAT | O_EXCL | O_WRONLY, 00644);
if (efd < 0) { if (efd < 0) {
close(fd); close(fd);
munmap(old_data, oldsize); munmap(old_data, old_size);
free(I); free(I);
return -1; return -1;
} }
if ((pf = fdopen(efd, "w")) == NULL) { if ((pf = fdopen(efd, "w")) == NULL) {
close(efd); close(efd);
close(fd); close(fd);
munmap(old_data, oldsize); munmap(old_data, old_size);
free(I); free(I);
return -1; return -1;
} }
if (fwrite(&small_header, 8, 1, pf) != 1) { if (fwrite(&small_header, 8, 1, pf) != 1) {
fclose(pf); fclose(pf);
close(fd); close(fd);
munmap(old_data, oldsize); munmap(old_data, old_size);
free(I); free(I);
return -1; return -1;
} }
fclose(pf); fclose(pf);
close(fd); close(fd);
munmap(old_data, oldsize); munmap(old_data, old_size);
free(I); free(I);
return 1; return 1;
} }
if ((new_data = malloc(newsize)) == NULL) { if ((new_data = malloc(new_size)) == NULL) {
close(fd); close(fd);
munmap(old_data, oldsize); munmap(old_data, old_size);
free(I); free(I);
return -1; return -1;
} }
if (pread(fd, new_data, newsize, 0) != newsize) { if (pread(fd, new_data, new_size, 0) != new_size) {
close(fd); close(fd);
munmap(old_data, oldsize); munmap(old_data, old_size);
free(new_data); free(new_data);
free(I); free(I);
return -1; return -1;
} }
if (close(fd) == -1) { if (close(fd) == -1) {
munmap(old_data, oldsize); munmap(old_data, old_size);
free(new_data); free(new_data);
free(I); free(I);
return -1; return -1;
} }
/* we can write 3 8 byte tupples extra, so allocate some headroom */ /* we can write 3 8 byte tupples extra, so allocate some headroom */
if ((cb = malloc(newsize + 25)) == NULL) { if ((cb = malloc(new_size + 25)) == NULL) {
munmap(old_data, oldsize); munmap(old_data, old_size);
free(new_data); free(new_data);
free(I); free(I);
return -1; return -1;
} }
if ((db = malloc(newsize + 25)) == NULL) { if ((db = malloc(new_size + 25)) == NULL) {
munmap(old_data, oldsize); munmap(old_data, old_size);
free(new_data); free(new_data);
free(cb); free(cb);
free(I); free(I);
return -1; return -1;
} }
if ((eb = malloc(newsize + 25)) == NULL) { if ((eb = malloc(new_size + 25)) == NULL) {
munmap(old_data, oldsize); munmap(old_data, old_size);
free(new_data); free(new_data);
free(cb); free(cb);
free(db); free(db);
@@ -612,15 +612,15 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
lastscan = 0; lastscan = 0;
lastpos = 0; lastpos = 0;
lastoffset = 0; lastoffset = 0;
while (scan < newsize) { while (scan < new_size) {
oldscore = 0; oldscore = 0;
for (scsc = scan += len; scan < newsize; scan++) { for (scsc = scan += len; scan < new_size; scan++) {
search(I, old_data, oldsize, new_data + scan, newsize - scan, search(I, old_data, old_size, new_data + scan, new_size - scan,
0, oldsize, &pos, &len); 0, old_size, &pos, &len);
for (; scsc < scan + len; scsc++) { for (; scsc < scan + len; scsc++) {
if ((scsc + lastoffset < oldsize) && if ((scsc + lastoffset < old_size) &&
(old_data[scsc + lastoffset] == new_data[scsc])) { (old_data[scsc + lastoffset] == new_data[scsc])) {
oldscore++; oldscore++;
} }
@@ -631,18 +631,18 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
break; break;
} }
if ((scan + lastoffset < oldsize) && if ((scan + lastoffset < old_size) &&
(old_data[scan + lastoffset] == new_data[scan])) { (old_data[scan + lastoffset] == new_data[scan])) {
oldscore--; oldscore--;
} }
} }
if ((len != oldscore) || (scan == newsize)) { if ((len != oldscore) || (scan == new_size)) {
s = 0; s = 0;
Sf = 0; Sf = 0;
lenf = 0; lenf = 0;
for (i = 0; for (i = 0;
(lastscan + i < scan) && (lastpos + i < oldsize);) { (lastscan + i < scan) && (lastpos + i < old_size);) {
if (old_data[lastpos + i] == new_data[lastscan + i]) { if (old_data[lastpos + i] == new_data[lastscan + i]) {
s++; s++;
} }
@@ -654,7 +654,7 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
} }
lenb = 0; lenb = 0;
if (scan < newsize) { if (scan < new_size) {
s = 0; s = 0;
Sb = 0; Sb = 0;
for (i = 1; for (i = 1;
@@ -707,8 +707,8 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
/* checking for control block overflow... /* checking for control block overflow...
* See regression test #15 for an example */ * See regression test #15 for an example */
if ((int64_t)(cblen + 24) > (newsize + 25)) { if ((int64_t)(cblen + 24) > (new_size + 25)) {
munmap(old_data, oldsize); munmap(old_data, old_size);
free(new_data); free(new_data);
free(cb); free(cb);
free(db); free(db);
@@ -766,8 +766,8 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
small_header.control_length = cblen; small_header.control_length = cblen;
small_header.diff_length = dblen; small_header.diff_length = dblen;
small_header.extra_length = eblen; small_header.extra_length = eblen;
small_header.old_file_length = oldsize; small_header.old_file_length = old_size;
small_header.new_file_length = newsize; small_header.new_file_length = new_size;
small_header.file_mode = new_stat.st_mode; small_header.file_mode = new_stat.st_mode;
small_header.file_owner = new_stat.st_uid; small_header.file_owner = new_stat.st_uid;
small_header.file_group = new_stat.st_gid; small_header.file_group = new_stat.st_gid;
@@ -777,7 +777,7 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
eblock_set_enc(&small_header.encoding, e_enc); eblock_set_enc(&small_header.encoding, e_enc);
encodings = small_header.encoding; encodings = small_header.encoding;
if ((first_block + cblen + dblen + eblen > 0.90 * newsize) && (enc != BSDIFF_ENC_NONE)) { /* tune */ if ((first_block + cblen + dblen + eblen > 0.90 * new_size) && (enc != BSDIFF_ENC_NONE)) { /* tune */
memcpy(&small_header.magic, BSDIFF_HDR_FULLDL, 8); memcpy(&small_header.magic, BSDIFF_HDR_FULLDL, 8);
ret = 1; ret = 1;
if (fwrite(&small_header, 8, 1, pf) != 1) { if (fwrite(&small_header, 8, 1, pf) != 1) {
@@ -805,8 +805,8 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
large_header.control_length = cblen; large_header.control_length = cblen;
large_header.diff_length = dblen; large_header.diff_length = dblen;
large_header.extra_length = eblen; large_header.extra_length = eblen;
large_header.old_file_length = oldsize; large_header.old_file_length = old_size;
large_header.new_file_length = newsize; large_header.new_file_length = new_size;
large_header.file_mode = new_stat.st_mode; large_header.file_mode = new_stat.st_mode;
large_header.file_owner = new_stat.st_uid; large_header.file_owner = new_stat.st_uid;
large_header.file_group = new_stat.st_gid; large_header.file_group = new_stat.st_gid;
@@ -816,7 +816,7 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
eblock_set_enc(&large_header.encoding, e_enc); eblock_set_enc(&large_header.encoding, e_enc);
encodings = large_header.encoding; encodings = large_header.encoding;
if ((first_block + cblen + dblen + eblen > 0.90 * newsize) && (enc != BSDIFF_ENC_NONE)) { /* tune */ if ((first_block + cblen + dblen + eblen > 0.90 * new_size) && (enc != BSDIFF_ENC_NONE)) { /* tune */
memcpy(&large_header.magic, BSDIFF_HDR_FULLDL, 8); memcpy(&large_header.magic, BSDIFF_HDR_FULLDL, 8);
ret = 1; ret = 1;
if (fwrite(&large_header, 8, 1, pf) != 1) { if (fwrite(&large_header, 8, 1, pf) != 1) {
@@ -847,7 +847,7 @@ int make_bsdiff_delta(char *old_filename, char *new_filename, char *delta_filena
} }
bsdiff_files++; bsdiff_files++;
bsdiff_newbytes += newsize; bsdiff_newbytes += new_size;
bsdiff_outputbytes += first_block + cblen + dblen + eblen; bsdiff_outputbytes += first_block + cblen + dblen + eblen;
if (cblock_get_enc(encodings) == BSDIFF_ENC_NONE) { if (cblock_get_enc(encodings) == BSDIFF_ENC_NONE) {
@@ -901,7 +901,7 @@ fulldl_close_free:
} }
fulldl_free: fulldl_free:
/* Free the memory we used */ /* Free the memory we used */
munmap(old_data, oldsize); munmap(old_data, old_size);
free(new_data); free(new_data);
free(cb); free(cb);
free(db); free(db);
src/patch.c
+21 -21
View File
@@ -544,7 +544,7 @@ static int apply_delta_v2(int subver, FILE *f,
int i, ret, fd; int i, ret, fd;
off_t data_offset; off_t data_offset;
off_t ctrllen, difflen, extralen; off_t ctrllen, difflen, extralen;
off_t oldsize, newsize; off_t old_size, new_size;
mode_t mode; mode_t mode;
uid_t uid; uid_t uid;
gid_t gid; gid_t gid;
@@ -561,8 +561,8 @@ static int apply_delta_v2(int subver, FILE *f,
ctrllen = header.control_length; ctrllen = header.control_length;
difflen = header.diff_length; difflen = header.diff_length;
extralen = header.extra_length; extralen = header.extra_length;
oldsize = header.old_file_length; old_size = header.old_file_length;
newsize = header.new_file_length; new_size = header.new_file_length;
mode = header.file_mode; mode = header.file_mode;
uid = header.file_owner; uid = header.file_owner;
gid = header.file_group; gid = header.file_group;
@@ -576,8 +576,8 @@ static int apply_delta_v2(int subver, FILE *f,
ctrllen = header.control_length; ctrllen = header.control_length;
difflen = header.diff_length; difflen = header.diff_length;
extralen = header.extra_length; extralen = header.extra_length;
oldsize = header.old_file_length; old_size = header.old_file_length;
newsize = header.new_file_length; new_size = header.new_file_length;
mode = header.file_mode; mode = header.file_mode;
uid = header.file_owner; uid = header.file_owner;
gid = header.file_group; gid = header.file_group;
@@ -588,7 +588,7 @@ static int apply_delta_v2(int subver, FILE *f,
if ((ret = check_header(f, encoding, if ((ret = check_header(f, encoding,
ctrllen, difflen, extralen, ctrllen, difflen, extralen,
oldsize, newsize, data_offset)) < 0) { old_size, new_size, data_offset)) < 0) {
return ret; return ret;
} }
@@ -597,29 +597,29 @@ static int apply_delta_v2(int subver, FILE *f,
return ret; return ret;
} }
ret = read_file(old_filename, &old_data, oldsize); ret = read_file(old_filename, &old_data, old_size);
if (ret < 0) { if (ret < 0) {
goto preperror; goto preperror;
} }
if (newsize > BSDIFF_MAX_FILESZ) { if (new_size > BSDIFF_MAX_FILESZ) {
munmap(old_data, oldsize); munmap(old_data, old_size);
ret = -1; ret = -1;
goto preperror; goto preperror;
} }
/* Allocate newsize+1 bytes instead of newsize bytes to ensure /* Allocate new_size+1 bytes instead of new_size bytes to ensure
that we never try to malloc(0) and get a NULL pointer */ that we never try to malloc(0) and get a NULL pointer */
if ((new_data = malloc(newsize + 1)) == NULL) { if ((new_data = malloc(new_size + 1)) == NULL) {
munmap(old_data, oldsize); munmap(old_data, old_size);
ret = -1; ret = -1;
goto preperror; goto preperror;
} }
memset(new_data, 0, newsize + 1); memset(new_data, 0, new_size + 1);
oldpos = 0; oldpos = 0;
newpos = 0; newpos = 0;
while (newpos < newsize) { while (newpos < new_size) {
/* Read control data: /* Read control data:
* ctrl[0] == offset into diff block * ctrl[0] == offset into diff block
* ctrl[1] == offset into extra block * ctrl[1] == offset into extra block
@@ -641,7 +641,7 @@ static int apply_delta_v2(int subver, FILE *f,
} }
/* Sanity-check */ /* Sanity-check */
if (newpos + ctrl[0] > newsize || ctrl[0] < 0 || newpos + ctrl[0] < 0) { if (newpos + ctrl[0] > new_size || ctrl[0] < 0 || newpos + ctrl[0] < 0) {
ret = -1; ret = -1;
goto readerror; goto readerror;
} }
@@ -654,7 +654,7 @@ static int apply_delta_v2(int subver, FILE *f,
/* Add old data to diff string */ /* Add old data to diff string */
for (i = 0; i < ctrl[0]; i++) { for (i = 0; i < ctrl[0]; i++) {
if ((oldpos + i >= 0) && (oldpos + i < oldsize)) { if ((oldpos + i >= 0) && (oldpos + i < old_size)) {
new_data[newpos + i] += old_data[oldpos + i]; new_data[newpos + i] += old_data[oldpos + i];
} }
} }
@@ -664,11 +664,11 @@ static int apply_delta_v2(int subver, FILE *f,
oldpos += ctrl[0]; oldpos += ctrl[0];
/* Sanity-check */ /* Sanity-check */
if (newpos + ctrl[1] > newsize || ctrl[1] < 0 || newpos + ctrl[1] < 0) { if (newpos + ctrl[1] > new_size || ctrl[1] < 0 || newpos + ctrl[1] < 0) {
ret = -1; ret = -1;
goto readerror; goto readerror;
} }
if (oldpos + ctrl[2] > oldsize || oldpos + ctrl[2] < 0) { if (oldpos + ctrl[2] > old_size || oldpos + ctrl[2] < 0) {
ret = -1; ret = -1;
goto readerror; goto readerror;
} }
@@ -696,7 +696,7 @@ static int apply_delta_v2(int subver, FILE *f,
goto writeerror; goto writeerror;
} }
if (write(fd, new_data, newsize) != newsize) { if (write(fd, new_data, new_size) != new_size) {
unlink(new_filename); unlink(new_filename);
close(fd); close(fd);
ret = -1; ret = -1;
@@ -719,12 +719,12 @@ static int apply_delta_v2(int subver, FILE *f,
writeerror: writeerror:
free(new_data); free(new_data);
munmap(old_data, oldsize); munmap(old_data, old_size);
return ret; return ret;
readerror: readerror:
free(new_data); free(new_data);
munmap(old_data, oldsize); munmap(old_data, old_size);
preperror: preperror:
cfclose(&cf); cfclose(&cf);
cfclose(&df); cfclose(&df);
src/sufsort.c
+11 -11
View File
@@ -126,8 +126,8 @@ static void split(int64_t *I, int64_t *V, int64_t arraylen, int64_t start, int64
} }
/* The old_data (previous file data) is passed into this suffix sort and sorted /* The old_data (previous file data) is passed into this suffix sort and sorted
* accordingly using the I and V arrays, which are both of length oldsize +1. */ * accordingly using the I and V arrays, which are both of length old_size +1. */
int qsufsort(int64_t *I, int64_t *V, u_char *old, int64_t oldsize) int qsufsort(int64_t *I, int64_t *V, u_char *old, int64_t old_size)
{ {
int64_t buckets[QSUF_BUCKET_SIZE]; int64_t buckets[QSUF_BUCKET_SIZE];
int64_t i, h, len; int64_t i, h, len;
@@ -135,7 +135,7 @@ int qsufsort(int64_t *I, int64_t *V, u_char *old, int64_t oldsize)
for (i = 0; i < QSUF_BUCKET_SIZE; i++) { for (i = 0; i < QSUF_BUCKET_SIZE; i++) {
buckets[i] = 0; buckets[i] = 0;
} }
for (i = 0; i < oldsize; i++) { for (i = 0; i < old_size; i++) {
buckets[old[i]]++; buckets[old[i]]++;
} }
for (i = 1; i < QSUF_BUCKET_SIZE; i++) { for (i = 1; i < QSUF_BUCKET_SIZE; i++) {
@@ -146,17 +146,17 @@ int qsufsort(int64_t *I, int64_t *V, u_char *old, int64_t oldsize)
} }
buckets[0] = 0; buckets[0] = 0;
for (i = 0; i < oldsize; i++) { for (i = 0; i < old_size; i++) {
if (buckets[old[i]] > oldsize + 1) { if (buckets[old[i]] > old_size + 1) {
return -1; return -1;
} }
I[++buckets[old[i]]] = i; I[++buckets[old[i]]] = i;
} }
for (i = 0; i < oldsize; i++) { for (i = 0; i < old_size; i++) {
V[i] = buckets[old[i]]; V[i] = buckets[old[i]];
} }
V[oldsize] = 0; V[old_size] = 0;
for (i = 1; i < QSUF_BUCKET_SIZE; i++) { for (i = 1; i < QSUF_BUCKET_SIZE; i++) {
if (buckets[i] == buckets[i - 1] + 1) { if (buckets[i] == buckets[i - 1] + 1) {
I[buckets[i]] = -1; I[buckets[i]] = -1;
@@ -164,9 +164,9 @@ int qsufsort(int64_t *I, int64_t *V, u_char *old, int64_t oldsize)
} }
I[0] = -1; I[0] = -1;
for (h = 1; I[0] != -(oldsize + 1); h += h) { for (h = 1; I[0] != -(old_size + 1); h += h) {
len = 0; len = 0;
for (i = 0; i < oldsize + 1;) { for (i = 0; i < old_size + 1;) {
if (I[i] < 0) { if (I[i] < 0) {
len -= I[i]; len -= I[i];
i -= I[i]; i -= I[i];
@@ -175,7 +175,7 @@ int qsufsort(int64_t *I, int64_t *V, u_char *old, int64_t oldsize)
I[i - len] = -len; I[i - len] = -len;
} }
len = V[I[i]] + 1 - i; len = V[I[i]] + 1 - i;
split(I, V, oldsize, i, len, h); split(I, V, old_size, i, len, h);
i += len; i += len;
len = 0; len = 0;
} }
@@ -185,7 +185,7 @@ int qsufsort(int64_t *I, int64_t *V, u_char *old, int64_t oldsize)
} }
} }
for (i = 0; i < oldsize + 1; i++) { for (i = 0; i < old_size + 1; i++) {
I[V[i]] = i; I[V[i]] = i;
} }