Class: MmapScanner

Inherits:
Object
  • Object
show all
Defined in:
ext/mmapscanner.c

Defined Under Namespace

Classes: Mmap

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object 



142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
 
# File 'ext/mmapscanner.c', line 142

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

Instance Method Details

#check(re) ⇒ Object 



391
392
393
394
 
# File 'ext/mmapscanner.c', line 391

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

#check_until(re) ⇒ Object 



396
397
398
399
 
# File 'ext/mmapscanner.c', line 396

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

#data ⇒ Object 



230
231
232
233
234
235
 
# File 'ext/mmapscanner.c', line 230

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

#eos? ⇒ Boolean

Returns:

  • (Boolean) 


431
432
433
434
435
436
 
# File 'ext/mmapscanner.c', line 431

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

#exist?(re) ⇒ Boolean

Returns:

  • (Boolean) 


416
417
418
419
 
# File 'ext/mmapscanner.c', line 416

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

#inspect ⇒ Object

rb_define_method(cMmapScanner, “[]”, slice, 2);



259
260
261
262
 
# File 'ext/mmapscanner.c', line 259

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

#length ⇒ Object 



223
224
225
226
227
228
 
# File 'ext/mmapscanner.c', line 223

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

#match?(re) ⇒ Boolean

Returns:

  • (Boolean) 


411
412
413
414
 
# File 'ext/mmapscanner.c', line 411

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

#matched(*args) ⇒ Object 



467
468
469
470
471
472
473
474
475
 
# File 'ext/mmapscanner.c', line 467

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) ⇒ Object 



477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
 
# File 'ext/mmapscanner.c', line 477

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(size) ⇒ Object 



421
422
423
424
425
426
427
428
429
 
# File 'ext/mmapscanner.c', line 421

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 ⇒ Object 



264
265
266
267
268
269
 
# File 'ext/mmapscanner.c', line 264

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

#pos=(pos) ⇒ Object 



271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
 
# File 'ext/mmapscanner.c', line 271

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 ⇒ Object 



438
439
440
441
442
443
 
# File 'ext/mmapscanner.c', line 438

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(re) ⇒ Object 



381
382
383
384
 
# File 'ext/mmapscanner.c', line 381

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

#scan_full(re, forward, ret_ms) ⇒ Object 



369
370
371
372
373
 
# File 'ext/mmapscanner.c', line 369

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(re) ⇒ Object 



386
387
388
389
 
# File 'ext/mmapscanner.c', line 386

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

#search_full(re, forward, ret_ms) ⇒ Object 



375
376
377
378
379
 
# File 'ext/mmapscanner.c', line 375

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 ⇒ Object 



223
224
225
226
227
228
 
# File 'ext/mmapscanner.c', line 223

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

#skip(re) ⇒ Object 



401
402
403
404
 
# File 'ext/mmapscanner.c', line 401

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

#skip_until(re) ⇒ Object 



406
407
408
409
 
# File 'ext/mmapscanner.c', line 406

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

#slice(pos, len) ⇒ Object 



250
251
252
253
254
255
256
257
 
# File 'ext/mmapscanner.c', line 250

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 ⇒ Object 



493
494
495
496
497
498
499
 
# File 'ext/mmapscanner.c', line 493

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

#to_s ⇒ Object 



237
238
239
240
241
242
243
244
245
246
247
248
 
# File 'ext/mmapscanner.c', line 237

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