ferret 0.9.1 → 0.9.2

data/ext/ind.c

@@ -1,5 +1,6 @@
-#include <string.h>
 #include "search.h"
+#include <string.h>
+
 
 static char * const NON_UNIQUE_KEY_ERROR_MSG = "Tried to use a key that was not unique";
 
@@ -45,23 +46,22 @@ Index *index_create(Store *store, Analyzer *analyzer, HashSet *def_fields,
   self->has_writes = false;
   if (store) {
     self->store = store;
-    self->close_store = false;
+    ref(store);
   } else {
     self->store = open_ram_store();
     create = true;
-    self->close_store = true;
   }
   if (analyzer) {
     self->analyzer = analyzer;
-    self->close_analyzer = false;
+    ref(analyzer);
   } else {
     self->analyzer = mb_standard_analyzer_create(true);
-    self->close_analyzer = true;
   }
   self->use_compound_file = true;
 
   if (create) {
-    self->iw = iw_open(self->store, self->analyzer, create, false, false);
+    ref(self->analyzer);
+    self->iw = iw_open(self->store, self->analyzer, create);
     iw_close(self->iw);
     self->iw = NULL;
   }
@@ -73,6 +73,7 @@ Index *index_create(Store *store, Analyzer *analyzer, HashSet *def_fields,
   self->auto_flush = false;
   self->check_latest = true;
 
+  ref(self->analyzer);
   self->qp = qp_create(all_fields, def_fields, self->analyzer);
   /* Index is a convenience class so set qp convenience options */
   self->qp->allow_any_fields = true;
@@ -87,8 +88,8 @@ void index_destroy(Index *self)
   mutex_destroy(&self->mutex);
   INDEX_CLOSE_READER(self);
   if (self->iw) iw_close(self->iw);
-  if (self->close_store) self->store->close(self->store);
-  if (self->close_analyzer) a_destroy(self->analyzer);
+  store_deref(self->store);
+  a_deref(self->analyzer);
   if (self->qp) qp_destroy(self->qp);
   if (self->id_field != ((char *)ID_STRING)) free(self->id_field);
   if (self->def_field != ((char *)ID_STRING)) free(self->def_field);
@@ -106,13 +107,19 @@ void index_flush(Index *self)
   }
   self->has_writes = false;
 }
+
 inline void ensure_writer_open(Index *self)
 {
   if (!self->iw) {
     INDEX_CLOSE_READER(self);
-    self->iw = iw_open(self->store, self->analyzer, false, false, false);
+
+    /* make sure the analzyer isn't deleted by the IndexWriter */
+    ref(self->analyzer);
+    self->iw = iw_open(self->store, self->analyzer, false);
     self->iw->use_compound_file = self->use_compound_file;
-  } else {
+  } else if (self->analyzer != self->iw->analyzer) {
+    a_deref(self->iw->analyzer);
+    ref(self->analyzer);
     self->iw->analyzer = self->analyzer; /* in case it has changed */
   }
 }
@@ -122,14 +129,14 @@ inline void ensure_reader_open(Index *self)
   if (self->ir) {
     if (self->check_latest && !ir_is_latest(self->ir)) {
       INDEX_CLOSE_READER(self);
-      self->ir = ir_open(self->store, false);
+      self->ir = ir_open(self->store);
     }
   } else {
     if (self->iw) {
       iw_close(self->iw);
       self->iw = NULL;
     }
-    self->ir = ir_open(self->store, false);
+    self->ir = ir_open(self->store);
   }
 }
 
@@ -203,7 +210,7 @@ static void inline index_add_doc_i(Index *self, Document *doc)
     } else if (td->total_hits == 1) {
       ir_delete_doc(self->ir, td->hits[0]->doc);
     }
-    q->destroy(q);
+    q_deref(q);
     td_destroy(td);
   }
   ensure_writer_open(self);
@@ -215,11 +222,16 @@ void index_add_doc_a(Index *self, Document *doc, Analyzer *analyzer)
 {
   Analyzer *tmp_analyzer;
   mutex_lock(&self->store->ext_mutex);
-  tmp_analyzer = self->analyzer;
-  self->analyzer = analyzer;
-  iw_add_doc(self->iw, doc);
-  index_add_doc_i(self, doc);
-  self->analyzer = tmp_analyzer;
+  if (analyzer != self->analyzer) {
+    ref(analyzer);
+    tmp_analyzer = self->analyzer;
+    self->analyzer = analyzer;
+    index_add_doc_i(self, doc);
+    self->analyzer = tmp_analyzer;
+    a_deref(analyzer);
+  } else {
+    index_add_doc_i(self, doc);
+  }
   mutex_unlock(&self->store->ext_mutex);
 }
 
@@ -272,7 +284,7 @@ TopDocs *index_search_str(Index *self, char *qstr, int first_doc,
   TopDocs *td;
   query = index_get_query(self, qstr); /* will ensure_searcher is open */
   td = sea_search(self->sea, query, first_doc, num_docs, filter, sort);
-  query->destroy(query);
+  q_deref(query);
   return td;
 }
 
@@ -363,7 +375,7 @@ void index_delete_id(Index *self, char *id)
   index_delete_term(self, &t);
 }
 
-static void index_qdel_i(Searcher *sea, int doc_num, void *arg)
+static void index_qdel_i(Searcher *sea, int doc_num, float score, void *arg)
 {
   ir_delete_doc(sea->ir, doc_num);
 }
@@ -381,7 +393,7 @@ void index_delete_query_str(Index *self, char *qstr, Filter *f)
 {
   Query *q = index_get_query(self, qstr);
   index_delete_query(self, q, f);
-  q->destroy(q);
+  q_deref(q);
 }
 
 Explanation *index_explain(Index *self, Query *q, int doc_num)

data/ext/index.h

@@ -15,6 +15,7 @@
 
 
 #define SEGMENT_NAME_MAX_LENGTH 100
+#define NOT_A_FIELD 0xFFFFFFFF
 
 typedef struct Config {
   int merge_factor;
@@ -75,7 +76,7 @@ FieldInfo *fi_create(char *name,
                      bool store_pos,
                      bool store_offset,
                      bool omit_norms);
-void fi_destroy(void *p);
+void fi_destroy(FieldInfo *fi);
 
 /****************************************************************************
  *
@@ -91,7 +92,7 @@ typedef struct FieldInfos {
 
 FieldInfos *fis_create();
 FieldInfos *fis_open(Store *store, char *filename);
-void fis_destroy(void *p);
+void fis_destroy(FieldInfos *fis);
 FieldInfo *fis_add(FieldInfos *fis,
     char *name,
     bool is_indexed,
@@ -111,8 +112,9 @@ bool fis_has_vectors(FieldInfos *fis);
 void fis_write(FieldInfos *fis, Store *store, char *segment, char *ext);
 FieldInfos *fis_read(FieldInfos *fis, InStream *is);
 FieldInfos *fis_add_doc(FieldInfos *fis, Document *doc);
-unsigned long long fis_get_number(FieldInfos *fis, char *name);
+ullong fis_get_number(FieldInfos *fis, char *name);
 FieldInfo *fis_get_fi(FieldInfos *fis, char *name);
+bool fis_reorder_required(FieldInfos *fis, Document *doc);
 
 /****************************************************************************
  *
@@ -126,7 +128,7 @@ typedef struct TermBuffer {
 } TermBuffer;
 
 TermBuffer *tb_create();
-void tb_destroy(void *p);
+void tb_destroy(TermBuffer *tb);
 TermBuffer *tb_set_term(TermBuffer *tb, Term *t);
 Term *tb_get_term(TermBuffer *tb);
 int tb_cmp(TermBuffer *tb1, TermBuffer *tb2);
@@ -149,7 +151,7 @@ typedef struct TermInfo {
 
 TermInfo *ti_create(int doc_freq, int freq_pointer, int prox_pointer, int skip_offset);
 TermInfo *ti_set(TermInfo *ti, int df, int fp, int pp, int so);
-void ti_destroy(void *p);
+void ti_destroy(TermInfo *ti);
 TermInfo *ti_cpy(TermInfo *ti1, TermInfo *ti2);
 TermInfo *ti_clone(TermInfo *other);
 int ti_eq(TermInfo *ti1, TermInfo *ti2);
@@ -226,7 +228,7 @@ typedef struct TermInfosWriter {
   TermInfo *last_term_info;
   FieldInfos *fis;
   char *curr_field;
-  int curr_field_num;
+  ullong curr_field_num;
 } TermInfosWriter;
 
 TermInfosWriter *tiw_open(Store *store,
@@ -332,7 +334,7 @@ TermVector *tv_create(const char *field,
                       int  *freqs,
                       int  **positions,
                       TVOffsetInfo ***offsets);
-void tv_destroy(void *p);
+void tv_destroy(TermVector *tv);
 
 /****************************************************************************
  *
@@ -441,11 +443,12 @@ struct TermDocEnum {
 /* * SegmentTermDocEnum * */
 
 typedef struct SegmentTermDocEnum SegmentTermDocEnum;
+
 struct SegmentTermDocEnum {
   SegmentReader *parent;
   InStream *freq_in;
-  int count;               // the number of docs for this term that we have skipped
-  int doc_freq;            // the number of doc this term appears 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;
@@ -538,8 +541,8 @@ typedef struct Posting {
 } Posting;
 
 Posting *p_create(Term *term, int position, TVOffsetInfo *offset);
-void p_destroy(void *p);
-void p_add_occurance(Posting *p, int position, TVOffsetInfo *offset);
+void p_destroy(Posting *self);
+void p_add_occurance(Posting *self, int position, TVOffsetInfo *offset);
 
 
 /****************************************************************************
@@ -581,7 +584,7 @@ typedef struct SegmentInfo {
 } SegmentInfo;
 
 SegmentInfo *si_create(char *name, int doc_cnt, Store *store);
-void si_destroy(void *p);
+void si_destroy(SegmentInfo *si);
 bool si_has_deletions(SegmentInfo *si);
 bool si_uses_compound_file(SegmentInfo *si);
 bool si_has_separate_norms(SegmentInfo *si);
@@ -598,12 +601,12 @@ typedef struct SegmentInfos {
   int scnt;
   int size;
   int counter;
-  unsigned int version;
+  int version;
   int format;
 } SegmentInfos;
 
 SegmentInfos *sis_create();
-void sis_destroy(void *p);
+void sis_destroy(SegmentInfos *sis);
 void sis_add_si(SegmentInfos *sis, SegmentInfo *si);
 void sis_del_at(SegmentInfos *sis, int at);
 void sis_del_from_to(SegmentInfos *sis, int from, int to);
@@ -619,24 +622,24 @@ int sis_read_current_version(Store *store);
  ****************************************************************************/
 
 enum FIELD_TYPE {
-  // all fields
+  /* all fields */
   IR_ALL,
-  // all indexed fields
+  /* all indexed fields */
   IR_INDEXED,
-  // all fields which are not indexed
+  /* all fields which are not indexed */
   IR_UNINDEXED,
-  // all fields which are indexed with termvectors enables
+  /* all fields which are indexed with termvectors enables */
   IR_INDEXED_WITH_TERM_VECTOR,
-  // all fields which are indexed but don't have termvectors enabled
+  /* 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
+  /* 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
+  /* all field with termvectors wiht positions enabled */
   IR_TERM_VECTOR_WITH_POSITION,
-  // all fields where termvectors with offset position are set
+  /* all fields where termvectors with offset position are set */
   IR_TERM_VECTOR_WITH_OFFSET,
-  // all fields where termvectors with offset and position values set
+  /* all fields where termvectors with offset and position values set */
   IR_TERM_VECTOR_WITH_POSITION_OFFSET
 };
 
@@ -651,7 +654,6 @@ struct IndexReader {
   bool has_changes : 1;
   bool is_stale    : 1;
   bool is_owner    : 1;
-  bool close_store : 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);
@@ -659,8 +661,10 @@ struct IndexReader {
   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);
+  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);
@@ -675,17 +679,19 @@ struct IndexReader {
   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);
 };
 
-IndexReader *ir_create(Store *store, SegmentInfos *sis, int is_owner, int close_store);
-IndexReader *ir_open(Store *store, int close_store);
+IndexReader *ir_create(Store *store, SegmentInfos *sis, int is_owner);
+IndexReader *ir_open(Store *store);
 bool ir_index_exists(Store *store);
 void ir_close(IndexReader *ir);
 void ir_commit(IndexReader *ir);
 void ir_delete_doc(IndexReader *ir, int doc_num);
 void ir_undelete_all(IndexReader *ir);
 void ir_set_norm(IndexReader *ir, int doc_num, char *field, uchar val);
-void ir_destroy(void *p);
+void ir_destroy(IndexReader *self);
 Document *ir_get_doc_with_term(IndexReader *ir, Term *term);
 TermDocEnum *ir_term_docs_for(IndexReader *ir, Term *term);
 TermDocEnum *ir_term_positions_for(IndexReader *ir, Term *term);
@@ -730,9 +736,8 @@ struct SegmentReader {
   uchar *fake_norms;
 };
 
-IndexReader *sr_open(SegmentInfos *sis, int si_num, int is_owner, int close_store);
+IndexReader *sr_open(SegmentInfos *sis, int si_num, bool is_owner);
 IndexReader *sr_open_si(SegmentInfo *si);
-//int sr_has_deletions(IndexReader *ir);
 
 /****************************************************************************
  *
@@ -751,7 +756,7 @@ typedef struct MultiReader {
 } MultiReader;
 
 IndexReader *mr_open(Store *store, SegmentInfos *sis, IndexReader **readers,
-    int rcnt, int close_store);
+    int rcnt);
 
 /****************************************************************************
  *
@@ -769,9 +774,9 @@ typedef struct SegmentMergeInfo {
 } SegmentMergeInfo;
 
 SegmentMergeInfo *smi_create(int base, TermEnum *te, IndexReader *ir);
-void smi_destroy(void *p);
+void smi_destroy(SegmentMergeInfo *smi);
 TermBuffer *smi_next(SegmentMergeInfo *smi);
-bool smi_lt(void *p1, void *p2);
+bool smi_lt(SegmentMergeInfo *smi1, SegmentMergeInfo *smi2);
 
 /****************************************************************************
  *
@@ -801,7 +806,7 @@ typedef struct SegmentMerger {
 } SegmentMerger;
 
 SegmentMerger *sm_create(Store *store, char *name, int term_index_interval);
-void sm_destroy(void *p);
+void sm_destroy(SegmentMerger *sm);
 void sm_add(SegmentMerger *sm, IndexReader *ir);
 int sm_merge(SegmentMerger *sm);
 Array *sm_create_compound_file(SegmentMerger *sm, char *fname);
@@ -817,6 +822,8 @@ Array *sm_create_compound_file(SegmentMerger *sm, char *fname);
 #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;
@@ -828,13 +835,11 @@ struct IndexWriter {
   SegmentInfos *sis;
   Store *ram_store;
   Lock *write_lock;
-  bool close_store : 1;
-  bool close_analyzer : 1;
   bool use_compound_file : 1;
 };
 
 IndexWriter *iw_open(Store *store, Analyzer *analyzer,
-    bool create, bool close_store, bool close_analyzer);
+    bool create);
 void iw_flush_ram_segments(IndexWriter *iw);
 void iw_close(IndexWriter *iw);
 int  iw_doc_count(IndexWriter *iw);

data/ext/index_io.c

@@ -56,15 +56,17 @@ void os_seek(OutStream *os, int new_pos)
 
 inline void os_write_byte(OutStream *os, uchar b)
 {
-  if (os->buf.pos >= BUFFER_SIZE)
+  if (os->buf.pos >= BUFFER_SIZE) {
     os_flush(os);
+  }
   write_byte(os, b);
 }
 
 void os_write_bytes(OutStream *os, uchar *b, int len)
 {
-  if (os->buf.pos > 0) // flush buffer
+  if (os->buf.pos > 0) { /* flush buffer */
     os_flush(os);
+  }
 
   if (len < BUFFER_SIZE) {
     os->flush_internal(os, b, len);
@@ -99,8 +101,9 @@ void is_refill(InStream *is)
   int start = is->buf.start + is->buf.pos;
   int last = start + BUFFER_SIZE;
   int flen = is->length_internal(is);
-  if (last > flen)            // don't read past EOF
+  if (last > flen) { /* don't read past EOF */
     last = flen;
+  }
 
   is->buf.len = last - start;
   if (is->buf.len <= 0) {
@@ -116,8 +119,9 @@ void is_refill(InStream *is)
 #define read_byte(is) is->buf.buf[is->buf.pos++]
 inline uchar is_read_byte(InStream *is)
 {
-  if (is->buf.pos >= is->buf.len)
+  if (is->buf.pos >= is->buf.len) {
     is_refill(is);
+  }
 
   return read_byte(is);
 }
@@ -182,17 +186,17 @@ is_read_int(InStream *is)
           (int)is_read_byte(is);
 }
 
-long long
+llong
 is_read_long(InStream *is)
 {
-  return ((long long)is_read_byte(is) << 56) |
-         ((long long)is_read_byte(is) << 48) |
-         ((long long)is_read_byte(is) << 40) |
-         ((long long)is_read_byte(is) << 32) |
-         ((long long)is_read_byte(is) << 24) |
-         ((long long)is_read_byte(is) << 16) |
-         ((long long)is_read_byte(is) <<  8) |
-          (long long)is_read_byte(is);
+  return ((llong)is_read_byte(is) << 56) |
+         ((llong)is_read_byte(is) << 48) |
+         ((llong)is_read_byte(is) << 40) |
+         ((llong)is_read_byte(is) << 32) |
+         ((llong)is_read_byte(is) << 24) |
+         ((llong)is_read_byte(is) << 16) |
+         ((llong)is_read_byte(is) <<  8) |
+          (llong)is_read_byte(is);
 }
 
 unsigned int
@@ -204,24 +208,24 @@ is_read_uint(InStream *is)
           (unsigned int)is_read_byte(is);
 }
 
-unsigned long long
+ullong
 is_read_ulong(InStream *is)
 {
-  return ((unsigned long long)is_read_byte(is) << 56) |
-         ((unsigned long long)is_read_byte(is) << 48) |
-         ((unsigned long long)is_read_byte(is) << 40) |
-         ((unsigned long long)is_read_byte(is) << 32) |
-         ((unsigned long long)is_read_byte(is) << 24) |
-         ((unsigned long long)is_read_byte(is) << 16) |
-         ((unsigned long long)is_read_byte(is) <<  8) |
-          (unsigned long long)is_read_byte(is);
+  return ((ullong)is_read_byte(is) << 56) |
+         ((ullong)is_read_byte(is) << 48) |
+         ((ullong)is_read_byte(is) << 40) |
+         ((ullong)is_read_byte(is) << 32) |
+         ((ullong)is_read_byte(is) << 24) |
+         ((ullong)is_read_byte(is) << 16) |
+         ((ullong)is_read_byte(is) <<  8) |
+          (ullong)is_read_byte(is);
 }
 
 /* optimized to use unchecked read_byte if there is definitely space */
-inline unsigned long long
+inline ullong
 is_read_vint(InStream *is)
 {
-  register unsigned long long res, b;
+  register ullong res, b;
   register int shift = 7;
 
   if (is->buf.pos > (is->buf.len - VINT_MAX_LEN)) {
@@ -283,63 +287,63 @@ is_read_string(InStream *is)
 void
 os_write_int(OutStream *os, int l)
 {
-  os_write_byte(os, (l >> 24) & 0xFF);
-  os_write_byte(os, (l >> 16) & 0xFF);
-  os_write_byte(os, (l >>  8) & 0xFF);
-  os_write_byte(os, l & 0xFF);
+  os_write_byte(os, (uchar)((l >> 24) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 16) & 0xFF));
+  os_write_byte(os, (uchar)((l >>  8) & 0xFF));
+  os_write_byte(os, (uchar)(l & 0xFF));
 }
 
 void
-os_write_long(OutStream *os, long long l)
+os_write_long(OutStream *os, llong l)
 {
-  os_write_byte(os, (l >> 56) & 0xFF);
-  os_write_byte(os, (l >> 48) & 0xFF);
-  os_write_byte(os, (l >> 40) & 0xFF);
-  os_write_byte(os, (l >> 32) & 0xFF);
-  os_write_byte(os, (l >> 24) & 0xFF);
-  os_write_byte(os, (l >> 16) & 0xFF);
-  os_write_byte(os, (l >>  8) & 0xFF);
-  os_write_byte(os, l & 0xFF);
+  os_write_byte(os, (uchar)((l >> 56) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 48) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 40) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 32) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 24) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 16) & 0xFF));
+  os_write_byte(os, (uchar)((l >>  8) & 0xFF));
+  os_write_byte(os, (uchar)(l & 0xFF));
 }
 
 void
 os_write_uint(OutStream *os, unsigned int l)
 {
-  os_write_byte(os, (l >> 24) & 0xFF);
-  os_write_byte(os, (l >> 16) & 0xFF);
-  os_write_byte(os, (l >>  8) & 0xFF);
-  os_write_byte(os, l & 0xFF);
+  os_write_byte(os, (uchar)((l >> 24) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 16) & 0xFF));
+  os_write_byte(os, (uchar)((l >>  8) & 0xFF));
+  os_write_byte(os, (uchar)(l & 0xFF));
 }
 
 void
-os_write_ulong(OutStream *os, unsigned long long l)
+os_write_ulong(OutStream *os, ullong l)
 {
-  os_write_byte(os, (l >> 56) & 0xFF);
-  os_write_byte(os, (l >> 48) & 0xFF);
-  os_write_byte(os, (l >> 40) & 0xFF);
-  os_write_byte(os, (l >> 32) & 0xFF);
-  os_write_byte(os, (l >> 24) & 0xFF);
-  os_write_byte(os, (l >> 16) & 0xFF);
-  os_write_byte(os, (l >>  8) & 0xFF);
-  os_write_byte(os, l & 0xFF);
+  os_write_byte(os, (uchar)((l >> 56) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 48) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 40) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 32) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 24) & 0xFF));
+  os_write_byte(os, (uchar)((l >> 16) & 0xFF));
+  os_write_byte(os, (uchar)((l >>  8) & 0xFF));
+  os_write_byte(os, (uchar)(l & 0xFF));
 }
 
 /* optimized to use an unchecked write if there is space */
 inline void
-os_write_vint(OutStream *os, register unsigned long long i)
+os_write_vint(OutStream *os, register ullong i)
 {
   if (os->buf.pos > VINT_END) {
     while (i > 127) {
-      os_write_byte(os, (i & 0x7f) | 0x80);
+      os_write_byte(os, (uchar)((i & 0x7f) | 0x80));
       i >>= 7;
     }
-    os_write_byte(os, i);
+    os_write_byte(os, (uchar)(i));
   } else {
     while (i > 127) {
-      write_byte(os, (i & 0x7f) | 0x80);
+      write_byte(os, (uchar)((i & 0x7f) | 0x80));
       i >>= 7;
     }
-    write_byte(os, i);
+    write_byte(os, (uchar)(i));
   }
 }
 
@@ -356,7 +360,7 @@ os_write_chars(OutStream *os, char *buf, int start, int length)
 void
 os_write_string(OutStream *os, char *str)
 {
-  int len = strlen(str);
+  int len = (int)strlen(str);
   os_write_vint(os, len);
 
   os_write_chars(os, str, 0, len);
@@ -364,6 +368,6 @@ os_write_string(OutStream *os, char *str)
 
 int file_is_lock(char *filename)
 {
-  int start = strlen(filename) - 4;
+  int start = (int)strlen(filename) - 4;
   return ((start > 0) && (strcmp(".lck", &filename[start]) == 0));
 }