lib/csharpexec.c

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