From d35f97f6f1ce5c367eb7dd0e780ff7f1dfbdc38c Mon Sep 17 00:00:00 2001 From: Al Date: Mon, 29 Feb 2016 22:36:00 -0500 Subject: [PATCH] [fix] All file_read_uint64 calls that use stack variables read into a uint64_t not a size_t so as not to smash the stack under a 32-bit arch (issue #18) --- src/address_dictionary.c | 10 ++- src/geodb.c | 12 +-- src/matrix.c | 18 +++-- src/numex.c | 52 ++++++------- src/sparse_matrix.c | 2 +- src/transliterate.c | 161 +++++++++++++++++++++------------------ src/trie.c | 44 +++++------ src/trie.h | 2 +- 8 files changed, 162 insertions(+), 139 deletions(-) diff --git a/src/address_dictionary.c b/src/address_dictionary.c index fafe7f1c..0d730d7f 100644 --- a/src/address_dictionary.c +++ b/src/address_dictionary.c @@ -49,7 +49,7 @@ bool address_dictionary_add_expansion(char *name, char *language, address_expans bool is_suffix = false; bool is_phrase = false; - for (int i = 0; i < expansion.num_dictionaries; i++) { + for (size_t i = 0; i < expansion.num_dictionaries; i++) { dictionary_type_t dict = expansion.dictionary_ids[i]; if (dict == DICTIONARY_CONCATENATED_SUFFIX_SEPARABLE || dict == DICTIONARY_CONCATENATED_SUFFIX_INSEPARABLE) { @@ -93,6 +93,7 @@ bool address_dictionary_add_expansion(char *name, char *language, address_expans expansions = address_expansion_array_new_size(1); address_expansion_array_push(expansions, expansion); khiter_t k = kh_put(str_expansions, address_dict->expansions, strdup(key), &ret); + if (ret < 0) goto exit_key_created; kh_value(address_dict->expansions, k) = expansions; value.count = 1; @@ -309,7 +310,7 @@ static bool address_expansion_read(FILE *f, address_expansion_t *expansion) { return false; } - for (int i = 0; i < expansion->num_dictionaries; i++) { + for (size_t i = 0; i < expansion->num_dictionaries; i++) { if (!file_read_uint16(f, (uint16_t *)expansion->dictionary_ids + i)) { return false; } @@ -340,7 +341,7 @@ static bool address_expansion_write(FILE *f, address_expansion_t expansion) { return false; } - for (int i = 0; i < expansion.num_dictionaries; i++) { + for (size_t i = 0; i < expansion.num_dictionaries; i++) { if (!file_write_uint16(f, expansion.dictionary_ids[i])) { return false; } @@ -399,7 +400,7 @@ bool address_dictionary_write(FILE *f) { } - for (int i = 0; i < num_expansions; i++) { + for (size_t i = 0; i < num_expansions; i++) { address_expansion_t expansion = expansions->a[i]; if (!address_expansion_write(f, expansion)) { return false; @@ -500,6 +501,7 @@ bool address_dictionary_read(FILE *f) { int ret; khiter_t k = kh_put(str_expansions, address_dict->expansions, key, &ret); + if (ret < 0) goto exit_address_dict_created; kh_value(address_dict->expansions, k) = expansions; } diff --git a/src/geodb.c b/src/geodb.c index 214ed533..11e4b12f 100644 --- a/src/geodb.c +++ b/src/geodb.c @@ -80,23 +80,23 @@ geodb_t *geodb_init(char *dir) { FILE *f = fopen(postal_codes_path, "rb"); uint64_t num_postal_strings = 0; - if (!file_read_uint64(f, (uint64_t *)&num_postal_strings)) { + if (!file_read_uint64(f, &num_postal_strings)) { goto exit_geodb_created; } - size_t postal_codes_str_len; + uint64_t postal_codes_str_len; - if (!file_read_uint64(f, (uint64_t *)&postal_codes_str_len)) { + if (!file_read_uint64(f, &postal_codes_str_len)) { goto exit_geodb_created; } - char_array *array = char_array_new_size(postal_codes_str_len); + char_array *array = char_array_new_size((size_t)postal_codes_str_len); - if (!file_read_chars(f, array->a, postal_codes_str_len)) { + if (!file_read_chars(f, array->a, (size_t)postal_codes_str_len)) { goto exit_geodb_created; } - array->n = postal_codes_str_len; + array->n = (size_t)postal_codes_str_len; gdb->postal_codes = cstring_array_from_char_array(array); diff --git a/src/matrix.c b/src/matrix.c index 05cb4417..61b3fa25 100644 --- a/src/matrix.c +++ b/src/matrix.c @@ -254,12 +254,18 @@ matrix_t *matrix_read(FILE *f) { mat->values = NULL; - if (!file_read_uint64(f, (uint64_t *)&mat->m) || - !file_read_uint64(f, (uint64_t *)&mat->n)) { + uint64_t m = 0; + uint64_t n = 0; + + if (!file_read_uint64(f, &m) || + !file_read_uint64(f, &n)) { goto exit_matrix_allocated; } - size_t len_data = (size_t)mat->m * (size_t)mat->n; + mat->m = (size_t)m; + mat->n = (size_t)n; + + size_t len_data = mat->m * mat->n; double *data = malloc(len_data * sizeof(double)); if (data == NULL) { @@ -286,14 +292,14 @@ bool matrix_write(matrix_t *self, FILE *f) { return false; } - if (!file_write_uint64(f, self->m) || - !file_write_uint64(f, self->n)) { + if (!file_write_uint64(f, (uint64_t)self->m) || + !file_write_uint64(f, (uint64_t)self->n)) { return false; } uint64_t len_data = (uint64_t)self->m * (uint64_t)self->n; - for (int i = 0; i < len_data; i++) { + for (uint64_t i = 0; i < len_data; i++) { if (!file_write_double(f, self->values[i])) { return false; } diff --git a/src/numex.c b/src/numex.c index 7fa7fca7..72dc1e06 100644 --- a/src/numex.c +++ b/src/numex.c @@ -139,9 +139,9 @@ numex_language_t *get_numex_language(char *name) { } static numex_language_t *numex_language_read(FILE *f) { - size_t lang_name_len; + uint64_t lang_name_len; - if (!file_read_uint64(f, (uint64_t *)&lang_name_len)) { + if (!file_read_uint64(f, &lang_name_len)) { return NULL; } @@ -159,27 +159,27 @@ static numex_language_t *numex_language_read(FILE *f) { return NULL; } - size_t rules_index; - if (!file_read_uint64(f, (uint64_t *)&rules_index)) { + uint64_t rules_index; + if (!file_read_uint64(f, &rules_index)) { return NULL; } - size_t num_rules; - if (!file_read_uint64(f, (uint64_t *)&num_rules)) { + uint64_t num_rules; + if (!file_read_uint64(f, &num_rules)) { return NULL; } - size_t ordinals_index; - if (!file_read_uint64(f, (uint64_t *)&ordinals_index)) { + uint64_t ordinals_index; + if (!file_read_uint64(f, &ordinals_index)) { return NULL; } - size_t num_ordinals; - if (!file_read_uint64(f, (uint64_t *)&num_ordinals)) { + uint64_t num_ordinals; + if (!file_read_uint64(f, &num_ordinals)) { return NULL; } - numex_language_t *language = numex_language_new(name, whole_tokens_only, rules_index, num_rules, ordinals_index, num_ordinals); + numex_language_t *language = numex_language_new(name, whole_tokens_only, (size_t)rules_index, (size_t)num_rules, (size_t)ordinals_index, (size_t)num_ordinals); return language; @@ -323,8 +323,8 @@ ordinal_indicator_t *ordinal_indicator_new(char *key, gender_t gender, grammatic } static ordinal_indicator_t *ordinal_indicator_read(FILE *f) { - size_t key_len; - if (!file_read_uint64(f, (uint64_t *)&key_len)) { + uint64_t key_len; + if (!file_read_uint64(f, &key_len)) { return NULL; } @@ -347,12 +347,12 @@ static ordinal_indicator_t *ordinal_indicator_read(FILE *f) { return NULL; } - size_t ordinal_suffix_len; - if (!file_read_uint64(f, (uint64_t *)&ordinal_suffix_len)) { + uint64_t ordinal_suffix_len; + if (!file_read_uint64(f, &ordinal_suffix_len)) { return NULL; } - char *ordinal_suffix = malloc(ordinal_suffix_len); + char *ordinal_suffix = malloc((size_t)ordinal_suffix_len); if (ordinal_suffix == NULL) { return NULL; } @@ -367,7 +367,7 @@ static ordinal_indicator_t *ordinal_indicator_read(FILE *f) { bool ordinal_indicator_write(ordinal_indicator_t *ordinal, FILE *f) { size_t key_len = strlen(ordinal->key) + 1; - if (!file_write_uint64(f, key_len) || + if (!file_write_uint64(f, (uint64_t)key_len) || !file_write_chars(f, ordinal->key, key_len)) { return false; } @@ -381,7 +381,7 @@ bool ordinal_indicator_write(ordinal_indicator_t *ordinal, FILE *f) { } size_t name_len = strlen(ordinal->suffix) + 1; - if (!file_write_uint64(f, name_len) || + if (!file_write_uint64(f, (uint64_t)name_len) || !file_write_chars(f, ordinal->suffix, name_len)) { return false; } @@ -409,13 +409,13 @@ bool numex_table_read(FILE *f) { log_debug("Numex table initialized\n"); - size_t num_languages; + uint64_t num_languages; - if (!file_read_uint64(f, (uint64_t *)&num_languages)) { + if (!file_read_uint64(f, &num_languages)) { goto exit_numex_table_load_error; } - log_debug("read num_languages = %zu\n", num_languages); + log_debug("read num_languages = %llu\n", num_languages); int i = 0; @@ -431,13 +431,13 @@ bool numex_table_read(FILE *f) { log_debug("read languages\n"); - size_t num_rules; + uint64_t num_rules; - if (!file_read_uint64(f, (uint64_t *)&num_rules)) { + if (!file_read_uint64(f, &num_rules)) { goto exit_numex_table_load_error; } - log_debug("read num_rules = %zu\n", num_rules); + log_debug("read num_rules = %llu\n", num_rules); numex_rule_t rule; @@ -450,9 +450,9 @@ bool numex_table_read(FILE *f) { log_debug("read rules\n"); - size_t num_ordinals; + uint64_t num_ordinals; - if (!file_read_uint64(f, (uint64_t *)&num_ordinals)) { + if (!file_read_uint64(f, &num_ordinals)) { goto exit_numex_table_load_error; } diff --git a/src/sparse_matrix.c b/src/sparse_matrix.c index 404eec97..dc9fa7fc 100644 --- a/src/sparse_matrix.c +++ b/src/sparse_matrix.c @@ -334,7 +334,7 @@ sparse_matrix_t *sparse_matrix_read(FILE *f) { goto exit_sparse_matrix_allocated; } - uint32_array *indptr = uint32_array_new_size(len_indptr); + uint32_array *indptr = uint32_array_new_size((size_t)len_indptr); if (indptr == NULL) { goto exit_sparse_matrix_allocated; } diff --git a/src/transliterate.c b/src/transliterate.c index fa890c73..a87dd42a 100644 --- a/src/transliterate.c +++ b/src/transliterate.c @@ -23,7 +23,7 @@ transliterator_t *transliterator_new(char *name, uint8_t internal, uint32_t step return NULL; } - trans->name = strdup(name); + trans->name = name; trans->internal = internal; trans->steps_index = steps_index; trans->steps_length = steps_length; @@ -1201,6 +1201,7 @@ bool transliteration_table_add_transliterator(transliterator_t *trans) { int ret; khiter_t k = kh_put(str_transliterator, trans_table->transliterators, trans->name, &ret); + if (ret < 0) return false; kh_value(trans_table->transliterators, k) = trans; return true; @@ -1213,6 +1214,7 @@ bool transliteration_table_add_script_language(script_language_t script_language int ret; khiter_t k = kh_put(script_language_index, trans_table->script_languages, script_language, &ret); + if (ret < 0) return false; kh_value(trans_table->script_languages, k) = index; return true; @@ -1249,9 +1251,9 @@ char *transliterator_replace_strings(trie_t *trie, cstring_array *replacements, } else { str = char_array_new_size(len); phrase_t phrase; - int start = 0; - int end = 0; - for (int i = 0; i < phrases->n; i++) { + size_t start = 0; + size_t end = 0; + for (size_t i = 0; i < phrases->n; i++) { phrase = phrases->a[i]; end = phrase.start; char_array_append_len(str, input + start, end - start); @@ -1276,14 +1278,16 @@ char *transliterator_replace_strings(trie_t *trie, cstring_array *replacements, } transliterator_t *transliterator_read(FILE *f) { - size_t trans_name_len; + uint64_t trans_name_len; - - if (!file_read_uint64(f, (uint64_t *)&trans_name_len)) { + if (!file_read_uint64(f, &trans_name_len)) { return NULL; } - char name[trans_name_len]; + char *name = malloc(trans_name_len); + if (name == NULL) { + return NULL; + } if (!file_read_chars(f, name, trans_name_len)) { return NULL; @@ -1313,7 +1317,7 @@ transliterator_t *transliterator_read(FILE *f) { bool transliterator_write(transliterator_t *trans, FILE *f) { size_t trans_name_len = strlen(trans->name) + 1; - if (!file_write_uint64(f, trans_name_len) || + if (!file_write_uint64(f, (uint64_t)trans_name_len) || !file_write_chars(f, trans->name, trans_name_len)) { return false; } @@ -1334,7 +1338,7 @@ bool transliterator_write(transliterator_t *trans, FILE *f) { } transliteration_step_t *transliteration_step_read(FILE *f) { - size_t step_name_len; + uint64_t step_name_len; log_debug("reading step\n");; @@ -1346,7 +1350,7 @@ transliteration_step_t *transliteration_step_read(FILE *f) { if (!file_read_uint32(f, &step->type)) { goto exit_step_destroy; } - if (!file_read_uint64(f, (uint64_t *) &step_name_len)) { + if (!file_read_uint64(f, &step_name_len)) { goto exit_step_destroy; } @@ -1376,7 +1380,7 @@ bool transliteration_step_write(transliteration_step_t *step, FILE *f) { // Include the NUL byte size_t step_name_len = strlen(step->name) + 1; - if (!file_write_uint64(f, step_name_len) || + if (!file_write_uint64(f, (uint64_t)step_name_len) || !file_write_chars(f, step->name, step_name_len)) { return false; } @@ -1385,13 +1389,18 @@ bool transliteration_step_write(transliteration_step_t *step, FILE *f) { } bool group_capture_read(FILE *f, group_capture_t *group) { - if (!file_read_uint64(f, (uint64_t *)&group->start)) { + uint64_t start; + if (!file_read_uint64(f, &start)) { + return false; + } + group->start = (size_t)start; + + uint64_t len; + if (!file_read_uint64(f, &len)) { return false; } - if (!file_read_uint64(f, (uint64_t *)&group->len)) { - return false; - } + group->len = (size_t)len; return true; } @@ -1418,18 +1427,18 @@ transliteration_replacement_t *transliteration_replacement_read(FILE *f) { return NULL; } - size_t num_groups; + uint64_t num_groups; - if (!file_read_uint64(f, (uint64_t *)&num_groups)) { + if (!file_read_uint64(f, &num_groups)) { return NULL; } group_capture_array *groups = NULL; if (num_groups > 0) { - groups = group_capture_array_new_size(num_groups); + groups = group_capture_array_new_size((size_t)num_groups); group_capture_t group; - for (int i = 0; i < num_groups; i++) { + for (size_t i = 0; i < (size_t)num_groups; i++) { if (!group_capture_read(f, &group)) { group_capture_array_destroy(groups); return NULL; @@ -1458,7 +1467,7 @@ bool transliteration_replacement_write(transliteration_replacement_t *replacemen group_capture_t group; - for (int i = 0; i < replacement->num_groups; i++) { + for (size_t i = 0; i < replacement->num_groups; i++) { group = replacement->groups->a[i]; if (!group_capture_write(group, f)) { return false; @@ -1486,20 +1495,20 @@ bool transliteration_table_read(FILE *f) { log_debug("Table initialized\n"); - size_t num_transliterators; + uint64_t num_transliterators = 0; - if (!file_read_uint64(f, (uint64_t *)&num_transliterators)) { + if (!file_read_uint64(f, &num_transliterators)) { goto exit_trans_table_load_error; } - log_debug("num_transliterators = %zu\n", num_transliterators); + log_debug("num_transliterators = %zu\n", (size_t)num_transliterators); - int i; + size_t i; transliterator_t *trans; - for (i = 0; i < num_transliterators; i++) { + for (i = 0; i < (size_t)num_transliterators; i++) { trans = transliterator_read(f); if (trans == NULL) { log_error("trans was NULL\n"); @@ -1514,69 +1523,75 @@ bool transliteration_table_read(FILE *f) { log_debug("Read transliterators\n"); - size_t num_script_languages; - if (!file_read_uint64(f, (uint64_t *)&num_script_languages)) { + uint64_t num_script_languages; + if (!file_read_uint64(f, &num_script_languages)) { goto exit_trans_table_load_error; } - log_debug("num_script_languages = %zu\n", num_script_languages); + log_debug("num_script_languages = %zu\n", (size_t)num_script_languages); script_language_t script_language; transliterator_index_t index; - size_t language_len = 0; + uint64_t language_len = 0; char language[MAX_LANGUAGE_LEN] = ""; + uint64_t transliterator_index = 0; + uint64_t index_num_transliterators = 0; + for (i = 0; i < num_script_languages; i++) { if (!file_read_uint32(f, (uint32_t *)&script_language.script)) { goto exit_trans_table_load_error; } - if (!file_read_uint64(f, (uint64_t *)&language_len) || language_len >= MAX_LANGUAGE_LEN) { + if (!file_read_uint64(f, &language_len) || language_len >= MAX_LANGUAGE_LEN) { goto exit_trans_table_load_error; } if (language_len == 0) { script_language.language[0] = '\0'; - } else if (!file_read_chars(f, (char *)language, language_len)) { + } else if (!file_read_chars(f, (char *)language, (size_t)language_len)) { goto exit_trans_table_load_error; } else { strcpy(script_language.language, language); } - - if (!file_read_uint64(f, (uint64_t *)&index.transliterator_index)) { - goto exit_trans_table_load_error; - } - - if (!file_read_uint64(f, (uint64_t *)&index.num_transliterators)) { + if (!file_read_uint64(f, &transliterator_index)) { goto exit_trans_table_load_error; } + index.transliterator_index = (size_t)transliterator_index; + + if (!file_read_uint64(f, &index_num_transliterators)) { + goto exit_trans_table_load_error; + } + + index.num_transliterators = (size_t)index_num_transliterators; + log_debug("Adding script language key={%d, %s}, value={%zu, %zu}\n", script_language.script, script_language.language, index.transliterator_index, index.num_transliterators); transliteration_table_add_script_language(script_language, index); } - size_t trans_table_num_strings; + uint64_t trans_table_num_strings; - if (!file_read_uint64(f, (uint64_t *)&trans_table_num_strings)) { + if (!file_read_uint64(f, &trans_table_num_strings)) { goto exit_trans_table_load_error; } - log_debug("trans_table_num_strings=%zu\n", trans_table_num_strings); + log_debug("trans_table_num_strings=%zu\n", (size_t)trans_table_num_strings); - size_t trans_name_str_len; + uint64_t trans_name_str_len; - if (!file_read_uint64(f, (uint64_t *)&trans_name_str_len)) { + if (!file_read_uint64(f, &trans_name_str_len)) { goto exit_trans_table_load_error; } - log_debug("Creating char_array with size=%zu\n", trans_name_str_len); + log_debug("Creating char_array with size=%zu\n", (size_t)trans_name_str_len); - char_array *array = char_array_new_size(trans_name_str_len); + char_array *array = char_array_new_size((size_t)trans_name_str_len); - if (!file_read_chars(f, array->a, trans_name_str_len)) { + if (!file_read_chars(f, array->a, (size_t)trans_name_str_len)) { goto exit_trans_table_load_error; } @@ -1594,15 +1609,15 @@ bool transliteration_table_read(FILE *f) { goto exit_trans_table_load_error; } - size_t num_steps; + uint64_t num_steps; - if (!file_read_uint64(f, (uint64_t *)&num_steps)) { + if (!file_read_uint64(f, &num_steps)) { goto exit_trans_table_load_error; } - log_debug("num_steps = %zu\n", num_steps); + log_debug("num_steps = %zu\n", (size_t)num_steps); - step_array_resize(trans_table->steps, num_steps); + step_array_resize(trans_table->steps, (size_t)num_steps); log_debug("resized\n"); @@ -1621,15 +1636,15 @@ bool transliteration_table_read(FILE *f) { transliteration_replacement_t *replacement; - size_t num_replacements; + uint64_t num_replacements; - if (!file_read_uint64(f, (uint64_t *)&num_replacements)) { + if (!file_read_uint64(f, &num_replacements)) { goto exit_trans_table_load_error; } - log_debug("num_replacements = %zu\n", num_replacements); + log_debug("num_replacements = %zu\n", (size_t)num_replacements); - transliteration_replacement_array_resize(trans_table->replacements, num_replacements); + transliteration_replacement_array_resize(trans_table->replacements, (size_t)num_replacements); log_debug("resized\n"); @@ -1643,15 +1658,15 @@ bool transliteration_table_read(FILE *f) { log_debug("Done with replacements\n"); - size_t num_replacement_tokens; + uint64_t num_replacement_tokens; - if (!file_read_uint64(f, (uint64_t *)&num_replacement_tokens)) { + if (!file_read_uint64(f, &num_replacement_tokens)) { goto exit_trans_table_load_error; } - log_debug("num_replacement_tokens = %zu\n", num_replacement_tokens); + log_debug("num_replacement_tokens = %zu\n", (size_t)num_replacement_tokens); - uint32_array_resize(trans_table->replacement_strings->indices, num_replacement_tokens); + uint32_array_resize(trans_table->replacement_strings->indices, (size_t)num_replacement_tokens); log_debug("resized\n"); @@ -1666,19 +1681,19 @@ bool transliteration_table_read(FILE *f) { log_debug("Done with replacement token indices\n"); - size_t replacement_strings_len; + uint64_t replacement_strings_len; - if (!file_read_uint64(f, (uint64_t *)&replacement_strings_len)) { + if (!file_read_uint64(f, &replacement_strings_len)) { goto exit_trans_table_load_error; } - log_debug("replacement_strings_len = %zu\n", replacement_strings_len); + log_debug("replacement_strings_len = %zu\n", (size_t)replacement_strings_len); - char_array_resize(trans_table->replacement_strings->str, replacement_strings_len); + char_array_resize(trans_table->replacement_strings->str, (size_t)replacement_strings_len); log_debug("resized\n"); - if (!file_read_chars(f, trans_table->replacement_strings->str->a, replacement_strings_len)) { + if (!file_read_chars(f, trans_table->replacement_strings->str->a, (size_t)replacement_strings_len)) { goto exit_trans_table_load_error; } @@ -1686,15 +1701,15 @@ bool transliteration_table_read(FILE *f) { trans_table->replacement_strings->str->n = replacement_strings_len; - size_t num_revisit_tokens; + uint64_t num_revisit_tokens; - if (!file_read_uint64(f, (uint64_t *)&num_revisit_tokens)) { + if (!file_read_uint64(f, &num_revisit_tokens)) { goto exit_trans_table_load_error; } - log_debug("num_revisit_tokens = %zu\n", num_revisit_tokens); + log_debug("num_revisit_tokens = %zu\n", (size_t)num_revisit_tokens); - uint32_array_resize(trans_table->revisit_strings->indices, num_revisit_tokens); + uint32_array_resize(trans_table->revisit_strings->indices, (size_t)num_revisit_tokens); log_debug("resized\n"); @@ -1707,19 +1722,19 @@ bool transliteration_table_read(FILE *f) { log_debug("Done with revisit token indices\n"); - size_t revisit_strings_len = 0; + uint64_t revisit_strings_len = 0; - if (!file_read_uint64(f, (uint64_t *)&revisit_strings_len)) { + if (!file_read_uint64(f, &revisit_strings_len)) { goto exit_trans_table_load_error; } - log_debug("revisit_strings_len = %zu\n", revisit_strings_len); + log_debug("revisit_strings_len = %zu\n", (size_t)revisit_strings_len); - char_array_resize(trans_table->revisit_strings->str, revisit_strings_len); + char_array_resize(trans_table->revisit_strings->str, (size_t)revisit_strings_len); log_debug("resized\n"); - if (!file_read_chars(f, trans_table->revisit_strings->str->a, revisit_strings_len)) { + if (!file_read_chars(f, trans_table->revisit_strings->str->a, (size_t)revisit_strings_len)) { goto exit_trans_table_load_error; } @@ -1766,7 +1781,7 @@ bool transliteration_table_write(FILE *f) { } }) - int i; + size_t i; size_t num_script_languages = kh_size(trans_table->script_languages); diff --git a/src/trie.c b/src/trie.c index f9206de8..9427ce48 100644 --- a/src/trie.c +++ b/src/trie.c @@ -215,7 +215,7 @@ static bool trie_node_has_children(trie_t *self, uint32_t node_id) { for (int i = 0; i < self->alphabet_size; i++) { unsigned char c = self->alphabet[i]; index = trie_get_transition_index(self, node, c); - if (index < self->nodes->n && trie_get_node(self, index).check == node_id) + if (index < self->nodes->n && (uint32_t)trie_get_node(self, index).check == node_id) return true; } return false; @@ -252,8 +252,8 @@ static void trie_get_transition_chars(trie_t *self, uint32_t node_id, unsigned c } -static bool trie_can_fit_transitions(trie_t *self, uint32_t node_id, unsigned char *transitions, int num_transitions) { - int i; +static bool trie_can_fit_transitions(trie_t *self, uint32_t node_id, unsigned char *transitions, uint32_t num_transitions) { + uint32_t i; uint32_t char_index, index; for (i = 0; i < num_transitions; i++) { @@ -270,7 +270,7 @@ static bool trie_can_fit_transitions(trie_t *self, uint32_t node_id, unsigned ch } -static uint32_t trie_find_new_base(trie_t *self, unsigned char *transitions, int num_transitions) { +static uint32_t trie_find_new_base(trie_t *self, unsigned char *transitions, uint32_t num_transitions) { uint32_t first_char_index = trie_get_char_index(self, transitions[0]); trie_node_t node = trie_get_free_list(self); @@ -324,7 +324,7 @@ static size_t trie_required_size(trie_t *self, uint32_t index) { static void trie_relocate_base(trie_t *self, uint32_t current_index, int32_t new_base) { log_debug("Relocating base at %d\n", current_index); - int i; + uint32_t i; trie_make_room_for(self, new_base); @@ -353,7 +353,7 @@ static void trie_relocate_base(trie_t *self, uint32_t current_index, int32_t new * set check values appropriately */ if (old_transition.base > 0) { // do nothing in the case of a tail pointer - for (int i = 0; i < self->alphabet_size; i++) { + for (i = 0; i < self->alphabet_size; i++) { unsigned char c = self->alphabet[i]; uint32_t index = trie_get_transition_index(self, old_transition, c); if (index < self->nodes->n && trie_get_node(self, index).check == old_index) { @@ -521,7 +521,7 @@ void trie_tail_merge(trie_t *self, uint32_t old_node_id, unsigned char *suffix, uint32_t node_id = old_node_id; log_debug("common_prefix=%zu\n", common_prefix); - for (int i=0; i < common_prefix; i++) { + for (size_t i = 0; i < common_prefix; i++) { c = old_tail[i]; log_debug("merge tail, c=%c, node_id=%d\n", c, node_id); next_id = trie_add_transition(self, node_id, c); @@ -559,7 +559,7 @@ exit_prune: void trie_print(trie_t *self) { printf("Trie\n"); printf("num_nodes=%zu, alphabet_size=%d\n\n", self->nodes->n, self->alphabet_size); - for (int i = 0; i < self->nodes->n; i++) { + for (size_t i = 0; i < self->nodes->n; i++) { int32_t base = self->nodes->a[i].base; int32_t check = self->nodes->a[i].check; @@ -572,23 +572,23 @@ void trie_print(trie_t *self) { } printf("\n"); - for (int i = 0; i < self->nodes->n; i++) { + for (size_t i = 0; i < self->nodes->n; i++) { int32_t base = self->nodes->a[i].base; int32_t check = self->nodes->a[i].check; - int check_width = abs(check) > 9 ? (int) log10(abs(check))+1 : 1; - int base_width = abs(base) > 9 ? (int) log10(abs(base))+1 : 1; + int check_width = abs(check) > 9 ? (int) log10(abs(check)) + 1 : 1; + int base_width = abs(base) > 9 ? (int) log10(abs(base)) + 1 : 1; if (base < 0) base_width++; if (check < 0) check_width++; int width = base_width > check_width ? base_width : check_width; printf("%*d ", width, check); } printf("\n"); - for (int i = 0; i < self->tail->n; i++) { + for (size_t i = 0; i < self->tail->n; i++) { printf("%c ", self->tail->a[i]); } printf("\n"); - for (int i = 0; i < self->data->n; i++) { + for (size_t i = 0; i < self->data->n; i++) { uint32_t tail = self->data->a[i].tail; uint32_t data = self->data->a[i].data; @@ -600,7 +600,7 @@ void trie_print(trie_t *self) { } printf("\n"); - for (int i = 0; i < self->data->n; i++) { + for (size_t i = 0; i < self->data->n; i++) { uint32_t tail = self->data->a[i].tail; uint32_t data = self->data->a[i].data; @@ -632,7 +632,7 @@ bool trie_add_at_index(trie_t *self, uint32_t node_id, char *key, size_t len, ui // Walks node until prefix reached, including the trailing \0 - for (int i = 0; i < len; ptr++, i++, last_node_id = node_id, last_node = node) { + for (size_t i = 0; i < len; ptr++, i++, last_node_id = node_id, last_node = node) { log_debug("--- char=%d\n", *ptr); node_id = trie_get_transition_index(self, last_node, *ptr); @@ -794,7 +794,7 @@ trie_prefix_result_t trie_get_prefix_from_index(trie_t *self, char *key, size_t bool original_node_no_tail = node.base >= 0; - int i = 0; + size_t i = 0; if (node.base >= 0) { // Include NUL-byte. It may be stored if this phrase is a prefix of a longer one @@ -854,7 +854,7 @@ uint32_t trie_get_from_index(trie_t *self, char *word, size_t len, uint32_t i) { // Include NUL-byte. It may be stored if this phrase is a prefix of a longer one - for (int i = 0; i < len + 1; i++, ptr++, node_id = next_id) { + for (size_t i = 0; i < len + 1; i++, ptr++, node_id = next_id) { next_id = trie_get_transition_index(self, node, *ptr); node = trie_get_node(self, next_id); @@ -922,14 +922,14 @@ I/O methods bool trie_write(trie_t *self, FILE *file) { if (!file_write_uint32(file, TRIE_SIGNATURE) || - !file_write_uint32(file, (uint32_t)self->alphabet_size)|| - !file_write_chars(file, (char *)self->alphabet, self->alphabet_size) || + !file_write_uint32(file, self->alphabet_size)|| + !file_write_chars(file, (char *)self->alphabet, (size_t)self->alphabet_size) || !file_write_uint32(file, self->num_keys) || !file_write_uint32(file, (uint32_t)self->nodes->n)) { return false; } - - int i; + + size_t i; trie_node_t node; for (i = 0; i < self->nodes->n; i++) { @@ -977,7 +977,7 @@ bool trie_save(trie_t *self, char *path) { } trie_t *trie_read(FILE *file) { - int i; + uint32_t i; long save_pos = ftell(file); diff --git a/src/trie.h b/src/trie.h index 4582fd91..d2f8519e 100644 --- a/src/trie.h +++ b/src/trie.h @@ -74,7 +74,7 @@ typedef struct trie { uchar_array *tail; char *alphabet; uint8_t alpha_map[NUM_CHARS]; - int alphabet_size; + uint32_t alphabet_size; uint32_t num_keys; } trie_t;