class MmapScanner

Public Class Methods

new(p1, p2 = v2, p3 = v3) click to toggle source

static VALUE initialize(int argc, VALUE *argv, VALUE obj)
{
    VALUE src, voffset, vsize;
    size_t offset, size;
    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)
        rb_raise(rb_eRangeError, "offset out of range: %lld", NUM2LL(voffset));
    if (vsize != Qnil && NUM2LL(vsize) < 0)
        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 = ms->data;
        src_size_defined = 1;
    } else if (TYPE(src) == T_FILE) {
        int fd = FIX2INT(rb_funcall(src, rb_intern("fileno"), 0));
        struct stat st;
        if (fstat(fd, &st) < 0)
            rb_sys_fail("fstat");
        if (st.st_size == 0) {
            src = rb_str_new(NULL, 0);
            src_size = 0;
        } else {
            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) {
        if (!src_size_defined)
            src_size = RSTRING_LEN(src);
    } else {
        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);
    size = vsize == Qnil ? src_size - offset : NUM2SIZET(vsize);
    if (size > src_size - offset)
        size = src_size - offset;

    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;
}

Public Instance Methods

check(p1) click to toggle source

static VALUE check(VALUE obj, VALUE re)
{
    return scan_sub(obj, re, 0, 1, 0);
}

check_until(p1) click to toggle source

static VALUE check_until(VALUE obj, VALUE re)
{
    return scan_sub(obj, re, 0, 0, 0);
}

data() click to toggle source

static VALUE data(VALUE obj)
{
    mmapscanner_t *ms;
    Data_Get_Struct(obj, mmapscanner_t, ms);
    return ms->data;
}

eos?() click to toggle source

static VALUE eos_p(VALUE obj)
{
    mmapscanner_t *ms;
    Data_Get_Struct(obj, mmapscanner_t, ms);
    return ms->pos >= ms->size ? Qtrue : Qfalse;
}

exist?(p1) click to toggle source

static VALUE exist_p(VALUE obj, VALUE re)
{
    return scan_sub(obj, re, 0, 0, 1);
}

inspect() click to toggle source

static VALUE inspect(VALUE obj)
{
    return rb_str_new2("#<MmapScanner>");
}

length()

Alias for: size

match?(p1) click to toggle source

static VALUE match_p(VALUE obj, VALUE re)
{
    return scan_sub(obj, re, 0, 1, 1);
}

matched(*args) click to toggle source

static VALUE matched(int argc, VALUE *argv, VALUE obj)
{
    mmapscanner_t *ms;
    size_t pos, len;
    Data_Get_Struct(obj, mmapscanner_t, ms);
    if (matched_sub(argc, argv, ms, &pos, &len) == 0)
        return Qnil;
    return create_from_mmapscanner(obj, pos, len);
}

matched_str(*args) click to toggle source

static VALUE matched_str(int argc, VALUE *argv, VALUE obj)
{
    mmapscanner_t *ms;
    mmap_data_t *mdata;
    size_t pos, len;
    Data_Get_Struct(obj, mmapscanner_t, ms);
    if (matched_sub(argc, argv, ms, &pos, &len) == 0)
        return Qnil;
    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);
}

peek(p1) click to toggle source

static VALUE peek(VALUE obj, VALUE size)
{
    mmapscanner_t *ms;
    size_t sz = NUM2SIZET(size);
    Data_Get_Struct(obj, mmapscanner_t, ms);
    if (sz > ms->size - ms->pos)
        sz = ms->size - ms->pos;
    return create_from_mmapscanner(obj, ms->pos, sz);
}

pos() click to toggle source

static VALUE pos(VALUE obj)
{
    mmapscanner_t *ms;
    Data_Get_Struct(obj, mmapscanner_t, ms);
    return SIZET2NUM(ms->pos);
}

pos=(p1) click to toggle source

static VALUE set_pos(VALUE obj, VALUE pos)
{
    mmapscanner_t *ms;
    size_t p, size;
    Data_Get_Struct(obj, mmapscanner_t, ms);

    if (NUM2LL(pos) < 0)
        rb_raise(rb_eRangeError, "out of range: %lld", NUM2LL(pos));
    p = NUM2SIZET(pos);
    size = ms->size;
    if (p > size)
        rb_raise(rb_eRangeError, "out of range: %zu > %zu", p, size);
    ms->pos = p;
    return pos;
}

rest() click to toggle source

static VALUE rest(VALUE obj)
{
    mmapscanner_t *ms;
    Data_Get_Struct(obj, mmapscanner_t, ms);
    return create_from_mmapscanner(obj, ms->pos, ms->size - ms->pos);
}

scan(p1) click to toggle source

static VALUE scan(VALUE obj, VALUE re)
{
    return scan_sub(obj, re, 1, 1, 0);
}

scan_full(p1, p2, p3) click to toggle source

static VALUE scan_full(VALUE obj, VALUE re, VALUE forward, VALUE ret_ms)
{
    return scan_sub(obj, re, (forward != Qnil && forward != Qfalse), 1,
                    (ret_ms == Qnil || ret_ms == Qfalse));
}

scan_until(p1) click to toggle source

static VALUE scan_until(VALUE obj, VALUE re)
{
    return scan_sub(obj, re, 1, 0, 0);
}

search_full(p1, p2, p3) click to toggle source

static VALUE search_full(VALUE obj, VALUE re, VALUE forward, VALUE ret_ms)
{
    return scan_sub(obj, re, (forward != Qnil && forward != Qfalse), 0,
                    (ret_ms == Qnil || ret_ms == Qfalse));
}

size() click to toggle source

static VALUE size(VALUE obj)
{
    mmapscanner_t *ms;
    Data_Get_Struct(obj, mmapscanner_t, ms);
    return SIZET2NUM(ms->size);
}

Also aliased as: length

skip(p1) click to toggle source

static VALUE skip(VALUE obj, VALUE re)
{
    return scan_sub(obj, re, 1, 1, 1);
}

skip_until(p1) click to toggle source

static VALUE skip_until(VALUE obj, VALUE re)
{
    return scan_sub(obj, re, 1, 0, 1);
}

slice(p1, p2) click to toggle source

static VALUE slice(VALUE obj, VALUE pos, VALUE len)
{
    if (NUM2LL(pos) < 0)
        rb_raise(rb_eRangeError, "offset out of range: %lld", NUM2LL(pos));
    if (NUM2LL(len) < 0)
        rb_raise(rb_eRangeError, "length out of range: %lld", NUM2LL(len));
    return create_from_mmapscanner(obj, NUM2ULL(pos), NUM2ULL(len));
}

terminate() click to toggle source

static VALUE terminate(VALUE obj)
{
    mmapscanner_t *ms;
    Data_Get_Struct(obj, mmapscanner_t, ms);
    ms->pos = ms->size;
    return obj;
}

to_s() click to toggle source

static VALUE to_s(VALUE obj)
{
    mmapscanner_t *ms;
    mmap_data_t *mdata;
    Data_Get_Struct(obj, mmapscanner_t, ms);
    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);
}