lib/csharpcomp.c

   1 /* Compile a C# program.
   2    Copyright (C) 2003-2017 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 <https://www.gnu.org/licenses/>.  */
  17
  18 #include <config.h>
  19 #include <alloca.h>
  20
  21 /* Specification.  */
  22 #include "csharpcomp.h"
  23
  24 #include <errno.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include "execute.h"
  30 #include "spawn-pipe.h"
  31 #include "wait-process.h"
  32 #include "sh-quote.h"
  33 #include "safe-read.h"
  34 #include "xmalloca.h"
  35 #include "error.h"
  36 #include "gettext.h"
  37
  38 #define _(str) gettext (str)
  39
  40
  41 /* Survey of C# compilers.
  42
  43    Program    from
  44
  45    cscc       pnet
  46    mcs        mono
  47    csc        sscli
  48
  49    We try the CIL interpreters in the following order:
  50      1. "cscc", because it is a completely free system.
  51      2. "mcs", because it is a free system but doesn't integrate so well
  52         with Unix. (Command line options start with / instead of -. Errors go
  53         to stdout instead of stderr. Source references are printed as
  54         "file(lineno)" instead of "file:lineno:".)
  55      3. "csc", although it is not free, because it is a kind of "reference
  56         implementation" of C#.
  57    But the order can be changed through the --enable-csharp configuration
  58    option.
  59  */
  60
  61 static int
  62 compile_csharp_using_pnet (const char * const *sources,
  63                            unsigned int sources_count,
  64                            const char * const *libdirs,
  65                            unsigned int libdirs_count,
  66                            const char * const *libraries,
  67                            unsigned int libraries_count,
  68                            const char *output_file, bool output_is_library,
  69                            bool optimize, bool debug,
  70                            bool verbose)
  71 {
  72   static bool cscc_tested;
  73   static bool cscc_present;
  74
  75   if (!cscc_tested)
  76     {
  77       /* Test for presence of cscc:
  78          "cscc --version >/dev/null 2>/dev/null"  */
  79       char *argv[3];
  80       int exitstatus;
  81
  82       argv[0] = "cscc";
  83       argv[1] = "--version";
  84       argv[2] = NULL;
  85       exitstatus = execute ("cscc", "cscc", argv, false, false, true, true,
  86                             true, false, NULL);
  87       cscc_present = (exitstatus == 0);
  88       cscc_tested = true;
  89     }
  90
  91   if (cscc_present)
  92     {
  93       unsigned int argc;
  94       char **argv;
  95       char **argp;
  96       int exitstatus;
  97       unsigned int i;
  98
  99       argc =
 100         1 + (output_is_library ? 1 : 0) + 2 + 2 * libdirs_count
 101         + 2 * libraries_count + (optimize ? 1 : 0) + (debug ? 1 : 0)
 102         + sources_count;
 103       argv = (char **) xmalloca ((argc + 1) * sizeof (char *));
 104
 105       argp = argv;
 106       *argp++ = "cscc";
 107       if (output_is_library)
 108         *argp++ = "-shared";
 109       *argp++ = "-o";
 110       *argp++ = (char *) output_file;
 111       for (i = 0; i < libdirs_count; i++)
 112         {
 113           *argp++ = "-L";
 114           *argp++ = (char *) libdirs[i];
 115         }
 116       for (i = 0; i < libraries_count; i++)
 117         {
 118           *argp++ = "-l";
 119           *argp++ = (char *) libraries[i];
 120         }
 121       if (optimize)
 122         *argp++ = "-O";
 123       if (debug)
 124         *argp++ = "-g";
 125       for (i = 0; i < sources_count; i++)
 126         {
 127           const char *source_file = sources[i];
 128           if (strlen (source_file) >= 10
 129               && memcmp (source_file + strlen (source_file) - 10, ".resources",
 130                          10) == 0)
 131             {
 132               char *option = (char *) xmalloca (12 + strlen (source_file) + 1);
 133
 134               memcpy (option, "-fresources=", 12);
 135               strcpy (option + 12, source_file);
 136               *argp++ = option;
 137             }
 138           else
 139             *argp++ = (char *) source_file;
 140         }
 141       *argp = NULL;
 142       /* Ensure argv length was correctly calculated.  */
 143       if (argp - argv != argc)
 144         abort ();
 145
 146       if (verbose)
 147         {
 148           char *command = shell_quote_argv (argv);
 149           printf ("%s\n", command);
 150           free (command);
 151         }
 152
 153       exitstatus = execute ("cscc", "cscc", argv, false, false, false, false,
 154                             true, true, NULL);
 155
 156       for (i = 0; i < sources_count; i++)
 157         if (argv[argc - sources_count + i] != sources[i])
 158           freea (argv[argc - sources_count + i]);
 159       freea (argv);
 160
 161       return (exitstatus != 0);
 162     }
 163   else
 164     return -1;
 165 }
 166
 167 static int
 168 compile_csharp_using_mono (const char * const *sources,
 169                            unsigned int sources_count,
 170                            const char * const *libdirs,
 171                            unsigned int libdirs_count,
 172                            const char * const *libraries,
 173                            unsigned int libraries_count,
 174                            const char *output_file, bool output_is_library,
 175                            bool optimize, bool debug,
 176                            bool verbose)
 177 {
 178   static bool mcs_tested;
 179   static bool mcs_present;
 180
 181   if (!mcs_tested)
 182     {
 183       /* Test for presence of mcs:
 184          "mcs --version >/dev/null 2>/dev/null"
 185          and (to exclude an unrelated 'mcs' program on QNX 6)
 186          "mcs --version 2>/dev/null | grep Mono >/dev/null"  */
 187       char *argv[3];
 188       pid_t child;
 189       int fd[1];
 190       int exitstatus;
 191
 192       argv[0] = "mcs";
 193       argv[1] = "--version";
 194       argv[2] = NULL;
 195       child = create_pipe_in ("mcs", "mcs", argv, DEV_NULL, true, true, false,
 196                               fd);
 197       mcs_present = false;
 198       if (child != -1)
 199         {
 200           /* Read the subprocess output, and test whether it contains the
 201              string "Mono".  */
 202           char c[4];
 203           size_t count = 0;
 204
 205           while (safe_read (fd[0], &c[count], 1) > 0)
 206             {
 207               count++;
 208               if (count == 4)
 209                 {
 210                   if (memcmp (c, "Mono", 4) == 0)
 211                     mcs_present = true;
 212                   c[0] = c[1]; c[1] = c[2]; c[2] = c[3];
 213                   count--;
 214                 }
 215             }
 216
 217           close (fd[0]);
 218
 219           /* Remove zombie process from process list, and retrieve exit
 220              status.  */
 221           exitstatus =
 222             wait_subprocess (child, "mcs", false, true, true, false, NULL);
 223           if (exitstatus != 0)
 224             mcs_present = false;
 225         }
 226       mcs_tested = true;
 227     }
 228
 229   if (mcs_present)
 230     {
 231       unsigned int argc;
 232       char **argv;
 233       char **argp;
 234       pid_t child;
 235       int fd[1];
 236       FILE *fp;
 237       char *line[2];
 238       size_t linesize[2];
 239       size_t linelen[2];
 240       unsigned int l;
 241       int exitstatus;
 242       unsigned int i;
 243
 244       argc =
 245         1 + (output_is_library ? 1 : 0) + 1 + libdirs_count + libraries_count
 246         + (debug ? 1 : 0) + sources_count;
 247       argv = (char **) xmalloca ((argc + 1) * sizeof (char *));
 248
 249       argp = argv;
 250       *argp++ = "mcs";
 251       if (output_is_library)
 252         *argp++ = "-target:library";
 253       {
 254         char *option = (char *) xmalloca (5 + strlen (output_file) + 1);
 255         memcpy (option, "-out:", 5);
 256         strcpy (option + 5, output_file);
 257         *argp++ = option;
 258       }
 259       for (i = 0; i < libdirs_count; i++)
 260         {
 261           char *option = (char *) xmalloca (5 + strlen (libdirs[i]) + 1);
 262           memcpy (option, "-lib:", 5);
 263           strcpy (option + 5, libdirs[i]);
 264           *argp++ = option;
 265         }
 266       for (i = 0; i < libraries_count; i++)
 267         {
 268           char *option = (char *) xmalloca (11 + strlen (libraries[i]) + 4 + 1);
 269           memcpy (option, "-reference:", 11);
 270           memcpy (option + 11, libraries[i], strlen (libraries[i]));
 271           strcpy (option + 11 + strlen (libraries[i]), ".dll");
 272           *argp++ = option;
 273         }
 274       if (debug)
 275         *argp++ = "-debug";
 276       for (i = 0; i < sources_count; i++)
 277         {
 278           const char *source_file = sources[i];
 279           if (strlen (source_file) >= 10
 280               && memcmp (source_file + strlen (source_file) - 10, ".resources",
 281                          10) == 0)
 282             {
 283               char *option = (char *) xmalloca (10 + strlen (source_file) + 1);
 284
 285               memcpy (option, "-resource:", 10);
 286               strcpy (option + 10, source_file);
 287               *argp++ = option;
 288             }
 289           else
 290             *argp++ = (char *) source_file;
 291         }
 292       *argp = NULL;
 293       /* Ensure argv length was correctly calculated.  */
 294       if (argp - argv != argc)
 295         abort ();
 296
 297       if (verbose)
 298         {
 299           char *command = shell_quote_argv (argv);
 300           printf ("%s\n", command);
 301           free (command);
 302         }
 303
 304       child = create_pipe_in ("mcs", "mcs", argv, NULL, false, true, true, fd);
 305
 306       /* Read the subprocess output, copying it to stderr.  Drop the last
 307          line if it starts with "Compilation succeeded".  */
 308       fp = fdopen (fd[0], "r");
 309       if (fp == NULL)
 310         error (EXIT_FAILURE, errno, _("fdopen() failed"));
 311       line[0] = NULL; linesize[0] = 0;
 312       line[1] = NULL; linesize[1] = 0;
 313       l = 0;
 314       for (;;)
 315         {
 316           linelen[l] = getline (&line[l], &linesize[l], fp);
 317           if (linelen[l] == (size_t)(-1))
 318             break;
 319           l = (l + 1) % 2;
 320           if (line[l] != NULL)
 321             fwrite (line[l], 1, linelen[l], stderr);
 322         }
 323       l = (l + 1) % 2;
 324       if (line[l] != NULL
 325           && !(linelen[l] >= 21
 326                && memcmp (line[l], "Compilation succeeded", 21) == 0))
 327         fwrite (line[l], 1, linelen[l], stderr);
 328       if (line[0] != NULL)
 329         free (line[0]);
 330       if (line[1] != NULL)
 331         free (line[1]);
 332       fclose (fp);
 333
 334       /* Remove zombie process from process list, and retrieve exit status.  */
 335       exitstatus =
 336         wait_subprocess (child, "mcs", false, false, true, true, NULL);
 337
 338       for (i = 1 + (output_is_library ? 1 : 0);
 339            i < 1 + (output_is_library ? 1 : 0)
 340                + 1 + libdirs_count + libraries_count;
 341            i++)
 342         freea (argv[i]);
 343       for (i = 0; i < sources_count; i++)
 344         if (argv[argc - sources_count + i] != sources[i])
 345           freea (argv[argc - sources_count + i]);
 346       freea (argv);
 347
 348       return (exitstatus != 0);
 349     }
 350   else
 351     return -1;
 352 }
 353
 354 static int
 355 compile_csharp_using_sscli (const char * const *sources,
 356                             unsigned int sources_count,
 357                             const char * const *libdirs,
 358                             unsigned int libdirs_count,
 359                             const char * const *libraries,
 360                             unsigned int libraries_count,
 361                             const char *output_file, bool output_is_library,
 362                             bool optimize, bool debug,
 363                             bool verbose)
 364 {
 365   static bool csc_tested;
 366   static bool csc_present;
 367
 368   if (!csc_tested)
 369     {
 370       /* Test for presence of csc:
 371          "csc -help >/dev/null 2>/dev/null \
 372           && ! { csc -help 2>/dev/null | grep -i chicken > /dev/null; }"  */
 373       char *argv[3];
 374       pid_t child;
 375       int fd[1];
 376       int exitstatus;
 377
 378       argv[0] = "csc";
 379       argv[1] = "-help";
 380       argv[2] = NULL;
 381       child = create_pipe_in ("csc", "csc", argv, DEV_NULL, true, true, false,
 382                               fd);
 383       csc_present = false;
 384       if (child != -1)
 385         {
 386           /* Read the subprocess output, and test whether it contains the
 387              string "chicken".  */
 388           char c[7];
 389           size_t count = 0;
 390
 391           csc_present = true;
 392           while (safe_read (fd[0], &c[count], 1) > 0)
 393             {
 394               if (c[count] >= 'A' && c[count] <= 'Z')
 395                 c[count] += 'a' - 'A';
 396               count++;
 397               if (count == 7)
 398                 {
 399                   if (memcmp (c, "chicken", 7) == 0)
 400                     csc_present = false;
 401                   c[0] = c[1]; c[1] = c[2]; c[2] = c[3];
 402                   c[3] = c[4]; c[4] = c[5]; c[5] = c[6];
 403                   count--;
 404                 }
 405             }
 406
 407           close (fd[0]);
 408
 409           /* Remove zombie process from process list, and retrieve exit
 410              status.  */
 411           exitstatus =
 412             wait_subprocess (child, "csc", false, true, true, false, NULL);
 413           if (exitstatus != 0)
 414             csc_present = false;
 415         }
 416       csc_tested = true;
 417     }
 418
 419   if (csc_present)
 420     {
 421       unsigned int argc;
 422       char **argv;
 423       char **argp;
 424       int exitstatus;
 425       unsigned int i;
 426
 427       argc =
 428         1 + 1 + 1 + libdirs_count + libraries_count
 429         + (optimize ? 1 : 0) + (debug ? 1 : 0) + sources_count;
 430       argv = (char **) xmalloca ((argc + 1) * sizeof (char *));
 431
 432       argp = argv;
 433       *argp++ = "csc";
 434       *argp++ =
 435         (char *) (output_is_library ? "-target:library" : "-target:exe");
 436       {
 437         char *option = (char *) xmalloca (5 + strlen (output_file) + 1);
 438         memcpy (option, "-out:", 5);
 439         strcpy (option + 5, output_file);
 440         *argp++ = option;
 441       }
 442       for (i = 0; i < libdirs_count; i++)
 443         {
 444           char *option = (char *) xmalloca (5 + strlen (libdirs[i]) + 1);
 445           memcpy (option, "-lib:", 5);
 446           strcpy (option + 5, libdirs[i]);
 447           *argp++ = option;
 448         }
 449       for (i = 0; i < libraries_count; i++)
 450         {
 451           char *option = (char *) xmalloca (11 + strlen (libraries[i]) + 4 + 1);
 452           memcpy (option, "-reference:", 11);
 453           memcpy (option + 11, libraries[i], strlen (libraries[i]));
 454           strcpy (option + 11 + strlen (libraries[i]), ".dll");
 455           *argp++ = option;
 456         }
 457       if (optimize)
 458         *argp++ = "-optimize+";
 459       if (debug)
 460         *argp++ = "-debug+";
 461       for (i = 0; i < sources_count; i++)
 462         {
 463           const char *source_file = sources[i];
 464           if (strlen (source_file) >= 10
 465               && memcmp (source_file + strlen (source_file) - 10, ".resources",
 466                          10) == 0)
 467             {
 468               char *option = (char *) xmalloca (10 + strlen (source_file) + 1);
 469
 470               memcpy (option, "-resource:", 10);
 471               strcpy (option + 10, source_file);
 472               *argp++ = option;
 473             }
 474           else
 475             *argp++ = (char *) source_file;
 476         }
 477       *argp = NULL;
 478       /* Ensure argv length was correctly calculated.  */
 479       if (argp - argv != argc)
 480         abort ();
 481
 482       if (verbose)
 483         {
 484           char *command = shell_quote_argv (argv);
 485           printf ("%s\n", command);
 486           free (command);
 487         }
 488
 489       exitstatus = execute ("csc", "csc", argv, false, false, false, false,
 490                             true, true, NULL);
 491
 492       for (i = 2; i < 3 + libdirs_count + libraries_count; i++)
 493         freea (argv[i]);
 494       for (i = 0; i < sources_count; i++)
 495         if (argv[argc - sources_count + i] != sources[i])
 496           freea (argv[argc - sources_count + i]);
 497       freea (argv);
 498
 499       return (exitstatus != 0);
 500     }
 501   else
 502     return -1;
 503 }
 504
 505 bool
 506 compile_csharp_class (const char * const *sources,
 507                       unsigned int sources_count,
 508                       const char * const *libdirs,
 509                       unsigned int libdirs_count,
 510                       const char * const *libraries,
 511                       unsigned int libraries_count,
 512                       const char *output_file,
 513                       bool optimize, bool debug,
 514                       bool verbose)
 515 {
 516   bool output_is_library =
 517     (strlen (output_file) >= 4
 518      && memcmp (output_file + strlen (output_file) - 4, ".dll", 4) == 0);
 519   int result;
 520
 521   /* First try the C# implementation specified through --enable-csharp.  */
 522 #if CSHARP_CHOICE_PNET
 523   result = compile_csharp_using_pnet (sources, sources_count,
 524                                       libdirs, libdirs_count,
 525                                       libraries, libraries_count,
 526                                       output_file, output_is_library,
 527                                       optimize, debug, verbose);
 528   if (result >= 0)
 529     return (bool) result;
 530 #endif
 531
 532 #if CSHARP_CHOICE_MONO
 533   result = compile_csharp_using_mono (sources, sources_count,
 534                                       libdirs, libdirs_count,
 535                                       libraries, libraries_count,
 536                                       output_file, output_is_library,
 537                                       optimize, debug, verbose);
 538   if (result >= 0)
 539     return (bool) result;
 540 #endif
 541
 542   /* Then try the remaining C# implementations in our standard order.  */
 543 #if !CSHARP_CHOICE_PNET
 544   result = compile_csharp_using_pnet (sources, sources_count,
 545                                       libdirs, libdirs_count,
 546                                       libraries, libraries_count,
 547                                       output_file, output_is_library,
 548                                       optimize, debug, verbose);
 549   if (result >= 0)
 550     return (bool) result;
 551 #endif
 552
 553 #if !CSHARP_CHOICE_MONO
 554   result = compile_csharp_using_mono (sources, sources_count,
 555                                       libdirs, libdirs_count,
 556                                       libraries, libraries_count,
 557                                       output_file, output_is_library,
 558                                       optimize, debug, verbose);
 559   if (result >= 0)
 560     return (bool) result;
 561 #endif
 562
 563   result = compile_csharp_using_sscli (sources, sources_count,
 564                                        libdirs, libdirs_count,
 565                                        libraries, libraries_count,
 566                                        output_file, output_is_library,
 567                                        optimize, debug, verbose);
 568   if (result >= 0)
 569     return (bool) result;
 570
 571   error (0, 0, _("C# compiler not found, try installing pnet"));
 572   return true;
 573 }