win32-api 1.4.5 → 1.9.2

data/appveyor.yml

@@ -0,0 +1,46 @@
+version: '{build}'
+
+init:
+  # use a minimal path
+  - set PATH=C:\ruby%ruby_version%\bin;C:\Program Files\7-Zip;C:\Program Files\AppVeyor\BuildAgent;C:\Program Files\Git\cmd;C:\Windows\system32
+  # Load ruby trunk build
+  - if %ruby_version%==_trunk (
+      appveyor DownloadFile https://ci.appveyor.com/api/projects/MSP-Greg/ruby-loco/artifacts/ruby_trunk.7z -FileName C:\ruby_trunk.7z &
+      7z x C:\ruby_trunk.7z -oC:\ruby_trunk
+    )
+
+platform: x64
+
+install:
+  - ruby --version
+  - gem --version
+  # Assume we can use the version of bundler that Appveyor has packaged with each ruby version
+  - bundle install
+
+build: off
+
+test_script:
+  - rake gem:binary
+  - rake -rdevkit test:all
+
+environment:
+  matrix:
+    - ruby_version: _trunk
+    - ruby_version: 26-x64
+    - ruby_version: 26
+    - ruby_version: 25-x64
+    - ruby_version: 25
+    - ruby_version: 24-x64
+    - ruby_version: 24
+    - ruby_version: 23-x64
+    - ruby_version: 23
+    - ruby_version: 22-x64
+    - ruby_version: 22
+    - ruby_version: 21-x64
+    - ruby_version: 21
+    - ruby_version: 200-x64
+    - ruby_version: 200
+
+matrix:
+  allow_failures:
+    - ruby_version: _trunk

data/build-gem.bat

@@ -0,0 +1,3 @@
+git clone https://github.com/cosmo0920/win32-api win32-api
+cd win32-api
+rake -rdevkit gem:binary

data/ext/extconf.rb

@@ -6,6 +6,10 @@
 ##########################################################################
 require 'mkmf'
 
+if RbConfig::CONFIG['host_os'] =~ /mingw/
+  $CFLAGS << ' -fno-omit-frame-pointer'
+end
+
 have_func('strncpy_s')
 
 create_makefile('win32/api', 'win32')

data/ext/win32/api.c

@@ -16,8 +16,34 @@
 #define RARRAY_LEN(a) (RARRAY(a)->len)
 #endif
 
+/* Use Ruby defined macro definitions. */
+#if !defined(NUM2SIZET) && !defined(NUM2SSIZET)
+# if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG
+#  define NUM2SIZET(x) ((size_t)NUM2ULL(x))
+#  define NUM2SSIZET(x) ((ssize_t)NUM2LL(x))
+# else
+#  define NUM2SIZET(x) NUM2ULONG(x)
+#  define NUM2SSIZET(x) NUM2LONG(x)
+# endif
+#endif
+
+/* Use Ruby defined macro definitions. */
+#if !defined(SIZET2NUM) && !defined(SSIZET2NUM)
+# if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
+#  define SIZET2NUM(v) ULL2NUM(v)
+#  define SSIZET2NUM(v) LL2NUM(v)
+# elif SIZEOF_SIZE_T == SIZEOF_LONG
+#  define SIZET2NUM(v) ULONG2NUM(v)
+#  define SSIZET2NUM(v) LONG2NUM(v)
+# else
+#  define SIZET2NUM(v) UINT2NUM(v)
+#  define SSIZET2NUM(v) INT2NUM(v)
+# endif
+#endif
+
+
 #define MAX_BUF 1024
-#define WINDOWS_API_VERSION "1.4.5"
+#define WINDOWS_API_VERSION "1.9.2"
 
 #define _T_VOID     0
 #define _T_LONG     1
@@ -46,6 +72,7 @@ static void api_free(Win32API* ptr){
 
 static VALUE api_allocate(VALUE klass){
    Win32API* ptr = malloc(sizeof(Win32API));
+   memset(ptr, 0, sizeof(*ptr));
    return Data_Wrap_Struct(klass, 0, api_free, ptr);
 }
 
@@ -56,61 +83,64 @@ static VALUE api_allocate(VALUE klass){
  * Internal use only.
  */
 char* StringError(DWORD dwError){
-   LPVOID lpMsgBuf;
-   static char buf[MAX_PATH];
-   DWORD dwLen;
-
-   // Assume ASCII error messages from the Windows API
-   dwLen = FormatMessageA(
+  LPVOID lpMsgBuf;
+  static char buf[MAX_PATH];
+  DWORD dwLen, dwLastError;
+
+  // Assume ASCII (English) error messages from the Windows API
+  dwLen = FormatMessageA(
+    FORMAT_MESSAGE_ALLOCATE_BUFFER |
+    FORMAT_MESSAGE_FROM_SYSTEM |
+    FORMAT_MESSAGE_IGNORE_INSERTS,
+    NULL,
+    dwError,
+    MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
+    (LPSTR)&lpMsgBuf,
+    0,
+    NULL
+  );
+
+  dwLastError = GetLastError();
+
+  /* It appears that Windows doesn't necessarily ship with the DLL
+   * required to always use English error messages. Check for error
+   * ERROR_MUI_FILE_NOT_FOUND (15100) or ERROR_RESOURCE_LANG_NOT_FOUND (1815)
+   * and try again if necessary.
+   */
+  if(!dwLen && (dwLastError == 15100 || dwLastError == 1815)){
+    dwLen = FormatMessageA(
       FORMAT_MESSAGE_ALLOCATE_BUFFER |
       FORMAT_MESSAGE_FROM_SYSTEM |
       FORMAT_MESSAGE_IGNORE_INSERTS,
       NULL,
       dwError,
-      MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
+      0,
       (LPSTR)&lpMsgBuf,
       0,
       NULL
-   );
+    );
+  }
 
-   /* It appears that Windows doesn't necessarily ship with the DLL
-    * required to always use English error messages. Check for error
-    * ERROR_MUI_FILE_NOT_FOUND (15100), and try again if necessary.
-    */
-   if(!dwLen && GetLastError() == 15100){
-      dwLen = FormatMessageA(
-         FORMAT_MESSAGE_ALLOCATE_BUFFER |
-         FORMAT_MESSAGE_FROM_SYSTEM |
-         FORMAT_MESSAGE_IGNORE_INSERTS,
-         NULL,
-         dwError,
-         0,
-         (LPSTR)&lpMsgBuf,
-         0,
-         NULL
-      );
-   }
+  if(!dwLen){
+    rb_raise(
+      cAPIError,
+      "Attempt to format message failed (error = '%lu')",
+      GetLastError()
+    );
+  }
 
-   if(!dwLen){
-      rb_raise(
-         cAPIError,
-         "Attempt to format message failed (error = '%d')",
-         GetLastError()
-      );
-   }
-
-   memset(buf, 0, MAX_PATH);
+  memset(buf, 0, MAX_PATH);
 
-   /* remove \r\n */
+  // Remove \r\n at end of string.
 #ifdef HAVE_STRNCPY_S
-   strncpy_s(buf, MAX_PATH, lpMsgBuf, dwLen - 2);
+  strncpy_s(buf, MAX_PATH, lpMsgBuf, dwLen - 2);
 #else
-   strncpy(buf, lpMsgBuf, dwLen - 2);
+  strncpy(buf, lpMsgBuf, dwLen - 2);
 #endif
 
-   LocalFree(lpMsgBuf);
+  LocalFree(lpMsgBuf);
 
-   return buf;
+  return buf;
 }
 
 /*
@@ -170,7 +200,7 @@ static VALUE callback_init(int argc, VALUE* argv, VALUE self)
       v_return = rb_str_new2("L");
    }
    else{
-      switch(*(char*)RSTRING_PTR(v_return)){
+      switch(*(TCHAR*)RSTRING_PTR(v_return)){
          case 'I': case 'L': case 'P': case 'V': case 'S':
             break;
          default:
@@ -183,7 +213,7 @@ static VALUE callback_init(int argc, VALUE* argv, VALUE self)
    rb_iv_set(self, "@function", v_proc);
    rb_iv_set(self, "@prototype", v_proto);
    rb_iv_set(self, "@return_type", v_return);
-   rb_iv_set(self, "@address", ULONG2NUM((LPARAM)find_callback(self,RSTRING_LEN(v_proto))));
+   rb_iv_set(self, "@address", SIZET2NUM((LPARAM)find_callback(self,RSTRING_LEN(v_proto))));
    ActiveCallback = self;
 
    return self;
@@ -234,8 +264,8 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
    FARPROC fProc;
    Win32API* ptr;
    int i;
-   char* first  = "A";
-   char* second = "W";
+   const char* first  = "A";
+   const char* second = "W";
    VALUE v_proc, v_proto, v_return, v_dll;
 
    rb_scan_args(argc, argv, "13", &v_proc, &v_proto, &v_return, &v_dll);
@@ -253,8 +283,8 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
    }
 
    // Set an arbitrary limit of 20 parameters
-   if(20 < RARRAY_LEN(v_proto))
-      rb_raise(rb_eArgError, "too many parameters: %d\n", RARRAY_LEN(v_proto));
+   if(RARRAY_LEN(v_proto) > 20)
+      rb_raise(rb_eArgError, "too many parameters: %ld", RARRAY_LEN(v_proto));
 
    // Set the default dll to 'kernel32'
    if(NIL_P(v_dll))
@@ -264,8 +294,10 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
    if(NIL_P(v_return))
       v_return = rb_str_new2("L");
 
+#if defined TAINTING_SUPPORT
    SafeStringValue(v_dll);
    SafeStringValue(v_proc);
+#endif
 
    hLibrary = LoadLibrary(TEXT(RSTRING_PTR(v_dll)));
 
@@ -332,8 +364,10 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
    // Push the numeric prototypes onto our int array for later use.
 
    for(i = 0; i < RARRAY_LEN(v_proto); i++){
+#if defined TAINTING_SUPPORT
       SafeStringValue(RARRAY_PTR(v_proto)[i]);
-      switch(*(char*)StringValuePtr(RARRAY_PTR(v_proto)[i])){
+#endif
+      switch(*(TCHAR*)StringValuePtr(RARRAY_PTR(v_proto)[i])){
          case 'L':
             ptr->prototype[i] = _T_LONG;
             break;
@@ -367,7 +401,9 @@ static VALUE api_init(int argc, VALUE* argv, VALUE self)
       ptr->return_type = _T_VOID;
    }
    else{
+#if defined TAINTING_SUPPORT
       SafeStringValue(v_return);
+#endif
       switch(*RSTRING_PTR(v_return)){
          case 'L':
             ptr->return_type = _T_LONG;
@@ -447,18 +483,20 @@ static VALUE func_init(int argc, VALUE* argv, VALUE self){
 
    // Set an arbitrary limit of 20 parameters
    if(20 < RARRAY_LEN(v_proto))
-      rb_raise(rb_eArgError, "too many parameters: %d\n", RARRAY_LEN(v_proto));
+      rb_raise(rb_eArgError, "too many parameters: %li\n", RARRAY_LEN(v_proto));
 
    // Set the default return type to 'L' (DWORD)
    if(NIL_P(v_return))
       v_return = rb_str_new2("L");
 
-   ptr->function = (FARPROC)NUM2LONG(v_address);
+   ptr->function = (FARPROC)NUM2SIZET(v_address);
 
    // Push the numeric prototypes onto our int array for later use.
 
    for(i = 0; i < RARRAY_LEN(v_proto); i++){
+#if defined TAINTING_SUPPORT
       SafeStringValue(RARRAY_PTR(v_proto)[i]);
+#endif
       switch(*(char*)StringValuePtr(RARRAY_PTR(v_proto)[i])){
          case 'L':
             ptr->prototype[i] = _T_LONG;
@@ -493,7 +531,9 @@ static VALUE func_init(int argc, VALUE* argv, VALUE self){
       ptr->return_type = _T_VOID;
    }
    else{
+#if defined TAINTING_SUPPORT
       SafeStringValue(v_return);
+#endif
       switch(*RSTRING_PTR(v_return)){
          case 'L':
             ptr->return_type = _T_LONG;
@@ -525,134 +565,132 @@ static VALUE func_init(int argc, VALUE* argv, VALUE self){
 }
 
 typedef struct {
-   DWORD params[20];
+   uintptr_t params[20];
 } CALLPARAM;
 
 
-DWORD CallbackFunction(CALLPARAM param,VALUE callback)
+DWORD CallbackFunction(CALLPARAM param, VALUE callback)
 {
-    VALUE v_proto, v_return, v_proc, v_retval;
-    VALUE argv[20];
-    int i, argc;
-    char *a_proto;
-    char *a_return;
-
-    if(callback && !NIL_P(callback)){
-        v_proto = rb_iv_get(callback, "@prototype");
-        a_proto = RSTRING_PTR(v_proto);
-
-        v_return = rb_iv_get(callback, "@return_type");
-        a_return = RSTRING_PTR(v_return);
-
-        v_proc = rb_iv_get(callback, "@function");
-        argc = RSTRING_LEN(v_proto);
-
-        for(i=0; i < RSTRING_LEN(v_proto); i++){
-           argv[i] = Qnil;
-           switch(a_proto[i]){
-              case 'L':
-                 argv[i] = ULONG2NUM(param.params[i]);
-                 break;
-              case 'P':
-                 if(param.params[i])
-                    argv[i] = rb_str_new2((char *)param.params[i]);
-                 break;
-              case 'I':
-                 argv[i] = INT2NUM(param.params[i]);
-                 break;
-              default:
-                 rb_raise(cAPIProtoError, "Illegal prototype '%s'",
-                    RSTRING_PTR(a_proto[i])
-                 );
-            }
-        }
+  VALUE v_proto, v_return, v_proc, v_retval;
+  VALUE argv[20];
+  int i, argc;
+  char *a_proto;
+  char *a_return;
+
+  if(callback && !NIL_P(callback)){
+    v_proto = rb_iv_get(callback, "@prototype");
+    a_proto = RSTRING_PTR(v_proto);
+
+    v_return = rb_iv_get(callback, "@return_type");
+    a_return = RSTRING_PTR(v_return);
+
+    v_proc = rb_iv_get(callback, "@function");
+    argc = RSTRING_LEN(v_proto);
+
+    for(i=0; i < RSTRING_LEN(v_proto); i++){
+      argv[i] = Qnil;
+      switch(a_proto[i]){
+        case 'L':
+          argv[i] = SIZET2NUM(param.params[i]);
+          break;
+        case 'P':
+          if(param.params[i])
+            argv[i] = rb_str_new2((char *)param.params[i]);
+          break;
+        case 'I':
+          argv[i] = INT2NUM(param.params[i]);
+          break;
+        default:
+          rb_raise(cAPIProtoError, "Illegal prototype '%c'", a_proto[i]);
+      }
+    }
 
-        v_retval = rb_funcall2(v_proc, rb_intern("call"), argc, argv);
-
-        /* Handle true and false explicitly, as some CALLBACK functions
-         * require TRUE or FALSE to break out of loops, etc.
-         */
-        if(v_retval == Qtrue)
-           return TRUE;
-        else if(v_retval == Qfalse)
-           return FALSE;
-
-        switch (*a_return) {
-           case 'I':
-              return NUM2INT(v_retval);
-              break;
-           case 'L':
-              return NUM2ULONG(v_retval);
-              break;
-           case 'S':
-              return (unsigned long)RSTRING_PTR(v_retval);
-              break;
-           case 'P':
-              if(NIL_P(v_retval)){
-                 return 0;
-              }
-              else if(FIXNUM_P(v_retval)){
-                 return NUM2ULONG(v_retval);
-              }
-              else{
-                 StringValue(v_retval);
-                 rb_str_modify(v_retval);
-                 return (unsigned long)StringValuePtr(v_retval);
-              }
-              break;
+    v_retval = rb_funcall2(v_proc, rb_intern("call"), argc, argv);
+
+    /* Handle true and false explicitly, as some CALLBACK functions
+     * require TRUE or FALSE to break out of loops, etc.
+     */
+    if(v_retval == Qtrue)
+      return TRUE;
+    else if(v_retval == Qfalse)
+      return FALSE;
+
+    switch (*a_return) {
+      case 'I':
+        return NUM2INT(v_retval);
+        break;
+      case 'L':
+        return NUM2SIZET(v_retval);
+        break;
+      case 'S':
+        return (uintptr_t)RSTRING_PTR(v_retval);
+        break;
+      case 'P':
+        if(NIL_P(v_retval)){
+          return 0;
+        }
+        else if(FIXNUM_P(v_retval)){
+          return NUM2SIZET(v_retval);
         }
+        else{
+          StringValue(v_retval);
+          rb_str_modify(v_retval);
+          return (uintptr_t)StringValuePtr(v_retval);
+        }
+        break;
     }
+  }
 
-    return 0;
+  return 0;
 }
 
 #define CALLBACK0(x) DWORD CALLBACK CallbackFunction0_##x() {\
-   CALLPARAM param = {0};\
+   CALLPARAM param = {{0}};\
    param.params[0] = 0;\
    return CallbackFunction(param,FuncTable[0][x]);\
 }
 
 #define CALLBACK1(x) DWORD CALLBACK CallbackFunction1_##x(DWORD p1) {\
-   CALLPARAM param = {p1};\
+   CALLPARAM param = {{p1}};\
    return CallbackFunction(param,FuncTable[1][x]);\
 }
 
 #define CALLBACK2(x) DWORD CALLBACK CallbackFunction2_##x(\
 DWORD p1, DWORD p2){\
-   CALLPARAM param = {p1,p2};\
+   CALLPARAM param = {{p1,p2}};\
    return CallbackFunction(param,FuncTable[2][x]);\
 }
 
 #define CALLBACK3(x) DWORD CALLBACK CallbackFunction3_##x(\
 DWORD p1, DWORD p2, DWORD p3){\
-   CALLPARAM param = {p1,p2,p3};\
+   CALLPARAM param = {{p1,p2,p3}};\
    return CallbackFunction(param,FuncTable[3][x]);\
 }
 
 #define CALLBACK4(x) DWORD CALLBACK CallbackFunction4_##x(\
 DWORD p1, DWORD p2, DWORD p3, DWORD p4){\
-   CALLPARAM param = {p1,p2,p3,p4};\
+   CALLPARAM param = {{p1,p2,p3,p4}};\
    return CallbackFunction(param,FuncTable[4][x]);\
 }
 
 #define CALLBACK5(x) DWORD CALLBACK CallbackFunction5_##x(\
    DWORD p1, DWORD p2, DWORD p3, DWORD p4, DWORD p5\
 ){\
-   CALLPARAM param = {p1,p2,p3,p4,p5};\
+   CALLPARAM param = {{p1,p2,p3,p4,p5}};\
    return CallbackFunction(param,FuncTable[5][x]);\
 }
 
 #define CALLBACK6(x) DWORD CALLBACK CallbackFunction6_##x(\
    DWORD p1, DWORD p2, DWORD p3, DWORD p4, DWORD p5, DWORD p6\
 ){\
-   CALLPARAM param = {p1,p2,p3,p4,p5,p6};\
+   CALLPARAM param = {{p1,p2,p3,p4,p5,p6}};\
    return CallbackFunction(param,FuncTable[6][x]);\
 }
 
 #define CALLBACK7(x) DWORD CALLBACK CallbackFunction7_##x(\
    DWORD p1, DWORD p2, DWORD p3, DWORD p4, DWORD p5, DWORD p6, DWORD p7\
 ){\
-   CALLPARAM param = {p1,p2,p3,p4,p5,p6,p7};\
+   CALLPARAM param = {{p1,p2,p3,p4,p5,p6,p7}};\
    return CallbackFunction(param,FuncTable[7][x]);\
 }
 
@@ -660,7 +698,7 @@ DWORD p1, DWORD p2, DWORD p3, DWORD p4){\
    DWORD p1, DWORD p2, DWORD p3, DWORD p4,\
    DWORD p5, DWORD p6, DWORD p7, DWORD p8\
 ){\
-   CALLPARAM param = {p1,p2,p3,p4,p5,p6,p7,p8};\
+   CALLPARAM param = {{p1,p2,p3,p4,p5,p6,p7,p8}};\
    return CallbackFunction(param,FuncTable[8][x]);\
 }
 
@@ -668,7 +706,7 @@ DWORD p1, DWORD p2, DWORD p3, DWORD p4){\
    DWORD p1, DWORD p2, DWORD p3, DWORD p4, DWORD p5,\
    DWORD p6, DWORD p7, DWORD p8, DWORD p9\
 ){\
-   CALLPARAM param = {p1,p2,p3,p4,p5,p6,p7,p8,p9};\
+   CALLPARAM param = {{p1,p2,p3,p4,p5,p6,p7,p8,p9}};\
    return CallbackFunction(param,FuncTable[9][x]);\
 }
 
@@ -740,12 +778,12 @@ void *find_callback(VALUE obj,int len)
 static VALUE api_call(int argc, VALUE* argv, VALUE self){
    VALUE v_proto, v_args, v_arg, v_return;
    Win32API* ptr;
-   unsigned long return_value;
+   uintptr_t return_value;
    int i = 0;
    int len;
 
    struct{
-      unsigned long params[20];
+      uintptr_t params[20];
    } param;
 
    Data_Get_Struct(self, Win32API, ptr);
@@ -762,7 +800,7 @@ static VALUE api_call(int argc, VALUE* argv, VALUE self){
       }
       else{
          rb_raise(rb_eArgError,
-            "wrong number of parameters: expected %d, got %d",
+            "wrong number of parameters: expected %ld, got %ld",
             RARRAY_LEN(v_proto), RARRAY_LEN(v_args)
          );
       }
@@ -775,7 +813,7 @@ static VALUE api_call(int argc, VALUE* argv, VALUE self){
 
       // Convert nil to NULL.  Otherwise convert as appropriate.
       if(NIL_P(v_arg))
-         param.params[i] = (unsigned long)NULL;
+         param.params[i] = (uintptr_t)NULL;
       else if(v_arg == Qtrue)
          param.params[i] = TRUE;
       else if(v_arg == Qfalse)
@@ -783,37 +821,159 @@ static VALUE api_call(int argc, VALUE* argv, VALUE self){
       else
          switch(ptr->prototype[i]){
             case _T_LONG:
-               param.params[i] = NUM2ULONG(v_arg);
+               param.params[i] = NUM2SIZET(v_arg);
                break;
             case _T_INTEGER:
                param.params[i] = NUM2INT(v_arg);
                break;
             case _T_POINTER:
                if(FIXNUM_P(v_arg)){
-                  param.params[i] = NUM2ULONG(v_arg);
+                  param.params[i] = NUM2SIZET(v_arg);
                }
                else{
                   StringValue(v_arg);
                   rb_str_modify(v_arg);
-                  param.params[i] = (unsigned long)StringValuePtr(v_arg);
+                  param.params[i] = (uintptr_t)StringValuePtr(v_arg);
                }
                break;
             case _T_CALLBACK:
                ActiveCallback = v_arg;
-               v_proto = rb_iv_get(ActiveCallback, "@prototype");
-               param.params[i] = (LPARAM)NUM2ULONG(rb_iv_get(ActiveCallback, "@address"));;
+               param.params[i] = (LPARAM)NUM2SIZET(rb_iv_get(ActiveCallback, "@address"));;
                break;
             case _T_STRING:
-               param.params[i] = (unsigned long)RSTRING_PTR(v_arg);
+               param.params[i] = (uintptr_t)RSTRING_PTR(v_arg);
                break;
             default:
-               param.params[i] = NUM2ULONG(v_arg);
+               param.params[i] = NUM2SIZET(v_arg);
          }
    }
 
    /* Call the function, get the return value */
-   return_value = ptr->function(param);
-
+   if(strcmp(StringValuePtr(RARRAY_PTR(v_proto)[0]), "V") == 0 && len == 1)
+   {
+        return_value = ptr->function();
+   }
+   else
+   {
+        switch(len)
+        {
+        case 0:
+            return_value = ptr->function();
+            break;
+        case 1:
+            return_value = ptr->function(param.params[0]);
+            break;
+        case 2:
+            return_value = ptr->function(param.params[0], param.params[1]);
+            break;
+        case 3:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2]);
+            break;
+        case 4:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3]);
+            break;
+        case 5:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4]);
+            break;
+        case 6:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5]);
+            break;
+        case 7:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6]);
+            break;
+        case 8:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7]);
+            break;
+        case 9:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8]);
+            break;
+        case 10:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8], param.params[9]);
+            break;
+        case 11:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8], param.params[9],
+                param.params[10]);
+            break;
+        case 12:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8], param.params[9],
+                param.params[10], param.params[11]);
+            break;
+        case 13:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8], param.params[9],
+                param.params[10], param.params[11], param.params[12]);
+            break;
+        case 14:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8], param.params[9],
+                param.params[10], param.params[11], param.params[12], param.params[13]);
+            break;
+        case 15:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8], param.params[9],
+                param.params[10], param.params[11], param.params[12], param.params[13],
+                param.params[14]);
+            break;
+        case 16:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8], param.params[9],
+                param.params[10], param.params[11], param.params[12], param.params[13],
+                param.params[14], param.params[15]);
+            break;
+        case 17:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8], param.params[9],
+                param.params[10], param.params[11], param.params[12], param.params[13],
+                param.params[14], param.params[15], param.params[16]);
+            break;
+        case 18:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8], param.params[9],
+                param.params[10], param.params[11], param.params[12], param.params[13],
+                param.params[14], param.params[15], param.params[16], param.params[17]);
+            break;
+        case 19:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8], param.params[9],
+                param.params[10], param.params[11], param.params[12], param.params[13],
+                param.params[14], param.params[15], param.params[16], param.params[17],
+                param.params[18]);
+            break;
+        case 20:
+            return_value = ptr->function(param.params[0], param.params[1],
+                param.params[2], param.params[3], param.params[4], param.params[5],
+                param.params[6], param.params[7], param.params[8], param.params[9],
+                param.params[10], param.params[11], param.params[12], param.params[13],
+                param.params[14], param.params[15], param.params[16], param.params[17],
+                param.params[18], param.params[19]);
+            break;
+        default:
+            rb_raise(rb_eArgError,"number of parameters exceed 20!");
+        }
+   }
 
    /* Return the appropriate type based on the return type specified
     * in the constructor.
@@ -823,7 +983,7 @@ static VALUE api_call(int argc, VALUE* argv, VALUE self){
          v_return = INT2NUM(return_value);
          break;
       case _T_LONG:
-         v_return = ULONG2NUM(return_value);
+         v_return = SIZET2NUM(return_value);
          break;
       case _T_VOID:
          v_return = Qnil;
@@ -943,6 +1103,6 @@ void Init_api(){
 
    /* Constants */
 
-   /* 1.4.5: The version of the win32-api library */
+   /* 1.6.0: The version of the win32-api library */
    rb_define_const(cAPI, "VERSION", rb_str_new2(WINDOWS_API_VERSION));
 }