isomorfeus-ferret 0.17.1 → 0.17.3

data/ext/isomorfeus_ferret_ext/frt_index.c

@@ -1,4 +1,6 @@
 #include "frt_global.h"
+#include "frt_lazy_doc_field.h"
+#include "frt_lazy_doc.h"
 #include "frt_index.h"
 #include "frt_similarity.h"
 #include "frt_helper.h"
@@ -6,13 +8,6 @@
 #include <string.h>
 #include <limits.h>
 #include <ctype.h>
-#include "brotli_decode.h"
-#include "brotli_encode.h"
-#include "bzlib.h"
-#include "lz4frame.h"
-
-// #undef close
-// #undef read
 
 extern rb_encoding *utf8_encoding;
 extern void frt_micro_sleep(const int micro_seconds);
@@ -46,19 +41,15 @@ static char *ste_next(FrtTermEnum *te);
 #define FORMAT 15
 #define SEGMENTS_GEN_FILE_NAME "segments"
 #define MAX_EXT_LEN 10
-#define FRT_COMPRESSION_BUFFER_SIZE 16348
-#define FRT_BROTLI_COMPRESSION_LEVEL 4
-#define FRT_BZIP_COMPRESSION_LEVEL 9
 
 /* *** Must be three characters *** */
 static const char *INDEX_EXTENSIONS[] = {
-    "frq", "prx", "fdx", "fdt", "tfx", "tix", "tis", "del", "gen", "cfs"
+    "frq", "prx", "fdx", "fdt", "tfx", "tix", "tis", "del", "gen"
 };
 
 static const char BASE36_DIGITMAP[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 
-static char *u64_to_str36(char *buf, int buf_size, frt_u64 u)
-{
+static char *u64_to_str36(char *buf, int buf_size, frt_u64 u) {
     int i = buf_size - 1;
     buf[i] = '\0';
     for (i--; i >= 0; i--) {
@@ -75,17 +66,14 @@ static char *u64_to_str36(char *buf, int buf_size, frt_u64 u)
     return buf + i;
 }
 
-static frt_u64 str36_to_u64(char *p)
-{
+static frt_u64 str36_to_u64(char *p) {
     frt_u64 u = 0;
     while (true) {
         if ('0' <= *p && '9' >= *p) {
             u = u * 36 + *p - '0';
-        }
-        else if ('a' <= *p && 'z' >= *p) {
+        } else if ('a' <= *p && 'z' >= *p) {
             u = u * 36 + *p - 'a' + 10;
-        }
-        else {
+        } else {
             break;
         }
         p++;
@@ -142,12 +130,10 @@ static char *fn_for_gen_field(char *buf,
                               const char *base,
                               const char *ext,
                               frt_i64 gen,
-                              int field_num)
-{
+                              int field_num) {
     if (-1 == gen) {
         return NULL;
-    }
-    else {
+    } else {
         char b[FRT_SEGMENT_NAME_MAX_LENGTH];
         sprintf(buf, "%s_%s.%s%d",
                 base,
@@ -164,18 +150,15 @@ static char *fn_for_gen_field(char *buf,
  *
  ***************************************************************************/
 
-static unsigned long co_hash(const void *key)
-{
-    return (unsigned long)key;
+static unsigned long co_hash(const void *key) {
+    return (unsigned long)(uintptr_t)key;
 }
 
-static int co_eq(const void *key1, const void *key2)
-{
+static int co_eq(const void *key1, const void *key2) {
     return (key1 == key2);
 }
 
-static void co_destroy(FrtCacheObject *self)
-{
+static void co_destroy(FrtCacheObject *self) {
     frt_h_rem(self->ref_tab1, self->ref2, false);
     frt_h_rem(self->ref_tab2, self->ref1, false);
     self->destroy(self->obj);
@@ -183,8 +166,7 @@ static void co_destroy(FrtCacheObject *self)
 }
 
 FrtCacheObject *frt_co_create(FrtHash *ref_tab1, FrtHash *ref_tab2,
-                       void *ref1, void *ref2, frt_free_ft destroy, void *obj)
-{
+                       void *ref1, void *ref2, frt_free_ft destroy, void *obj) {
     FrtCacheObject *self = FRT_ALLOC(FrtCacheObject);
     frt_h_set(ref_tab1, ref2, self);
     frt_h_set(ref_tab2, ref1, self);
@@ -201,302 +183,13 @@ FrtHash *frt_co_hash_create(void) {
     return frt_h_new(&co_hash, &co_eq, (frt_free_ft)NULL, (frt_free_ft)&co_destroy);
 }
 
-/****************************************************************************
- *
- * FieldInfo
- *
- ****************************************************************************/
-
-static void fi_check_params(unsigned int bits) {
-    if (!bits_is_indexed(bits) && bits_store_term_vector(bits)) {
-        FRT_RAISE(FRT_ARG_ERROR, "You can't store the term vectors of an unindexed field.");
-    }
-    if (bits_is_compressed(bits) && !bits_is_stored(bits)) {
-        FRT_RAISE(FRT_ARG_ERROR, "Field must be stored for compression to be useful.");
-    }
-}
-
-FrtFieldInfo *frt_fi_alloc(void) {
-    return FRT_ALLOC(FrtFieldInfo);
-}
-
-FrtFieldInfo *frt_fi_init(FrtFieldInfo *fi, ID name, unsigned int bits) {
-    assert(NULL != name);
-    fi_check_params(bits);
-    fi->name = name;
-    fi->boost = 1.0f;
-    fi->bits = bits;
-    fi->number = 0;
-    fi->ref_cnt = 1;
-    fi->rfi = Qnil;
-    return fi;
-}
-
-FrtFieldInfo *frt_fi_new(ID name, unsigned int bits) {
-    FrtFieldInfo *fi = frt_fi_alloc();
-    return frt_fi_init(fi, name, bits);
-}
-
-void frt_fi_deref(FrtFieldInfo *fi) {
-    if (FRT_DEREF(fi) == 0) free(fi);
-}
-
-FrtCompressionType frt_fi_get_compression(FrtFieldInfo *fi) {
-    if (bits_is_compressed(fi->bits)) {
-        if (bits_is_compressed_brotli(fi->bits)) {
-            return FRT_COMPRESSION_BROTLI;
-        } else if (bits_is_compressed_bz2(fi->bits)) {
-            return FRT_COMPRESSION_BZ2;
-        } else if (bits_is_compressed_lz4(fi->bits)) {
-            return FRT_COMPRESSION_LZ4;
-        } else {
-            return FRT_COMPRESSION_BROTLI;
-        }
-    } else {
-        return FRT_COMPRESSION_NONE;
-    }
-}
-
-char *frt_fi_to_s(FrtFieldInfo *fi)
-{
-    const char *fi_name = rb_id2name(fi->name);
-    char *str = FRT_ALLOC_N(char, strlen(fi_name) + 200);
-    char *s = str;
-    s += sprintf(str, "[\"%s\":(%s%s%s%s%s%s%s%s", fi_name,
-                 bits_is_stored(fi->bits) ? "is_stored, " : "",
-                 bits_is_compressed(fi->bits) ? "is_compressed, " : "",
-                 bits_is_indexed(fi->bits) ? "is_indexed, " : "",
-                 bits_is_tokenized(fi->bits) ? "is_tokenized, " : "",
-                 bits_omit_norms(fi->bits) ? "omit_norms, " : "",
-                 bits_store_term_vector(fi->bits) ? "store_term_vector, " : "",
-                 bits_store_positions(fi->bits) ? "store_positions, " : "",
-                 bits_store_offsets(fi->bits) ? "store_offsets, " : "");
-    s -= 2;
-    if (*s != ',') {
-        s += 2;
-    }
-
-    sprintf(s, ")]");
-    return str;
-}
-
-/****************************************************************************
- *
- * FieldInfos
- *
- ****************************************************************************/
-
-FrtFieldInfos *frt_fis_alloc(void) {
-    return FRT_ALLOC(FrtFieldInfos);
-}
-
-FrtFieldInfos *frt_fis_init(FrtFieldInfos *fis, unsigned int bits) {
-    fi_check_params(bits);
-    fis->field_dict = frt_h_new_ptr((frt_free_ft)&frt_fi_deref);
-    fis->size = 0;
-    fis->capa = FIELD_INFOS_INIT_CAPA;
-    fis->fields = FRT_ALLOC_N(FrtFieldInfo *, fis->capa);
-    fis->bits = bits;
-    fis->ref_cnt = 1;
-    fis->rfis = Qnil;
-    return fis;
-}
-
-FrtFieldInfos *frt_fis_new(unsigned int bits) {
-    FrtFieldInfos *fis = frt_fis_alloc();
-    return frt_fis_init(fis, bits);
-}
-
-FrtFieldInfo *frt_fis_add_field(FrtFieldInfos *fis, FrtFieldInfo *fi) {
-    if (fis->size == fis->capa) {
-        fis->capa <<= 1;
-        FRT_REALLOC_N(fis->fields, FrtFieldInfo *, fis->capa);
-    }
-    if (!frt_h_set_safe(fis->field_dict, (void *)fi->name, fi)) {
-        FRT_RAISE(FRT_ARG_ERROR, "Field :%s already exists", rb_id2name(fi->name));
-    }
-    FRT_REF(fi);
-    fi->number = fis->size;
-    fis->fields[fis->size] = fi;
-    fis->size++;
-    return fi;
-}
-
-FrtFieldInfo *frt_fis_get_field(FrtFieldInfos *fis, ID name) {
-    return (FrtFieldInfo *)frt_h_get(fis->field_dict, (void *)name);
-}
-
-int frt_fis_get_field_num(FrtFieldInfos *fis, ID name) {
-    FrtFieldInfo *fi = (FrtFieldInfo *)frt_h_get(fis->field_dict, (void *)name);
-    if (fi) { return fi->number; }
-    else { return -1; }
-}
-
-FrtFieldInfo *frt_fis_get_or_add_field(FrtFieldInfos *fis, ID name) {
-    FrtFieldInfo *fi = (FrtFieldInfo *)frt_h_get(fis->field_dict, (void *)name);
-    if (!fi) {
-        fi = (FrtFieldInfo*)frt_fi_new(name, fis->bits);
-        frt_fis_add_field(fis, fi);
-    }
-    return fi;
-}
-
-FrtFieldInfos *frt_fis_read(FrtInStream *is)
-{
-    FrtFieldInfos *volatile fis = NULL;
-    char *field_name;
-    FRT_TRY
-        do {
-            volatile int i;
-            union { frt_u32 i; float f; } tmp;
-            FrtFieldInfo *volatile fi;
-            fis = frt_fis_new(frt_is_read_vint(is));
-            for (i = frt_is_read_vint(is); i > 0; i--) {
-                fi = FRT_ALLOC_AND_ZERO(FrtFieldInfo);
-                FRT_TRY
-                    field_name = frt_is_read_string_safe(is);
-                    fi->name = rb_intern(field_name);
-                    free(field_name);
-                    tmp.i = frt_is_read_u32(is);
-                    fi->boost = tmp.f;
-                    fi->bits = frt_is_read_vint(is);
-                FRT_XCATCHALL
-                    free(fi);
-                FRT_XENDTRY
-                frt_fis_add_field(fis, fi);
-                fi->ref_cnt = 1;
-            }
-        } while (0);
-    FRT_XCATCHALL
-        frt_fis_deref(fis);
-    FRT_XENDTRY
-    return fis;
-}
-
-void frt_fis_write(FrtFieldInfos *fis, FrtOutStream *os)
-{
-    int i;
-    union { frt_u32 i; float f; } tmp;
-    FrtFieldInfo *fi;
-    const int fis_size = fis->size;
-
-    frt_os_write_vint(os, fis->bits);
-    frt_os_write_vint(os, fis->size);
-
-    for (i = 0; i < fis_size; i++) {
-        fi = fis->fields[i];
-
-        frt_os_write_string(os, rb_id2name(fi->name));
-        tmp.f = fi->boost;
-        frt_os_write_u32(os, tmp.i);
-        frt_os_write_vint(os, fi->bits);
-    }
-}
-
-static const char *store_str[] = {
-    ":no",
-    ":yes",
-    "",
-    ":compressed"
-};
-
-static const char *fi_store_str(FrtFieldInfo *fi)
-{
-    return store_str[fi->bits & 0x3];
-}
-
-static const char *index_str[] = {
-    ":no",
-    ":untokenized",
-    "",
-    ":yes",
-    "",
-    ":untokenized_omit_norms",
-    "",
-    ":omit_norms"
-};
-
-static const char *fi_index_str(FrtFieldInfo *fi)
-{
-    return index_str[(fi->bits >> 2) & 0x7];
-}
-
-static const char *term_vector_str[] = {
-    ":no",
-    ":yes",
-    "",
-    ":with_positions",
-    "",
-    ":with_offsets",
-    "",
-    ":with_positions_offsets"
-};
-
-static const char *fi_term_vector_str(FrtFieldInfo *fi)
-{
-    return term_vector_str[(fi->bits >> 5) & 0x7];
-}
-
-char *frt_fis_to_s(FrtFieldInfos *fis)
-{
-    int i, pos, capa = 200 + fis->size * 120;
-    char *buf = FRT_ALLOC_N(char, capa);
-    FrtFieldInfo *fi;
-    const int fis_size = fis->size;
-
-    pos = sprintf(buf,
-                  "default:\n"
-                  "  store: %s\n"
-                  "  index: %s\n"
-                  "  term_vector: %s\n"
-                  "fields:\n",
-                  store_str[fis->bits & 0x3],
-                  index_str[(fis->bits >> 2) & 0x7],
-                  term_vector_str[(fis->bits >> 5) & 0x7]);
-    for (i = 0; i < fis_size; i++) {
-        fi = fis->fields[i];
-        pos += sprintf(buf + pos,
-                       "  %s:\n"
-                       "    boost: %f\n"
-                       "    store: %s\n"
-                       "    index: %s\n"
-                       "    term_vector: %s\n",
-                       rb_id2name(fi->name), fi->boost, fi_store_str(fi),
-                       fi_index_str(fi), fi_term_vector_str(fi));
-    }
-
-    return buf;
-}
-
-void frt_fis_deref(FrtFieldInfos *fis) {
-    if (FRT_DEREF(fis) == 0) {
-        frt_h_destroy(fis->field_dict);
-        free(fis->fields);
-        free(fis);
-    }
-}
-
-static bool fis_has_vectors(FrtFieldInfos *fis)
-{
-    int i;
-    const int fis_size = fis->size;
-
-    for (i = 0; i < fis_size; i++) {
-        if (bits_store_term_vector(fis->fields[i]->bits)) {
-            return true;
-        }
-    }
-    return false;
-}
-
 /****************************************************************************
  *
  * SegmentInfo
  *
  ****************************************************************************/
 
-FrtSegmentInfo *frt_si_new(char *name, int doc_cnt, FrtStore *store)
-{
+FrtSegmentInfo *frt_si_new(char *name, int doc_cnt, FrtStore *store) {
     FrtSegmentInfo *si = FRT_ALLOC(FrtSegmentInfo);
     si->name = name;
     si->doc_cnt = doc_cnt;
@@ -509,8 +202,7 @@ FrtSegmentInfo *frt_si_new(char *name, int doc_cnt, FrtStore *store)
     return si;
 }
 
-static FrtSegmentInfo *si_read(FrtStore *store, FrtInStream *is)
-{
+static FrtSegmentInfo *si_read(FrtStore *store, FrtInStream *is) {
     FrtSegmentInfo *volatile si = FRT_ALLOC_AND_ZERO(FrtSegmentInfo);
     FRT_TRY
         si->store = store;
@@ -535,8 +227,7 @@ static FrtSegmentInfo *si_read(FrtStore *store, FrtInStream *is)
     return si;
 }
 
-static void si_write(FrtSegmentInfo *si, FrtOutStream *os)
-{
+static void si_write(FrtSegmentInfo *si, FrtOutStream *os) {
     frt_os_write_string(os, si->name);
     frt_os_write_vint(os, si->doc_cnt);
     frt_os_write_vint(os, si->del_gen);
@@ -558,13 +249,11 @@ void frt_si_close(FrtSegmentInfo *si) {
     }
 }
 
-bool frt_si_has_deletions(FrtSegmentInfo *si)
-{
+bool frt_si_has_deletions(FrtSegmentInfo *si) {
     return si->del_gen >= 0;
 }
 
-void frt_si_advance_norm_gen(FrtSegmentInfo *si, int field_num)
-{
+void frt_si_advance_norm_gen(FrtSegmentInfo *si, int field_num) {
     if (field_num >= si->norm_gens_size) {
         int i;
         FRT_REALLOC_N(si->norm_gens, int, field_num + 1);
@@ -576,8 +265,7 @@ void frt_si_advance_norm_gen(FrtSegmentInfo *si, int field_num)
     si->norm_gens[field_num]++;
 }
 
-static char *si_norm_file_name(FrtSegmentInfo *si, char *buf, int field_num)
-{
+static char *si_norm_file_name(FrtSegmentInfo *si, char *buf, int field_num) {
     int norm_gen;
     if (field_num >= si->norm_gens_size
         || 0 > (norm_gen = si->norm_gens[field_num])) {
@@ -590,38 +278,13 @@ static char *si_norm_file_name(FrtSegmentInfo *si, char *buf, int field_num)
 
 void frt_deleter_queue_file(FrtDeleter *dlr, const char *file_name);
 
-static void si_delete_files(FrtSegmentInfo *si, FrtFieldInfos *fis, FrtDeleter *dlr)
-{
-    int i;
-    char file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
-    size_t seg_len = strlen(si->name);
-    char *ext;
-
-    for (i = si->norm_gens_size - 1; i >= 0; i--) {
-        if (0 <= si->norm_gens[i]) {
-            frt_deleter_queue_file(dlr, si_norm_file_name(si, file_name, fis->fields[i]->number));
-        }
-    }
-
-    memcpy(file_name, si->name, seg_len);
-    file_name[seg_len] = '.';
-    ext = file_name + seg_len + 1;
-
-    for (i = FRT_NELEMS(INDEX_EXTENSIONS) - 1; i >= 0; i--) {
-        memcpy(ext, INDEX_EXTENSIONS[i], 4);
-        frt_deleter_queue_file(dlr, file_name);
-    }
-}
-
 /****************************************************************************
  *
  * SegmentInfos
  *
  ****************************************************************************/
 
-#include <time.h>
-static char *new_segment(frt_i64 generation)
-{
+static char *new_segment(frt_i64 generation) {
     char buf[FRT_SEGMENT_NAME_MAX_LENGTH];
     char *fn_p = u64_to_str36(buf, FRT_SEGMENT_NAME_MAX_LENGTH - 1,
                               (frt_u64)generation);
@@ -642,8 +305,7 @@ typedef struct FindSegmentsFile {
     } ret;
 } FindSegmentsFile;
 
-static void which_gen_i(const char *file_name, void *arg)
-{
+static void which_gen_i(const char *file_name, void *arg) {
     frt_i64 *max_generation = (frt_i64 *)arg;
     if (0 == strncmp(FRT_SEGMENTS_FILE_NAME"_", file_name,
                      sizeof(FRT_SEGMENTS_FILE_NAME))) {
@@ -689,10 +351,9 @@ void frt_sis_put(FrtSegmentInfos *sis, FILE *stream) {
  *
  * @param store - the Store to look in
  */
-frt_i64 frt_sis_current_segment_generation(FrtStore *store)
-{
+frt_i64 frt_sis_current_segment_generation(FrtStore *store) {
     frt_i64 current_generation = -1;
-    store->each(store, &which_gen_i, &current_generation);
+    store->each(store, segm_idx_name, &which_gen_i, &current_generation);
     return current_generation;
 }
 
@@ -703,8 +364,7 @@ frt_i64 frt_sis_current_segment_generation(FrtStore *store)
  * @param store - the Store to look in
  * @return segments_N where N is the current generation
  */
-char *frt_sis_curr_seg_file_name(char *buf, FrtStore *store)
-{
+char *frt_sis_curr_seg_file_name(char *buf, FrtStore *store) {
     return segfn_for_generation(buf, frt_sis_current_segment_generation(store));
 }
 
@@ -717,16 +377,14 @@ char *frt_sis_curr_seg_file_name(char *buf, FrtStore *store)
  */
 /*
 FIXME: not used
-static char *sis_next_seg_file_name(char *buf, FrtStore *store)
-{
+static char *sis_next_seg_file_name(char *buf, FrtStore *store) {
     return segfn_for_generation(buf, frt_sis_current_segment_generation(store) + 1);
 }
 */
 
 #define GEN_FILE_RETRY_COUNT 10
 #define GEN_LOOK_AHEAD_COUNT 10
-static void sis_find_segments_file(FrtStore *store, FindSegmentsFile *fsf, void (*run)(FrtStore *store, FindSegmentsFile *fsf, FrtIndexReader *ir), FrtIndexReader *ir)
-{
+static void sis_find_segments_file(FrtStore *store, FindSegmentsFile *fsf, void (*run)(FrtStore *store, FindSegmentsFile *fsf, FrtIndexReader *ir), FrtIndexReader *ir) {
     volatile int i;
     volatile int gen_look_ahead_count = 0;
     volatile bool retry = false;
@@ -763,7 +421,7 @@ static void sis_find_segments_file(FrtStore *store, FindSegmentsFile *fsf, void
                 FrtInStream *gen_is;
                 gen_is = NULL;
                 FRT_TRY
-                    gen_is = store->open_input(store, SEGMENTS_GEN_FILE_NAME);
+                    gen_is = store->open_input(store, segm_idx_name, SEGMENTS_GEN_FILE_NAME);
                 FRT_XCATCHALL
                     FRT_HANDLED();
                     /* TODO:LOG "segments open: FRT_IO_ERROR"*/
@@ -813,7 +471,7 @@ static void sis_find_segments_file(FrtStore *store, FindSegmentsFile *fsf, void
                  * this must be a real error.  We throw the original exception
                  * we got. */
                 char *listing, listing_buffer[1024];
-                listing = frt_store_to_s(store);
+                listing = frt_store_folder_to_s(store, segm_idx_name);
                 strncpy(listing_buffer, listing, 1023);
                 listing_buffer[1023] = '\0';
                 free(listing);
@@ -846,7 +504,7 @@ static void sis_find_segments_file(FrtStore *store, FindSegmentsFile *fsf, void
                  * and try it if so: */
                 char prev_seg_file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
                 segfn_for_generation(prev_seg_file_name, gen - 1);
-                if (store->exists(store, prev_seg_file_name)) {
+                if (store->exists(store, segm_idx_name, prev_seg_file_name)) {
                     /* TODO:LOG "fallback to prior segment file '" +
                      * prevSegmentFileName + "'" */
                     FRT_TRY
@@ -870,8 +528,7 @@ static void sis_find_segments_file(FrtStore *store, FindSegmentsFile *fsf, void
     }
 }
 
-FrtSegmentInfos *frt_sis_new(FrtFieldInfos *fis)
-{
+FrtSegmentInfos *frt_sis_new(FrtFieldInfos *fis) {
     FrtSegmentInfos *sis = FRT_ALLOC_AND_ZERO(FrtSegmentInfos);
     FRT_REF(fis);
     sis->fis = fis;
@@ -885,13 +542,11 @@ FrtSegmentInfos *frt_sis_new(FrtFieldInfos *fis)
     return sis;
 }
 
-FrtSegmentInfo *frt_sis_new_segment(FrtSegmentInfos *sis, int doc_cnt, FrtStore *store)
-{
+FrtSegmentInfo *frt_sis_new_segment(FrtSegmentInfos *sis, int doc_cnt, FrtStore *store) {
     return frt_sis_add_si(sis, frt_si_new(new_segment(sis->counter++), doc_cnt, store));
 }
 
-void frt_sis_destroy(FrtSegmentInfos *sis)
-{
+void frt_sis_destroy(FrtSegmentInfos *sis) {
     int i;
     const int sis_size = sis->size;
     for (i = 0; i < sis_size; i++) {
@@ -903,8 +558,7 @@ void frt_sis_destroy(FrtSegmentInfos *sis)
     free(sis);
 }
 
-FrtSegmentInfo *frt_sis_add_si(FrtSegmentInfos *sis, FrtSegmentInfo *si)
-{
+FrtSegmentInfo *frt_sis_add_si(FrtSegmentInfos *sis, FrtSegmentInfo *si) {
     if (sis->size >= sis->capa) {
         sis->capa <<= 1;
         FRT_REALLOC_N(sis->segs, FrtSegmentInfo *, sis->capa);
@@ -913,8 +567,7 @@ FrtSegmentInfo *frt_sis_add_si(FrtSegmentInfos *sis, FrtSegmentInfo *si)
     return si;
 }
 
-void frt_sis_del_at(FrtSegmentInfos *sis, int at)
-{
+void frt_sis_del_at(FrtSegmentInfos *sis, int at) {
     int i;
     const int sis_size = --(sis->size);
     frt_si_close(sis->segs[at]);
@@ -923,8 +576,7 @@ void frt_sis_del_at(FrtSegmentInfos *sis, int at)
     }
 }
 
-void frt_sis_del_from_to(FrtSegmentInfos *sis, int from, int to)
-{
+void frt_sis_del_from_to(FrtSegmentInfos *sis, int from, int to) {
     int i, num_to_del = to - from;
     const int sis_size = sis->size -= num_to_del;
     for (i = from; i < to; i++) {
@@ -935,8 +587,7 @@ void frt_sis_del_from_to(FrtSegmentInfos *sis, int from, int to)
     }
 }
 
-static void frt_sis_read_i(FrtStore *store, FindSegmentsFile *fsf, FrtIndexReader *ir_)
-{
+static void frt_sis_read_i(FrtStore *store, FindSegmentsFile *fsf, FrtIndexReader *ir_) {
     int seg_cnt;
     int i;
     frt_u32 format = 0;
@@ -947,7 +598,7 @@ static void frt_sis_read_i(FrtStore *store, FindSegmentsFile *fsf, FrtIndexReade
     segfn_for_generation(seg_file_name, fsf->generation);
     fsf->ret.sis = NULL;
     FRT_TRY
-        is = store->open_input(store, seg_file_name);
+        is = store->open_input(store, segm_idx_name, seg_file_name);
         sis->store = store;
         FRT_REF(store);
         sis->generation = fsf->generation;
@@ -973,22 +624,20 @@ static void frt_sis_read_i(FrtStore *store, FindSegmentsFile *fsf, FrtIndexReade
     fsf->ret.sis = sis;
 }
 
-FrtSegmentInfos *frt_sis_read(FrtStore *store)
-{
+FrtSegmentInfos *frt_sis_read(FrtStore *store) {
     FindSegmentsFile fsf;
     sis_find_segments_file(store, &fsf, &frt_sis_read_i, NULL);
     return fsf.ret.sis;
 }
 
-void frt_sis_write(FrtSegmentInfos *sis, FrtStore *store, FrtDeleter *deleter)
-{
+void frt_sis_write(FrtSegmentInfos *sis, FrtStore *store, FrtDeleter *deleter) {
     int i;
     FrtOutStream *volatile os = NULL;
     const int sis_size = sis->size;
     char buf[FRT_SEGMENT_NAME_MAX_LENGTH];
     sis->generation++;
     FRT_TRY
-        os = store->new_output(store, segfn_for_generation(buf, sis->generation));
+        os = store->new_output(store, segm_idx_name, segfn_for_generation(buf, sis->generation));
         frt_os_write_u32(os, FORMAT);
         frt_os_write_u64(os, ++(sis->version)); /* every write changes the index */
         frt_os_write_u64(os, sis->counter);
@@ -1002,7 +651,7 @@ void frt_sis_write(FrtSegmentInfos *sis, FrtStore *store, FrtDeleter *deleter)
     FRT_XENDTRY
 
     FRT_TRY
-        os = store->new_output(store, SEGMENTS_GEN_FILE_NAME);
+        os = store->new_output(store, segm_idx_name, SEGMENTS_GEN_FILE_NAME);
         frt_os_write_u64(os, sis->generation);
         frt_os_write_u64(os, sis->generation);
     FRT_XFINALLY
@@ -1016,15 +665,14 @@ void frt_sis_write(FrtSegmentInfos *sis, FrtStore *store, FrtDeleter *deleter)
     }
 }
 
-static void frt_sis_read_ver_i(FrtStore *store, FindSegmentsFile *fsf, FrtIndexReader *ir_)
-{
+static void frt_sis_read_ver_i(FrtStore *store, FindSegmentsFile *fsf, FrtIndexReader *ir_) {
     FrtInStream *is;
     frt_u32 format = 0;
     frt_u64 version = 0;
     char seg_file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
 
     segfn_for_generation(seg_file_name, (frt_u64)fsf->generation);
-    is = store->open_input(store, seg_file_name);
+    is = store->open_input(store, segm_idx_name, seg_file_name);
 
     FRT_TRY
         format = frt_is_read_u32(is); // format
@@ -1037,362 +685,12 @@ static void frt_sis_read_ver_i(FrtStore *store, FindSegmentsFile *fsf, FrtIndexR
     fsf->ret.uint64 = version;
 }
 
-frt_u64 frt_sis_read_current_version(FrtStore *store)
-{
+frt_u64 frt_sis_read_current_version(FrtStore *store) {
     FindSegmentsFile fsf;
     sis_find_segments_file(store, &fsf, &frt_sis_read_ver_i, NULL);
     return fsf.ret.uint64;
 }
 
-/****************************************************************************
- *
- * LazyDocField
- *
- ****************************************************************************/
-
-static FrtLazyDocField *lazy_df_new(ID name, const int size, FrtCompressionType compression) {
-    FrtLazyDocField *self = FRT_ALLOC(FrtLazyDocField);
-    self->name = name;
-    self->size = size;
-    self->data = FRT_ALLOC_AND_ZERO_N(FrtLazyDocFieldData, size);
-    self->compression = compression;
-    self->decompressed = false;
-    self->loaded = false;
-    return self;
-}
-
-static void lazy_df_destroy(FrtLazyDocField *self) {
-    int i;
-    for (i = self->size - 1; i >= 0; i--) {
-        if (self->data[i].text) {
-            free(self->data[i].text);
-         }
-    }
-    free(self->data);
-    free(self);
-}
-
-static void comp_raise(void) {
-    FRT_RAISE(EXCEPTION, "Compression error");
-}
-
-static char *is_read_brotli_compressed_bytes(FrtInStream *is, int compressed_len, int *len) {
-    int buf_out_idx = 0;
-    int read_len;
-    frt_uchar buf_in[FRT_COMPRESSION_BUFFER_SIZE];
-    const frt_uchar *next_in;
-    size_t available_in;
-    frt_uchar *buf_out = NULL;
-    frt_uchar *next_out;
-    size_t available_out;
-
-    BrotliDecoderState *b_state = BrotliDecoderCreateInstance(NULL, NULL, NULL);
-    BrotliDecoderResult b_result = BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT;
-    if (!b_state) { comp_raise(); return NULL; }
-
-    do {
-        read_len = (compressed_len > FRT_COMPRESSION_BUFFER_SIZE) ? FRT_COMPRESSION_BUFFER_SIZE : compressed_len;
-        frt_is_read_bytes(is, buf_in, read_len);
-        compressed_len -= read_len;
-        available_in = read_len;
-        next_in = buf_in;
-        available_out = FRT_COMPRESSION_BUFFER_SIZE;
-        do {
-            FRT_REALLOC_N(buf_out, frt_uchar, buf_out_idx + FRT_COMPRESSION_BUFFER_SIZE);
-            next_out = buf_out + buf_out_idx;
-            b_result = BrotliDecoderDecompressStream(b_state,
-                &available_in, &next_in,
-                &available_out, &next_out, NULL);
-            if (b_result == BROTLI_DECODER_RESULT_ERROR) { comp_raise(); return NULL; }
-            buf_out_idx += FRT_COMPRESSION_BUFFER_SIZE - available_out;
-        } while (b_result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT);
-    } while (b_result != BROTLI_DECODER_RESULT_SUCCESS && compressed_len > 0);
-
-    BrotliDecoderDestroyInstance(b_state);
-
-    FRT_REALLOC_N(buf_out, frt_uchar, buf_out_idx + 1);
-    buf_out[buf_out_idx] = '\0';
-    *len = buf_out_idx;
-    return (char *)buf_out;
-}
-
-static void zraise(int ret) {
-    switch (ret) {
-    case BZ_IO_ERROR:
-        if (ferror(stdin))
-            FRT_RAISE(FRT_IO_ERROR, "bzlib: error reading stdin");
-        if (ferror(stdout))
-            FRT_RAISE(FRT_IO_ERROR, "bzlib: error writing stdout");
-        break;
-    case BZ_CONFIG_ERROR:
-        FRT_RAISE(FRT_IO_ERROR, "bzlib: system configuration error");
-        break;
-    case BZ_SEQUENCE_ERROR: /* shouldn't occur if code is correct */
-        FRT_RAISE(FRT_IO_ERROR, "bzlib: !!BUG!! sequence error");
-        break;
-    case BZ_PARAM_ERROR:    /* shouldn't occur if code is correct */
-        FRT_RAISE(FRT_IO_ERROR, "bzlib: !!BUG!! parameter error");
-        break;
-    case BZ_MEM_ERROR:
-        FRT_RAISE(FRT_IO_ERROR, "bzlib: memory error");
-        break;
-    case BZ_DATA_ERROR:
-        FRT_RAISE(FRT_IO_ERROR, "bzlib: data integrity check error");
-        break;
-    case BZ_DATA_ERROR_MAGIC:
-        FRT_RAISE(FRT_IO_ERROR, "bzlib: data integrity check - non-matching magic");
-        break;
-    case BZ_UNEXPECTED_EOF:
-        FRT_RAISE(FRT_IO_ERROR, "bzlib: unexpected end-of-file");
-        break;
-    case BZ_OUTBUFF_FULL:
-        FRT_RAISE(FRT_IO_ERROR, "bzlib: output buffer full");
-        break;
-    default:
-        FRT_RAISE(FRT_EXCEPTION, "bzlib: unknown error");
-    }
-}
-
-static char *is_read_bz2_compressed_bytes(FrtInStream *is, int compressed_len, int *len) {
-    int buf_out_idx = 0, ret, read_len;
-    char *buf_out = NULL;
-    char buf_in[FRT_COMPRESSION_BUFFER_SIZE];
-    bz_stream zstrm;
-    zstrm.bzalloc = NULL;
-    zstrm.bzfree  = NULL;
-    zstrm.opaque  = NULL;
-    zstrm.next_in = NULL;
-    zstrm.avail_in = 0;
-    if ((ret = BZ2_bzDecompressInit(&zstrm, 0, 0)) != BZ_OK) zraise(ret);
-
-    do {
-        read_len = (compressed_len > FRT_COMPRESSION_BUFFER_SIZE) ? FRT_COMPRESSION_BUFFER_SIZE : compressed_len;
-        frt_is_read_bytes(is, (frt_uchar *)buf_in, read_len);
-        compressed_len -= read_len;
-        zstrm.avail_in = read_len;
-        zstrm.next_in = buf_in;
-        zstrm.avail_out = FRT_COMPRESSION_BUFFER_SIZE;
-
-        do {
-            REALLOC_N(buf_out, char, buf_out_idx + FRT_COMPRESSION_BUFFER_SIZE);
-            zstrm.next_out = buf_out + buf_out_idx;
-            ret = BZ2_bzDecompress(&zstrm);
-            assert(ret != BZ_SEQUENCE_ERROR);  /* state not clobbered */
-            if (ret != BZ_OK && ret != BZ_STREAM_END) {
-                (void)BZ2_bzDecompressEnd(&zstrm);
-                zraise(ret);
-            }
-            buf_out_idx += FRT_COMPRESSION_BUFFER_SIZE - zstrm.avail_out;
-        } while (zstrm.avail_out == 0);
-    } while (ret != BZ_STREAM_END && compressed_len != 0);
-
-    (void)BZ2_bzDecompressEnd(&zstrm);
-
-    FRT_REALLOC_N(buf_out, char, buf_out_idx + 1);
-    buf_out[buf_out_idx] = '\0';
-
-    *len = buf_out_idx;
-    return (char *)buf_out;
-}
-
-static char *is_read_lz4_compressed_bytes(FrtInStream *is, int compressed_len, int *length) {
-    frt_uchar buf_in[FRT_COMPRESSION_BUFFER_SIZE];
-    char *buf_out = NULL;
-    int dc_length = 0;
-    LZ4F_dctx *dctx;
-    LZ4F_frameInfo_t frame_info;
-    LZ4F_errorCode_t dctx_status = LZ4F_createDecompressionContext(&dctx, LZ4F_VERSION);
-    if (LZ4F_isError(dctx_status)) { *length = -1; return NULL; }
-
-    /* header and buffer */
-    int read_length = (compressed_len > FRT_COMPRESSION_BUFFER_SIZE) ? FRT_COMPRESSION_BUFFER_SIZE : compressed_len;
-    frt_is_read_bytes(is, buf_in, read_length);
-    compressed_len -= read_length;
-
-    size_t consumed_size = read_length;
-    size_t res = LZ4F_getFrameInfo(dctx, &frame_info, buf_in, &consumed_size);
-    if (LZ4F_isError(res)) { *length = -1; return NULL; }
-    size_t buf_out_length;
-    switch(frame_info.blockSizeID) {
-        case LZ4F_default:
-        case LZ4F_max64KB:
-            buf_out_length = 1 << 16;
-            break;
-        case LZ4F_max256KB:
-            buf_out_length = 1 << 18;
-            break;
-        case LZ4F_max1MB:
-            buf_out_length = 1 << 20;
-            break;
-        case LZ4F_max4MB:
-            buf_out_length = 1 << 22;
-            break;
-        default:
-            buf_out_length = 0;
-    }
-
-    res = 1;
-    int first_chunk = 1;
-
-    /* decompress data */
-    while (res != 0) {
-        if (!first_chunk) {
-            read_length = (compressed_len > FRT_COMPRESSION_BUFFER_SIZE) ? FRT_COMPRESSION_BUFFER_SIZE : compressed_len;
-            frt_is_read_bytes(is, buf_in, read_length);
-            compressed_len -= read_length;
-            consumed_size = 0;
-        }
-        first_chunk = 0;
-
-        char *src = (char *)(buf_in + consumed_size);
-        char *src_end = (char *)buf_in + read_length;
-
-        while (src < src_end && res != 0){
-            size_t dest_length = buf_out_length;
-            size_t consumed_size = read_length;
-            FRT_REALLOC_N(buf_out, char, dc_length + buf_out_length);
-            res = LZ4F_decompress(dctx, buf_out + dc_length, &dest_length, src, &consumed_size, NULL);
-            if (LZ4F_isError(res)) { *length = -1; return NULL; }
-            dc_length += dest_length;
-            src = src + consumed_size;
-        }
-    }
-
-    /* finish up */
-    LZ4F_freeDecompressionContext(dctx);
-
-    FRT_REALLOC_N(buf_out, char, dc_length + 1);
-    buf_out[dc_length] = '\0';
-
-    *length = dc_length;
-    return buf_out;
-}
-
-static char *is_read_compressed_bytes(FrtInStream *is, int compressed_len, int *len, FrtCompressionType compression) {
-    switch (compression) {
-        case FRT_COMPRESSION_BROTLI:
-            return is_read_brotli_compressed_bytes(is, compressed_len, len);
-        case FRT_COMPRESSION_BZ2:
-            return is_read_bz2_compressed_bytes(is, compressed_len, len);
-        case FRT_COMPRESSION_LZ4:
-            return is_read_lz4_compressed_bytes(is, compressed_len, len);
-        default:
-            return NULL;
-    }
-}
-
-char *frt_lazy_df_get_data(FrtLazyDocField *self, int i) {
-    char *text = NULL;
-    if (i < self->size && i >= 0) {
-        text = self->data[i].text;
-        if (NULL == text) {
-            const int read_len = self->data[i].length + 1;
-            frt_is_seek(self->doc->fields_in, self->data[i].start);
-            if (self->data[i].compression != FRT_COMPRESSION_NONE) {
-                self->data[i].text = text = is_read_compressed_bytes(self->doc->fields_in, read_len, &(self->data[i].length), self->data[i].compression);
-            } else {
-                self->data[i].text = text = FRT_ALLOC_N(char, read_len);
-                frt_is_read_bytes(self->doc->fields_in, (frt_uchar *)text, read_len);
-                text[read_len - 1] = '\0';
-            }
-            self->loaded = true;
-        }
-    }
-
-    return text;
-}
-
-void frt_lazy_df_get_bytes(FrtLazyDocField *self, char *buf, int start, int len) {
-    if (self->compression != FRT_COMPRESSION_NONE && !self->decompressed) {
-        int i;
-        self->len = 0;
-        for (i = self->size-1; i >= 0; i--) {
-            (void)frt_lazy_df_get_data(self, i);
-            self->len += self->data[i].length + 1;
-        }
-        self->len--; /* each field separated by ' ' but no need to add to end */
-        self->decompressed = true;
-    }
-    if (start < 0 || start >= self->len) {
-        FRT_RAISE(FRT_IO_ERROR, "start out of range in LazyDocField#get_bytes. %d "
-              "is not between 0 and %d", start, self->len);
-    }
-    if (len <= 0) {
-        FRT_RAISE(FRT_IO_ERROR, "len = %d, but should be greater than 0", len);
-    }
-    if (start + len > self->len) {
-        FRT_RAISE(FRT_IO_ERROR, "Tried to read past end of field. Field is only %d "
-              "bytes long but tried to read to %d", self->len, start + len);
-    }
-    if (self->compression != FRT_COMPRESSION_NONE) {
-        int cur_start = 0, buf_start = 0, cur_end, i, copy_start, copy_len;
-        for (i = 0; i < self->size; i++) {
-            cur_end = cur_start + self->data[i].length;
-            if (start < cur_end) {
-                copy_start = start > cur_start ? start - cur_start : 0;
-                copy_len = cur_end - cur_start - copy_start;
-                if (copy_len >= len) {
-                    copy_len = len;
-                    len = 0;
-                }
-                else {
-                    len -= copy_len;
-                }
-                memcpy(buf + buf_start,
-                       self->data[i].text + copy_start,
-                       copy_len);
-                buf_start += copy_len;
-                if (len > 0) {
-                    buf[buf_start++] = ' ';
-                    len--;
-                }
-                if (len == 0) break;
-            }
-            cur_start = cur_end + 1;
-        }
-    } else {
-        frt_is_seek(self->doc->fields_in, self->data[0].start + start);
-        frt_is_read_bytes(self->doc->fields_in, (frt_uchar *)buf, len);
-    }
-}
-
-/****************************************************************************
- *
- * LazyDoc
- *
- ****************************************************************************/
-
-static FrtLazyDoc *lazy_doc_new(int size, FrtInStream *fdt_in)
-{
-    FrtLazyDoc *self = FRT_ALLOC(FrtLazyDoc);
-    self->field_dictionary = frt_h_new_ptr((frt_free_ft)&lazy_df_destroy);
-    self->size = size;
-    self->fields = FRT_ALLOC_AND_ZERO_N(FrtLazyDocField *, size);
-    self->fields_in = frt_is_clone(fdt_in);
-    self->loaded = false;
-    return self;
-}
-
-void frt_lazy_doc_close(FrtLazyDoc *self)
-{
-    frt_h_destroy(self->field_dictionary);
-    frt_is_close(self->fields_in);
-    free(self->fields);
-    free(self);
-}
-
-static void lazy_doc_add_field(FrtLazyDoc *self, FrtLazyDocField *lazy_df, int i)
-{
-    self->fields[i] = lazy_df;
-
-    frt_h_set(self->field_dictionary, (void *)lazy_df->name, lazy_df);
-    lazy_df->doc = self;
-}
-
-FrtLazyDocField *frt_lazy_doc_get(FrtLazyDoc *self, ID field) {
-    return (FrtLazyDocField *)frt_h_get(self->field_dictionary, (void *)field);
-}
-
 /****************************************************************************
  * FrtFieldsReader
  ****************************************************************************/
@@ -1409,9 +707,9 @@ FrtFieldsReader *frt_fr_open(FrtStore *store, const char *segment, FrtFieldInfos
     fr->fis = fis;
 
     strcpy(file_name + segment_len, ".fdt");
-    fr->fdt_in = store->open_input(store, file_name);
+    fr->fdt_in = store->open_input(store, segm_idx_name, file_name);
     strcpy(file_name + segment_len, ".fdx");
-    fr->fdx_in = store->open_input(store, file_name);
+    fr->fdx_in = store->open_input(store, segm_idx_name, file_name);
     fr->size = frt_is_length(fr->fdx_in) / FIELDS_IDX_PTR_SIZE;
     fr->store = store;
     FRT_REF(store);
@@ -1437,32 +735,30 @@ void frt_fr_close(FrtFieldsReader *fr) {
     free(fr);
 }
 
-static FrtDocField *frt_fr_df_new(ID name, int size, FrtCompressionType compression) {
+static FrtDocField *frt_fr_df_new(ID name, int size, FrtCompressionType compression_type) {
     FrtDocField *df = FRT_ALLOC(FrtDocField);
     df->name = name;
     df->capa = df->size = size;
-    df->data = FRT_ALLOC_N(char *, df->capa);
+    df->data = FRT_ALLOC_N(const char *, df->capa);
     df->lengths = FRT_ALLOC_N(int, df->capa);
     df->encodings = FRT_ALLOC_N(rb_encoding *, df->capa);
-    df->destroy_data = true;
     df->boost = 1.0f;
-    df->compression = compression;
+    df->compression_type = compression_type;
     return df;
 }
 
-static void frt_fr_read_compressed_fields(FrtFieldsReader *fr, FrtDocField *df, FrtCompressionType compression) {
+static void frt_fr_read_compressed_fields(FrtFieldsReader *fr, FrtDocField *df, FrtCompressionType compression_type) {
     int i;
     const int df_size = df->size;
     FrtInStream *fdt_in = fr->fdt_in;
 
     for (i = 0; i < df_size; i++) {
-        const int compressed_len = df->lengths[i] + 1;
-        df->data[i] = is_read_compressed_bytes(fdt_in, compressed_len, &(df->lengths[i]), compression);
+        const int compressed_len = df->lengths[i];
+        df->data[i] = frt_is_read_compressed_bytes(fdt_in, compressed_len, &(df->lengths[i]), compression_type);
     }
 }
 
-FrtDocument *frt_fr_get_doc(FrtFieldsReader *fr, int doc_num)
-{
+FrtDocument *frt_fr_get_doc(FrtFieldsReader *fr, int doc_num) {
     int i, j;
     frt_off_t pos;
     int stored_cnt;
@@ -1478,28 +774,29 @@ FrtDocument *frt_fr_get_doc(FrtFieldsReader *fr, int doc_num)
     for (i = 0; i < stored_cnt; i++) {
         const int field_num = frt_is_read_vint(fdt_in);
         FrtFieldInfo *fi = fr->fis->fields[field_num];
-        const int df_size = frt_is_read_vint(fdt_in);
-        FrtDocField *df = frt_fr_df_new(fi->name, df_size, frt_fi_get_compression(fi));
+        const int df_field_count = frt_is_read_vint(fdt_in);
+        FrtDocField *df = frt_fr_df_new(fi->name, df_field_count, bits_get_compression_type(fi->bits));
 
-        for (j = 0; j < df_size; j++) {
+        for (j = 0; j < df_field_count; j++) {
             df->lengths[j] = frt_is_read_vint(fdt_in);
             df->encodings[j] = rb_enc_from_index(frt_is_read_vint(fdt_in));
-            df->compression = frt_is_read_vint(fdt_in);
+            df->compression_type = frt_is_read_vint(fdt_in);
         }
 
         frt_doc_add_field(doc, df);
     }
     for (i = 0; i < stored_cnt; i++) {
         FrtDocField *df = doc->fields[i];
-        if (df->compression != FRT_COMPRESSION_NONE) {
-            frt_fr_read_compressed_fields(fr, df, df->compression);
+        if (df->compression_type != FRT_COMPRESSION_NONE) {
+            frt_fr_read_compressed_fields(fr, df, df->compression_type);
         } else {
             const int df_size = df->size;
             for (j = 0; j < df_size; j++) {
-                const int read_len = df->lengths[j] + 1;
-                df->data[j] = FRT_ALLOC_N(char, read_len);
-                frt_is_read_bytes(fdt_in, (frt_uchar *)df->data[j], read_len);
-                df->data[j][read_len - 1] = '\0';
+                const int read_len = df->lengths[j];
+                char *d = FRT_ALLOC_N(char, read_len + 1);
+                frt_is_read_bytes(fdt_in, (frt_uchar *)d, read_len);
+                d[read_len] = '\0';
+                df->data[j] = d;
             }
         }
     }
@@ -1507,8 +804,7 @@ FrtDocument *frt_fr_get_doc(FrtFieldsReader *fr, int doc_num)
     return doc;
 }
 
-FrtLazyDoc *frt_fr_get_lazy_doc(FrtFieldsReader *fr, int doc_num)
-{
+FrtLazyDoc *frt_fr_get_lazy_doc(FrtFieldsReader *fr, int doc_num) {
     int start = 0;
     int i, j;
     frt_off_t pos;
@@ -1522,23 +818,23 @@ FrtLazyDoc *frt_fr_get_lazy_doc(FrtFieldsReader *fr, int doc_num)
     frt_is_seek(fdt_in, pos);
     stored_cnt = frt_is_read_vint(fdt_in);
 
-    lazy_doc = lazy_doc_new(stored_cnt, fdt_in);
+    lazy_doc = frt_lazy_doc_new(stored_cnt, fdt_in);
     for (i = 0; i < stored_cnt; i++) {
         FrtFieldInfo *fi = fr->fis->fields[frt_is_read_vint(fdt_in)];
         const int df_size = frt_is_read_vint(fdt_in);
-        FrtLazyDocField *lazy_df = lazy_df_new(fi->name, df_size, frt_fi_get_compression(fi));
+        FrtLazyDocField *lazy_df = frt_lazy_df_new(fi->name, df_size, bits_get_compression_type(fi->bits));
         const int field_start = start;
         /* get the starts relative positions this time around */
 
         for (j = 0; j < df_size; j++) {
             lazy_df->data[j].start = start;
-            start += 1 + (lazy_df->data[j].length = frt_is_read_vint(fdt_in));
+            start += (lazy_df->data[j].length = frt_is_read_vint(fdt_in));
             lazy_df->data[j].encoding = rb_enc_from_index(frt_is_read_vint(fdt_in));
-            lazy_df->data[j].compression = frt_is_read_vint(fdt_in);
+            lazy_df->data[j].compression_type = frt_is_read_vint(fdt_in);
         }
 
-        lazy_df->len = start - field_start - 1;
-        lazy_doc_add_field(lazy_doc, lazy_df, i);
+        lazy_df->len = start - field_start;
+        frt_lazy_doc_add_field(lazy_doc, lazy_df, i);
     }
     /* correct the starts to their correct absolute positions */
     const frt_off_t abs_start = frt_is_pos(fdt_in);
@@ -1553,8 +849,7 @@ FrtLazyDoc *frt_fr_get_lazy_doc(FrtFieldsReader *fr, int doc_num)
     return lazy_doc;
 }
 
-static FrtTermVector *frt_fr_read_term_vector(FrtFieldsReader *fr, int field_num)
-{
+static FrtTermVector *frt_fr_read_term_vector(FrtFieldsReader *fr, int field_num) {
     FrtTermVector *tv = FRT_ALLOC_AND_ZERO(FrtTermVector);
     FrtInStream *fdt_in = fr->fdt_in;
     FrtFieldInfo *fi = fr->fis->fields[field_num];
@@ -1612,8 +907,7 @@ static FrtTermVector *frt_fr_read_term_vector(FrtFieldsReader *fr, int field_num
     return tv;
 }
 
-FrtHash *frt_fr_get_tv(FrtFieldsReader *fr, int doc_num)
-{
+FrtHash *frt_fr_get_tv(FrtFieldsReader *fr, int doc_num) {
     FrtHash *term_vectors = frt_h_new_ptr((frt_free_ft)&frt_tv_destroy);
     int i;
     FrtInStream *fdx_in = fr->fdx_in;
@@ -1699,10 +993,10 @@ FrtFieldsWriter *frt_fw_open(FrtStore *store, const char *segment, FrtFieldInfos
     memcpy(file_name, segment, segment_len);
 
     strcpy(file_name + segment_len, ".fdt");
-    fw->fdt_out = store->new_output(store, file_name);
+    fw->fdt_out = store->new_output(store, segm_idx_name, file_name);
 
     strcpy(file_name + segment_len, ".fdx");
-    fw->fdx_out = store->new_output(store, file_name);
+    fw->fdx_out = store->new_output(store, segm_idx_name, file_name);
 
     fw->buffer = frt_ram_new_buffer();
 
@@ -1720,152 +1014,13 @@ void frt_fw_close(FrtFieldsWriter *fw) {
     free(fw);
 }
 
-static int frt_os_write_brotli_compressed_bytes(FrtOutStream* out_stream, frt_uchar *data, int length) {
-    size_t compressed_length = 0;
-    const frt_uchar *next_in = data;
-    size_t available_in = length;
-    size_t available_out;
-    frt_uchar compression_buffer[FRT_COMPRESSION_BUFFER_SIZE];
-    frt_uchar *next_out;
-    BrotliEncoderState *b_state = BrotliEncoderCreateInstance(NULL, NULL, NULL);
-    if (!b_state) { comp_raise(); return -1; }
-
-    BrotliEncoderSetParameter(b_state, BROTLI_PARAM_QUALITY, FRT_BROTLI_COMPRESSION_LEVEL);
-
-    do {
-        available_out = FRT_COMPRESSION_BUFFER_SIZE;
-        next_out = compression_buffer;
-        if (!BrotliEncoderCompressStream(b_state, BROTLI_OPERATION_FINISH,
-            &available_in, &next_in,
-            &available_out, &next_out, &compressed_length)) {
-            BrotliEncoderDestroyInstance(b_state);
-            comp_raise();
-            return -1;
-        }
-        frt_os_write_bytes(out_stream, compression_buffer, FRT_COMPRESSION_BUFFER_SIZE - available_out);
-    } while (!BrotliEncoderIsFinished(b_state));
-
-    BrotliEncoderDestroyInstance(b_state);
-
-    return (int)compressed_length;
-}
-
-static int frt_os_write_bz2_compressed_bytes(FrtOutStream* out_stream, frt_uchar *data, int length) {
-    int ret, buf_size, compressed_len = 0;
-    char out_buffer[FRT_COMPRESSION_BUFFER_SIZE];
-    bz_stream zstrm;
-    zstrm.bzalloc = NULL;
-    zstrm.bzfree  = NULL;
-    zstrm.opaque = NULL;
-    if ((ret = BZ2_bzCompressInit(&zstrm, FRT_BZIP_COMPRESSION_LEVEL, 0, 0)) != BZ_OK) zraise(ret);
-
-    zstrm.avail_in = length;
-    zstrm.next_in = (char *)data;
-    zstrm.avail_out = FRT_COMPRESSION_BUFFER_SIZE;
-    zstrm.next_out = out_buffer;
-
-    do {
-        ret = BZ2_bzCompress(&zstrm, BZ_FINISH); /* no bad return value */
-        assert(ret != BZ_SEQUENCE_ERROR);        /* state not clobbered */
-        compressed_len += buf_size = FRT_COMPRESSION_BUFFER_SIZE - zstrm.avail_out;
-        frt_os_write_bytes(out_stream, (frt_uchar *)out_buffer, buf_size);
-    } while (zstrm.avail_out == 0);
-    assert(zstrm.avail_in == 0);       /* all input will be used */
-
-    (void)BZ2_bzCompressEnd(&zstrm);
-    return compressed_len;
-}
-
-static const LZ4F_preferences_t lz4_prefs = {
-    {
-        LZ4F_default,
-        LZ4F_blockLinked,
-        LZ4F_noContentChecksum,
-        LZ4F_frame,
-        0, /* unknown content size */
-        0, /* no dictID */
-        LZ4F_noBlockChecksum
-    },
-    0,
-    1,
-    1,
-    {0,0,0}
-};
-
-static int frt_os_write_lz4_compressed_bytes(FrtOutStream* out_stream, frt_uchar *data, int length) {
-    int compressed_length = 0;
-    int remaining_length = length;
-    size_t ccmp_length = 0;
-    LZ4F_compressionContext_t ctx;
-    size_t out_buf_length = LZ4F_compressBound(FRT_COMPRESSION_BUFFER_SIZE, &lz4_prefs);
-    frt_uchar *out_buf = frt_ecalloc(out_buf_length);
-
-    size_t ctx_creation = LZ4F_createCompressionContext(&ctx, LZ4F_VERSION);
-    if (LZ4F_isError(ctx_creation)) {
-        compressed_length = -1;
-        goto finish;
-    }
-
-    /* create header */
-    ccmp_length = LZ4F_compressBegin(ctx, out_buf, out_buf_length, &lz4_prefs);
-    if (LZ4F_isError(ccmp_length)) {
-        compressed_length = -1;
-        goto finish;
-    }
-    compressed_length = ccmp_length;
-    frt_os_write_bytes(out_stream, out_buf, ccmp_length);
-
-    /* compress data */
-    do {
-        int read_length = (FRT_COMPRESSION_BUFFER_SIZE > remaining_length) ? remaining_length : FRT_COMPRESSION_BUFFER_SIZE;
-        ccmp_length = LZ4F_compressUpdate(ctx, out_buf, out_buf_length, data + (length - remaining_length), read_length, NULL);
-        if (LZ4F_isError(ccmp_length)) {
-            compressed_length = -1;
-            goto finish;
-        }
-        frt_os_write_bytes(out_stream, out_buf, ccmp_length);
-        compressed_length += ccmp_length;
-        remaining_length -= read_length;
-    } while (remaining_length > 0);
-
-    /* finish up */
-    ccmp_length = LZ4F_compressEnd(ctx, out_buf, out_buf_length, NULL);
-    if (LZ4F_isError(ccmp_length)) {
-        compressed_length = -1;
-        goto finish;
-    }
-
-    frt_os_write_bytes(out_stream, out_buf, ccmp_length);
-    compressed_length += ccmp_length;
-
-finish:
-    LZ4F_freeCompressionContext(ctx);
-    free(out_buf);
-
-    return compressed_length;
-}
-
-static int frt_os_write_compressed_bytes(FrtOutStream* out_stream, frt_uchar *data, int length, FrtCompressionType compression) {
-    switch (compression) {
-        case FRT_COMPRESSION_BROTLI:
-            return frt_os_write_brotli_compressed_bytes(out_stream, data, length);
-        case FRT_COMPRESSION_BZ2:
-            return frt_os_write_bz2_compressed_bytes(out_stream, data, length);
-        case FRT_COMPRESSION_LZ4:
-            return frt_os_write_lz4_compressed_bytes(out_stream, data, length);
-        default:
-            return -1;
-    }
-
-}
-
 void frt_fw_add_doc(FrtFieldsWriter *fw, FrtDocument *doc) {
     int i, j, stored_cnt = 0;
     FrtDocField *df;
     FrtFieldInfo *fi;
-    FrtCompressionType compression;
+    FrtCompressionType compression_type;
     FrtOutStream *fdt_out = fw->fdt_out, *fdx_out = fw->fdx_out;
-    const int doc_size = doc->size;
+    const int doc_size = doc->field_count;
 
     for (i = 0; i < doc_size; i++) {
         df = doc->fields[i];
@@ -1889,23 +1044,20 @@ void frt_fw_add_doc(FrtFieldsWriter *fw, FrtDocument *doc) {
             frt_os_write_vint(fdt_out, df_size);
 
             if (bits_is_compressed(fi->bits)) {
-                compression = frt_fi_get_compression(fi);
+                compression_type = bits_get_compression_type(fi->bits);
                 for (j = 0; j < df_size; j++) {
-                    const int length = df->lengths[j];
-                    int compressed_len = frt_os_write_compressed_bytes(fw->buffer, (frt_uchar*)df->data[j], length, compression);
-                    frt_os_write_vint(fdt_out, compressed_len - 1);
+                    int compressed_len = frt_os_write_compressed_bytes(fw->buffer, (frt_uchar*)df->data[j], df->lengths[j], compression_type);
+                    frt_os_write_vint(fdt_out, compressed_len);
                     frt_os_write_vint(fdt_out, rb_enc_to_index(df->encodings[j]));
-                    frt_os_write_vint(fdt_out, compression);
+                    frt_os_write_vint(fdt_out, compression_type);
                 }
             } else {
                 for (j = 0; j < df_size; j++) {
                     const int length = df->lengths[j];
+                    frt_os_write_bytes(fw->buffer, (frt_uchar*)df->data[j], length);
                     frt_os_write_vint(fdt_out, length);
                     frt_os_write_vint(fdt_out, rb_enc_to_index(df->encodings[j]));
-                    frt_os_write_vint(fdt_out, FRT_COMPRESSION_NONE);
-                    frt_os_write_bytes(fw->buffer, (frt_uchar*)df->data[j], length);
-                    /* leave a space between fields as that is how they are analyzed */
-                    frt_os_write_byte(fw->buffer, ' ');
+                    frt_os_write_vint(fdt_out, FRT_COMPRESSION_NONE);     
                 }
             }
         }
@@ -1932,8 +1084,7 @@ void frt_fw_add_postings(FrtFieldsWriter *fw,
                      FrtPostingList **plists,
                      int posting_count,
                      FrtOffset *offsets,
-                     int offset_count)
-{
+                     int offset_count) {
     int i, delta_start, delta_length;
     const char *last_term = FRT_EMPTY_STRING;
     FrtOutStream *fdt_out = fw->fdt_out;
@@ -1997,19 +1148,16 @@ void frt_fw_add_postings(FrtFieldsWriter *fw,
 
 #define TE(ste) ((FrtTermEnum *)ste)
 
-char *frt_te_get_term(FrtTermEnum *te)
-{
+char *frt_te_get_term(FrtTermEnum *te) {
     return (char *)memcpy(FRT_ALLOC_N(char, te->curr_term_len + 1),
                           te->curr_term, te->curr_term_len + 1);
 }
 
-FrtTermInfo *frt_te_get_ti(FrtTermEnum *te)
-{
+FrtTermInfo *frt_te_get_ti(FrtTermEnum *te) {
     return (FrtTermInfo*)memcpy(FRT_ALLOC(FrtTermInfo), &(te->curr_ti), sizeof(FrtTermInfo));
 }
 
-static char *te_skip_to(FrtTermEnum *te, const char *term)
-{
+static char *te_skip_to(FrtTermEnum *te, const char *term) {
     char *curr_term = te->curr_term;
     if (strcmp(curr_term, term) < 0) {
         while (NULL != ((curr_term = te->next(te)))
@@ -2031,8 +1179,7 @@ static char *te_skip_to(FrtTermEnum *te, const char *term)
  * SegmentTermIndex
  ****************************************************************************/
 
-static void sti_destroy(FrtSegmentTermIndex *sti)
-{
+static void sti_destroy(FrtSegmentTermIndex *sti) {
     if (sti->index_terms) {
         int i;
         const int sti_index_cnt = sti->index_cnt;
@@ -2076,8 +1223,7 @@ static void sti_ensure_index_is_read(FrtSegmentTermIndex *sti, FrtTermEnum *inde
     }
 }
 
-static int sti_get_index_offset(FrtSegmentTermIndex *sti, const char *term)
-{
+static int sti_get_index_offset(FrtSegmentTermIndex *sti, const char *term) {
     int lo = 0;
     int hi = sti->index_cnt - 1;
     int mid, delta;
@@ -2088,11 +1234,9 @@ static int sti_get_index_offset(FrtSegmentTermIndex *sti, const char *term)
         delta = strcmp(term, index_terms[mid]);
         if (delta < 0) {
             hi = mid - 1;
-        }
-        else if (delta > 0) {
+        } else if (delta > 0) {
             lo = mid + 1;
-        }
-        else {
+        } else {
             return mid;
         }
     }
@@ -2120,7 +1264,7 @@ FrtSegmentFieldIndex *frt_sfi_open(FrtStore *store, const char *segment) {
     pthread_mutex_init(&sfi->mutex, NULL);
 
     sprintf(file_name, "%s.tfx", segment);
-    is = store->open_input(store, file_name);
+    is = store->open_input(store, segm_idx_name, file_name);
     field_count = (int)frt_is_read_u32(is);
     sfi->index_interval = frt_is_read_vint(is);
     sfi->skip_interval = frt_is_read_vint(is);
@@ -2139,7 +1283,7 @@ FrtSegmentFieldIndex *frt_sfi_open(FrtStore *store, const char *segment) {
     frt_is_close(is);
 
     sprintf(file_name, "%s.tix", segment);
-    is = store->open_input(store, file_name);
+    is = store->open_input(store, segm_idx_name, file_name);
     FRT_DEREF(is);
     sfi->index_te = frt_ste_new(is, sfi);
     return sfi;
@@ -2269,13 +1413,11 @@ void frt_ste_close(FrtTermEnum *te) {
     free(te);
 }
 
-static char *frt_ste_get_term(FrtTermEnum *te, int pos)
-{
+static char *frt_ste_get_term(FrtTermEnum *te, int pos) {
     FrtSegmentTermEnum *ste = STE(te);
     if (pos >= ste->size) {
         return NULL;
-    }
-    else if (pos != ste->pos) {
+    } else if (pos != ste->pos) {
         int idx_int = ste->sfi->index_interval;
         if ((pos < ste->pos) || pos > (1 + ste->pos / idx_int) * idx_int) {
             FrtSegmentTermIndex *sti = (FrtSegmentTermIndex *)frt_h_get_int(ste->sfi->field_dict, te->field_num);
@@ -2292,8 +1434,7 @@ static char *frt_ste_get_term(FrtTermEnum *te, int pos)
     return te->curr_term;
 }
 
-FrtTermEnum *frt_ste_new(FrtInStream *is, FrtSegmentFieldIndex *sfi)
-{
+FrtTermEnum *frt_ste_new(FrtInStream *is, FrtSegmentFieldIndex *sfi) {
     FrtSegmentTermEnum *ste = ste_allocate();
 
     TE(ste)->field_num = -1;
@@ -2313,8 +1454,7 @@ FrtTermEnum *frt_ste_new(FrtInStream *is, FrtSegmentFieldIndex *sfi)
 
 #define MTE(te) ((MultiTermEnum *)(te))
 
-typedef struct TermEnumWrapper
-{
+typedef struct TermEnumWrapper {
     int index;
     FrtTermEnum *te;
     int *doc_map;
@@ -2322,8 +1462,7 @@ typedef struct TermEnumWrapper
     char *term;
 } TermEnumWrapper;
 
-typedef struct MultiTermEnum
-{
+typedef struct MultiTermEnum {
     FrtTermEnum te;
     int doc_freq;
     FrtPriorityQueue *tew_queue;
@@ -2335,29 +1474,24 @@ typedef struct MultiTermEnum
     int *ti_indexes;
 } MultiTermEnum;
 
-static bool tew_lt(const TermEnumWrapper *tew1, const TermEnumWrapper *tew2)
-{
+static bool tew_lt(const TermEnumWrapper *tew1, const TermEnumWrapper *tew2) {
     int cmpres = strcmp(tew1->term, tew2->term);
     if (0 == cmpres) {
         return tew1->index < tew2->index;
-    }
-    else {
+    } else {
         return cmpres < 0;
     }
 }
 
-static char *tew_next(TermEnumWrapper *tew)
-{
+static char *tew_next(TermEnumWrapper *tew) {
     return (tew->term = tew->te->next(tew->te));
 }
 
-static char *tew_skip_to(TermEnumWrapper *tew, const char *term)
-{
+static char *tew_skip_to(TermEnumWrapper *tew, const char *term) {
     return (tew->term = tew->te->skip_to(tew->te, term));
 }
 
-static void tew_destroy(TermEnumWrapper *tew)
-{
+static void tew_destroy(TermEnumWrapper *tew) {
     frt_ir_close(tew->ir);
     if (tew->doc_map) {
         free(tew->doc_map);
@@ -2424,8 +1558,7 @@ static FrtTermEnum *mte_set_field(FrtTermEnum *te, int field_num) {
             if (tew_next(tew)) {
                 frt_pq_push(mte->tew_queue, tew); /* initialize queue */
             }
-        }
-        else {
+        } else {
             sub_te->field_num = -1;
         }
 
@@ -2528,7 +1661,7 @@ FrtTermInfosReader *frt_tir_open(FrtStore *store, FrtSegmentFieldIndex *sfi, con
     char file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
 
     sprintf(file_name, "%s.tis", segment);
-    FrtInStream *is = store->open_input(store, file_name);
+    FrtInStream *is = store->open_input(store, segm_idx_name, file_name);
     FRT_DEREF(is);
     tir->orig_te = frt_ste_new(is, sfi);
     tir->thread_te = 0;
@@ -2607,7 +1740,7 @@ void frt_tir_close(FrtTermInfosReader *tir) {
 
 static FrtTermWriter *frt_tw_new(FrtStore *store, char *file_name) {
     FrtTermWriter *tw = FRT_ALLOC_AND_ZERO(FrtTermWriter);
-    tw->os = store->new_output(store, file_name);
+    tw->os = store->new_output(store, segm_idx_name, file_name);
     tw->last_term = FRT_EMPTY_STRING;
     return tw;
 }
@@ -2634,7 +1767,7 @@ FrtTermInfosWriter *frt_tiw_open(FrtStore *store, const char *segment, int index
     strcpy(file_name + segment_len, ".tis");
     tiw->tis_writer = frt_tw_new(store, file_name);
     strcpy(file_name + segment_len, ".tfx");
-    tiw->tfx_out = store->new_output(store, file_name);
+    tiw->tfx_out = store->new_output(store, segm_idx_name, file_name);
     frt_os_write_u32(tiw->tfx_out, 0); /* make space for field_count */
 
     /* The following two numbers are the first numbers written to the field
@@ -3002,35 +2135,30 @@ static bool stpe_next(FrtTermDocEnum *tde) {
     }
 }
 
-static int stpe_read(FrtTermDocEnum *tde, int *docs, int *freqs, int req_num)
-{
+static int stpe_read(FrtTermDocEnum *tde, int *docs, int *freqs, int req_num) {
     (void)tde; (void)docs; (void)freqs; (void)req_num;
     FRT_RAISE(FRT_ARG_ERROR, "TermPosEnum does not handle processing multiple documents"
                      " in one call. Use TermDocEnum instead.");
     return -1;
 }
 
-static int stpe_next_position(FrtTermDocEnum *tde)
-{
+static int stpe_next_position(FrtTermDocEnum *tde) {
     FrtSegmentTermDocEnum *stde = STDE(tde);
     return (stde->prx_cnt-- > 0) ? stde->position += frt_is_read_vint(stde->prx_in)
                                  : -1;
 }
 
-static void stpe_close(FrtTermDocEnum *tde)
-{
+static void stpe_close(FrtTermDocEnum *tde) {
     frt_is_close(STDE(tde)->prx_in);
     STDE(tde)->prx_in = NULL;
     stde_close(tde);
 }
 
-static void stpe_skip_prox(FrtSegmentTermDocEnum *stde)
-{
+static void stpe_skip_prox(FrtSegmentTermDocEnum *stde) {
     frt_is_skip_vints(stde->prx_in, stde->freq);
 }
 
-static void stpe_seek_prox(FrtSegmentTermDocEnum *stde, frt_off_t prx_ptr)
-{
+static void stpe_seek_prox(FrtSegmentTermDocEnum *stde, frt_off_t prx_ptr) {
     frt_is_seek(stde->prx_in, prx_ptr);
     stde->prx_cnt = 0;
 }
@@ -3039,8 +2167,7 @@ FrtTermDocEnum *frt_stpe_new(FrtTermInfosReader *tir,
                       FrtInStream *frq_in,
                       FrtInStream *prx_in,
                       FrtBitVector *del_docs,
-                      int skip_interval)
-{
+                      int skip_interval) {
     FrtTermDocEnum *tde         = frt_stde_new(tir, frq_in, del_docs, skip_interval);
     FrtSegmentTermDocEnum *stde = STDE(tde);
 
@@ -3069,8 +2196,7 @@ FrtTermDocEnum *frt_stpe_new(FrtTermInfosReader *tir,
 
 #define MTDE(tde) ((MultiTermDocEnum *)(tde))
 
-typedef struct MultiTermDocEnum
-{
+typedef struct MultiTermDocEnum {
     FrtTermDocEnum tde;
     int *starts;
     int base;
@@ -3083,16 +2209,14 @@ typedef struct MultiTermDocEnum
     FrtTermDocEnum *curr_tde;
 } MultiTermDocEnum;
 
-static FrtTermDocEnum *mtde_next_tde(MultiTermDocEnum *mtde)
-{
+static FrtTermDocEnum *mtde_next_tde(MultiTermDocEnum *mtde) {
     mtde->ptr++;
     while (mtde->ptr < mtde->ir_cnt && !mtde->state[mtde->ptr]) {
         mtde->ptr++;
     }
     if (mtde->ptr >= mtde->ir_cnt) {
         return mtde->curr_tde = NULL;
-    }
-    else {
+    } else {
         FrtTermDocEnum *tde = mtde->irs_tde[mtde->ptr];
         mtde->base = mtde->starts[mtde->ptr];
         return mtde->curr_tde = tde;
@@ -3106,8 +2230,7 @@ static FrtTermDocEnum *mtde_next_tde(MultiTermDocEnum *mtde)
     }\
 } while (0)
 
-static void mtde_seek_te(FrtTermDocEnum *tde, FrtTermEnum *te)
-{
+static void mtde_seek_te(FrtTermDocEnum *tde, FrtTermEnum *te) {
     int i;
     MultiTermDocEnum *mtde = MTDE(tde);
     memset(mtde->state, 0, mtde->ir_cnt);
@@ -3117,11 +2240,9 @@ static void mtde_seek_te(FrtTermDocEnum *tde, FrtTermEnum *te)
         mtde->state[index] = 1;
         if (tde->close == stde_close) {
             stde_seek_ti(STDE(tde), MTE(te)->tis + i);
-        }
-        else if (tde->close == stpe_close) {
+        } else if (tde->close == stpe_close) {
             stpe_seek_ti(STDE(tde), MTE(te)->tis + i);
-        }
-        else {
+        } else {
             tde->seek(tde, MTE(te)->tews[index].te->field_num, te->curr_term);
         }
     }
@@ -3130,48 +2251,40 @@ static void mtde_seek_te(FrtTermDocEnum *tde, FrtTermEnum *te)
     mtde_next_tde(mtde);
 }
 
-static void mtde_seek(FrtTermDocEnum *tde, int field_num, const char *term)
-{
+static void mtde_seek(FrtTermDocEnum *tde, int field_num, const char *term) {
     MultiTermDocEnum *mtde = MTDE(tde);
     FrtTermEnum *te = mtde->te;
     char *t;
     te->set_field(te, field_num);
     if (NULL != (t = te->skip_to(te, term)) && 0 == strcmp(term, t)) {
         mtde_seek_te(tde, te);
-    }
-    else {
+    } else {
         memset(mtde->state, 0, mtde->ir_cnt);
     }
 }
 
-static int mtde_doc_num(FrtTermDocEnum *tde)
-{
+static int mtde_doc_num(FrtTermDocEnum *tde) {
     CHECK_CURR_TDE("doc_num");
     return MTDE(tde)->base + MTDE(tde)->curr_tde->doc_num(MTDE(tde)->curr_tde);
 }
 
-static int mtde_freq(FrtTermDocEnum *tde)
-{
+static int mtde_freq(FrtTermDocEnum *tde) {
     CHECK_CURR_TDE("freq");
     return MTDE(tde)->curr_tde->freq(MTDE(tde)->curr_tde);
 }
 
-static bool mtde_next(FrtTermDocEnum *tde)
-{
+static bool mtde_next(FrtTermDocEnum *tde) {
     MultiTermDocEnum *mtde = MTDE(tde);
     if (NULL != mtde->curr_tde && mtde->curr_tde->next(mtde->curr_tde)) {
         return true;
-    }
-    else if (mtde_next_tde(mtde)) {
+    } else if (mtde_next_tde(mtde)) {
         return mtde_next(tde);
-    }
-    else {
+    } else {
         return false;
     }
 }
 
-static int mtde_read(FrtTermDocEnum *tde, int *docs, int *freqs, int req_num)
-{
+static int mtde_read(FrtTermDocEnum *tde, int *docs, int *freqs, int req_num) {
     int i, end = 0, last_end = 0, b;
     MultiTermDocEnum *mtde = MTDE(tde);
     while (true) {
@@ -3180,24 +2293,21 @@ static int mtde_read(FrtTermDocEnum *tde, int *docs, int *freqs, int req_num)
                                     freqs + last_end, req_num - last_end);
         if (end == last_end) {              /* none left in segment */
             if (!mtde_next_tde(mtde)) return end;
-        }
-        else {                            /* got some */
+        } else {                            /* got some */
             b = mtde->base;                 /* adjust doc numbers */
             for (i = last_end; i < end; i++) {
                 docs[i] += b;
             }
             if (end == req_num) {
                 return end;
-            }
-            else {
+            } else {
                 last_end = end;
             }
         }
     }
 }
 
-static bool mtde_skip_to(FrtTermDocEnum *tde, int target_doc_num)
-{
+static bool mtde_skip_to(FrtTermDocEnum *tde, int target_doc_num) {
     MultiTermDocEnum *mtde = MTDE(tde);
     FrtTermDocEnum *curr_tde;
     while (NULL != (curr_tde = mtde->curr_tde)) {
@@ -3211,8 +2321,7 @@ static bool mtde_skip_to(FrtTermDocEnum *tde, int target_doc_num)
     return false;
 }
 
-static void mtde_close(FrtTermDocEnum *tde)
-{
+static void mtde_close(FrtTermDocEnum *tde) {
     MultiTermDocEnum *mtde = MTDE(tde);
     FrtTermDocEnum *tmp_tde;
     int i = mtde->ir_cnt;
@@ -3227,8 +2336,7 @@ static void mtde_close(FrtTermDocEnum *tde)
     free(tde);
 }
 
-static FrtTermDocEnum *mtxe_new(FrtMultiReader *mr)
-{
+static FrtTermDocEnum *mtxe_new(FrtMultiReader *mr) {
     MultiTermDocEnum *mtde  = FRT_ALLOC_AND_ZERO(MultiTermDocEnum);
     FrtTermDocEnum *tde        = TDE(mtde);
     tde->seek               = &mtde_seek;
@@ -3250,8 +2358,7 @@ static FrtTermDocEnum *mtxe_new(FrtMultiReader *mr)
     return tde;
 }
 
-static FrtTermDocEnum *mtde_new(FrtMultiReader *mr)
-{
+static FrtTermDocEnum *mtde_new(FrtMultiReader *mr) {
     int i;
     FrtTermDocEnum *tde        = mtxe_new(mr);
     tde->next_position      = NULL;
@@ -3266,14 +2373,12 @@ static FrtTermDocEnum *mtde_new(FrtMultiReader *mr)
  * MultiTermPosEnum
  ****************************************************************************/
 
-static int mtpe_next_position(FrtTermDocEnum *tde)
-{
+static int mtpe_next_position(FrtTermDocEnum *tde) {
     CHECK_CURR_TDE("next_position");
     return MTDE(tde)->curr_tde->next_position(MTDE(tde)->curr_tde);
 }
 
-static FrtTermDocEnum *mtpe_new(FrtMultiReader *mr)
-{
+static FrtTermDocEnum *mtpe_new(FrtMultiReader *mr) {
     int i;
     FrtTermDocEnum *tde        = mtxe_new(mr);
     tde->next_position      = &mtpe_next_position;
@@ -3293,8 +2398,7 @@ static FrtTermDocEnum *mtpe_new(FrtMultiReader *mr)
 #define MTDPE(tde) ((MultipleTermDocPosEnum *)(tde))
 #define  MTDPE_POS_QUEUE_INIT_CAPA 8
 
-typedef struct
-{
+typedef struct {
     FrtTermDocEnum tde;
     int doc_num;
     int freq;
@@ -3309,8 +2413,7 @@ static void tde_destroy(FrtTermDocEnum *tde) {
     tde->close(tde);
 }
 
-static void mtdpe_seek(FrtTermDocEnum *tde, int field_num, const char *term)
-{
+static void mtdpe_seek(FrtTermDocEnum *tde, int field_num, const char *term) {
     (void)tde;
     (void)field_num;
     (void)term;
@@ -3318,18 +2421,15 @@ static void mtdpe_seek(FrtTermDocEnum *tde, int field_num, const char *term)
           " the #seek operation");
 }
 
-static int mtdpe_doc_num(FrtTermDocEnum *tde)
-{
+static int mtdpe_doc_num(FrtTermDocEnum *tde) {
     return MTDPE(tde)->doc_num;
 }
 
-static int mtdpe_freq(FrtTermDocEnum *tde)
-{
+static int mtdpe_freq(FrtTermDocEnum *tde) {
     return MTDPE(tde)->freq;
 }
 
-static bool mtdpe_next(FrtTermDocEnum *tde)
-{
+static bool mtdpe_next(FrtTermDocEnum *tde) {
     FrtTermDocEnum *sub_tde;
     int pos = 0, freq = 0;
     int doc;
@@ -3358,8 +2458,7 @@ static bool mtdpe_next(FrtTermDocEnum *tde)
 
         if (sub_tde->next(sub_tde)) {
             frt_pq_down(mtdpe->pq);
-        }
-        else {
+        } else {
             sub_tde = (FrtTermDocEnum *)frt_pq_pop(mtdpe->pq);
             sub_tde->close(sub_tde);
         }
@@ -3375,13 +2474,11 @@ static bool mtdpe_next(FrtTermDocEnum *tde)
     return true;
 }
 
-static bool tdpe_less_than(FrtTermDocEnum *p1, FrtTermDocEnum *p2)
-{
+static bool tdpe_less_than(FrtTermDocEnum *p1, FrtTermDocEnum *p2) {
     return p1->doc_num(p1) < p2->doc_num(p2);
 }
 
-static bool mtdpe_skip_to(FrtTermDocEnum *tde, int target_doc_num)
-{
+static bool mtdpe_skip_to(FrtTermDocEnum *tde, int target_doc_num) {
     FrtTermDocEnum *sub_tde;
     FrtPriorityQueue *mtdpe_pq = MTDPE(tde)->pq;
 
@@ -3389,8 +2486,7 @@ static bool mtdpe_skip_to(FrtTermDocEnum *tde, int target_doc_num)
            && (target_doc_num > sub_tde->doc_num(sub_tde))) {
         if (sub_tde->skip_to(sub_tde, target_doc_num)) {
             frt_pq_down(mtdpe_pq);
-        }
-        else {
+        } else {
             sub_tde = (FrtTermDocEnum *)frt_pq_pop(mtdpe_pq);
             sub_tde->close(sub_tde);
         }
@@ -3398,8 +2494,7 @@ static bool mtdpe_skip_to(FrtTermDocEnum *tde, int target_doc_num)
     return tde->next(tde);
 }
 
-static int mtdpe_read(FrtTermDocEnum *tde, int *docs, int *freqs, int req_num)
-{
+static int mtdpe_read(FrtTermDocEnum *tde, int *docs, int *freqs, int req_num) {
     (void)tde;
     (void)docs;
     (void)freqs;
@@ -3408,21 +2503,18 @@ static int mtdpe_read(FrtTermDocEnum *tde, int *docs, int *freqs, int req_num)
     return req_num;
 }
 
-static int mtdpe_next_position(FrtTermDocEnum *tde)
-{
+static int mtdpe_next_position(FrtTermDocEnum *tde) {
     return MTDPE(tde)->pos_queue[MTDPE(tde)->pos_queue_index++];
 }
 
-static void mtdpe_close(FrtTermDocEnum *tde)
-{
+static void mtdpe_close(FrtTermDocEnum *tde) {
     frt_pq_clear(MTDPE(tde)->pq);
     frt_pq_destroy(MTDPE(tde)->pq);
     free(MTDPE(tde)->pos_queue);
     free(tde);
 }
 
-FrtTermDocEnum *frt_mtdpe_new(FrtIndexReader *ir, int field_num, char **terms, int t_cnt)
-{
+FrtTermDocEnum *frt_mtdpe_new(FrtIndexReader *ir, int field_num, char **terms, int t_cnt) {
     int i;
     MultipleTermDocPosEnum *mtdpe = FRT_ALLOC_AND_ZERO(MultipleTermDocPosEnum);
     FrtTermDocEnum *tde = TDE(mtdpe);
@@ -3437,8 +2529,7 @@ FrtTermDocEnum *frt_mtdpe_new(FrtIndexReader *ir, int field_num, char **terms, i
         tpe->seek(tpe, field_num, terms[i]);
         if (tpe->next(tpe)) {
             frt_pq_push(pq, tpe);
-        }
-        else {
+        } else {
             tpe->close(tpe);
         }
     }
@@ -3471,26 +2562,22 @@ static void file_name_filter_init(void) {
     frt_register_for_cleanup(fn_extensions, (frt_free_ft)&frt_h_destroy);
 }
 
-bool frt_file_name_filter_is_index_file(const char *file_name, bool include_locks)
-{
+bool frt_file_name_filter_is_index_file(const char *file_name, bool include_locks) {
     char *p = strrchr(file_name, '.');
     if (NULL == fn_extensions) file_name_filter_init();
     if (NULL != p) {
         char *extension = p + 1;
         if (NULL != frt_h_get(fn_extensions, extension)) {
             return true;
-        }
-        else if ((*extension == 'f' || *extension == 's')
+        } else if ((*extension == 'f' || *extension == 's')
                  && *(extension + 1) >= '0'
                  && *(extension + 1) <= '9') {
             return true;
-        }
-        else if (include_locks && (strcmp(extension, "lck") == 0)
+        } else if (include_locks && (strcmp(extension, "lck") == 0)
                                && (strncmp(file_name, "ferret", 6) == 0)) {
             return true;
         }
-    }
-    else if (0 == strncmp(FRT_SEGMENTS_FILE_NAME, file_name,
+    } else if (0 == strncmp(FRT_SEGMENTS_FILE_NAME, file_name,
                           sizeof(FRT_SEGMENTS_FILE_NAME) - 1)) {
         return true;
     }
@@ -3526,8 +2613,8 @@ void frt_deleter_queue_file(FrtDeleter *dlr, const char *file_name) {
 void frt_deleter_delete_file(FrtDeleter *dlr, char *file_name) {
     FrtStore *store = dlr->store;
     FRT_TRY
-        if (store->exists(store, file_name)) {
-            store->remove(store, file_name);
+        if (store->exists(store, segm_idx_name, file_name)) {
+            store->remove(store, segm_idx_name, file_name);
         }
         frt_hs_del(dlr->pending, file_name);
     FRT_XCATCHALL
@@ -3642,20 +2729,18 @@ void frt_deleter_find_deletable_files(FrtDeleter *dlr) {
      * info: */
     frt_sis_curr_seg_file_name(dfa.curr_seg_file_name, store);
 
-    store->each(store, &frt_deleter_find_deletable_files_i, &dfa);
+    store->each(store, segm_idx_name, &frt_deleter_find_deletable_files_i, &dfa);
     frt_h_destroy(dfa.current);
 }
 
-static void deleter_delete_deletable_files(FrtDeleter *dlr)
-{
+static void deleter_delete_deletable_files(FrtDeleter *dlr) {
     frt_deleter_find_deletable_files(dlr);
     deleter_commit_pending_deletions(dlr);
 }
 
 /*
 TODO: currently not used. Why not?
-static void deleter_clear_pending_deletions(FrtDeleter *dlr)
-{
+static void deleter_clear_pending_deletions(FrtDeleter *dlr) {
     frt_hs_clear(dlr->pending);
 }
 */
@@ -3666,14 +2751,12 @@ static void deleter_clear_pending_deletions(FrtDeleter *dlr)
  *
  ****************************************************************************/
 
-static void ir_acquire_not_necessary(FrtIndexReader *ir)
-{
+static void ir_acquire_not_necessary(FrtIndexReader *ir) {
     (void)ir;
 }
 
 #define I64_PFX POSH_I64_PRINTF_PREFIX
-static void ir_acquire_write_lock(FrtIndexReader *ir)
-{
+static void ir_acquire_write_lock(FrtIndexReader *ir) {
     if (ir->is_stale) {
         FRT_RAISE(FRT_STATE_ERROR, "IndexReader out of date and no longer valid for "
                            "delete, undelete, or set_norm operations. To "
@@ -3682,7 +2765,7 @@ static void ir_acquire_write_lock(FrtIndexReader *ir)
     }
 
     if (NULL == ir->write_lock) {
-        ir->write_lock = frt_open_lock(ir->store, FRT_WRITE_LOCK_NAME);
+        ir->write_lock = frt_open_lock(ir->store, segm_idx_name, FRT_WRITE_LOCK_NAME);
         if (!ir->write_lock->obtain(ir->write_lock)) {/* obtain write lock */
             FRT_RAISE(FRT_LOCK_ERROR, "Could not obtain write lock when trying to "
                               "write changes to the index. Check that there "
@@ -3728,8 +2811,7 @@ static FrtIndexReader *ir_setup(FrtIndexReader *ir, FrtStore *store, FrtSegmentI
     ir->is_owner = is_owner;
     if (is_owner) {
         ir->acquire_write_lock = &ir_acquire_write_lock;
-    }
-    else {
+    } else {
         ir->acquire_write_lock = &ir_acquire_not_necessary;
     }
 
@@ -3740,8 +2822,7 @@ int frt_ir_doc_freq(FrtIndexReader *ir, ID field, const char *term) {
     int field_num = frt_fis_get_field_num(ir->fis, field);
     if (field_num >= 0) {
         return ir->doc_freq(ir, field_num, term);
-    }
-    else {
+    } else {
         return 0;
     }
 }
@@ -3761,8 +2842,7 @@ void frt_ir_set_norm(FrtIndexReader *ir, int doc_num, ID field, frt_uchar val) {
     }
 }
 
-frt_uchar *frt_ir_get_norms_i(FrtIndexReader *ir, int field_num)
-{
+frt_uchar *frt_ir_get_norms_i(FrtIndexReader *ir, int field_num) {
     frt_uchar *norms = NULL;
     if (field_num >= 0) {
         norms = ir->get_norms(ir, field_num);
@@ -3785,15 +2865,13 @@ frt_uchar *frt_ir_get_norms_into(FrtIndexReader *ir, ID field, frt_uchar *buf) {
     int field_num = frt_fis_get_field_num(ir->fis, field);
     if (field_num >= 0) {
         ir->get_norms_into(ir, field_num, buf);
-    }
-    else {
+    } else {
         memset(buf, 0, ir->max_doc(ir));
     }
     return buf;
 }
 
-void frt_ir_undelete_all(FrtIndexReader *ir)
-{
+void frt_ir_undelete_all(FrtIndexReader *ir) {
     pthread_mutex_lock(&ir->mutex);
     ir->acquire_write_lock(ir);
     ir->undelete_all_i(ir);
@@ -3801,8 +2879,7 @@ void frt_ir_undelete_all(FrtIndexReader *ir)
     pthread_mutex_unlock(&ir->mutex);
 }
 
-void frt_ir_delete_doc(FrtIndexReader *ir, int doc_num)
-{
+void frt_ir_delete_doc(FrtIndexReader *ir, int doc_num) {
     if (doc_num >= 0 && doc_num < ir->max_doc(ir)) {
         pthread_mutex_lock(&ir->mutex);
         ir->acquire_write_lock(ir);
@@ -3861,8 +2938,7 @@ FrtTermDocEnum *frt_ir_term_positions_for(FrtIndexReader *ir, ID field, const ch
     return tde;
 }
 
-static void ir_commit_i(FrtIndexReader *ir)
-{
+static void ir_commit_i(FrtIndexReader *ir) {
     if (ir->has_changes) {
         if (NULL == ir->deleter && NULL != ir->store) {
             /* In the MultiReader case, we share this deleter across all
@@ -3888,16 +2964,14 @@ static void ir_commit_i(FrtIndexReader *ir)
                 frt_close_lock(ir->write_lock);
                 ir->write_lock = NULL;
             }
-        }
-        else {
+        } else {
             ir->commit_i(ir);
         }
     }
     ir->has_changes = false;
 }
 
-void frt_ir_commit(FrtIndexReader *ir)
-{
+void frt_ir_commit(FrtIndexReader *ir) {
     pthread_mutex_lock(&ir->mutex);
     ir_commit_i(ir);
     pthread_mutex_unlock(&ir->mutex);
@@ -3930,15 +3004,13 @@ void frt_ir_close(FrtIndexReader *ir) {
 /**
  * Don't call this method if the cache already exists
  **/
-void frt_ir_add_cache(FrtIndexReader *ir)
-{
+void frt_ir_add_cache(FrtIndexReader *ir) {
     if (NULL == ir->cache) {
         ir->cache = frt_co_hash_create();
     }
 }
 
-bool frt_ir_is_latest(FrtIndexReader *ir)
-{
+bool frt_ir_is_latest(FrtIndexReader *ir) {
     return ir->is_latest_i(ir);
 }
 
@@ -3953,8 +3025,7 @@ typedef struct Norm {
     bool is_dirty : 1;
 } Norm;
 
-static Norm *norm_create(FrtInStream *is, int field_num)
-{
+static Norm *norm_create(FrtInStream *is, int field_num) {
     Norm *norm = FRT_ALLOC(Norm);
 
     norm->is = is;
@@ -3966,8 +3037,7 @@ static Norm *norm_create(FrtInStream *is, int field_num)
     return norm;
 }
 
-static void norm_destroy(Norm *norm)
-{
+static void norm_destroy(Norm *norm) {
     frt_is_close(norm->is);
     if (NULL != norm->bytes) {
         free(norm->bytes);
@@ -3976,8 +3046,7 @@ static void norm_destroy(Norm *norm)
 }
 
 static void norm_rewrite(Norm *norm, FrtStore *store, FrtDeleter *dlr,
-                         FrtSegmentInfo *si, int doc_count)
-{
+                         FrtSegmentInfo *si, int doc_count) {
     FrtOutStream *os;
     char norm_file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
     const int field_num = norm->field_num;
@@ -3987,7 +3056,7 @@ static void norm_rewrite(Norm *norm, FrtStore *store, FrtDeleter *dlr,
     }
     frt_si_advance_norm_gen(si, field_num);
     si_norm_file_name(si, norm_file_name, field_num);
-    os = store->new_output(store, norm_file_name);
+    os = store->new_output(store, segm_idx_name, norm_file_name);
     frt_os_write_bytes(os, norm->bytes, doc_count);
     frt_os_close(os);
     norm->is_dirty = false;
@@ -4011,8 +3080,7 @@ static FrtFieldsReader *sr_fr(FrtSegmentReader *sr) {
     return fr;
 }
 
-static bool sr_is_deleted_i(FrtSegmentReader *sr, int doc_num)
-{
+static bool sr_is_deleted_i(FrtSegmentReader *sr, int doc_num) {
     return (NULL != sr->deleted_docs && frt_bv_get(sr->deleted_docs, doc_num));
 }
 
@@ -4080,10 +3148,9 @@ static void sr_set_deleter_i(FrtIndexReader *ir, FrtDeleter *deleter) {
   ir->deleter = deleter;
 }
 
-static void bv_write(FrtBitVector *bv, FrtStore *store, char *name)
-{
+static void bv_write(FrtBitVector *bv, FrtStore *store, char *name) {
     int i;
-    FrtOutStream *os = store->new_output(store, name);
+    FrtOutStream *os = store->new_output(store, segm_idx_name, name);
     frt_os_write_vint(os, bv->size);
     for (i = ((bv->size-1) >> 5); i >= 0; i--) {
         frt_os_write_u32(os, bv->bits[i]);
@@ -4091,11 +3158,10 @@ static void bv_write(FrtBitVector *bv, FrtStore *store, char *name)
     frt_os_close(os);
 }
 
-static FrtBitVector *bv_read(FrtStore *store, char *name)
-{
+static FrtBitVector *bv_read(FrtStore *store, char *name) {
     int i;
     volatile bool success = false;
-    FrtInStream *volatile is = store->open_input(store, name);
+    FrtInStream *volatile is = store->open_input(store, segm_idx_name, name);
     FrtBitVector *volatile bv = FRT_ALLOC_AND_ZERO(FrtBitVector);
     bv->size = (int)frt_is_read_vint(is);
     bv->capa = (bv->size >> 5) + 1;
@@ -4114,13 +3180,11 @@ static FrtBitVector *bv_read(FrtStore *store, char *name)
     return bv;
 }
 
-static bool sr_is_latest_i(FrtIndexReader *ir)
-{
+static bool sr_is_latest_i(FrtIndexReader *ir) {
     return (frt_sis_read_current_version(ir->store) == ir->sis->version);
 }
 
-static void sr_commit_i(FrtIndexReader *ir)
-{
+static void sr_commit_i(FrtIndexReader *ir) {
     FrtSegmentInfo *si = SR(ir)->si;
     char *segment = SR(ir)->si->name;
     char tmp_file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
@@ -4133,8 +3197,7 @@ static void sr_commit_i(FrtIndexReader *ir)
         if (SR(ir)->undelete_all) {
             si->del_gen = -1;
             SR(ir)->undelete_all = false;
-        }
-        else {
+        } else {
             /* (SR(ir)->deleted_docs_dirty) re-write deleted */
             si->del_gen++;
             frt_fn_for_generation(tmp_file_name, segment, "del", si->del_gen);
@@ -4177,8 +3240,7 @@ static void sr_close_i(FrtIndexReader *ir) {
     }
 }
 
-static int sr_num_docs(FrtIndexReader *ir)
-{
+static int sr_num_docs(FrtIndexReader *ir) {
     int num_docs;
 
     pthread_mutex_lock(&ir->mutex);
@@ -4190,13 +3252,11 @@ static int sr_num_docs(FrtIndexReader *ir)
     return num_docs;
 }
 
-static int sr_max_doc(FrtIndexReader *ir)
-{
+static int sr_max_doc(FrtIndexReader *ir) {
     return SR(ir)->fr->size;
 }
 
-static FrtDocument *sr_get_doc(FrtIndexReader *ir, int doc_num)
-{
+static FrtDocument *sr_get_doc(FrtIndexReader *ir, int doc_num) {
     FrtDocument *doc;
     pthread_mutex_lock(&ir->mutex);
     if (sr_is_deleted_i(SR(ir), doc_num)) {
@@ -4208,8 +3268,7 @@ static FrtDocument *sr_get_doc(FrtIndexReader *ir, int doc_num)
     return doc;
 }
 
-static FrtLazyDoc *sr_get_lazy_doc(FrtIndexReader *ir, int doc_num)
-{
+static FrtLazyDoc *sr_get_lazy_doc(FrtIndexReader *ir, int doc_num) {
     FrtLazyDoc *lazy_doc;
     pthread_mutex_lock(&ir->mutex);
     if (sr_is_deleted_i(SR(ir), doc_num)) {
@@ -4221,8 +3280,7 @@ static FrtLazyDoc *sr_get_lazy_doc(FrtIndexReader *ir, int doc_num)
     return lazy_doc;
 }
 
-static frt_uchar *sr_get_norms(FrtIndexReader *ir, int field_num)
-{
+static frt_uchar *sr_get_norms(FrtIndexReader *ir, int field_num) {
     frt_uchar *norms;
     pthread_mutex_lock(&ir->mutex);
     norms = sr_get_norms_i(SR(ir), field_num);
@@ -4231,23 +3289,20 @@ static frt_uchar *sr_get_norms(FrtIndexReader *ir, int field_num)
 }
 
 static frt_uchar *sr_get_norms_into(FrtIndexReader *ir, int field_num,
-                              frt_uchar *buf)
-{
+                              frt_uchar *buf) {
     pthread_mutex_lock(&ir->mutex);
     sr_get_norms_into_i(SR(ir), field_num, buf);
     pthread_mutex_unlock(&ir->mutex);
     return buf;
 }
 
-static FrtTermEnum *sr_terms(FrtIndexReader *ir, int field_num)
-{
+static FrtTermEnum *sr_terms(FrtIndexReader *ir, int field_num) {
     FrtTermEnum *te = SR(ir)->tir->orig_te;
     te = frt_ste_clone(te);
     return ste_set_field(te, field_num);
 }
 
-static FrtTermEnum *sr_terms_from(FrtIndexReader *ir, int field_num, const char *term)
-{
+static FrtTermEnum *sr_terms_from(FrtIndexReader *ir, int field_num, const char *term) {
     FrtTermEnum *te = SR(ir)->tir->orig_te;
     te = frt_ste_clone(te);
     ste_set_field(te, field_num);
@@ -4255,20 +3310,17 @@ static FrtTermEnum *sr_terms_from(FrtIndexReader *ir, int field_num, const char
     return te;
 }
 
-static int sr_doc_freq(FrtIndexReader *ir, int field_num, const char *term)
-{
+static int sr_doc_freq(FrtIndexReader *ir, int field_num, const char *term) {
     FrtTermInfo *ti = frt_tir_get_ti(frt_tir_set_field(SR(ir)->tir, field_num), term);
     return ti ? ti->doc_freq : 0;
 }
 
-static FrtTermDocEnum *sr_term_docs(FrtIndexReader *ir)
-{
+static FrtTermDocEnum *sr_term_docs(FrtIndexReader *ir) {
     return frt_stde_new(SR(ir)->tir, SR(ir)->frq_in, SR(ir)->deleted_docs,
                     STE(SR(ir)->tir->orig_te)->skip_interval);
 }
 
-static FrtTermDocEnum *sr_term_positions(FrtIndexReader *ir)
-{
+static FrtTermDocEnum *sr_term_positions(FrtIndexReader *ir) {
     FrtSegmentReader *sr = SR(ir);
     return frt_stpe_new(sr->tir, sr->frq_in, sr->prx_in, sr->deleted_docs,
                     STE(sr->tir->orig_te)->skip_interval);
@@ -4285,8 +3337,7 @@ static FrtTermVector *sr_term_vector(FrtIndexReader *ir, int doc_num, ID field)
     return frt_fr_get_field_tv(fr, doc_num, fi->number);
 }
 
-static FrtHash *sr_term_vectors(FrtIndexReader *ir, int doc_num)
-{
+static FrtHash *sr_term_vectors(FrtIndexReader *ir, int doc_num) {
     FrtFieldsReader *fr;
     if (!SR(ir)->fr || NULL == (fr = sr_fr(SR(ir)))) {
         return NULL;
@@ -4295,8 +3346,7 @@ static FrtHash *sr_term_vectors(FrtIndexReader *ir, int doc_num)
     return frt_fr_get_tv(fr, doc_num);
 }
 
-static bool sr_is_deleted(FrtIndexReader *ir, int doc_num)
-{
+static bool sr_is_deleted(FrtIndexReader *ir, int doc_num) {
     bool is_del;
 
     pthread_mutex_lock(&ir->mutex);
@@ -4306,13 +3356,11 @@ static bool sr_is_deleted(FrtIndexReader *ir, int doc_num)
     return is_del;
 }
 
-static bool sr_has_deletions(FrtIndexReader *ir)
-{
+static bool sr_has_deletions(FrtIndexReader *ir) {
     return NULL != SR(ir)->deleted_docs;
 }
 
-static void sr_open_norms(FrtIndexReader *ir, FrtStore *cfs_store)
-{
+static void sr_open_norms(FrtIndexReader *ir, FrtStore *cfs_store) {
     int i;
     FrtSegmentInfo *si = SR(ir)->si;
     char file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
@@ -4320,7 +3368,7 @@ static void sr_open_norms(FrtIndexReader *ir, FrtStore *cfs_store)
     for (i = si->norm_gens_size - 1; i >= 0; i--) {
         FrtStore *store = ir->store;
         if (si_norm_file_name(si, file_name, i)) {
-            FrtInStream *is = store->open_input(store, file_name);
+            FrtInStream *is = store->open_input(store, segm_idx_name, file_name);
             FRT_DEREF(is);
             frt_h_set_int(SR(ir)->norms, i, norm_create(is, i));
         }
@@ -4328,8 +3376,7 @@ static void sr_open_norms(FrtIndexReader *ir, FrtStore *cfs_store)
     SR(ir)->norms_dirty = false;
 }
 
-static FrtIndexReader *sr_setup_i(FrtSegmentReader *sr)
-{
+static FrtIndexReader *sr_setup_i(FrtSegmentReader *sr) {
     FrtStore *volatile store = sr->si->store;
     FrtIndexReader *ir = IR(sr);
     char file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
@@ -4378,12 +3425,12 @@ static FrtIndexReader *sr_setup_i(FrtSegmentReader *sr)
         }
 
         sprintf(file_name, "%s.frq", sr_segment);
-        sr->frq_in = store->open_input(store, file_name);
+        sr->frq_in = store->open_input(store, segm_idx_name, file_name);
         sprintf(file_name, "%s.prx", sr_segment);
-        sr->prx_in = store->open_input(store, file_name);
+        sr->prx_in = store->open_input(store, segm_idx_name, file_name);
         sr->norms = frt_h_new_int((frt_free_ft)&norm_destroy);
         sr_open_norms(ir, store);
-        if (fis_has_vectors(ir->fis)) {
+        if (frt_fis_has_vectors(ir->fis)) {
             frb_thread_key_create(&sr->thread_fr, NULL);
             sr->fr_bucket = frt_ary_new();
         }
@@ -4413,8 +3460,7 @@ static FrtIndexReader *sr_open(FrtSegmentInfos *sis, FrtFieldInfos *fis, int si_
 
 #define MR(ir) ((FrtMultiReader *)(ir))
 
-static int mr_reader_index_i(FrtMultiReader *mr, int doc_num)
-{
+static int mr_reader_index_i(FrtMultiReader *mr, int doc_num) {
     int lo = 0;                       /* search @starts array */
     int hi = mr->r_cnt - 1;            /* for first element less */
     int mid;
@@ -4425,11 +3471,9 @@ static int mr_reader_index_i(FrtMultiReader *mr, int doc_num)
         mid_value = mr->starts[mid];
         if (doc_num < mid_value) {
             hi = mid - 1;
-        }
-        else if (doc_num > mid_value) {
+        } else if (doc_num > mid_value) {
             lo = mid + 1;
-        }
-        else { /* found a match */
+        } else { /* found a match */
             while ((mid+1 < mr->r_cnt) && (mr->starts[mid+1] == mid_value)) {
                 mid += 1; /* scan to last match in case we have empty segments */
             }
@@ -4439,8 +3483,7 @@ static int mr_reader_index_i(FrtMultiReader *mr, int doc_num)
     return hi;
 }
 
-static int mr_num_docs(FrtIndexReader *ir)
-{
+static int mr_num_docs(FrtIndexReader *ir) {
     int i, num_docs;
     pthread_mutex_lock(&ir->mutex);
     if (MR(ir)->num_docs_cache == -1) {
@@ -4457,8 +3500,7 @@ static int mr_num_docs(FrtIndexReader *ir)
     return num_docs;
 }
 
-static int mr_max_doc(FrtIndexReader *ir)
-{
+static int mr_max_doc(FrtIndexReader *ir) {
     return MR(ir)->max_doc;
 }
 
@@ -4466,30 +3508,25 @@ static int mr_max_doc(FrtIndexReader *ir)
     int i = mr_reader_index_i(MR(ir), doc_num);\
     FrtIndexReader *reader = MR(ir)->sub_readers[i]
 
-static FrtDocument *mr_get_doc(FrtIndexReader *ir, int doc_num)
-{
+static FrtDocument *mr_get_doc(FrtIndexReader *ir, int doc_num) {
     GET_READER();
     return reader->get_doc(reader, doc_num - MR(ir)->starts[i]);
 }
 
-static FrtLazyDoc *mr_get_lazy_doc(FrtIndexReader *ir, int doc_num)
-{
+static FrtLazyDoc *mr_get_lazy_doc(FrtIndexReader *ir, int doc_num) {
     GET_READER();
     return reader->get_lazy_doc(reader, doc_num - MR(ir)->starts[i]);
 }
 
-int frt_mr_get_field_num(FrtMultiReader *mr, int ir_num, int f_num)
-{
+int frt_mr_get_field_num(FrtMultiReader *mr, int ir_num, int f_num) {
     if (mr->field_num_map) {
         return mr->field_num_map[ir_num][f_num];
-    }
-    else {
+    } else {
         return f_num;
     }
 }
 
-static frt_uchar *mr_get_norms(FrtIndexReader *ir, int field_num)
-{
+static frt_uchar *mr_get_norms(FrtIndexReader *ir, int field_num) {
     frt_uchar *bytes;
 
     pthread_mutex_lock(&ir->mutex);
@@ -4514,16 +3551,14 @@ static frt_uchar *mr_get_norms(FrtIndexReader *ir, int field_num)
     return bytes;
 }
 
-static frt_uchar *mr_get_norms_into(FrtIndexReader *ir, int field_num, frt_uchar *buf)
-{
+static frt_uchar *mr_get_norms_into(FrtIndexReader *ir, int field_num, frt_uchar *buf) {
     frt_uchar *bytes;
 
     pthread_mutex_lock(&ir->mutex);
     bytes = (frt_uchar *)frt_h_get_int(MR(ir)->norms_cache, field_num);
     if (NULL != bytes) {
         memcpy(buf, bytes, MR(ir)->max_doc);
-    }
-    else {
+    } else {
         int i;
         const int mr_reader_cnt = MR(ir)->r_cnt;
         for (i = 0; i < mr_reader_cnt; i++) {
@@ -4538,18 +3573,15 @@ static frt_uchar *mr_get_norms_into(FrtIndexReader *ir, int field_num, frt_uchar
     return buf;
 }
 
-static FrtTermEnum *mr_terms(FrtIndexReader *ir, int field_num)
-{
+static FrtTermEnum *mr_terms(FrtIndexReader *ir, int field_num) {
     return frt_mte_new(MR(ir), field_num, NULL);
 }
 
-static FrtTermEnum *mr_terms_from(FrtIndexReader *ir, int field_num, const char *term)
-{
+static FrtTermEnum *mr_terms_from(FrtIndexReader *ir, int field_num, const char *term) {
     return frt_mte_new(MR(ir), field_num, term);
 }
 
-static int mr_doc_freq(FrtIndexReader *ir, int field_num, const char *t)
-{
+static int mr_doc_freq(FrtIndexReader *ir, int field_num, const char *t) {
     int total = 0;          /* sum freqs in segments */
     int i = MR(ir)->r_cnt;
     for (i = MR(ir)->r_cnt - 1; i >= 0; i--) {
@@ -4562,13 +3594,11 @@ static int mr_doc_freq(FrtIndexReader *ir, int field_num, const char *t)
     return total;
 }
 
-static FrtTermDocEnum *mr_term_docs(FrtIndexReader *ir)
-{
+static FrtTermDocEnum *mr_term_docs(FrtIndexReader *ir) {
     return mtde_new(MR(ir));
 }
 
-static FrtTermDocEnum *mr_term_positions(FrtIndexReader *ir)
-{
+static FrtTermDocEnum *mr_term_positions(FrtIndexReader *ir) {
     return mtpe_new(MR(ir));
 }
 
@@ -4577,25 +3607,21 @@ static FrtTermVector *mr_term_vector(FrtIndexReader *ir, int doc_num, ID field)
     return reader->term_vector(reader, doc_num - MR(ir)->starts[i], field);
 }
 
-static FrtHash *mr_term_vectors(FrtIndexReader *ir, int doc_num)
-{
+static FrtHash *mr_term_vectors(FrtIndexReader *ir, int doc_num) {
     GET_READER();
     return reader->term_vectors(reader, doc_num - MR(ir)->starts[i]);
 }
 
-static bool mr_is_deleted(FrtIndexReader *ir, int doc_num)
-{
+static bool mr_is_deleted(FrtIndexReader *ir, int doc_num) {
     GET_READER();
     return reader->is_deleted(reader, doc_num - MR(ir)->starts[i]);
 }
 
-static bool mr_has_deletions(FrtIndexReader *ir)
-{
+static bool mr_has_deletions(FrtIndexReader *ir) {
     return MR(ir)->has_deletions;
 }
 
-static void mr_set_norm_i(FrtIndexReader *ir, int doc_num, int field_num, frt_uchar val)
-{
+static void mr_set_norm_i(FrtIndexReader *ir, int doc_num, int field_num, frt_uchar val) {
     int i = mr_reader_index_i(MR(ir), doc_num);
     int fnum = frt_mr_get_field_num(MR(ir), i, field_num);
     if (fnum >= 0) {
@@ -4606,8 +3632,7 @@ static void mr_set_norm_i(FrtIndexReader *ir, int doc_num, int field_num, frt_uc
     }
 }
 
-static void mr_delete_doc_i(FrtIndexReader *ir, int doc_num)
-{
+static void mr_delete_doc_i(FrtIndexReader *ir, int doc_num) {
     GET_READER();
     MR(ir)->num_docs_cache = -1; /* invalidate cache */
 
@@ -4617,8 +3642,7 @@ static void mr_delete_doc_i(FrtIndexReader *ir, int doc_num)
     ir->has_changes = true;
 }
 
-static void mr_undelete_all_i(FrtIndexReader *ir)
-{
+static void mr_undelete_all_i(FrtIndexReader *ir) {
     int i;
     const int mr_reader_cnt = MR(ir)->r_cnt;
 
@@ -4631,8 +3655,7 @@ static void mr_undelete_all_i(FrtIndexReader *ir)
     ir->has_changes = true;
 }
 
-static void mr_set_deleter_i(FrtIndexReader *ir, FrtDeleter *deleter)
-{
+static void mr_set_deleter_i(FrtIndexReader *ir, FrtDeleter *deleter) {
     int i;
     ir->deleter = deleter;
     for (i = MR(ir)->r_cnt - 1; i >= 0; i--) {
@@ -4641,8 +3664,7 @@ static void mr_set_deleter_i(FrtIndexReader *ir, FrtDeleter *deleter)
     }
 }
 
-static bool mr_is_latest_i(FrtIndexReader *ir)
-{
+static bool mr_is_latest_i(FrtIndexReader *ir) {
     int i;
     const int mr_reader_cnt = MR(ir)->r_cnt;
     for (i = 0; i < mr_reader_cnt; i++) {
@@ -4653,8 +3675,7 @@ static bool mr_is_latest_i(FrtIndexReader *ir)
     return true;
 }
 
-static void mr_commit_i(FrtIndexReader *ir)
-{
+static void mr_commit_i(FrtIndexReader *ir) {
     int i;
     const int mr_reader_cnt = MR(ir)->r_cnt;
     for (i = 0; i < mr_reader_cnt; i++) {
@@ -4663,8 +3684,7 @@ static void mr_commit_i(FrtIndexReader *ir)
     }
 }
 
-static void mr_close_i(FrtIndexReader *ir)
-{
+static void mr_close_i(FrtIndexReader *ir) {
     int i;
     const int mr_reader_cnt = MR(ir)->r_cnt;
     for (i = 0; i < mr_reader_cnt; i++) {
@@ -4870,8 +3890,7 @@ FrtIndexReader *frt_ir_open(FrtIndexReader *ir, FrtStore *store) {
  *
  ****************************************************************************/
 
-static FrtOccurence *occ_new(FrtMemoryPool *mp, int pos)
-{
+static FrtOccurence *occ_new(FrtMemoryPool *mp, int pos) {
     FrtOccurence *occ = FRT_MP_ALLOC(mp, FrtOccurence);
     occ->pos = pos;
     occ->next = NULL;
@@ -4884,8 +3903,7 @@ static FrtOccurence *occ_new(FrtMemoryPool *mp, int pos)
  *
  ****************************************************************************/
 
-FrtPosting *frt_p_new(FrtMemoryPool *mp, int doc_num, int pos)
-{
+FrtPosting *frt_p_new(FrtMemoryPool *mp, int doc_num, int pos) {
     FrtPosting *p = FRT_MP_ALLOC(mp, FrtPosting);
     p->doc_num = doc_num;
     p->first_occ = occ_new(mp, pos);
@@ -4901,8 +3919,7 @@ FrtPosting *frt_p_new(FrtMemoryPool *mp, int doc_num, int pos)
  ****************************************************************************/
 
 FrtPostingList *frt_pl_new(FrtMemoryPool *mp, const char *term,
-                           int term_len, FrtPosting *p)
-{
+                           int term_len, FrtPosting *p) {
     // TODO account for term_len as measured in the original text vs utf8 term_len of term
     FrtPostingList *pl = FRT_MP_ALLOC(mp, FrtPostingList);
     pl->term = (char *)frt_mp_memdup(mp, term, term_len + 1);
@@ -4912,20 +3929,17 @@ FrtPostingList *frt_pl_new(FrtMemoryPool *mp, const char *term,
     return pl;
 }
 
-void frt_pl_add_occ(FrtMemoryPool *mp, FrtPostingList *pl, int pos)
-{
+void frt_pl_add_occ(FrtMemoryPool *mp, FrtPostingList *pl, int pos) {
     pl->last_occ = pl->last_occ->next = occ_new(mp, pos);
     pl->last->freq++;
 }
 
-static void pl_add_posting(FrtPostingList *pl, FrtPosting *p)
-{
+static void pl_add_posting(FrtPostingList *pl, FrtPosting *p) {
     pl->last = pl->last->next = p;
     pl->last_occ = p->first_occ;
 }
 
-int frt_pl_cmp(const FrtPostingList **pl1, const FrtPostingList **pl2)
-{
+int frt_pl_cmp(const FrtPostingList **pl1, const FrtPostingList **pl2) {
     return strcmp((*pl1)->term, (*pl2)->term);
 }
 
@@ -4935,8 +3949,7 @@ int frt_pl_cmp(const FrtPostingList **pl1, const FrtPostingList **pl2)
  *
  ****************************************************************************/
 
-static FrtFieldInverter *fld_inv_new(FrtDocWriter *dw, FrtFieldInfo *fi)
-{
+static FrtFieldInverter *fld_inv_new(FrtDocWriter *dw, FrtFieldInfo *fi) {
     FrtFieldInverter *fld_inv = FRT_MP_ALLOC(dw->mp, FrtFieldInverter);
     fld_inv->is_tokenized = bits_is_tokenized(fi->bits);
     fld_inv->store_term_vector = bits_store_term_vector(fi->bits);
@@ -4953,8 +3966,7 @@ static FrtFieldInverter *fld_inv_new(FrtDocWriter *dw, FrtFieldInfo *fi)
     return fld_inv;
 }
 
-static void fld_inv_destroy(FrtFieldInverter *fld_inv)
-{
+static void fld_inv_destroy(FrtFieldInverter *fld_inv) {
     frt_h_destroy(fld_inv->plists);
 }
 
@@ -4964,8 +3976,7 @@ static void fld_inv_destroy(FrtFieldInverter *fld_inv)
  *
  ****************************************************************************/
 
-typedef struct SkipBuffer
-{
+typedef struct SkipBuffer {
     FrtOutStream *buf;
     FrtOutStream *frq_out;
     FrtOutStream *prx_out;
@@ -4974,16 +3985,14 @@ typedef struct SkipBuffer
     frt_off_t last_prx_ptr;
 } SkipBuffer;
 
-static void skip_buf_reset(SkipBuffer *skip_buf)
-{
+static void skip_buf_reset(SkipBuffer *skip_buf) {
     frt_ramo_reset(skip_buf->buf);
     skip_buf->last_doc = 0;
     skip_buf->last_frq_ptr = frt_os_pos(skip_buf->frq_out);
     skip_buf->last_prx_ptr = frt_os_pos(skip_buf->prx_out);
 }
 
-static SkipBuffer *skip_buf_new(FrtOutStream *frq_out, FrtOutStream *prx_out)
-{
+static SkipBuffer *skip_buf_new(FrtOutStream *frq_out, FrtOutStream *prx_out) {
     SkipBuffer *skip_buf = FRT_ALLOC(SkipBuffer);
     skip_buf->buf = frt_ram_new_buffer();
     skip_buf->frq_out = frq_out;
@@ -4991,8 +4000,7 @@ static SkipBuffer *skip_buf_new(FrtOutStream *frq_out, FrtOutStream *prx_out)
     return skip_buf;
 }
 
-static void skip_buf_add(SkipBuffer *skip_buf, int doc)
-{
+static void skip_buf_add(SkipBuffer *skip_buf, int doc) {
     frt_off_t frq_ptr = frt_os_pos(skip_buf->frq_out);
     frt_off_t prx_ptr = frt_os_pos(skip_buf->prx_out);
 
@@ -5005,15 +4013,13 @@ static void skip_buf_add(SkipBuffer *skip_buf, int doc)
     skip_buf->last_prx_ptr = prx_ptr;
 }
 
-static frt_off_t skip_buf_write(SkipBuffer *skip_buf)
-{
+static frt_off_t skip_buf_write(SkipBuffer *skip_buf) {
   frt_off_t skip_ptr = frt_os_pos(skip_buf->frq_out);
   frt_ramo_write_to(skip_buf->buf, skip_buf->frq_out);
   return skip_ptr;
 }
 
-static void skip_buf_destroy(SkipBuffer *skip_buf)
-{
+static void skip_buf_destroy(SkipBuffer *skip_buf) {
     frt_ram_destroy_buffer(skip_buf->buf);
     free(skip_buf);
 }
@@ -5024,21 +4030,19 @@ static void skip_buf_destroy(SkipBuffer *skip_buf)
  *
  ****************************************************************************/
 
-static void dw_write_norms(FrtDocWriter *dw, FrtFieldInverter *fld_inv)
-{
+static void dw_write_norms(FrtDocWriter *dw, FrtFieldInverter *fld_inv) {
     char file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
     FrtOutStream *norms_out;
     frt_si_advance_norm_gen(dw->si, fld_inv->fi->number);
     si_norm_file_name(dw->si, file_name, fld_inv->fi->number);
-    norms_out = dw->store->new_output(dw->store, file_name);
+    norms_out = dw->store->new_output(dw->store, segm_idx_name, file_name);
     frt_os_write_bytes(norms_out, fld_inv->norms, dw->doc_num);
     frt_os_close(norms_out);
 }
 
 /* we'll use the postings Hash's table area to sort the postings as it is
  * going to be zeroset soon anyway */
-static FrtPostingList **dw_sort_postings(FrtHash *plists_ht)
-{
+static FrtPostingList **dw_sort_postings(FrtHash *plists_ht) {
     int i, j;
     FrtHashEntry *he;
     FrtPostingList **plists = (FrtPostingList **)plists_ht->table;
@@ -5056,8 +4060,7 @@ static FrtPostingList **dw_sort_postings(FrtHash *plists_ht)
     return plists;
 }
 
-static void dw_flush_streams(FrtDocWriter *dw)
-{
+static void dw_flush_streams(FrtDocWriter *dw) {
     frt_mp_reset(dw->mp);
     frt_fw_close(dw->fw);
     dw->fw = NULL;
@@ -5065,8 +4068,7 @@ static void dw_flush_streams(FrtDocWriter *dw)
     dw->doc_num = 0;
 }
 
-static void dw_flush(FrtDocWriter *dw)
-{
+static void dw_flush(FrtDocWriter *dw) {
     int i, j, last_doc, doc_code, doc_freq, last_pos, posting_count;
     int skip_interval = dw->skip_interval;
     FrtFieldInfos *fis = dw->fis;
@@ -5084,9 +4086,9 @@ static void dw_flush(FrtDocWriter *dw)
     SkipBuffer *skip_buf;
 
     sprintf(file_name, "%s.frq", dw->si->name);
-    frq_out = store->new_output(store, file_name);
+    frq_out = store->new_output(store, segm_idx_name, file_name);
     sprintf(file_name, "%s.prx", dw->si->name);
-    prx_out = store->new_output(store, file_name);
+    prx_out = store->new_output(store, segm_idx_name, file_name);
     skip_buf = skip_buf_new(frq_out, prx_out);
 
     for (i = 0; i < fields_count; i++) {
@@ -5120,8 +4122,7 @@ static void dw_flush(FrtDocWriter *dw)
 
                 if (p->freq == 1) {
                     frt_os_write_vint(frq_out, 1|doc_code);
-                }
-                else {
+                } else {
                     frt_os_write_vint(frq_out, doc_code);
                     frt_os_write_vint(frq_out, p->freq);
                 }
@@ -5144,8 +4145,7 @@ static void dw_flush(FrtDocWriter *dw)
     dw_flush_streams(dw);
 }
 
-FrtDocWriter *frt_dw_open(FrtIndexWriter *iw, FrtSegmentInfo *si)
-{
+FrtDocWriter *frt_dw_open(FrtIndexWriter *iw, FrtSegmentInfo *si) {
     FrtStore *store = iw->store;
     FrtMemoryPool *mp = frt_mp_new_capa(iw->config.chunk_size,
         iw->config.max_buffer_memory/iw->config.chunk_size);
@@ -5177,14 +4177,12 @@ FrtDocWriter *frt_dw_open(FrtIndexWriter *iw, FrtSegmentInfo *si)
     return dw;
 }
 
-void frt_dw_new_segment(FrtDocWriter *dw, FrtSegmentInfo *si)
-{
+void frt_dw_new_segment(FrtDocWriter *dw, FrtSegmentInfo *si) {
     dw->fw = frt_fw_open(dw->store, si->name, dw->fis);
     dw->si = si;
 }
 
-void frt_dw_close(FrtDocWriter *dw)
-{
+void frt_dw_close(FrtDocWriter *dw) {
     if (dw->doc_num) {
         dw_flush(dw);
     }
@@ -5199,8 +4197,7 @@ void frt_dw_close(FrtDocWriter *dw)
     free(dw);
 }
 
-FrtFieldInverter *frt_dw_get_fld_inv(FrtDocWriter *dw, FrtFieldInfo *fi)
-{
+FrtFieldInverter *frt_dw_get_fld_inv(FrtDocWriter *dw, FrtFieldInfo *fi) {
     FrtFieldInverter *fld_inv = (FrtFieldInverter*)frt_h_get_int(dw->fields, fi->number);
 
     if (!fld_inv) {
@@ -5216,8 +4213,7 @@ static void dw_add_posting(FrtMemoryPool *mp,
                            int doc_num,
                            const char *text,
                            int len,
-                           int pos)
-{
+                           int pos) {
     FrtHashEntry *pl_he;
     if (frt_h_set_ext(curr_plists, text, &pl_he)) {
         FrtPosting *p =  frt_p_new(mp, doc_num, pos);
@@ -5227,21 +4223,18 @@ static void dw_add_posting(FrtMemoryPool *mp,
         if (frt_h_set_ext(fld_plists, text, &fld_pl_he)) {
             fld_pl_he->value = pl = frt_pl_new(mp, text, len, p);
             pl_he->key = fld_pl_he->key = (char *)pl->term;
-        }
-        else {
+        } else {
             pl = (FrtPostingList *)fld_pl_he->value;
             pl_add_posting(pl, p);
             pl_he->key = (char *)pl->term;
         }
         pl_he->value = pl;
-    }
-    else {
+    } else {
         frt_pl_add_occ(mp, (FrtPostingList *)pl_he->value, pos);
     }
 }
 
-static void dw_add_offsets(FrtDocWriter *dw, int pos, frt_off_t start, frt_off_t end)
-{
+static void dw_add_offsets(FrtDocWriter *dw, int pos, frt_off_t start, frt_off_t end) {
     if (pos >= dw->offsets_capa) {
         int old_capa = dw->offsets_capa;
         while (pos >= dw->offsets_capa) {
@@ -5305,7 +4298,7 @@ FrtHash *frt_dw_invert_field(FrtDocWriter *dw, FrtFieldInverter *fld_inv, FrtDoc
         buf[FRT_MAX_WORD_SIZE - 1] = '\0';
         for (i = 0; i < df_size; i++) {
             int len = df->lengths[i];
-            char *data_ptr = df->data[i];
+            const char *data_ptr = df->data[i];
             if (len >= FRT_MAX_WORD_SIZE) {
                 char *head_last = rb_enc_left_char_head(data_ptr, data_ptr + FRT_MAX_WORD_SIZE - 1, data_ptr + len, df->encodings[i]);
                 len = head_last - data_ptr;
@@ -5347,7 +4340,7 @@ void frt_dw_add_doc(FrtDocWriter *dw, FrtDocument *doc) {
     FrtFieldInverter *fld_inv;
     FrtHash *postings;
     FrtFieldInfo *fi;
-    const int doc_size = doc->size;
+    const int doc_size = doc->field_count;
 
     /* frt_fw_add_doc will add new fields as necessary */
     frt_fw_add_doc(dw->fw, doc);
@@ -5384,484 +4377,23 @@ void frt_dw_add_doc(FrtDocWriter *dw, FrtDocument *doc) {
  * IndexWriter
  *
  ****************************************************************************/
-/****************************************************************************
- * SegmentMergeInfo
- ****************************************************************************/
-
-typedef struct SegmentMergeInfo {
-    int base;
-    int max_doc;
-    int doc_cnt;
-    FrtSegmentInfo *si;
-    FrtStore *store;
-    FrtStore *orig_store;
-    FrtBitVector *deleted_docs;
-    FrtSegmentFieldIndex *sfi;
-    FrtTermEnum *te;
-    FrtTermDocEnum *tde;
-    char *term;
-    int *doc_map;
-    FrtInStream *frq_in;
-    FrtInStream *prx_in;
-} SegmentMergeInfo;
-
-static bool smi_lt(const SegmentMergeInfo *smi1, const SegmentMergeInfo *smi2)
-{
-    int cmpres = strcmp(smi1->term, smi2->term);
-    if (0 == cmpres) {
-        return smi1->base < smi2->base;
-    }
-    else {
-        return cmpres < 0;
-    }
-}
-
-static void smi_load_doc_map(SegmentMergeInfo *smi)
-{
-    FrtBitVector *deleted_docs = smi->deleted_docs;
-    const int max_doc = smi->max_doc;
-    int j = 0, i;
-
-    smi->doc_map = FRT_ALLOC_N(int, max_doc);
-    for (i = 0; i < max_doc; i++) {
-        if (frt_bv_get(deleted_docs, i)) {
-            smi->doc_map[i] = -1;
-        }
-        else {
-            smi->doc_map[i] = j++;
-        }
-    }
-    smi->doc_cnt = j;
-}
-
-static SegmentMergeInfo *smi_new(int base, FrtStore *store, FrtSegmentInfo *si)
-{
-    SegmentMergeInfo *smi = FRT_ALLOC_AND_ZERO(SegmentMergeInfo);
-    char file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
-    char *segment = si->name;
-    smi->base = base;
-    smi->si = si;
-    smi->orig_store = smi->store = store;
-    FRT_REF(smi->orig_store);
-
-    sprintf(file_name, "%s.fdx", segment);
-    smi->doc_cnt = smi->max_doc
-        = smi->store->length(smi->store, file_name) / FIELDS_IDX_PTR_SIZE;
-
-    if (si->del_gen >= 0) {
-        frt_fn_for_generation(file_name, segment, "del", si->del_gen);
-        smi->deleted_docs = bv_read(store, file_name);
-        smi_load_doc_map(smi);
-    }
-    return smi;
-}
-
-static void smi_load_term_input(SegmentMergeInfo *smi)
-{
-    FrtStore *store = smi->store;
-    char *segment = smi->si->name;
-    char file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
-    smi->sfi = frt_sfi_open(store, segment);
-    sprintf(file_name, "%s.tis", segment);
-    FrtInStream *is = store->open_input(store, file_name);
-    FRT_DEREF(is);
-    smi->te = TE(frt_ste_new(is, smi->sfi));
-    sprintf(file_name, "%s.frq", segment);
-    smi->frq_in = store->open_input(store, file_name);
-    sprintf(file_name, "%s.prx", segment);
-    smi->prx_in = store->open_input(store, file_name);
-    smi->tde = frt_stpe_new(NULL, smi->frq_in, smi->prx_in, smi->deleted_docs,
-                        STE(smi->te)->skip_interval);
-}
-
-static void smi_close_term_input(SegmentMergeInfo *smi)
-{
-    frt_ste_close(smi->te);
-    frt_sfi_close(smi->sfi);
-    stpe_close(smi->tde);
-    frt_is_close(smi->frq_in);
-    frt_is_close(smi->prx_in);
-}
-
-static void smi_destroy(SegmentMergeInfo *smi)
-{
-    if (smi->store != smi->orig_store) {
-        frt_store_close(smi->store);
-    }
-    frt_store_close(smi->orig_store);
-    if (smi->deleted_docs) {
-        frt_bv_destroy(smi->deleted_docs);
-        free(smi->doc_map);
-    }
-    free(smi);
-}
-
-static char *smi_next(SegmentMergeInfo *smi)
-{
-    return (smi->term = ste_next(smi->te));
-}
-
-/****************************************************************************
- * SegmentMerger
- ****************************************************************************/
-
-typedef struct SegmentMerger {
-    FrtTermInfo ti;
-    FrtStore *store;
-    FrtFieldInfos *fis;
-    FrtSegmentInfo *si;
-    SegmentMergeInfo **smis;
-    int seg_cnt;
-    int doc_cnt;
-    FrtConfig *config;
-    FrtTermInfosWriter *tiw;
-    char *term_buf;
-    int term_buf_ptr;
-    int term_buf_size;
-    FrtPriorityQueue *queue;
-    SkipBuffer *skip_buf;
-    FrtOutStream *frq_out;
-    FrtOutStream *prx_out;
-} SegmentMerger;
-
-static SegmentMerger *sm_create(FrtIndexWriter *iw, FrtSegmentInfo *si, FrtSegmentInfo **seg_infos, const int seg_cnt)
-{
-    int i;
-    SegmentMerger *sm = FRT_ALLOC_AND_ZERO_N(SegmentMerger, seg_cnt);
-    sm->store = iw->store;
-    FRT_REF(sm->store);
-    sm->fis = iw->fis;
-    sm->si = si;
-    sm->doc_cnt = 0;
-    sm->smis = FRT_ALLOC_N(SegmentMergeInfo *, seg_cnt);
-    for (i = 0; i < seg_cnt; i++) {
-        sm->smis[i] = smi_new(sm->doc_cnt, seg_infos[i]->store, seg_infos[i]);
-        sm->doc_cnt += sm->smis[i]->doc_cnt;
-    }
-    sm->seg_cnt = seg_cnt;
-    sm->config = &iw->config;
-    return sm;
-}
-
-static void sm_destroy(SegmentMerger *sm)
-{
-    int i;
-    const int seg_cnt = sm->seg_cnt;
-    for (i = 0; i < seg_cnt; i++) {
-        smi_destroy(sm->smis[i]);
-    }
-    frt_store_close(sm->store);
-    free(sm->smis);
-    free(sm);
-}
-
-static void sm_merge_fields(SegmentMerger *sm)
-{
-    int i, j;
-    frt_off_t start, end = 0;
-    char file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
-    FrtOutStream *fdt_out, *fdx_out;
-    FrtStore *store = sm->store;
-    const int seg_cnt = sm->seg_cnt;
-
-    sprintf(file_name, "%s.fdt", sm->si->name);
-    fdt_out = store->new_output(store, file_name);
-
-    sprintf(file_name, "%s.fdx", sm->si->name);
-    fdx_out = store->new_output(store, file_name);
-
-    for (i = 0; i < seg_cnt; i++) {
-        SegmentMergeInfo *smi = sm->smis[i];
-        const int max_doc = smi->max_doc;
-        FrtInStream *fdt_in, *fdx_in;
-        char *segment = smi->si->name;
-        store = smi->store;
-        sprintf(file_name, "%s.fdt", segment);
-        fdt_in = store->open_input(store, file_name);
-        sprintf(file_name, "%s.fdx", segment);
-        fdx_in = store->open_input(store, file_name);
-
-        if (max_doc > 0) {
-            end = (off_t)frt_is_read_u64(fdx_in);
-        }
-        for (j = 0; j < max_doc; j++) {
-            frt_u32 tv_idx_offset = frt_is_read_u32(fdx_in);
-            start = end;
-            if (j == max_doc - 1) {
-                end = frt_is_length(fdt_in);
-            }
-            else {
-                end = (off_t)frt_is_read_u64(fdx_in);
-            }
-            /* skip deleted docs */
-            if (!smi->deleted_docs || !frt_bv_get(smi->deleted_docs, j)) {
-                frt_os_write_u64(fdx_out, frt_os_pos(fdt_out));
-                frt_os_write_u32(fdx_out, tv_idx_offset);
-                frt_is_seek(fdt_in, start);
-                frt_is2os_copy_bytes(fdt_in, fdt_out, end - start);
-            }
-        }
-        frt_is_close(fdt_in);
-        frt_is_close(fdx_in);
-    }
-    frt_os_close(fdt_out);
-    frt_os_close(fdx_out);
-}
-
-static int sm_append_postings(SegmentMerger *sm, SegmentMergeInfo **matches,
-                              const int match_size)
-{
-    int i;
-    int last_doc = 0, base, doc, doc_code, freq;
-    int skip_interval = sm->config->skip_interval;
-    int *doc_map = NULL;
-    int df = 0;            /* number of docs w/ term */
-    FrtTermDocEnum *tde;
-    SegmentMergeInfo *smi;
-    SkipBuffer *skip_buf = sm->skip_buf;
-    skip_buf_reset(skip_buf);
-
-    for (i = 0; i < match_size; i++) {
-        smi = matches[i];
-        base = smi->base;
-        doc_map = smi->doc_map;
-        tde = smi->tde;
-        stpe_seek_ti(STDE(tde), &smi->te->curr_ti);
-
-        /* since we are using copy_bytes below to copy the proximities we use
-         * stde_next rather than stpe_next here */
-        while (stde_next(tde)) {
-            doc = stde_doc_num(tde);
-            if (NULL != doc_map) {
-                doc = doc_map[doc]; /* work around deletions */
-            }
-            doc += base;          /* convert to merged space */
-            assert(doc == 0 || doc > last_doc);
-
-            df++;
-            if (0 == (df % skip_interval)) {
-                skip_buf_add(skip_buf, last_doc);
-            }
-
-            doc_code = (doc - last_doc) << 1;    /* use low bit to flag freq=1 */
-            last_doc = doc;
-
-            freq = stde_freq(tde);
-            if (freq == 1) {
-                frt_os_write_vint(sm->frq_out, doc_code | 1); /* doc & freq=1 */
-            }
-            else {
-                frt_os_write_vint(sm->frq_out, doc_code); /* write doc */
-                frt_os_write_vint(sm->frq_out, freq);     /* write freqency in doc */
-            }
-
-            /* copy position deltas */
-            frt_is2os_copy_vints(STDE(tde)->prx_in, sm->prx_out, freq);
-        }
-    }
-    return df;
-}
-
-static char *sm_cache_term(SegmentMerger *sm, char *term, int term_len)
-{
-    term = (char *)memcpy(sm->term_buf + sm->term_buf_ptr, term, term_len + 1);
-    sm->term_buf_ptr += term_len + 1;
-    if (sm->term_buf_ptr > sm->term_buf_size) {
-        sm->term_buf_ptr = 0;
-    }
-    return term;
-}
-
-static void sm_merge_term_info(SegmentMerger *sm, SegmentMergeInfo **matches,
-                               int match_size)
-{
-    frt_off_t frq_ptr = frt_os_pos(sm->frq_out);
-    frt_off_t prx_ptr = frt_os_pos(sm->prx_out);
-
-    int df = sm_append_postings(sm, matches, match_size); /* append posting data */
-
-    frt_off_t skip_ptr = skip_buf_write(sm->skip_buf);
-
-    if (df > 0) {
-        /* add an entry to the dictionary with ptrs to prox and freq files */
-        SegmentMergeInfo *first_match = matches[0];
-        int term_len = first_match->te->curr_term_len;
-
-        frt_ti_set(sm->ti, df, frq_ptr, prx_ptr,
-               (skip_ptr - frq_ptr));
-        frt_tiw_add(sm->tiw, sm_cache_term(sm, first_match->term, term_len),
-                term_len, &sm->ti);
-    }
-}
-
-static void sm_merge_term_infos(SegmentMerger *sm)
-{
-    int i, j, match_size;
-    SegmentMergeInfo *smi, *top, **matches;
-    char *term;
-    const int seg_cnt = sm->seg_cnt;
-    const int fis_size = sm->fis->size;
-
-    matches = FRT_ALLOC_N(SegmentMergeInfo *, seg_cnt);
-
-    for (j = 0; j < seg_cnt; j++) {
-        smi_load_term_input(sm->smis[j]);
-    }
-
-    for (i = 0; i < fis_size; i++) {
-        frt_tiw_start_field(sm->tiw, i);
-        for (j = 0; j < seg_cnt; j++) {
-            smi = sm->smis[j];
-            ste_set_field(smi->te, i);
-            if (NULL != smi_next(smi)) {
-                frt_pq_push(sm->queue, smi); /* initialize @queue */
-            }
-        }
-        while (sm->queue->size > 0) {
-            match_size = 0;     /* pop matching terms */
-            matches[0] = (SegmentMergeInfo *)frt_pq_pop(sm->queue);
-            match_size++;
-            term = matches[0]->term;
-            top = (SegmentMergeInfo *)frt_pq_top(sm->queue);
-            while ((NULL != top) && (0 == strcmp(term, top->term))) {
-                matches[match_size] = (SegmentMergeInfo *)frt_pq_pop(sm->queue);
-                match_size++;
-                top = (SegmentMergeInfo *)frt_pq_top(sm->queue);
-            }
-
-            sm_merge_term_info(sm, matches, match_size);/* add new FrtTermInfo */
-
-            while (match_size > 0) {
-                match_size--;
-                smi = matches[match_size];
-                if (NULL != smi_next(smi)) {
-                    frt_pq_push(sm->queue, smi);   /* restore queue */
-                }
-            }
-        }
-    }
-    free(matches);
-    for (j = 0; j < seg_cnt; j++) {
-        smi_close_term_input(sm->smis[j]);
-    }
-}
-
-static void sm_merge_terms(SegmentMerger *sm)
-{
-    char file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
-
-    sprintf(file_name, "%s.frq", sm->si->name);
-    sm->frq_out = sm->store->new_output(sm->store, file_name);
-    sprintf(file_name, "%s.prx", sm->si->name);
-    sm->prx_out = sm->store->new_output(sm->store, file_name);
-
-    sm->tiw = frt_tiw_open(sm->store, sm->si->name, sm->config->index_interval,
-                       sm->config->skip_interval);
-    sm->skip_buf = skip_buf_new(sm->frq_out, sm->prx_out);
-
-    /* terms_buf_ptr holds a buffer of terms since the FrtTermInfosWriter needs
-     * to keep the last index_interval terms so that it can compare the last
-     * term put in the index with the next one. So the size of the buffer must
-     * by index_interval + 2. */
-    sm->term_buf_ptr = 0;
-    sm->term_buf_size = (sm->config->index_interval + 1) * FRT_MAX_WORD_SIZE;
-    sm->term_buf = FRT_ALLOC_N(char, sm->term_buf_size + FRT_MAX_WORD_SIZE);
-
-    sm->queue = frt_pq_new(sm->seg_cnt, (frt_lt_ft)&smi_lt, NULL);
-
-    sm_merge_term_infos(sm);
-
-    frt_os_close(sm->frq_out);
-    frt_os_close(sm->prx_out);
-    frt_tiw_close(sm->tiw);
-    frt_pq_destroy(sm->queue);
-    skip_buf_destroy(sm->skip_buf);
-    free(sm->term_buf);
-}
-
-static void sm_merge_norms(SegmentMerger *sm)
-{
-    FrtSegmentInfo *si;
-    int i, j, k;
-    FrtStore *store;
-    frt_uchar byte;
-    FrtFieldInfo *fi;
-    FrtOutStream *os;
-    FrtInStream *is;
-    char file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
-    SegmentMergeInfo *smi;
-    const int seg_cnt = sm->seg_cnt;
-    for (i = sm->fis->size - 1; i >= 0; i--) {
-        fi = sm->fis->fields[i];
-        if (bits_has_norms(fi->bits))  {
-            si = sm->si;
-            frt_si_advance_norm_gen(si, i);
-            si_norm_file_name(si, file_name, i);
-            os = sm->store->new_output(sm->store, file_name);
-            for (j = 0; j < seg_cnt; j++) {
-                smi = sm->smis[j];
-                si = smi->si;
-                if (si_norm_file_name(si, file_name, i)) {
-                    const int max_doc = smi->max_doc;
-                    FrtBitVector *deleted_docs =  smi->deleted_docs;
-                    store = smi->store;
-                    is = store->open_input(store, file_name);
-                    if (deleted_docs) {
-                        for (k = 0; k < max_doc; k++) {
-                            byte = frt_is_read_byte(is);
-                            if (!frt_bv_get(deleted_docs, k)) {
-                                frt_os_write_byte(os, byte);
-                            }
-                        }
-                    }
-                    else {
-                        frt_is2os_copy_bytes(is, os, max_doc);
-                    }
-                    frt_is_close(is);
-                }
-                else {
-                    const int doc_cnt = smi->doc_cnt;
-                    for (k = 0; k < doc_cnt; k++) {
-                        frt_os_write_byte(os, '\0');
-                    }
-                }
-            }
-            frt_os_close(os);
-        }
-    }
-}
-
-static int sm_merge(SegmentMerger *sm)
-{
-    sm_merge_fields(sm);
-    sm_merge_terms(sm);
-    sm_merge_norms(sm);
-    return sm->doc_cnt;
-}
-
-
-/****************************************************************************
- * IndexWriter
- ****************************************************************************/
 
 /* prepare an index ready for writing */
-void frt_index_create(FrtStore *store, FrtFieldInfos *fis)
-{
+void frt_index_create(FrtStore *store, FrtFieldInfos *fis) {
     FrtSegmentInfos *sis = frt_sis_new(fis);
-    store->clear_all(store);
+    store->clear_all(store, segm_idx_name);
     frt_sis_write(sis, store, NULL);
     frt_sis_destroy(sis);
 }
 
 bool frt_index_is_locked(FrtStore *store) {
-    FrtLock *write_lock = frt_open_lock(store, FRT_WRITE_LOCK_NAME);
+    FrtLock *write_lock = frt_open_lock(store, segm_idx_name, FRT_WRITE_LOCK_NAME);
     bool is_locked = write_lock->is_locked(write_lock);
     frt_close_lock(write_lock);
     return is_locked;
 }
 
-int frt_iw_doc_count(FrtIndexWriter *iw)
-{
+int frt_iw_doc_count(FrtIndexWriter *iw) {
     int i, doc_cnt = 0;
     pthread_mutex_lock(&iw->mutex);
     for (i = iw->sis->size - 1; i >= 0; i--) {
@@ -5874,68 +4406,6 @@ int frt_iw_doc_count(FrtIndexWriter *iw)
     return doc_cnt;
 }
 
-static void iw_merge_segments(FrtIndexWriter *iw, const int min_seg, const int max_seg) {
-    int i;
-    FrtSegmentInfos *sis = iw->sis;
-    FrtSegmentInfo *si = frt_sis_new_segment(sis, 0, iw->store);
-
-    SegmentMerger *merger = sm_create(iw, si, &sis->segs[min_seg], max_seg - min_seg);
-
-    /* This is where all the action happens. */
-    si->doc_cnt = sm_merge(merger);
-
-    pthread_mutex_lock(&iw->store->mutex);
-    /* delete merged segments */
-    for (i = min_seg; i < max_seg; i++) {
-        si_delete_files(sis->segs[i], iw->fis, iw->deleter);
-    }
-
-    frt_sis_del_from_to(sis, min_seg, max_seg);
-
-    frt_sis_write(sis, iw->store, iw->deleter);
-    deleter_commit_pending_deletions(iw->deleter);
-
-    pthread_mutex_unlock(&iw->store->mutex);
-
-    sm_destroy(merger);
-}
-
-static void iw_merge_segments_from(FrtIndexWriter *iw, int min_segment)
-{
-    iw_merge_segments(iw, min_segment, iw->sis->size);
-}
-
-static void iw_maybe_merge_segments(FrtIndexWriter *iw)
-{
-    int target_merge_docs = iw->config.merge_factor;
-    int min_segment, merge_docs;
-    FrtSegmentInfo *si;
-
-    while (target_merge_docs > 0
-           && target_merge_docs <= iw->config.max_merge_docs) {
-        /* find segments smaller than current target size */
-        min_segment = iw->sis->size - 1;
-        merge_docs = 0;
-        while (min_segment >= 0) {
-            si = iw->sis->segs[min_segment];
-            if (si->doc_cnt >= target_merge_docs) {
-                break;
-            }
-            merge_docs += si->doc_cnt;
-            min_segment--;
-        }
-
-        if (merge_docs >= target_merge_docs) { /* found a merge to do */
-            iw_merge_segments_from(iw, min_segment + 1);
-        }
-        else if (min_segment <= 0) {
-            break;
-        }
-
-        target_merge_docs *= iw->config.merge_factor;
-    }
-}
-
 static void iw_flush_ram_segment(FrtIndexWriter *iw) {
     FrtSegmentInfos *sis = iw->sis;
     FrtSegmentInfo *si;
@@ -5947,16 +4417,13 @@ static void iw_flush_ram_segment(FrtIndexWriter *iw) {
     frt_sis_write(iw->sis, iw->store, iw->deleter);
     deleter_commit_pending_deletions(iw->deleter);
     pthread_mutex_unlock(&iw->store->mutex);
-    // iw_maybe_merge_segments(iw);
 }
 
-void frt_iw_add_doc(FrtIndexWriter *iw, FrtDocument *doc)
-{
+void frt_iw_add_doc(FrtIndexWriter *iw, FrtDocument *doc) {
     pthread_mutex_lock(&iw->mutex);
     if (NULL == iw->dw) {
         iw->dw = frt_dw_open(iw, frt_sis_new_segment(iw->sis, 0, iw->store));
-    }
-    else if (NULL == iw->dw->fw) {
+    } else if (NULL == iw->dw->fw) {
         frt_dw_new_segment(iw->dw, frt_sis_new_segment(iw->sis, 0, iw->store));
     }
     frt_dw_add_doc(iw->dw, doc);
@@ -5967,15 +4434,13 @@ void frt_iw_add_doc(FrtIndexWriter *iw, FrtDocument *doc)
     pthread_mutex_unlock(&iw->mutex);
 }
 
-static void iw_commit_i(FrtIndexWriter *iw)
-{
+static void iw_commit_i(FrtIndexWriter *iw) {
     if (iw->dw && iw->dw->doc_num > 0) {
         iw_flush_ram_segment(iw);
     }
 }
 
-void frt_iw_commit(FrtIndexWriter *iw)
-{
+void frt_iw_commit(FrtIndexWriter *iw) {
     pthread_mutex_lock(&iw->mutex);
     iw_commit_i(iw);
     pthread_mutex_unlock(&iw->mutex);
@@ -6051,28 +4516,7 @@ void frt_iw_delete_terms(FrtIndexWriter *iw, ID field, char **terms, const int t
     }
 }
 
-static void iw_optimize_i(FrtIndexWriter *iw)
-{
-    int min_segment;
-    iw_commit_i(iw);
-    // while (iw->sis->size > 1
-    //        || (iw->sis->size == 1
-    //            && (frt_si_has_deletions(iw->sis->segs[0])
-    //                || (iw->sis->segs[0]->store != iw->store)))) {
-    //     min_segment = iw->sis->size - iw->config.merge_factor;
-    //     iw_merge_segments_from(iw, min_segment < 0 ? 0 : min_segment);
-    // }
-}
-
-void frt_iw_optimize(FrtIndexWriter *iw)
-{
-    pthread_mutex_lock(&iw->mutex);
-    iw_optimize_i(iw);
-    pthread_mutex_unlock(&iw->mutex);
-}
-
-void frt_iw_close(FrtIndexWriter *iw)
-{
+void frt_iw_close(FrtIndexWriter *iw) {
     pthread_mutex_lock(&iw->mutex);
     iw_commit_i(iw);
     if (iw->dw) {
@@ -6108,7 +4552,7 @@ FrtIndexWriter *frt_iw_open(FrtIndexWriter *iw, FrtStore *store, FrtAnalyzer *vo
     iw->config = *config;
 
     FRT_TRY
-        iw->write_lock = frt_open_lock(store, FRT_WRITE_LOCK_NAME);
+        iw->write_lock = frt_open_lock(store, segm_idx_name, FRT_WRITE_LOCK_NAME);
         if (!iw->write_lock->obtain(iw->write_lock)) {
             FRT_RAISE(FRT_LOCK_ERROR, "Couldn't obtain write lock when opening IndexWriter");
         }
@@ -6150,21 +4594,21 @@ static void iw_cp_fields(FrtIndexWriter *iw, FrtSegmentReader *sr, const char *s
     char *sr_segment = sr->si->name;
 
     sprintf(file_name, "%s.fdt", segment);
-    fdt_out = store_out->new_output(store_out, file_name);
+    fdt_out = store_out->new_output(store_out, segm_idx_name, file_name);
     sprintf(file_name, "%s.fdx", segment);
-    fdx_out = store_out->new_output(store_out, file_name);
+    fdx_out = store_out->new_output(store_out, segm_idx_name, file_name);
 
     sprintf(file_name, "%s.fdt", sr_segment);
-    fdt_in = store_in->open_input(store_in, file_name);
+    fdt_in = store_in->open_input(store_in, segm_idx_name, file_name);
     sprintf(file_name, "%s.fdx", sr_segment);
-    fdx_in = store_in->open_input(store_in, file_name);
+    fdx_in = store_in->open_input(store_in, segm_idx_name, file_name);
 
     sprintf(file_name, "%s.del", sr_segment);
-    if (store_in->exists(store_in, file_name)) {
+    if (store_in->exists(store_in, segm_idx_name, file_name)) {
         FrtOutStream *del_out;
-        FrtInStream *del_in = store_in->open_input(store_in, file_name);
+        FrtInStream *del_in = store_in->open_input(store_in, segm_idx_name, file_name);
         sprintf(file_name, "%s.del", segment);
-        del_out = store_out->new_output(store_out, file_name);
+        del_out = store_out->new_output(store_out, segm_idx_name, file_name);
         frt_is2os_copy_bytes(del_in, del_out, frt_is_length(del_in));
         frt_os_close(del_out);
         frt_is_close(del_in);
@@ -6231,8 +4675,7 @@ static void iw_cp_fields(FrtIndexWriter *iw, FrtSegmentReader *sr, const char *s
 }
 
 static void iw_cp_terms(FrtIndexWriter *iw, FrtSegmentReader *sr,
-                        const char *segment, int *map)
-{
+                        const char *segment, int *map) {
     char file_name[FRT_SEGMENT_NAME_MAX_LENGTH];
     FrtOutStream *tix_out, *tis_out, *tfx_out, *frq_out, *prx_out;
     FrtInStream *tix_in, *tis_in, *tfx_in, *frq_in, *prx_in;
@@ -6241,29 +4684,29 @@ static void iw_cp_terms(FrtIndexWriter *iw, FrtSegmentReader *sr,
     char *sr_segment = sr->si->name;
 
     sprintf(file_name, "%s.tix", segment);
-    tix_out = store_out->new_output(store_out, file_name);
+    tix_out = store_out->new_output(store_out, segm_idx_name, file_name);
     sprintf(file_name, "%s.tix", sr_segment);
-    tix_in = store_in->open_input(store_in, file_name);
+    tix_in = store_in->open_input(store_in, segm_idx_name, file_name);
 
     sprintf(file_name, "%s.tis", segment);
-    tis_out = store_out->new_output(store_out, file_name);
+    tis_out = store_out->new_output(store_out, segm_idx_name, file_name);
     sprintf(file_name, "%s.tis", sr_segment);
-    tis_in = store_in->open_input(store_in, file_name);
+    tis_in = store_in->open_input(store_in, segm_idx_name, file_name);
 
     sprintf(file_name, "%s.tfx", segment);
-    tfx_out = store_out->new_output(store_out, file_name);
+    tfx_out = store_out->new_output(store_out, segm_idx_name, file_name);
     sprintf(file_name, "%s.tfx", sr_segment);
-    tfx_in = store_in->open_input(store_in, file_name);
+    tfx_in = store_in->open_input(store_in, segm_idx_name, file_name);
 
     sprintf(file_name, "%s.frq", segment);
-    frq_out = store_out->new_output(store_out, file_name);
+    frq_out = store_out->new_output(store_out, segm_idx_name, file_name);
     sprintf(file_name, "%s.frq", sr_segment);
-    frq_in = store_in->open_input(store_in, file_name);
+    frq_in = store_in->open_input(store_in, segm_idx_name, file_name);
 
     sprintf(file_name, "%s.prx", segment);
-    prx_out = store_out->new_output(store_out, file_name);
+    prx_out = store_out->new_output(store_out, segm_idx_name, file_name);
     sprintf(file_name, "%s.prx", sr_segment);
-    prx_in = store_in->open_input(store_in, file_name);
+    prx_in = store_in->open_input(store_in, segm_idx_name, file_name);
 
     if (map) {
         int field_cnt = frt_is_read_u32(tfx_in);
@@ -6278,8 +4721,7 @@ static void iw_cp_terms(FrtIndexWriter *iw, FrtSegmentReader *sr,
             frt_os_write_vint(tfx_out, frt_is_read_vint(tfx_in));     /* index size */
             frt_os_write_vint(tfx_out, frt_is_read_vint(tfx_in));     /* dict size */
         }
-    }
-    else {
+    } else {
         frt_is2os_copy_bytes(tfx_in, tfx_out, frt_is_length(tfx_in));
     }
     frt_is2os_copy_bytes(tix_in, tix_out, frt_is_length(tix_in));
@@ -6300,8 +4742,7 @@ static void iw_cp_terms(FrtIndexWriter *iw, FrtSegmentReader *sr,
 }
 
 static void iw_cp_norms(FrtIndexWriter *iw, FrtSegmentReader *sr,
-                        FrtSegmentInfo *si, int *map)
-{
+                        FrtSegmentInfo *si, int *map) {
     int i;
     FrtFieldInfos *fis = IR(sr)->fis;
     const int field_cnt = fis->size;
@@ -6317,10 +4758,10 @@ static void iw_cp_norms(FrtIndexWriter *iw, FrtSegmentReader *sr,
             FrtStore *store = IR(sr)->store;
             int field_num = map ? map[i] : i;
 
-            norms_in = store->open_input(store, file_name_in);
+            norms_in = store->open_input(store, segm_idx_name, file_name_in);
             frt_si_advance_norm_gen(si, field_num);
             si_norm_file_name(si, file_name_out, field_num);
-            norms_out = store_out->new_output(store_out, file_name_out);
+            norms_out = store_out->new_output(store_out, segm_idx_name, file_name_out);
             frt_is2os_copy_bytes(norms_in, norms_out, frt_is_length(norms_in));
             frt_os_close(norms_out);
             frt_is_close(norms_in);
@@ -6398,7 +4839,6 @@ static void iw_add_segments(FrtIndexWriter *iw, FrtIndexReader *ir) {
 void frt_iw_add_readers(FrtIndexWriter *iw, FrtIndexReader **readers, const int r_cnt) {
     int i;
     pthread_mutex_lock(&iw->mutex);
-    iw_optimize_i(iw);
 
     for (i = 0; i < r_cnt; i++) {
         iw_add_segments(iw, readers[i]);
@@ -6410,6 +4850,5 @@ void frt_iw_add_readers(FrtIndexWriter *iw, FrtIndexReader **readers, const int
     frt_sis_write(iw->sis, iw->store, iw->deleter);
     pthread_mutex_unlock(&iw->store->mutex);
 
-    iw_optimize_i(iw);
     pthread_mutex_unlock(&iw->mutex);
 }