windows-pr 0.6.6 → 0.7.0

data/lib/windows/debug.rb

@@ -0,0 +1,36 @@
+require 'windows/api'
+include Windows
+
+module Windows
+   module Debug
+      API.auto_namespace = 'Windows::Debug'
+      API.auto_constant  = true
+      API.auto_method    = true
+      API.auto_unicode   = false
+
+      API.new('ContinueDebugEvent', 'LLL', 'B')
+      API.new('DebugActiveProcess', 'L', 'B')
+      API.new('DebugBreak', 'V', 'V')
+      API.new('FatalExit', 'I', 'V')
+      API.new('FlushInstructionCache', 'LLL', 'B')
+      API.new('GetThreadContext', 'LP', 'B')
+      API.new('GetThreadSelectorEntry', 'LLP', 'B')
+      API.new('IsDebuggerPresent', 'V', 'B')
+      API.new('OutputDebugStringA', 'P', 'V')
+      API.new('ReadProcessMemory', 'LLPLP', 'B')
+      API.new('SetThreadContext', 'LP', 'B')
+      API.new('WaitForDebugEvent', 'PL', 'B')
+      API.new('WriteProcessMemory', 'LLPLP', 'B')
+
+      # Windows XP or later
+      begin
+         API.new('CheckRemoteDebuggerPresent', 'LP', 'B')
+         API.new('DebugActiveProcessStop', 'L', 'B')
+         API.new('DebugBreakProcess', 'L', 'B')
+         API.new('DebugSetProcessKillOnExit', 'I', 'B')
+      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
+   end
+end

data/lib/windows/device_io.rb

@@ -1,7 +1,13 @@
-require 'Win32API'
+require 'windows/api'
+include Windows
 
 module Windows
    module DeviceIO
+      API.auto_namespace = 'Windows::DeviceIO'
+      API.auto_constant  = true
+      API.auto_method    = true
+      API.auto_unicode   = false
+
       # Device Types
       FILE_DEVICE_BEEP                = 0x00000001
       FILE_DEVICE_CD_ROM              = 0x00000002
@@ -66,11 +72,7 @@ module Windows
       METHOD_BUFFERED = 0
       FILE_ANY_ACCESS = 0
       
-      DeviceIoControl = Win32API.new('kernel32', 'DeviceIoControl', 'LLPLPLPP', 'I')
-      
-      def DeviceIoControl(dev, code, in_buf, in_buf_size, out_buf, out_buf_size, bytes, overlapped)
-         DeviceIoControl.call(dev, code, in_buf, in_buf_size, out_buf, out_buf_size, bytes, overlapped) > 0
-      end
+      API.new('DeviceIoControl', 'LLPLPLPP', 'B')
       
       # Macros from WinIoCtl.h
       def CTL_CODE(device, function, method, access)
@@ -85,4 +87,4 @@ module Windows
          CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 49, 0, FILE_ANY_ACCESS)
       end
    end
-end
+end

data/lib/windows/directory.rb

@@ -1,80 +1,25 @@
-require 'windows/unicode'
+require 'windows/api'
 
+# The Windows::Directory module contains functions that are used in directory
+# management. Note that functions that could be applied to files or
+# directories, such as CreateFile(), are probably in the Windows::File
+# module.
+#
 module Windows
    module Directory
-      CreateDirectory             = Win32API.new('kernel32', 'CreateDirectory', 'PP', 'I')
-      CreateDirectoryW            = Win32API.new('kernel32', 'CreateDirectoryW', 'PP', 'I')
-      CreateDirectoryEx           = Win32API.new('kernel32', 'CreateDirectoryEx', 'PPP', 'I')
-      CreateDirectoryExW          = Win32API.new('kernel32', 'CreateDirectoryExW', 'PPP', 'I')
-      FindCloseChangeNotification = Win32API.new('kernel32', 'FindCloseChangeNotification', 'L', 'I')
-      FindFirstChangeNotification = Win32API.new('kernel32', 'FindFirstChangeNotification', 'PIL', 'L')
-      FindNextChangeNotification  = Win32API.new('kernel32', 'FindNextChangeNotification', 'PIL', 'I')
-      GetCurrentDirectory         = Win32API.new('kernel32', 'GetCurrentDirectory', 'LP', 'L')
-      GetCurrentDirectoryW        = Win32API.new('kernel32', 'GetCurrentDirectoryW', 'LP', 'L')
-      ReadDirectoryChangesW       = Win32API.new('kernel32', 'ReadDirectoryChangesW', 'LPLILPPP', 'I')
-      RemoveDirectory             = Win32API.new('kernel32', 'RemoveDirectory', 'P', 'I')
-      RemoveDirectoryW            = Win32API.new('kernel32', 'RemoveDirectoryW', 'P', 'I')
-      SetCurrentDirectory         = Win32API.new('kernel32', 'SetCurrentDirectory', 'P', 'I')
-      SetCurrentDirectoryW        = Win32API.new('kernel32', 'SetCurrentDirectoryW', 'P', 'I')
-
-      def CreateDirectory(path, attributes = 0)
-         CreateDirectory.call(path, attributes) != 0
-      end
-      
-      def CreateDirectoryW(path, attributes)
-         path = multi_to_wide(path) unless IsTextUnicode(path)
-         CreateDirectoryW.call(path, attributes) != 0
-      end
-
-      def CreateDirectoryEx(template, new_dir, attributes)
-         CreateDirectoryEx.call(template, new_dir, attributes) != 0
-      end
-      
-      def CreateDirectoryExW(template, new_dir, attributes)
-         new_dir = multi_to_wide(new_dir) unless IsTextUnicode(new_dir)
-         CreateDirectoryExW.call(template, new_dir, attributes) != 0
-      end
-
-      def FindCloseChangeNotification(handle)
-         FindCloseChangeNotification.call(handle) != 0
-      end
-
-      def FindFirstChangeNotification(path, subtree, filter)
-         FindFirstChangeNotification.call(path, subtree, filter)
-      end
-
-      def FindNextChangeNotification(handle)
-         FindNextChangeNotification.call(handle) != 0
-      end
-
-      def GetCurrentDirectory(buf_len, buf)
-         GetCurrentDirectory.call(buf_len, buf)
-      end
-      
-      def GetCurrentDirectoryW(buf_len, buf)
-         GetCurrentDirectoryW.call(buf_len, buf)
-      end
-
-      def ReadDirectoryChangesW(handle, buf, buf_len, subtree, filter, bytes, overlapped, routine)
-         ReadDirectoryChangesW.call(handle, buf, buf_len, subtree, filter, bytes, overlapped, routine) != 0
-      end
-
-      def RemoveDirectory(path)
-         RemoveDirectory.call(path) != 0
-      end
-      
-      def RemoveDirectoryW(path)
-         path = multi_to_wide(path) unless IsTextUnicode(path)
-         RemoveDirectoryW.call(path) != 0
-      end
-
-      def SetCurrentDirectory(path)
-         SetCurrentDirectory.call(path) != 0
-      end
-      
-      def SetCurrentDirectoryW(path)
-         path = multi_to_wide(path) unless IsTextUnicode(path)
-         SetCurrentDirectoryW.call(path) != 0
-      end
+      API.auto_namespace = 'Windows::Directory'
+      API.auto_constant  = true
+      API.auto_method    = true
+      API.auto_unicode   = true
+
+      API.new('CreateDirectory', 'PP', 'B')
+      API.new('CreateDirectoryEx', 'PPP', 'B')
+      API.new('FindCloseChangeNotification', 'L', 'B')
+      API.new('FindFirstChangeNotification', 'PIL', 'L')
+      API.new('FindNextChangeNotification', 'PIL', 'B')
+      API.new('GetCurrentDirectory', 'LP', 'L')
+      API.new('ReadDirectoryChangesW', 'LPLILPPP', 'B') # No ANSI equivalent
+      API.new('RemoveDirectory', 'P', 'B')
+      API.new('SetCurrentDirectory', 'P', 'B')
    end
 end

data/lib/windows/error.rb

@@ -1,17 +1,24 @@
 ############################################################################
 # error.rb
 #
-# Includes all of the error codes in error.h and some from winerror.h.
+# Includes all of the error codes in error.h, msterr.h and some from
+# winerror.h.
 #
 # Adds the following convenience methods:
 #
 # get_last_error - Returns a human readable string for the error returned
 # by the GetLastError() function.
 ############################################################################
-require 'windows/unicode'
+require 'windows/api'
+include Windows
 
 module Windows
    module Error
+      API.auto_namespace = 'Windows::Error'
+      API.auto_method    = true
+      API.auto_constant  = true
+      API.auto_unicode   = true
+
       FORMAT_MESSAGE_ALLOCATE_BUFFER   = 0x00000100
       FORMAT_MESSAGE_IGNORE_INSERTS    = 0x00000200
       FORMAT_MESSAGE_FROM_STRING       = 0x00000400
@@ -229,7 +236,6 @@ module Windows
       I24_AREA      = 0x6
       I24_CLASS     = 0x80
 
-
       ERRCLASS_OUTRES  = 1   # Out of Resource 
       ERRCLASS_TEMPSIT = 2   # Temporary Situation 
       ERRCLASS_AUTH    = 3   # Permission problem 
@@ -268,42 +274,51 @@ module Windows
       # From WinError.h
       ERROR_INVALID_FLAGS          = 4100 # 1004L
       ERROR_NO_UNICODE_TRANSLATION = 4371 
+
+      E_INVALIDARG  = 2147942487 # 0x80070057L
+      E_NOINTERFACE = 2147500034 # 0x80004002L
+      E_NOTIMPL     = 2147500033 # 0x80004001L
+      E_OUTOFMEMORY = 2147942414 # 0x8007000EL
+      E_UNEXPECTED  = 2147549183 # 0x8000FFFFL
+
+      RPC_E_TIMEOUT = 2147549471 # 0x8001011FL
+
+      CO_E_NOT_SUPPORTED = 2147500065 # 0x80004021L
+
+      CLASS_E_NOAGGREGATION = 2147746064 # 0x80040110L
+
+      # Registry errors
+      REGDB_E_CLASSNOTREG = 2147746132 # 0x80040154L
+
+      # msterr.h
+      SCHED_S_TASK_READY                  = 267008 # 0x00041300L
+      SCHED_S_TASK_RUNNING                = 267009 # 0x00041301L
+      SCHED_S_TASK_DISABLED               = 267010 # 0x00041302L
+      SCHED_S_TASK_HAS_NOT_RUN            = 267011 # 0x00041303L
+      SCHED_S_TASK_HAS_NO_MORE_RUNS       = 267012 # 0x00041304L
+      SCHED_S_TASK_NOT_SCHEDULED          = 267013 # 0x00041305L
+      SCHED_S_TASK_TERMINATED             = 267014 # 0x00041306L
+      SCHED_S_TASK_NO_VALID_TRIGGERS      = 267015 # 0x00041307L
+      SCHED_S_EVENT_TRIGGER               = 267016 # 0x00041308L
+      SCHED_E_TRIGGER_NOT_FOUND           = 267017 # 0x00041309L
+      SCHED_E_TASK_NOT_READY              = 267018 # 0x0004130AL
+      SCHED_E_TASK_NOT_RUNNING            = 267019 # 0x0004130BL
+      SCHED_E_SERVICE_NOT_INSTALLED       = 267020 # 0x0004130CL
+      SCHED_E_CANNOT_OPEN_TASK            = 267021 # 0x0004130DL
+      SCHED_E_INVALID_TASK                = 267022 # 0x0004130EL
+      SCHED_E_ACCOUNT_INFORMATION_NOT_SET = 267023 # 0x0004130FL
+      SCHED_E_ACCOUNT_NAME_NOT_FOUND      = 267024 # 0x00041310L
+      SCHED_E_ACCOUNT_DBASE_CORRUPT       = 267025 # 0x00041311L
+      SCHED_E_NO_SECURITY_SERVICES        = 267026 # 0x00041312L
+      SCHED_E_UNKNOWN_OBJECT_VERSION      = 267027 # 0x00041313L
          
-      GetLastError   = Win32API.new('kernel32', 'GetLastError', 'V', 'L')
-      SetLastError   = Win32API.new('kernel32', 'SetLastError', 'L', 'V')
-      SetErrorMode   = Win32API.new('kernel32', 'SetErrorMode', 'I', 'I')
-      FormatMessage  = Win32API.new('kernel32', 'FormatMessage', 'LLLLPLP', 'L')
-      FormatMessageW = Win32API.new('kernel32', 'FormatMessageW', 'LLLLPLP', 'L')
-      
-      begin
-         SetLastErrorEx = Win32API.new('user32', 'SetLastErrorEx', 'LL', 'V')
-      rescue Exception
-      end
-      
-      def GetLastError
-         GetLastError.call
-      end
-      
-      def SetLastError(error)
-         SetLastError.call(error)
-      end
-      
-      def SetErrorMode(mode)
-         SetErrorMode.call(mode)
-      end
-      
-      def FormatMessage(flags, src, msg_id, lang_id, buf, size, args)
-         FormatMessage.call(flags, src, msg_id, lang_id, buf, size, args)
-      end
-      
-      def FormatMessageW(flags, src, msg_id, lang_id, buf, size, args)
-         FormatMessageW.call(flags, src, msg_id, lang_id, buf, size, args)
-      end
+      API.new('GetLastError', 'V', 'L')
+      API.new('SetLastError', 'L', 'V')
+      API.new('SetErrorMode', 'I', 'I')
+      API.new('FormatMessage', 'LLLLPLP', 'L')
       
       begin
-         def SetLastErrorEx(error, type=0)
-            SetLastErrorEx.call(error, type)
-         end
+         API.new('SetLastErrorEx', 'LL', 'V', 'user32')
       rescue Exception
          # VC++ 7.0 or later
       end

data/lib/windows/eventlog.rb

@@ -1,7 +1,13 @@
-require 'Win32API'
+require 'windows/api'
+include Windows
 
 module Windows
    module EventLog
+      API.auto_namespace = 'Windows::EventLog'
+      API.auto_constant  = true
+      API.auto_method    = true
+      API.auto_unicode   = true
+
       EVENTLOG_SEQUENTIAL_READ = 0x0001
       EVENTLOG_SEEK_READ       = 0x0002
       EVENTLOG_FORWARDS_READ   = 0x0004
@@ -16,105 +22,18 @@ module Windows
       
       EVENTLOG_FULL_INFO = 0
 
-      BackupEventLog             = Win32API.new('advapi32', 'BackupEventLog', 'LP', 'I')
-      BackupEventLogW            = Win32API.new('advapi32', 'BackupEventLogW', 'LP', 'I')
-      ClearEventLog              = Win32API.new('advapi32', 'ClearEventLog', 'LP', 'I')
-      ClearEventLogW             = Win32API.new('advapi32', 'ClearEventLogW', 'LP', 'I')
-      CloseEventLog              = Win32API.new('advapi32', 'CloseEventLog', 'L', 'I')
-      DeregisterEventSource      = Win32API.new('advapi32', 'DeregisterEventSource', 'L', 'I')
-      GetEventLogInformation     = Win32API.new('advapi32', 'GetEventLogInformation', 'LLPLP', 'I')
-      GetNumberOfEventLogRecords = Win32API.new('advapi32', 'GetNumberOfEventLogRecords', 'LP', 'I')
-      GetOldestEventLogRecord    = Win32API.new('advapi32', 'GetOldestEventLogRecord', 'LP', 'I')
-      NotifyChangeEventLog       = Win32API.new('advapi32', 'NotifyChangeEventLog', 'LL', 'I')
-      OpenBackupEventLog         = Win32API.new('advapi32', 'OpenBackupEventLog', 'PP', 'L')
-      OpenBackupEventLogW        = Win32API.new('advapi32', 'OpenBackupEventLogW', 'PP', 'L')
-      OpenEventLog               = Win32API.new('advapi32', 'OpenEventLog', 'PP', 'L')
-      OpenEventLogW              = Win32API.new('advapi32', 'OpenEventLogW', 'PP', 'L')
-      ReadEventLog               = Win32API.new('advapi32', 'ReadEventLog', 'LLLPLPP', 'I')
-      ReadEventLogW              = Win32API.new('advapi32', 'ReadEventLogW', 'LLLPLPP', 'I')
-      RegisterEventSource        = Win32API.new('advapi32', 'RegisterEventSource', 'PP', 'L')
-      RegisterEventSourceW       = Win32API.new('advapi32', 'RegisterEventSourceW', 'PP', 'L')
-      ReportEvent                = Win32API.new('advapi32', 'ReportEvent', 'LIILPILPP', 'I')
-      ReportEventW               = Win32API.new('advapi32', 'ReportEventW', 'LIILPILPP', 'I')
-
-      def BackupEventLog(handle, file)
-         BackupEventLog.call(handle, file) != 0
-      end
-
-      def BackupEventLogW(handle, file)
-         BackupEventLogW.call(handle, file) != 0
-      end
-
-      def ClearEventLog(handle, file = 0)
-         ClearEventLog.call(handle, file) != 0
-      end
-
-      def ClearEventLogW(handle, file = 0)
-         ClearEventLogW.call(handle, file) != 0
-      end
-
-      def CloseEventLog(handle)
-         CloseEventLog.call(handle) != 0
-      end
-
-      def DeregisterEventSource(handle)
-         DeregisterEventSource.call(handle) != 0
-      end
-
-      def GetEventLogInformation(handle, level, buf, buf_size, bytes)
-         GetEventLogInformation.call(handle, level, buf, buf_size, bytes) != 0
-      end
-
-      def GetNumberOfEventLogRecords(handle, num)
-         GetNumberOfEventLogRecords.call(handle, num) != 0
-      end
-      
-      def GetOldestEventLogRecord(handle, rec)
-         GetOldestEventLogRecord.call(handle, rec) != 0
-      end
-
-      def NotifyChangeEventLog(handle, event)
-         NotifyChangeEventLog.call(handle, event) != 0
-      end
-
-      def OpenBackupEventLog(server, file)
-         OpenBackupEventLog.call(server, file)
-      end
-
-      def OpenBackupEventLogW(server, file)
-         OpenBackupEventLogW.call(server, file)
-      end
-
-      def OpenEventLog(server, source)
-         OpenEventLog.call(server, source)
-      end
-
-      def OpenEventLogW(server, source)
-         OpenEventLogW.call(server, source)
-      end
-
-      def ReadEventLog(handle, flags, offset, buf, bytes, bytes_read, min_bytes)
-         ReadEventLog.call(handle, flags, offset, buf, bytes, bytes_read, min_bytes) != 0
-      end
-
-      def ReadEventLogW(handle, flags, offset, buf, bytes, bytes_read, min_bytes)
-         ReadEventLogW.call(handle, flags, offset, buf, bytes, bytes_read, min_bytes) != 0
-      end
-
-      def RegisterEventSource(server, source)
-         RegisterEventSource.call(server, source)
-      end
-
-      def RegisterEventSourceW(server, source)
-         RegisterEventSourceW.call(server, source)
-      end
-
-      def ReportEvent(handle, type, cat, id, sid, num, size, strings, raw)
-         ReportEvent.call(handle, type, cat, id, sid, num, size, strings, raw) != 0
-      end
-
-      def ReportEventW(handle, type, cat, id, sid, num, size, strings, raw)
-         ReportEventW.call(handle, type, cat, id, sid, num, size, strings, raw) != 0
-      end
+      API.new('BackupEventLog', 'LP', 'B', 'advapi32')
+      API.new('ClearEventLog', 'LP', 'B', 'advapi32')
+      API.new('CloseEventLog', 'L', 'B', 'advapi32')
+      API.new('DeregisterEventSource', 'L', 'B', 'advapi32')
+      API.new('GetEventLogInformation', 'LLPLP', 'B', 'advapi32')
+      API.new('GetNumberOfEventLogRecords', 'LP', 'B', 'advapi32')
+      API.new('GetOldestEventLogRecord', 'LP', 'B', 'advapi32')
+      API.new('NotifyChangeEventLog', 'LL', 'B', 'advapi32')
+      API.new('OpenBackupEventLog', 'PP', 'L', 'advapi32')
+      API.new('OpenEventLog', 'PP', 'L', 'advapi32')
+      API.new('ReadEventLog', 'LLLPLPP', 'B', 'advapi32')
+      API.new('RegisterEventSource', 'PP', 'L', 'advapi32')
+      API.new('ReportEvent', 'LIILPILPP', 'B', 'advapi32')
    end
 end

data/lib/windows/file.rb

@@ -1,8 +1,14 @@
 require 'windows/unicode'
+include Windows
 
 module Windows
    module File
       include Windows::Unicode
+
+      API.auto_namespace = 'Windows::File'
+      API.auto_constant  = true
+      API.auto_method    = true
+      API.auto_unicode   = true
       
       # File Attributes
       FILE_ATTRIBUTE_READONLY      = 0x00000001  
@@ -83,16 +89,28 @@ module Windows
       FILE_READ_ATTRIBUTES         = 128
       FILE_WRITE_ATTRIBUTES        = 256
 	
-      FILE_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x1ff)
+      FILE_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1ff
 	
-      FILE_GENERIC_READ = (STANDARD_RIGHTS_READ|FILE_READ_DATA|
-         FILE_READ_ATTRIBUTES|FILE_READ_EA|SYNCHRONIZE)
+      FILE_GENERIC_READ = 
+         STANDARD_RIGHTS_READ |
+         FILE_READ_DATA |
+         FILE_READ_ATTRIBUTES |
+         FILE_READ_EA |
+         SYNCHRONIZE
 	                               
-      FILE_GENERIC_WRITE = (STANDARD_RIGHTS_WRITE|FILE_WRITE_DATA|
-         FILE_WRITE_ATTRIBUTES|FILE_WRITE_EA|FILE_APPEND_DATA|SYNCHRONIZE)
+      FILE_GENERIC_WRITE = 
+         STANDARD_RIGHTS_WRITE |
+         FILE_WRITE_DATA |
+         FILE_WRITE_ATTRIBUTES |
+         FILE_WRITE_EA |
+         FILE_APPEND_DATA |
+         SYNCHRONIZE
 	           
-      FILE_GENERIC_EXECUTE = (STANDARD_RIGHTS_EXECUTE|FILE_READ_ATTRIBUTES|
-         FILE_EXECUTE|SYNCHRONIZE)
+      FILE_GENERIC_EXECUTE = 
+         STANDARD_RIGHTS_EXECUTE |
+         FILE_READ_ATTRIBUTES |
+         FILE_EXECUTE |
+         SYNCHRONIZE
 	         
       FILE_SHARE_READ                = 1
       FILE_SHARE_WRITE               = 2
@@ -146,301 +164,47 @@ module Windows
       SECTION_MAP_EXECUTE = 0x0008
       SECTION_EXTEND_SIZE = 0x0010
 
-      SECTION_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY |
-         SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE |
+      SECTION_ALL_ACCESS =
+         STANDARD_RIGHTS_REQUIRED |
+         SECTION_QUERY |
+         SECTION_MAP_WRITE |
+         SECTION_MAP_READ |
+         SECTION_MAP_EXECUTE |
          SECTION_EXTEND_SIZE
            
       # Errors
-      INVALID_FILE_ATTRIBUTES   = -1
-      INVALID_HANDLE_VALUE      = -1
-      INVALID_FILE_SIZE         = 0xFFFFFFFF
+      INVALID_FILE_ATTRIBUTES = -1
+      INVALID_HANDLE_VALUE    = -1
+      INVALID_FILE_SIZE       = 0xFFFFFFFF
       
       # Misc
       LOCKFILE_EXCLUSIVE_LOCK   = 0x00000001
       LOCKFILE_FAIL_IMMEDIATELY = 0x00000002
      
-      CopyFile  = Win32API.new('kernel32', 'CopyFile', 'PPI', 'I')
-      CopyFileA = Win32API.new('kernel32', 'CopyFileA', 'PPI', 'I')
-      CopyFileW = Win32API.new('kernel32', 'CopyFileW', 'PPI', 'I')
-      
-      CopyFileEx  = Win32API.new('kernel32', 'CopyFileEx', 'PPPPPL', 'I')
-      CopyFileExA = Win32API.new('kernel32', 'CopyFileExA', 'PPPPPL', 'I')
-      CopyFileExW = Win32API.new('kernel32', 'CopyFileExW', 'PPPPPL', 'I')
-      
-      CreateFile  = Win32API.new('kernel32', 'CreateFile', 'PLLPLLL', 'L')
-      CreateFileA = Win32API.new('kernel32', 'CreateFileA', 'PLLPLLL', 'L')
-      CreateFileW = Win32API.new('kernel32', 'CreateFileW', 'PLLPLLL', 'L')
-      
-      CreateHardLink  = Win32API.new('kernel32', 'CreateHardLink', 'PPP', 'I')
-      CreateHardLinkA = Win32API.new('kernel32', 'CreateHardLinkA', 'PPP', 'I')
-      CreateHardLinkW = Win32API.new('kernel32', 'CreateHardLinkW', 'PPP', 'I')
-      
-      DecryptFile  = Win32API.new('advapi32', 'DecryptFile', 'PL', 'I')
-      DecryptFileA = Win32API.new('advapi32', 'DecryptFileA', 'PL', 'I')
-      DecryptFileW = Win32API.new('advapi32', 'DecryptFileW', 'PL', 'I')
-      
-      DeleteFile  = Win32API.new('kernel32', 'DeleteFile', 'P', 'I')
-      DeleteFileA = Win32API.new('kernel32', 'DeleteFileA', 'P', 'I')
-      DeleteFileW = Win32API.new('kernel32', 'DeleteFileW', 'P', 'I')
-      
-      EncryptFile  = Win32API.new('advapi32', 'EncryptFile', 'P', 'I')
-      EncryptFileA = Win32API.new('advapi32', 'EncryptFileA', 'P', 'I')
-      EncryptFileW = Win32API.new('advapi32', 'EncryptFileW', 'P', 'I')
-
-      GetBinaryType  = Win32API.new('kernel32', 'GetBinaryType', 'PP', 'I')
-      GetBinaryTypeA = Win32API.new('kernel32', 'GetBinaryTypeA', 'PP', 'I')
-      GetBinaryTypeW = Win32API.new('kernel32', 'GetBinaryTypeW', 'PP', 'I')
-      
-      GetFileAttributes  = Win32API.new('kernel32', 'GetFileAttributes', 'P', 'L')
-      GetFileAttributesA = Win32API.new('kernel32', 'GetFileAttributesA', 'P', 'L')
-      GetFileAttributesW = Win32API.new('kernel32', 'GetFileAttributesW', 'P', 'L')
-      
-      GetFileAttributesEx  = Win32API.new('kernel32', 'GetFileAttributesEx', 'PPP', 'I')
-      GetFileAttributesExA = Win32API.new('kernel32', 'GetFileAttributesExA', 'PPP', 'I')
-      GetFileAttributesExW = Win32API.new('kernel32', 'GetFileAttributesExW', 'PPP', 'I')
-      
-      GetFileSize   = Win32API.new('kernel32', 'GetFileSize', 'LP', 'L')
-      GetFileSizeEx = Win32API.new('kernel32', 'GetFileSizeEx', 'LP', 'L')
-      GetFileType   = Win32API.new('kernel32', 'GetFileType', 'L', 'L')
-      
-      GetFullPathName  = Win32API.new('kernel32', 'GetFullPathName', 'PLPP', 'L')
-      GetFullPathNameA = Win32API.new('kernel32', 'GetFullPathNameA', 'PLPP', 'L')
-      GetFullPathNameW = Win32API.new('kernel32', 'GetFullPathNameW', 'PLPP', 'L')
-      
-      GetLongPathName  = Win32API.new('kernel32', 'GetLongPathName', 'PPL', 'L')
-      GetLongPathNameA = Win32API.new('kernel32', 'GetLongPathNameA', 'PPL', 'L')
-      GetLongPathNameW = Win32API.new('kernel32', 'GetLongPathNameW', 'PPL', 'L')
-      
-      GetShortPathName  = Win32API.new('kernel32', 'GetShortPathName', 'PPL', 'L')
-      GetShortPathNameA = Win32API.new('kernel32', 'GetShortPathNameA', 'PPL', 'L')
-      GetShortPathNameW = Win32API.new('kernel32', 'GetShortPathNameW', 'PPL', 'L')
-
-      LockFile   = Win32API.new('kernel32', 'LockFile', 'LLLLL', 'I')
-      LockFileEx = Win32API.new('kernel32', 'LockFileEx', 'LLLLLL', 'I')
-      
-      ReadFile   = Win32API.new('kernel32', 'ReadFile', 'LPLPP', 'I')
-      ReadFileEx = Win32API.new('kernel32', 'ReadFileEx', 'LPLPP', 'I')
-
-      SetFileAttributes  = Win32API.new('kernel32', 'SetFileAttributes', 'PL', 'I')
-      SetFileAttributesA = Win32API.new('kernel32', 'SetFileAttributesA', 'PL', 'I')
-      SetFileAttributesW = Win32API.new('kernel32', 'SetFileAttributesW', 'PL', 'I')
-
-      UnlockFile   = Win32API.new('kernel32', 'UnlockFile', 'LLLLL', 'I')
-      UnlockFileEx = Win32API.new('kernel32', 'UnlockFileEx', 'LLLLL', 'I')
-      
-      WriteFile   = Win32API.new('kernel32', 'WriteFile', 'LPLPP', 'I')   
-      WriteFileEx = Win32API.new('kernel32', 'WriteFileEx', 'LPLPP', 'I')
-
-      def CopyFile(curr_file, new_file, bail)
-         CopyFile.call(curr_file, new_file, bail) > 0
-      end
-      
-      def CopyFileA(curr_file, new_file, bail)
-         CopyFileA.call(curr_file, new_file, bail) > 0
-      end
-      
-      def CopyFileW(curr_file, new_file, bail)
-         CopyFileW.call(curr_file, new_file, bail) > 0
-      end
-
-      def CopyFileEx(curr_file, new_file, routine, data, cancel, flags)
-         CopyFileEx.call(curr_file, new_file, routine, data, cancel, flags) > 0
-      end
-      
-      def CopyFileExA(curr_file, new_file, routine, data, cancel, flags)
-         CopyFileExA.call(curr_file, new_file, routine, data, cancel, flags) > 0
-      end
-      
-      def CopyFileExW(curr_file, new_file, routine, data, cancel, flags)
-         CopyFileExW.call(curr_file, new_file, routine, data, cancel, flags) > 0
-      end
-      
-      def CreateFile(file, access, share, sec, disp, flags, template)
-         CreateFile.call(file, access, share, sec, disp, flags, template)
-      end
-
-      def CreateFileA(file, access, share, sec, disp, flags, template)
-         CreateFileA.call(file, access, share, sec, disp, flags, template)
-      end
-      
-      def CreateFileW(file, access, share, sec, disp, flags, template)
-         CreateFileW.call(file, access, share, sec, disp, flags, template)
-      end
-
-      def CreateHardLink(new_file, old_file, attributes)
-         CreateHardLink.call(new_file, old_file, attributes) > 0
-      end
-      
-      def CreateHardLinkA(new_file, old_file, attributes)
-         CreateHardLinkA.call(new_file, old_file, attributes) > 0
-      end
-      
-      def CreateHardLinkW(new_file, old_file, attributes)
-         CreateHardLinkW.call(new_file, old_file, attributes) > 0
-      end
-
-      def DecryptFile(file, res = 0)
-         DecryptFile.call(file, res)
-      end
-      
-      def DecryptFileA(file, res = 0)
-         DecryptFileA.call(file, res)
-      end
-      
-      def DecryptFileW(file, res = 0)
-         DecryptFileW.call(file, res)
-      end
-
-      def DeleteFile(file)
-         DeleteFile.call(file) > 0
-      end
-      
-      def DeleteFileA(file)
-         DeleteFileA.call(file) > 0
-      end
-      
-      def DeleteFileW(file)
-         DeleteFileW.call(file) > 0
-      end
-
-      def EncryptFile(file)
-         EncryptFile.call(file) > 0
-      end
-      
-      def EncryptFileA(file)
-         EncryptFileA.call(file) > 0
-      end
-      
-      def EncryptFileW(file)
-         EncryptFileW.call(file) > 0
-      end
-
-      def GetBinaryType(file, type)
-         GetBinaryType.call(file, type) > 0
-      end
-      
-      def GetBinaryTypeA(file, type)
-         GetBinaryTypeA.call(file, type) > 0
-      end
-      
-      def GetBinaryTypeW(file, type)
-         GetBinaryTypeW.call(file, type) > 0
-      end
-
-      def GetFileAttributes(file)
-         GetFileAttributes.call(file)
-      end
-      
-      def GetFileAttributesA(file)
-         GetFileAttributesA.call(file)
-      end
-      
-      def GetFileAttributesW(file)
-         GetFileAttributesW.call(file)
-      end
-
-      def GetFileAttributesEx(file, level_id, info)
-         GetFileAttributesEx.call(file, level_id, info)
-      end
-      
-      def GetFileAttributesExA(file, level_id, info)
-         GetFileAttributesExA.call(file, level_id, info)
-      end
-      
-      def GetFileAttributesExW(file, level_id, info)
-         GetFileAttributesExW.call(file, level_id, info)
-      end
-
-      def GetFileSize(handle, size)
-         GetFileSize.call(handle, size)
-      end
-
-      def GetFileSizeEx(handle, size)
-         GetFileSizeEx.call(handle, size) > 0
-      end
-
-      def GetFileType(handle)
-         GetFileType.call(handle)
-      end
-      
-      def GetFullPathName(file, buf, buf_size, part)
-         GetFullPathName.call(file, buf, buf_size, part)
-      end
-      
-      def GetFullPathNameA(file, buf, buf_size, part)
-         GetFullPathNameA.call(file, buf, buf_size, part)
-      end
-      
-      def GetFullPathNameW(file, buf, buf_size, part)
-         GetFullPathNameW.call(file, buf, buf_size, part)
-      end
-      
-      def GetLongPathName(short, buf, buf_size)
-         GetLongPathName.call(short, buf, buf_size)
-      end
-      
-      def GetLongPathNameA(short, buf, buf_size)
-         GetLongPathNameA.call(short, buf, buf_size)
-      end
-      
-      def GetLongPathNameW(short, buf, buf_size)
-         GetLongPathNameW.call(short, buf, buf_size)
-      end
-      
-      def GetShortPathName(long, buf, buf_size)
-         GetShortPathName.call(long, buf, buf_size)
-      end
-      
-      def GetShortPathNameA(long, buf, buf_size)
-         GetShortPathNameA.call(long, buf, buf_size)
-      end
-      
-      def GetShortPathNameW(long, buf, buf_size)
-         GetShortPathNameW.call(long, buf, buf_size)
-      end
-
-      def LockFile(handle, off_low, off_high, lock_low, lock_high)
-         LockFile.call(handle, off_low, off_high, lock_low, lock_high) > 0
-      end
-
-      def LockFileEx(handle, flags, res, low, high, overlapped)
-         LockFileEx.call(handle, flags, res, low, high, overlapped) > 0
-      end
-
-      def ReadFile(file, buf, bytes, bytes_read, overlapped)
-         ReadFile.call(file, buf, bytes, bytes_read, overlapped) > 0
-      end
-
-      def ReadFileEx(file, buf, bytes, overlapped, routine)
-         ReadFileEx.call(file, buf, bytes, overlapped, routine) > 0
-      end
-
-      def SetFileAttributes(file, attributes)
-         SetFileAttributes.call(file, attributes) > 0
-      end
-      
-      def SetFileAttributesA(file, attributes)
-         SetFileAttributesA.call(file, attributes) > 0
-      end
-      
-      def SetFileAttributesW(file, attributes)
-         SetFileAttributesW.call(file, attributes) > 0
-      end
-
-      def UnlockFile(handle, off_low, off_high, bytes_low, bytes_high)
-         UnlockFile.call(handle, off_low, off_high, bytes_low, bytes_high) > 0
-      end
-
-      def UnlockFileEx(handle, res, low, high, overlapped)
-         UnlockFileEx.call(handle, res, low, high, overlapped) > 0
-      end
-
-      def WriteFile(handle, buf, bytes, overlapped)
-         WriteFile.call(handle, buf, bytes, overlapped) > 0
-      end
-
-      def WriteFileEx(handle, buf, bytes, overlapped, routine)
-         WriteFileEx.call(handle, buf, bytes, overlapped, routine) > 0
-      end
+      API.new('CopyFile', 'PPI', 'B')
+      API.new('CopyFileEx', 'PPPPPL', 'B')
+      API.new('CreateFile', 'PLLPLLL', 'L')
+      API.new('CreateHardLink', 'PPP', 'B')
+      API.new('DecryptFile', 'PL', 'B', 'advapi32')
+      API.new('DeleteFile', 'P', 'B')
+      API.new('EncryptFile', 'P', 'B', 'advapi32')
+      API.new('GetBinaryType', 'PP', 'B')
+      API.new('GetFileAttributes', 'P', 'L')
+      API.new('GetFileAttributesEx', 'PPP', 'I')
+      API.new('GetFileSize', 'LP', 'L')
+      API.new('GetFileSizeEx', 'LP', 'B')
+      API.new('GetFileType', 'L', 'L')
+      API.new('GetFullPathName', 'PLPP', 'L')
+      API.new('GetLongPathName', 'PPL', 'L')
+      API.new('GetShortPathName', 'PPL', 'L')
+      API.new('LockFile', 'LLLLL', 'B')
+      API.new('LockFileEx', 'LLLLLL', 'B')
+      API.new('ReadFile', 'LPLPP', 'B')
+      API.new('ReadFileEx', 'LPLPP', 'B')
+      API.new('SetFileAttributes', 'PL', 'B')
+      API.new('UnlockFile', 'LLLLL', 'B')
+      API.new('UnlockFileEx', 'LLLLL', 'B')
+      API.new('WriteFile', 'LPLPP', 'B')
+      API.new('WriteFileEx', 'LPLPP', 'B')
    end
 end