windows-pr 0.6.6 → 0.7.0

data/lib/windows/file_mapping.rb

@@ -1,7 +1,13 @@
-require 'Win32API'
+require 'windows/api'
+include Windows
 
 module Windows
    module FileMapping     
+      API.auto_namespace = 'Windows::FileMapping'
+      API.auto_constant  = true
+      API.auto_method    = true
+      API.auto_unicode   = true
+
       FILE_MAP_COPY       = 0x0001
       FILE_MAP_WRITE      = 0x0002
       FILE_MAP_READ       = 0x0004
@@ -25,35 +31,11 @@ module Windows
       SEC_COMMIT             = 0x8000000     
       SEC_NOCACHE            = 0x10000000
       
-      CreateFileMapping = Win32API.new('kernel32', 'CreateFileMapping', 'LPLLLP', 'L')
-      FlushViewOfFile   = Win32API.new('kernel32', 'FlushViewOfFile', 'PL', 'I')
-      MapViewOfFile     = Win32API.new('kernel32', 'MapViewOfFile', 'LLLLL', 'L')
-      MapViewOfFileEx   = Win32API.new('kernel32', 'MapViewOfFileEx', 'LLLLLL', 'L')
-      OpenFileMapping   = Win32API.new('kernel32', 'OpenFileMapping', 'LIP', 'L')
-      UnmapViewOfFile   = Win32API.new('kernel32', 'UnmapViewOfFile', 'P', 'I')
-      
-      def CreateFileMapping(handle, security, protect, high, low, name)
-         CreateFileMapping.call(handle, security, protect, high, low, name)
-      end
-      
-      def FlushViewOfFile(address, bytes)
-         FlushViewOfFile.call(address, bytes) != 0
-      end
-      
-      def MapViewOfFile(handle, access, high, low, bytes)
-         MapViewOfFile.call(handle, access, high, low, bytes)
-      end
-      
-      def MapViewOfFileEx(handle, access, high, low, bytes, address)
-         MapViewOfFileEx.call(handle, access, high, low, bytes, address)
-      end
-
-      def OpenFileMapping(access, inherit, name)
-         OpenFileMapping.call(access, inherit, name)
-      end
-      
-      def UnmapViewOfFile(address)
-         UnmapViewOfFile.call(address) != 0
-      end
+      API.new('CreateFileMapping', 'LPLLLP', 'L')
+      API.new('FlushViewOfFile', 'PL', 'B')
+      API.new('MapViewOfFile', 'LLLLL', 'L')
+      API.new('MapViewOfFileEx', 'LLLLLL', 'L')
+      API.new('OpenFileMapping', 'LIP', 'L')
+      API.new('UnmapViewOfFile', 'P', 'B')
    end
-end
+end

data/lib/windows/filesystem.rb

@@ -1,16 +1,14 @@
-require 'Win32API'
+require 'windows/api'
+include Windows
 
 module Windows
    module FileSystem
-      GetDiskFreeSpace   = Win32API.new('kernel32', 'GetDiskFreeSpace', 'PPPPP', 'I')
-      GetDiskFreeSpaceEx = Win32API.new('kernel32', 'GetDiskFreeSpaceEx', 'PPPP', 'I')
+      API.auto_namespace = 'Windows::FileSystem'
+      API.auto_constant  = true
+      API.auto_method    = true
+      API.auto_unicode   = true
 
-      def GetDiskFreeSpace(path, sectors, bytes, free, total)
-         GetDiskFreeSpace.call(path, sectors, bytes, free, total) > 0
-      end
-
-      def GetDiskFreeSpaceEx(path, free_bytes, total_bytes, total_free)
-         GetDiskFreeSpaceEx.call(path, free_bytes, total_bytes, total_free) > 0
-      end
+      API.new('GetDiskFreeSpace', 'PPPPP', 'B')
+      API.new('GetDiskFreeSpaceEx', 'PPPP', 'B')
    end
 end

data/lib/windows/handle.rb

@@ -1,19 +1,23 @@
-require 'Win32API'
+require 'windows/api'
+include Windows
 
 module Windows
    module Handle
-      INVALID_HANDLE_VALUE = -1
-      
+      API.auto_namespace = 'Windows::Handle'
+      API.auto_constant  = false # Due to some functions with leading '_'. 
+      API.auto_method    = false
+      API.auto_unicode   = false
+
+      INVALID_HANDLE_VALUE           = -1
       HANDLE_FLAG_INHERIT            = 0x00000001
       HANDLE_FLAG_PROTECT_FROM_CLOSE = 0x00000002
       
-      CloseHandle          = Win32API.new('kernel32', 'CloseHandle', 'L', 'I')
-      DuplicateHandle      = Win32API.new('kernel32', 'DuplicateHandle', 'LLLLLIL', 'I')
-      GetHandleInformation = Win32API.new('kernel32', 'GetHandleInformation', 'LL', 'I')
-      SetHandleInformation = Win32API.new('kernel32', 'SetHandleInformation', 'LLL', 'I')
-
-      GetOSFHandle         = Win32API.new('msvcrt', '_get_osfhandle', 'I', 'L')
-      OpenOSFHandle        = Win32API.new('msvcrt', '_open_osfhandle', 'LI', 'I')
+      CloseHandle          = API.new('CloseHandle', 'L', 'I')
+      DuplicateHandle      = API.new('DuplicateHandle', 'LLLLLIL', 'I')
+      GetHandleInformation = API.new('GetHandleInformation', 'LL', 'I')
+      SetHandleInformation = API.new('SetHandleInformation', 'LLL', 'I')
+      GetOSFHandle         = API.new('_get_osfhandle', 'I', 'L', 'msvcrt')
+      OpenOSFHandle        = API.new('_open_osfhandle', 'LI', 'I', 'msvcrt')
             
       def CloseHandle(handle)
          CloseHandle.call(handle) != 0
@@ -39,4 +43,4 @@ module Windows
          OpenOSFHandle.call(handle, flags)
       end
    end
-end
+end

data/lib/windows/library.rb

@@ -1,7 +1,13 @@
-require 'Win32API'
+require 'windows/api'
+include Windows
 
 module Windows
    module Library
+      API.auto_namespace = 'Windows::Library'
+      API.auto_constant  = true
+      API.auto_method    = true
+      API.auto_unicode   = true
+
       DLL_PROCESS_DETACH = 0
       DLL_PROCESS_ATTACH = 1
       DLL_THREAD_ATTACH  = 2
@@ -16,72 +22,24 @@ module Windows
       LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008
       LOAD_IGNORE_CODE_AUTHZ_LEVEL  = 0x00000010
             
-      DisableThreadLibraryCalls = Win32API.new('kernel32', 'DisableThreadLibraryCalls', 'L', 'I')
-      FreeLibrary               = Win32API.new('kernel32', 'FreeLibrary', 'L', 'I')
-      FreeLibraryAndExitThread  = Win32API.new('kernel32', 'FreeLibraryAndExitThread', 'LL', 'V')     
-      GetModuleFileName         = Win32API.new('kernel32', 'GetModuleFileName', 'LPL', 'L')
-      GetModuleHandle           = Win32API.new('kernel32', 'GetModuleHandle', 'P', 'L')      
-      GetProcAddress            = Win32API.new('kernel32', 'GetProcAddress', 'LP', 'L')
-      LoadLibrary               = Win32API.new('kernel32', 'LoadLibrary', 'P', 'L')
-      LoadLibraryEx             = Win32API.new('kernel32', 'LoadLibraryEx', 'PLL', 'L')
-      LoadModule                = Win32API.new('kernel32', 'LoadModule', 'PP', 'L')
-      
+      API.new('DisableThreadLibraryCalls', 'L', 'B')
+      API.new('FreeLibrary', 'L', 'B')
+      API.new('FreeLibraryAndExitThread', 'LL', 'V')     
+      API.new('GetModuleFileName', 'LPL', 'L')
+      API.new('GetModuleHandle', 'P', 'L')      
+      API.new('GetProcAddress', 'LP', 'L')
+      API.new('LoadLibrary', 'P', 'L')
+      API.new('LoadLibraryEx', 'PLL', 'L')
+      API.new('LoadModule', 'PP', 'L')
+     
       # Windows XP or later     
       begin
-         GetDllDirectory   = Win32API.new('kernel32', 'GetDllDirectory', 'LP', 'L')
-         GetModuleHandleEx = Win32API.new('kernel32', 'GetModuleHandleEx', 'LPP', 'I')
-         SetDllDirectory   = Win32API.new('kernel32', 'SetDllDirectory', 'P', 'I')
+         API.new('GetDllDirectory', 'LP', 'L')
+         API.new('GetModuleHandleEx', 'LPP', 'I')
+         API.new('SetDllDirectory', 'P', 'I')
       rescue Exception
          # Do nothing - not supported on current platform.  It's up to you to
          # check for the existence of the constant in your code.
       end
-      
-      def DisableThreadLibraryCalls(hmodule)
-         DisableThreadLibraryCalls.call(hmodule) != 0
-      end
-      
-      def FreeLibrary(hmodule)
-         FreeLibrary.call(hmodule) != 0
-      end
-      
-      def GetModuleFileName(hmodule, file, size)
-         GetModuleFileName.call(hmodule, file, size)
-      end
-      
-      def GetModuleHandle(module_name)
-         GetModuleHandle.call(module_name)
-      end
-     
-      def GetProcAddress(hmodule, proc_name)
-         GetProcAddress.call(hmodule, proc_name)
-      end
-      
-      def LoadLibrary(library)
-         LoadLibrary.call(library)
-      end
-      
-      def LoadLibraryEx(library, file, flags)
-         LoadLibraryEx.call(library, file, flags)
-      end
-      
-      def LoadModule(hmodule, param_block)
-         LoadModule.call(hmodule, param_block)
-      end
-      
-      begin
-         def SetDllDirectory(path)
-            SetDllDirectory.call(path)
-         end
-         
-         def GetModuleHandleEx(flags, module_name, hmodule)
-            GetModuleHandleEx.call(flags, module_name, hmodule)
-         end
-         
-         def GetDllDirectory(length, buffer)
-            GetDllDirectory.call(length, buffer)
-         end
-      rescue Exception
-         # Windows XP or later
-      end
    end
-end
+end

data/lib/windows/memory.rb

@@ -1,7 +1,13 @@
-require 'Win32API'
+require 'windows/api'
+include Windows
 
 module Windows
    module Memory
+      API.auto_namespace = 'Windows::Memory'
+      API.auto_constant  = true
+      API.auto_method    = true
+      API.auto_unicode   = false
+
       GHND           = 0x0042
       GMEM_FIXED     = 0x0000
       GMEM_MOVABLE   = 0002
@@ -16,110 +22,26 @@ module Windows
       MEM_TOP_DOWN    = 0x100000
       MEM_WRITE_WATCH = 0x200000
 
-      GlobalAlloc          = Win32API.new('kernel32', 'GlobalAlloc', 'II', 'I')
-      GlobalFlags          = Win32API.new('kernel32', 'GlobalFlags', 'I', 'I')
-      GlobalFree           = Win32API.new('kernel32', 'GlobalFree', 'I', 'I')
-      GlobalHandle         = Win32API.new('kernel32', 'GlobalHandle', 'P', 'I')
-      GlobalLock           = Win32API.new('kernel32', 'GlobalLock', 'L', 'L')
-      GlobalMemoryStatus   = Win32API.new('kernel32', 'GlobalMemoryStatus', 'P', 'V')
-      GlobalMemoryStatusEx = Win32API.new('kernel32', 'GlobalMemoryStatusEx', 'P', 'V')
-      GlobalReAlloc        = Win32API.new('kernel32', 'GlobalReAlloc', 'III', 'I')
-      GlobalSize           = Win32API.new('kernel32', 'GlobalSize', 'I', 'I')
-      GlobalUnlock         = Win32API.new('kernel32', 'GlobalUnlock', 'I', 'I')
-      VirtualAlloc         = Win32API.new('kernel32', 'VirtualAlloc', 'LLLL', 'P')
-      VirtualAllocEx       = Win32API.new('kernel32', 'VirtualAllocEx', 'LLLLL', 'P')
-      VirtualFree          = Win32API.new('kernel32', 'VirtualFree', 'LLL', 'I')
-      VirtualFreeEx        = Win32API.new('kernel32', 'VirtualFreeEx', 'LLLL', 'I')
-      VirtualLock          = Win32API.new('kernel32', 'VirtualLock', 'PL', 'I')
-      VirtualProtect       = Win32API.new('kernel32', 'VirtualProtect', 'PLLP', 'I')
-      VirtualProtectEx     = Win32API.new('kernel32', 'VirtualProtectEx', 'LPLLP', 'I')
-      VirtualQuery         = Win32API.new('kernel32', 'VirtualQuery', 'LPL', 'L')
-      VirtualQueryEx       = Win32API.new('kernel32', 'VirtualQueryEx', 'LLPL', 'L')
-      VirtualUnlock        = Win32API.new('kernel32', 'VirtualUnlock', 'PL', 'I')
-      ZeroMemory           = Win32API.new('kernel32', 'RtlZeroMemory', 'PL', 'I')
-
-      def GlobalAlloc(flags, bytes)
-         GlobalAlloc.call(flags, bytes)
-      end
-
-      def GlobalFlags(handle)
-         GlobalFlags.call(handle)
-      end
-
-      def GlobalFree(handle)
-         GlobalFree.call(handle)
-      end
-
-      def GlobalHandle(handle)
-         GlobalHandle.call(handle)
-      end
-
-      def GlobalLock(handle)
-         GlobalLock.call(handle)
-      end
-
-      def GlobalMemoryStatus(buf)
-         GlobalMemoryStatus.call(buf)
-      end
-
-      def GlobalMemoryStatusEx(buf)
-         GlobalMemoryStatusEx.call(buf)
-      end
-
-      def GlobalReAlloc(handle, bytes, flags)
-         GlobalReAlloc.call(handle, bytes, flags)
-      end
-
-      def GlobalSize(handle)
-         GlobalSize.call(handle)
-      end
-
-      def GlobalUnlock(handle)
-         GlobalUnlock.call(handle)
-      end
-
-      def VirtualAlloc(address, size, alloc_type, protect)
-         VirtualAlloc.call(address, size, alloc_type, protect)
-      end
-
-      def VirtualAllocEx(handle, address, size, alloc_type, protect)
-         VirtualAllocEx.call(handle, address, size, alloc_type, protect)
-      end
-
-      def VirtualFree(address, size, free_type)
-         VirtualFree.call(address, size, free_type) != 0
-      end
-
-      def VirtualFreeEx(handle, address, size, free_type)
-         VirtualFreeEx.call(handle, address, size, free_type) != 0
-      end
-
-      def VirtualLock(address, size)
-         VirtualLock.call(address, size) != 0
-      end
-
-      def VirtualProtect(address, size, new_protect, old_protect)
-         VirtualProtect.call(address, size, new_protect, old_protect) != 0
-      end
-
-      def VirtualProtectEx(handle, address, size, new_protect, old_protect)
-         VirtualProtectEx.call(handle, address, size, new_protect, old_protect) != 0
-      end
-
-      def VirtualQuery(address, buffer, length)
-         VirtualQuery.call(address, buffer, length)
-      end
-      
-      def VirtualQueryEx(handle, address, buffer, length)
-         VirtualQueryEx.call(handle, address, buffer, length)
-      end
-
-      def VirtualUnlock(address, size)
-         VirtualUnlock.call(address, size) != 0
-      end
-
-      def ZeroMemory(dest, length)
-         ZeroMemory.call(dest, length)
-      end
+      API.new('GlobalAlloc', 'II', 'I')
+      API.new('GlobalFlags', 'I', 'I')
+      API.new('GlobalFree', 'I', 'I')
+      API.new('GlobalHandle', 'P', 'I')
+      API.new('GlobalLock', 'L', 'L')
+      API.new('GlobalMemoryStatus', 'P', 'V')
+      API.new('GlobalMemoryStatusEx', 'P', 'V')
+      API.new('GlobalReAlloc', 'III', 'I')
+      API.new('GlobalSize', 'I', 'I')
+      API.new('GlobalUnlock', 'I', 'I')
+      API.new('VirtualAlloc', 'LLLL', 'P')
+      API.new('VirtualAllocEx', 'LLLLL', 'P')
+      API.new('VirtualFree', 'LLL', 'B')
+      API.new('VirtualFreeEx', 'LLLL', 'B')
+      API.new('VirtualLock', 'PL', 'B')
+      API.new('VirtualProtect', 'PLLP', 'B')
+      API.new('VirtualProtectEx', 'LPLLP', 'B')
+      API.new('VirtualQuery', 'LPL', 'L')
+      API.new('VirtualQueryEx', 'LLPL', 'L')
+      API.new('VirtualUnlock', 'PL', 'B')
+      API.new('RtlZeroMemory', 'PL', 'L')
    end
 end

data/lib/windows/msvcrt/buffer.rb

@@ -1,22 +1,27 @@
-require 'Win32API'
+require 'windows/api'
+include Windows
 
 module Windows
    module MSVCRT
       module Buffer
-         Memcpy  = Win32API.new('msvcrt', 'memcpy', 'PLL', 'P')
-         Memccpy = Win32API.new('msvcrt', '_memccpy', 'PPIL', 'P')
-         Memchr  = Win32API.new('msvcrt', 'memchr', 'PIL', 'P')
-         Memcmp  = Win32API.new('msvcrt', 'memcmp', 'PPL', 'I')
-         Memicmp = Win32API.new('msvcrt', '_memicmp', 'PPL', 'I')
-         Memmove = Win32API.new('msvcrt', 'memmove', 'PPL', 'P')
-         Memset  = Win32API.new('msvcrt', 'memset', 'PLL', 'L')
-         Swab    = Win32API.new('msvcrt', '_swab', 'PPI', 'V')
+         API.auto_constant = false
+         API.auto_method   = false
+         API.auto_unicode  = false
+
+         Memcpy   = API.new('memcpy', 'PLL', 'P', 'msvcrt')
+         Memccpy  = API.new('_memccpy', 'PPIL', 'P', 'msvcrt')
+         Memchr   = API.new('memchr', 'PIL', 'P', 'msvcrt')
+         Memcmp   = API.new('memcmp', 'PPL', 'I', 'msvcrt')
+         Memicmp  = API.new('_memicmp', 'PPL', 'I', 'msvcrt')
+         Memmove  = API.new('memmove', 'PPL', 'P', 'msvcrt')
+         Memset   = API.new('memset', 'PLL', 'L', 'msvcrt')
+         Swab     = API.new('_swab', 'PPI', 'V', 'msvcrt')
+         
+         MemcpyPLL  = API.new('memcpy', 'PLL', 'P', 'msvcrt')
+         MemcpyLPL  = API.new('memcpy', 'LPL', 'P', 'msvcrt')
+         MemcpyLLL  = API.new('memcpy', 'LLL', 'P', 'msvcrt')
+         MemcpyPPL  = API.new('memcpy', 'PPL', 'P', 'msvcrt')
          
-         MemcpyPLL  = Win32API.new('msvcrt', 'memcpy', 'PLL', 'P')
-         MemcpyLPL  = Win32API.new('msvcrt', 'memcpy', 'LPL', 'P')
-         MemcpyLLL  = Win32API.new('msvcrt', 'memcpy', 'LLL', 'P')
-         MemcpyPPL  = Win32API.new('msvcrt', 'memcpy', 'PPL', 'P')
-      
          # Wrapper for the memcpy() function.  Both the +dest+ and +src+ can
          # be either a string or a memory address.  If +size+ is omitted, it
          # defaults to the length of +src+.
@@ -66,4 +71,4 @@ module Windows
          end
       end
    end
-end
+end

data/lib/windows/msvcrt/file.rb

@@ -1,8 +1,13 @@
-require 'Win32API'
+require 'windows/api'
+include Windows
 
 module Windows
    module MSVCRT
       module File
+         API.auto_method   = false
+         API.auto_constant = false
+         API.auto_unicode  = false
+
          S_IFMT   = 0170000 # file type mask
          S_IFDIR  = 0040000 # directory
          S_IFCHR  = 0020000 # character special
@@ -12,10 +17,28 @@ module Windows
          S_IWRITE = 0000200 # write permission, owner
          S_IEXEC  = 0000100 # execute/search permission, owner
 
-         Stat    = Win32API.new('msvcrt', '_stat', 'PP', 'I')
-         Wstat   = Win32API.new('msvcrt', '_wstat', 'PP', 'I')
-         Stat64  = Win32API.new('msvcrt', '_stat64', 'PP', 'I')
-         Wstat64 = Win32API.new('msvcrt', '_wstat64', 'PP', 'I')
+         Mktemp  = API.new('_mktemp', 'P', 'P', 'msvcrt')
+         Stat    = API.new('_stat', 'PP', 'I', 'msvcrt')
+         Stat64  = API.new('_stat64', 'PP', 'I', 'msvcrt')
+         Wmktemp = API.new('_wmktemp', 'P', 'P', 'msvcrt')
+         Wstat   = API.new('_wstat', 'PP', 'I', 'msvcrt')
+         Wstat64 = API.new('_wstat64', 'PP', 'I', 'msvcrt')
+
+         # VC++ 8.0 or later
+         begin
+            Mktemp_s  = API.new('_mktemp_s', 'PL', 'L', 'msvcrt')
+            Wmktemp_s = API.new('_wmktemp_s', 'PL', 'L', 'msvcrt')
+         rescue RuntimeError
+            # Ignore - you must check for it via 'defined?'
+         end
+
+         def mktemp(template)
+            Mktemp.call(template)
+         end
+
+         def mktemp_s(template, size)
+            Mktemp_s.call(template, size)
+         end
          
          def stat(path, buffer)
             Stat.call(path, buffer)
@@ -24,7 +47,15 @@ module Windows
          def stat64(path, buffer)
             Stat64.call(path, buffer)
          end
-         
+
+         def wmktemp(template)
+            Wmktemp.call(template)
+         end
+
+         def wmktemp_s(template, size)
+            Wmktemp_s.call(template, size)
+         end
+
          def wstat(path, buffer)
             Wstat.call(path, buffer)
          end
@@ -34,4 +65,4 @@ module Windows
          end
       end
    end
-end
+end