ferret 0.3.2 → 0.9.0

data/ext/index_io.c

@@ -1,523 +1,377 @@
-#include "ferret.h"
+#include <store.h>
+#include <string.h>
 
-ID frt_length, frt_flush_buffer, frt_read_internal, frt_seek_internal; 
-
-/****************************************************************************
- *
- * BufferIndexInput Methods
- *
- ****************************************************************************/
-
-void
-frt_indexbuffer_free(void *p)
+Buffer *buf_create()
 {
-  IndexBuffer *my_buf = (IndexBuffer *)p;
-  free(my_buf->buffer);
-  free(p);
+  Buffer *buf = ALLOC(Buffer);
+  buf->start = 0;
+  buf->pos = 0;
+  buf->len = 0;
+  return buf;
 }
 
-static VALUE
-frt_indexbuffer_alloc(VALUE klass)
+void buf_destroy(Buffer *buf)
 {
-  IndexBuffer *my_buf;
-
-  my_buf = ALLOC(IndexBuffer);
-  MEMZERO(my_buf, IndexBuffer, 1);
-  my_buf->buffer = ALLOC_N(byte_t, BUFFER_SIZE);
-
-  return Data_Wrap_Struct(klass, NULL, frt_indexbuffer_free, my_buf);
+  free(buf);
 }
 
-#define GET_MY_BUF IndexBuffer *my_buf; Data_Get_Struct(self, IndexBuffer, my_buf)
-static VALUE
-frt_indexin_init_copy(VALUE self, VALUE orig)
+OutStream *os_create()
 {
-  IndexBuffer *orig_buf;
-  int len;
-  GET_MY_BUF;
-  if (self == orig)
-    return self;
-
-  Data_Get_Struct(orig, IndexBuffer, orig_buf);
-
-  len = orig_buf->len;
-  my_buf->len = len;
-  my_buf->pos = orig_buf->pos;
-  my_buf->start = orig_buf->start;
-
-  MEMCPY(my_buf->buffer, orig_buf->buffer, byte_t, len);
-
-  return self;
+  OutStream *os = ALLOC(OutStream);
+  os->buf.start = 0;
+  os->buf.pos = 0;
+  os->buf.len = 0;
+  return os;
 }
 
-static VALUE
-frt_indexin_refill(VALUE self)
+inline void os_flush(OutStream *os)
 {
-  long start;
-  VALUE rStr;
-  int stop, len_to_read;
-  int input_len = FIX2INT(rb_funcall(self, frt_length, 0, NULL));
-  GET_MY_BUF;
-
-  start = my_buf->start + my_buf->pos;
-  stop = start + BUFFER_SIZE;
-  if (stop > input_len) {
-    stop = input_len;
-  }
-
-  len_to_read = stop - start;
-  if (len_to_read <= 0) {
-    rb_raise(rb_eEOFError, "IndexInput: Read past End of File");
-  }
-
-  rStr = rb_str_new((char *)my_buf->buffer, BUFFER_SIZE);
-  rb_funcall(self, frt_read_internal, 3,
-      rStr, INT2FIX(0), INT2FIX(len_to_read));
-
-  memcpy(my_buf->buffer, RSTRING(rStr)->ptr, BUFFER_SIZE);
-  /* my_buf->buffer = StringValuePtr(rStr); */
-
-  my_buf->len = len_to_read;
-  my_buf->start = start;
-  my_buf->pos = 0;
-
-  return Qnil;
+  os->flush_internal(os, os->buf.buf, os->buf.pos);
+  os->buf.start += os->buf.pos;
+  os->buf.pos = 0;
 }
 
-static inline byte_t
-frt_read_byte(VALUE self, IndexBuffer *my_buf)
+void os_close(OutStream *os)
 {
-  if (my_buf->pos >= my_buf->len)
-    frt_indexin_refill(self);
-  return my_buf->buffer[my_buf->pos++];
+  os_flush(os);
+  os->close_internal(os);
+  free(os);
 }
 
-static VALUE
-frt_indexin_read_byte(VALUE self)
-{
-  GET_MY_BUF;
-  return INT2FIX(frt_read_byte(self, my_buf));
-}
-  
-static VALUE
-frt_indexin_pos(VALUE self)
+int os_pos(OutStream *os)
 {
-  IndexBuffer *my_buf;
-  Data_Get_Struct(self, IndexBuffer, my_buf);
-  return INT2FIX(my_buf->start + my_buf->pos);
+  return os->buf.start + os->buf.pos;
 }
 
-static VALUE
-frt_read_bytes(VALUE self, VALUE rbuffer, int offset, int len)
+void os_seek(OutStream *os, int new_pos)
 {
-  int i;
-  VALUE rbuf = StringValue(rbuffer);
-
-  GET_MY_BUF;
-
-  if (RSTRING(rbuf)->len < (offset + len)) {
-    rb_str_resize(rbuf, offset + len);
-  }
-  if ((len + offset) < BUFFER_SIZE) {
-    rb_str_modify(rbuf);
-    for (i = offset; i < offset + len; i++) {
-      RSTRING(rbuf)->ptr[i] = frt_read_byte(self, my_buf);
-    }
-  } else {
-    VALUE start = frt_indexin_pos(self);
-    rb_funcall(self, frt_seek_internal, 1, start);
-    rb_funcall(self, frt_read_internal, 3,
-        rbuf, INT2FIX(offset), INT2FIX(len));
-
-    my_buf->start = my_buf->start + len;
-    my_buf->pos = 0;
-    my_buf->len = 0;              /* trigger refill() on read() */
-  }
-
-  return rbuf;
+  os_flush(os);
+  os->buf.start = new_pos;
+  os->seek_internal(os, new_pos);
 }
 
-static VALUE
-frt_indexin_read_bytes(VALUE self, VALUE rbuf, VALUE roffset, VALUE rlen)
-{
-  int len, offset;
+#define write_byte(os, b) os->buf.buf[os->buf.pos++] = b
 
-  len = FIX2INT(rlen);
-  offset = FIX2INT(roffset);
-
-  return frt_read_bytes(self, rbuf, offset, len);
+inline void os_write_byte(OutStream *os, uchar b)
+{
+  if (os->buf.pos >= BUFFER_SIZE)
+    os_flush(os);
+  write_byte(os, b);
 }
 
-VALUE
-frt_indexin_seek(VALUE self, VALUE rpos)
+void os_write_bytes(OutStream *os, uchar *b, int len)
 {
-  int pos = FIX2INT(rpos);
-
-  GET_MY_BUF;
+  if (os->buf.pos > 0) // flush buffer
+    os_flush(os);
 
-  if ((pos >= my_buf->start) && (pos < (my_buf->start + my_buf->len))) {
-    my_buf->pos = pos - my_buf->start;  /* seek within buffer */
+  if (len < BUFFER_SIZE) {
+    os->flush_internal(os, b, len);
+    os->buf.start += len;
   } else {
-    my_buf->start = pos;
-    my_buf->pos = 0;
-    my_buf->len = 0;                    /* trigger refill() on read() */
-    rb_funcall(self, frt_seek_internal, 1, rpos);
+    int pos = 0;
+    int size;
+    while (pos < len) {
+      if (len - pos < BUFFER_SIZE) {
+        size = len - pos;
+      } else {
+        size = BUFFER_SIZE;
+      }
+      os->flush_internal(os, b + pos, size);
+      pos += size;
+      os->buf.start += size;
+    }
   }
-  return Qnil;
 }
 
-VALUE
-frt_indexin_read_int(VALUE self)
+InStream *is_create()
 {
-  GET_MY_BUF;
-  return LONG2NUM(((int)frt_read_byte(self, my_buf) << 24) |
-                  ((int)frt_read_byte(self, my_buf) << 16) |
-                  ((int)frt_read_byte(self, my_buf) << 8) |
-                   (int)frt_read_byte(self, my_buf));
+  InStream *is = ALLOC(InStream);
+  is->buf.start = 0;
+  is->buf.pos = 0;
+  is->buf.len = 0;
+  return is;
 }
 
-VALUE
-frt_indexin_read_long(VALUE self)
+void is_refill(InStream *is)
 {
-  GET_MY_BUF;
-  return LL2NUM(((long long)frt_read_byte(self, my_buf) << 56) |
-                ((long long)frt_read_byte(self, my_buf) << 48) |
-                ((long long)frt_read_byte(self, my_buf) << 40) |
-                ((long long)frt_read_byte(self, my_buf) << 32) |
-                ((long long)frt_read_byte(self, my_buf) << 24) |
-                ((long long)frt_read_byte(self, my_buf) << 16) |
-                ((long long)frt_read_byte(self, my_buf) << 8) |
-                 (long long)frt_read_byte(self, my_buf));
-}
+  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
+    last = flen;
 
-static VALUE
-frt_indexin_read_uint(VALUE self)
-{
-  GET_MY_BUF;
-  return ULONG2NUM(((unsigned int)frt_read_byte(self, my_buf) << 24) |
-                   ((unsigned int)frt_read_byte(self, my_buf) << 16) |
-                   ((unsigned int)frt_read_byte(self, my_buf) << 8) |
-                    (unsigned int)frt_read_byte(self, my_buf));
-}
+  is->buf.len = last - start;
+  if (is->buf.len <= 0) {
+    eprintf(IO_ERROR, "EOF Error when trying to refill. flen was %d\n", flen);
+  }
 
-static VALUE
-frt_indexin_read_ulong(VALUE self)
-{
-  GET_MY_BUF;
-  return ULL2NUM(((unsigned long long)frt_read_byte(self, my_buf) << 56) |
-                 ((unsigned long long)frt_read_byte(self, my_buf) << 48) |
-                 ((unsigned long long)frt_read_byte(self, my_buf) << 40) |
-                 ((unsigned long long)frt_read_byte(self, my_buf) << 32) |
-                 ((unsigned long long)frt_read_byte(self, my_buf) << 24) |
-                 ((unsigned long long)frt_read_byte(self, my_buf) << 16) |
-                 ((unsigned long long)frt_read_byte(self, my_buf) << 8) |
-                  (unsigned long long)frt_read_byte(self, my_buf));
+  is->read_internal(is, is->buf.buf, 0, is->buf.len);
+
+  is->buf.start = start;
+  is->buf.pos = 0;
 }
 
-unsigned long long
-frt_read_vint(VALUE self, IndexBuffer *my_buf)
+#define read_byte(is) is->buf.buf[is->buf.pos++]
+inline uchar is_read_byte(InStream *is)
 {
-  register unsigned long long i, b;
-  register int shift = 7;
+  if (is->buf.pos >= is->buf.len)
+    is_refill(is);
 
-  b = frt_read_byte(self, my_buf);
-  i = b & 0x7F; /* 0x7F = 0b01111111 */
-  
-  while ((b & 0x80) != 0) {/* 0x80 = 0b10000000 */
-    b = frt_read_byte(self, my_buf);
-    i |= (b & 0x7F) << shift;
-    shift += 7;
-  }
-  
-  return i;
+  return read_byte(is);
 }
 
-static VALUE
-frt_indexin_read_vint(VALUE self)
+int is_pos(InStream *is)
 {
-  GET_MY_BUF;
-  return ULL2NUM(frt_read_vint(self, my_buf));
+  return is->buf.start + is->buf.pos;
 }
 
-void
-frt_read_chars(VALUE self, char* buffer, int off, int len) 
+uchar *is_read_bytes(InStream *is, uchar *b, int offset, int len)
 {
-  /* byte_t b, b1, b2; */
-  int end, i;
-
-  GET_MY_BUF;
-
-  end = off + len;
-
-
-  for(i = off; i < end; i++) {
-      buffer[i] = frt_read_byte(self, my_buf);
+  int i, start;
+  if ((offset + len) < BUFFER_SIZE) {
+    for (i = offset; i < offset + len; i++) {
+      b[i] = is_read_byte(is);
+    }
+  } else {                           // read all-at-once
+    start = is_pos(is);
+    is->seek_internal(is, start);
+    is->read_internal(is, b, offset, len);
+
+    is->buf.start = start + len;        // adjust stream variables
+    is->buf.pos = 0;
+    is->buf.len = 0;                    // trigger refill on read
   }
+  return b;
 }
 
-static VALUE
-frt_indexin_read_string(VALUE self)
+void is_seek(InStream *is, int pos)
 {
-  int length;
-  char *str;
-  GET_MY_BUF;
-  length = (int)frt_read_vint(self, my_buf);
-  str = ALLOC_N(char, length);
-
-  frt_read_chars(self, str, 0, length);
-
-  return rb_str_new(str, length);
+  if (pos >= is->buf.start && pos < (is->buf.start + is->buf.len)) {
+    is->buf.pos = pos - is->buf.start;  // seek within buffer
+  } else {
+    is->buf.start = pos;
+    is->buf.pos = 0;
+    is->buf.len = 0;               // trigger refill() on read()
+    is->seek_internal(is, pos);
+  }
 }
 
-/****************************************************************************
- *
- * BufferIndexInput Methods
- *
- ****************************************************************************/
-
-static VALUE
-frt_indexout_flush(VALUE self)
+void is_close(InStream *is)
 {
-  GET_MY_BUF;
-
-  rb_funcall(self, frt_flush_buffer, 2,
-      rb_str_new((char *)my_buf->buffer, BUFFER_SIZE), INT2FIX(my_buf->pos));
-
-  my_buf->start += my_buf->pos;
-  my_buf->pos = 0;
-
-  return Qnil;
+  is->close_internal(is);
+  free(is);
 }
 
-static VALUE
-frt_write_byte(VALUE self, byte_t b)
+InStream *is_clone(InStream *is) 
 {
-  GET_MY_BUF;
-
-  my_buf->buffer[my_buf->pos++] = b;
-
-  if (my_buf->pos >= BUFFER_SIZE)
-    frt_indexout_flush(self);
-  return Qnil;
+  InStream *new_index_i = ALLOC(InStream);
+  memcpy(new_index_i, is, sizeof(InStream));
+  //new_index_i->buf.start = is->buf.start;
+  //new_index_i->buf.pos = is->buf.pos;
+  //new_index_i->buf.len = is->buf.len;
+  //new_index_i->file = is->file;
+  //new_index_i->d = is->d;
+  //new_index_i->read_internal = is->read_internal;
+  //new_index_i->seek_internal = is->seek_internal;
+  //new_index_i->length_internal = is->length_internal;
+  //new_index_i->clone_internal = is->clone_internal;
+  //new_index_i->close_internal = is->close_internal;
+  new_index_i->is_clone = true;
+  is->clone_internal(is, new_index_i);
+  return new_index_i;
 }
 
-static VALUE
-frt_indexout_write_byte(VALUE self, VALUE rbyte)
+int
+is_read_int(InStream *is)
 {
-  byte_t b = (byte_t)FIX2INT(rbyte);
-  frt_write_byte(self, b);
-  return Qnil;
+  return ((int)is_read_byte(is) << 24) |
+         ((int)is_read_byte(is) << 16) |
+         ((int)is_read_byte(is) <<  8) |
+          (int)is_read_byte(is);
 }
 
-void
-frt_write_bytes(VALUE self, byte_t *buf, int len)
+long long
+is_read_long(InStream *is)
 {
-  int i;
-  for (i = 0; i < len; i++)
-    frt_write_byte(self, buf[i]);
+  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);
 }
 
-static VALUE
-frt_indexout_write_bytes(VALUE self, VALUE rbuffer, VALUE rlen)
+unsigned int
+is_read_uint(InStream *is)
 {
-  int len = FIX2INT(rlen);
-  int i;
-  VALUE rbuf = StringValue(rbuffer);
-
-  for (i = 0; i < len; i++)
-    frt_write_byte(self, RSTRING(rbuf)->ptr[i]);
-
-  return Qnil;
+  return ((unsigned int)is_read_byte(is) << 24) |
+         ((unsigned int)is_read_byte(is) << 16) |
+         ((unsigned int)is_read_byte(is) <<  8) |
+          (unsigned int)is_read_byte(is);
 }
 
-static VALUE
-frt_indexout_pos(VALUE self)
+unsigned long long
+is_read_ulong(InStream *is)
 {
-  GET_MY_BUF;
-  return INT2FIX(my_buf->start + my_buf->pos);
+  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);
 }
 
-static VALUE
-frt_indexout_seek(VALUE self, VALUE pos)
+/* optimized to use unchecked read_byte if there is definitely space */
+inline unsigned long long
+is_read_vint(InStream *is)
 {
-  GET_MY_BUF;
-
-  frt_indexout_flush(self);
-  my_buf->start = FIX2INT(pos);
+  register unsigned long long res, b;
+  register int shift = 7;
 
-  return Qnil;
+  if (is->buf.pos > (is->buf.len - VINT_MAX_LEN)) {
+    b = is_read_byte(is);
+    res = b & 0x7F; // 0x7F = 0b01111111
+    
+    while ((b & 0x80) != 0) {// 0x80 = 0b10000000
+      b = is_read_byte(is);
+      res |= (b & 0x7F) << shift;
+      shift += 7;
+    }
+  } else { // unchecked
+    b = read_byte(is);
+    res = b & 0x7F; // 0x7F = 0b01111111
+    
+    while ((b & 0x80) != 0) {// 0x80 = 0b10000000
+      b = read_byte(is);
+      res |= (b & 0x7F) << shift;
+      shift += 7;
+    }
+  }
+  
+  return res;
 }
 
-static VALUE
-frt_indexout_write_int(VALUE self, VALUE rint)
+inline void
+is_read_chars(InStream *is, char* buffer, int off, int len)
 {
-  long l = NUM2LONG(rint);
-  frt_write_byte(self, (l >> 24) & 0xFF);
-  frt_write_byte(self, (l >> 16) & 0xFF);
-  frt_write_byte(self, (l >>  8) & 0xFF);
-  frt_write_byte(self, l & 0xFF);
-
-  return Qnil;
-}
+	int end, i;
 
-static VALUE
-frt_indexout_write_long(VALUE self, VALUE rlong)
-{
-  long long l = NUM2LL(rlong);
-  frt_write_byte(self, (l >> 56) & 0xFF);
-  frt_write_byte(self, (l >> 48) & 0xFF);
-  frt_write_byte(self, (l >> 40) & 0xFF);
-  frt_write_byte(self, (l >> 32) & 0xFF);
-  frt_write_byte(self, (l >> 24) & 0xFF);
-  frt_write_byte(self, (l >> 16) & 0xFF);
-  frt_write_byte(self, (l >>  8) & 0xFF);
-  frt_write_byte(self, l & 0xFF);
+	end = off + len;
 
-  return Qnil;
+	for(i = off; i < end; i++) {
+		buffer[i] = is_read_byte(is);
+  }
 }
 
-static VALUE
-frt_indexout_write_uint(VALUE self, VALUE ruint)
+char *
+is_read_string(InStream *is)
 {
-  unsigned long l = NUM2ULONG(ruint);
-  frt_write_byte(self, (l >> 24) & 0xFF);
-  frt_write_byte(self, (l >> 16) & 0xFF);
-  frt_write_byte(self, (l >>  8) & 0xFF);
-  frt_write_byte(self, l & 0xFF);
+  register int length = (int)is_read_vint(is);
+  char *str = ALLOC_N(char, length + 1);
+  str[length] = '\0';
 
-  return Qnil;
+  if (is->buf.pos > (is->buf.len - length)) {
+    register int i;
+    for(i = 0; i < length; i++) {
+      str[i] = is_read_byte(is);
+    }
+  } else { // unchecked
+    memcpy(str, is->buf.buf + is->buf.pos, length);
+    is->buf.pos += length;
+  }
+  //is_read_chars(is, str, 0, length);
+
+  return str;
 }
 
-static VALUE
-frt_indexout_write_ulong(VALUE self, VALUE rulong)
+void
+os_write_int(OutStream *os, int l)
 {
-  unsigned long long l;
-  l = rb_num2ull(rulong); /* ruby 1.8 doesn't have NUM2ULL. Added in 1.9 */
-  frt_write_byte(self, (l >> 56) & 0xFF);
-  frt_write_byte(self, (l >> 48) & 0xFF);
-  frt_write_byte(self, (l >> 40) & 0xFF);
-  frt_write_byte(self, (l >> 32) & 0xFF);
-  frt_write_byte(self, (l >> 24) & 0xFF);
-  frt_write_byte(self, (l >> 16) & 0xFF);
-  frt_write_byte(self, (l >>  8) & 0xFF);
-  frt_write_byte(self, l & 0xFF);
-
-  return Qnil;
+  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);
 }
 
-static VALUE
-frt_write_vint(VALUE self, register unsigned long long i)
+void
+os_write_long(OutStream *os, long long l)
 {
-  while (i > 127) {
-    frt_write_byte(self, (i & 0x7f) | 0x80);
-    i >>= 7;
-  }
-  frt_write_byte(self, i);
-
-  return Qnil;
+  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);
 }
 
-static VALUE
-frt_indexout_write_vint(VALUE self, VALUE rulong)
+void
+os_write_uint(OutStream *os, unsigned int l)
 {
-  register unsigned long long i = rb_num2ull(rulong);
+  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);
+}
 
-  while (i > 127) {
-    frt_write_byte(self, (i & 0x7f) | 0x80);
-    i >>= 7;
+void
+os_write_ulong(OutStream *os, unsigned long long 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);
+}
+
+/* optimized to use an unchecked write if there is space */
+inline void
+os_write_vint(OutStream *os, register unsigned long long i)
+{
+  if (os->buf.pos > VINT_END) {
+    while (i > 127) {
+      os_write_byte(os, (i & 0x7f) | 0x80);
+      i >>= 7;
+    }
+    os_write_byte(os, i);
+  } else {
+    while (i > 127) {
+      write_byte(os, (i & 0x7f) | 0x80);
+      i >>= 7;
+    }
+    write_byte(os, i);
   }
-  frt_write_byte(self, i);
-
-  return Qnil;
 }
 
-static VALUE
-frt_write_chars(VALUE self, VALUE rbuf, int start, int length)
+void
+os_write_chars(OutStream *os, char *buf, int start, int length)
 {
   int i;
-  VALUE rstr = StringValue(rbuf);
 
   for (i = start; i < start + length; i++) {
-    frt_write_byte(self, RSTRING(rstr)->ptr[i]);
+    os_write_byte(os, buf[i]);
   }
-
-  return Qnil;
 }
 
-static VALUE
-frt_indexout_write_chars(VALUE self, VALUE rstr, VALUE rstart, VALUE rlength)
+void
+os_write_string(OutStream *os, char *str)
 {
-  int start = FIX2INT(rstart);
-  int length = FIX2INT(rlength);
+  int len = strlen(str);
+  os_write_vint(os, len);
 
-  return frt_write_chars(self, rstr, start, length);
+  os_write_chars(os, str, 0, len);
 }
 
-static VALUE
-frt_indexout_write_string(VALUE self, VALUE rstr)
+int file_is_lock(char *filename)
 {
-  int len = RSTRING(StringValue(rstr))->len;
-  frt_write_vint(self, len);
-
-  frt_write_chars(self, rstr, 0, len);
-  return Qnil;
-}
-
-/****************************************************************************
- *
- * Init Function
- *
- ****************************************************************************/
-
-void
-Init_indexio(void)
-{
-  /* IDs */
-  frt_length = rb_intern("length");
-  frt_flush_buffer = rb_intern("flush_buffer");
-  frt_read_internal = rb_intern("read_internal");
-  frt_seek_internal = rb_intern("seek_internal");
-
-  /* IndexInput */
-  cIndexIn = rb_define_class_under(mStore, "IndexInput", rb_cObject);
-  cBufferedIndexIn = rb_define_class_under(mStore, "BufferedIndexInput", cIndexIn);
-  rb_define_alloc_func(cBufferedIndexIn, frt_indexbuffer_alloc);
-
-  rb_define_method(cBufferedIndexIn, "initialize_copy", frt_indexin_init_copy, 1);
-  rb_define_method(cBufferedIndexIn, "refill", frt_indexin_refill, 0);
-  rb_define_method(cBufferedIndexIn, "read_byte", frt_indexin_read_byte, 0);
-  rb_define_method(cBufferedIndexIn, "read_bytes", frt_indexin_read_bytes, 3);
-  rb_define_method(cBufferedIndexIn, "pos", frt_indexin_pos, 0);
-  rb_define_method(cBufferedIndexIn, "seek", frt_indexin_seek, 1);
-  rb_define_method(cBufferedIndexIn, "read_int", frt_indexin_read_int, 0);
-  rb_define_method(cBufferedIndexIn, "read_long", frt_indexin_read_long, 0);
-  rb_define_method(cBufferedIndexIn, "read_uint", frt_indexin_read_uint, 0);
-  rb_define_method(cBufferedIndexIn, "read_ulong", frt_indexin_read_ulong, 0);
-  rb_define_method(cBufferedIndexIn, "read_vint", frt_indexin_read_vint, 0);
-  rb_define_method(cBufferedIndexIn, "read_vlong", frt_indexin_read_vint, 0);
-  rb_define_method(cBufferedIndexIn, "read_string", frt_indexin_read_string, 0);
-  rb_define_method(cBufferedIndexIn, "read_chars", frt_indexin_read_bytes, 3);
-
-  /* IndexOutput */
-  cIndexOut = rb_define_class_under(mStore, "IndexOutput", rb_cObject);
-  cBufferedIndexOut = rb_define_class_under(mStore, "BufferedIndexOutput", cIndexOut);
-  rb_define_alloc_func(cBufferedIndexOut, frt_indexbuffer_alloc);
-
-  rb_define_method(cBufferedIndexOut, "write_byte", frt_indexout_write_byte, 1);
-  rb_define_method(cBufferedIndexOut, "write_bytes", frt_indexout_write_bytes, 2);
-  rb_define_method(cBufferedIndexOut, "flush", frt_indexout_flush, 0);
-  rb_define_method(cBufferedIndexOut, "close", frt_indexout_flush, 0);
-  rb_define_method(cBufferedIndexOut, "pos", frt_indexout_pos, 0);
-  rb_define_method(cBufferedIndexOut, "seek", frt_indexout_seek, 1);
-  rb_define_method(cBufferedIndexOut, "write_int", frt_indexout_write_int, 1);
-  rb_define_method(cBufferedIndexOut, "write_long", frt_indexout_write_long, 1);
-  rb_define_method(cBufferedIndexOut, "write_uint", frt_indexout_write_uint, 1);
-  rb_define_method(cBufferedIndexOut, "write_ulong", frt_indexout_write_ulong, 1);
-  rb_define_method(cBufferedIndexOut, "write_vint", frt_indexout_write_vint, 1);
-  rb_define_method(cBufferedIndexOut, "write_vlong", frt_indexout_write_vint, 1);
-  rb_define_method(cBufferedIndexOut, "write_chars", frt_indexout_write_chars, 3);
-  rb_define_method(cBufferedIndexOut, "write_string", frt_indexout_write_string, 1);
-
-  /* FSIndexInput */
-  /*cFSIndexIn = rb_define_class_under(mStore, "FSIndexInput", cBufferedIndexIn); */
+  int start = strlen(filename) - 4;
+  return ((start > 0) && (strcmp(".lck", &filename[start]) == 0));
 }