IOWA 1.0.0

data/external/windows-pr/lib/windows/path.rb

@@ -0,0 +1,296 @@
+require 'Win32API'
+
+module Windows
+   module Path
+      # These constants are for use by the PathGetCharType() function.
+      GCT_INVALID   = 0x0000   # The character is not valid in a path.
+      GCT_LFNCHAR   = 0x0001   # The character is valid in a long file name.
+      GCT_SHORTCHAR = 0x0002   # The character is valid in a short (8.3) file name.
+      GCT_WILD      = 0x0004   # The character is a wildcard character.
+      GCT_SEPARATOR = 0x0008   # The character is a path separator.
+
+      PathAddBackslash  = Win32API.new('shlwapi', 'PathAddBackslash', 'P', 'P')
+      PathAddExtension  = Win32API.new('shlwapi', 'PathAddExtension', 'PP', 'I')
+      PathAppend        = Win32API.new('shlwapi', 'PathAppend', 'PP', 'I')
+      PathBuildRoot     = Win32API.new('shlwapi', 'PathBuildRoot', 'PI', 'P')
+      PathCanonicalize  = Win32API.new('shlwapi', 'PathCanonicalize', 'PP', 'I')
+      PathCombine       = Win32API.new('shlwapi', 'PathCombine', 'PPP', 'P')
+      PathCommonPrefix  = Win32API.new('shlwapi', 'PathCommonPrefix', 'PPP', 'I')
+      PathCompactPath   = Win32API.new('shlwapi', 'PathCompactPath', 'PPI', 'I')
+      PathCompactPathEx = Win32API.new('shlwapi', 'PathCompactPathEx', 'PPIL', 'I')
+      PathCreateFromUrl = Win32API.new('shlwapi', 'PathCreateFromUrl', 'PPPL', 'L')      
+      PathFileExists    = Win32API.new('shlwapi', 'PathFileExists', 'P', 'I')
+      PathFindExtension = Win32API.new('shlwapi', 'PathFindExtension', 'P', 'P')
+      PathFindFileName  = Win32API.new('shlwapi', 'PathFindFileName', 'P', 'P') 
+
+      PathFindNextComponent  = Win32API.new('shlwapi', 'PathFindNextComponent', 'P', 'P')
+      PathFindOnPath         = Win32API.new('shlwapi', 'PathFindOnPath', 'PP', 'I')
+      PathFindSuffixArray    = Win32API.new('shlwapi', 'PathFindSuffixArray', 'PPI', 'P')
+      PathGetArgs            = Win32API.new('shlwapi', 'PathGetArgs', 'P', 'P')
+      PathGetCharType        = Win32API.new('shlwapi', 'PathGetCharType', 'P', 'I')
+      PathGetDriveNumber     = Win32API.new('shlwapi', 'PathGetDriveNumber', 'P', 'I')
+      PathIsContentType      = Win32API.new('shlwapi', 'PathIsContentType', 'PP', 'I')
+      PathIsDirectory        = Win32API.new('shlwapi', 'PathIsDirectory', 'P', 'I')
+      PathIsDirectoryEmpty   = Win32API.new('shlwapi', 'PathIsDirectoryEmpty', 'P', 'I')
+      PathIsFileSpec         = Win32API.new('shlwapi', 'PathIsFileSpec', 'P', 'I')
+      #PathIsHTMLFile        = Win32API.new('shlwapi', 'PathIsHTMLFile', 'P', 'I')
+      PathIsLFNFileSpec      = Win32API.new('shlwapi', 'PathIsLFNFileSpec', 'P', 'I')
+      PathIsNetworkPath      = Win32API.new('shlwapi', 'PathIsNetworkPath', 'P', 'I')
+      PathIsPrefix           = Win32API.new('shlwapi', 'PathIsPrefix', 'PP', 'I')
+      PathIsRelative         = Win32API.new('shlwapi', 'PathIsRelative', 'P', 'I')
+      PathIsRoot             = Win32API.new('shlwapi', 'PathIsRoot', 'P', 'I')
+      PathIsSameRoot         = Win32API.new('shlwapi', 'PathIsSameRoot', 'PP', 'I')
+      PathIsSystemFolder     = Win32API.new('shlwapi', 'PathIsSystemFolder', 'PL', 'I')
+      PathIsUNC              = Win32API.new('shlwapi', 'PathIsUNC', 'P', 'I')
+      PathIsUNCServer        = Win32API.new('shlwapi', 'PathIsUNCServer', 'P', 'I')  
+      PathIsUNCServerShare   = Win32API.new('shlwapi', 'PathIsUNCServerShare','P','I')     
+      PathIsURL              = Win32API.new('shlwapi', 'PathIsURL', 'P', 'I')
+      PathMakePretty         = Win32API.new('shlwapi', 'PathMakePretty', 'P', 'I')  
+      PathMakeSystemFolder   = Win32API.new('shlwapi', 'PathMakeSystemFolder', 'P', 'I')      
+      PathMatchSpec          = Win32API.new('shlwapi', 'PathMatchSpec', 'PP', 'I')
+      PathParseIconLocation  = Win32API.new('shlwapi', 'PathParseIconLocation', 'P', 'I')
+      PathQuoteSpaces        = Win32API.new('shlwapi', 'PathQuoteSpaces', 'P', 'V')
+      PathRelativePathTo     = Win32API.new('shlwapi', 'PathRelativePathTo', 'PPLPL', 'I')
+      PathRemoveArgs         = Win32API.new('shlwapi', 'PathRemoveArgs', 'P', 'V')
+      PathRemoveBackslash    = Win32API.new('shlwapi', 'PathRemoveBackslash', 'P', 'P')
+      PathRemoveBlanks       = Win32API.new('shlwapi', 'PathRemoveBlanks', 'P', 'V')
+      PathRemoveExtension    = Win32API.new('shlwapi', 'PathRemoveExtension', 'P','V')
+      PathRemoveFileSpec     = Win32API.new('shlwapi', 'PathRemoveFileSpec', 'P', 'L')
+      PathRenameExtension    = Win32API.new('shlwapi', 'PathRenameExtension', 'PP','I')
+      PathSearchAndQualify   = Win32API.new('shlwapi', 'PathSearchAndQualify', 'PPI', 'I')
+      PathSetDlgItemPath     = Win32API.new('shlwapi', 'PathSetDlgItemPath', 'LIP', 'V')
+      PathSkipRoot           = Win32API.new('shlwapi', 'PathSkipRoot', 'P', 'P')
+      PathStripPath          = Win32API.new('shlwapi', 'PathStripPath', 'P', 'V')
+      PathStripToRoot        = Win32API.new('shlwapi', 'PathStripToRoot', 'P', 'I')
+      PathUndecorate         = Win32API.new('shlwapi', 'PathUndecorate', 'P', 'V')
+      PathUnExpandEnvStrings = Win32API.new('shlwapi', 'PathUnExpandEnvStrings', 'PPI', 'I')
+      PathUnmakeSystemFolder = Win32API.new('shlwapi', 'PathUnmakeSystemFolder', 'P', 'I')
+      PathUnquoteSpaces      = Win32API.new('shlwapi', 'PathUnquoteSpaces', 'P', 'V')
+
+      def PathAddBackslash(path)
+         PathAddBackslash.call(path)
+      end
+
+      def PathAddExtension(path, ext)
+         PathAddExtension.call(path, ext) > 0
+      end
+
+      def PathAppend(path, more)
+         PathAppend.call(path, more) > 0
+      end
+
+      def PathBuildRoot(root, drive)
+         PathBuildRoot.call(root, drive)
+      end
+
+      def PathCanonicalize(dst, src)
+         PathCanonicalize.call(dst, src) > 0
+      end
+
+      def PathCombine(dest, dir, file)
+         PathCombine.call(dest, dir, file)
+      end
+
+      def PathCommonPrefix(path1, path2, buf)
+         PathCommonPrefix.call(path1, path2, buf)
+      end
+
+      def PathCompactPath(handle, path, px_width)
+         PathCompactPath.call(handle, path, px_width) > 0
+      end
+
+      def PathCompactPathEx(out, src, max, flags = nil)
+         PathCompactPathEx.call(out, src, max, flags) > 0
+      end
+
+      def PathCreateFromUrl(url, path, path_size, reserved = nil)
+         PathCreateFromUrl.call(url, path, path_size, reserved) >= 0
+      end
+
+      def PathFileExists(path)
+         PathFileExists.call(path) > 0
+      end
+
+      def PathFindExtension(path)
+         PathFindExtension.call(path)
+      end
+
+      def PathFindFileName(path)
+         PathFindFileName.call(path)
+      end
+
+      def PathFindNextComponent(path)
+         PathFindNextComponent.call(path)
+      end
+
+      def PathFindOnPath(file, dirs)
+         PathFindOnPath.call(file, dirs)
+      end
+
+      def PathFindSuffixArray(path, suffix_array, suffix_size)
+         PathFindSuffixArray.call(path, suffix_array, suffix_size)
+      end
+
+      def PathGetArgs(path)
+         PathGetArgs.call(path)
+      end
+
+      def PathGetCharType(char)
+         PathGetCharType.call(char)
+      end
+
+      def PathGetDriveNumber(path)
+         PathGetDriveNumber.call(path)
+      end
+
+      def PathIsContentType(path, content_type)
+         PathIsContentType.call(path, content_type) > 0
+      end
+
+      def PathIsDirectory(path)
+         PathIsDirectory.call(path) > 0
+      end
+
+      def PathIsDirectoryEmpty(path)
+         PathIsDirectoryEmpty.call(path) > 0
+      end
+
+      def PathIsFileSpec(path)
+         PathIsFileSpec.call(path) > 0
+      end
+
+      # This appears to be broken with the current MSVC distro.  Use
+      # PathIsContentType instead.
+      #def PathIsHTMLFile(path)
+      #   PathIsHTMLFile.call(path)
+      #end
+
+      def PathIsLFNFileSpec(path)
+         PathIsLFNFileSpec.call(path) > 0
+      end
+
+      def PathIsNetworkPath(path)
+         PathIsNetworkPath.call(path) > 0
+      end
+
+      def PathIsPrefix(prefix, path)
+         PathIsPrefix.call(prefix, path) > 0
+      end
+
+      def PathIsRelative(path)
+         PathIsRelative.call(path) > 0
+      end
+
+      def PathIsRoot(path)
+         PathIsRoot.call(path) > 0
+      end
+
+      def PathIsSameRoot(path1, path2)
+         PathIsSameRoot.call(path1, path2) > 0
+      end
+
+      def PathIsSystemFolder(path)
+         PathIsSystemFolder.call(path) > 0
+      end
+
+      def PathIsUNC(path)
+         PathIsUNC.call(path) > 0
+      end
+
+      def PathIsUNCServer(path)
+         PathIsUNCServer.call(path) > 0
+      end
+
+      def PathIsUNCServerShare(path)
+         PathIsUNCServerShare.call(path) > 0
+      end
+
+      def PathIsURL(path)
+         PathIsURL.call(path) > 0
+      end
+
+      def PathMakePretty(path)
+         PathMakePretty.call(path) > 0
+      end
+
+      def PathMakeSystemFolder(path)
+         PathMakeSystemFolder.call(path) > 0
+      end
+
+      def PathMatchSpec(path, spec)
+         PathMatchSpec.call(path, spec) > 0
+      end
+
+      def PathParseIconLocation(path)
+         PathParseIconLocation.call(path)
+      end
+
+      def PathQuoteSpaces(path)
+         PathQuoteSpaces.call(path)
+      end
+
+      def PathRelativePathTo(path, from, from_attr, to, to_attr)
+         PathRelativePathTo.call(path, from, from_attr, to, to_attr) > 0
+      end
+
+      def PathRemoveArgs(path)
+         PathRemoveArgs.call(path)
+      end
+
+      def PathRemoveBackslash(path)
+         PathRemoveBackslash.call(path)
+      end
+
+      def PathRemoveBlanks(path)
+         PathRemoveBlanks.call(path)
+      end
+
+      def PathRemoveExtension(path)
+         PathRemoveExtension.call(path)
+      end
+
+      def PathRemoveFileSpec(path)
+         PathRemoveFileSpec.call(path) > 0
+      end
+
+      def PathRenameExtension(path, ext)
+         PathRenameExtension.call(path, ext) > 0
+      end
+      
+      def PathSearchAndQualify(path, full_path, full_path_size)
+         PathSearchAndQualify.call(path, full_path, full_path_size) > 0
+      end
+      
+      def PathSetDlgItemPath(handle, id, path)
+         PathSetDlgItemPath.call(handle, id, path)
+      end
+      
+      def PathSkipRoot(path)
+         PathSkipRoot.call(path)
+      end
+      
+      def PathStripPath(path)
+         PathStripPath.call(path)
+      end
+      
+      def PathStripToRoot(path)
+         PathStripToRoot.call(path) > 0
+      end
+      
+      def PathUndecorate(path)
+         PathUndecorate.call(path)
+      end
+      
+      def PathUnExpandEnvStrings(path, buf, buf_size)
+         PathUnExpandEnvStrings.call(path, buf, buf_size) > 0
+      end
+      
+      def PathUnmakeSystemFolder(path)
+         PathUnmakeSystemFolder.call(path) > 0
+      end 
+      
+      def PathUnquoteSpaces(path)
+         PathUnquoteSpaces.call(path)
+      end
+   end
+end

data/external/windows-pr/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/external/windows-pr/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