win32-api 1.0.0-mswin32 → 1.0.1-mswin32

data/CHANGES

@@ -1,2 +1,8 @@
+= 1.0.1 - 27-Sep-2007
+* Functions declared with a void prototype no longer require an explicit nil
+  argument to fulfill the arity requirement. You can still call them with an
+  explicit nil if you wish, however.
+* Fixed the gemspec for the native build.
+
 = 1.0.0 - 14-Sep-2007
 * Initial release

data/test/tc_win32_api.rb

@@ -12,10 +12,11 @@ class TC_Win32_API < Test::Unit::TestCase
    def setup
       @buf = 0.chr * 260
       @api = API.new('GetCurrentDirectory', 'LP')
+      @gle = API.new('GetLastError', 'V', 'L')
    end
 
    def test_version
-      assert_equal('1.0.0', API::VERSION)
+      assert_equal('1.0.1', API::VERSION)
    end
  
    def test_call
@@ -24,6 +25,11 @@ class TC_Win32_API < Test::Unit::TestCase
       assert_equal(Dir.pwd.tr('/', "\\"), @buf.strip)
    end
    
+   def test_call_with_void
+      assert_nothing_raised{ @gle.call }
+      assert_nothing_raised{ @gle.call(nil) }
+   end
+   
    def test_dll_name
       assert_respond_to(@api, :dll_name)
       assert_equal('kernel32', @api.dll_name)
@@ -57,5 +63,6 @@ class TC_Win32_API < Test::Unit::TestCase
    def teardown
       @buf = nil
       @api = nil
+      @gle = nil
    end
 end

data/test/tc_win32_api_callback.rb

@@ -1,58 +1,58 @@
-############################################################################
-# tc_win32_api_callback.rb
-# 
-# Test case for the Win32::API::Callback class. You should run this as Rake
-# task, i.e. 'rake test', instead of running it directly.
-############################################################################
-require 'win32/api'
-require 'test/unit'
-include Win32
-
-class TC_Win32_API_Callback < Test::Unit::TestCase
-   def setup
-      @buffer   = 0.chr * 260
-      @api_ew   = API.new('EnumWindows', 'KP', 'L', 'user32')
-      @api_gwt  = API.new('GetWindowText', 'LPI', 'I', 'user32')
-      @callback = nil
-   end
-   
-   def test_constructor
-      assert_respond_to(API::Callback, :new)
-      assert_nothing_raised{ API::Callback.new('LP', 'I') }
-      assert_nothing_raised{ API::Callback.new('LP', 'I'){} }
-   end
-   
-   def test_prototype
-      assert_nothing_raised{ @callback = API::Callback.new('LP', 'I') }
-      assert_respond_to(@callback, :prototype)
-      assert_equal('LP', @callback.prototype)
-   end
-   
-   def test_return_value
-      assert_nothing_raised{ @callback = API::Callback.new('LP', 'I') }
-      assert_respond_to(@callback, :return_type)
-      assert_equal('I', @callback.return_type)
-   end
-   
-   def test_callback
-      assert_nothing_raised{
-         @callback = API::Callback.new('LP', 'I'){ |handle, param|
-         	buf = "\0" * 200
-            @api_gwt.call(handle, buf, 200);
-            buf.index(param).nil? ? true : false           
-         }
-      }
-      assert_nothing_raised{ @api_ew.call(@callback, 'UEDIT32') }
-   end
-   
-   def test_constructor_expected_errors
-      assert_raise(API::Callback::Error){ API::Callback.new('X') }
-   end
-   
-   def teardown
-      @buffer   = nil
-      @api_ew   = nil
-      @api_gwt  = nil
-      @callback = nil
-   end
+############################################################################
+# tc_win32_api_callback.rb
+# 
+# Test case for the Win32::API::Callback class. You should run this as Rake
+# task, i.e. 'rake test', instead of running it directly.
+############################################################################
+require 'win32/api'
+require 'test/unit'
+include Win32
+
+class TC_Win32_API_Callback < Test::Unit::TestCase
+   def setup
+      @buffer   = 0.chr * 260
+      @api_ew   = API.new('EnumWindows', 'KP', 'L', 'user32')
+      @api_gwt  = API.new('GetWindowText', 'LPI', 'I', 'user32')
+      @callback = nil
+   end
+   
+   def test_constructor
+      assert_respond_to(API::Callback, :new)
+      assert_nothing_raised{ API::Callback.new('LP', 'I') }
+      assert_nothing_raised{ API::Callback.new('LP', 'I'){} }
+   end
+   
+   def test_prototype
+      assert_nothing_raised{ @callback = API::Callback.new('LP', 'I') }
+      assert_respond_to(@callback, :prototype)
+      assert_equal('LP', @callback.prototype)
+   end
+   
+   def test_return_value
+      assert_nothing_raised{ @callback = API::Callback.new('LP', 'I') }
+      assert_respond_to(@callback, :return_type)
+      assert_equal('I', @callback.return_type)
+   end
+   
+   def test_callback
+      assert_nothing_raised{
+         @callback = API::Callback.new('LP', 'I'){ |handle, param|
+         	buf = "\0" * 200
+            @api_gwt.call(handle, buf, 200);
+            buf.index(param).nil? ? true : false           
+         }
+      }
+      assert_nothing_raised{ @api_ew.call(@callback, 'UEDIT32') }
+   end
+   
+   def test_constructor_expected_errors
+      assert_raise(API::Callback::Error){ API::Callback.new('X') }
+   end
+   
+   def teardown
+      @buffer   = nil
+      @api_ew   = nil
+      @api_gwt  = nil
+      @callback = nil
+   end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: win32-api
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2007-09-14 00:00:00 -06:00
+  version: 1.0.1
+date: 2007-09-27 00:00:00 -06:00
 summary: A superior replacement for Win32API
 require_paths: 
 - lib
@@ -29,13 +29,13 @@ post_install_message:
 authors: 
 - Daniel J. Berger
 files: 
+- lib/win32
 - lib/win32/api.so
 - test/tc_win32_api.rb
 - test/tc_win32_api_callback.rb
 - README
 - CHANGES
 - MANIFEST
-- ext/win32/api.c
 test_files: 
 - test/tc_win32_api.rb
 - test/tc_win32_api_callback.rb
@@ -45,7 +45,6 @@ extra_rdoc_files:
 - README
 - CHANGES
 - MANIFEST
-- ext/win32/api.c
 executables: []
 
 extensions: []

data/ext/win32/api.c

@@ -1,496 +0,0 @@
-#include <ruby.h>
-#include <windows.h>
-
-#define MAX_BUF 1024
-#define WINDOWS_API_VERSION "1.0.0"
-
-#define _T_VOID     0
-#define _T_LONG     1
-#define _T_POINTER  2
-#define _T_INTEGER  3
-#define _T_CALLBACK 4
-
-VALUE cAPIError, cCallbackError;
-
-/* Helper function that converts the error number returned by GetLastError()
- * into a human readable string.  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(
-      FORMAT_MESSAGE_ALLOCATE_BUFFER |
-      FORMAT_MESSAGE_FROM_SYSTEM |
-      FORMAT_MESSAGE_IGNORE_INSERTS,
-      NULL,
-      dwError,
-      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-      (LPSTR)&lpMsgBuf,
-      0,
-      NULL
-   );
-
-   if(!dwLen)
-      rb_raise(cAPIError, "Attempt to format message failed");
-
-   memset(buf, 0, MAX_PATH);
-
-   /* remove \r\n */
-#ifdef HAVE_STRNCPY_S
-   strncpy_s(buf, MAX_PATH, lpMsgBuf, dwLen - 2);
-#else
-   strncpy(buf, lpMsgBuf, dwLen - 2);
-#endif
-
-   LocalFree(lpMsgBuf);
-
-   return buf;
-}
-
-/*
- * call-seq:
- *    Win32::API::Callback.new(prototype, return='L')
- * 
- * Creates and returns a new Win32::API::Callback object. The +function+ is
- * the name of the Windows function.
- * 
- * The +prototype+ is the function prototype for the callback function. This
- * is a string. The possible valid characters are 'I' (integer), 'L' (long),
- * 'V' (void), or 'P' (pointer). Unlike API objects, API::Callback objects
- * do not have a default prototype.
- * 
- * The +return+ argument is the return type for the callback function. The
- * valid characters are the same as for the +prototype+. The default is
- * 'L' (long).
- */
-static VALUE callback_init(int argc, VALUE* argv, VALUE self)
-{
-   VALUE v_proto, v_return, v_proc;
-    
-   rb_scan_args(argc, argv, "11", &v_proto, &v_return);
-
-   if(NIL_P(v_return) || RARRAY(v_return)->len == 0)
-      v_return = rb_str_new2("L");
-
-   if(rb_block_given_p())
-      v_proc = rb_block_proc();
-   else
-      v_proc = Qnil;
-
-    rb_iv_set(self, "@function", v_proc);
-    rb_iv_set(self, "@prototype", v_proto);
-    rb_iv_set(self, "@return_type", v_return);
-    
-    return self;
-}
-
-
-typedef struct {
-    HANDLE library;
-    FARPROC function;
-    int return_type;
-    int prototype[];
-} Win32API;
-
-static void api_free(Win32API* ptr){
-   if(ptr->library)
-      FreeLibrary(ptr->library);
-
-   free(ptr);
-}
-
-static VALUE api_allocate(VALUE klass){
-   Win32API* ptr = malloc(sizeof(Win32API));
-   return Data_Wrap_Struct(klass, 0, api_free, ptr);
-}
-
-/*
- * call-seq:
- *    Win32::API.new(function, prototype='V', return='L', dll='kernel32')
- * 
- * Creates and returns a new Win32::API object. The +function+ is the name
- * of the Windows function.
- * 
- * The +prototype+ is the function prototype for +function+. This can be a
- * string or an array of characters.  The possible valid characters are 'I'
- * (integer), 'L' (long), 'V' (void), 'P' (pointer), or 'K' (callback).
- * The default is void ('V').
- * 
- * The +return+ argument is the return type for the function.  The valid
- * characters are the same as for the +prototype+.  The default is 'L' (long).
- * 
- * The +dll+ is the name of the DLL file that the function is exported from.
- * The default is 'kernel32'.
- * 
- * If the function cannot be found then an API::Error is raised (a subclass
- * of RuntimeError).
- */
-static VALUE api_init(int argc, VALUE* argv, VALUE self)
-{
-   HMODULE hLibrary;
-   FARPROC fProc;
-   Win32API* ptr;
-   int i;
-   VALUE v_proc, v_proto, v_return, v_dll, v_bool, v_name;
-   
-   rb_scan_args(argc, argv, "13", &v_proc, &v_proto, &v_return, &v_dll);
-   
-   Data_Get_Struct(self, Win32API, ptr);
-
-   /* Convert a string prototype to an array of characters */
-   if(rb_respond_to(v_proto, rb_intern("split")))
-      v_proto = rb_str_split(v_proto, "");
-
-   /* Set an arbitrary limit of 16 parameters */
-   if(16 < RARRAY(v_proto)->len)
-      rb_raise(rb_eArgError, "too many parameters: %d\n", RARRAY(v_proto)->len);
-
-   /* Convert a nil or empty prototype to 'V' (void) automatically */
-   if(NIL_P(v_proto) || RARRAY(v_proto)->len == 0){
-      v_proto = rb_ary_new();
-      rb_ary_push(v_proto, rb_str_new2("V"));
-   }
-   
-   /* Set the default dll to 'kernel32' */
-   if(NIL_P(v_dll))
-   	v_dll = rb_str_new2("kernel32");
-   	
-   /* Set the default return type to 'L' (DWORD) */
-   if(NIL_P(v_return))
-   	v_return = rb_str_new2("L");
-
-   SafeStringValue(v_dll);
-   SafeStringValue(v_proc);
-
-   hLibrary = LoadLibrary(TEXT(RSTRING(v_dll)->ptr));
-
-   /* The most likely cause of failure is a bad DLL load path */
-   if(!hLibrary){
-      rb_raise(cAPIError, "LoadLibrary() function failed for '%s': %s",
-         RSTRING(v_dll)->ptr,
-         StringError(GetLastError())
-      );
-   }
-
-   ptr->library = hLibrary;
-
-   /* Attempt to get the function.  If it fails, try again with an 'A'
-    * appended.  If that fails, try again with a 'W' appended.  If that
-    * still fails, raise an API::Error.
-    */
-   fProc = GetProcAddress(hLibrary, TEXT(RSTRING(v_proc)->ptr));
-
-   if(!fProc){
-      VALUE v_ascii = rb_str_new3(v_proc);
-      v_ascii = rb_str_cat(v_ascii, "A", 1);
-      fProc = GetProcAddress(hLibrary, TEXT(RSTRING(v_ascii)->ptr));
-
-      if(!fProc){
-         VALUE v_unicode = rb_str_new3(v_proc);
-         v_unicode = rb_str_cat(v_unicode, "W", 1);
-         fProc = GetProcAddress(hLibrary, TEXT(RSTRING(v_unicode)->ptr));
-
-         if(!fProc){
-            rb_raise(
-               cAPIError,
-               "GetProcAddress() failed for '%s', '%s' and '%s': %s",
-               RSTRING(v_proc)->ptr,
-               RSTRING(v_ascii)->ptr,
-               RSTRING(v_unicode)->ptr,
-               StringError(GetLastError())
-            );
-         }
-      }
-   }
-
-   ptr->function = fProc;
-
-   /* Push the numeric prototypes onto our int array for later use. */
-   for(i = 0; i < RARRAY(v_proto)->len; i++){
-      SafeStringValue(RARRAY(v_proto)->ptr[i]);
-      switch(*(char*)StringValuePtr(RARRAY(v_proto)->ptr[i])){
-         case 'L':
-            ptr->prototype[i] = _T_LONG;
-            break;
-         case 'P':
-            ptr->prototype[i] = _T_POINTER;
-            break;
-         case 'I': case 'B':
-            ptr->prototype[i] = _T_INTEGER;
-            break;
-         case 'V':
-            ptr->prototype[i] = _T_VOID;
-            break;
-         case 'K':
-            ptr->prototype[i] = _T_CALLBACK;
-            break;
-         default:
-            rb_raise(cAPIError, "Illegal prototype '%s'", RARRAY(v_proto)->ptr[i]);
-      }
-   }
-
-   /* Store the return type for later use.  Automatically convert empty
-    * strings or nil to type void.
-    */
-   if(NIL_P(v_return) || RSTRING(v_return)->len == 0){
-      v_return = rb_str_new2("V");
-      ptr->return_type = _T_VOID;
-   }
-   else{
-      SafeStringValue(v_return);
-      switch(*RSTRING(v_return)->ptr){
-         case 'L':
-            ptr->return_type = _T_LONG;
-            break;
-         case 'P':
-            ptr->return_type = _T_POINTER;
-            break;
-         case 'I': case 'B':
-            ptr->return_type = _T_INTEGER;
-            break;
-         case 'V':
-            ptr->return_type = _T_VOID;
-            break;
-         default:
-            rb_raise(cAPIError, "Illegal prototype '%s'", RARRAY(v_proto)->ptr[i]);
-      }
-   }
-
-   rb_iv_set(self, "@dll_name", v_dll);
-   rb_iv_set(self, "@function_name", v_proc);
-   rb_iv_set(self, "@prototype", v_proto);
-   rb_iv_set(self, "@return_type", v_return);
-
-   return self;
-}
-
-typedef struct {
-   DWORD params[1];
-} PARAM;
-
-static VALUE ActiveCallback; 
-
-DWORD CallbackFunction(PARAM param)
-{
-    VALUE v_proto, v_return, v_proc, v_retval;
-    VALUE argv[16];
-    int i, argc;
-    char *a_proto;
-    char *a_return;
-    
-    if(!NIL_P(ActiveCallback)){
-        v_proto = rb_iv_get(ActiveCallback, "@prototype");
-        a_proto = RSTRING(v_proto)->ptr;
-        
-        v_return = rb_iv_get(ActiveCallback, "@return_type");
-        a_return = RSTRING(v_return)->ptr;
-        
-        v_proc = rb_iv_get(ActiveCallback, "@function");
-        argc = RSTRING(v_proto)->len;
-        
-        for(i=0; i < RSTRING(v_proto)->len; 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(cCallbackError, "Illegal prototype '%s'", 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 '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;
-        }        
-    }
-    
-    return 0;
-}
-
-/*
- * call-seq:
- *    Win32::API#call(arg1, arg2, ...)
- * 
- * Calls the function pointer with the given arguments (if any). Note that,
- * while this method will catch some prototype mismatches (raising a TypeError
- * in the process), it is not fulproof.  It is ultimately your job to make
- * sure the arguments match the +prototype+ specified in the constructor.
- * 
- * For convenience, nil is converted to NULL, true is converted to TRUE (1)
- * and false is converted to FALSE (0).
- */
-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;
-   int i = 0;
-
-   struct{
-      unsigned long params[16];
-   } param;
-
-   Data_Get_Struct(self, Win32API, ptr);
-
-   rb_scan_args(argc, argv, "0*", &v_args);
-
-   v_proto = rb_iv_get(self, "@prototype");
-
-   if(RARRAY(v_proto)->len != RARRAY(v_args)->len)
-      rb_raise(rb_eArgError, "wrong number of parameters: expected %d, got %d",
-         RARRAY(v_proto)->len, RARRAY(v_args)->len
-      );
-
-   for(i = 0; i < RARRAY(v_proto)->len; i++){
-      v_arg = RARRAY(v_args)->ptr[i];
-
-      /* Convert nil to NULL.  Otherwise convert as appropriate. */
-      if(NIL_P(v_arg))
-         param.params[i] = (unsigned long)NULL;
-      else if(v_arg == Qtrue)
-         param.params[i] = TRUE;
-      else if(v_arg == Qfalse)
-         param.params[i] = FALSE;
-      else
-         switch(ptr->prototype[i]){
-            case _T_LONG:
-               param.params[i] = NUM2ULONG(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);
-               else
-                  param.params[i] = (unsigned long)StringValuePtr(v_arg);
-               break;
-            case _T_CALLBACK:
-               ActiveCallback = v_arg;
-               param.params[i] = (LPARAM)CallbackFunction;	
-               break;
-            default:
-               param.params[i] = NUM2ULONG(v_arg);
-         }
-   }
-
-   /* Call the function, get the return value */
-   return_value = ptr->function(param);
-
-   /* Return the appropriate type based on the return type specified
-    * in the constructor.
-    */
-   switch(ptr->return_type){
-      case _T_INTEGER:
-         v_return = INT2NUM(return_value);
-         break;
-      case _T_LONG:
-         v_return = LONG2NUM(return_value);
-         break;
-      case _T_VOID:
-         v_return = Qnil;
-         break;
-      case _T_POINTER:
-         v_return = rb_str_new2((TCHAR*)return_value);
-         break;
-      default:
-         v_return = INT2NUM(0);
-   }
-
-   return v_return;
-}
-
-/* 
- * Wraps the Windows API functions in a Ruby interface.
- */
-void Init_api(){
-   VALUE mWin32, cAPI, cCallback;
-   
-   /* Modules and Classes */
-   
-   /* The Win32 module serves as a namespace only */
-   mWin32 = rb_define_module("Win32");
-   
-   /* The API class encapsulates a function pointer to Windows API function */
-   cAPI = rb_define_class_under(mWin32, "API", rb_cObject);
-   
-   /* The API::Callback class encapsulates a Windows CALLBACK function */ 
-   cCallback = rb_define_class_under(cAPI, "Callback", rb_cObject);
-   
-   /* The API::Error class is raised if the constructor fails */
-   cAPIError = rb_define_class_under(cAPI, "Error", rb_eRuntimeError);
-
-   /* The API::Callback::Error class is raised if the constructor fails */
-   cCallbackError = rb_define_class_under(cCallback, "Error", rb_eRuntimeError);
-
-   /* Miscellaneous */
-   rb_define_alloc_func(cAPI, api_allocate);
-   
-   /* Win32::API Instance Methods */
-   rb_define_method(cAPI, "initialize", api_init, -1);
-   rb_define_method(cAPI, "call", api_call, -1);
-
-   rb_define_method(cCallback, "initialize", callback_init, -1);
-   
-   /* The name of the DLL that exports the API function */
-   rb_define_attr(cAPI, "dll_name", 1, 0);
-   
-   /* The name of the function */
-   rb_define_attr(cAPI, "function_name", 1, 0);
-   
-   /* The prototype, returned as an array of characters */
-   rb_define_attr(cAPI, "prototype", 1, 0);
-   
-   /* The return type, returned as a single character, P, L, I, V or B */
-   rb_define_attr(cAPI, "return_type", 1, 0);
-   
-   /* Win32::API::Callback Instance Methods */
-   
-   /* The prototype, returned as an array of characters */
-   rb_define_attr(cCallback, "prototype", 1, 0);
-      
-   /* The return type, returned as a single character, P, L, I, V or B */
-   rb_define_attr(cCallback, "return_type", 1, 0);
- 
-   /* Constants */
-   
-   /* 1.0.0: The version of this library, returned as a String */
-   rb_define_const(cAPI, "VERSION", rb_str_new2(WINDOWS_API_VERSION));
-}