tommy/libpostal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[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)

Browse Source
This commit is contained in:
Al
2016-02-29 22:36:00 -05:00
parent 3aba78d806
commit d35f97f6f1
8 changed files with 162 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/address_dictionary.c
View File

@@ -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;
}

12
src/geodb.c
View File

@@ -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);

18
src/matrix.c
View File

@@ -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;
}

52
src/numex.c
View File

@@ -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;
}

2
src/sparse_matrix.c
View File

@@ -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;
}

161
src/transliterate.c
View File

@@ -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);

44
src/trie.c
View File

@@ -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);

2
src/trie.h
View File

@@ -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;