Пример #1
0
bool address_dictionary_write(FILE *f) {
    if (address_dict == NULL || f == NULL) return false;

    if (!file_write_uint32(f, ADDRESS_DICTIONARY_SIGNATURE)) {
        return false;
    }

    uint32_t canonical_str_len = (uint32_t) cstring_array_used(address_dict->canonical);
    if (!file_write_uint32(f, canonical_str_len)) {
        return false;
    }

    if (!file_write_chars(f, address_dict->canonical->str->a, canonical_str_len)) {
        return false;
    }

    uint32_t num_values = (uint32_t) address_dict->values->n;

    if (!file_write_uint32(f, num_values)) {
        return false;
    }

    for (size_t i = 0; i < num_values; i++) {
        address_expansion_value_t *value = address_dict->values->a[i];
        if (!address_expansion_value_write(value, f)) {
            return false;
        }
    }

    if (!trie_write(address_dict->trie, f)) {
        return false;
    }

    return true;
}
Пример #2
0
int
tail_write (const Tail *t, FILE *file)
{
    TrieIndex   i;

    if (!file_write_int32 (file, TAIL_SIGNATURE) ||
        !file_write_int32 (file, t->first_free)  ||
        !file_write_int32 (file, t->num_tails))
    {
        return -1;
    }
    for (i = 0; i < t->num_tails; i++) {
        int16   length;

        if (!file_write_int32 (file, t->tails[i].next_free) ||
            !file_write_int32 (file, t->tails[i].data))
        {
            return -1;
        }

        length = t->tails[i].suffix ? strlen ((const char *)t->tails[i].suffix)
                                    : 0;
        if (!file_write_int16 (file, length))
            return -1;
        if (length > 0 &&
            !file_write_chars (file, (char *)t->tails[i].suffix, length))
        {
            return -1;
        }
    }

    return 0;
}
Пример #3
0
static bool address_expansion_write(address_expansion_t expansion, FILE *f) {
    if (f == NULL) return false;

    uint32_t language_len = (uint32_t)strlen(expansion.language) + 1;

    if (!file_write_uint32(f, (uint32_t)expansion.canonical_index) ||
        !file_write_uint32(f, language_len) ||
        !file_write_chars(f, expansion.language, language_len) ||
        !file_write_uint32(f, expansion.num_dictionaries)
       ) {
        return false;
    }

    for (size_t i = 0; i < expansion.num_dictionaries; i++) {
        if (!file_write_uint16(f, expansion.dictionary_ids[i])) {
            return false;
        }
    }

    if (!file_write_uint32(f, expansion.address_components)) {
        return false;
    }

    if (!file_write_uint8(f, expansion.separable)) {
        return false;
    }

    return true;
}
Пример #4
0
int
tail_save (Tail *t)
{
    TrieIndex   i;

    if (!t->is_dirty)
        return 0;

    rewind (t->file);
    if (!file_write_int16 (t->file, TAIL_SIGNATURE) ||
        !file_write_int16 (t->file, t->first_free)  ||
        !file_write_int16 (t->file, t->num_tails))
    {
        return -1;
    }
    for (i = 0; i < t->num_tails; i++) {
        int8    length;

        if (!file_write_int16 (t->file, t->tails[i].next_free) ||
            !file_write_int16 (t->file, t->tails[i].data))
        {
            return -1;
        }

        length = t->tails[i].suffix ? strlen ((const char *)t->tails[i].suffix)
                                    : 0;
        if (!file_write_int8 (t->file, length))
            return -1;
        if (length > 0 &&
            !file_write_chars (t->file, (char *)t->tails[i].suffix, length))
        {
            return -1;
        }
    }
    t->is_dirty = FALSE;

    return 0;
}