xdiff: make xrecord_t.ptr a uint8_t instead of char

Rust uses u8 to refer to bytes in memory. Since xrecord_t.ptr is also
referring to bytes in memory, rather than Unicode code points, use
uint8_t instead of char.

Every usage of this field was inspected and cast to char*, or similar,
to avoid signedness warnings/errors from the compiler. Casting was used
so that the whole of xdiff doesn't need to be refactored in order to
change the type of this field.

Signed-off-by: Ezekiel Newren <ezekielnewren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/xdiff/xdiffi.c b/xdiff/xdiffi.c
index 6f3998ee54c01e9ed2572877cff2244620b70930..411a8aa69f3d62c8bcda7604a7d1a6616a8b25bb 100644 (file)
--- a/xdiff/xdiffi.c
+++ b/xdiff/xdiffi.c
@@ -407,7 +407,7 @@ static int get_indent(xrecord_t *rec)
        int ret = 0;
 
        for (i = 0; i < rec->size; i++) {
-               char c = rec->ptr[i];
+               uint8_t c = rec->ptr[i];
 
                if (!XDL_ISSPACE(c))
                        return ret;
@@ -993,11 +993,11 @@ static void xdl_mark_ignorable_lines(xdchange_t *xscr, xdfenv_t *xe, long flags)
 
                rec = &xe->xdf1.recs[xch->i1];
                for (i = 0; i < xch->chg1 && ignore; i++)
-                       ignore = xdl_blankline(rec[i].ptr, rec[i].size, flags);
+                       ignore = xdl_blankline((const char *)rec[i].ptr, rec[i].size, flags);
 
                rec = &xe->xdf2.recs[xch->i2];
                for (i = 0; i < xch->chg2 && ignore; i++)
-                       ignore = xdl_blankline(rec[i].ptr, rec[i].size, flags);
+                       ignore = xdl_blankline((const char *)rec[i].ptr, rec[i].size, flags);
 
                xch->ignore = ignore;
        }
@@ -1008,7 +1008,7 @@ static int record_matches_regex(xrecord_t *rec, xpparam_t const *xpp) {
        size_t i;
 
        for (i = 0; i < xpp->ignore_regex_nr; i++)
-               if (!regexec_buf(xpp->ignore_regex[i], rec->ptr, rec->size, 1,
+               if (!regexec_buf(xpp->ignore_regex[i], (const char *)rec->ptr, rec->size, 1,
                                 &regmatch, 0))
                        return 1;
 

diff --git a/xdiff/xemit.c b/xdiff/xemit.c
index b2f1f30cd36eef9aede1d7c208145c7f02476793..ead930088a560187ef4eb864f71f78d2e18a8066 100644 (file)
--- a/xdiff/xemit.c
+++ b/xdiff/xemit.c
@@ -27,7 +27,7 @@ static int xdl_emit_record(xdfile_t *xdf, long ri, char const *pre, xdemitcb_t *
 {
        xrecord_t *rec = &xdf->recs[ri];
 
-       if (xdl_emit_diffrec(rec->ptr, rec->size, pre, strlen(pre), ecb) < 0)
+       if (xdl_emit_diffrec((char const *)rec->ptr, rec->size, pre, strlen(pre), ecb) < 0)
                return -1;
 
        return 0;
@@ -113,8 +113,8 @@ static long match_func_rec(xdfile_t *xdf, xdemitconf_t const *xecfg, long ri,
        xrecord_t *rec = &xdf->recs[ri];
 
        if (!xecfg->find_func)
-               return def_ff(rec->ptr, rec->size, buf, sz);
-       return xecfg->find_func(rec->ptr, rec->size, buf, sz, xecfg->find_func_priv);
+               return def_ff((const char *)rec->ptr, rec->size, buf, sz);
+       return xecfg->find_func((const char *)rec->ptr, rec->size, buf, sz, xecfg->find_func_priv);
 }
 
 static int is_func_rec(xdfile_t *xdf, xdemitconf_t const *xecfg, long ri)

diff --git a/xdiff/xmerge.c b/xdiff/xmerge.c
index fd600cbb5d58a210947178a0d8799920daae8d65..75cb3e76a2c8e45114988a6007539a6ee9bcf8d4 100644 (file)
--- a/xdiff/xmerge.c
+++ b/xdiff/xmerge.c
@@ -101,8 +101,8 @@ static int xdl_merge_cmp_lines(xdfenv_t *xe1, int i1, xdfenv_t *xe2, int i2,
        xrecord_t *rec2 = xe2->xdf2.recs + i2;
 
        for (i = 0; i < line_count; i++) {
-               int result = xdl_recmatch(rec1[i].ptr, rec1[i].size,
-                       rec2[i].ptr, rec2[i].size, flags);
+               int result = xdl_recmatch((const char *)rec1[i].ptr, rec1[i].size,
+                       (const char *)rec2[i].ptr, rec2[i].size, flags);
                if (!result)
                        return -1;
        }
@@ -324,8 +324,8 @@ static int xdl_fill_merge_buffer(xdfenv_t *xe1, const char *name1,
 
 static int recmatch(xrecord_t *rec1, xrecord_t *rec2, unsigned long flags)
 {
-       return xdl_recmatch(rec1->ptr, rec1->size,
-                           rec2->ptr, rec2->size, flags);
+       return xdl_recmatch((const char *)rec1->ptr, rec1->size,
+                           (const char *)rec2->ptr, rec2->size, flags);
 }
 
 /*
@@ -382,10 +382,10 @@ static int xdl_refine_conflicts(xdfenv_t *xe1, xdfenv_t *xe2, xdmerge_t *m,
                 * we have a very simple mmfile structure.
                 */
                t1.ptr = (char *)xe1->xdf2.recs[m->i1].ptr;
-               t1.size = xe1->xdf2.recs[m->i1 + m->chg1 - 1].ptr
+               t1.size = (char *)xe1->xdf2.recs[m->i1 + m->chg1 - 1].ptr
                        + xe1->xdf2.recs[m->i1 + m->chg1 - 1].size - t1.ptr;
                t2.ptr = (char *)xe2->xdf2.recs[m->i2].ptr;
-               t2.size = xe2->xdf2.recs[m->i2 + m->chg2 - 1].ptr
+               t2.size = (char *)xe2->xdf2.recs[m->i2 + m->chg2 - 1].ptr
                        + xe2->xdf2.recs[m->i2 + m->chg2 - 1].size - t2.ptr;
                if (xdl_do_diff(&t1, &t2, xpp, &xe) < 0)
                        return -1;
@@ -440,7 +440,7 @@ static int line_contains_alnum(const char *ptr, long size)
 static int lines_contain_alnum(xdfenv_t *xe, int i, int chg)
 {
        for (; chg; chg--, i++)
-               if (line_contains_alnum(xe->xdf2.recs[i].ptr,
+               if (line_contains_alnum((const char *)xe->xdf2.recs[i].ptr,
                                xe->xdf2.recs[i].size))
                        return 1;
        return 0;

diff --git a/xdiff/xpatience.c b/xdiff/xpatience.c
index 669b653580efe6f9ecd295bc55c838fa0113ca21..bb61354f22a17761d7bd54172309cc98ef0ecb0f 100644 (file)
--- a/xdiff/xpatience.c
+++ b/xdiff/xpatience.c
@@ -121,7 +121,7 @@ static void insert_record(xpparam_t const *xpp, int line, struct hashmap *map,
                return;
        map->entries[index].line1 = line;
        map->entries[index].hash = record->ha;
-       map->entries[index].anchor = is_anchor(xpp, map->env->xdf1.recs[line - 1].ptr);
+       map->entries[index].anchor = is_anchor(xpp, (const char *)map->env->xdf1.recs[line - 1].ptr);
        if (!map->first)
                map->first = map->entries + index;
        if (map->last) {

diff --git a/xdiff/xprepare.c b/xdiff/xprepare.c
index 192334f1b72e630dba7e9400dc4741d2c07cff9a..4cb18b2b886fa6b89ef486978e64fe20c740719f 100644 (file)
--- a/xdiff/xprepare.c
+++ b/xdiff/xprepare.c
@@ -99,8 +99,8 @@ static int xdl_classify_record(unsigned int pass, xdlclassifier_t *cf, xrecord_t
        hi = (long) XDL_HASHLONG(rec->ha, cf->hbits);
        for (rcrec = cf->rchash[hi]; rcrec; rcrec = rcrec->next)
                if (rcrec->rec.ha == rec->ha &&
-                               xdl_recmatch(rcrec->rec.ptr, rcrec->rec.size,
-                                       rec->ptr, rec->size, cf->flags))
+                               xdl_recmatch((const char *)rcrec->rec.ptr, rcrec->rec.size,
+                                       (const char *)rec->ptr, rec->size, cf->flags))
                        break;
 
        if (!rcrec) {
@@ -156,8 +156,8 @@ static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, long narec, xpparam_
                        if (XDL_ALLOC_GROW(xdf->recs, xdf->nrec + 1, narec))
                                goto abort;
                        crec = &xdf->recs[xdf->nrec++];
-                       crec->ptr = prev;
-                       crec->size = (long) (cur - prev);
+                       crec->ptr = (uint8_t const *)prev;
+                       crec->size =(long) ( cur - prev);
                        crec->ha = hav;
                        if (xdl_classify_record(pass, cf, crec) < 0)
                                goto abort;

diff --git a/xdiff/xtypes.h b/xdiff/xtypes.h
index 7c8c057bca16e96b2f28f40af249cd852722164e..b1c520a37809f663f96ddc6a2d51bb5daaa20d26 100644 (file)
--- a/xdiff/xtypes.h
+++ b/xdiff/xtypes.h
@@ -39,7 +39,7 @@ typedef struct s_chastore {
 } chastore_t;
 
 typedef struct s_xrecord {
-       char const *ptr;
+       uint8_t const *ptr;
        long size;
        unsigned long ha;
 } xrecord_t;

diff --git a/xdiff/xutils.c b/xdiff/xutils.c
index 447e66c7198b08a1363db353d516039fb3772358..7be063bfb61d721e77ab423182acbe41dcba362a 100644 (file)
--- a/xdiff/xutils.c
+++ b/xdiff/xutils.c
@@ -465,10 +465,10 @@ int xdl_fall_back_diff(xdfenv_t *diff_env, xpparam_t const *xpp,
        xdfenv_t env;
 
        subfile1.ptr = (char *)diff_env->xdf1.recs[line1 - 1].ptr;
-       subfile1.size = diff_env->xdf1.recs[line1 + count1 - 2].ptr +
+       subfile1.size = (char *)diff_env->xdf1.recs[line1 + count1 - 2].ptr +
                diff_env->xdf1.recs[line1 + count1 - 2].size - subfile1.ptr;
        subfile2.ptr = (char *)diff_env->xdf2.recs[line2 - 1].ptr;
-       subfile2.size = diff_env->xdf2.recs[line2 + count2 - 2].ptr +
+       subfile2.size = (char *)diff_env->xdf2.recs[line2 + count2 - 2].ptr +
                diff_env->xdf2.recs[line2 + count2 - 2].size - subfile2.ptr;
        if (xdl_do_diff(&subfile1, &subfile2, xpp, &env) < 0)
                return -1;