update.
[chise/xemacs-chise.git] / lib-src / i.c
1 /* I-connector utility
2    Copyright (C) 2000 Kirill M. Katsnelson
3
4 This file is part of XEmacs.
5
6 XEmacs is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
9 later version.
10
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with XEmacs; see the file COPYING.  If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.  */
20
21 /* When run with an argument, i treats it as a command line, and pipes
22 command stdin, stdout and stderr to its own respective streams. How
23 silly it should sound, but windowed program in Win32 cannot do output
24 to the console from which it has been started, and should be run using
25 this utility.
26
27 This utility is for running [tx]emacs as part of make process so that
28 its output goes to the same console as the rest of the make output
29 does.  It can be used also when xemacs should be run as a batch
30 command ina script, especially when its standart output should be
31 obtained programmatically. */
32
33 #include <windows.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <tchar.h>
37
38 typedef struct
39 {
40   HANDLE source;
41   HANDLE drain;
42 } I_connector;
43
44 /* 
45  * Make new handle as that pointed to by PH but
46  * inheritable, substitute PH with it, and close the
47  * original one
48  */
49 static void
50 make_inheritable (HANDLE* ph)
51 {
52   HANDLE htmp;
53   DuplicateHandle (GetCurrentProcess(), *ph, GetCurrentProcess(), &htmp,
54                    0, TRUE, DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS);
55   *ph = htmp;
56 }
57
58 /*
59  * Worker thread proc. Reads source, pumps into drain,
60  * till either clogs.
61  */
62 static DWORD CALLBACK
63 pump (LPVOID pv_i)
64 {
65   I_connector* pi = (I_connector*) pv_i;
66   BYTE buffer [256];
67   DWORD really_read, unused;
68
69   while (ReadFile (pi->source, buffer, sizeof (buffer), &really_read, NULL) &&
70          WriteFile (pi->drain, buffer, really_read, &unused, NULL))
71     ;
72
73   return 0;
74 }
75
76 /*
77  * Launch a pump for the given I-connector
78  */
79 static void
80 start_pump (I_connector* pi)
81 {
82   DWORD unused;
83   HANDLE h_thread = CreateThread (NULL, 0, pump, (void*)pi, 0, &unused);
84   CloseHandle (h_thread);
85 }
86
87 /*
88  * Get command line, skip over the executable name, return the rest.
89  */
90 static LPTSTR
91 get_command (void)
92 {
93   LPTSTR cl = GetCommandLine ();
94   int ix;
95
96   while (1)
97     {
98       ix = _tcscspn (cl, _T(" \t\""));
99       if (cl[ix] == '\"')
100         {
101           cl = _tcschr (cl + ix + 1, '\"');
102           if (cl == NULL)
103             return NULL; /* Unmatched quote */
104           cl++;
105         }
106       else
107         {
108           cl += ix;
109           cl += _tcsspn (cl, _T(" \t"));
110           return *cl ? cl : NULL;
111         }
112     }
113 }
114
115 /*
116  * Brew coffee and bring snickers
117  */
118 void
119 usage (void)
120 {
121   fprintf (stderr,
122    "\n"
123    "usage: i command\n"
124    "i executes the command and reroutes its standard handles to the calling\n"
125    "console.  Good for seeing output of GUI programs that use standard output."
126    "\n");
127 }
128
129 int
130 main (void)
131 {
132   STARTUPINFO si;
133   PROCESS_INFORMATION pi;
134   I_connector I_in, I_out, I_err;
135   DWORD exit_code;
136
137   LPTSTR command = get_command ();
138   if (command == NULL)
139     {
140       usage ();
141       return 1;
142     }
143
144   ZeroMemory (&si, sizeof (si));
145   si.dwFlags = STARTF_USESTDHANDLES;
146
147   I_in.source = GetStdHandle (STD_INPUT_HANDLE);
148   CreatePipe (&si.hStdInput, &I_in.drain, NULL, 0);
149   make_inheritable (&si.hStdInput);
150
151   I_out.drain = GetStdHandle (STD_OUTPUT_HANDLE);
152   CreatePipe (&I_out.source, &si.hStdOutput, NULL, 0);
153   make_inheritable (&si.hStdOutput);
154
155   I_err.drain = GetStdHandle (STD_ERROR_HANDLE);
156   CreatePipe (&I_err.source, &si.hStdError, NULL, 0);
157   make_inheritable (&si.hStdError);
158
159   if (CreateProcess (NULL, command, NULL, NULL, TRUE, 0,
160                      NULL, NULL, &si, &pi) == 0)
161     {
162       _ftprintf (stderr, _T("Error %d launching `%s'\n"),
163                  GetLastError (), command);
164       return 2;
165     }
166
167   CloseHandle (pi.hThread);
168
169   /* Start pump in each I-connector */
170   start_pump (&I_in);
171   start_pump (&I_out);
172   start_pump (&I_err);
173
174   /* Wait for the process to complete */
175   WaitForSingleObject (pi.hProcess, INFINITE);
176   GetExitCodeProcess (pi.hProcess, &exit_code);
177   CloseHandle (pi.hProcess);
178
179   /* Make pump threads eventually die out. Looks rude, I agree */
180   CloseHandle (GetStdHandle (STD_INPUT_HANDLE));
181   CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE));
182   CloseHandle (GetStdHandle (STD_ERROR_HANDLE));
183
184   return exit_code;
185 }