ferret 0.9.4 → 0.9.5

data/README

@@ -26,7 +26,7 @@ Run the following;
   $ rake ext
   $ ruby setup.rb config
   $ ruby setup.rb setup
-  # ruby setup.rb install
+  # sudo ruby setup.rb install
   
 These simple steps install ferret in the default location of Ruby libraries.
 You can also install files into your favorite directory by supplying setup.rb

data/Rakefile

@@ -211,6 +211,7 @@ else
     #### Load-time details: library and application (you will need one or both).
 
     s.require_path = 'lib'                         # Use these for libraries.
+    s.autorequire = 'ferret'
 
     #s.bindir = "bin"                               # Use these for applications.
     #s.executables = ["rake"]

data/ext/field.c

@@ -213,93 +213,6 @@ FieldInfos *fis_add_doc(FieldInfos *fis, Document *doc)
   return fis;
 }
 
-/****************************************************************************
- *
- * FieldsWriter
- *
- ****************************************************************************/
-
-FieldsWriter *fw_open(Store *store, char *segment, FieldInfos *fis)
-{
-  FieldsWriter *fw = ALLOC(FieldsWriter);
-  char buf[SEGMENT_NAME_MAX_LENGTH];
-  int slen = (int)strlen(segment);
-
-  strcpy(buf, segment);
-
-  fw->fis = fis;
-  strcpy(buf+slen, ".fdt");
-  fw->fields_out = store->create_output(store, buf);
-  strcpy(buf+slen, ".fdx");
-  fw->index_out = store->create_output(store, buf);
-  return fw;
-}
-
-void fw_close(FieldsWriter *fw)
-{
-  os_close(fw->fields_out);
-  os_close(fw->index_out);
-  free(fw);
-}
-
-void save_data(OutStream *fout, char *data, int dlen)
-{
-  os_write_vint(fout, dlen);
-  os_write_bytes(fout, (uchar *)data, dlen);
-}
-
-void fw_add_doc(FieldsWriter *fw, Document *doc)
-{
-  int i, bits;
-  DocField *df;
-  char *data;
-  int stored_count = 0;
-  OutStream *fout = fw->fields_out, *iout = fw->index_out;
-
-  os_write_long(iout, os_pos(fout));
-
-  for (i = 0; i < doc->dfcnt; i++) {
-    if (doc->df_arr[i]->is_stored)
-      stored_count++;
-  }
-  os_write_vint(fout, stored_count);
-  
-  for (i = 0; i < doc->dfcnt; i++) {
-    df = doc->df_arr[i];
-    if (df->is_stored) {
-      os_write_vint(fout, ((FieldInfo *)ht_get(fw->fis->by_name, df->name))->number);
-
-      bits = 0;
-      if (df->is_tokenized) {
-        bits |= FIELD_IS_TOKENIZED;
-      }
-      if (df->is_binary) {
-        bits |= FIELD_IS_BINARY;
-      }
-      if (df->is_compressed) {
-        bits |= FIELD_IS_COMPRESSED;
-      }
-      os_write_byte(fout, bits);
-      
-      data = NULL;
-      if (df->is_compressed) {
-        /* Not compressing just yet but we'll save it anyway */
-        if (df->is_binary) {
-          save_data(fout, df->data, df->blen);
-        } else {
-          os_write_string(fout, df->data);
-        }
-      } else {
-        if (df->is_binary) {
-          save_data(fout, df->data, df->blen);
-        } else {
-          os_write_string(fout, df->data);
-        }
-      }
-    }
-  }
-}
-
 /****************************************************************************
  *
  * FieldsReader
@@ -406,3 +319,90 @@ Document *fr_get_doc(FieldsReader *fr, int doc_num)
   return doc;
 }
 
+/****************************************************************************
+ *
+ * FieldsWriter
+ *
+ ****************************************************************************/
+
+FieldsWriter *fw_open(Store *store, char *segment, FieldInfos *fis)
+{
+  FieldsWriter *fw = ALLOC(FieldsWriter);
+  char buf[SEGMENT_NAME_MAX_LENGTH];
+  int slen = (int)strlen(segment);
+
+  strcpy(buf, segment);
+
+  fw->fis = fis;
+  strcpy(buf+slen, ".fdt");
+  fw->fields_out = store->create_output(store, buf);
+  strcpy(buf+slen, ".fdx");
+  fw->index_out = store->create_output(store, buf);
+  return fw;
+}
+
+void fw_close(FieldsWriter *fw)
+{
+  os_close(fw->fields_out);
+  os_close(fw->index_out);
+  free(fw);
+}
+
+void save_data(OutStream *fout, char *data, int dlen)
+{
+  os_write_vint(fout, dlen);
+  os_write_bytes(fout, (uchar *)data, dlen);
+}
+
+void fw_add_doc(FieldsWriter *fw, Document *doc)
+{
+  int i, bits;
+  DocField *df;
+  char *data;
+  int stored_count = 0;
+  OutStream *fout = fw->fields_out, *iout = fw->index_out;
+
+  os_write_long(iout, os_pos(fout));
+
+  for (i = 0; i < doc->dfcnt; i++) {
+    if (doc->df_arr[i]->is_stored)
+      stored_count++;
+  }
+  os_write_vint(fout, stored_count);
+  
+  for (i = 0; i < doc->dfcnt; i++) {
+    df = doc->df_arr[i];
+    if (df->is_stored) {
+      os_write_vint(fout, ((FieldInfo *)ht_get(fw->fis->by_name, df->name))->number);
+
+      bits = 0;
+      if (df->is_tokenized) {
+        bits |= FIELD_IS_TOKENIZED;
+      }
+      if (df->is_binary) {
+        bits |= FIELD_IS_BINARY;
+      }
+      if (df->is_compressed) {
+        bits |= FIELD_IS_COMPRESSED;
+      }
+      os_write_byte(fout, bits);
+      
+      data = NULL;
+      if (df->is_compressed) {
+        /* Not compressing just yet but we'll save it anyway */
+        if (df->is_binary) {
+          save_data(fout, df->data, df->blen);
+        } else {
+          os_write_string(fout, df->data);
+        }
+      } else {
+        if (df->is_binary) {
+          save_data(fout, df->data, df->blen);
+        } else {
+          os_write_string(fout, df->data);
+        }
+      }
+    }
+  }
+}
+

data/ext/index.h

@@ -162,7 +162,6 @@ int ti_eq(TermInfo *ti1, TermInfo *ti2);
  *
  ****************************************************************************/
 
-typedef struct TermEnumFilter TermEnumFilter;
 typedef struct TermEnum TermEnum;
 struct TermEnum {
   void *data;
@@ -301,10 +300,11 @@ void tvf_destroy(void *p);
  ****************************************************************************/
 
 typedef struct TVTerm {
-  char *text;
-  int freq;
-  int *positions;
-  TVOffsetInfo **offsets;
+    int field_num;
+    char *text;
+    int freq;
+    int *positions;
+    TVOffsetInfo **offsets;
 } TVTerm;
 
 TVTerm *tvt_create(char *text,
@@ -320,12 +320,12 @@ void tvt_destroy(void *p);
  ****************************************************************************/
 
 typedef struct TermVector {
-  char *field;
-  char **terms;
-  int tcnt;
-  int *freqs;
-  int **positions;
-  TVOffsetInfo ***offsets;
+    char *field;
+    char **terms;
+    int tcnt;
+    int *freqs;
+    int **positions;
+    TVOffsetInfo ***offsets;
 } TermVector;
 
 TermVector *tv_create(const char *field,
@@ -344,27 +344,27 @@ void tv_destroy(TermVector *tv);
 
 #define STORE_POSITIONS_WITH_TERMVECTOR 0x1
 #define STORE_OFFSET_WITH_TERMVECTOR 0x2
-    
+
 #define FORMAT_VERSION 2
 #define FORMAT_SIZE 4
-    
+
 #define TVX_EXTENSION ".tvx"
 #define TVD_EXTENSION ".tvd"
 #define TVF_EXTENSION ".tvf"
 
 typedef struct TermVectorsWriter {
-  TVField *curr_field;
-  int curr_doc_pointer;
-  OutStream *tvx;
-  OutStream *tvd;
-  OutStream *tvf;
-  FieldInfos *fis;
-  TVField **fields;
-  int fcnt;
-  int fsize;
-  TVTerm **terms;
-  int tcnt;
-  int tsize;
+    TVField *curr_field;
+    int curr_doc_pointer;
+    OutStream *tvx;
+    OutStream *tvd;
+    OutStream *tvf;
+    FieldInfos *fis;
+    TVField **fields;
+    int fcnt;
+    int fsize;
+    TVTerm **terms;
+    int tcnt;
+    int tsize;
 } TermVectorsWriter;
 
 TermVectorsWriter *tvw_open(Store *store, char *segment, FieldInfos *fis);
@@ -384,23 +384,40 @@ void tvw_add_all_doc_vectors(TermVectorsWriter *tvw, Array *vectors);
  ****************************************************************************/
 
 typedef struct TermVectorsReader {
-  int size;
-  InStream *tvx;
-  InStream *tvd;
-  InStream *tvf;
-  FieldInfos *fis;
-  int tvd_format;
-  int tvf_format;
+    int size;
+    InStream *tvx;
+    InStream *tvd;
+    InStream *tvf;
+    FieldInfos *fis;
+    int tvd_format;
+    int tvf_format;
 } TermVectorsReader;
 
 TermVectorsReader *tvr_open(Store *store, char *segment, FieldInfos *fis);
 TermVectorsReader *tvr_clone(TermVectorsReader *orig);
 void tvr_close(TermVectorsReader *tvr);
 TermVector *tvr_read_term_vector(TermVectorsReader *tvr,
-    char *field, int tvf_pointer);
+                                 char *field, int tvf_pointer);
 Array *tvr_get_tv(TermVectorsReader *tvr, int doc_num);
 TermVector *tvr_get_field_tv(TermVectorsReader *tvr, int doc_num, char *field);
 
+/****************************************************************************
+ *
+ * FieldsReader
+ *
+ ****************************************************************************/
+
+typedef struct FieldsReader {
+    int len;
+    FieldInfos *fis;
+    InStream *fields_in;
+    InStream *index_in;
+} FieldsReader;
+
+FieldsReader *fr_open(Store *store, char *segment, FieldInfos *fis);
+void fr_close(FieldsReader *fr);
+Document *fr_get_doc(FieldsReader *fr, int doc_num);
+
 /****************************************************************************
  *
  * FieldsWriter
@@ -412,9 +429,9 @@ TermVector *tvr_get_field_tv(TermVectorsReader *tvr, int doc_num, char *field);
 #define FIELD_IS_COMPRESSED 0X4 
 
 typedef struct FieldsWriter {
-  FieldInfos *fis;
-  OutStream *fields_out;
-  OutStream *index_out;
+    FieldInfos *fis;
+    OutStream *fields_out;
+    OutStream *index_out;
 } FieldsWriter;
 
 FieldsWriter *fw_open(Store *store, char *segment, FieldInfos *fis);
@@ -429,15 +446,15 @@ void fw_add_doc(FieldsWriter *fw, Document *doc);
 
 typedef struct TermDocEnum TermDocEnum;
 struct TermDocEnum {
-  void *data;
-  void (*seek)(TermDocEnum *tde, Term *term);
-  int  (*doc_num)(TermDocEnum *tde);
-  int  (*freq)(TermDocEnum *tde);
-  bool (*next)(TermDocEnum *tde);
-  int  (*read)(TermDocEnum *tde, int *docs, int *freqs, int req_num);
-  bool (*skip_to)(TermDocEnum *tde, int target);
-  int  (*next_position)(TermDocEnum *tde);
-  void (*close)(TermDocEnum *tde);
+    void *data;
+    void (*seek)(TermDocEnum *tde, Term *term);
+    int  (*doc_num)(TermDocEnum *tde);
+    int  (*freq)(TermDocEnum *tde);
+    bool (*next)(TermDocEnum *tde);
+    int  (*read)(TermDocEnum *tde, int *docs, int *freqs, int req_num);
+    bool (*skip_to)(TermDocEnum *tde, int target);
+    int  (*next_position)(TermDocEnum *tde);
+    void (*close)(TermDocEnum *tde);
 };
 
 /* * SegmentTermDocEnum * */
@@ -445,27 +462,27 @@ struct TermDocEnum {
 typedef struct SegmentTermDocEnum SegmentTermDocEnum;
 
 struct SegmentTermDocEnum {
-  SegmentReader *parent;
-  InStream *freq_in;
-  int count;               /* number of docs for this term  skipped */
-  int doc_freq;            /* number of doc this term appears in */
-  BitVector *deleted_docs;
-  int doc_num;
-  int freq;
-  int skip_interval;
-  int num_skips;
-  int skip_count;
-  InStream *skip_in;
-  int skip_doc;
-  int freq_pointer;
-  int prox_pointer;
-  int skip_pointer;
-  unsigned int have_skipped : 1;
-  void (*skip_prox)(SegmentTermDocEnum *stde);
-  InStream *prox_in;
-  int prox_cnt;
-  int position;
-  void (*seek_prox)(SegmentTermDocEnum *stde, int prox_pointer);
+    SegmentReader *parent;
+    InStream *freq_in;
+    int count;               /* number of docs for this term  skipped */
+    int doc_freq;            /* number of doc this term appears in */
+    BitVector *deleted_docs;
+    int doc_num;
+    int freq;
+    int skip_interval;
+    int num_skips;
+    int skip_count;
+    InStream *skip_in;
+    int skip_doc;
+    int freq_pointer;
+    int prox_pointer;
+    int skip_pointer;
+    unsigned int have_skipped : 1;
+    void (*skip_prox)(SegmentTermDocEnum *stde);
+    InStream *prox_in;
+    int prox_cnt;
+    int position;
+    void (*seek_prox)(SegmentTermDocEnum *stde, int prox_pointer);
 };
 
 TermDocEnum *stde_create(IndexReader *ir);
@@ -477,15 +494,15 @@ TermDocEnum *stpe_create(IndexReader *ir);
 /* * MultiTermDocEnum * */
 typedef struct MultiTermDocEnum MultiTermDocEnum;
 struct MultiTermDocEnum {
-  IndexReader **irs;
-  int *starts;
-  int ir_cnt;
-  Term *term;
-  int base;
-  int pointer;
-  TermDocEnum **irs_tde;
-  TermDocEnum *curr_tde;
-  TermDocEnum *(*term_docs_from_reader)(IndexReader *ir);
+    IndexReader **irs;
+    int *starts;
+    int ir_cnt;
+    Term *term;
+    int base;
+    int pointer;
+    TermDocEnum **irs_tde;
+    TermDocEnum *curr_tde;
+    TermDocEnum *(*term_docs_from_reader)(IndexReader *ir);
 };
 
 TermDocEnum *mtde_create(IndexReader **readers, int *starts, int ir_cnt);
@@ -499,33 +516,16 @@ TermDocEnum *mtpe_create(IndexReader **readers, int *starts, int ir_cnt);
 
 #define  MTDPE_POS_QUEUE_INIT_CAPA 8
 typedef struct {
-  int doc_num;
-  int freq;
-  PriorityQueue *pq;
-  int *pos_queue;
-  int pos_queue_index;
-  int pos_queue_capa;
+    int doc_num;
+    int freq;
+    PriorityQueue *pq;
+    int *pos_queue;
+    int pos_queue_index;
+    int pos_queue_capa;
 } MultipleTermDocPosEnum;
 
 TermDocEnum *mtdpe_create(IndexReader *ir, Term **terms, int t_cnt);
 
-/****************************************************************************
- *
- * FieldsReader
- *
- ****************************************************************************/
-
-typedef struct FieldsReader {
-  int len;
-  FieldInfos *fis;
-  InStream *fields_in;
-  InStream *index_in;
-} FieldsReader;
-
-FieldsReader *fr_open(Store *store, char *segment, FieldInfos *fis);
-void fr_close(FieldsReader *fr);
-Document *fr_get_doc(FieldsReader *fr, int doc_num);
-
 /****************************************************************************
  *
  * Posting
@@ -533,11 +533,11 @@ Document *fr_get_doc(FieldsReader *fr, int doc_num);
  ****************************************************************************/
 
 typedef struct Posting {
-  Term *term;
-  int freq;
-  int size;
-  int *positions;
-  TVOffsetInfo **offsets;
+    Term *term;
+    int freq;
+    int size;
+    int *positions;
+    TVOffsetInfo **offsets;
 } Posting;
 
 Posting *p_create(Term *term, int position, TVOffsetInfo *offset);
@@ -552,22 +552,22 @@ void p_add_occurance(Posting *self, int position, TVOffsetInfo *offset);
  ****************************************************************************/
 
 typedef struct DocumentWriter {
-  Store *store;
-  Analyzer *analyzer;
-  Similarity *similarity;
-  HshTable *postingtable;
-  int pcnt;
-  FieldInfos *fis;
-  float *field_boosts;
-  int *field_lengths;
-  int *field_positions;
-  int *field_offsets;
-  int max_field_length;
-  int term_index_interval;
+    Store *store;
+    Analyzer *analyzer;
+    Similarity *similarity;
+    HshTable *postingtable;
+    int pcnt;
+    FieldInfos *fis;
+    float *field_boosts;
+    int *field_lengths;
+    int *field_positions;
+    int *field_offsets;
+    int max_field_length;
+    int term_index_interval;
 } DocumentWriter; 
 
 DocumentWriter *dw_open(Store *store, Analyzer *analyzer,
-    Similarity *similarity, int max_field_length, int term_index_interval);
+                        Similarity *similarity, int max_field_length, int term_index_interval);
 void dw_close(DocumentWriter *dw);
 void dw_add_doc(DocumentWriter *dw, char *segment, Document *doc);
 
@@ -578,9 +578,9 @@ void dw_add_doc(DocumentWriter *dw, char *segment, Document *doc);
  ****************************************************************************/
 
 typedef struct SegmentInfo {
-  char *name;
-  int doc_cnt;
-  Store *store;
+    char *name;
+    int doc_cnt;
+    Store *store;
 } SegmentInfo;
 
 SegmentInfo *si_create(char *name, int doc_cnt, Store *store);
@@ -596,13 +596,13 @@ bool si_has_separate_norms(SegmentInfo *si);
  ****************************************************************************/
 
 typedef struct SegmentInfos {
-  Store *store;
-  SegmentInfo **segs;
-  int scnt;
-  int size;
-  int counter;
-  int version;
-  int format;
+    Store *store;
+    SegmentInfo **segs;
+    int scnt;
+    int size;
+    int counter;
+    int version;
+    int format;
 } SegmentInfos;
 
 SegmentInfos *sis_create();
@@ -622,65 +622,63 @@ int sis_read_current_version(Store *store);
  ****************************************************************************/
 
 enum FIELD_TYPE {
-  /* all fields */
-  IR_ALL,
-  /* all indexed fields */
-  IR_INDEXED,
-  /* all fields which are not indexed */
-  IR_UNINDEXED,
-  /* all fields which are indexed with termvectors enables */
-  IR_INDEXED_WITH_TERM_VECTOR,
-  /* all fields which are indexed but don't have termvectors enabled */
-  IR_INDEXED_NO_TERM_VECTOR,
-  /* all fields where termvectors are enabled. Please note that only standard */
-  /* termvector fields are returned */
-  IR_TERM_VECTOR,
-  /* all field with termvectors wiht positions enabled */
-  IR_TERM_VECTOR_WITH_POSITION,
-  /* all fields where termvectors with offset position are set */
-  IR_TERM_VECTOR_WITH_OFFSET,
-  /* all fields where termvectors with offset and position values set */
-  IR_TERM_VECTOR_WITH_POSITION_OFFSET
+    /* all fields */
+    IR_ALL,
+    /* all indexed fields */
+    IR_INDEXED,
+    /* all fields which are not indexed */
+    IR_UNINDEXED,
+    /* all fields which are indexed with termvectors enables */
+    IR_INDEXED_WITH_TERM_VECTOR,
+    /* all fields which are indexed but don't have termvectors enabled */
+    IR_INDEXED_NO_TERM_VECTOR,
+    /* all fields where termvectors are enabled. Please note that only standard */
+    /* termvector fields are returned */
+    IR_TERM_VECTOR,
+    /* all field with termvectors wiht positions enabled */
+    IR_TERM_VECTOR_WITH_POSITION,
+    /* all fields where termvectors with offset position are set */
+    IR_TERM_VECTOR_WITH_OFFSET,
+    /* all fields where termvectors with offset and position values set */
+    IR_TERM_VECTOR_WITH_POSITION_OFFSET
 };
 
 struct IndexReader {
-  mutex_t mutex;
-  HshTable *cache;
-  HshTable *sort_cache;
-  void *data;
-  Store *store;
-  Lock *write_lock;
-  SegmentInfos *sis;
-  bool has_changes : 1;
-  bool is_stale    : 1;
-  bool is_owner    : 1;
-  TermVector  *(*get_term_vector)(IndexReader *ir, int doc_num, char *field);
-  Array       *(*get_term_vectors)(IndexReader *ir, int doc_num);
-  int          (*num_docs)(IndexReader *ir);
-  int          (*max_doc)(IndexReader *ir);
-  Document    *(*get_doc)(IndexReader *ir, int doc_num);
-  uchar       *(*get_norms)(IndexReader *ir, char *field);
-  uchar       *(*get_norms_always)(IndexReader *ir, char *field);
-  void         (*do_set_norm)(IndexReader *ir, int doc_num, char *field,
-                   uchar val);
-  void         (*get_norms_into)(IndexReader *ir, char *field, uchar *buf,
-                   int offset);
-  TermEnum    *(*terms)(IndexReader *ir);
-  TermEnum    *(*terms_from)(IndexReader *ir, Term *term);
-  int          (*doc_freq)(IndexReader *ir, Term *t);
-  TermDocEnum *(*term_docs)(IndexReader *ir);
-  TermDocEnum *(*term_positions)(IndexReader *ir);
-  void         (*do_delete_doc)(IndexReader *ir, int doc_num);
-  void         (*do_undelete_all)(IndexReader *ir);
-  bool         (*is_deleted)(IndexReader *ir, int doc_num);
-  bool         (*has_deletions)(IndexReader *ir);
-  bool         (*has_norms)(IndexReader *ir, char *field);
-  HashSet     *(*get_field_names)(IndexReader *ir, int field_type);
-  void         (*do_commit)(IndexReader *ir);
-  void         (*do_close)(IndexReader *ir);
-  void         (*acquire_write_lock)(IndexReader *ir);
-  int          (*write_fields_i)(IndexReader *ir, OutStream *fdt_out,
-                   OutStream *fdx_out);
+    mutex_t mutex;
+    HshTable *cache;
+    HshTable *sort_cache;
+    void *data;
+    Store *store;
+    Lock *write_lock;
+    SegmentInfos *sis;
+    bool has_changes : 1;
+    bool is_stale    : 1;
+    bool is_owner    : 1;
+    TermVector  *(*get_term_vector)(IndexReader *ir, int doc_num, char *field);
+    Array       *(*get_term_vectors)(IndexReader *ir, int doc_num);
+    int          (*num_docs)(IndexReader *ir);
+    int          (*max_doc)(IndexReader *ir);
+    Document    *(*get_doc)(IndexReader *ir, int doc_num);
+    uchar       *(*get_norms)(IndexReader *ir, char *field);
+    uchar       *(*get_norms_always)(IndexReader *ir, char *field);
+    void         (*do_set_norm)(IndexReader *ir, int doc_num, char *field,
+                                uchar val);
+    void         (*get_norms_into)(IndexReader *ir, char *field, uchar *buf,
+                                   int offset);
+    TermEnum    *(*terms)(IndexReader *ir);
+    TermEnum    *(*terms_from)(IndexReader *ir, Term *term);
+    int          (*doc_freq)(IndexReader *ir, Term *t);
+    TermDocEnum *(*term_docs)(IndexReader *ir);
+    TermDocEnum *(*term_positions)(IndexReader *ir);
+    void         (*do_delete_doc)(IndexReader *ir, int doc_num);
+    void         (*do_undelete_all)(IndexReader *ir);
+    bool         (*is_deleted)(IndexReader *ir, int doc_num);
+    bool         (*has_deletions)(IndexReader *ir);
+    bool         (*has_norms)(IndexReader *ir, char *field);
+    HashSet     *(*get_field_names)(IndexReader *ir, int field_type);
+    void         (*do_commit)(IndexReader *ir);
+    void         (*do_close)(IndexReader *ir);
+    void         (*acquire_write_lock)(IndexReader *ir);
 };
 
 IndexReader *ir_create(Store *store, SegmentInfos *sis, int is_owner);
@@ -705,10 +703,10 @@ bool ir_is_latest(IndexReader *ir);
  ****************************************************************************/
 
 typedef struct Norm {
-  bool is_dirty : 1;
-  int field_num;
-  InStream *is;
-  uchar *bytes;
+    bool is_dirty : 1;
+    int field_num;
+    InStream *is;
+    uchar *bytes;
 } Norm;
 
 /****************************************************************************
@@ -718,22 +716,22 @@ typedef struct Norm {
  ****************************************************************************/
 
 struct SegmentReader {
-  FieldInfos *fis;
-  FieldsReader *fr;
-  char *segment;
-  BitVector *deleted_docs;
-  bool deleted_docs_dirty : 1;
-  bool undelete_all : 1;
-  bool norms_dirty : 1;
-  InStream *freq_in;
-  InStream *prox_in;
-  TermInfosReader *tir;
-  TermVectorsReader *orig_tvr;
-  thread_key_t thread_tvr;
-  Array *tvr_bucket;
-  HshTable *norms;
-  Store *cfs_store;
-  uchar *fake_norms;
+    FieldInfos *fis;
+    FieldsReader *fr;
+    char *segment;
+    BitVector *deleted_docs;
+    bool deleted_docs_dirty : 1;
+    bool undelete_all : 1;
+    bool norms_dirty : 1;
+    InStream *freq_in;
+    InStream *prox_in;
+    TermInfosReader *tir;
+    TermVectorsReader *orig_tvr;
+    thread_key_t thread_tvr;
+    Array *tvr_bucket;
+    HshTable *norms;
+    Store *cfs_store;
+    uchar *fake_norms;
 };
 
 IndexReader *sr_open(SegmentInfos *sis, int si_num, bool is_owner);
@@ -746,17 +744,17 @@ IndexReader *sr_open_si(SegmentInfo *si);
  ****************************************************************************/
 
 typedef struct MultiReader {
-  bool has_deletions : 1;
-  int max_doc;
-  int num_docs_cache;
-  int  rcnt;
-  int *starts;
-  IndexReader **sub_readers;
-  HshTable *norms_cache;
+    bool has_deletions : 1;
+    int max_doc;
+    int num_docs_cache;
+    int  rcnt;
+    int *starts;
+    IndexReader **sub_readers;
+    HshTable *norms_cache;
 } MultiReader;
 
 IndexReader *mr_open(Store *store, SegmentInfos *sis, IndexReader **readers,
-    int rcnt);
+                     int rcnt);
 
 /****************************************************************************
  *
@@ -765,12 +763,12 @@ IndexReader *mr_open(Store *store, SegmentInfos *sis, IndexReader **readers,
  ****************************************************************************/
 
 typedef struct SegmentMergeInfo {
-  int base;
-  IndexReader *ir;
-  TermEnum *te;
-  TermBuffer *tb;
-  TermDocEnum *postings;
-  int *doc_map;
+    int base;
+    IndexReader *ir;
+    TermEnum *te;
+    TermBuffer *tb;
+    TermDocEnum *postings;
+    int *doc_map;
 } SegmentMergeInfo;
 
 SegmentMergeInfo *smi_create(int base, TermEnum *te, IndexReader *ir);
@@ -785,24 +783,24 @@ bool smi_lt(SegmentMergeInfo *smi1, SegmentMergeInfo *smi2);
  ****************************************************************************/
 
 typedef struct SegmentMerger {
-  Store *store;
-  char *name;
-  Array *readers;
-  FieldInfos *fis;
-  OutStream *freq_out;
-  OutStream *prox_out;
-  TermInfosWriter *tiw;
-  Term *terms_buf;
-  int terms_buf_pointer;
-  int terms_buf_size;
-  PriorityQueue *queue;
-  TermInfo *ti;
-  int term_index_interval;
-  OutStream *skip_buffer;
-  int skip_interval;
-  int last_skip_doc;
-  int last_skip_freq_pointer;
-  int last_skip_prox_pointer;
+    Store *store;
+    char *name;
+    Array *readers;
+    FieldInfos *fis;
+    OutStream *freq_out;
+    OutStream *prox_out;
+    TermInfosWriter *tiw;
+    Term *terms_buf;
+    int terms_buf_pointer;
+    int terms_buf_size;
+    PriorityQueue *queue;
+    TermInfo *ti;
+    int term_index_interval;
+    OutStream *skip_buffer;
+    int skip_interval;
+    int last_skip_doc;
+    int last_skip_freq_pointer;
+    int last_skip_prox_pointer;
 } SegmentMerger;
 
 SegmentMerger *sm_create(Store *store, char *name, int term_index_interval);
@@ -821,25 +819,25 @@ Array *sm_create_compound_file(SegmentMerger *sm, char *fname);
 #define WRITE_LOCK_NAME "write"
 #define COMMIT_LOCK_NAME "commit"
 struct IndexWriter {
-  mutex_t mutex;
-  HshTable *postings;
-  FieldInfos *fis;
-  int merge_factor;
-  int min_merge_docs;
-  int max_merge_docs;
-  int max_field_length;
-  int term_index_interval;
-  Store *store;
-  Analyzer *analyzer;
-  Similarity *similarity;
-  SegmentInfos *sis;
-  Store *ram_store;
-  Lock *write_lock;
-  bool use_compound_file : 1;
+    mutex_t mutex;
+    HshTable *postings;
+    FieldInfos *fis;
+    int merge_factor;
+    int min_merge_docs;
+    int max_merge_docs;
+    int max_field_length;
+    int term_index_interval;
+    Store *store;
+    Analyzer *analyzer;
+    Similarity *similarity;
+    SegmentInfos *sis;
+    Store *ram_store;
+    Lock *write_lock;
+    bool use_compound_file : 1;
 };
 
 IndexWriter *iw_open(Store *store, Analyzer *analyzer,
-    bool create);
+                     bool create);
 void iw_flush_ram_segments(IndexWriter *iw);
 void iw_close(IndexWriter *iw);
 int  iw_doc_count(IndexWriter *iw);
@@ -855,11 +853,11 @@ void iw_add_readers(IndexWriter *iw, IndexReader **stores, int cnt);
  ****************************************************************************/
 
 typedef struct CompoundWriter {
-  Store *store;
-  const char *name;
-  HashSet *ids;
-  Array *file_entries;
-  bool merged;
+    Store *store;
+    const char *name;
+    HashSet *ids;
+    Array *file_entries;
+    bool merged;
 } CompoundWriter;
 
 CompoundWriter *open_cw(Store *store, char *name);