isomorfeus-ferret 0.17.2 → 0.17.4

data/ext/isomorfeus_ferret_ext/frt_doc_field.h

@@ -0,0 +1,26 @@
+#ifndef FRT_DOC_FIELD_H
+#define FRT_DOC_FIELD_H
+
+#include <ruby/encoding.h>
+#include "frt_hash.h"
+
+#define FRT_DF_INIT_CAPA 1
+
+typedef struct FrtDocField {
+    ID name;
+    int size;
+    int capa;
+    int *lengths;
+    rb_encoding **encodings; /* used for processing */
+    const char **data;
+    float boost;
+    FrtCompressionType compression_type;
+} FrtDocField;
+
+extern FrtDocField *frt_df_new(ID name);
+extern FrtDocField *frt_df_add_data(FrtDocField *df, const char *data, rb_encoding *encoding);
+extern FrtDocField *frt_df_add_data_len(FrtDocField *df, const char *data, int len, rb_encoding *encoding);
+extern void frt_df_destroy(FrtDocField *df);
+extern char *frt_df_to_s(FrtDocField *df);
+
+#endif

data/ext/isomorfeus_ferret_ext/frt_document.c

@@ -1,103 +1,10 @@
 #include "frt_document.h"
 #include <string.h>
 
-/****************************************************************************
- *
- * FrtDocField
- *
- ****************************************************************************/
-
-FrtDocField *frt_df_new(ID name) {
-    FrtDocField *df = FRT_ALLOC(FrtDocField);
-    df->name = name;
-    df->size = 0;
-    df->capa = FRT_DF_INIT_CAPA;
-    df->data = FRT_ALLOC_N(char *, df->capa);
-    df->lengths = FRT_ALLOC_N(int, df->capa);
-    df->encodings = FRT_ALLOC_N(rb_encoding *, df->capa);
-    df->destroy_data = false;
-    df->boost = 1.0f;
-    return df;
-}
-
-FrtDocField *frt_df_add_data_len(FrtDocField *df, char *data, int len, rb_encoding *encoding) {
-    if (df->size >= df->capa) {
-        df->capa <<= 2;
-        FRT_REALLOC_N(df->data, char *, df->capa);
-        FRT_REALLOC_N(df->lengths, int, df->capa);
-        FRT_REALLOC_N(df->encodings, rb_encoding *, df->capa);
-    }
-    df->data[df->size] = data;
-    df->lengths[df->size] = len;
-    df->encodings[df->size] = encoding;
-    df->size++;
-    return df;
-}
-
-FrtDocField *frt_df_add_data(FrtDocField *df, char *data, rb_encoding *encoding) {
-    return frt_df_add_data_len(df, data, strlen(data), encoding);
-}
-
-void frt_df_destroy(FrtDocField *df) {
-    if (df->destroy_data) {
-        int i;
-        for (i = 0; i < df->size; i++) {
-            free(df->data[i]);
-        }
-    }
-    free(df->data);
-    free(df->lengths);
-    free(df->encodings);
-    free(df);
-}
-
-/*
- * Format for one item is: name: "data"
- *        for more items : name: ["data", "data", "data"]
- * internally used for testing, thus encoding can be ignored
- */
-char *frt_df_to_s(FrtDocField *df) {
-    const char *df_name = rb_id2name(df->name);
-    int i, len = 0, namelen = strlen(df_name);
-    char *str, *s;
-    for (i = 0; i < df->size; i++) {
-        len += df->lengths[i] + 4;
-    }
-    s = str = FRT_ALLOC_N(char, namelen + len + 5);
-    memcpy(s, df_name, namelen);
-    s += namelen;
-    s = frt_strapp(s, ": ");
-
-    if (df->size > 1) {
-        s = frt_strapp(s, "[");
-    }
-    for (i = 0; i < df->size; i++) {
-        if (i != 0) {
-            s = frt_strapp(s, ", ");
-        }
-        s = frt_strapp(s, "\"");
-        memcpy(s, df->data[i], df->lengths[i]);
-        s += df->lengths[i];
-        s = frt_strapp(s, "\"");
-    }
-
-    if (df->size > 1) {
-        s = frt_strapp(s, "]");
-    }
-    *s = 0;
-    return str;
-}
-
-/****************************************************************************
- *
- * FrtDocument
- *
- ****************************************************************************/
-
 FrtDocument *frt_doc_new(void) {
     FrtDocument *doc = FRT_ALLOC(FrtDocument);
     doc->field_dict = frt_h_new_ptr((frt_free_ft)&frt_df_destroy);
-    doc->size = 0;
+    doc->field_count = 0;
     doc->capa = FRT_DOC_INIT_CAPA;
     doc->fields = FRT_ALLOC_N(FrtDocField *, doc->capa);
     doc->boost = 1.0f;
@@ -109,12 +16,12 @@ FrtDocField *frt_doc_add_field(FrtDocument *doc, FrtDocField *df) {
         FRT_RAISE(FRT_EXCEPTION, "tried to add %s field which alread existed\n",
               rb_id2name(df->name));
     }
-    if (doc->size >= doc->capa) {
+    if (doc->field_count >= doc->capa) {
         doc->capa <<= 1;
         FRT_REALLOC_N(doc->fields, FrtDocField *, doc->capa);
     }
-    doc->fields[doc->size] = df;
-    doc->size++;
+    doc->fields[doc->field_count] = df;
+    doc->field_count++;
     return df;
 }
 

data/ext/isomorfeus_ferret_ext/frt_document.h

@@ -2,44 +2,16 @@
 #define FRT_DOCUMENT_H
 
 #include "frt_global.h"
-#include "frt_hash.h"
+#include "frt_doc_field.h"
 #include <ruby/encoding.h>
 
-/****************************************************************************
- *
- * FrtDocField
- *
- ****************************************************************************/
-
-#define FRT_DF_INIT_CAPA 1
-typedef struct FrtDocField {
-    ID name;
-    int size;
-    int capa;
-    int *lengths;
-    rb_encoding **encodings; /* used for processing */
-    char **data;
-    float boost;
-    FrtCompressionType compression;
-    bool destroy_data : 1;
-} FrtDocField;
-
-extern FrtDocField *frt_df_new(ID name);
-extern FrtDocField *frt_df_add_data(FrtDocField *df, char *data, rb_encoding *encoding);
-extern FrtDocField *frt_df_add_data_len(FrtDocField *df, char *data, int len, rb_encoding *encoding);
-extern void frt_df_destroy(FrtDocField *df);
-extern char *frt_df_to_s(FrtDocField *df);
-
-/****************************************************************************
- *
- * FrtDocument
- *
- ****************************************************************************/
-
 #define FRT_DOC_INIT_CAPA 8
+
 typedef struct FrtDocument {
+    // frt_uchar ulid[16];
+    // char *ulid_c;
     FrtHash *field_dict;
-    int size;
+    int field_count;
     int capa;
     FrtDocField **fields;
     float boost;

data/ext/isomorfeus_ferret_ext/frt_except.c

@@ -1,3 +1,8 @@
+/* prevent warning: #warning Please include winsock2.h before windows.h [-Wcpp] */
+#ifdef _WIN32
+#   include <winsock2.h>
+#endif
+
 #include <stdarg.h>
 #include "bzlib.h"
 #include "frt_global.h"
@@ -61,11 +66,9 @@ void frt_xraise(int excode, const char *const msg) {
 
     if (!top_context) {
         FRT_XEXIT(ERROR_TYPES[excode], msg);
-    }
-    else if (!top_context->in_finally) {
+    } else if (!top_context->in_finally) {
         frt_xraise_context(top_context, excode, msg);
-    }
-    else if (top_context->handled) {
+    } else if (top_context->handled) {
         top_context->msg = msg;
         top_context->excode = excode;
         top_context->handled = false;
@@ -122,8 +125,7 @@ void frt_xpop_context(void) {
     if (!top_cxt->handled) {
         if (context) {
             frt_xraise_context(context, top_cxt->excode, top_cxt->msg);
-        }
-        else {
+        } else {
             FRT_XEXIT(ERROR_TYPES[top_cxt->excode], top_cxt->msg);
         }
     }

data/ext/isomorfeus_ferret_ext/frt_except.h

@@ -112,8 +112,7 @@ extern const char *frt_err_code_to_type(const int err_code);
 
 extern void frb_rb_raise(const char *file, int line_num, const char *func, const char *err_type, const char *fmt, ...);
 
-typedef struct frt_xcontext_t
-{
+typedef struct frt_xcontext_t {
     jmp_buf jbuf;
     struct frt_xcontext_t *next;
     const char *msg;

data/ext/isomorfeus_ferret_ext/frt_field_index.c

@@ -9,22 +9,19 @@
  *
  ***************************************************************************/
 
-static unsigned long long field_index_hash(const void *p)
-{
+static unsigned long field_index_hash(const void *p) {
     FrtFieldIndex *self = (FrtFieldIndex *)p;
     return frt_str_hash(rb_id2name(self->field)) ^ (unsigned long long)(self->klass);
 }
 
-static int field_index_eq(const void *p1, const void *p2)
-{
+static int field_index_eq(const void *p1, const void *p2) {
     FrtFieldIndex *fi1 = (FrtFieldIndex *)p1;
     FrtFieldIndex *fi2 = (FrtFieldIndex *)p2;
     return (fi1->field == fi2->field) &&
         (fi1->klass->type == fi2->klass->type);
 }
 
-static void field_index_destroy(void *p)
-{
+static void field_index_destroy(void *p) {
     FrtFieldIndex *self = (FrtFieldIndex *)p;
     if (self->index) {
         self->klass->destroy_index(self->index);
@@ -63,7 +60,7 @@ FrtFieldIndex *frt_field_index_get(FrtIndexReader *ir, ID field, const FrtFieldI
          * just use the field_infos field symbol */
         self->field = fi->name;
 
-        length = ir->max_doc(ir);
+        length = ir->max_doc_num(ir);
         if (length > 0) {
             FRT_TRY
             {
@@ -95,10 +92,7 @@ FrtFieldIndex *frt_field_index_get(FrtIndexReader *ir, ID field, const FrtFieldI
  * index should only be used for sorting and not as a field cache of the
  * column's value.
  ******************************************************************************/
-static void byte_handle_term(void *index_ptr,
-                             FrtTermDocEnum *tde,
-                             const char *text)
-{
+static void byte_handle_term(void *index_ptr, FrtTermDocEnum *tde, const char *text) {
     long *index = (long *)index_ptr;
     long val = index[-1]++;
     (void)text;
@@ -107,15 +101,13 @@ static void byte_handle_term(void *index_ptr,
     }
 }
 
-static void *byte_create_index(int size)
-{
+static void *byte_create_index(int size) {
     long *index = FRT_ALLOC_AND_ZERO_N(long, size + 1);
     index[0] = 1;
     return &index[1];
 }
 
-static void byte_destroy_index(void *p)
-{
+static void byte_destroy_index(void *p) {
     long *index = (long *)p;
     free(&index[-1]);
 }
@@ -130,15 +122,11 @@ const FrtFieldIndexClass FRT_BYTE_FIELD_INDEX_CLASS = {
 /******************************************************************************
  * IntegerFieldIndex < FieldIndex
  ******************************************************************************/
-static void *integer_create_index(int size)
-{
+static void *integer_create_index(int size) {
     return FRT_ALLOC_AND_ZERO_N(long, size);
 }
 
-static void integer_handle_term(void *index_ptr,
-                                FrtTermDocEnum *tde,
-                                const char *text)
-{
+static void integer_handle_term(void *index_ptr, FrtTermDocEnum *tde, const char *text) {
     long *index = (long *)index_ptr;
     long val;
     sscanf(text, "%ld", &val);
@@ -158,15 +146,11 @@ const FrtFieldIndexClass FRT_INTEGER_FIELD_INDEX_CLASS = {
  * FloatFieldIndex < FieldIndex
  ******************************************************************************/
 #define VALUES_ARRAY_START_SIZE 8
-static void *float_create_index(int size)
-{
+static void *float_create_index(int size) {
     return FRT_ALLOC_AND_ZERO_N(float, size);
 }
 
-static void float_handle_term(void *index_ptr,
-                              FrtTermDocEnum *tde,
-                              const char *text)
-{
+static void float_handle_term(void *index_ptr, FrtTermDocEnum *tde, const char *text) {
     float *index = (float *)index_ptr;
     float val;
     sscanf(text, "%g", &val);
@@ -186,8 +170,7 @@ const FrtFieldIndexClass FRT_FLOAT_FIELD_INDEX_CLASS = {
  * StringFieldIndex < FieldIndex
  ******************************************************************************/
 
-static void *string_create_index(int size)
-{
+static void *string_create_index(int size) {
     FrtStringIndex *self = FRT_ALLOC_AND_ZERO(FrtStringIndex);
     self->size = size;
     self->index = FRT_ALLOC_AND_ZERO_N(long, size);
@@ -197,8 +180,7 @@ static void *string_create_index(int size)
     return self;
 }
 
-static void string_destroy_index(void *p)
-{
+static void string_destroy_index(void *p) {
     FrtStringIndex *self = (FrtStringIndex *)p;
     int i;
     free(self->index);
@@ -211,8 +193,7 @@ static void string_destroy_index(void *p)
 
 static void string_handle_term(void *index_ptr,
                                FrtTermDocEnum *tde,
-                               const char *text)
-{
+                               const char *text) {
     FrtStringIndex *index = (FrtStringIndex *)index_ptr;
     if (index->v_size >= index->v_capa) {
         index->v_capa *= 2;

data/ext/isomorfeus_ferret_ext/frt_field_index.h

@@ -3,12 +3,6 @@
 
 #include "frt_index.h"
 
-/***************************************************************************
- *
- * FrtFieldIndex
- *
- ***************************************************************************/
-
 typedef struct FrtStringIndex {
     int  size;
     long *index;

data/ext/isomorfeus_ferret_ext/frt_field_info.c

@@ -0,0 +1,69 @@
+#include "frt_field_info.h"
+
+FrtFieldInfo *frt_fi_alloc(void) {
+    return FRT_ALLOC(FrtFieldInfo);
+}
+
+FrtFieldInfo *frt_fi_init(FrtFieldInfo *fi, ID name, unsigned int bits) {
+    assert(NULL != name);
+    bits_check(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);
+}
+
+void bits_check(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.");
+    }
+}
+
+FrtCompressionType bits_get_compression_type(unsigned int bits) {
+    if (bits_is_compressed_brotli(bits)) {
+        return FRT_COMPRESSION_BROTLI;
+    } else if (bits_is_compressed_bz2(bits)) {
+        return FRT_COMPRESSION_BZ2;
+    } else if (bits_is_compressed_lz4(bits)) {
+        return FRT_COMPRESSION_LZ4;
+    } 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;
+}

data/ext/isomorfeus_ferret_ext/frt_field_info.h

@@ -0,0 +1,49 @@
+#ifndef FRT_FIELD_INFO_H
+#define FRT_FIELD_INFO_H
+
+#include "frt_global.h"
+#include <ruby.h>
+
+#define FRT_FI_DEFAULTS_BM  FRT_FI_IS_STORED_BM | FRT_FI_IS_INDEXED_BM | FRT_FI_IS_TOKENIZED_BM | FRT_FI_STORE_TERM_VECTOR_BM | FRT_FI_STORE_POSITIONS_BM | FRT_FI_STORE_OFFSETS_BM
+#define FRT_FI_IS_STORED_BM          0x001
+#define FRT_FI_IS_INDEXED_BM         0x002
+#define FRT_FI_IS_TOKENIZED_BM       0x004
+#define FRT_FI_OMIT_NORMS_BM         0x008
+#define FRT_FI_STORE_TERM_VECTOR_BM  0x010
+#define FRT_FI_STORE_POSITIONS_BM    0x020
+#define FRT_FI_STORE_OFFSETS_BM      0x040
+#define FRT_FI_COMPRESSION_BROTLI_BM 0x080
+#define FRT_FI_COMPRESSION_BZ2_BM    0x100
+#define FRT_FI_COMPRESSION_LZ4_BM    0x200
+
+typedef struct FrtFieldInfo {
+    ID           name;
+    float        boost;
+    unsigned int bits;
+    int          number;
+    _Atomic unsigned int ref_cnt;
+    VALUE        rfi;
+} FrtFieldInfo;
+
+extern FrtFieldInfo *frt_fi_alloc();
+extern FrtFieldInfo *frt_fi_init(FrtFieldInfo *fi, ID name, unsigned int bits);
+extern FrtFieldInfo *frt_fi_new(ID name, unsigned int bits);
+extern char *frt_fi_to_s(FrtFieldInfo *fi);
+extern void frt_fi_deref(FrtFieldInfo *fi);
+
+extern void bits_check(unsigned int bits);
+extern FrtCompressionType bits_get_compression_type(unsigned int bits);
+#define bits_is_stored(bits)            ((bits & FRT_FI_IS_STORED_BM) != 0)
+#define bits_is_indexed(bits)           ((bits & FRT_FI_IS_INDEXED_BM) != 0)
+#define bits_is_tokenized(bits)         ((bits & FRT_FI_IS_TOKENIZED_BM) != 0)
+#define bits_omit_norms(bits)           ((bits & FRT_FI_OMIT_NORMS_BM) != 0)
+#define bits_store_term_vector(bits)    ((bits & FRT_FI_STORE_TERM_VECTOR_BM) != 0)
+#define bits_store_positions(bits)      ((bits & FRT_FI_STORE_POSITIONS_BM) != 0)
+#define bits_store_offsets(bits)        ((bits & FRT_FI_STORE_OFFSETS_BM) != 0)
+#define bits_has_norms(bits)            ((bits & (FRT_FI_OMIT_NORMS_BM|FRT_FI_IS_INDEXED_BM)) == FRT_FI_IS_INDEXED_BM)
+#define bits_is_compressed_brotli(bits) ((bits & FRT_FI_COMPRESSION_BROTLI_BM) != 0)
+#define bits_is_compressed_bz2(bits)    ((bits & FRT_FI_COMPRESSION_BZ2_BM) != 0)
+#define bits_is_compressed_lz4(bits)    ((bits & FRT_FI_COMPRESSION_LZ4_BM) != 0)
+#define bits_is_compressed(bits)        (bits_is_compressed_brotli(bits) || bits_is_compressed_bz2(bits) || bits_is_compressed_lz4(bits))
+
+#endif

data/ext/isomorfeus_ferret_ext/frt_field_infos.c

@@ -0,0 +1,196 @@
+#include "frt_field_infos.h"
+#include "frt_except.h"
+
+FrtFieldInfos *frt_fis_alloc(void) {
+    return FRT_ALLOC(FrtFieldInfos);
+}
+
+FrtFieldInfos *frt_fis_init(FrtFieldInfos *fis, unsigned int bits) {
+    bits_check(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;
+}
+
+bool frt_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;
+}
+
+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[bits_is_compressed(fi->bits) ? 2 : fi->bits & 0x1];
+}
+
+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 >> 1) & 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 >> 4) & 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[bits_is_compressed(fis->bits) ? 2 : fis->bits & 0x1],
+                  index_str[(fis->bits >> 1) & 0x7],
+                  term_vector_str[(fis->bits >> 4) & 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);
+    }
+}