1 /* Execute a C# program.
2 Copyright (C) 2003-2006 Free Software Foundation, Inc.
3 Written by Bruno Haible <bruno@clisp.org>, 2003.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
8 any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software Foundation,
17 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
18
19 #include <config.h>
20 #include <alloca.h>
21
22 /* Specification. */
23 #include "csharpexec.h"
24
25 #include <stdio.h>
26 #include <stdlib.h>
27
28 #include "execute.h"
29 #include "sh-quote.h"
30 #include "xallocsa.h"
31 #include "error.h"
32 #include "gettext.h"
33
34 /* Handling of MONO_PATH is just like Java CLASSPATH. */
35 #define CLASSPATHVAR "MONO_PATH"
36 #define new_classpath new_monopath
37 #define set_classpath set_monopath
38 #define reset_classpath reset_monopath
39 #include "classpath.h"
40 #include "classpath.c"
41 #undef reset_classpath
42 #undef set_classpath
43 #undef new_classpath
44 #undef CLASSPATHVAR
45
46 /* Handling of clix' PATH variable is just like Java CLASSPATH. */
47 #if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__
48 /* Win32, Cygwin */
49 #define CLASSPATHVAR "PATH"
50 #elif defined __APPLE__ && defined __MACH__
51 /* MacOS X */
52 #define CLASSPATHVAR "DYLD_LIBRARY_PATH"
53 #else
54 /* Normal Unix */
55 #define CLASSPATHVAR "LD_LIBRARY_PATH"
56 #endif
57 #define new_classpath new_clixpath
58 #define set_classpath set_clixpath
59 #define reset_classpath reset_clixpath
60 #include "classpath.h"
61 #include "classpath.c"
62 #undef reset_classpath
63 #undef set_classpath
64 #undef new_classpath
65 #undef CLASSPATHVAR
66
67 #define _(str) gettext (str)
68
69
70 /* Survey of CIL interpreters.
71
72 Program from
73
74 ilrun pnet
75 mono mono
76 clix sscli
77
78 With Mono, the MONO_PATH is a colon separated list of pathnames. (On
79 Windows: semicolon separated list of pathnames.)
80
81 We try the CIL interpreters in the following order:
82 1. "ilrun", because it is a completely free system.
83 2. "mono", because it is a partially free system but doesn't integrate
84 well with Unix.
85 3. "clix", although it is not free, because it is a kind of "reference
86 implementation" of C#.
87 But the order can be changed through the --enable-csharp configuration
88 option.
89 */
90
91 static int
execute_csharp_using_pnet(const char * assembly_path,const char * const * libdirs,unsigned int libdirs_count,const char * const * args,unsigned int nargs,bool verbose,bool quiet,execute_fn * executer,void * private_data)92 execute_csharp_using_pnet (const char *assembly_path,
93 const char * const *libdirs,
94 unsigned int libdirs_count,
95 const char * const *args, unsigned int nargs,
96 bool verbose, bool quiet,
97 execute_fn *executer, void *private_data)
98 {
99 static bool ilrun_tested;
100 static bool ilrun_present;
101
102 if (!ilrun_tested)
103 {
104 /* Test for presence of ilrun:
105 "ilrun --version >/dev/null 2>/dev/null" */
106 char *argv[3];
107 int exitstatus;
108
109 argv[0] = "ilrun";
110 argv[1] = "--version";
111 argv[2] = NULL;
112 exitstatus = execute ("ilrun", "ilrun", argv, false, false, true, true,
113 true, false);
114 ilrun_present = (exitstatus == 0);
115 ilrun_tested = true;
116 }
117
118 if (ilrun_present)
119 {
120 unsigned int argc;
121 char **argv;
122 char **argp;
123 unsigned int i;
124 bool err;
125
126 argc = 1 + 2 * libdirs_count + 1 + nargs;
127 argv = (char **) xallocsa ((argc + 1) * sizeof (char *));
128
129 argp = argv;
130 *argp++ = "ilrun";
131 for (i = 0; i < libdirs_count; i++)
132 {
133 *argp++ = "-L";
134 *argp++ = (char *) libdirs[i];
135 }
136 *argp++ = (char *) assembly_path;
137 for (i = 0; i < nargs; i++)
138 *argp++ = (char *) args[i];
139 *argp = NULL;
140 /* Ensure argv length was correctly calculated. */
141 if (argp - argv != argc)
142 abort ();
143
144 if (verbose)
145 {
146 char *command = shell_quote_argv (argv);
147 printf ("%s\n", command);
148 free (command);
149 }
150
151 err = executer ("ilrun", "ilrun", argv, private_data);
152
153 freesa (argv);
154
155 return err;
156 }
157 else
158 return -1;
159 }
160
161 static int
execute_csharp_using_mono(const char * assembly_path,const char * const * libdirs,unsigned int libdirs_count,const char * const * args,unsigned int nargs,bool verbose,bool quiet,execute_fn * executer,void * private_data)162 execute_csharp_using_mono (const char *assembly_path,
163 const char * const *libdirs,
164 unsigned int libdirs_count,
165 const char * const *args, unsigned int nargs,
166 bool verbose, bool quiet,
167 execute_fn *executer, void *private_data)
168 {
169 static bool mono_tested;
170 static bool mono_present;
171
172 if (!mono_tested)
173 {
174 /* Test for presence of mono:
175 "mono --version >/dev/null 2>/dev/null" */
176 char *argv[3];
177 int exitstatus;
178
179 argv[0] = "mono";
180 argv[1] = "--version";
181 argv[2] = NULL;
182 exitstatus = execute ("mono", "mono", argv, false, false, true, true,
183 true, false);
184 mono_present = (exitstatus == 0);
185 mono_tested = true;
186 }
187
188 if (mono_present)
189 {
190 char *old_monopath;
191 char **argv = (char **) xallocsa ((2 + nargs + 1) * sizeof (char *));
192 unsigned int i;
193 bool err;
194
195 /* Set MONO_PATH. */
196 old_monopath = set_monopath (libdirs, libdirs_count, false, verbose);
197
198 argv[0] = "mono";
199 argv[1] = (char *) assembly_path;
200 for (i = 0; i <= nargs; i++)
201 argv[2 + i] = (char *) args[i];
202
203 if (verbose)
204 {
205 char *command = shell_quote_argv (argv);
206 printf ("%s\n", command);
207 free (command);
208 }
209
210 err = executer ("mono", "mono", argv, private_data);
211
212 /* Reset MONO_PATH. */
213 reset_monopath (old_monopath);
214
215 freesa (argv);
216
217 return err;
218 }
219 else
220 return -1;
221 }
222
223 static int
execute_csharp_using_sscli(const char * assembly_path,const char * const * libdirs,unsigned int libdirs_count,const char * const * args,unsigned int nargs,bool verbose,bool quiet,execute_fn * executer,void * private_data)224 execute_csharp_using_sscli (const char *assembly_path,
225 const char * const *libdirs,
226 unsigned int libdirs_count,
227 const char * const *args, unsigned int nargs,
228 bool verbose, bool quiet,
229 execute_fn *executer, void *private_data)
230 {
231 static bool clix_tested;
232 static bool clix_present;
233
234 if (!clix_tested)
235 {
236 /* Test for presence of clix:
237 "clix >/dev/null 2>/dev/null ; test $? = 1" */
238 char *argv[2];
239 int exitstatus;
240
241 argv[0] = "clix";
242 argv[1] = NULL;
243 exitstatus = execute ("clix", "clix", argv, false, false, true, true,
244 true, false);
245 clix_present = (exitstatus == 0 || exitstatus == 1);
246 clix_tested = true;
247 }
248
249 if (clix_present)
250 {
251 char *old_clixpath;
252 char **argv = (char **) xallocsa ((2 + nargs + 1) * sizeof (char *));
253 unsigned int i;
254 bool err;
255
256 /* Set clix' PATH variable. */
257 old_clixpath = set_clixpath (libdirs, libdirs_count, false, verbose);
258
259 argv[0] = "clix";
260 argv[1] = (char *) assembly_path;
261 for (i = 0; i <= nargs; i++)
262 argv[2 + i] = (char *) args[i];
263
264 if (verbose)
265 {
266 char *command = shell_quote_argv (argv);
267 printf ("%s\n", command);
268 free (command);
269 }
270
271 err = executer ("clix", "clix", argv, private_data);
272
273 /* Reset clix' PATH variable. */
274 reset_clixpath (old_clixpath);
275
276 freesa (argv);
277
278 return err;
279 }
280 else
281 return -1;
282 }
283
284 bool
execute_csharp_program(const char * assembly_path,const char * const * libdirs,unsigned int libdirs_count,const char * const * args,bool verbose,bool quiet,execute_fn * executer,void * private_data)285 execute_csharp_program (const char *assembly_path,
286 const char * const *libdirs,
287 unsigned int libdirs_count,
288 const char * const *args,
289 bool verbose, bool quiet,
290 execute_fn *executer, void *private_data)
291 {
292 unsigned int nargs;
293 int result;
294
295 /* Count args. */
296 {
297 const char * const *arg;
298
299 for (nargs = 0, arg = args; *arg != NULL; nargs++, arg++)
300 ;
301 }
302
303 /* First try the C# implementation specified through --enable-csharp. */
304 #if CSHARP_CHOICE_PNET
305 result = execute_csharp_using_pnet (assembly_path, libdirs, libdirs_count,
306 args, nargs, verbose, quiet,
307 executer, private_data);
308 if (result >= 0)
309 return (bool) result;
310 #endif
311
312 #if CSHARP_CHOICE_MONO
313 result = execute_csharp_using_mono (assembly_path, libdirs, libdirs_count,
314 args, nargs, verbose, quiet,
315 executer, private_data);
316 if (result >= 0)
317 return (bool) result;
318 #endif
319
320 /* Then try the remaining C# implementations in our standard order. */
321 #if !CSHARP_CHOICE_PNET
322 result = execute_csharp_using_pnet (assembly_path, libdirs, libdirs_count,
323 args, nargs, verbose, quiet,
324 executer, private_data);
325 if (result >= 0)
326 return (bool) result;
327 #endif
328
329 #if !CSHARP_CHOICE_MONO
330 result = execute_csharp_using_mono (assembly_path, libdirs, libdirs_count,
331 args, nargs, verbose, quiet,
332 executer, private_data);
333 if (result >= 0)
334 return (bool) result;
335 #endif
336
337 result = execute_csharp_using_sscli (assembly_path, libdirs, libdirs_count,
338 args, nargs, verbose, quiet,
339 executer, private_data);
340 if (result >= 0)
341 return (bool) result;
342
343 if (!quiet)
344 error (0, 0, _("C# virtual machine not found, try installing pnet"));
345 return true;
346 }
347