pintos-os.org Git - pspp/blob - lib/csharpcomp.c

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