The R Project SVN – R – Diff – /branches/R-exp-R5/src/gnuwin32/run.c

+{
     char  c;
     char *s, *p, *q, *f, *dest, *src;
     int   d, ext, len = strlen(cmd)+1;
     char buf[len], fl[len], fn[len];
     /* make a copy as we manipulate in place */
     strcpy(buf, cmd);
     if (!(s = (char *) malloc(MAX_PATH + strlen(cmd)))) {
 	strcpy(RunError, "Insufficient memory (expandcmd)");
    with the hThread handle closed.
 */
 extern size_t Rf_utf8towcs(wchar_t *wc, const char *s, size_t n);
 static void pcreate(const char* cmd, cetype_t enc,
 		      int newconsole, int visible,
 		      HANDLE hIN, HANDLE hOUT, HANDLE hERR,
 		      PROCESS_INFORMATION *pi)
+{
     DWORD ret;
     STARTUPINFO si;
     sa.bInheritHandle = TRUE;
     /* FIXME: this might need to be done in wchar_t */
     if (!(ecmd = expandcmd(cmd))) return; /* error message already set */
     inpipe = (hIN != INVALID_HANDLE_VALUE)
 	|| (hOUT != INVALID_HANDLE_VALUE)
 	|| (hERR != INVALID_HANDLE_VALUE);
     if (inpipe) {
 	HANDLE hNULL = CreateFile("NUL:", GENERIC_READ | GENERIC_WRITE, 0,
 			   &sa, OPEN_EXISTING, 0, NULL);
-    	HANDLE hTHIS = GetCurrentProcess();
+	HANDLE hTHIS = GetCurrentProcess();
 	if (hIN == INVALID_HANDLE_VALUE) hIN = hNULL;
 	if (hOUT == INVALID_HANDLE_VALUE) hOUT = hNULL;
 	if (hERR == INVALID_HANDLE_VALUE) hERR = hNULL;
 	DuplicateHandle(hTHIS, hIN,
 			hTHIS, &dupIN, 0, TRUE, DUPLICATE_SAME_ACCESS);
 	DuplicateHandle(hTHIS, hOUT,
 			hTHIS, &dupOUT, 0, TRUE, DUPLICATE_SAME_ACCESS);
 	DuplicateHandle(hTHIS, hERR,
 			hTHIS, &dupERR, 0, TRUE, DUPLICATE_SAME_ACCESS);
 	CloseHandle(hTHIS);
 	CloseHandle(hNULL);
     }
     switch (visible) {
     case -1:
 	showWindow = SW_HIDE;
 	break;
     case 0:
 	showWindow = SW_SHOWMINIMIZED;
 	break;
+    }
     if(enc == CE_UTF8) {
 	wsi.cb = sizeof(wsi);
 	wsi.lpReserved = NULL;
 	wsi.lpReserved2 = NULL;
 	wsi.cbReserved2 = 0;
 	wsi.lpDesktop = NULL;
 	wsi.lpTitle = NULL;
 	wsi.dwFlags = STARTF_USESHOWWINDOW;
 	wsi.wShowWindow = showWindow;
 	if (inpipe) {
 	    wsi.dwFlags |= STARTF_USESTDHANDLES;
 	    wsi.hStdInput  = dupIN;
 	    wsi.hStdOutput = dupOUT;
 	    wsi.hStdError  = dupERR;
 	si.lpReserved2 = NULL;
 	si.cbReserved2 = 0;
 	si.lpDesktop = NULL;
 	si.lpTitle = NULL;
 	si.dwFlags = STARTF_USESHOWWINDOW;
 	si.wShowWindow = showWindow;
 	if (inpipe) {
 	    si.dwFlags |= STARTF_USESTDHANDLES;
 	    si.hStdInput  = dupIN;
 	    si.hStdOutput = dupOUT;
 	    si.hStdError  = dupERR;
 char *runerror(void)
+{
     return RunError;
+}
-static HANDLE getInputHandle(const char *finput)
+static HANDLE getInputHandle(const char *fin)
+{
-    if (finput && finput[0]) {
+    if (fin && fin[0]) {
 	SECURITY_ATTRIBUTES sa;
 	sa.nLength = sizeof(sa);
 	sa.lpSecurityDescriptor = NULL;
 	sa.bInheritHandle = TRUE;
-	HANDLE hIN = CreateFile(finput, GENERIC_READ, 0,
+	HANDLE hIN = CreateFile(fin, GENERIC_READ, 0,
-			 &sa, OPEN_EXISTING, 0, NULL);
+				&sa, OPEN_EXISTING, 0, NULL);
 	if (hIN == INVALID_HANDLE_VALUE) {
+	    snprintf(RunError, 500,
-	    strcpy(RunError, _("unable to redirect input"));
+		     "unable to redirect input from '%s'", fin);
 	    return NULL;
+	}
 	return hIN;
+    }
     return INVALID_HANDLE_VALUE;
+}
+static HANDLE getOutputHandle(const char *fout)
+{
+    if (fout && fout[0]) {
+	SECURITY_ATTRIBUTES sa;
+	sa.nLength = sizeof(sa);
+	sa.lpSecurityDescriptor = NULL;
+	sa.bInheritHandle = TRUE;
+	HANDLE hOUT = CreateFile(fout, GENERIC_WRITE, 0,
+				 &sa, CREATE_ALWAYS, 0, NULL);
+	if (hOUT == INVALID_HANDLE_VALUE) {
+	    snprintf(RunError, 500,
+		     "unable to redirect output to '%s'", fout);
+	    return NULL;
+	}
+	return hOUT;
+    }
+    return INVALID_HANDLE_VALUE;
+}
 BOOL CALLBACK TerminateWindow(HWND hwnd, LPARAM lParam)
+{
     DWORD ID ;
     GetWindowThreadProcessId(hwnd, &ID);
     if (ID == (DWORD)lParam)
-        PostMessage(hwnd, WM_CLOSE, 0, 0);
+	PostMessage(hwnd, WM_CLOSE, 0, 0);
     return TRUE;
+}
 /* Terminate the process pwait2 is waiting for. */
 static void terminate_process(void *p)
+{
     PROCESS_INFORMATION *pi = (PROCESS_INFORMATION*)p;
     EnumWindows((WNDENUMPROC)TerminateWindow, (LPARAM)pi->dwProcessId);
     if (WaitForSingleObject(pi->hProcess, 5000) == WAIT_TIMEOUT) {
-    	if (R_Interactive)
+	if (R_Interactive)
-    	    GA_askok(_("Child process not responding.  R will terminate it."));
+	    GA_askok(_("Child process not responding.  R will terminate it."));
-    	TerminateProcess(pi->hProcess, 99);
+	TerminateProcess(pi->hProcess, 99);
+    }
+}
 static int pwait2(HANDLE p)
+{
     DWORD ret;
     while( WaitForSingleObject(p, 100) == WAIT_TIMEOUT )
-    	R_CheckUserInterrupt();
+	R_CheckUserInterrupt();
     GetExitCodeProcess(p, &ret);
     return ret;
+}
 /*
   Used for external commands in file.show() and edit(), and for
-  system(intern=FALSE).
+  system(intern=FALSE).  Also called from postscript().
   wait != 0 says wait for child to terminate before returning.
   visible = -1, 0, 1 for hide, minimized, default
-  finput is either NULL or the name of a file from which to
+  fin is either NULL or the name of a file from which to
   redirect stdin for the child.
 */
 int runcmd(const char *cmd, cetype_t enc, int wait, int visible,
-	   const char *finput)
+	   const char *fin, const char *fout, const char *ferr)
+{
-    HANDLE hIN = getInputHandle(finput);
+    HANDLE hIN = getInputHandle(fin), hOUT = getOutputHandle(fout),
+	hERR = getOutputHandle(ferr);
     int ret = 0;
     PROCESS_INFORMATION pi;
     memset(&pi, 0, sizeof(pi));
-    pcreate(cmd, enc, !wait, visible,
+    pcreate(cmd, enc, !wait, visible, hIN, hOUT, hERR, &pi);
-    		      hIN,
-    		      INVALID_HANDLE_VALUE,
-    		      INVALID_HANDLE_VALUE,
-    		      &pi);
     if (!pi.hProcess) return NOLAUNCH;
     if (wait) {
-    	RCNTXT cntxt;
+	RCNTXT cntxt;
-    	begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
+	begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
 		 R_NilValue, R_NilValue);
-    	cntxt.cend = &terminate_process;
+	cntxt.cend = &terminate_process;
-    	cntxt.cenddata = &pi;
+	cntxt.cenddata = &pi;
 	ret = pwait2(pi.hProcess);
 	endcontext(&cntxt);
 	sprintf(RunError, _("Exit code was %d"), ret);
 	ret &= 0xffff;
     } else ret = 0;
     CloseHandle(pi.hProcess);
     if (hIN != INVALID_HANDLE_VALUE) CloseHandle(hIN);
+    if (hOUT != INVALID_HANDLE_VALUE) CloseHandle(hERR);
+    if (hERR != INVALID_HANDLE_VALUE) CloseHandle(hERR);
     return ret;
+}
 /*
    finput is either NULL or the name of a file from which to
      redirect stdin for the child.
    visible = -1, 0, 1 for hide, minimized, default
    io = 0 to read stdout from pipe, 1 to write to pipe,
+to read stderr from pipe,
-to read stdout and stderr from pipe.
+to read both stdout and stderr from pipe.
  */
 rpipe * rpipeOpen(const char *cmd, cetype_t enc, int visible,
 		  const char *finput, int io)
+{
     rpipe *r;
 	r->read = hReadPipe;
 	DuplicateHandle(hTHIS, hWritePipe, hTHIS, &r->write,
 , FALSE, DUPLICATE_SAME_ACCESS);
 	CloseHandle(hWritePipe);
 	CloseHandle(hTHIS);
 	pcreate(cmd, enc, 1, visible,
-	        r->read, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE,
+		r->read, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE,
-	        &(r->pi));
+		&(r->pi));
 	r->active = 1;
 	if (!r->pi.hProcess) return NULL; else return r;
+    }
     /* pipe for R to read from */
     hTHIS = GetCurrentProcess();
     r->write = hWritePipe;
     DuplicateHandle(hTHIS, hReadPipe, hTHIS, &r->read,
 , FALSE, DUPLICATE_SAME_ACCESS);
     CloseHandle(hReadPipe);
     CloseHandle(hTHIS);
     hIN = getInputHandle(finput);
     pcreate(cmd, enc, 0, visible,
-            hIN, r->write,
+	    hIN,
+	    (io == 0 || io == 3) ? r->write : INVALID_HANDLE_VALUE,
-            io > 0 ? r->write : INVALID_HANDLE_VALUE,
+	    io >= 2 ? r->write : INVALID_HANDLE_VALUE,
-            &(r->pi));
+	    &(r->pi));
     if (hIN != INVALID_HANDLE_VALUE) CloseHandle(hIN);
     r->active = 1;
     if (!r->pi.hProcess)
 	return NULL;
     if (!(r->thread = CreateThread(NULL, 0, threadedwait, r, 0, &id))) {
 	rpipeClose(r);
 	return NULL;
+    }
     return r;
+}
 static void
 rpipeTerminate(rpipe * r)
+{
     if (r->thread) {
-        TerminateThread(r->thread, 0);
+	TerminateThread(r->thread, 0);
-        CloseHandle(r->thread);
+	CloseHandle(r->thread);
-        r->thread = NULL;
+	r->thread = NULL;
+    }
     if (r->active) {
-    	terminate_process(&(r->pi));
+	terminate_process(&(r->pi));
-    	r->active = 0;
+	r->active = 0;
+    }
+}
 #include "graphapp/ga.h"
 extern Rboolean UserBreak;

The R Project SVN R

(root)/branches/R-exp-R5/src/gnuwin32/run.c @ 63243 – Rev 52813 → 52814