Extended maintenance of Ruby versions 1.8.7 and 1.9.2 will end on July 31, 2014. Read more

In Files

  • Win32API/Win32API.c

Parent

Methods

Win32API

Public Class Methods

new(p1, p2, p3, p4) click to toggle source
 
               static VALUE
Win32API_initialize(self, dllname, proc, import, export)
    VALUE self;
    VALUE dllname;
    VALUE proc;
    VALUE import;
    VALUE export;
{
    HANDLE hproc;
    HINSTANCE hdll;
    VALUE str;
    VALUE a_import;
    VALUE *ptr;
    char *s;
    int i;
    int len;
    int ex = _T_VOID;

    SafeStringValue(dllname);
    SafeStringValue(proc);
    hdll = LoadLibrary(RSTRING(dllname)->ptr);
    if (!hdll)
        rb_raise(rb_eRuntimeError, "LoadLibrary: %s\n", RSTRING(dllname)->ptr);
    rb_iv_set(self, "__hdll__", Data_Wrap_Struct(rb_cData, 0, Win32API_FreeLibrary, (void*)hdll));
    hproc = (HANDLE)GetProcAddress(hdll, RSTRING(proc)->ptr);
    if (!hproc) {
        str = rb_str_new3(proc);
        str = rb_str_cat(str, "A", 1);
        hproc = (HANDLE)GetProcAddress(hdll, RSTRING(str)->ptr);
        if (!hproc)
            rb_raise(rb_eRuntimeError, "GetProcAddress: %s or %s\n",
                RSTRING(proc)->ptr, RSTRING(str)->ptr);
    }
    rb_iv_set(self, "__dll__", UINT2NUM((unsigned long)hdll));
    rb_iv_set(self, "__dllname__", dllname);
    rb_iv_set(self, "__proc__", UINT2NUM((unsigned long)hproc));

    a_import = rb_ary_new();
    switch (TYPE(import)) {
    case T_NIL:
        break;
    case T_ARRAY:
        ptr = RARRAY(import)->ptr;
        for (i = 0, len = RARRAY(import)->len; i < len; i++) {
            SafeStringValue(ptr[i]);
            switch (*(char *)RSTRING(ptr[i])->ptr) {
            case 'N': case 'n': case 'L': case 'l':
                rb_ary_push(a_import, INT2FIX(_T_NUMBER));
                break;
            case 'P': case 'p':
                rb_ary_push(a_import, INT2FIX(_T_POINTER));
                break;
            case 'I': case 'i':
                rb_ary_push(a_import, INT2FIX(_T_INTEGER));
                break;
            }
        }
        break;
    default:
        SafeStringValue(import);
        s = RSTRING(import)->ptr;
        for (i = 0, len = RSTRING(import)->len; i < len; i++) {
            switch (*s++) {
            case 'N': case 'n': case 'L': case 'l':
                rb_ary_push(a_import, INT2FIX(_T_NUMBER));
                break;
            case 'P': case 'p':
                rb_ary_push(a_import, INT2FIX(_T_POINTER));
                break;
            case 'I': case 'i':
                rb_ary_push(a_import, INT2FIX(_T_INTEGER));
                break;
            }
        }
        break;
    }

    if (16 < RARRAY(a_import)->len) {
        rb_raise(rb_eRuntimeError, "too many parameters: %ld\n", RARRAY(a_import)->len);
    }

    rb_iv_set(self, "__import__", a_import);

    if (NIL_P(export)) {
        ex = _T_VOID;
    } else {
        SafeStringValue(export);
        switch (*RSTRING(export)->ptr) {
        case 'V': case 'v':
            ex = _T_VOID;
            break;
        case 'N': case 'n': case 'L': case 'l':
            ex = _T_NUMBER;
            break;
        case 'P': case 'p':
            ex = _T_POINTER;
            break;
        case 'I': case 'i':
            ex = _T_INTEGER;
            break;
        }
    }
    rb_iv_set(self, "__export__", INT2FIX(ex));

    return Qnil;
}
            

Public Instance Methods

Call(*args) click to toggle source
Alias for: call
call(*args) click to toggle source
 
               static VALUE
Win32API_Call(argc, argv, obj)
    int argc;
    VALUE *argv;
    VALUE obj;
{
    VALUE args;
    unsigned long ret;
    int i;
    struct {
        unsigned long params[16];
    } param;
#define params param.params

    VALUE obj_proc = rb_iv_get(obj, "__proc__");
    VALUE obj_import = rb_iv_get(obj, "__import__");
    VALUE obj_export = rb_iv_get(obj, "__export__");
    FARPROC ApiFunction = (FARPROC)NUM2ULONG(obj_proc);
    int items = rb_scan_args(argc, argv, "0*", &args);
    int nimport = RARRAY(obj_import)->len;


    if (items != nimport)
        rb_raise(rb_eRuntimeError, "wrong number of parameters: expected %d, got %d",
            nimport, items);

    for (i = 0; i < nimport; i++) {
        unsigned long lParam = 0;
        switch (FIX2INT(rb_ary_entry(obj_import, i))) {
            VALUE str;
        case _T_NUMBER:
        case _T_INTEGER:
        default:
            lParam = NUM2ULONG(rb_ary_entry(args, i));
            break;
        case _T_POINTER:
            str = rb_ary_entry(args, i);
            if (NIL_P(str)) {
                lParam = 0;
            } else if (FIXNUM_P(str)) {
                lParam = NUM2ULONG(str);
            } else {
                StringValue(str);
                rb_str_modify(str);
                lParam = (unsigned long)StringValuePtr(str);
            }
            break;
        }
        params[i] = lParam;
    }

    ret = ApiFunction(param);

    switch (FIX2INT(obj_export)) {
    case _T_NUMBER:
    case _T_INTEGER:
        return INT2NUM(ret);
    case _T_POINTER:
        return rb_str_new2((char *)ret);
    case _T_VOID:
    default:
        return INT2NUM(0);
    }
}
            
Also aliased as: Call

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus