windows-pr 0.2.0 → 0.5.3

data/lib/windows/path.rb

@@ -1,79 +1,3 @@
-######################################################################
-# path.rb
-# 
-# Defines the following functions:
-#
-# PathAddBackslash()
-# PathAddExtension()
-# PathAppend()
-# PathBuildRoot()
-# PathCanonicalize()
-# PathCombine()
-# PathCommonPrefix()
-# PathCompactPath()
-# PathCompactPathEx()
-# PathCreateFromUrl()
-# PathFileExists()
-# PathFindExtension()
-# PathFindFileName()
-# PathFindNextComponent()
-# PathFindOnPath()
-# PathFindSuffixArray()
-# PathGetArgs()
-# PathGetCharType()
-# PathGetDriveNumber()
-# PathIsContentType()
-# PathIsDirectory()
-# PathIsDirectoryEmpty()
-# PathIsFileSpec()
-# PathIsHTMLFile() - BROKEN
-# PathIsLFNFileSpec()
-# PathIsNetworkPath()
-# PathIsPrefix()
-# PathIsRelative()
-# PathIsRoot()
-# PathIsSameRoot()
-# PathIsSystemFolder()
-# PathIsUNC()
-# PathIsUNCServer()
-# PathIsUNCServerShare()
-# PathIsURL()
-# PathMakePretty()
-# PathMakeSystemFolder()
-# PathMatchSpec()
-# PathParseIconLocation()
-# PathQuoteSpaces()
-# PathRelativePathTo()
-# PathRemoveArgs()
-# PathRemoveBackslash()
-# PathRemoveBlanks()
-# PathRemoveExtension()
-# PathRemoveFileSpec()
-# PathRenameExtension()
-# PathSearchAndQualify()
-# PathSetDlgItemPath()
-# PathSkipRoot()
-# PathStripPath()
-# PathStripToRoot()
-# PathUndecorate()
-# PathUnExpandEnvStrings()
-# PathUnmakeSystemFolder() 
-# PathUnquoteSpaces()
-#
-# Defines the following constants:
-#
-# GCT_INVALID
-# GCT_LFNCHAR
-# GCT_SHORTCHAR
-# GCT_WILD
-# GCT_SEPARATOR
-#
-# Notes:
-#
-# The PathIsHTMLFile() function does not appear to be exported in the
-# shlwapi.dll file that is currently (March, 2006) shipped with the
-# free compiler libs from Microsoft.
-######################################################################
 require 'Win32API'
 
 module Windows
@@ -160,7 +84,7 @@ module Windows
       end
 
       def PathCanonicalize(dst, src)
-         PathCanonicalize.call(dst, src)
+         PathCanonicalize.call(dst, src) > 0
       end
 
       def PathCombine(dest, dir, file)

data/lib/windows/pipe.rb

@@ -0,0 +1,77 @@
+require 'Win32API'
+
+module Windows
+   module Pipe
+      NMPWAIT_NOWAIT           = 0x00000001
+      NMPWAIT_WAIT_FOREVER     = 0xffffffff
+      NMPWAIT_USE_DEFAULT_WAIT = 0x00000000
+
+      PIPE_WAIT             = 0x00000000
+      PIPE_NOWAIT           = 0x00000001
+      PIPE_ACCESS_INBOUND   = 0x00000001
+      PIPE_ACCESS_OUTBOUND  = 0x00000002
+      PIPE_ACCESS_DUPLEX    = 0x00000003
+      PIPE_TYPE_BYTE        = 0x00000000
+      PIPE_TYPE_MESSAGE     = 0x00000004
+      PIPE_READMODE_BYTE    = 0x00000000
+      PIPE_READMODE_MESSAGE = 0x00000002
+      PIPE_CLIENT_END       = 0x00000000
+      PIPE_SERVER_END       = 0x00000001
+
+      CallNamedPipe           = Win32API.new('kernel32', 'CallNamedPipe', 'PPLPLPL', 'I')
+      ConnectNamedPipe        = Win32API.new('kernel32', 'ConnectNamedPipe', 'LP', 'I')
+      CreateNamedPipe         = Win32API.new('kernel32', 'CreateNamedPipe', 'PLLLLLLL', 'L')
+      CreatePipe              = Win32API.new('kernel32', 'CreatePipe', 'PPPL', 'I')
+      DisconnectNamedPipe     = Win32API.new('kernel32', 'DisconnectNamedPipe', 'L', 'I')
+      GetNamedPipeHandleState = Win32API.new('kernel32', 'GetNamedPipeHandleState', 'LPPPPPL', 'I')
+      GetNamedPipeInfo        = Win32API.new('kernel32', 'GetNamedPipeInfo', 'LPPPP', 'I')
+      PeekNamedPipe           = Win32API.new('kernel32', 'PeekNamedPipe', 'LPLPPP', 'I')
+      SetNamedPipeHandleState = Win32API.new('kernel32', 'SetNamedPipeHandleState', 'LPPP', 'I')
+      TransactNamedPipe       = Win32API.new('kernel32', 'TransactNamedPipe', 'LPLPLPP', 'I')
+      WaitNamedPipe           = Win32API.new('kernel32', 'WaitNamedPipe', 'PL', 'I')
+
+      def CallNamedPipe(name, buf, buf_size, out, out_size, read, timeout)
+         CallNamedPipe.call(name, buf, buf_size, out, out_size, read, timeout) != 0
+      end
+
+      def ConnectNamedPipe(pipe, overlapped = 0)
+         ConnectNamedPipe.call(pipe, overlapped) != 0
+      end
+
+      def CreateNamedPipe(name, open_mode, pipe_mode, max, out_size, in_size, timeout, sec_attr)
+         CreateNamedPipe.call(name, open_mode, pipe_mode, max, out_size, in_size, timeout, sec_attr)
+      end
+
+      def CreatePipe(read_pipe, write_pipe, pipe_attr, size)
+         CreatePipe.call(read_pipe, write_pipe, pipe_attr, size) != 0
+      end
+
+      def DisconnectNamedPipe(name)
+         DisconnectNamedPipe.call(name) != 0
+      end
+
+      def GetNamedPipeHandleState(name, state, instances, count, timeout, user, size)
+         GetNamedPipeHandleState.call(name, state, instances, count, timeout, user, size) != 0
+      end
+
+      def GetNamedPipeInfo(name, flags, out_size, in_size, max)
+         GetNamedPipeInfo.call(name, flags, out_size, in_size, max) != 0
+      end
+
+      def PeekNamedPipe(name, buf, buf_size, bytes_read, bytes_avail, bytes_left)
+         PeekNamedPipe.call(name, buf, buf_size, bytes_read, bytes_avail, bytes_left) != 0
+      end
+
+      def SetNamedPipeHandleState(name, mode, max, timeout)
+         SetNamedPipeHandleState.call(name, mode, max, timeout) != 0
+      end
+
+      def TransactNamedPipe(name, in_buf, in_buf_size, out_buf, out_buf_size, read, overlapped)
+         TransactNamedPipe.call(name, in_buf, in_buf_size, out_buf, out_buf_size, read, overlapped) != 0
+      end
+
+      def WaitNamedPipe(name, timeout)
+         WaitNamedPipe.call(name, timeout) != 0
+      end
+   end
+end

data/lib/windows/process.rb

@@ -0,0 +1,171 @@
+require 'Win32API'
+
+module Windows
+   module Process
+      PROCESS_ALL_ACCESS                = 0x1F0FFF
+      PROCESS_CREATE_PROCESS            = 0x0080
+      PROCESS_CREATE_THREAD             = 0x0002
+      PROCESS_DUP_HANDLE                = 0x0040
+      PROCESS_QUERY_INFORMATION         = 0x0400
+      PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+      PROCESS_SET_QUOTA                 = 0x0100
+      PROCESS_SET_INFORMATION           = 0x0200
+      PROCESS_SUSPEND_RESUME            = 0x0800
+      PROCESS_TERMINATE                 = 0x0001
+      PROCESS_VM_OPERATION              = 0x0008
+      PROCESS_VM_READ                   = 0x0010
+      PROCESS_VM_WRITE                  = 0x0020
+      SYNCHRONIZE                       = 1048576
+      STILL_ACTIVE                      = 259
+      
+      ABOVE_NORMAL_PRIORITY_CLASS = 0x00008000
+      BELOW_NORMAL_PRIORITY_CLASS = 0x00004000
+      HIGH_PRIORITY_CLASS         = 0x00000080
+      IDLE_PRIORITY_CLASS         = 0x00000040
+      NORMAL_PRIORITY_CLASS       = 0x00000020
+      REALTIME_PRIORITY_CLASS     = 0x00000100
+      
+      # Process creation flags
+      CREATE_BREAKAWAY_FROM_JOB        = 0x01000000
+      CREATE_DEFAULT_ERROR_MODE        = 0x04000000
+      CREATE_NEW_CONSOLE               = 0x00000010
+      CREATE_NEW_PROCESS_GROUP         = 0x00000200
+      CREATE_NO_WINDOW                 = 0x08000000
+      CREATE_PRESERVE_CODE_AUTHZ_LEVEL = 0x02000000
+      CREATE_SEPARATE_WOW_VDM          = 0x00000800
+      CREATE_SHARED_WOW_VDM            = 0x00001000
+      CREATE_SUSPENDED                 = 0x00000004
+      CREATE_UNICODE_ENVIRONMENT       = 0x00000400
+      DEBUG_ONLY_THIS_PROCESS          = 0x00000002
+      DEBUG_PROCESS                    = 0x00000001
+      DETACHED_PROCESS                 = 0x00000008
+      
+      STARTF_USESHOWWINDOW    = 0x00000001
+      STARTF_USESIZE          = 0x00000002
+      STARTF_USEPOSITION      = 0x00000004
+      STARTF_USECOUNTCHARS    = 0x00000008
+      STARTF_USEFILLATTRIBUTE = 0x00000010
+      STARTF_RUNFULLSCREEN    = 0x00000020
+      STARTF_FORCEONFEEDBACK  = 0x00000040
+      STARTF_FORCEOFFFEEDBACK = 0x00000080
+      STARTF_USESTDHANDLES    = 0x00000100
+      STARTF_USEHOTKEY        = 0x00000200
+      
+      CreateProcess          = Win32API.new('kernel32', 'CreateProcess', 'LPLLLLLPPP', 'I')
+      CreateRemoteThread     = Win32API.new('kernel32', 'CreateRemoteThread', 'LPLLPLP', 'L')
+      CreateThread           = Win32API.new('kernel32', 'CreateThread', 'PLPPLP', 'L')
+      ExitProcess            = Win32API.new('kernel32', 'ExitProcess', 'L', 'V')
+      GetCommandLine         = Win32API.new('kernel32', 'GetCommandLine', 'V', 'P')
+      GetCurrentProcess      = Win32API.new('kernel32', 'GetCurrentProcess', 'V', 'L')      
+      GetCurrentProcessId    = Win32API.new('kernel32', 'GetCurrentProcessId', 'V', 'L')
+      GetEnvironmentStrings  = Win32API.new('kernel32', 'GetEnvironmentStrings', 'V', 'L')
+      GetEnvironmentVariable = Win32API.new('kernel32', 'GetEnvironmentVariable', 'PPL', 'L')
+      GetExitCodeProcess     = Win32API.new('kernel32', 'GetExitCodeProcess', 'LP', 'I')
+      GetPriorityClass       = Win32API.new('kernel32', 'GetPriorityClass', 'L', 'L')
+      GetProcessTimes        = Win32API.new('kernel32', 'GetProcessTimes', 'LPPPP', 'I')
+      GetStartupInfo         = Win32API.new('kernel32', 'GetStartupInfo', 'P', 'V')
+      OpenProcess            = Win32API.new('kernel32', 'OpenProcess', 'LIL', 'L')
+      SetEnvironmentVariable = Win32API.new('kernel32', 'SetEnvironmentVariable', 'PP', 'I')
+      Sleep                  = Win32API.new('kernel32', 'Sleep', 'L', 'V')
+      SleepEx                = Win32API.new('kernel32', 'SleepEx', 'LI', 'L')
+      TerminateProcess       = Win32API.new('kernel32', 'TerminateProcess', 'LL', 'I')
+      WaitForInputIdle       = Win32API.new('user32', 'WaitForInputIdle', 'LL', 'L')
+      
+      # Windows XP or later
+      begin
+         GetProcessId           = Win32API.new('kernel32', 'GetProcessId', 'L', 'L')
+         GetProcessHandleCount  = Win32API.new('kernel32', 'GetProcessHandleCount', 'LP', '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 CreateProcess(app, cmd, pattr, tattr, handles, flags, env, dir, sinfo, pinfo)
+         CreateProcess.call(app, cmd, pattr, tattr, handles, flags, env, dir, sinfo, pinfo) != 0
+      end
+      
+      def CreateRemoteThread(handle, tattr, size, start, param, flags, tid)
+         CreateRemoteThread.call(handle, tattr, size, start, param, flags, tid)
+      end
+      
+      def CreateThread(attr, size, addr, param, flags, id)
+         CreateThread.call(attr, size, addr, param, flags, id)
+      end
+      
+      def ExitProcess(exit_code)
+         ExitProcess.call(exit_code)
+      end
+      
+      def GetCommandLine
+         GetCommandLine.call
+      end
+      
+      def GetCurrentProcess()
+         GetCurrentProcess.call
+      end
+      
+      def GetCurrentProcessId()
+         GetCurrentProcessId.call
+      end
+      
+      def GetEnvironmentStrings()
+         GetEnvironmentStrings.call
+      end
+      
+      def GetEnvironmentVariable(name, buffer, size)
+         GetEnvironmentVariable.call(name, buffer, size)
+      end
+      
+      def GetExitCodeProcess(handle, exit_code)
+         GetExitCodeProcess.call(handle, exit_code) != 0
+      end
+      
+      def GetPriorityClass(handle)
+         GetPriorityClass.call(handle)
+      end
+      
+      def GetProcessTimes(handle, t_creation, t_exit, t_kernel, t_user)
+         GetProcessTimes.call(handle, t_creation, t_exit, t_kernel, t_user) != 0
+      end
+      
+      def GetStartupInfo(info_struct)
+         GetStartupInfo.call(info_struct)
+      end
+      
+      def OpenProcess(access, handle, pid)
+         OpenProcess.call(access, handle, pid)
+      end
+      
+      def SetEnvironmentVariable(name, value)
+         SetEnvironmentVariable.call(name, value)
+      end
+      
+      def Sleep(milliseconds)
+         Sleep.call(milliseconds)
+      end
+      
+      def SleepEx(milliseconds, alertable)
+         SleepEx.call(milliseconds, alertable)
+      end
+      
+      def TerminateProcess(handle, exit_code)
+         TerminateProcess.call(handle, exit_code) != 0
+      end
+      
+      def WaitForInputIdle(handle, milliseconds)
+         WaitForInputIdle.call(handle, milliseconds)
+      end
+
+      begin
+         def GetProcessId(handle)
+            GetProcessId.call(handle)
+         end
+
+         def GetProcessHandleCount(handle, count)
+            GetProcessHandleCount.call(handle, count) != 0
+         end
+      rescue Exception
+         # Windows XP or later      
+      end
+   end
+end

data/lib/windows/registry.rb

@@ -0,0 +1,238 @@
+require 'windows/file'
+
+module Windows
+   module Registry
+      include Windows::File
+      
+      HKEY_CLASSES_ROOT        = 0x80000000
+      KEY_CURRENT_USER         = 0x80000001
+      HKEY_LOCAL_MACHINE       = 0x80000002
+      HKEY_USERS               = 0x80000003
+      HKEY_PERFORMANCE_DATA    = 0x80000004
+      HKEY_PERFORMANCE_TEXT    = 0x80000050
+      HKEY_PERFORMANCE_NLSTEXT = 0x80000060
+      HKEY_CURRENT_CONFIG      = 0x80000005
+      HKEY_DYN_DATA            = 0x80000006
+
+      KEY_QUERY_VALUE         = 0x0001
+      KEY_SET_VALUE           = 0x0002
+      KEY_CREATE_SUB_KEY      = 0x0004
+      KEY_ENUMERATE_SUB_KEYS  = 0x0008
+      KEY_NOTIFY              = 0x0010
+      KEY_CREATE_LINK         = 0x0020
+      KEY_WOW64_32KEY         = 0x0200
+      KEY_WOW64_64KEY         = 0x0100
+      KEY_WOW64_RES           = 0x0300
+
+      KEY_READ = (STANDARD_RIGHTS_READ|KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS|
+                  KEY_NOTIFY) & (~SYNCHRONIZE)
+
+      KEY_WRITE = (STANDARD_RIGHTS_WRITE|KEY_SET_VALUE|
+                  KEY_CREATE_SUB_KEY) & (~SYNCHRONIZE)
+
+      KEY_EXECUTE = KEY_READ & (~SYNCHRONIZE)
+
+      KEY_ALL_ACCESS = (STANDARD_RIGHTS_ALL|KEY_QUERY_VALUE|KEY_SET_VALUE|
+                  KEY_CREATE_SUB_KEY|KEY_ENUMERATE_SUB_KEYS|KEY_NOTIFY|
+                  KEY_CREATE_LINK) & (~SYNCHRONIZE)
+                  
+      REG_OPTION_RESERVED       = 0
+      REG_OPTION_NON_VOLATILE   = 0
+      REG_OPTION_VOLATILE       = 1
+      REG_OPTION_CREATE_LINK    = 2
+      REG_OPTION_BACKUP_RESTORE = 4
+      REG_OPTION_OPEN_LINK      = 8
+
+      REG_LEGAL_OPTION = REG_OPTION_RESERVED|REG_OPTION_NON_VOLATILE|
+         REG_OPTION_VOLATILE|REG_OPTION_CREATE_LINK|REG_OPTION_BACKUP_RESTORE|
+         REG_OPTION_OPEN_LINK
+
+      REG_CREATED_NEW_KEY     = 1
+      REG_OPENED_EXISTING_KEY = 2
+
+      REG_STANDARD_FORMAT = 1
+      REG_LATEST_FORMAT   = 2
+      REG_NO_COMPRESSION  = 4
+
+      REG_WHOLE_HIVE_VOLATILE = 1
+      REG_REFRESH_HIVE        = 2
+      REG_NO_LAZY_FLUSH       = 4
+      REG_FORCE_RESTORE       = 8
+
+      REG_FORCE_UNLOAD = 1
+
+      REG_NOTIFY_CHANGE_NAME        = 1
+      REG_NOTIFY_CHANGE_ATTRIBUTES  = 2
+      REG_NOTIFY_CHANGE_LAST_SET    = 4
+      REG_NOTIFY_CHANGE_SECURITY    = 8
+
+      REG_LEGAL_CHANGE_FILTER = REG_NOTIFY_CHANGE_NAME|
+         REG_NOTIFY_CHANGE_ATTRIBUTES|REG_NOTIFY_CHANGE_LAST_SET|
+         REG_NOTIFY_CHANGE_SECURITY
+
+      REG_NONE                       = 0
+      REG_SZ                         = 1
+      REG_EXPAND_SZ                  = 2    
+      REG_BINARY                     = 3
+      REG_DWORD                      = 4
+      REG_DWORD_LITTLE_ENDIAN        = 4
+      REG_DWORD_BIG_ENDIAN           = 5
+      REG_LINK                       = 6
+      REG_MULTI_SZ                   = 7
+      REG_RESOURCE_LIST              = 8 
+      REG_FULL_RESOURCE_DESCRIPTOR   = 9
+      REG_RESOURCE_REQUIREMENTS_LIST = 10 
+      REG_QWORD                      = 11 
+      REG_QWORD_LITTLE_ENDIAN        = 11
+
+      RegCloseKey               = Win32API.new('advapi32', 'RegCloseKey', 'L', 'L')
+      RegConnectRegistry        = Win32API.new('advapi32', 'RegConnectRegistry', 'PLP', 'L')
+      RegCreateKey              = Win32API.new('advapi32', 'RegCreateKey', 'LPP', 'L')
+      RegCreateKeyEx            = Win32API.new('advapi32', 'RegCreateKeyEx', 'LPLPLLPPP', 'L')
+      RegDeleteKey              = Win32API.new('advapi32', 'RegDeleteKey', 'LP', 'L')
+      RegDeleteValue            = Win32API.new('advapi32', 'RegDeleteValue', 'LP', 'L')
+      RegDisablePredefinedCache = Win32API.new('advapi32', 'RegDisablePredefinedCache', 'V', 'L')
+      RegEnumKey                = Win32API.new('advapi32', 'RegEnumKey', 'LLPL', 'L')
+      RegEnumKeyEx              = Win32API.new('advapi32', 'RegEnumKeyEx', 'LLPPPPP', 'L')
+      RegEnumValue              = Win32API.new('advapi32', 'RegEnumValue', 'LLPPPPPP', 'L')
+      RegFlushKey               = Win32API.new('advapi32', 'RegFlushKey', 'L', 'L')
+      RegLoadKey                = Win32API.new('advapi32', 'RegLoadKey', 'LPP', 'L')
+      RegNotifyChangeKeyValue   = Win32API.new('advapi32', 'RegNotifyChangeKeyValue', 'LILLI', 'L')
+      RegOpenCurrentUser        = Win32API.new('advapi32', 'RegOpenCurrentUser', 'LP', 'L')
+      RegOpenKey                = Win32API.new('advapi32', 'RegOpenKey', 'LPP', 'L')
+      RegOpenKeyEx              = Win32API.new('advapi32', 'RegOpenKeyEx', 'LPLLP', 'L')
+      RegOpenUserClassesRoot    = Win32API.new('advapi32', 'RegOpenUserClassesRoot', 'LLLP', 'L')
+      RegOverridePredefKey      = Win32API.new('advapi32', 'RegOverridePredefKey', 'LL', 'L')
+      RegQueryInfoKey           = Win32API.new('advapi32', 'RegQueryInfoKey', 'LPPPPPPPPPPP', 'L')
+      RegQueryMultipleValues    = Win32API.new('advapi32', 'RegQueryMultipleValues', 'LPLPP', 'L')
+      RegQueryValueEx           = Win32API.new('advapi32', 'RegQueryValueEx', 'LPPPPP', 'L')
+      RegReplaceKey             = Win32API.new('advapi32', 'RegReplaceKey', 'LPPP', 'L')
+      RegRestoreKey             = Win32API.new('advapi32', 'RegRestoreKey', 'LPL', 'L')
+      RegSaveKey                = Win32API.new('advapi32', 'RegSaveKey', 'LPP', 'L')      
+      RegSetValueEx             = Win32API.new('advapi32', 'RegSetValueEx', 'LPLLPL', 'L')
+      RegUnLoadKey              = Win32API.new('advapi32', 'RegUnLoadKey', 'LP', 'L')
+      
+      # Windows XP or later
+      begin
+         RegSaveKeyEx = Win32API.new('advapi32', 'RegSaveKeyEx', 'LPPL', 'L')
+      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 RegCloseKey(key)
+         RegCloseKey.call(key)
+      end
+
+      def RegConnectRegistry(machine, key, result)
+         RegConnectRegistry.call(machine, key, result)
+      end
+
+      def RegCreateKey(key, subkey, result)
+         RegCreateKey.call(key, subkey, result)
+      end
+
+      def RegCreateKeyEx(key, subkey, res, klass, opt, sam, sec, result, disp)
+         RegCreateKeyEx.call(key, subkey, res, klass, opt, sam, sec, result, disp)
+      end
+
+      def RegDeleteKey(key, subkey)
+         RegDeleteKey.call(key, subkey)
+      end
+
+      def RegDeleteValue(key, value)
+         RegDeleteValue.call(key, value)
+      end
+
+      def RegDisablePredefinedCache()
+         RegDisablePredefinedCache.call()
+      end
+
+      def RegEnumKey(key, index, name, size)
+         RegEnumKey.call(key, index, name, size)
+      end
+
+      def RegEnumKeyEx(key, index, name, size, res, klass, ksize, time)
+         RegEnumKeyEx.call(key, index, name, size, res, klass, ksize, time)
+      end
+
+      def RegEnumValue(key, index, value, size, res, type, data, dsize)
+         RegEnumValue.call(key, index, value, size, res, type, data, dsize)
+      end
+
+      def RegOpenKeyEx(key, subkey, options, sam, result)
+         RegOpenKeyEx.call(key, subkey, options, sam, result)
+      end
+
+      def RegFlushKey(key)
+         RegFlushKey.call(key)
+      end
+
+      def RegLoadKey(key, subkey, file)
+         RegLoadKey.call(key, subkey, file)
+      end
+
+      def RegNotifyChangeKeyValue(key, subtree, filter, event, async)
+         RegNotifyChangeKeyValue.call(key, subtree, filter, event, async)
+      end
+
+      def RegOpenCurrentUser(sam, result)
+         RegOpenCurrentUser.call(sam, result)
+      end
+
+      def RegOpenKeyEx(key, subkey, options, sam, result)
+         RegOpenKeyEx.call(key, subkey, options, sam, result)
+      end
+
+      def RegOpenUserClassesRoot(token, options, sam, result)
+         RegOpenUserClassesRoot.call(token, options, sam, result)
+      end
+
+      def RegOverridePredefKey(key, new_key)
+         RegOverridePredefKey.call(key, new_key)
+      end
+
+      def RegQueryInfoKey(key, klass, ksize, res, subkeys, maxkey, maxklass,
+         values, maxname, maxvalue, sec, time)
+         RegQueryInfoKey.call(key, klass, ksize, res, subkeys, maxkey, maxklass,
+            values, maxname, maxvalue, sec, time)
+      end
+
+      def RegQueryMultipleValues(key, val_list, num_vals, buf, size)
+         RegQueryMultipleValues.call(key, val_list, num_vals, buf, size)
+      end
+
+      def RegQueryValueEx(key, value, res, type, data, cbdata)
+         RegQueryValueEx.call(key, value, res, type, data, cbdata)
+      end
+
+      def RegReplaceKey(key, subkey, newfile, oldfile)
+         RegReplaceKey.call(key, subkey, newfile, oldfile)
+      end
+
+      def RegRestoreKey(key, file, flags)
+         RegRestoreKey.call(key, file, flags)
+      end
+
+      def RegSaveKey(key, file, sec)
+         RegSaveKey.call(key, file, sec)
+      end
+
+      def RegSetValueEx(key, value, res, type, data, size)
+         RegSetValueEx.call(key, value, res, type, data, size)
+      end
+
+      def RegUnLoadKey(key, subkey)
+         RegUnLoadKey.call(key, subkey)
+      end
+      
+      # Windows XP or later
+      begin
+         def RegSaveKeyEx(key, file, sec, flags)
+            RegSaveKeyEx.call(key, file, sec, flags)
+         end
+      rescue Exception
+         # Do nothing - not supported on current platform
+      end
+   end
+end