mmapscanner 0.3.1 → 0.3.2

data/ext/mmapscanner.c

@@ -28,20 +28,68 @@ static void mmap_free(mmap_data_t *data)
 {
     if (data->ptr)
         munmap(data->ptr, data->size);
-    free(data);
+    xfree(data);
 }
 
-static VALUE create_mmap_object(int fd, size_t offset, size_t size)
+static VALUE mmap_allocate(VALUE klass)
 {
     mmap_data_t *data;
-    void *ptr;
-    if ((ptr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, offset)) == MAP_FAILED) {
-        rb_exc_raise(rb_funcall(rb_eSystemCallError, rb_intern("new"), 1, INT2FIX(errno)));
-    }
     data = xmalloc(sizeof(mmap_data_t));
+    data->ptr = NULL;
+    data->size = 0;
+    return Data_Wrap_Struct(klass, 0, mmap_free, data);
+}
+
+static VALUE mmap_initialize(int argc, VALUE *argv, VALUE obj)
+{
+    mmap_data_t *data;
+    Data_Get_Struct(obj, mmap_data_t, data);
+    if (data->ptr)
+        rb_raise(rb_eRuntimeError, "already mapped");
+    VALUE file, voffset, vlength;
+    off_t offset = 0;
+    size_t length = 0;
+    rb_scan_args(argc, argv, "12", &file, &voffset, &vlength);
+    if (TYPE(file) != T_FILE)
+        rb_raise(rb_eTypeError, "File object required");
+    if (voffset != Qnil && NUM2LL(voffset) < 0)
+        rb_raise(rb_eRangeError, "offset out of range: %lld", NUM2LL(voffset));
+    if (vlength != Qnil && NUM2LL(vlength) < 0)
+        rb_raise(rb_eRangeError, "length out of range: %lld", NUM2LL(vlength));
+    int fd = RFILE(file)->fptr->fd;
+    struct stat st;
+    if (fstat(fd, &st) < 0)
+        rb_sys_fail("fstat");
+    offset = voffset == Qnil ? 0 : NUM2SIZET(voffset);
+    length = vlength == Qnil ? st.st_size : NUM2SIZET(vlength);
+    if (offset + length > st.st_size)
+        length = st.st_size - offset;
+    void *ptr;
+    if ((ptr = mmap(NULL, length, PROT_READ, MAP_SHARED, fd, offset)) == MAP_FAILED)
+        rb_sys_fail("mmap");
+
     data->ptr = ptr;
-    data->size = size;
-    return Data_Wrap_Struct(cMmap, 0, mmap_free, data);
+    data->size = length;
+    return Qnil;
+}
+
+static VALUE mmap_size(VALUE obj)
+{
+    mmap_data_t *data;
+    Data_Get_Struct(obj, mmap_data_t, data);
+    return SIZET2NUM(data->size);
+}
+
+static VALUE mmap_unmap(VALUE obj)
+{
+    mmap_data_t *data;
+    Data_Get_Struct(obj, mmap_data_t, data);
+    if (data->ptr == NULL)
+        rb_raise(rb_eRuntimeError, "already unmapped");
+    if (munmap(data->ptr, data->size) < 0)
+        rb_sys_fail("munmap");
+    data->ptr = NULL;
+    return Qnil;
 }
 
 static void mmapscanner_free(mmapscanner_t *ms)
@@ -74,9 +122,9 @@ static VALUE initialize(int argc, VALUE *argv, VALUE obj)
 {
     VALUE src, voffset, vsize;
     size_t offset, size;
-    size_t src_offset, src_size;
-    VALUE src_data;
-    mmapscanner_t *ms;
+    size_t src_offset = 0, src_size = 0;
+    mmapscanner_t *self;
+    int src_size_defined = 0;
 
     rb_scan_args(argc, argv, "12", &src, &voffset, &vsize);
     if (voffset != Qnil && NUM2LL(voffset) < 0)
@@ -85,27 +133,26 @@ static VALUE initialize(int argc, VALUE *argv, VALUE obj)
         rb_raise(rb_eRangeError, "length out of range: %lld", NUM2LL(vsize));
     offset = voffset == Qnil ? 0 : NUM2SIZET(voffset);
     if (rb_obj_class(src) == cMmapScanner) {
+        mmapscanner_t *ms;
         Data_Get_Struct(src, mmapscanner_t, ms);
         src_offset = ms->offset;
         src_size = ms->size;
-        src_data = ms->data;
+        src = ms->data;
+        src_size_defined = 1;
     } else if (TYPE(src) == T_FILE) {
-        int fd;
-        struct stat st;
-        fd = RFILE(src)->fptr->fd;
-        fstat(fd, &st);
-        src_offset = 0;
-        src_size = st.st_size;
-        size = vsize == Qnil ? src_size - offset : NUM2SIZET(vsize);
-        if (size > st.st_size - offset)
-            size = st.st_size - offset;
-        src_data = create_mmap_object(fd, offset, size);
+        src = rb_funcall(cMmap, rb_intern("new"), 1, src);
+    }
+    if (rb_obj_class(src) == cMmap) {
+        if (!src_size_defined) {
+            mmap_data_t *data;
+            Data_Get_Struct(src, mmap_data_t, data);
+            src_size = data->size;
+        }
     } else if (TYPE(src) == T_STRING) {
-        src_offset = 0;
-        src_size = RSTRING_LEN(src);
-        src_data = src;
+        if (!src_size_defined)
+            src_size = RSTRING_LEN(src);
     } else {
-        rb_raise(rb_eTypeError, "wrong argument type %s (expected File/String/MmapScanner)", rb_obj_classname(src));
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected File/String/MmapScanner/MmapScanner::Mmap)", rb_obj_classname(src));
     }
     if (offset > src_size)
         rb_raise(rb_eRangeError, "length out of range: %zu > %zu", offset, src_size);
@@ -113,13 +160,13 @@ static VALUE initialize(int argc, VALUE *argv, VALUE obj)
     if (size > src_size - offset)
         size = src_size - offset;
 
-    Data_Get_Struct(obj, mmapscanner_t, ms);
-    ms->offset = src_offset + offset;
-    ms->size = size;
-    ms->pos = 0;
-    ms->matched = 0;
-    ms->matched_pos = 0;
-    ms->data = src_data;
+    Data_Get_Struct(obj, mmapscanner_t, self);
+    self->offset = src_offset + offset;
+    self->size = size;
+    self->pos = 0;
+    self->matched = 0;
+    self->matched_pos = 0;
+    self->data = src;
     return Qnil;
 }
 
@@ -130,6 +177,13 @@ static VALUE size(VALUE obj)
     return SIZET2NUM(ms->size);
 }
 
+static VALUE data(VALUE obj)
+{
+    mmapscanner_t *ms;
+    Data_Get_Struct(obj, mmapscanner_t, ms);
+    return ms->data;
+}
+
 static VALUE to_s(VALUE obj)
 {
     mmapscanner_t *ms;
@@ -138,6 +192,8 @@ static VALUE to_s(VALUE obj)
     if (TYPE(ms->data) == T_STRING)
         return rb_str_new(RSTRING_PTR(ms->data) + ms->offset, ms->size);
     Data_Get_Struct(ms->data, mmap_data_t, mdata);
+    if (mdata->ptr == NULL)
+        rb_raise(rb_eRuntimeError, "already unmapped");
     return rb_str_new(mdata->ptr + ms->offset, ms->size);
 }
 
@@ -194,6 +250,8 @@ static VALUE scan_sub(VALUE obj, VALUE re, int forward, int headonly, int sizeon
         ptr = RSTRING_PTR(ms->data);
     else {
         Data_Get_Struct(ms->data, mmap_data_t, mdata);
+        if (mdata->ptr == NULL)
+            rb_raise(rb_eRuntimeError, "already unmapped");
         ptr = mdata->ptr;
     }
     ptr += ms->offset;
@@ -329,6 +387,8 @@ static VALUE matched_str(int argc, VALUE *argv, VALUE obj)
     if (TYPE(ms->data) == T_STRING)
         return rb_str_new(RSTRING_PTR(ms->data)+ms->offset+pos, len);
     Data_Get_Struct(ms->data, mmap_data_t, mdata);
+    if (mdata->ptr == NULL)
+        rb_raise(rb_eRuntimeError, "already unmapped");
     return rb_str_new(mdata->ptr+ms->offset+pos, len);
 }
 
@@ -339,6 +399,7 @@ void Init_mmapscanner(void)
     rb_define_method(cMmapScanner, "initialize", initialize, -1);
     rb_define_method(cMmapScanner, "size", size, 0);
     rb_define_method(cMmapScanner, "length", size, 0);
+    rb_define_method(cMmapScanner, "data", data, 0);
     rb_define_method(cMmapScanner, "to_s", to_s, 0);
     rb_define_method(cMmapScanner, "slice", slice, 2);
 //    rb_define_method(cMmapScanner, "[]", slice, 2);
@@ -357,4 +418,8 @@ void Init_mmapscanner(void)
     rb_define_method(cMmapScanner, "matched_str", matched_str, -1);
 
     cMmap = rb_define_class_under(cMmapScanner, "Mmap", rb_cObject);
+    rb_define_alloc_func(cMmap, mmap_allocate);
+    rb_define_method(cMmap, "initialize", mmap_initialize, -1);
+    rb_define_method(cMmap, "size", mmap_size, 0);
+    rb_define_method(cMmap, "unmap", mmap_unmap, 0);
 }

data/spec/mmapscanner_spec.rb

@@ -3,6 +3,29 @@ require 'tempfile'
 $LOAD_PATH.unshift "#{File.dirname __FILE__}/../ext"
 require 'mmapscanner'
 
+describe MmapScanner::Mmap do
+  before do
+    tmpf = Tempfile.new 'mmapscanner'
+    tmpf.write '0123456789'*1000
+    @file = File.open(tmpf.path)
+  end
+  subject{MmapScanner::Mmap.new(@file)}
+  it '#size returns file size' do
+    subject.size.should == 10000
+  end
+  it '.new with invalid offset raise error' do
+    expect{MmapScanner::Mmap.new(@file, 4095)}.to raise_error(Errno::EINVAL)
+  end
+  context 'unmapped object' do
+    before do
+      subject.unmap
+    end
+    it '#unmap raise error' do
+      expect{subject.unmap}.to raise_error(RuntimeError, 'already unmapped')
+    end
+  end
+end
+
 describe MmapScanner do
   shared_examples_for 'MmapScanner' do
     it '#size returns size of file' do
@@ -184,9 +207,9 @@ describe MmapScanner do
     let(:src){@file}
     subject{MmapScanner.new(src)}
     it_should_behave_like 'MmapScanner'
-    describe '.new with position' do
-      it 'raise error when invalid position' do
-        expect{MmapScanner.new(@file, 4095)}.to raise_error(Errno::EINVAL)
+    describe '#data' do
+      it 'returns Mmap object' do
+        subject.data.should be_kind_of MmapScanner::Mmap
       end
     end
   end
@@ -202,6 +225,49 @@ describe MmapScanner do
         m.to_s.should be_empty
       end
     end
+    describe '#data' do
+      it 'returns source object' do
+        subject.data.should be_equal src
+      end
+    end
+  end
+
+  context 'with Mmap' do
+    before do
+      tmpf = Tempfile.new 'mmapscanner'
+      tmpf.write '0123456789'*1020
+      @file = File.open(tmpf.path)
+    end
+    let(:src){MmapScanner::Mmap.new(@file)}
+    subject{MmapScanner.new(src, 100, 10000)}
+    it_should_behave_like 'MmapScanner'
+    describe '.new with empty source' do
+      it 'returns empty MmapScanner' do
+        m = MmapScanner.new(src, 1020, 0)
+        m.size.should == 0
+        m.to_s.should be_empty
+      end
+    end
+    describe '#data' do
+      it 'returns source object' do
+        subject.data.should be_equal src
+      end
+    end
+    context 'unmapped object' do
+      before do
+        subject.scan(/.../)
+        src.unmap
+      end
+      it '#to_s raise RuntimeError' do
+        expect{subject.to_s}.to raise_error(RuntimeError, 'already unmapped')
+      end
+      it '#scan raise RuntimeError' do
+        expect{subject.scan(/./)}.to raise_error(RuntimeError, 'already unmapped')
+      end
+      it '#matched_str raise RuntimeError' do
+        expect{subject.matched_str}.to raise_error(RuntimeError, 'already unmapped')
+      end
+    end
   end
 
   context 'with MmapScanner' do
@@ -213,6 +279,11 @@ describe MmapScanner do
     let(:src){MmapScanner.new(@file)}
     subject{MmapScanner.new(src, 100, 10000)}
     it_should_behave_like 'MmapScanner'
+    describe '#data' do
+      it 'returns data object' do
+        subject.data.should be_kind_of MmapScanner::Mmap
+      end
+    end
     describe '.new with empty source' do
       it 'returns empty MmapScanner' do
         m = MmapScanner.new(src, 1020, 0)

metadata

@@ -2,7 +2,7 @@
 name: mmapscanner
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
 - TOMITA Masahiro
@@ -10,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-23 00:00:00 +09:00
-default_executable: 
+date: 2011-07-23 00:00:00 Z
 dependencies: []
 
 description: 
@@ -27,7 +26,6 @@ files:
 - ext/mmapscanner.c
 - spec/mmapscanner_spec.rb
 - ext/extconf.rb
-has_rdoc: true
 homepage: http://github.com/tmtm/mmapscanner
 licenses: 
 - Ruby's
@@ -51,7 +49,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.0
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: MmapScanner like StringScanner but it use mmap(2)-ed data