namespace pipeio

--****

-- === Pipe Input/Output

--

-- ==== Notes

-- Due to a bug, Euphoria does not handle STDERR properly

-- STDERR cannot captured for Euphoria programs (other programs will work fully)

-- The IO functions currently work with file handles, a future version might wrap them in streams

-- so that they can be used directly alongside other file/socket/other-streams with a

-- stream_select() function.

--

--Includes

include std/dll.e

include std/machine.e

include std/error.e

constant

kernel32 = open_dll("kernel32.dll"),

--iGetExitCodeProcess=define_c_func(kernel32,"GetExitCodeProcess",{C_UINT,C_POINTER},C_INT),

iCreatePipe = define_c_func(kernel32,"CreatePipe",{C_POINTER,C_POINTER,C_POINTER,C_DWORD},C_BOOL),

iReadFile = define_c_func(kernel32,"ReadFile",{C_UINT,C_POINTER,C_DWORD,C_POINTER,C_POINTER},C_BOOL),

iWriteFile = define_c_func(kernel32,"WriteFile",{C_UINT,C_POINTER,C_DWORD,C_POINTER,C_POINTER},C_BOOL),

iCloseHandle = define_c_func(kernel32,"CloseHandle",{C_UINT},C_BOOL),

iTerminateProcess=define_c_func(kernel32,"TerminateProcess",{C_UINT,C_UINT},C_BOOL),

iGetLastError = define_c_func(kernel32,"GetLastError",{},C_DWORD),

iGetStdHandle = define_c_func(kernel32,"GetStdHandle",{C_DWORD},C_UINT),

iSetHandleInformation = define_c_func(kernel32,"SetHandleInformation",{C_UINT,C_DWORD,C_DWORD},C_BOOL),

iCreateProcess = define_c_func(kernel32,"CreateProcessA",{C_POINTER,C_POINTER,C_POINTER,

C_POINTER,C_BOOL,C_DWORD,C_POINTER,C_POINTER,C_POINTER,C_POINTER},C_BOOL)

constant

-- STD_INPUT_HANDLE = -10,

-- STD_OUTPUT_HANDLE = -11,

-- STD_ERROR_HANDLE = -12,

-- FILE_INVALID_HANDLE = -1,

-- ERROR_BROKEN_PIPE = 109,

SA_SIZE = 12,

PIPE_WRITE_HANDLE = 1, PIPE_READ_HANDLE=2,

HANDLE_FLAG_INHERIT=1,

SUIdwFlags = 44,

SUIhStdInput = 56,

STARTUPINFO_SIZE = 68,

STARTF_USESHOWWINDOW = 1,

STARTF_USESTDHANDLES = 256,

PROCESS_INFORMATION_SIZE = 16,

FAIL = 0

elsedef

--*NIX-specific constants

constant

enum

end ifdef

--****

-- === Accessor Constants

public enum

--** Child processes standard input

--** Child processes standard output

--** Child processes standard error

--** Process ID

--

public enum

--** Set of pipes that are for the use of the parent

--** Set of pipes that are given to the child - should not be used by the parent

--

-- Common functions

return c_func(iGetLastError,{})

elsedef

end ifdef

end function

--****

-- === Opening/Closing

--**

-- Process Type

end if

end if

end type

--**

-- Close handle fd

--

-- Returns:

-- An **integer**, 0 on success, -1 on failure

--

-- Example 1:

--

-- integer status = pipeio:close(p[STDIN])

--

--

atom ret

ret=c_func(iCloseHandle,{fd})

elsedef

end ifdef

end if

end function

--**

-- Close pipes and kill process p with signal signal (default 15)

--

-- Comments:

-- Signal is ignored on Windows.

--

-- Example 1:

--

-- kill(p)

--

--

atom ret

--Close the pipes

--If any fail its probably just because they were already closed, so that is ignored

--Error may result, but it is usually just because the process has already ended.

--Not how to handle "signal", so its ignored on Windows for now

ret=c_func(iTerminateProcess,{p[PID],signal and 0})

elsedef

end ifdef

sequence handles

atom ret

atom psaAttrib, phWriteToPipe, phReadFromPipe

psaAttrib = allocate(SA_SIZE+2*4)

poke4(psaAttrib,{SA_SIZE,0,1})

phWriteToPipe = psaAttrib+SA_SIZE

phReadFromPipe = psaAttrib+SA_SIZE+4

ret = c_func(iCreatePipe,{phReadFromPipe,phWriteToPipe,psaAttrib,0})

handles = peek4u({phWriteToPipe,2})

free(psaAttrib)

elsedef

end ifdef

end if

end function

--****

-- === Read/Write Process

--**

-- Read ##bytes## bytes from handle ##fd##

--

-- Returns:

-- A **sequence**, containing data, an empty sequence on EOF or an error code.

-- Similar to [[:get_bytes]].

--

-- Example 1:

--

-- sequence data=read(p[STDOUT],256)

--

--

ret, ReadCount,

atom pReadCount=allocate(4)

ret = c_func(iReadFile,{fd,buf,bytes,pReadCount,0})

ReadCount=peek4u(pReadCount)

free(pReadCount)

elsedef

end ifdef

end if

end function

--****

-- Write ##bytes## to handle ##fd##

--

-- Returns:

-- A **integer**, number of bytes written, or -1 on error

--

-- Example 1:

--

-- integer bytes_written = write(p[STDIN],"Hello World!")

--

--

atom

-- fd = p[2],

ret,WrittenCount

atom pWrittenCount=allocate(4)

ret=c_func(iWriteFile,{fd,buf,length(str),pWrittenCount,0})

WrittenCount=peek4u(pWrittenCount)

free(pWrittenCount)

elsedef

end ifdef

end if

end function

--**

-- Get error no from last call to a pipe function

--

-- Comments:

-- Value returned will be OS-specific, and is not always set on Windows at least

--

-- Example 1:

--

-- integer error = error_no()

--

--

end function

--WIN32-specific functions

function GetStdHandle(atom device)

return c_func(iGetStdHandle,{device})

end function

function SetHandleInformation(atom hObject, atom dwMask, atom dwFlags)

return c_func(iSetHandleInformation,{hObject,dwMask,dwFlags})

end function

procedure CloseAllHandles(sequence handles)

atom ret

for i = 1 to length(handles) do

ret=close(handles[i])

end for

end procedure

function CreateProcess(sequence CommandLine,sequence StdHandles)

object fnVal

atom pPI, pSUI, pCmdLine

sequence ProcInfo

pCmdLine = allocate_string(CommandLine)

pPI = allocate(PROCESS_INFORMATION_SIZE)

mem_set(pPI,0,PROCESS_INFORMATION_SIZE)

pSUI = allocate(STARTUPINFO_SIZE)

mem_set(pSUI,0,STARTUPINFO_SIZE)

poke4(pSUI,STARTUPINFO_SIZE)

poke4(pSUI+SUIdwFlags,or_bits(STARTF_USESTDHANDLES,STARTF_USESHOWWINDOW))

poke4(pSUI+SUIhStdInput,StdHandles)

fnVal = c_func(iCreateProcess,{0,pCmdLine,0,0,1,0,0,0,pSUI,pPI})

free(pCmdLine)

free(pSUI)

ProcInfo = peek4u({pPI,4})

free(pPI)

if not fnVal then

return 0

end if

return ProcInfo

end function -- CreateProcess()

--WIN32 version of create()

--**

-- Create pipes for inter-process communication

--

-- Returns:

-- A **handle**, process handles { {parent side pipes},{child side pipes} }

--

-- Example 1:

--

-- object p = exec("dir", create())

--

--

public function create()

atom hChildStdInRd,hChildStdOutWr, hChildStdErrWr, -- handles used by child process

hChildStdInWr, hChildStdOutRd,hChildStdErrRd -- handles used by parent process

object

StdInPipe = {},

StdOutPipe = {},

StdErrPipe = {}

object fnVal

-- capture child process std input

StdInPipe = os_pipe()

if atom(StdInPipe) then return -1 end if

hChildStdInRd = StdInPipe[PIPE_READ_HANDLE]

hChildStdInWr = StdInPipe[PIPE_WRITE_HANDLE]

-- capture child process std output

StdOutPipe = os_pipe()

if atom(StdOutPipe) then

CloseAllHandles(StdInPipe)

return -1

end if

hChildStdOutWr = StdOutPipe[PIPE_WRITE_HANDLE]

hChildStdOutRd = StdOutPipe[PIPE_READ_HANDLE]

-- capture child process std error

StdErrPipe = os_pipe()

if atom(StdErrPipe) then

CloseAllHandles(StdErrPipe & StdOutPipe)

return -1

end if

hChildStdErrWr = StdErrPipe[PIPE_WRITE_HANDLE]

hChildStdErrRd = StdErrPipe[PIPE_READ_HANDLE]

fnVal = SetHandleInformation(StdInPipe[PIPE_WRITE_HANDLE],HANDLE_FLAG_INHERIT,0)

fnVal = SetHandleInformation(StdOutPipe[PIPE_READ_HANDLE],HANDLE_FLAG_INHERIT,0)

fnVal = SetHandleInformation(StdErrPipe[PIPE_READ_HANDLE],HANDLE_FLAG_INHERIT,0)

return {{hChildStdInWr,hChildStdOutRd,hChildStdErrRd},

{hChildStdInRd,hChildStdOutWr,hChildStdErrWr}}

end function

--WIN32 version of exec()

--**

-- Open process with command line cmd

--

-- Returns:

-- A **handle**, process handles { [[:PID]], [[:STDIN]], [[:STDOUT]], [[:STDERR]] }

--

-- Example 1:

--

-- object p = exec("dir", create())

--

--

public function exec(sequence cmd, sequence pipe)

object fnVal

atom hChildStdInRd,hChildStdOutWr, hChildStdErrWr, -- handles used by child process

hChildStdInWr, hChildStdOutRd,hChildStdErrRd -- handles used by parent process

atom ret

hChildStdInWr = pipe[1][1]

hChildStdOutRd = pipe[1][2]

hChildStdErrRd = pipe[1][3]

hChildStdInRd = pipe[2][1]

hChildStdOutWr = pipe[2][2]

hChildStdErrWr = pipe[2][3]

atom hChildProcess

-- create child process

fnVal = CreateProcess(cmd,{hChildStdInRd,hChildStdOutWr,hChildStdErrWr})

if atom(fnVal) then

return -1

end if

hChildProcess = fnVal[1]

ret=close(fnVal[2]) -- hChildThread not needed.

ret=close(hChildStdInRd)

ret=close(hChildStdOutWr)

ret=close(hChildStdErrWr)

return {hChildStdInWr,hChildStdOutRd,hChildStdErrRd,hChildProcess}

end function

elsedef

--*NIX-specific functions

end if

end function

end if

end function

atom sbuf

atom vbuf

sequence vbufseq

atom r

end function

end function

--*NIX version of create()

--See docs above in WIN32 version

object ipipe,opipe,epipe

integer ret

--Create pipes

end if

end if

end if

end function

--Linux takes parameters as a sequence of args,

--so this is wrapped in a function below to make it compatible with the Windows implementation

atom pid

integer ret

sequence p

object ipipe,opipe,epipe

--Fork

--Child process

--Not much can really be done about errors at this stage,

--so most are left unchecked

--Close the sides we don't need, otherwise they will be left hanging

--What does this do?

--dup our pipe descriptors to STD*, then close them so they aren't left hanging

--Replace the forked child process with the process we intend to launch

--We should never reach this, so its an error no matter what happens

--Failed to fork

--Close all the descriptors

else

--Parent process

--Process info

--Close the sides we don't need, otherwise they will be left hanging

--If any failed to close, something is wrong with them, so bail out

end if

end if

end function

--*NIX version of exec()

--See docs above in WIN32 version

--*NIX needs exe and args separated,

--but for Windows compatibility, we need to accept a command line

--PHP's proc_open() does it this way.

--If there is a better way, please fix it.

--Need to make sure this works on all *NIX platforms

end function

end ifdef