Class: Peepmem::Pointer

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

Instance Method Summary collapse

Instance Method Details

#+(integer) ⇒ Peepmem::Pointer

Returns a pointer which shifts to upper address.

Examples:

handle = Peepmem.open(7658)
pointer = handle[0x00400000]
pointer + 0x10 # => #<Peepmem::Pointer:0x00000000400010 PID=7658>



373
374
375
376
377
378
379
380
381
 
# File 'ext/peepmem/peepmem.c', line 373

static VALUE peepmem_pointer_add(VALUE lhs, VALUE rhs)
{
    peepmem_pointer_t *ptr = DATA_PTR(lhs);
    VALUE argv[2];

    argv[0] = ptr->handle->self;
    argv[1] = SIZET2NUM(ptr->address + NUM2SSIZET(rhs));
    return rb_class_new_instance(2, argv, cPointer);
}

#-(integer) ⇒ Peepmem::Pointer

Returns a pointer which shifts to lower address.

Examples:

handle = Peepmem.open(7658)
pointer = handle[0x00400000]
pointer - 0x10 # => #<Peepmem::Pointer:0x000000003ffff0 PID=7658>



396
397
398
399
400
401
402
403
404
 
# File 'ext/peepmem/peepmem.c', line 396

static VALUE peepmem_pointer_sub(VALUE lhs, VALUE rhs)
{
    peepmem_pointer_t *ptr = DATA_PTR(lhs);
    VALUE argv[2];

    argv[0] = ptr->handle->self;
    argv[1] = SIZET2NUM(ptr->address - NUM2SSIZET(rhs));
    return rb_class_new_instance(2, argv, cPointer);
}

#[](format) ⇒ Object

Reads memory according to the format string. The format string consists of one or more directives separated by spaces. A directive consists of (optional) count, data type and (optional) data length. If a format string conststs of one directive without count, it returns an object. Otherwise, it returns an array.

Directive    | Returns           | Meaning
-----------------------------------------------------------------
   d1        | Integer           | 8-bit signed integer
   d2        | Integer           | 16-bit signed integer
   d4        | Integer           | 32-bit signed integer
   d8        | Integer           | 64-bit signed integer
   dL        | Integer           | signed integer whose length is same with long
   dP        | Integer           | signed integer whose length is same with poiner
   u1        | Integer           | 8-bit unsigned integer
   u2        | Integer           | 16-bit unsigned integer
   u4        | Integer           | 32-bit unsigned integer
   u8        | Integer           | 64-bit unsigned integer
   uL        | Integer           | unsigned integer whose length is same with long
   uP        | Integer           | unsigned integer whose length is same with pointer
   f4        | Double            | 32-bit floating point number (float)
   f8        | Double            | 64-bit floating point number (double)
   s         | String            | null-terminated string
   s(number) | String            | string whose length is specified by (number)
   w         | String            | null-terminated string, UTF16-LE encoding
   w(number) | String            | string whose length is specified by (number), UTF16-LE encoding
   p         | Peepmem::Pointer  | pointer
   >         |                   | skip one byte
   >(number) |                   | skip bytes specified by (number)

Examples:

pointer = Peepmem.open(7658)[0x00400000]
pointer['d4']
# => 32-bit signed integer
pointer['1d4']
# => [32-bit signed integer]
pointer['2d4']
# => [32-bit signed integer, 32-bit signed integer]
pointer['u4 u2 >2 f8'] # '>2': skip two-byte padding
# => [32-bit unsigned integer, 16-bit unsigned integer, double]



767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
 
# File 'ext/peepmem/peepmem.c', line 767

static VALUE peepmem_pointer_aref(VALUE self, VALUE format)
{
    peepmem_pointer_t *ptr = DATA_PTR(self);
    const char *fmt, *fmt_end;
    size_t address = ptr->address;
    volatile VALUE rv;
    VALUE obj;

    SafeStringValue(format);

    fmt = RSTRING_PTR(format);
    fmt_end = fmt + RSTRING_LEN(format);
    obj = read_directive(ptr->handle, &address, &fmt, fmt_end);
    if (fmt >= fmt_end) {
        if (obj == Qundef) {
            rb_raise(rb_eArgError, "wrong format");
        }
        return obj;
    }
    rv = rb_ary_new4(1, &obj);
    do {
        obj = read_directive(ptr->handle, &address, &fmt, fmt_end);
        if (RB_TYPE_P(obj, T_ARRAY)) {
            rb_ary_concat(rv, obj);
        } else if (obj != Qundef) {
            rb_ary_push(rv, obj);
        }
    } while (fmt < fmt_end);

    return rv;
}

#to_i ⇒ Integer

Returns address as a integer.

Examples:

handle = Peepmem.open(7658)
pointer = handle[0x00400000]
pointer.to_i # => 4194304



321
322
323
324
325
326
 
# File 'ext/peepmem/peepmem.c', line 321

static VALUE peepmem_pointer_to_i(VALUE self)
{
    peepmem_pointer_t *ptr = DATA_PTR(self);

    return SIZET2NUM(ptr->address);
}

#to_s ⇒ String

Returns address as a hexadecimal string.

Examples:

handle = Peepmem.open(7658)
pointer = handle[0x00400000]
pointer.to_s # => "0x00000000400000"



341
342
343
344
345
346
 
# File 'ext/peepmem/peepmem.c', line 341

static VALUE peepmem_pointer_to_s(VALUE self)
{
    peepmem_pointer_t *ptr = DATA_PTR(self);

    return rb_sprintf("%p", (void*)ptr->address);
}