win32-api 1.4.0-x86-mswin32-60 → 1.4.1-x86-mswin32-60

data/CHANGES

@@ -1,3 +1,7 @@
+= 1.4.1 - 29-May-2009
+* Callback handling improvements.
+* Updated the gemspec description.
+
 = 1.4.0 - 19-Feb-2009
 * Now compatible with Ruby 1.9.x.
 * In what will go down as, "It seemed like a good idea at the time", I have

data/README

@@ -92,7 +92,7 @@
    http://www.rubyforge.org/projects/win32utils.
 
 = Copyright
-   (C) 2003-2008 Daniel J. Berger
+   (C) 2003-2009 Daniel J. Berger
    All Rights Reserved
 
 = License

data/ext/win32/api.c

@@ -17,7 +17,7 @@
 #endif
 
 #define MAX_BUF 1024
-#define WINDOWS_API_VERSION "1.4.0"
+#define WINDOWS_API_VERSION "1.4.1"
 
 #define _T_VOID     0
 #define _T_LONG     1
@@ -126,6 +126,7 @@ char* StringError(DWORD dwError){
 static VALUE callback_init(int argc, VALUE* argv, VALUE self)
 {
    extern void *CallbackTable[];
+   void *find_callback(VALUE,int);
    VALUE v_proto, v_return, v_proc;
    int i;
 
@@ -160,7 +161,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)CallbackTable[RSTRING_LEN(v_proto)]));
+   rb_iv_set(self, "@address", ULONG2NUM((LPARAM)find_callback(self,RSTRING_LEN(v_proto))));
    ActiveCallback = self;
 
    return self;
@@ -506,7 +507,7 @@ typedef struct {
 } CALLPARAM;
 
 
-DWORD CallbackFunction(CALLPARAM param)
+DWORD CallbackFunction(CALLPARAM param,VALUE callback)
 {
     VALUE v_proto, v_return, v_proc, v_retval;
     VALUE argv[20];
@@ -514,14 +515,14 @@ DWORD CallbackFunction(CALLPARAM param)
     char *a_proto;
     char *a_return;
 
-    if(!NIL_P(ActiveCallback)){
-        v_proto = rb_iv_get(ActiveCallback, "@prototype");
+    if(callback && !NIL_P(callback)){
+        v_proto = rb_iv_get(callback, "@prototype");
         a_proto = RSTRING_PTR(v_proto);
 
-        v_return = rb_iv_get(ActiveCallback, "@return_type");
+        v_return = rb_iv_get(callback, "@return_type");
         a_return = RSTRING_PTR(v_return);
 
-        v_proc = rb_iv_get(ActiveCallback, "@function");
+        v_proc = rb_iv_get(callback, "@function");
         argc = RSTRING_LEN(v_proto);
 
         for(i=0; i < RSTRING_LEN(v_proto); i++){
@@ -583,85 +584,124 @@ DWORD CallbackFunction(CALLPARAM param)
     return 0;
 }
 
-DWORD CALLBACK CallbackFunction0() {
-   CALLPARAM param = {0};
-   param.params[0] = 0;
-   return CallbackFunction(param);
+#define CALLBACK0(x) DWORD CALLBACK CallbackFunction0_##x() {\
+   CALLPARAM param = {0};\
+   param.params[0] = 0;\
+   return CallbackFunction(param,FuncTable[0][x]);\
 }
 
-DWORD CALLBACK CallbackFunction1(DWORD p1) {
-   CALLPARAM param = {p1};
-   return CallbackFunction(param);
+#define CALLBACK1(x) DWORD CALLBACK CallbackFunction1_##x(DWORD p1) {\
+   CALLPARAM param = {p1};\
+   return CallbackFunction(param,FuncTable[1][x]);\
 }
 
-DWORD CALLBACK CallbackFunction2(DWORD p1, DWORD p2){
-   CALLPARAM param = {p1,p2};
-   return CallbackFunction(param);
+#define CALLBACK2(x) DWORD CALLBACK CallbackFunction2_##x(\
+DWORD p1, DWORD p2){\
+   CALLPARAM param = {p1,p2};\
+   return CallbackFunction(param,FuncTable[2][x]);\
 }
 
-DWORD CALLBACK CallbackFunction3(DWORD p1, DWORD p2, DWORD p3){
-   CALLPARAM param = {p1,p2,p3};
-   return CallbackFunction(param);
+#define CALLBACK3(x) DWORD CALLBACK CallbackFunction3_##x(\
+DWORD p1, DWORD p2, DWORD p3){\
+   CALLPARAM param = {p1,p2,p3};\
+   return CallbackFunction(param,FuncTable[3][x]);\
 }
 
-DWORD CALLBACK CallbackFunction4(DWORD p1, DWORD p2, DWORD p3, DWORD p4){
-   CALLPARAM param = {p1,p2,p3,p4};
-   return CallbackFunction(param);
+#define CALLBACK4(x) DWORD CALLBACK CallbackFunction4_##x(\
+DWORD p1, DWORD p2, DWORD p3, DWORD p4){\
+   CALLPARAM param = {p1,p2,p3,p4};\
+   return CallbackFunction(param,FuncTable[4][x]);\
 }
 
-DWORD CALLBACK CallbackFunction5(
-   DWORD p1, DWORD p2, DWORD p3, DWORD p4, DWORD p5
-)
-{
-   CALLPARAM param = {p1,p2,p3,p4,p5};
-   return CallbackFunction(param);
+#define CALLBACK5(x) DWORD CALLBACK CallbackFunction5_##x(\
+   DWORD p1, DWORD p2, DWORD p3, DWORD p4, DWORD p5\
+){\
+   CALLPARAM param = {p1,p2,p3,p4,p5};\
+   return CallbackFunction(param,FuncTable[5][x]);\
 }
 
-DWORD CALLBACK CallbackFunction6(
-   DWORD p1, DWORD p2, DWORD p3, DWORD p4, DWORD p5, DWORD p6
-)
-{
-   CALLPARAM param = {p1,p2,p3,p4,p5,p6};
-   return CallbackFunction(param);
+#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};\
+   return CallbackFunction(param,FuncTable[6][x]);\
 }
 
-DWORD CALLBACK CallbackFunction7(
-   DWORD p1, DWORD p2, DWORD p3, DWORD p4, DWORD p5, DWORD p6, DWORD p7)
-{
-   CALLPARAM param = {p1,p2,p3,p4,p5,p6,p7};
-   return CallbackFunction(param);
+#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};\
+   return CallbackFunction(param,FuncTable[7][x]);\
 }
 
-DWORD CALLBACK CallbackFunction8(
-   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};
-   return CallbackFunction(param);
+#define CALLBACK8(x) DWORD CALLBACK CallbackFunction8_##x(\
+   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};\
+   return CallbackFunction(param,FuncTable[8][x]);\
 }
 
-DWORD CALLBACK CallbackFunction9(
-   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};
-   return CallbackFunction(param);
+#define CALLBACK9(x) DWORD CALLBACK CallbackFunction9_##x(\
+   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};\
+   return CallbackFunction(param,FuncTable[9][x]);\
 }
 
-void *CallbackTable[] = {
-   CallbackFunction0,
-   CallbackFunction1,
-   CallbackFunction2,
-   CallbackFunction3,
-   CallbackFunction4,
-   CallbackFunction5,
-   CallbackFunction6,
-   CallbackFunction7,
-   CallbackFunction8,
-   CallbackFunction9
-};
+#define DEFCALLBACK(x) CALLBACK##x(0)\
+CALLBACK##x(1)\
+CALLBACK##x(2)\
+CALLBACK##x(3)\
+CALLBACK##x(4)\
+CALLBACK##x(5)\
+CALLBACK##x(6)\
+CALLBACK##x(7)\
+CALLBACK##x(8)\
+CALLBACK##x(9)
+
+#define CF(x,y)	CallbackFunction##x##_##y
+
+static VALUE FuncTable[10][10];
+
+DEFCALLBACK(0)
+DEFCALLBACK(1)
+DEFCALLBACK(2)
+DEFCALLBACK(3)
+DEFCALLBACK(4)
+DEFCALLBACK(5)
+DEFCALLBACK(6)
+DEFCALLBACK(7)
+DEFCALLBACK(8)
+DEFCALLBACK(9)
+
+void *CallbackTable[10][10] = {
+{CF(0,0),CF(0,1),CF(0,2),CF(0,3),CF(0,4),CF(0,5),CF(0,6),CF(0,7),CF(0,8),CF(0,9)},
+{CF(1,0),CF(1,1),CF(1,2),CF(1,3),CF(1,4),CF(1,5),CF(1,6),CF(1,7),CF(1,8),CF(1,9)},
+{CF(2,0),CF(2,1),CF(2,2),CF(2,3),CF(2,4),CF(2,5),CF(2,6),CF(2,7),CF(2,8),CF(2,9)},
+{CF(3,0),CF(3,1),CF(3,2),CF(3,3),CF(3,4),CF(3,5),CF(3,6),CF(3,7),CF(3,8),CF(3,9)},
+{CF(4,0),CF(4,1),CF(4,2),CF(4,3),CF(4,4),CF(4,5),CF(4,6),CF(4,7),CF(4,8),CF(4,9)},
+{CF(5,0),CF(5,1),CF(5,2),CF(5,3),CF(5,4),CF(5,5),CF(5,6),CF(5,7),CF(5,8),CF(5,9)},
+{CF(6,0),CF(6,1),CF(6,2),CF(6,3),CF(6,4),CF(6,5),CF(6,6),CF(6,7),CF(6,8),CF(6,9)},
+{CF(7,0),CF(7,1),CF(7,2),CF(7,3),CF(7,4),CF(7,5),CF(7,6),CF(7,7),CF(7,8),CF(7,9)},
+{CF(8,0),CF(8,1),CF(8,2),CF(8,3),CF(8,4),CF(8,5),CF(8,6),CF(8,7),CF(8,8),CF(8,9)},
+{CF(9,0),CF(9,1),CF(9,2),CF(9,3),CF(9,4),CF(9,5),CF(9,6),CF(9,7),CF(9,8),CF(9,9)}};
+
+
+void *find_callback(VALUE obj,int len)
+{
+   int i;
+   for(i=0;i<10;i++)
+   {
+       if(FuncTable[len][i]==0)
+          break;
+   }
+   if(i>=10)
+      rb_raise(cAPIError,"too many callbacks are defined.");
+   FuncTable[len][i] = obj;
+   return CallbackTable[len][i];
+}
 
 /*
  * call-seq:
@@ -739,7 +779,7 @@ static VALUE api_call(int argc, VALUE* argv, VALUE self){
             case _T_CALLBACK:
                ActiveCallback = v_arg;
                v_proto = rb_iv_get(ActiveCallback, "@prototype");
-               param.params[i] = (LPARAM)CallbackTable[RSTRING_LEN(v_proto)];
+               param.params[i] = (LPARAM)NUM2ULONG(rb_iv_get(ActiveCallback, "@address"));;
                break;
             case _T_STRING:
                param.params[i] = (unsigned long)RSTRING_PTR(v_arg);
@@ -761,7 +801,7 @@ static VALUE api_call(int argc, VALUE* argv, VALUE self){
          v_return = INT2NUM(return_value);
          break;
       case _T_LONG:
-         v_return = LONG2NUM(return_value);
+         v_return = ULONG2NUM(return_value);
          break;
       case _T_VOID:
          v_return = Qnil;
@@ -881,6 +921,6 @@ void Init_api(){
 
    /* Constants */
 
-   /* 1.2.2: The version of this library, returned as a String */
+   /* 1.4.1: The version of this library, returned as a String */
    rb_define_const(cAPI, "VERSION", rb_str_new2(WINDOWS_API_VERSION));
 }

data/test/test_win32_api.rb

@@ -20,7 +20,7 @@ class TC_Win32_API < Test::Unit::TestCase
    end
 
    def test_version
-      assert_equal('1.4.0', API::VERSION)
+      assert_equal('1.4.1', API::VERSION)
    end
 
    def test_constructor_basic

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: win32-api
 version: !ruby/object:Gem::Version 
-  version: 1.4.0
+  version: 1.4.1
 platform: x86-mswin32-60
 authors: 
 - Daniel J. Berger
@@ -10,11 +10,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-19 00:00:00 -07:00
+date: 2009-05-29 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
-description: A superior replacement for Win32API
+description: "         The Win32::API library is meant as a replacement for the Win32API\n         library that ships as part of the standard library. It contains several\n         advantages over Win32API, including callback support, raw function\n         pointers, an additional string type, and more.\n"
 email: djberg96@gmail.com
 executables: []
 
@@ -36,6 +36,8 @@ files:
 - ext/win32/api.c
 has_rdoc: true
 homepage: http://www.rubyforge.org/projects/win32utils
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -56,9 +58,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: win32utils
-rubygems_version: 1.3.1
+rubygems_version: 1.3.3
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A superior replacement for Win32API
 test_files: 
 - test/test_win32_api.rb