Fix signedness mismatches in string processing code

Author: niner

src/strings/decode_stream.c

@@ -113,7 +113,7 @@ void MVM_string_decodestream_discard_to(MVMThreadContext *tc, MVMDecodeStream *d
 #define RUN_DECODE_NOTHING_DECODED          0
 #define RUN_DECODE_STOPPER_NOT_REACHED      1
 #define RUN_DECODE_STOPPER_REACHED          2
-static MVMuint32 run_decode(MVMThreadContext *tc, MVMDecodeStream *ds, const MVMint32 *stopper_chars, MVMDecodeStreamSeparators *sep_spec, MVMint32 eof) {
+static MVMuint32 run_decode(MVMThreadContext *tc, MVMDecodeStream *ds, const MVMuint32 *stopper_chars, MVMDecodeStreamSeparators *sep_spec, MVMint32 eof) {
     MVMDecodeStreamChars *prev_chars_tail = ds->chars_tail;
     MVMuint32 reached_stopper;
     switch (ds->encoding) {
@@ -277,7 +277,7 @@ static MVMString * take_chars(MVMThreadContext *tc, MVMDecodeStream *ds, MVMint3
 }
 MVMString * MVM_string_decodestream_get_chars(MVMThreadContext *tc, MVMDecodeStream *ds,
                                               MVMint32 chars, MVMint64 eof) {
-    MVMint32 missing;
+    MVMuint32 missing;
 
     /* If we request nothing, give empty string. */
     if (chars == 0)

src/strings/nfg.c

@@ -270,7 +270,7 @@ MVMGrapheme32 MVM_nfg_crlf_grapheme(MVMThreadContext *tc) {
  * safe point. */
 MVMNFGSynthetic * MVM_nfg_get_synthetic_info(MVMThreadContext *tc, MVMGrapheme32 synth) {
     MVMNFGState *nfg       = tc->instance->nfg;
-    MVMint32     synth_idx = -synth - 1;
+    MVMuint32     synth_idx = -synth - 1;
     if (synth >= 0)
         MVM_oops(tc, "MVM_nfg_get_synthetic_info illegally called on a non-synthetic codepoint.\nRequested codepoint %i.", synth);
     if (synth_idx >= nfg->num_synthetics)
@@ -475,7 +475,7 @@ void MVM_nfg_init(MVMThreadContext *tc) {
  * to a VM instance. */
 void MVM_nfg_destroy(MVMThreadContext *tc) {
     MVMNFGState *nfg = tc->instance->nfg;
-    MVMint32 i;
+    MVMuint32 i;
 
     /* Free all synthetics. */
     if (nfg->synthetics) {

src/strings/nfg.h

@@ -18,7 +18,7 @@ struct MVMNFGState {
     uv_mutex_t update_mutex;
 
     /* Number of synthetics we have. */
-    MVMint32 num_synthetics;
+    MVMuint32 num_synthetics;
 
     /* Cached CRLF grapheme index, since we need it so often. */
     MVMGrapheme32 crlf_grapheme;

src/strings/ops.c

@@ -355,7 +355,7 @@ static void iterate_gi_into_string(MVMThreadContext *tc, MVMGraphemeIter *gi, MV
             graphs_so_far += graphs_this_strand; \
         } \
         else { \
-            int j = 0; \
+            MVMuint32 j = 0; \
             for (; j <= orig->body.storage.strands[i].repetitions; j++) { \
                 memcpy(graphs_so_far + result->body.storage.BLOB_TYPE, \
                     orig->body.storage.strands[i].blob_string->body.storage.BLOB_TYPE + orig->body.storage.strands[i].start, \
@@ -842,7 +842,7 @@ static MVMuint16 final_strand_match_with_repetition_count(MVMThreadContext *tc,
 /* Append one string to another. */
 MVMString * MVM_string_concatenate(MVMThreadContext *tc, MVMString *a, MVMString *b) {
     MVMString *result = NULL, *renormalized_section = NULL;
-    int renormalized_section_graphs = 0, consumed_a = 0, consumed_b = 0;
+    MVMuint32 renormalized_section_graphs = 0, consumed_a = 0, consumed_b = 0;
     MVMuint32  agraphs, bgraphs;
     MVMuint64  total_graphs;
     int lost_strands          = 0;
@@ -1620,7 +1620,7 @@ static MVMString * do_case_change(MVMThreadContext *tc, MVMString *s, MVMint32 t
             }
             else {
                 MVMGrapheme32 *transformed;
-                MVMint32 num_transformed = MVM_nfg_get_case_change(tc, g, type, &transformed);
+                MVMuint32 num_transformed = MVM_nfg_get_case_change(tc, g, type, &transformed);
                 if (num_transformed == 0) {
                     result_buf[i++] = g;
                 }
@@ -1874,7 +1874,7 @@ MVMObject * MVM_string_split(MVMThreadContext *tc, MVMString *separator, MVMStri
             /* XXX make this use the dual-traverse iterator, but such that it
                 can reset the index of what it's comparing... <!> */
             index = MVM_string_index(tc, input, separator, start);
-            length = sep_length ? (index == -1 ? end : index) - start : 1;
+            length = sep_length ? (index == (MVMStringIndex)-1 ? end : index) - start : 1;
             if (0 < length || (sep_length && length == 0)) {
                 portion = MVM_string_substring(tc, input, start, length);
                 MVMROOT(tc, portion, {

src/strings/unicode_db.c

@@ -75045,7 +75045,7 @@ static const char *bogus = "<BOGUS>"; /* only for table too short; return null s
 static const char* MVM_unicode_get_property_str(MVMThreadContext *tc, MVMint64 codepoint, MVMint64 property_code) {
     MVMuint32 switch_val = (MVMuint32)property_code;
     MVMint32 result_val = 0; /* we'll never have negatives, but so */
-    MVMuint32 codepoint_row;
+    MVMint32 codepoint_row;
     MVMuint16 bitfield_row = 0;
 
     if (switch_val == MVM_UNICODE_PROPERTY_BLOCK) {
@@ -75167,7 +75167,7 @@ static const char* MVM_unicode_get_property_str(MVMThreadContext *tc, MVMint64 c
 
 static MVMint32 MVM_unicode_get_property_int(MVMThreadContext *tc, MVMint64 codepoint, MVMint64 property_code) {
     MVMint32 result_val = 0; /* we'll never have negatives, but so */
-    MVMuint32 codepoint_row = MVM_codepoint_to_row_index(tc, codepoint);
+    MVMint32 codepoint_row = MVM_codepoint_to_row_index(tc, codepoint);
     MVMuint16 bitfield_row;
     /* If codepoint is not found in bitfield rows */
     if (codepoint_row == -1) {

src/strings/unicode_ops.c

@@ -700,7 +700,7 @@ MVMGrapheme32 MVM_unicode_lookup_by_name(MVMThreadContext *tc, MVMString *name)
         };
         int i;
         for (i = 0; i < prefixes_len; i++) {
-            int str_len = strlen(prefixes[i]);
+            size_t str_len = strlen(prefixes[i]);
             if (cname_len <= str_len)
                 continue;
             /* Make sure to catch conditions which strtoll is ok with but we
@@ -713,7 +713,7 @@ MVMGrapheme32 MVM_unicode_lookup_by_name(MVMThreadContext *tc, MVMString *name)
             if (!strncmp(cname, prefixes[i], str_len)) {
                 char *reject = NULL;
                 MVMint64 rtrn = strtol(cname + strlen(prefixes[i]), &reject, 16);
-                if (prefixes[i][0] == '<' && *reject == '>' && reject - cname + 1 == cname_len) {
+                if (prefixes[i][0] == '<' && *reject == '>' && (size_t)(reject - cname + 1) == cname_len) {
                     MVM_free(cname);
                     return rtrn;
                 }
@@ -752,7 +752,7 @@ MVMString * MVM_unicode_get_name(MVMThreadContext *tc, MVMint64 codepoint) {
         name_len = strlen(name);
     /* Look up name. */
     else {
-        MVMuint32 codepoint_row = MVM_codepoint_to_row_index(tc, codepoint);
+        MVMint32 codepoint_row = MVM_codepoint_to_row_index(tc, codepoint);
         if (codepoint_row != -1) {
             name = codepoint_names[codepoint_row];
             if (!name) {

src/strings/utf8_c8.c

@@ -86,7 +86,7 @@ static unsigned classify(MVMCodepoint cp) {
     return 0;
 }
 
-static MVMint32 utf8_encode(MVMuint8 *bp, MVMCodepoint cp) {
+static MVMuint32 utf8_encode(MVMuint8 *bp, MVMCodepoint cp) {
     unsigned cc = classify(cp);
 
     if (!(cc & (CP_CHAR | CP_NONCHAR)))
@@ -194,7 +194,7 @@ typedef struct {
 
     /* Bad bytes from an earlier buffer, for the sake of streaming decode. */
     MVMuint8 prev_bad_bytes[4];
-    MVMint32 num_prev_bad_bytes;
+    MVMuint32 num_prev_bad_bytes;
 } DecodeState;
 
 /* Appends a single grapheme to the buffer if it will not cause a mismatch
@@ -241,7 +241,7 @@ static int append_grapheme(MVMThreadContext *tc, DecodeState *state, MVMGrapheme
         for (i = state->orig_codes_unnormalized; i < state->orig_codes_pos; i++) {
             MVMCodepoint to_encode = state->orig_codes[i];
             MVMuint8 encoded[4];
-            MVMint32 bytes = utf8_encode(encoded, to_encode);
+            MVMuint32 bytes = utf8_encode(encoded, to_encode);
             for (j = 0; j < bytes; j++)
                 state->result[state->result_pos++] = synthetic_for(tc, encoded[j]);
         }
@@ -417,7 +417,7 @@ MVMString * MVM_string_utf8_c8_decode(MVMThreadContext *tc, const MVMObject *res
 /* Decodes using a decodestream. Decodes as far as it can with the input
  * buffers, or until a stopper is reached. */
 MVMuint32 MVM_string_utf8_c8_decodestream(MVMThreadContext *tc, MVMDecodeStream *ds,
-                                     const MVMint32 *stopper_chars,
+                                     const MVMuint32 *stopper_chars,
                                      MVMDecodeStreamSeparators *seps,
                                      MVMint32 eof) {
     /* Local state for decode loop. */
@@ -467,7 +467,7 @@ MVMuint32 MVM_string_utf8_c8_decodestream(MVMThreadContext *tc, MVMDecodeStream
     reached_stopper = 0;
     while (cur_bytes && !reached_stopper) {
         /* Set up decode state for this buffer. */
-        MVMint32 bytes = cur_bytes->length;
+        MVMuint32 bytes = cur_bytes->length;
         /* Space for graphemes we have + 1 grapheme we receive from last buffer */
         state.result = MVM_malloc((bytes + 1) * sizeof(MVMGrapheme32));
         state.orig_codes = MVM_realloc(state.orig_codes,
@@ -577,7 +577,7 @@ MVMuint32 MVM_string_utf8_c8_decodestream(MVMThreadContext *tc, MVMDecodeStream
         /* If there were bytes we didn't accept, hold on to them in case we
          * need to emit them as bad bytes. */
         if (state.unaccepted_start != state.cur_byte && cur_bytes->next) {
-            int i;
+            size_t i;
             for (i = state.unaccepted_start; i < state.cur_byte; i++)
                 state.prev_bad_bytes[state.num_prev_bad_bytes++] = state.utf8[i];
         }
@@ -609,7 +609,7 @@ MVMuint32 MVM_string_utf8_c8_decodestream(MVMThreadContext *tc, MVMDecodeStream
 static void emit_cp(MVMThreadContext *tc, MVMCodepoint cp, MVMuint8 **result,
                     size_t *result_pos, size_t *result_limit,
                     MVMuint8 *repl_bytes, MVMuint64 repl_length) {
-    MVMint32 bytes;
+    MVMuint32 bytes;
     if (*result_pos >= *result_limit) {
         *result_limit *= 2;
         *result = MVM_realloc(*result, *result_limit + 4);

src/strings/utf8_c8.h

@@ -1,5 +1,5 @@
 MVM_PUBLIC MVMString * MVM_string_utf8_c8_decode(MVMThreadContext *tc, const MVMObject *result_type, const char *utf8, size_t bytes);
-MVM_PUBLIC MVMuint32 MVM_string_utf8_c8_decodestream(MVMThreadContext *tc, MVMDecodeStream *ds, const MVMint32 *stopper_chars, MVMDecodeStreamSeparators *seps, MVMint32 eof);
+MVM_PUBLIC MVMuint32 MVM_string_utf8_c8_decodestream(MVMThreadContext *tc, MVMDecodeStream *ds, const MVMuint32 *stopper_chars, MVMDecodeStreamSeparators *seps, MVMint32 eof);
 MVM_PUBLIC char * MVM_string_utf8_c8_encode_substr(MVMThreadContext *tc,
         MVMString *str, MVMuint64 *output_size, MVMint64 start, MVMint64 length, MVMString *replacement);
 MVM_PUBLIC char * MVM_string_utf8_c8_encode(MVMThreadContext *tc, MVMString *str, MVMuint64 *output_size);

src/strings/windows1252.c

@@ -501,7 +501,7 @@ MVMString * MVM_string_windows125X_decode(MVMThreadContext *tc,
                 /* Since things we are decoding always fit into Unicode, if we are
                  * using a replacement, it won't get used unless we use strict */
                 if (replacement && MVM_ENCODING_CONFIG_STRICT(config)) {
-                    int i = 0;
+                    MVMStringIndex i = 0;
                     /* Only triggered if repl_length > 1. Copies all but the last
                      * grapheme in the replacement string */
                     if (1 < repl_length) {

tools/ucd2c.pl

@@ -911,7 +911,7 @@ sub emit_property_value_lookup {
 
 static MVMint32 MVM_unicode_get_property_int(MVMThreadContext *tc, MVMint64 codepoint, MVMint64 property_code) {
     MVMint32 result_val = 0; /* we'll never have negatives, but so */
-    MVMuint32 codepoint_row = MVM_codepoint_to_row_index(tc, codepoint);
+    MVMint32 codepoint_row = MVM_codepoint_to_row_index(tc, codepoint);
     MVMuint16 bitfield_row;
     /* If codepoint is not found in bitfield rows */
     if (codepoint_row == -1) {
@@ -935,7 +935,7 @@ END
 static const char* MVM_unicode_get_property_str(MVMThreadContext *tc, MVMint64 codepoint, MVMint64 property_code) {
     MVMuint32 switch_val = (MVMuint32)property_code;
     MVMint32 result_val = 0; /* we'll never have negatives, but so */
-    MVMuint32 codepoint_row;
+    MVMint32 codepoint_row;
     MVMuint16 bitfield_row = 0;
 
     if (switch_val == MVM_UNICODE_PROPERTY_BLOCK) {